331 lines
10 KiB
TypeScript
331 lines
10 KiB
TypeScript
import { useQuery } from '@tanstack/react-query';
|
|
import type { DMInstanceRef } from '@cognite/reveal';
|
|
import type { Node3D, CogniteClient } from '@cognite/sdk';
|
|
import { useRevealContext } from './useRevealContext';
|
|
import type { ThreeDModelFdmMappings, CadModelOptions } from '../types';
|
|
import {
|
|
ASSET_VIEW,
|
|
COGNITE_3D_OBJECT_VIEW,
|
|
COGNITE_CAD_NODE_VIEW,
|
|
} from '../utils/views';
|
|
import { unwrapProperties } from '../utils/data-mapper';
|
|
import type { CDFNode } from '../utils/cdf-types';
|
|
|
|
interface DmsUniqueIdentifier {
|
|
space: string;
|
|
externalId: string;
|
|
}
|
|
|
|
interface CogniteAssetProperties {
|
|
space: string;
|
|
externalId: string;
|
|
object3D: DmsUniqueIdentifier;
|
|
}
|
|
|
|
interface CogniteCADNodeProperties {
|
|
space: string;
|
|
externalId: string;
|
|
object3D: DmsUniqueIdentifier;
|
|
model3D: DmsUniqueIdentifier;
|
|
revisions: DmsUniqueIdentifier[];
|
|
treeIndexes: number[];
|
|
subTreeSizes: number[];
|
|
}
|
|
|
|
/**
|
|
* Fetches FDM-to-CAD mappings using Core DM connections.
|
|
* This queries the data model for CAD nodes connected to assets via object3D references.
|
|
*/
|
|
export function useFdmAssetMappings(
|
|
instances: DMInstanceRef[],
|
|
models: CadModelOptions[]
|
|
) {
|
|
const { sdk } = useRevealContext();
|
|
return useQuery({
|
|
queryKey: [
|
|
'fdm-cad-connections',
|
|
instances.map((i) => `${i.space}:${i.externalId}`).join(','),
|
|
models.map((m) => `${m.modelId}:${m.revisionId}`).join(','),
|
|
],
|
|
queryFn: async (): Promise<ThreeDModelFdmMappings[]> => {
|
|
if (instances.length === 0 || models.length === 0) {
|
|
return [];
|
|
}
|
|
|
|
try {
|
|
// Step 1: Query DMS for CAD connections
|
|
// This traverses: Assets → object3D → CAD nodes
|
|
const queryResult = await sdk.instances.query({
|
|
with: {
|
|
// Start from the input instances (assets)
|
|
assets: {
|
|
nodes: {
|
|
filter: {
|
|
and: [
|
|
{
|
|
in: {
|
|
property: ['node', 'space'],
|
|
values: [
|
|
...new Set(instances.map((inst) => inst.space)),
|
|
],
|
|
},
|
|
},
|
|
{
|
|
in: {
|
|
property: ['node', 'externalId'],
|
|
values: instances.map((inst) => inst.externalId),
|
|
},
|
|
},
|
|
],
|
|
},
|
|
},
|
|
},
|
|
// Navigate to object3D (Cognite3DObject)
|
|
object_3ds: {
|
|
nodes: {
|
|
from: 'assets',
|
|
through: {
|
|
view: { type: 'view', ...ASSET_VIEW },
|
|
identifier: 'object3D',
|
|
},
|
|
direction: 'outwards',
|
|
filter: {
|
|
hasData: [{ type: 'view', ...COGNITE_3D_OBJECT_VIEW }],
|
|
},
|
|
},
|
|
},
|
|
// Navigate back to CAD nodes that reference this object3D
|
|
cad_nodes: {
|
|
nodes: {
|
|
from: 'object_3ds',
|
|
through: {
|
|
view: { type: 'view', ...COGNITE_CAD_NODE_VIEW },
|
|
identifier: 'object3D',
|
|
},
|
|
direction: 'inwards',
|
|
},
|
|
},
|
|
},
|
|
select: {
|
|
assets: {
|
|
sources: [
|
|
{
|
|
source: { type: 'view', ...ASSET_VIEW },
|
|
properties: ['object3D'],
|
|
},
|
|
],
|
|
},
|
|
cad_nodes: {
|
|
sources: [
|
|
{
|
|
source: { type: 'view', ...COGNITE_CAD_NODE_VIEW },
|
|
properties: [
|
|
'object3D',
|
|
'model3D',
|
|
'revisions',
|
|
'treeIndexes',
|
|
'subTreeSizes',
|
|
],
|
|
},
|
|
],
|
|
},
|
|
},
|
|
});
|
|
|
|
// Step 2: Build mappings per model/revision
|
|
const mappingsByModel = new Map<string, Map<string, Node3D[]>>();
|
|
|
|
const cadNodes = queryResult.items.cad_nodes || [];
|
|
|
|
// Group CAD nodes by which instances reference them
|
|
const object3DToAssets = new Map<string, DMInstanceRef[]>();
|
|
for (const asset of queryResult.items.assets || []) {
|
|
const props = unwrapProperties<CogniteAssetProperties>(
|
|
asset as CDFNode,
|
|
ASSET_VIEW
|
|
);
|
|
if (props?.object3D) {
|
|
const key = `${props.object3D.space}/${props.object3D.externalId}`;
|
|
const existing = object3DToAssets.get(key) || [];
|
|
existing.push({ space: asset.space, externalId: asset.externalId });
|
|
object3DToAssets.set(key, existing);
|
|
}
|
|
}
|
|
|
|
// Collect all (modelId, revisionId, treeIndex) tuples for batch fetching
|
|
interface NodeRequest {
|
|
modelId: number;
|
|
revisionId: number;
|
|
treeIndex: number;
|
|
assetInstances: DMInstanceRef[];
|
|
}
|
|
|
|
const nodeRequests: NodeRequest[] = [];
|
|
|
|
// Process CAD nodes to build Node3D mappings
|
|
for (const cadNode of cadNodes) {
|
|
const props = unwrapProperties<CogniteCADNodeProperties>(
|
|
cadNode as CDFNode,
|
|
COGNITE_CAD_NODE_VIEW
|
|
);
|
|
if (!props) continue;
|
|
|
|
const { model3D, revisions, treeIndexes, object3D } = props;
|
|
if (!model3D || !revisions || !treeIndexes) continue;
|
|
|
|
// Find which assets reference this CAD node
|
|
const object3DKey = `${object3D.space}/${object3D.externalId}`;
|
|
const relatedAssets = object3DToAssets.get(object3DKey);
|
|
if (!relatedAssets) continue;
|
|
|
|
// Extract modelId and match with requested models
|
|
const modelId = extractModelId(model3D.externalId);
|
|
|
|
// For each revision/treeIndex pair
|
|
for (let i = 0; i < revisions.length; i++) {
|
|
const revision = revisions[i];
|
|
const treeIndex = treeIndexes[i];
|
|
const revisionId = extractRevisionId(revision.externalId);
|
|
|
|
// Check if this model/revision is in our requested list
|
|
const matchingModel = models.find(
|
|
(m) => m.modelId === modelId && m.revisionId === revisionId
|
|
);
|
|
if (!matchingModel) continue;
|
|
|
|
nodeRequests.push({
|
|
modelId,
|
|
revisionId,
|
|
treeIndex,
|
|
assetInstances: relatedAssets,
|
|
});
|
|
}
|
|
}
|
|
|
|
// Batch fetch nodes by revision
|
|
const nodesByRevision = new Map<string, NodeRequest[]>();
|
|
for (const req of nodeRequests) {
|
|
const key = `${req.modelId}/${req.revisionId}`;
|
|
const existing = nodesByRevision.get(key) || [];
|
|
existing.push(req);
|
|
nodesByRevision.set(key, existing);
|
|
}
|
|
|
|
// Fetch all nodes in parallel per revision
|
|
const revisionFetchPromises = Array.from(nodesByRevision.entries()).map(
|
|
async ([revisionKey, requests]) => {
|
|
const [modelId, revisionId] = revisionKey.split('/').map(Number);
|
|
const treeIndexes = requests.map((r) => r.treeIndex);
|
|
|
|
const nodes = await fetchNodesByTreeIndex(
|
|
sdk,
|
|
modelId,
|
|
revisionId,
|
|
treeIndexes
|
|
);
|
|
|
|
return { revisionKey, nodes, requests };
|
|
}
|
|
);
|
|
|
|
const allRevisionData = await Promise.all(revisionFetchPromises);
|
|
|
|
for (const { revisionKey, nodes, requests } of allRevisionData) {
|
|
const treeIndexToNode = new Map(
|
|
nodes.map((node) => [node.treeIndex, node])
|
|
);
|
|
|
|
const modelMappings =
|
|
mappingsByModel.get(revisionKey) ?? new Map<string, Node3D[]>();
|
|
mappingsByModel.set(revisionKey, modelMappings);
|
|
|
|
for (const req of requests) {
|
|
const node3D = treeIndexToNode.get(req.treeIndex);
|
|
if (!node3D) continue;
|
|
|
|
for (const instance of req.assetInstances) {
|
|
const instanceKey = `${instance.space}:${instance.externalId}`;
|
|
const arr = modelMappings.get(instanceKey) ?? [];
|
|
arr.push(node3D);
|
|
modelMappings.set(instanceKey, arr);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Convert to result format
|
|
const results: ThreeDModelFdmMappings[] = [];
|
|
for (const model of models) {
|
|
const modelKey = `${model.modelId}/${model.revisionId}`;
|
|
results.push({
|
|
modelId: model.modelId,
|
|
revisionId: model.revisionId,
|
|
mappings: mappingsByModel.get(modelKey) ?? new Map(),
|
|
});
|
|
}
|
|
|
|
return results;
|
|
} catch (error) {
|
|
console.error('Error fetching FDM CAD connections:', error);
|
|
return [];
|
|
}
|
|
},
|
|
enabled: !!sdk && instances.length > 0 && models.length > 0,
|
|
staleTime: 5 * 60 * 1000, // 5 minutes
|
|
});
|
|
}
|
|
|
|
// Helper to extract numeric modelId from externalId like "model_123_space"
|
|
function extractModelId(externalId: string): number {
|
|
const match = externalId.match(/model_(\d+)/);
|
|
return match ? parseInt(match[1], 10) : -1;
|
|
}
|
|
|
|
// Helper to extract numeric revisionId from externalId like "model_123_revision_456_space"
|
|
function extractRevisionId(externalId: string): number {
|
|
const match = externalId.match(/revision_(\d+)/);
|
|
return match ? parseInt(match[1], 10) : -1;
|
|
}
|
|
|
|
/**
|
|
* Fetch 3D nodes by their tree indices using the optimized internal IDs endpoint.
|
|
* This is much more efficient than fetching all nodes and filtering.
|
|
*/
|
|
async function fetchNodesByTreeIndex(
|
|
sdk: CogniteClient,
|
|
modelId: number,
|
|
revisionId: number,
|
|
treeIndexes: number[]
|
|
): Promise<Node3D[]> {
|
|
if (treeIndexes.length === 0) {
|
|
return [];
|
|
}
|
|
|
|
// Deduplicate tree indices
|
|
const uniqueTreeIndexes = Array.from(new Set(treeIndexes));
|
|
|
|
// Step 1: Convert tree indices to internal node IDs
|
|
const nodeIdResponse = await sdk.post<{ items: number[] }>(
|
|
`/api/v1/projects/${sdk.project}/3d/models/${modelId}/revisions/${revisionId}/nodes/internalids/bytreeindices`,
|
|
{
|
|
data: {
|
|
items: uniqueTreeIndexes,
|
|
},
|
|
}
|
|
);
|
|
|
|
const nodeIds = nodeIdResponse.data.items;
|
|
|
|
if (nodeIds.length === 0) {
|
|
return [];
|
|
}
|
|
|
|
// Step 2: Retrieve full node details by internal IDs
|
|
const nodes = await sdk.revisions3D.retrieve3DNodes(
|
|
modelId,
|
|
revisionId,
|
|
nodeIds.map((id) => ({ id }))
|
|
);
|
|
|
|
return nodes;
|
|
}
|