@cognite/reveal 4.2.1 → 4.3.0

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

@@ -0,0 +1,62 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { Image360DataProvider, Image360Descriptor } from '../../../data-providers';
+import { Image360Revision } from './Image360Revision';
+import { Image360VisualizationBox } from './Image360VisualizationBox';
+import { ImageAnnotationObject } from '../annotation/ImageAnnotationObject';
+import { Image360AnnotationAppearance } from '../annotation/types';
+import { Image360AnnotationFilter } from '../annotation/Image360AnnotationFilter';
+export declare class Image360RevisionEntity implements Image360Revision {
+    private readonly _imageProvider;
+    private readonly _image360Descriptor;
+    private readonly _image360VisualizationBox;
+    private _previewTextures;
+    private _fullResolutionTextures;
+    private _onFullResolutionCompleted;
+    private _defaultAppearance;
+    private _annotations;
+    private readonly _annotationFilterer;
+    constructor(imageProvider: Image360DataProvider, image360Descriptor: Image360Descriptor, image360VisualizationBox: Image360VisualizationBox, annotationFilterer: Image360AnnotationFilter);
+    /**
+     * The date of this revision. Undefined if the revision is undated.
+     * @returns Date | undefined
+     */
+    get date(): Date | undefined;
+    getAnnotations(): Promise<ImageAnnotationObject[]>;
+    intersectAnnotations(raycaster: THREE.Raycaster): ImageAnnotationObject | undefined;
+    /**
+     * Loads the textures needed for the 360 image (6 faces).
+     *
+     * This will start the download of both low and full resolution textures and return one promise for when each texture set is ready.
+     * If the low resolution images are completed first the full resolution download and texture loading will continue in the background,
+     * and applyFullResolutionTextures can be called to apply full resolution textures to the image360VisualizationBox at a desired time.
+     *
+     * @returns lowResolutionCompleted A promise for when the low resolution images are done loading.
+     * @returns fullResolutionCompleted A promise for when the full resolution images are done loading.
+     */
+    loadTextures(abortSignal?: AbortSignal): {
+        lowResolutionCompleted: Promise<void>;
+        fullResolutionCompleted: Promise<void>;
+    };
+    getPreviewThumbnailUrl(face?: 'front' | 'back' | 'left' | 'right' | 'top' | 'bottom'): Promise<string | undefined>;
+    private loadPreviewTextures;
+    private loadFullTextures;
+    private loadAndSetAnnotations;
+    setDefaultAppearance(appearance: Image360AnnotationAppearance): void;
+    private propagateDefaultAppearanceToAnnotations;
+    /**
+     * Clear the cached textures used by this revision.
+     */
+    dispose(): void;
+    /**
+     * Apply cached textures to the image360VisualizationBox.
+     */
+    applyTextures(): void;
+    /**
+     * Apply full resolution textures to the image360VisualizationBox.
+     * This has no effect if full resolution has already been applied.
+     */
+    applyFullResolutionTextures(): Promise<void>;
+    getDescriptors(): Image360Descriptor;
+}

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

@@ -2,25 +2,32 @@
  * Copyright 2022 Cognite AS
  */
 import * as THREE from 'three';
-import { SceneHandler } from '../../../utilities';
+import { DeviceDescriptor, SceneHandler } from '../../../utilities';
 import { Image360Face, Image360Texture } from '../../../data-providers';
 import { Image360Visualization } from './Image360Visualization';
+import { ImageAnnotationObject } from '../annotation/ImageAnnotationObject';
 export declare class Image360VisualizationBox implements Image360Visualization {
+    private readonly MAX_MOBILE_IMAGE_SIZE;
     private readonly _worldTransform;
     private _visualizationMesh;
     private _faceMaterials;
     private readonly _sceneHandler;
+    private readonly _device;
     private readonly _visualizationState;
     private readonly _textureLoader;
     private readonly _faceMaterialOrder;
+    private readonly _annotationsGroup;
     get opacity(): number;
     set opacity(alpha: number);
     get visible(): boolean;
     set visible(isVisible: boolean);
     set scale(newScale: THREE.Vector3);
     set renderOrder(newRenderOrder: number);
-    constructor(worldTransform: THREE.Matrix4, sceneHandler: SceneHandler);
-    loadImages(textures: Image360Texture[]): Promise<void>;
+    setAnnotations(annotations: ImageAnnotationObject[]): void;
+    constructor(worldTransform: THREE.Matrix4, sceneHandler: SceneHandler, device: DeviceDescriptor);
+    loadImages(textures: Image360Texture[]): void;
     loadFaceTextures(faces: Image360Face[]): Promise<Image360Texture[]>;
     unloadImages(): void;
+    private getScaledImageTexture;
+    setAnnotationsVisibility(visibility: boolean): void;
 }

package/dist/packages/360-images/src/icons/IconCollection.d.ts

@@ -3,16 +3,20 @@
  */
 import { Vector3 } from 'three';
 import { BeforeSceneRenderedDelegate, EventTrigger, SceneHandler } from '../../../utilities';
-import { Image360Icon } from './Image360Icon';
+import { Overlay3DIcon } from '../../../3d-overlays';
 export type IconCullingScheme = 'clustered' | 'proximity';
+export type IconsOptions = {
+    platformMaxPointsSize?: number;
+};
 export declare class IconCollection {
-    private readonly MIN_PIXEL_SIZE;
-    private readonly MAX_PIXEL_SIZE;
+    private static readonly MinPixelSize;
+    private static readonly DefaultMaxPixelSize;
+    private readonly _maxPixelSize;
     private readonly _sceneHandler;
-    private readonly _hoverIconTexture;
     private readonly _sharedTexture;
+    private readonly _hoverSprite;
     private readonly _icons;
-    private readonly _iconsSprite;
+    private readonly _pointsObject;
     private readonly _computeClustersEventHandler;
     private readonly _computeProximityPointsEventHandler;
     private readonly _onBeforeSceneRenderedEvent;
@@ -21,14 +25,16 @@ export declare class IconCollection {
     private _iconCullingScheme;
     private _proximityRadius;
     private _proximityPointLimit;
-    get icons(): Image360Icon[];
+    get icons(): Overlay3DIcon[];
+    set hoverSpriteVisibility(value: boolean);
     setCullingScheme(scheme: IconCullingScheme): void;
     set360IconCullingRestrictions(radius: number, pointLimit: number): void;
-    constructor(points: Vector3[], sceneHandler: SceneHandler, onBeforeSceneRendered: EventTrigger<BeforeSceneRenderedDelegate>);
+    constructor(points: Vector3[], sceneHandler: SceneHandler, onBeforeSceneRendered: EventTrigger<BeforeSceneRenderedDelegate>, iconOptions?: IconsOptions);
     private setIconClustersByLOD;
     private computeProximityPoints;
     private initializeImage360Icons;
     dispose(): void;
+    private createHoverSprite;
     private createOuterRingsTexture;
     private createHoverIconTexture;
 }

package/dist/packages/360-images/src/types.d.ts

@@ -2,10 +2,11 @@
  * Copyright 2023 Cognite AS
  */
 import { Image360 } from './entity/Image360';
+import { Image360Revision } from './entity/Image360Revision';
 /**
  * Delegate for 360 image mode entered events.
  */
-export type Image360EnteredDelegate = (image360: Image360) => void;
+export type Image360EnteredDelegate = (image360: Image360, revision: Image360Revision) => void;
 /**
  * Delegate for 360 image mode exited events.
  */

package/dist/packages/3d-overlays/index.d.ts

@@ -0,0 +1,9 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+export { Overlay3DCollection } from './src/Overlay3DCollection';
+export { OverlayPointsObject, OverlayPointsParameters } from './src/OverlayPointsObject';
+export { Overlay3DIcon } from './src/Overlay3DIcon';
+export { Overlay3D } from './src/Overlay3D';
+export { OverlayCollection, OverlayInfo, DefaultOverlay3DContentType } from './src/OverlayCollection';
+export { IconOctree } from './src/IconOctree';

package/dist/packages/{360-images/src/icons → 3d-overlays/src}/IconOctree.d.ts

@@ -3,13 +3,13 @@
  */
 import { Node, PointOctant, PointOctree } from 'sparse-octree';
 import { Box3, Matrix4 } from 'three';
-import { Image360Icon } from '../icons/Image360Icon';
-export declare class IconOctree extends PointOctree<Image360Icon> {
+import { Overlay3DIcon } from './Overlay3DIcon';
+export declare class IconOctree extends PointOctree<Overlay3DIcon> {
     private readonly _nodeCenters;
-    static getMinimalOctreeBoundsFromIcons(icons: Image360Icon[]): Box3;
-    constructor(icons: Image360Icon[], bounds: Box3, maxLeafSize: number);
-    getNodeIcon(node: Node): Image360Icon | undefined;
-    getLODByScreenArea(areaThreshold: number, projection: Matrix4, minimumLevel?: number): Set<PointOctant<Image360Icon>>;
+    static getMinimalOctreeBoundsFromIcons(icons: Overlay3DIcon[]): Box3;
+    constructor(icons: Overlay3DIcon[], bounds: Box3, maxLeafSize: number);
+    getNodeIcon(node: Node): Overlay3DIcon | undefined;
+    getLODByScreenArea(areaThreshold: number, projection: Matrix4, minimumLevel?: number): Set<PointOctant<Overlay3DIcon>>;
     private populateNodeCenters;
     private filterEmptyLeaves;
     private hasChildren;

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

@@ -0,0 +1,33 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { Color, Vector3 } from 'three';
+/**
+ * Represents one 3d overlay
+ */
+export interface Overlay3D<ContentType> {
+    /**
+     * Set whether this overlay should be visible.
+     * */
+    setVisible(visible: boolean): void;
+    /**
+     * Get whether this overlay is visible.
+     */
+    getVisible(): boolean;
+    /**
+     * Get the position of this overlay.
+     */
+    getPosition(): Vector3;
+    /**
+     * Set the display color of this overlay.
+     * */
+    setColor(color: Color): void;
+    /**
+     * Get the display color of this overlay.
+     * */
+    getColor(): Color;
+    /**
+     * Get the metadata associated with this overlay.
+     * */
+    getContent(): ContentType;
+}

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

@@ -0,0 +1,35 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { Color, Texture, Object3D } from 'three';
+import { Overlay3D } from './Overlay3D';
+import { DefaultOverlay3DContentType, OverlayCollection, OverlayInfo } from './OverlayCollection';
+export type Overlay3DCollectionOptions = {
+    overlayTexture?: Texture;
+    overlayTextureMask?: Texture;
+    maxPointSize?: number;
+    defaultOverlayColor?: Color;
+};
+export declare class Overlay3DCollection<MetadataType = DefaultOverlay3DContentType> extends Object3D implements OverlayCollection<MetadataType> {
+    private readonly MinPixelSize;
+    private readonly MaxPixelSize;
+    private readonly DefaultMaxPoints;
+    private readonly defaultOverlayColor;
+    private readonly _sharedTextures;
+    private readonly _overlayPoints;
+    private readonly _iconRadius;
+    private _overlays;
+    private _octree;
+    constructor(overlayInfos?: OverlayInfo<MetadataType>[], options?: Overlay3DCollectionOptions);
+    setVisibility(visibility: boolean): void;
+    getOverlays(): Overlay3D<MetadataType>[];
+    addOverlays(overlayInfos: OverlayInfo<MetadataType>[]): Overlay3D<MetadataType>[];
+    sortOverlaysRelativeToCamera(camera: THREE.Camera): void;
+    removeOverlays(overlays: Overlay3D<MetadataType>[]): void;
+    removeAllOverlays(): void;
+    private rebuildOctree;
+    private updatePointsObject;
+    private initializeOverlay3DIcons;
+    dispose(): void;
+    private createCircleTextures;
+}

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

@@ -0,0 +1,70 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { PerspectiveCamera, Ray, Vector3, Color } from 'three';
+import { Overlay3D } from './Overlay3D';
+import { DefaultOverlay3DContentType } from './OverlayCollection';
+export type IconParameters = {
+    position: THREE.Vector3;
+    color?: THREE.Color;
+    minPixelSize: number;
+    maxPixelSize: number;
+    iconRadius: number;
+    hoverSprite?: THREE.Sprite;
+};
+export type SetAdaptiveScaleDelegate = (args: {
+    camera: THREE.Camera;
+    renderSize: THREE.Vector2;
+    domElement: HTMLElement;
+}) => void;
+export type ParametersChangeDelegate = (event: {
+    color: THREE.Color;
+    visble: boolean;
+}) => void;
+export type SelectedDelegate = (event: {
+    selected: boolean;
+}) => void;
+export type IconEvent = 'selected' | 'parametersChange';
+export declare class Overlay3DIcon<ContentType = DefaultOverlay3DContentType> implements Overlay3D<ContentType> {
+    private readonly _position;
+    private readonly _minPixelSize;
+    private readonly _maxPixelSize;
+    private readonly _setAdaptiveScale;
+    private readonly _iconRadius;
+    private readonly _hoverSprite?;
+    private readonly _content;
+    private readonly _raycastBoundingSphere;
+    private _adaptiveScale;
+    private _visible;
+    private _culled;
+    private _selected;
+    private _color;
+    private readonly _ndcPosition;
+    private readonly _events;
+    constructor(iconParameters: IconParameters, content: ContentType);
+    on(event: 'selected', callback: SelectedDelegate): void;
+    on(event: 'parametersChange', callback: ParametersChangeDelegate): void;
+    off(event: 'selected', callback: SelectedDelegate): void;
+    off(event: 'parametersChange', callback: ParametersChangeDelegate): void;
+    set selected(newValue: boolean);
+    get selected(): boolean;
+    updateHoverSpriteScale(): void;
+    updateAdaptiveScale(delegateArguments: {
+        renderSize: THREE.Vector2;
+        camera: PerspectiveCamera;
+        domElement: HTMLElement;
+    }): void;
+    setColor(color: Color): void;
+    getColor(): Color;
+    getContent(): ContentType;
+    get adaptiveScale(): number;
+    set culled(culled: boolean);
+    get culled(): boolean;
+    setVisible(visible: boolean): void;
+    getVisible(): boolean;
+    getPosition(): Vector3;
+    intersect(ray: Ray): Vector3 | null;
+    dispose(): void;
+    private setupAdaptiveScaling;
+    private computeAdaptiveScaling;
+}

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

@@ -0,0 +1,55 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { Overlay3D } from './Overlay3D';
+/**
+ * The default metadata type contained in Overlays
+ */
+export type DefaultOverlay3DContentType = {
+    [key: string]: string;
+};
+/**
+ * Data used in creating an overlay.
+ */
+export type OverlayInfo<ContentType = DefaultOverlay3DContentType> = {
+    /**
+     * Position of the overlay
+     */
+    position: THREE.Vector3;
+    /**
+     * The data contained in this overlay
+     */
+    content: ContentType;
+    /**
+     * The color of this overlay. Will be set by collection if undefined
+     */
+    color?: THREE.Color;
+};
+/**
+ * A set of overlays managed.
+ */
+export interface OverlayCollection<ContentType> {
+    /**
+     * Get all overlays in the collection.
+     * */
+    getOverlays(): Overlay3D<ContentType>[];
+    /**
+     * Add overlays to the collection.
+     * @param overlays Overlays to add to the collection.
+     * @returns The added overlays.
+     */
+    addOverlays(overlays: OverlayInfo<ContentType>[]): Overlay3D<ContentType>[];
+    /**
+     * Remove overlays from the collection.
+     * @param overlays Overlays to remove from the collection.
+     */
+    removeOverlays(overlays: Overlay3D<ContentType>[]): void;
+    /**
+     * Remove all overlays from the collection.
+     */
+    removeAllOverlays(): void;
+    /**
+     * Sets whether overlays in the collection should be visible.
+     */
+    setVisibility(visibility: boolean): void;
+}

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

@@ -0,0 +1,27 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { Color, DepthModes, Group, Texture, Vector3 } from 'three';
+export type OverlayPointsParameters = {
+    spriteTexture: Texture;
+    maskTexture?: Texture;
+    minPixelSize: number;
+    maxPixelSize: number;
+    radius: number;
+    colorTint?: Color;
+    depthMode?: DepthModes;
+    collectionOpacity?: number;
+};
+export declare class OverlayPointsObject extends Group {
+    private readonly _geometry;
+    private readonly _frontMaterial;
+    private readonly _positionBuffer;
+    private readonly _positionAttribute;
+    private readonly _colorBuffer;
+    private readonly _colorAttribute;
+    constructor(maxNumberOfPoints: number, materialParameters: OverlayPointsParameters);
+    setPoints(points: Vector3[], colors?: Color[]): void;
+    dispose(): void;
+    private initializePoints;
+    private createIconsMaterial;
+}

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

@@ -2,36 +2,44 @@
  * Copyright 2022 Cognite AS
  */
 import * as THREE from 'three';
-import { CogniteClient } from '@cognite/sdk';
-import { Image360Collection, Image360Entity, Image360 } from '../../../360-images';
+import { CogniteClient, Metadata } from '@cognite/sdk';
+import { Image360Collection, Image360Entity, Image360, IconsOptions, Image360RevisionEntity, Image360AnnotationIntersection, Image360AnnotationFilterOptions } from '../../../360-images';
 import { BeforeSceneRenderedDelegate, EventTrigger, InputHandler, SceneHandler } from '../../../utilities';
 import { ProxyCameraManager } from '../../../camera-manager';
 export declare class Image360ApiHelper {
     private readonly _image360Facade;
     private readonly _domElement;
     private _transitionInProgress;
+    private readonly _raycaster;
+    private _needsRedraw;
+    private readonly _imageCollections;
     private readonly _interactionState;
     private readonly _eventHandlers;
     private readonly _debouncePreLoad;
-    private readonly _requestRedraw;
     private readonly _activeCameraManager;
     private readonly _image360Navigation;
     private readonly _onBeforeSceneRenderedEvent;
     private _cachedCameraManager;
-    constructor(cogniteClient: CogniteClient, sceneHandler: SceneHandler, domElement: HTMLElement, activeCameraManager: ProxyCameraManager, inputHandler: InputHandler, requestRedraw: () => void, onBeforeSceneRendered: EventTrigger<BeforeSceneRenderedDelegate>);
-    add360ImageSet(eventFilter: {
-        [key: string]: string;
-    }, collectionTransform: THREE.Matrix4, preMultipliedRotation: boolean): Promise<Image360Collection>;
+    constructor(cogniteClient: CogniteClient, sceneHandler: SceneHandler, domElement: HTMLElement, activeCameraManager: ProxyCameraManager, inputHandler: InputHandler, onBeforeSceneRendered: EventTrigger<BeforeSceneRenderedDelegate>, iconsOptions?: IconsOptions);
+    get needsRedraw(): boolean;
+    resetRedraw(): void;
+    private getNormalizedOffset;
+    add360ImageSet(eventFilter: Metadata, collectionTransform: THREE.Matrix4, preMultipliedRotation: boolean, annotationOptions?: Image360AnnotationFilterOptions): Promise<Image360Collection>;
+    getImageCollections(): Image360Collection[];
     remove360Images(entities: Image360[]): Promise<void>;
-    enter360Image(image360Entity: Image360Entity): Promise<void>;
+    remove360ImageCollection(collection: Image360Collection): void;
+    enter360Image(image360Entity: Image360Entity, revision?: Image360RevisionEntity): Promise<void>;
+    private applyFullResolutionTextures;
     private transition;
     private tweenVisualizationAlpha;
     private tweenVisualizationZoom;
     private set360CameraManager;
     exit360Image(): void;
     dispose(): void;
+    private findRevisionIdToEnter;
     private enter360ImageOnIntersect;
     intersect360ImageIcons(offsetX: number, offsetY: number): Image360Entity | undefined;
+    intersect360ImageAnnotations(offsetX: number, offsetY: number): Image360AnnotationIntersection | undefined;
     private setHoverIconOnIntersect;
     private exit360ImageOnEscape;
 }

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

@@ -5,12 +5,12 @@ import * as THREE from 'three';
 import { PointerEventDelegate, SceneRenderedDelegate, DisposedDelegate, BeforeSceneRenderedDelegate } from '../../../../utilities';
 import { CogniteCadModel } from '../../../../cad-model';
 import { PointCloudBudget, CognitePointCloudModel } from '../../../../pointclouds';
-import { AddImage360Options, AddModelOptions, Cognite3DViewerOptions, Intersection, CadModelBudget, ResolutionOptions } from './types';
+import { AddImage360Options, AddModelOptions, Cognite3DViewerOptions, Intersection, CadModelBudget, ResolutionOptions, RenderParameters } from './types';
 import { CogniteModel } from '../types';
 import { ViewerState } from '../../utilities/ViewStateHelper';
 import { CameraManager, CameraChangeDelegate, CameraStopDelegate } from '../../../../camera-manager';
 import { SupportedModelTypes } from '../../../../model-base';
-import { Image360Collection, Image360 } from '../../../../360-images';
+import { Image360Collection, Image360, Image360Revision, Image360AnnotationIntersection } from '../../../../360-images';
 /**
  * @example
  * ```js
@@ -35,6 +35,10 @@ export declare class Cognite3DViewer {
      * The DOM element cannot be changed after the viewer has been created.
      */
     get domElement(): HTMLElement;
+    /**
+     * Returns parameters of THREE.WebGLRenderer used by the viewer.
+     */
+    get renderParameters(): RenderParameters;
     /**
      * Returns the renderer used to produce images from 3D geometry.
      */
@@ -110,10 +114,10 @@ export declare class Cognite3DViewer {
     /**
      * Dispose of WebGL resources. Can be used to free up memory when the viewer is no longer in use.
      * @see {@link https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects}
-     * ```ts
+     * ```js
      * // Viewer is no longer in use, free up memory
      * viewer.dispose();
-     * ```.
+     * ```
      */
     dispose(): void;
     /**
@@ -181,7 +185,7 @@ export declare class Cognite3DViewer {
      */
     off(event: 'cameraStop', callback: CameraStopDelegate): void;
     /**
-     * Unsubscribe the 'beforeSceneRendered'-event previously subscribed with {@link on}.
+     * Unsubscribe the 'beforeSceneRendered'-event previously subscribed with {@link Cognite3DViewer.on}.
      */
     off(event: 'beforeSceneRendered', callback: BeforeSceneRenderedDelegate): void;
     /**
@@ -277,16 +281,27 @@ export declare class Cognite3DViewer {
     add360ImageSet(datasource: 'events', eventFilter: {
         [key: string]: string;
     }, add360ImageOptions?: AddImage360Options): Promise<Image360Collection>;
+    /**
+     * Returns a list of added 360 image collections.
+     */
+    get360ImageCollections(): Image360Collection[];
     /**
      * Remove a set of 360 images.
      * @param image360Entities
+     * @deprecated
      */
     remove360Images(...image360Entities: Image360[]): Promise<void>;
+    /**
+     * Removes a previously added 360 image collection from the viewer.
+     * @param imageCollection Collection to remove.
+     */
+    remove360ImageSet(imageCollection: Image360Collection): void;
     /**
      * Enter visualization of a 360 image.
-     * @param image360
+     * @param image360 The 360 image to enter.
+     * @param revision The image revision to use. If not provided the newest revision will be shown.
      */
-    enter360Image(image360: Image360): Promise<void>;
+    enter360Image(image360: Image360, revision?: Image360Revision): Promise<void>;
     /**
      * Exit visualization of the 360 image.
      */
@@ -558,6 +573,14 @@ export declare class Cognite3DViewer {
      * ```
      */
     getIntersectionFromPixel(offsetX: number, offsetY: number): Promise<null | Intersection>;
+    /**
+     * Check for intersections with 360 annotations through the given pixel.
+     * Similar to {getIntersectionFromPixel}, but checks 360 image annotations
+     * instead of models.
+     * @param offsetX
+     * @param offsetY
+     */
+    get360AnnotationIntersectionFromPixel(offsetX: number, offsetY: number): Promise<null | Image360AnnotationIntersection>;
     /** @private */
     private getModels;
     /**

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

@@ -8,6 +8,7 @@ import { CameraManager } from '../../../../camera-manager';
 import { GeometryFilter, CogniteCadModel } from '../../../../cad-model';
 import { DataSource } from '../../../../data-source';
 import { EdlOptions } from '../../../../rendering';
+import { Image360AnnotationFilterOptions } from '../../../../360-images';
 /**
  * Callback to monitor loaded requests and progress.
  * Use OnLoadingCallback instead of onProgress/onComplete.
@@ -18,6 +19,15 @@ import { EdlOptions } from '../../../../rendering';
  * @param itemsCulled Number of items deemed unnecessary to load in this batch.
  */
 export type OnLoadingCallback = (itemsLoaded: number, itemsRequested: number, itemsCulled: number) => void;
+/**
+ * Some parameters of THREE.WebGLRenderer initialized with {@link Cognite3DViewer}.
+ */
+export type RenderParameters = {
+    /**
+     * Current width and height of the renderer's output canvas, in pixels.
+     */
+    renderSize: THREE.Vector2;
+};
 /**
  * @module @cognite/reveal
  */
@@ -123,7 +133,7 @@ export interface Cognite3DViewerOptions {
      *
      * Note that the data source must support {@link CdfModelIdentifier}.
      *
-     * This cannot be used together with {@link _localModels}.
+     * This cannot be used together with {@link Cognite3DViewerOptions._localModels}.
      */
     customDataSource?: DataSource;
     /**
@@ -154,6 +164,10 @@ export type AddImage360Options = {
      * @default true
      */
     preMultipliedRotation?: boolean;
+    /**
+     * Annotation options.
+     */
+    annotationFilter?: Image360AnnotationFilterOptions;
 };
 export type CadIntersection = {
     /**

package/dist/packages/cad-geometry-loaders/src/sector/SectorLoader.d.ts

@@ -7,7 +7,7 @@ import { SectorCuller } from './culling/SectorCuller';
 import { ModelStateHandler } from './ModelStateHandler';
 /**
  * Loads sector based on a given camera pose, a set of models and budget.
- * Uses {@link SectorCuller} to determine what to load, {@link Repository} to
+ * Uses {@link SectorCuller} to determine what to load, {@link SectorDownloadScheduler} to
  * load sectors and {@link ModelStateHandler} to keep track of what has been
  * loaded to avoid loading data that's already available.
  *

package/dist/packages/cad-geometry-loaders/src/sector/culling/SectorCuller.d.ts

@@ -10,7 +10,8 @@ import { DetermineSectorsInput, SectorLoadingSpent } from './types';
 export interface SectorCuller {
     /**
      * Determine initial sector prioritization about what we think to load. This provides an initial guesstimate of
-     * what sectors we should load. Use {@link filterSectorsToLoad} to improve this estimate as new data is loaded.
+     * what sectors we should load. Use {@link SectorCuller.filterSectorsToLoad} to improve
+     * this estimate as new data is loaded.
      * @param input
      */
     determineSectors(input: DetermineSectorsInput): {
@@ -19,11 +20,11 @@ export interface SectorCuller {
     };
     /**
      * Evaluates if sectors provided should be loaded or not, e.g. based on geometry we have now loaded
-     * since {@link determineSectors} was called. This can be used to e.g. implement pre-load occlusion culling
-     * of sectors based on geometry that has been loaded.
+     * since {@link SectorCuller.determineSectors} was called. This can be used to e.g.
+     * implement pre-load occlusion culling of sectors based on geometry that has been loaded.
      *
-     * @param input Same input as used in {@link determineSectors}.
-     * @param wantedSectorsBatch A set of sectors from {@link determineSectors}, e.g. in batches of 5-10.
+     * @param input Same input as used in {@link SectorCuller.determineSectors}.
+     * @param wantedSectorsBatch A set of sectors from {@link SectorCuller.determineSectors}, e.g. in batches of 5-10.
      */
     filterSectorsToLoad(input: DetermineSectorsInput, wantedSectorsBatch: WantedSector[]): Promise<WantedSector[]>;
     /**

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

@@ -11,7 +11,7 @@ export type GeometryFilter = {
      * 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 isBoundingBoxInModelCoordinates}.
+     * @see {@link GeometryFilter.isBoundingBoxInModelCoordinates}.
      */
     boundingBox?: THREE.Box3;
     /**

package/dist/packages/cad-model/src/wrappers/CadNode.d.ts

@@ -20,8 +20,10 @@ export declare class CadNode extends Object3D {
     private readonly _batchedGeometryMeshGroup;
     private readonly _styledTreeIndexSets;
     private _needsRedraw;
+    readonly type = "CadNode";
     constructor(model: CadModelMetadata, materialManager: CadMaterialManager, sectorRepository: SectorRepository);
     get needsRedraw(): boolean;
+    resetRedraw(): void;
     get nodeTransformProvider(): NodeTransformProvider;
     get nodeAppearanceProvider(): NodeAppearanceProvider;
     get defaultNodeAppearance(): NodeAppearance;