@cognite/reveal 4.35.3 → 4.37.0

package/dist/packages/360-images/index.d.ts

@@ -25,3 +25,10 @@ export { DEFAULT_IMAGE_360_OPACITY } from './src/entity/Image360VisualizationBox
 export { Image360Action } from './src/Image360Action';
 export { Image360History } from './src/Image360History';
 export { createCollectionIdString } from './src/collection/createCollectionIdString';
+export type { Image360Provider, Image360ProviderMap } from './src/providers/Image360Provider';
+export { getImage360ProviderFromMap } from './src/providers/Image360Provider';
+export { Image360ProviderCombiner } from './src/providers/Image360ProviderCombiner';
+export { Cdf360ImageAnnotationProvider } from './src/providers/Cdf360ImageAnnotationProvider';
+export { CoreDm360ImageAnnotationProvider } from './src/providers/CoreDm360ImageAnnotationProvider';
+export { Local360ImageProvider } from './src/providers/Local360ImageProvider';
+export { getAnnotationIdKey } from './src/providers/annotations';

package/dist/packages/360-images/src/collection/DefaultImage360Collection.d.ts

@@ -7,10 +7,10 @@ import { Overlay3DIcon } from '../../../3d-overlays';
 import { Image360AnnotationAppearance } from '../annotation/types';
 import { ClusterScreenInfo } from '../icons/clustering';
 import { HtmlClusterCollection } from '../icons/clustering/HtmlClusterCoordinator';
-import { ClassicDataSourceType, DataSourceType, DMDataSourceType, Image360FileDescriptor, Image360Provider } from '../../../data-providers';
+import { ClassicDataSourceType, DataSourceType, DMDataSourceType, Image360FileDescriptor, InstanceReference } from '../../../data-providers';
+import { Image360Provider } from '../providers/Image360Provider';
 import { Image360AnnotationFilter } from '../annotation/Image360AnnotationFilter';
 import { Matrix4, Ray } from 'three';
-import { InstanceReference } from '../../../data-providers/src/types';
 /**
  * Default implementation of {@link Image360Collection}. Used for events when entering
  * and exiting 360 image mode

package/dist/packages/360-images/src/collection/Image360CollectionFactory.d.ts

@@ -4,7 +4,7 @@ import { DefaultImage360Collection } from './DefaultImage360Collection';
 import { IconsOptions } from '../icons/IconCollection';
 import { Matrix4 } from 'three';
 import { Image360AnnotationFilterOptions } from '../annotation/types';
-import { Image360ProviderMap } from '../../../data-providers/src/Image360Provider';
+import { Image360ProviderMap } from '../providers/Image360Provider';
 export declare class Image360CollectionFactory {
     private readonly _image360ProviderMap;
     private readonly _sceneHandler;

package/dist/packages/360-images/src/entity/Image360Entity.d.ts

@@ -1,5 +1,6 @@
 import { DeviceDescriptor, SceneHandler } from '../../../utilities';
-import { DataSourceType, Image360Provider } from '../../../data-providers';
+import { DataSourceType } from '../../../data-providers';
+import { Image360Provider } from '../providers/Image360Provider';
 import { Image360 } from './Image360';
 import { Historical360ImageSet, Image360RevisionId } from '../../../data-providers/src/types';
 import { Image360RevisionEntity } from './Image360RevisionEntity';

package/dist/packages/360-images/src/entity/Image360RevisionEntity.d.ts

@@ -1,4 +1,5 @@
-import { Image360Descriptor, Image360RevisionId, DataSourceType, Image360Provider } from '../../../data-providers';
+import { Image360Descriptor, Image360RevisionId, DataSourceType } from '../../../data-providers';
+import { Image360Provider } from '../providers/Image360Provider';
 import { Image360Revision } from './Image360Revision';
 import { Image360VisualizationBox } from './Image360VisualizationBox';
 import { JpegType } from '../utils/JpegDataStreamParser';

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

@@ -1,8 +1,10 @@
 import { AnnotationModel } from '@cognite/sdk';
-import { FaceName, Image360AnnotationFilterDelegate, Image360AnnotationProvider, Image360AnnotationSpecifier, Image360FileDescriptor, InstanceReference } from '../types';
-import { ClassicDataSourceType, DataSourceType, DMDataSourceType } from '../DataSourceType';
-import { AssetAnnotationImage360Info, AssetHybridAnnotationImage360Info, DefaultImage360Collection, Image360AnnotationAssetQueryResult, Image360Entity, Image360RevisionEntity } from '../../../360-images';
-import { Cdf360ImageAnnotationCache } from './Cdf360ImageAnnotationCache';
+import { FaceName, Image360FileDescriptor, InstanceReference, ClassicDataSourceType, DataSourceType, DMDataSourceType, Cdf360ImageAnnotationCache } from '../../../data-providers';
+import { Image360AnnotationFilterDelegate, Image360AnnotationProvider, Image360AnnotationSpecifier } from './Image360AnnotationProvider';
+import { AssetAnnotationImage360Info, AssetHybridAnnotationImage360Info, Image360AnnotationAssetQueryResult } from '../collection/Image360Collection';
+import { DefaultImage360Collection } from '../collection/DefaultImage360Collection';
+import { Image360Entity } from '../entity/Image360Entity';
+import { Image360RevisionEntity } from '../entity/Image360RevisionEntity';
 export type RevisionFaceRelation = {
     entity: Image360Entity<ClassicDataSourceType>;
     revision: Image360RevisionEntity<ClassicDataSourceType>;

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

@@ -1,6 +1,7 @@
-import { ClassicDataSourceType, DataSourceType, DMDataSourceType } from '../DataSourceType';
-import { Image360AnnotationFilterDelegate, Image360AnnotationProvider, Image360AnnotationSpecifier, InstanceReference } from '../types';
-import { AssetAnnotationImage360Info, AssetHybridAnnotationImage360Info, DefaultImage360Collection, Image360AnnotationAssetQueryResult } from '../../../360-images';
+import { ClassicDataSourceType, DataSourceType, DMDataSourceType, InstanceReference } from '../../../data-providers';
+import { Image360AnnotationFilterDelegate, Image360AnnotationProvider, Image360AnnotationSpecifier } from './Image360AnnotationProvider';
+import { AssetAnnotationImage360Info, AssetHybridAnnotationImage360Info, Image360AnnotationAssetQueryResult } from '../collection/Image360Collection';
+import { DefaultImage360Collection } from '../collection/DefaultImage360Collection';
 import { CogniteClient } from '@cognite/sdk';
 export declare class CoreDm360ImageAnnotationProvider implements Image360AnnotationProvider<DMDataSourceType> {
     private readonly _client;

package/dist/packages/360-images/src/providers/Image360AnnotationProvider.d.ts

@@ -0,0 +1,24 @@
+import { ClassicDataSourceType, DataSourceType, DMDataSourceType, Image360RevisionId, Image360FileDescriptor } from '../../../data-providers';
+import { AssetAnnotationImage360Info, AssetHybridAnnotationImage360Info, Image360AnnotationAssetQueryResult } from '../collection/Image360Collection';
+import { DefaultImage360Collection } from '../collection/DefaultImage360Collection';
+import { Image360AnnotationInstanceReference } from '../annotation/types';
+export type Image360AnnotationFilterDelegate<T extends DataSourceType> = (annotation: T['image360AnnotationType']) => boolean;
+export type Image360AnnotationSpecifier<T extends DataSourceType> = {
+    revisionId: Image360RevisionId<T>;
+    fileDescriptors: Image360FileDescriptor[];
+};
+export interface Image360AnnotationProvider<T extends DataSourceType> {
+    getRelevant360ImageAnnotations(annotationSpecifier: Image360AnnotationSpecifier<T>): Promise<T['image360AnnotationType'][]>;
+    /**
+     * Resolves the mapping from internal file IDs (annotatedResourceId) to external IDs.
+     * This is needed to match annotations to face descriptors when descriptors use externalId.
+     * Optional - if not implemented, the caller should build mapping from descriptors only.
+     */
+    resolveFileIdToExternalIdMapping?(annotations: T['image360AnnotationType'][], descriptors: Image360FileDescriptor[]): Promise<Map<number, string>>;
+    findImageAnnotationsForInstance(instanceFilter: Image360AnnotationInstanceReference<T>, collection: DefaultImage360Collection<T>): Promise<Image360AnnotationAssetQueryResult<T>[]>;
+    getAllImage360AnnotationInfos(source: 'assets', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetAnnotationImage360Info<ClassicDataSourceType>[]>;
+    getAllImage360AnnotationInfos(source: 'hybrid', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetHybridAnnotationImage360Info[]>;
+    getAllImage360AnnotationInfos(source: 'cdm', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetAnnotationImage360Info<DMDataSourceType>[]>;
+    getAllImage360AnnotationInfos(source: 'all', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetAnnotationImage360Info<DataSourceType>[]>;
+    getAllImage360AnnotationInfos(source: 'assets' | 'hybrid' | 'cdm' | 'all', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetAnnotationImage360Info<ClassicDataSourceType>[] | AssetAnnotationImage360Info<DMDataSourceType>[] | AssetAnnotationImage360Info<DataSourceType>[] | AssetHybridAnnotationImage360Info[]>;
+}

package/dist/packages/{data-providers/src → 360-images/src/providers}/Image360Provider.d.ts

@@ -1,6 +1,6 @@
-import { Image360CollectionSourceType } from '../../360-images';
-import { ClassicDataSourceType, DataSourceType, DMDataSourceType } from './DataSourceType';
-import { Image360DescriptorProvider, Image360FileProvider, Image360AnnotationProvider } from './types';
+import { Image360CollectionSourceType } from '../types';
+import { ClassicDataSourceType, DataSourceType, DMDataSourceType, Image360DescriptorProvider, Image360FileProvider } from '../../../data-providers';
+import { Image360AnnotationProvider } from './Image360AnnotationProvider';
 export type Image360ProviderMap = Map<Image360CollectionSourceType, Image360Provider<DMDataSourceType> | Image360Provider<ClassicDataSourceType>>;
 export declare function getImage360ProviderFromMap<T extends DataSourceType>(identifier: T['image360Identifier'], providerMap: Image360ProviderMap): Image360Provider<T>;
 export interface Image360Provider<T extends DataSourceType> extends Image360DescriptorProvider<T>, Image360FileProvider, Image360AnnotationProvider<T> {

package/dist/packages/{data-providers/src → 360-images/src/providers}/Image360ProviderCombiner.d.ts

@@ -1,8 +1,9 @@
 import { Image360Provider } from './Image360Provider';
-import { ClassicDataSourceType, DataSourceType, DMDataSourceType } from './DataSourceType';
-import { Historical360ImageSet, Image360AnnotationFilterDelegate, Image360AnnotationProvider, Image360AnnotationSpecifier, Image360DescriptorProvider, Image360Face, Image360FileDescriptor, Image360FileProvider } from './types';
-import { AssetAnnotationImage360Info, AssetHybridAnnotationImage360Info, DefaultImage360Collection, Image360AnnotationAssetQueryResult } from '../../360-images';
-import { Image360AnnotationInstanceReference } from '../../360-images/src/annotation/types';
+import { ClassicDataSourceType, DataSourceType, DMDataSourceType, Historical360ImageSet, Image360DescriptorProvider, Image360Face, Image360FileDescriptor, Image360FileProvider } from '../../../data-providers';
+import { Image360AnnotationFilterDelegate, Image360AnnotationProvider, Image360AnnotationSpecifier } from './Image360AnnotationProvider';
+import { AssetAnnotationImage360Info, AssetHybridAnnotationImage360Info, Image360AnnotationAssetQueryResult } from '../collection/Image360Collection';
+import { DefaultImage360Collection } from '../collection/DefaultImage360Collection';
+import { Image360AnnotationInstanceReference } from '../annotation/types';
 export declare class Image360ProviderCombiner<T extends DataSourceType> implements Image360Provider<T> {
     private readonly _descriptorProvider;
     private readonly _fileProvider;

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

@@ -1,8 +1,9 @@
-import { Image360Provider } from '../Image360Provider';
-import { Historical360ImageSet, Image360AnnotationFilterDelegate, Image360AnnotationSpecifier, Image360Face, Image360FileDescriptor, InstanceReference } from '../types';
+import { Image360Provider } from './Image360Provider';
+import { Historical360ImageSet, Image360Face, Image360FileDescriptor, InstanceReference, ClassicDataSourceType, DataSourceType, DMDataSourceType } from '../../../data-providers';
+import { Image360AnnotationFilterDelegate, Image360AnnotationSpecifier } from './Image360AnnotationProvider';
 import { CogniteInternalId, IdEither } from '@cognite/sdk';
-import { ClassicDataSourceType, DataSourceType, DMDataSourceType } from '../DataSourceType';
-import { AssetAnnotationImage360Info, AssetHybridAnnotationImage360Info, DefaultImage360Collection, Image360AnnotationAssetQueryResult } from '../../../360-images';
+import { AssetAnnotationImage360Info, AssetHybridAnnotationImage360Info, Image360AnnotationAssetQueryResult } from '../collection/Image360Collection';
+import { DefaultImage360Collection } from '../collection/DefaultImage360Collection';
 export declare class Local360ImageProvider implements Image360Provider<ClassicDataSourceType> {
     private readonly _modelUrl;
     constructor(modelUrl: string);

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

@@ -1,2 +1,2 @@
-import { DataSourceType } from '../DataSourceType';
+import { DataSourceType } from '../../../data-providers';
 export declare function getAnnotationIdKey(annotation: DataSourceType['image360AnnotationType']): string;

package/dist/packages/3d-overlays/src/Overlay3DCollection.d.ts

@@ -17,6 +17,10 @@ export type Overlay3DCollectionOptions = {
      * The maximum display size of each icon in pixels
      */
     maxPointSize?: number;
+    /**
+     * The minimum display size of each icon in pixels
+     */
+    minPointSize?: number;
     /**
      * The default color to apply to overlay icons without a color on their own
      */

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

@@ -26,6 +26,7 @@ export declare class Image360ApiHelper<DataSourceT extends DataSourceType> {
     private readonly onBeforeRender;
     private readonly onKeyPressed;
     readonly onHover: (event: PointerEvent) => void;
+    readonly onPointerLeave: () => void;
     readonly onClick: (event: PointerEventData) => Promise<boolean>;
     private readonly updateHoverStateOnRenderHandler;
     constructor(cogniteClient: CogniteClient, sceneHandler: SceneHandler, domElement: HTMLElement, activeCameraManager: ProxyCameraManager, inputHandler: InputHandler, onBeforeSceneRendered: EventTrigger<BeforeSceneRenderedDelegate>, hasEventListeners?: boolean, iconsOptions?: IconsOptions);
@@ -77,6 +78,7 @@ export declare class Image360ApiHelper<DataSourceT extends DataSourceType> {
      */
     findBestNext360ImageEntity(clickedWorldPosition: Vector3): Image360WithCollection<DataSourceT> | undefined;
     private setHoverIconOnIntersect;
+    clearHoverIntersection(): void;
     private exit360ImageByTween;
     private getImageOpacity;
 }

package/dist/packages/api/src/public/RevealManager.d.ts

@@ -38,6 +38,7 @@ export declare class RevealManager {
     setOutputRenderTarget(target: WebGLRenderTarget | null, autoSizeRenderTarget?: boolean): void;
     get materialManager(): CadMaterialManager;
     get needsRedraw(): boolean;
+    get cameraInMotion(): boolean;
     update(camera: PerspectiveCamera): void;
     get cadBudget(): CadModelBudget;
     set cadBudget(budget: CadModelBudget);

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

@@ -677,6 +677,7 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
      * @param options
      * @param options.stopOnHitting360Icon
      * @param options.predicate Check whether a CustomObject should be intersected.
+     * @param options.forceWindowedPick Skip point-cloud full-frame pick caching for this call.
      * @returns A promise that if there was an intersection then return the intersection object - otherwise it
      * returns `null` if there were no intersections.
      * @beta
@@ -684,6 +685,7 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
     getAnyIntersectionFromPixel(pixelCoords: Vector2, options?: {
         stopOnHitting360Icon?: boolean;
         predicate?: (customObject: ICustomObject) => boolean;
+        forceWindowedPick?: boolean;
     }): Promise<AnyIntersection<DataSourceT> | undefined>;
     /**
      * Event function to click on 360 images.

package/dist/packages/cad-model/src/types.d.ts

@@ -1,25 +1,11 @@
-import { Box3 } from 'three';
+/*!
+ * Copyright 2022 Cognite AS
+ */
+export type { GeometryFilter } from '../../data-providers';
 /**
  * Units supported by {@link CogniteCadModel}.
  */
 export type WellKnownUnit = 'Meters' | 'Centimeters' | 'Millimeters' | 'Micrometers' | 'Kilometers' | 'Feet' | 'Inches' | 'Yards' | 'Miles' | 'Mils' | 'Microinches';
-export type GeometryFilter = {
-    /**
-     * The bounds to load geometry within. By default this box is in CDF coordinate space which
-     * will be transformed into coordinates relative to the model using the the model transformation
-     * which can be specified using {@link https://docs.cognite.com/api/v1/#operation/update3DRevisions |the CDF API},
-     * or set in {@link https://fusion.cognite.com/ |Cognite Fusion}.
-     * @see {@link GeometryFilter.isBoundingBoxInModelCoordinates}.
-     */
-    boundingBox?: Box3;
-    /**
-     * When set, the geometry filter `boundingBox` will be considered to be in "Reveal/ThreeJS space".
-     * Rather than CDF space which is the default. When using Reveal space, the model transformation
-     * which can be specified using {@link https://docs.cognite.com/api/v1/#operation/update3DRevisions |the CDF API},
-     * or set in {@link https://fusion.cognite.com/ |Cognite Fusion}.
-     */
-    isBoundingBoxInModelCoordinates?: boolean;
-};
 export type CadModelSectorLoadStatistics = {
     /**
      * Estimated number of bytes to download sectors.

package/dist/packages/camera-manager/src/Flexible/FlexibleCameraManager.d.ts

@@ -2,12 +2,11 @@ import { PerspectiveCamera, Scene, Box3, Vector3 } from 'three';
 import { FlexibleControls } from './FlexibleControls';
 import { FlexibleControlsOptions } from './FlexibleControlsOptions';
 import { PointerEvents } from '../../../utilities';
-import { CameraEventDelegate, CameraManagerCallbackData, CameraManagerEventType, CameraState } from './../types';
+import { CameraEventDelegate, CameraManagerEventType, CameraState, RaycastCallback } from './../types';
 import { CameraManager } from './../CameraManager';
 import { FlexibleControlsType } from './FlexibleControlsType';
 import { FlexibleControlsTypeChangeDelegate, IFlexibleCameraManager } from './IFlexibleCameraManager';
 import { FlexibleCameraEventTarget } from './FlexibleCameraEventTarget';
-type RaycastCallback = (x: number, y: number, pickBoundingBox: boolean) => Promise<CameraManagerCallbackData>;
 /**
  * Flexible implementation of {@link CameraManager}. The user can switch between Orbit, FirstPersion or OrbitInCenter
  * Supports automatic update of camera near and far planes and animated change of camera position and target.
@@ -79,4 +78,3 @@ export declare class FlexibleCameraManager extends PointerEvents implements IFle
     private updateControlsSensitivity;
     static as(manager: CameraManager): FlexibleCameraManager | undefined;
 }
-export {};

package/dist/packages/camera-manager/src/Flexible/GetPickedPointByPixelCoordinates.d.ts

@@ -1,2 +1,2 @@
 import { Vector2, Vector3 } from 'three';
-export type GetPickedPointByPixelCoordinates = (position: Vector2) => Promise<Vector3>;
+export type GetPickedPointByPixelCoordinates = (position: Vector2, forceWindowedPick?: boolean) => Promise<Vector3>;

package/dist/packages/camera-manager/src/types.d.ts

@@ -54,6 +54,11 @@ export type CameraManagerCallbackData = {
      */
     pickedBoundingBox: Box3 | undefined;
 };
+/**
+ * Callback used by camera managers to request a raycast/pick against the scene.
+ * @beta
+ */
+export type RaycastCallback = (x: number, y: number, pickBoundingBox: boolean, forceWindowedPick?: boolean) => Promise<CameraManagerCallbackData>;
 /**
  * List of supported event types (adapted from https://stackoverflow.com/questions/44480644/string-union-to-string-array)
  */

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

@@ -5,26 +5,26 @@ export { CdfModelDataProvider } from './src/model-data-providers/CdfModelDataPro
 export { CachedModelDataProvider } from './src/model-data-providers/CachedModelDataProvider';
 export { CdfModelIdentifier } from './src/model-identifiers/CdfModelIdentifier';
 export { CdfModelMetadataProvider } from './src/metadata-providers/CdfModelMetadataProvider';
-export { getAnnotationIdKey } from './src/image-360-data-providers/annotations';
-export { Cdf360ImageAnnotationProvider } from './src/image-360-data-providers/Cdf360ImageAnnotationProvider';
 export { type Cdf360ImageAnnotationCache, createCdf360ImageAnnotationCache } from './src/image-360-data-providers/Cdf360ImageAnnotationCache';
 export { Cdf360EventDescriptorProvider } from './src/image-360-data-providers/descriptor-providers/events/Cdf360EventDescriptorProvider';
-export { CoreDm360ImageAnnotationProvider } from './src/image-360-data-providers/CoreDm360ImageAnnotationProvider';
 export { Cdf360CdmDescriptorProvider } from './src/image-360-data-providers/descriptor-providers/datamodels/cdm/Cdf360CdmDescriptorProvider';
 export { Cdf360ImageFileProvider } from './src/image-360-data-providers/Cdf360ImageFileProvider';
 export type { Image360DataModelIdentifier, Image360CoreDataModelIdentifier, Image360LegacyDataModelIdentifier, Image360BaseIdentifier } from './src/image-360-data-providers/descriptor-providers/datamodels/system-space/Cdf360DataModelsDescriptorProvider';
 export { Cdf360DataModelsDescriptorProvider } from './src/image-360-data-providers/descriptor-providers/datamodels/system-space/Cdf360DataModelsDescriptorProvider';
-export { isClassic360Identifier, isCoreDmImage360Identifier, isLegacyDM360Identifier, isFdm360ImageCollectionIdentifier, isClassicMetadata360Identifier } from './src/image-360-data-providers/shared';
+export { isClassic360Identifier, isCoreDmImage360Identifier, isLegacyDM360Identifier, isFdm360ImageCollectionIdentifier, isClassicMetadata360Identifier, isSameImage360RevisionId } from './src/image-360-data-providers/shared';
+export { fetchCoreDm360AnnotationsForRevision } from './src/image-360-data-providers/cdm/fetchCoreDm360AnnotationsForRevision';
+export { fetchAnnotationsForInstance, type Image360AnnotationsForInstanceResult } from './src/image-360-data-providers/cdm/fetchAnnotationsForInstance';
+export { fetchCoreDm360AnnotationsForCollection } from './src/image-360-data-providers/cdm/fetchCoreDm360AnnotationsForCollection';
 export type { CoreDmImage360Annotation } from './src/image-360-data-providers/cdm/types';
 export { LocalModelDataProvider } from './src/model-data-providers/LocalModelDataProvider';
 export { LocalModelIdentifier } from './src/model-identifiers/LocalModelIdentifier';
 export { DMModelIdentifier } from './src/model-identifiers/DMModelIdentifier';
 export { LocalModelMetadataProvider } from './src/metadata-providers/LocalModelMetadataProvider';
-export { Local360ImageProvider } from './src/image-360-data-providers/Local360ImageProvider';
 export type { ModelIdentifier } from './src/ModelIdentifier';
 export { createModelIdentifier } from './src/ModelIdentifier';
 export type { ModelMetadataProvider } from './src/ModelMetadataProvider';
 export type { ModelDataProvider } from './src/ModelDataProvider';
+export type { GeometryFilter } from './src/GeometryFilter';
 export type { PointCloudObjectMetadata, PointCloudObject } from './src/pointcloud-stylable-object-providers/types';
 export type { PointCloudStylableObjectProvider } from './src/PointCloudStylableObjectProvider';
 export type { StylableObject, SerializableStylableObject } from './src/pointcloud-stylable-object-providers/StylableObject';
@@ -32,16 +32,16 @@ export { CdfPointCloudStylableObjectProvider } from './src/pointcloud-stylable-o
 export { DummyPointCloudStylableObjectProvider } from './src/pointcloud-stylable-object-providers/DummyPointCloudStylableObjectProvider';
 export { CdfPointCloudDMStylableObjectProvider } from './src/pointcloud-stylable-object-providers/pointcloud-volume-data-providers/CdfPointCloudDMStylableObjectProvider';
 export { DummyPointCloudDMStylableObjectProvider } from './src/pointcloud-stylable-object-providers/pointcloud-volume-data-providers/DummyPointCloudDMStylableObjectProvider';
-export type { Image360Provider, Image360ProviderMap } from './src/Image360Provider';
-export { getImage360ProviderFromMap } from './src/Image360Provider';
-export { Image360ProviderCombiner } from './src/Image360ProviderCombiner';
-export type { BinaryFileProvider, JsonFileProvider, SignedFileProvider, BlobOutputMetadata, Image360Descriptor, Image360FileProvider, Image360Face, Image360Texture, Image360FileDescriptor, ImageAssetLinkAnnotationInfo, ImageInstanceLinkAnnotationInfo, InstanceReference, Image360Id, Image360RevisionId, SignedFileItem } from './src/types';
+export type { BinaryFileProvider, JsonFileProvider, SignedFileProvider, BlobOutputMetadata, Image360Descriptor, Image360DescriptorProvider, Image360FileProvider, Image360Face, Image360Texture, Image360FileDescriptor, ImageAssetLinkAnnotationInfo, ImageInstanceLinkAnnotationInfo, InstanceReference, Image360Id, Image360RevisionId, Historical360ImageSet, FaceName, SignedFileItem } from './src/types';
 export { File3dFormat } from './src/types';
 export { fetchDMModelIdFromRevisionId } from './src/requests/fetchDMModelIdFromRevisionId';
 export { isDMPointCloudVolumeObject, isClassicPointCloudVolumeObject, isDMPointCloudVolume, isClassicPointCloudVolume } from './src/utilities/utils';
 export { getExternalIdFromDescriptor } from './src/utilities/getExternalIdFromDescriptor';
+export { getInstanceKey } from './src/utilities/instanceIds';
 export type { DataSourceType, ClassicDataSourceType, DMDataSourceType, ClassicModelIdentifierType, DMModelIdentifierType, InternalDataSourceType, LocalDataSourceType, LocalModelIdentifierType, GenericDataSourceType } from './src/DataSourceType';
-export { isClassicIdentifier, isDMIdentifier, isLocalIdentifier } from './src/DataSourceType';
+export { isClassicIdentifier, isDMIdentifier, isLocalIdentifier, isSameDMIdentifier } from './src/DataSourceType';
 export type { LocalAddModelOptions, CommonModelOptions, InternalAddModelOptions, AddModelOptionsWithModelRevisionId } from './src/utilities/internalAddModelOptions';
 export type { MetadataWithSignedFiles } from './src/metadata-providers/types';
 export { SignedUrlRefresher, type FetchWithRefreshOptions } from './src/utilities/SignedUrlRefresh';
+export { PointCloudObjectCollection, PointCloudAnnotationVolumeCollection } from './src/point-cloud-collections/PointCloudObjectCollection';
+export { PointCloudDMVolumeCollection } from './src/point-cloud-collections/PointCloudDMVolumeCollection';

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

@@ -1,6 +1,7 @@
 import { AnnotationModel, AnnotationsAssetRef } from '@cognite/sdk';
 import { Image360DataModelIdentifier } from './image-360-data-providers/descriptor-providers/datamodels/system-space/Cdf360DataModelsDescriptorProvider';
-import { PointCloudAnnotationVolumeCollection, PointCloudDMVolumeCollection } from '../../pointcloud-styling';
+import { PointCloudAnnotationVolumeCollection } from './point-cloud-collections/PointCloudObjectCollection';
+import { PointCloudDMVolumeCollection } from './point-cloud-collections/PointCloudDMVolumeCollection';
 import { CoreDmImage360Annotation } from './image-360-data-providers/cdm/types';
 import { DMInstanceRef } from '../../utilities';
 /**

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

@@ -0,0 +1,18 @@
+import { Box3 } from 'three';
+export type GeometryFilter = {
+    /**
+     * The bounds to load geometry within. By default this box is in CDF coordinate space which
+     * will be transformed into coordinates relative to the model using the the model transformation
+     * which can be specified using {@link https://docs.cognite.com/api/v1/#operation/update3DRevisions |the CDF API},
+     * or set in {@link https://fusion.cognite.com/ |Cognite Fusion}.
+     * @see {@link GeometryFilter.isBoundingBoxInModelCoordinates}.
+     */
+    boundingBox?: Box3;
+    /**
+     * When set, the geometry filter `boundingBox` will be considered to be in "Reveal/ThreeJS space".
+     * Rather than CDF space which is the default. When using Reveal space, the model transformation
+     * which can be specified using {@link https://docs.cognite.com/api/v1/#operation/update3DRevisions |the CDF API},
+     * or set in {@link https://fusion.cognite.com/ |Cognite Fusion}.
+     */
+    isBoundingBoxInModelCoordinates?: boolean;
+};

package/dist/packages/{pointcloud-styling/src → data-providers/src/point-cloud-collections}/PointCloudDMVolumeCollection.d.ts

@@ -1,4 +1,4 @@
-import { DMInstanceRef } from '../../utilities';
+import { DMInstanceRef } from '../../../utilities';
 /**
  * A simple PointCloudDMVolumeCollection that consists of an explicitly provided list of data model instance.
  */

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

@@ -1,10 +1,8 @@
 import { AnnotationModel, AnnotationsTypesImagesAssetLink, AnnotationsTypesImagesInstanceLink, IdEither } from '@cognite/sdk';
 import { Matrix4, Texture } from 'three';
 import { ClassicDataSourceType, DataSourceType, DMDataSourceType } from './DataSourceType';
-import { AssetAnnotationImage360Info, AssetHybridAnnotationImage360Info, DefaultImage360Collection, Image360AnnotationAssetQueryResult, Image360AnnotationInstanceReference } from '../../360-images';
 import { DMInstanceRef } from '../../utilities';
 import { ModelIdentifier } from './ModelIdentifier';
-export type Image360AnnotationFilterDelegate<T extends DataSourceType> = (annotation: T['image360AnnotationType']) => boolean;
 export interface JsonFileProvider {
     /**
      * Download and parse a JSON file and return the resulting struct.
@@ -48,29 +46,10 @@ export type Image360Id<T extends DataSourceType> = Image360RevisionId<T>;
  * An ID identifiying a single Image360 revision within a collection
  */
 export type Image360RevisionId<T extends DataSourceType> = T extends DMDataSourceType ? DMInstanceRef : string;
-export type Image360AnnotationSpecifier<T extends DataSourceType> = {
-    revisionId: Image360RevisionId<T>;
-    fileDescriptors: Image360FileDescriptor[];
-};
 /**
  * Filter for finding linked annotations in either a classic 360 collection or a new one
  */
 export type InstanceReference<T extends DataSourceType> = T extends ClassicDataSourceType ? IdEither : DMInstanceRef;
-export interface Image360AnnotationProvider<T extends DataSourceType> {
-    getRelevant360ImageAnnotations(annotationSpecifier: Image360AnnotationSpecifier<T>): Promise<T['image360AnnotationType'][]>;
-    /**
-     * Resolves the mapping from internal file IDs (annotatedResourceId) to external IDs.
-     * This is needed to match annotations to face descriptors when descriptors use externalId.
-     * Optional - if not implemented, the caller should build mapping from descriptors only.
-     */
-    resolveFileIdToExternalIdMapping?(annotations: T['image360AnnotationType'][], descriptors: Image360FileDescriptor[]): Promise<Map<number, string>>;
-    findImageAnnotationsForInstance(instanceFilter: Image360AnnotationInstanceReference<T>, collection: DefaultImage360Collection<T>): Promise<Image360AnnotationAssetQueryResult<T>[]>;
-    getAllImage360AnnotationInfos(source: 'assets', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetAnnotationImage360Info<ClassicDataSourceType>[]>;
-    getAllImage360AnnotationInfos(source: 'hybrid', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetHybridAnnotationImage360Info[]>;
-    getAllImage360AnnotationInfos(source: 'cdm', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetAnnotationImage360Info<DMDataSourceType>[]>;
-    getAllImage360AnnotationInfos(source: 'all', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetAnnotationImage360Info<DataSourceType>[]>;
-    getAllImage360AnnotationInfos(source: 'assets' | 'hybrid' | 'cdm' | 'all', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetAnnotationImage360Info<ClassicDataSourceType>[] | AssetAnnotationImage360Info<DMDataSourceType>[] | AssetAnnotationImage360Info<DataSourceType>[] | AssetHybridAnnotationImage360Info[]>;
-}
 export interface Image360DescriptorProvider<T extends DataSourceType> {
     get360ImageDescriptors(metadataFilter: T['image360Identifier'], preMultipliedRotation: boolean): Promise<Historical360ImageSet<T>[]>;
 }

package/dist/packages/data-providers/src/utilities/internalAddModelOptions.d.ts

@@ -1,4 +1,4 @@
-import { GeometryFilter } from '../../../cad-model';
+import { GeometryFilter } from '../GeometryFilter';
 import { ClassicModelIdentifierType, InternalDataSourceType, LocalModelIdentifierType } from '../DataSourceType';
 import { File3dFormat } from '../types';
 /**

package/dist/packages/model-base/src/types.d.ts

@@ -5,6 +5,8 @@ export interface IntersectInput {
     clippingPlanes: Plane[];
     renderer: WebGLRenderer;
     domElement: HTMLElement;
+    cameraInMotion?: boolean;
+    forceWindowedPick?: boolean;
 }
 /**
  * State holding information about data being loaded.

package/dist/packages/pointcloud-styling/index.d.ts

@@ -4,7 +4,6 @@
 export type { CompletePointCloudAppearance, PointCloudAppearance } from './src/PointCloudAppearance';
 export { DefaultPointCloudAppearance, applyDefaultsToPointCloudAppearance } from './src/PointCloudAppearance';
 export { StyledPointCloudObjectCollection, StyledPointCloudVolumeCollection } from './src/StyledPointCloudVolumeCollection';
-export { PointCloudObjectCollection, PointCloudAnnotationVolumeCollection } from './src/PointCloudObjectCollection';
+export { PointCloudObjectCollection, PointCloudAnnotationVolumeCollection, PointCloudDMVolumeCollection } from '../data-providers';
 export { AnnotationIdPointCloudObjectCollection } from './src/AnnotationIdPointCloudObjectCollection';
-export { PointCloudDMVolumeCollection } from './src/PointCloudDMVolumeCollection';
 export { isPointCloudObjectCollection, isDMInstanceRefPointCloudObjectCollection } from './src/utils';

package/dist/packages/pointcloud-styling/src/AnnotationIdPointCloudObjectCollection.d.ts

@@ -1,4 +1,4 @@
-import { PointCloudAnnotationVolumeCollection } from './PointCloudObjectCollection';
+import { PointCloudAnnotationVolumeCollection } from '../../data-providers';
 /**
  * A simple PointCloudAnnotationVolumeCollection that consists of an explicitly provided list of annotation IDs
  */

package/dist/packages/pointcloud-styling/src/utils.d.ts

@@ -1,4 +1,3 @@
-import { PointCloudDMVolumeCollection } from './PointCloudDMVolumeCollection';
-import { PointCloudAnnotationVolumeCollection } from './PointCloudObjectCollection';
+import { PointCloudDMVolumeCollection, PointCloudAnnotationVolumeCollection } from '../../data-providers';
 export declare function isPointCloudObjectCollection(collection: PointCloudAnnotationVolumeCollection | PointCloudDMVolumeCollection): collection is PointCloudAnnotationVolumeCollection;
 export declare function isDMInstanceRefPointCloudObjectCollection(collection: PointCloudAnnotationVolumeCollection | PointCloudDMVolumeCollection): collection is PointCloudDMVolumeCollection;

package/dist/packages/pointclouds/src/PointCloudPickingHandler.d.ts

@@ -11,5 +11,10 @@ export declare class PointCloudPickingHandler {
     private static readonly PickingWindowSize;
     constructor(renderer: WebGLRenderer);
     dispose(): void;
+    /**
+     * Invalidates the picker's cached full-frame pick buffer. Must be called whenever a new
+     * frame of the scene is rendered.
+     */
+    invalidatePickCache(): void;
     intersectPointClouds(nodes: PointCloudNode<DataSourceType>[], input: IntersectInput): Promise<IntersectPointCloudNodeResult<DataSourceType>[]>;
 }

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

@@ -5,10 +5,27 @@ import { PickParams } from './PointCloudOctreePickerHelper';
 export type { PickParams };
 export declare class PointCloudOctreePicker {
     private static readonly helperVec3;
+    private static readonly helperVec2;
+    private static readonly REBUILD_HOLDOFF_MS;
     private pickState;
     private readonly _renderer;
     private readonly _pickerHelper;
+    private _cache;
+    private _invalidationCount;
+    private _lastInvalidatedAt;
     constructor(renderer: WebGLRenderer);
     dispose(): void;
+    /**
+     * Invalidates the cached full-frame pick buffer. Must be called whenever a new frame of the
+     * scene is rendered (camera, point cloud LOD, styling or clipping changes) and on resize.
+     */
+    invalidateCache(): void;
     pick(camera: Camera, ray: Ray, octrees: PointCloudOctree[], params?: Partial<PickParams>): Promise<PickPoint | null>;
+    private pickWindowed;
+    private isCacheUsable;
+    private buildCache;
+    /** Picks the smallest node-index bit width that fits every visible node, or undefined if there are no nodes or none fits. */
+    private computeNodeIndexBits;
+    private renderAndReadBackPixels;
+    private pickFromCache;
 }

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

@@ -29,6 +29,25 @@ export interface PickParams {
      * @param renterTarget The render target used for picking.
      */
     onBeforePickRender: (material: PointCloudMaterial, renterTarget: WebGLRenderTarget) => void;
+    /**
+     * Whether the camera is currently known to be in motion (e.g. during an interactive zoom/pan/
+     * orbit). When true, the full-frame pick cache is never rebuilt for this call, regardless of
+     * how long ago it was last invalidated. Confirmed by measurement: a full-frame rebuild's async
+     * GPU readback (tens to hundreds of ms) routinely doesn't finish before the next camera-change
+     * invalidates it again during continuous motion, so the rebuild is started, pays its full cost,
+     * gets discarded, and the caller still has to fall back to a windowed pick anyway. Falls back to
+     * the time-based holdoff when omitted.
+     */
+    cameraInMotion?: boolean;
+    /**
+     * Unconditionally skips the full-frame pick cache (both serving from it and rebuilding it) for
+     * this call, regardless of camera-motion state. Intended for callers that pick on every input
+     * event of a fast, continuous interaction (e.g. wheel-driven zoom-to-cursor) where even
+     * checking/rebuilding the cache adds latency that matters more than the cache's benefit - unlike
+     * `cameraInMotion`, this doesn't depend on the camera having already started moving, which
+     * matters because some callers pick *before* moving the camera for that same input event.
+     */
+    forceWindowedPick?: boolean;
 }
 /**
  * Helper class for PointCloudOctreePicker.
@@ -40,15 +59,21 @@ export declare class PointCloudOctreePickerHelper {
     private readonly _rendererStateHelper;
     constructor(renderer: WebGLRenderer);
     resetState(): void;
-    prepareRender(x: number, y: number, pickWndSize: number, pickMaterial: PointCloudMaterial, pickState: IPickState): void;
-    render(camera: Camera, pickMaterial: PointCloudMaterial, octrees: PointCloudOctree[], ray: Ray, pickState: IPickState, params: Partial<PickParams>): RenderedNode[];
+    prepareRender(x: number, y: number, width: number, height: number, pickMaterial: PointCloudMaterial, pickState: IPickState): void;
+    render(camera: Camera, pickMaterial: PointCloudMaterial, octrees: PointCloudOctree[], ray: Ray | undefined, pickState: IPickState, params: Partial<PickParams>, nodeIndexBits?: number): RenderedNode[];
     private static nodesOnRay;
-    readPixelsAsync(x: number, y: number, pickWndSize: number, renderTarget: WebGLRenderTarget): Promise<Uint8Array>;
+    readPixelsAsync(x: number, y: number, width: number, height: number, renderTarget: WebGLRenderTarget, pixels?: Uint8Array): Promise<Uint8Array>;
     private static createTempNodes;
     private static updatePickMaterial;
     static updatePickRenderTarget(pickState: IPickState, width: number, height: number): void;
     private static makePickRenderTarget;
-    static findHit(pixels: Uint8Array, pickWndSize: number, nodes: RenderedNode[], camera: Camera): PointCloudHit | null;
+    static computeBitSplit(nodeCount: number, maxPointsPerNode: number): number | undefined;
+    static decodePackedPixel(packedIndex: number, nodeIndexBits: number): {
+        nodeIndex: number;
+        pointIndex: number;
+    };
+    static findHit(pixels: Uint8Array, pickWndSize: number, nodes: RenderedNode[], camera: Camera, nodeIndexBits?: number): PointCloudHit | null;
+    static findHitInBuffer(ibuffer: Uint32Array, bufferWidth: number, bufferHeight: number, centerX: number, centerY: number, windowSize: number, nodes: RenderedNode[], camera: Camera, nodeIndexBits: number): PointCloudHit | null;
     static getPickPoint(hit: PointCloudHit | null, nodes: RenderedNode[]): PickPoint | null;
     static getPointPosition(nodes: RenderedNode[], pcIndex: number, pIndex: number): Vector3;
     private static addPositionToPickPoint;

package/dist/packages/rendering/src/pointcloud-rendering/PointCloudMaterial.d.ts

@@ -23,6 +23,7 @@ export interface IPointCloudMaterialUniforms {
     level: IUniform<number>;
     maxSize: IUniform<number>;
     minSize: IUniform<number>;
+    nodeIndexBits: IUniform<number>;
     objectIdLUT: IUniform<Texture>;
     octreeSize: IUniform<number>;
     pcIndex: IUniform<number>;
@@ -68,6 +69,8 @@ export declare class PointCloudMaterial extends RawShaderMaterial {
     set maxSize(value: number);
     get minSize(): number;
     set minSize(value: number);
+    get nodeIndexBits(): number;
+    set nodeIndexBits(value: number);
     get octreeSize(): number;
     set octreeSize(value: number);
     get screenHeight(): number;

package/dist/packages/rendering/src/pointcloud-rendering/constants.d.ts

@@ -3,6 +3,7 @@ export declare const DEFAULT_MAX_POINT_SIZE = 10;
 export declare const DEFAULT_MIN_NODE_PIXEL_SIZE = 50;
 export declare const DEFAULT_MIN_POINT_SIZE = 1;
 export declare const DEFAULT_PICK_WINDOW_SIZE = 15;
+export declare const DEFAULT_NODE_INDEX_BITS = 8;
 export declare const DEFAULT_POINT_BUDGET = 3000000;
 export declare const MAX_LOADS_TO_GPU = 15;
 export declare const MAX_NUM_NODES_LOADING = 8;