@cognite/reveal 4.7.1 → 4.8.0

package/dist/packages/api/src/api-helpers/Image360ApiHelper.d.ts

@@ -4,6 +4,7 @@
 import * as THREE from 'three';
 import { CogniteClient, Metadata } from '@cognite/sdk';
 import { Image360Collection, Image360Entity, Image360, IconsOptions, Image360RevisionEntity, Image360AnnotationIntersection, Image360AnnotationFilterOptions } from '../../../360-images';
+import { Image360DataModelIdentifier } from '../../../data-providers';
 import { BeforeSceneRenderedDelegate, EventTrigger, InputHandler, SceneHandler } from '../../../utilities';
 import { ProxyCameraManager } from '../../../camera-manager';
 export declare class Image360ApiHelper {
@@ -23,7 +24,7 @@ export declare class Image360ApiHelper {
     get needsRedraw(): boolean;
     resetRedraw(): void;
     private getNormalizedOffset;
-    add360ImageSet(eventFilter: Metadata, collectionTransform: THREE.Matrix4, preMultipliedRotation: boolean, annotationOptions?: Image360AnnotationFilterOptions): Promise<Image360Collection>;
+    add360ImageSet(collectionIdentifier: Metadata | Image360DataModelIdentifier, collectionTransform: THREE.Matrix4, preMultipliedRotation: boolean, annotationOptions?: Image360AnnotationFilterOptions): Promise<Image360Collection>;
     getImageCollections(): Image360Collection[];
     remove360Images(entities: Image360[]): Promise<void>;
     remove360ImageCollection(collection: Image360Collection): void;

package/dist/packages/api/src/public/migration/Cognite3DViewer.d.ts

@@ -9,6 +9,7 @@ import { AddImage360Options, AddModelOptions, Cognite3DViewerOptions, Intersecti
 import { CogniteModel } from '../types';
 import { ViewerState } from '../../utilities/ViewStateHelper';
 import { CameraManager, CameraChangeDelegate, CameraStopDelegate } from '../../../../camera-manager';
+import { Image360DataModelIdentifier } from '../../../../data-providers';
 import { SupportedModelTypes } from '../../../../model-base';
 import { Image360Collection, Image360, Image360Revision, Image360AnnotationIntersection } from '../../../../360-images';
 /**
@@ -273,6 +274,12 @@ export declare class Cognite3DViewer {
      */
     addPointCloudModel(options: AddModelOptions): Promise<CognitePointCloudModel>;
     private addPointCloudModelWithSequencer;
+    /**
+     * Adds a set of 360 images to the scene from the /datamodels API in Cognite Data Fusion.
+     * @param datasource The data data source which holds the references to the 360 image sets.
+     * @param dataModelIdentifier The search parameters to apply when querying Cognite Datamodels that contains the 360 images.
+     */
+    add360ImageSet(datasource: 'datamodels', dataModelIdentifier: Image360DataModelIdentifier): Promise<Image360Collection>;
     /**
      * Adds a set of 360 images to the scene from the /events API in Cognite Data Fusion.
      * @param datasource The CDF data source which holds the references to the 360 image sets.

package/dist/packages/data-providers/index.d.ts

@@ -4,7 +4,10 @@
 export { CdfModelDataProvider } from './src/model-data-providers/CdfModelDataProvider';
 export { CdfModelIdentifier } from './src/model-identifiers/CdfModelIdentifier';
 export { CdfModelMetadataProvider } from './src/metadata-providers/CdfModelMetadataProvider';
-export { Cdf360ImageEventProvider } from './src/image-360-data-providers/Cdf360ImageEventProvider';
+export { Cdf360ImageProvider } from './src/image-360-data-providers/Cdf360ImageProvider';
+export { Cdf360EventDescriptorProvider } from './src/image-360-data-providers/descriptor-providers/events/Cdf360EventDescriptorProvider';
+export { Cdf360DataModelsDescriptorProvider, Image360DataModelIdentifier } from './src/image-360-data-providers/descriptor-providers/datamodels/Cdf360DataModelsDescriptorProvider';
+export { Cdf360CombinedDescriptorProvider } from './src/image-360-data-providers/descriptor-providers/Cdf360CombinedDescriptorProvider';
 export { LocalModelDataProvider } from './src/model-data-providers/LocalModelDataProvider';
 export { LocalModelIdentifier } from './src/model-identifiers/LocalModelIdentifier';
 export { LocalModelMetadataProvider } from './src/metadata-providers/LocalModelMetadataProvider';

package/dist/packages/data-providers/src/DataModelsSdk.d.ts

@@ -0,0 +1,11 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { CogniteClient } from '@cognite/sdk';
+import { Query, QueryNextCursors, QueryResult } from './types';
+export declare class DataModelsSdk {
+    private readonly _sdk;
+    private readonly _queryEndpoint;
+    constructor(sdk: CogniteClient);
+    queryNodesAndEdges<const T extends Query>(query: T, nextCursor?: QueryNextCursors<T>): Promise<QueryResult<T>>;
+}

package/dist/packages/data-providers/src/image-360-data-providers/{Cdf360ImageEventProvider.d.ts → Cdf360ImageProvider.d.ts}

@@ -1,29 +1,25 @@
 /*!
  * Copyright 2022 Cognite AS
  */
-import { AnnotationModel, CogniteClient, IdEither, Metadata, CogniteInternalId } from '@cognite/sdk';
-import { Historical360ImageSet, Image360AnnotationFilterDelegate, Image360Face, Image360FileDescriptor, ImageAssetLinkAnnotationInfo } from '../types';
+import { AnnotationModel, CogniteClient, IdEither, CogniteInternalId } from '@cognite/sdk';
+import { Historical360ImageSet, Image360AnnotationFilterDelegate, Image360DescriptorProvider, Image360Face, Image360FileDescriptor, ImageAssetLinkAnnotationInfo } from '../types';
 import { Image360Provider } from '../Image360Provider';
-export declare class Cdf360ImageEventProvider implements Image360Provider<Metadata> {
+export declare class Cdf360ImageProvider<T> implements Image360Provider<T> {
     private readonly _client;
-    constructor(client: CogniteClient);
-    get360ImageDescriptors(metadataFilter: Metadata, preMultipliedRotation: boolean): Promise<Historical360ImageSet[]>;
+    private readonly _descriptorProvider;
+    constructor(client: CogniteClient, descriptorProvider: Image360DescriptorProvider<T>);
+    get360ImageDescriptors(metadataFilter: T, preMultipliedRotation: boolean): Promise<Historical360ImageSet[]>;
     get360ImageAnnotations(descriptors: Image360FileDescriptor[]): Promise<AnnotationModel[]>;
     getFilesByAssetRef(assetRef: IdEither): Promise<CogniteInternalId[]>;
     get360ImageFiles(image360FaceDescriptors: Image360FileDescriptor[], abortSignal?: AbortSignal): Promise<Image360Face[]>;
     getLowResolution360ImageFiles(image360FaceDescriptors: Image360FileDescriptor[], abortSignal?: AbortSignal): Promise<Image360Face[]>;
     private getFileIds;
     private createFaces;
-    private mergeDescriptors;
-    private listEvents;
-    private listFiles;
-    private sortFileInfoSetByNewest;
     private getFileBuffers;
     getIconBuffers(fileIds: {
         id: number;
     }[], abortSignal?: AbortSignal): Promise<ArrayBuffer[]>;
     private getDownloadUrls;
-    private parseEventMetadata;
     get360ImageAssets(image360FileDescriptors: Image360FileDescriptor[], annotationFilter: Image360AnnotationFilterDelegate): Promise<ImageAssetLinkAnnotationInfo[]>;
     private listFileAnnotations;
 }

package/dist/packages/data-providers/src/image-360-data-providers/descriptor-providers/Cdf360CombinedDescriptorProvider.d.ts

@@ -0,0 +1,14 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { Metadata } from '@cognite/sdk';
+import { Historical360ImageSet, Image360DescriptorProvider } from '../../types';
+import { Cdf360DataModelsDescriptorProvider, Image360DataModelIdentifier } from './datamodels/Cdf360DataModelsDescriptorProvider';
+import { Cdf360EventDescriptorProvider } from './events/Cdf360EventDescriptorProvider';
+export declare class Cdf360CombinedDescriptorProvider implements Image360DescriptorProvider<Metadata | Image360DataModelIdentifier> {
+    private readonly _eventProvider;
+    private readonly _fdmProvider;
+    static isFdmIdentifier(metadataFilter: Metadata | Image360DataModelIdentifier): metadataFilter is Image360DataModelIdentifier;
+    constructor(fdmProvider: Cdf360DataModelsDescriptorProvider, eventProvider: Cdf360EventDescriptorProvider);
+    get360ImageDescriptors(metadataFilter: Metadata | Image360DataModelIdentifier, preMultipliedRotation: boolean): Promise<Historical360ImageSet[]>;
+}

package/dist/packages/data-providers/src/image-360-data-providers/descriptor-providers/datamodels/Cdf360DataModelsDescriptorProvider.d.ts

@@ -0,0 +1,23 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { CogniteClient } from '@cognite/sdk';
+import { Historical360ImageSet, Image360DescriptorProvider } from '../../../types';
+/**
+ * An identifier uniquely determining an instance of a Cognite Data Model
+ */
+export type Image360DataModelIdentifier = {
+    space: string;
+    image360CollectionExternalId: string;
+};
+export declare class Cdf360DataModelsDescriptorProvider implements Image360DescriptorProvider<Image360DataModelIdentifier> {
+    private readonly _dmsSdk;
+    private readonly _cogniteSdk;
+    constructor(sdk: CogniteClient);
+    get360ImageDescriptors(collectionIdentifier: Image360DataModelIdentifier, _: boolean): Promise<Historical360ImageSet[]>;
+    private queryCollection;
+    private getFileDescriptors;
+    private getHistorical360ImageSet;
+    private getImageRevision;
+    private getRevisionTransform;
+}

package/dist/packages/data-providers/src/image-360-data-providers/descriptor-providers/datamodels/get360CollectionQuery.d.ts

@@ -0,0 +1,103 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+declare const Image360CollectionQuery: {
+    readonly with: {
+        readonly image_collection: {
+            readonly nodes: {
+                readonly filter: {
+                    readonly and: readonly [{
+                        readonly equals: {
+                            readonly property: readonly ["node", "externalId"];
+                            readonly value: {
+                                readonly parameter: "collectionExternalId";
+                            };
+                        };
+                    }, {
+                        readonly equals: {
+                            readonly property: readonly ["node", "space"];
+                            readonly value: {
+                                readonly parameter: "collectionSpace";
+                            };
+                        };
+                    }];
+                };
+            };
+            readonly limit: 1;
+        };
+        readonly images: {
+            readonly nodes: {
+                readonly from: "image_collection";
+                readonly through: {
+                    readonly view: {
+                        readonly type: "view";
+                        readonly space: "cdf_360_image_schema";
+                        readonly externalId: "Image360";
+                        readonly version: "v1";
+                    };
+                    readonly identifier: "collection360";
+                };
+            };
+            readonly limit: 10000;
+        };
+        readonly stations: {
+            readonly nodes: {
+                readonly from: "images";
+                readonly through: {
+                    readonly view: {
+                        readonly type: "view";
+                        readonly space: "cdf_360_image_schema";
+                        readonly externalId: "Image360";
+                        readonly version: "v1";
+                    };
+                    readonly identifier: "station";
+                };
+                readonly direction: "outwards";
+            };
+            readonly limit: 10000;
+        };
+    };
+    readonly select: {
+        readonly image_collection: {
+            readonly sources: readonly [{
+                readonly source: {
+                    readonly type: "view";
+                    readonly space: "cdf_360_image_schema";
+                    readonly externalId: "Image360Collection";
+                    readonly version: "v1";
+                };
+                readonly properties: readonly ["label"];
+            }];
+        };
+        readonly images: {
+            readonly sources: readonly [{
+                readonly source: {
+                    readonly type: "view";
+                    readonly space: "cdf_360_image_schema";
+                    readonly externalId: "Image360";
+                    readonly version: "v1";
+                };
+                readonly properties: readonly ["translationX", "translationY", "translationZ", "eulerRotationX", "eulerRotationY", "eulerRotationZ", "scaleX", "scaleY", "scaleZ", "cubeMapFront", "cubeMapBack", "cubeMapLeft", "cubeMapRight", "cubeMapTop", "cubeMapBottom", "collection360", "station", "timeTaken", "label"];
+            }];
+        };
+        readonly stations: {
+            readonly sources: readonly [{
+                readonly source: {
+                    readonly type: "view";
+                    readonly space: "cdf_360_image_schema";
+                    readonly externalId: "Station360";
+                    readonly version: "v1";
+                };
+                readonly properties: readonly ["label"];
+            }];
+        };
+    };
+};
+export type Cdf360FdmQuery = typeof Image360CollectionQuery;
+export declare function get360CollectionQuery(externalId: string, space: string): Cdf360FdmQuery & {
+    parameters: {
+        collectionExternalId: string;
+        collectionSpace: string;
+    };
+};
+export {};

package/dist/packages/data-providers/src/image-360-data-providers/descriptor-providers/events/Cdf360EventDescriptorProvider.d.ts

@@ -0,0 +1,15 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { CogniteClient, Metadata } from '@cognite/sdk';
+import { Historical360ImageSet, Image360DescriptorProvider } from '../../../types';
+export declare class Cdf360EventDescriptorProvider implements Image360DescriptorProvider<Metadata> {
+    private readonly _client;
+    constructor(client: CogniteClient);
+    get360ImageDescriptors(metadataFilter: Metadata, preMultipliedRotation: boolean): Promise<Historical360ImageSet[]>;
+    private mergeDescriptors;
+    private listEvents;
+    private listFiles;
+    private sortFileInfoSetByNewest;
+    private parseEventMetadata;
+}

package/dist/packages/data-providers/src/types.d.ts

@@ -37,7 +37,7 @@ export type Historical360ImageSet = Image360EventDescriptor & {
     imageRevisions: Image360Descriptor[];
 };
 export type Image360Descriptor = {
-    timestamp?: number;
+    timestamp?: number | string;
     faceDescriptors: Image360FileDescriptor[];
 };
 export type Image360EventDescriptor = {
@@ -74,3 +74,89 @@ export interface BlobOutputMetadata {
     format: File3dFormat | string;
     version: number;
 }
+type InstanceType = 'node' | 'edge';
+export type Item = {
+    instanceType: InstanceType;
+} & InstanceIdentifier;
+export type Source = {
+    type: 'view';
+    version: string;
+} & InstanceIdentifier;
+export type InstanceIdentifier = {
+    space: string;
+    externalId: string;
+};
+export type EdgeItem = {
+    startNode: InstanceIdentifier;
+    endNode: InstanceIdentifier;
+};
+export type Query = {
+    with: Record<string, ResultSetExpression>;
+    select: Record<string, QuerySelect>;
+    parameters?: Record<string, string | number>;
+    cursors?: Record<string, string>;
+};
+type QuerySelect = {
+    sources: readonly SourceProperties[];
+};
+type SourceProperties = {
+    source: TestSource;
+    properties: readonly string[];
+};
+type TestSource = {
+    type: 'view';
+    space: string;
+    externalId: string;
+    version: string;
+};
+export type ResultSetExpression = (NodeResultSetExpression | EdgeResultSetExpression) & {
+    limit?: number;
+    sort?: any[];
+};
+export type NodeResultSetExpression = {
+    nodes: {
+        filter?: any;
+        from?: any;
+        through?: any;
+        chainTo?: any;
+    };
+};
+export type EdgeResultSetExpression = {
+    edges: {
+        filter?: any;
+        from?: any;
+        nodeFilter?: any;
+        maxDistance?: number;
+        direction?: 'outwards' | 'inwards';
+        limitEach?: number;
+    };
+};
+type SelectKey<T extends Query> = keyof T['select'];
+type Sources<T extends Query, K extends SelectKey<T>> = T['select'][K]['sources'][0];
+type MainSource<T extends Query, K extends SelectKey<T>> = Sources<T, K>['source'];
+type MainSourceProperties<T extends Query, K extends SelectKey<T>> = Sources<T, K>['properties'];
+type ResultExpressionProperties<T extends Query, K extends SelectKey<T>> = {
+    [V in MainSource<T, K>['space']]: {
+        [Q in `${MainSource<T, K>['externalId']}/${MainSource<T, K>['version']}`]: {
+            [B in MainSourceProperties<T, K>[number]]: string | number | InstanceIdentifier;
+        };
+    };
+};
+type ResultExpression<T extends Query, K extends SelectKey<T>> = {
+    instanceType: 'node';
+    version: number;
+    space: string;
+    externalId: string;
+    createdTime: number;
+    lastUpdatedTime: number;
+    properties: ResultExpressionProperties<T, K>;
+};
+export type QueryNextCursors<T extends Query> = {
+    [K in SelectKey<T>]?: string | undefined;
+};
+export type QueryResult<T extends Query> = {
+    [K in SelectKey<T>]: ResultExpression<T, K>[];
+} & {
+    nextCursor?: QueryNextCursors<T>;
+};
+export {};

package/dist/packages/pointclouds/src/potree-three-loader/tree/PointAttributes.d.ts

@@ -1,9 +1,9 @@
 export declare enum PointAttributeName {
-    POSITION_CARTESIAN = 0,
-    COLOR_PACKED = 1,
-    COLOR_FLOATS_1 = 2,
-    COLOR_FLOATS_255 = 3,
-    NORMAL_FLOATS = 4,
+    POSITION_CARTESIAN = 0,// float x, y, z;
+    COLOR_PACKED = 1,// byte r, g, b, a; 	I = [0,1]
+    COLOR_FLOATS_1 = 2,// float r, g, b; 		I = [0,1]
+    COLOR_FLOATS_255 = 3,// float r, g, b; 		I = [0,255]
+    NORMAL_FLOATS = 4,// float x, y, z;
     FILLER = 5,
     INTENSITY = 6,
     CLASSIFICATION = 7,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cognite/reveal",
-  "version": "4.7.1",
+  "version": "4.8.0",
   "description": "WebGL based 3D viewer for CAD and point clouds processed in Cognite Data Fusion.",
   "homepage": "https://github.com/cognitedata/reveal/tree/master/viewer",
   "repository": {
@@ -86,18 +86,18 @@
     "@types/glob": "8.1.0",
     "@types/jest": "29.5.10",
     "@types/jest-environment-puppeteer": "5.0.6",
-    "@types/jest-image-snapshot": "6.2.3",
+    "@types/jest-image-snapshot": "6.3.0",
     "@types/jsdom": "21.1.6",
     "@types/lodash": "4.14.202",
     "@types/mixpanel-browser": "2.47.5",
-    "@types/node": "18.18.13",
+    "@types/node": "18.19.1",
     "@types/random-seed": "0.3.5",
     "@types/skmeans": "0.11.7",
     "@types/stats": "0.16.30",
     "@types/three": "0.158.2",
     "@types/tween.js": "18.5.1",
-    "@typescript-eslint/eslint-plugin": "6.11.0",
-    "@typescript-eslint/parser": "6.11.0",
+    "@typescript-eslint/eslint-plugin": "6.12.0",
+    "@typescript-eslint/parser": "6.12.0",
     "concurrently": "8.2.2",
     "cross-env": "7.0.3",
     "dat.gui": "0.7.9",
@@ -117,11 +117,11 @@
     "jest-canvas-mock": "2.5.2",
     "jest-environment-jsdom": "29.7.0",
     "jest-extended": "4.0.2",
-    "jest-image-snapshot": "6.2.0",
+    "jest-image-snapshot": "6.3.0",
     "jest-puppeteer": "9.0.1",
     "jsdom": "22.1.0",
     "moq.ts": "10.0.8",
-    "nock": "13.3.8",
+    "nock": "13.4.0",
     "prettier": "3.1.0",
     "process": "0.11.10",
     "puppeteer": "21.5.2",
@@ -135,7 +135,7 @@
     "ts-jest": "29.1.1",
     "ts-loader": "9.5.1",
     "tsc-alias": "1.8.8",
-    "typescript": "5.2.2",
+    "typescript": "5.3.2",
     "wasm-pack": "0.12.1",
     "webpack": "5.89.0",
     "webpack-cli": "5.1.4",