@cognite/reveal 4.2.2 → 4.3.1-dev.20230605

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

@@ -2,10 +2,16 @@
  * Copyright 2022 Cognite AS
  */
 export { Image360 } from './src/entity/Image360';
-export { Image360Collection } from './src/collection/Image360Collection';
+export { Image360Revision } from './src/entity/Image360Revision';
+export { Image360Collection, Image360AnnotationAssetFilter, Image360AnnotationAssetQueryResult } from './src/collection/Image360Collection';
 export { Image360Facade } from './src/Image360Facade';
 export { Image360CollectionFactory } from './src/collection/Image360CollectionFactory';
 export { Image360Entity } from './src/entity/Image360Entity';
+export { Image360RevisionEntity } from './src/entity/Image360RevisionEntity';
 export { Image360Visualization } from './src/entity/Image360Visualization';
 export { Image360EnteredDelegate, Image360ExitedDelegate } from './src/types';
+export { Image360AnnotationAppearance, Image360AnnotationFilterOptions } from './src/annotation/types';
+export { Image360AnnotationIntersection } from './src/annotation/Image360AnnotationIntersection';
+export { Image360Annotation } from './src/annotation/Image360Annotation';
 export { DefaultImage360Collection } from './src/collection/DefaultImage360Collection';
+export { IconsOptions } from './src/icons/IconCollection';

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

@@ -6,6 +6,8 @@ import { Image360Entity } from './entity/Image360Entity';
 import { Image360CollectionFactory } from './collection/Image360CollectionFactory';
 import { DefaultImage360Collection } from './collection/DefaultImage360Collection';
 import { IconCullingScheme } from './icons/IconCollection';
+import { Image360RevisionEntity } from './entity/Image360RevisionEntity';
+import { Image360AnnotationFilterOptions } from './annotation/types';
 export declare class Image360Facade<T> {
     private readonly _entityFactory;
     private readonly _image360Collections;
@@ -13,16 +15,14 @@ export declare class Image360Facade<T> {
     private readonly _image360Cache;
     get collections(): DefaultImage360Collection[];
     set allIconsVisibility(visible: boolean);
-    set allHoverIconsVisibility(visible: boolean);
+    set allIconsSelected(visible: boolean);
+    set hoverIconVisibility(visible: boolean);
     set allIconCullingScheme(scheme: IconCullingScheme);
     constructor(_entityFactory: Image360CollectionFactory<T>);
-    create(dataProviderFilter: T, postTransform?: THREE.Matrix4, preComputedRotation?: boolean): Promise<DefaultImage360Collection>;
+    create(dataProviderFilter: T, annotationFilter?: Image360AnnotationFilterOptions, postTransform?: THREE.Matrix4, preComputedRotation?: boolean): Promise<DefaultImage360Collection>;
     delete(entity: Image360Entity): Promise<void>;
-    preload(entity: Image360Entity, lockDownload?: boolean): Promise<void>;
+    preload(entity: Image360Entity, revision: Image360RevisionEntity, lockDownload?: boolean): Promise<void>;
     getCollectionContainingEntity(entity: Image360Entity): DefaultImage360Collection;
-    intersect(coords: {
-        x: number;
-        y: number;
-    }, camera: THREE.Camera): Image360Entity | undefined;
+    intersect(coords: THREE.Vector2, camera: THREE.Camera): Image360Entity | undefined;
     dispose(): void;
 }

package/dist/packages/360-images/src/annotation/BoxAnnotationData.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { ImageAnnotationObjectData } from './ImageAnnotationData';
+import { BufferGeometry, Matrix4, PlaneGeometry, Vector2 } from 'three';
+import { AnnotationsBoundingBox } from '@cognite/sdk';
+export declare class BoxAnnotationData implements ImageAnnotationObjectData {
+    private readonly _geometry;
+    private readonly _initialTranslation;
+    private readonly _outline;
+    constructor(annotationsBox: AnnotationsBoundingBox);
+    createGeometry(annotationsBox: AnnotationsBoundingBox): PlaneGeometry;
+    getGeometry(): BufferGeometry;
+    getNormalizationMatrix(): Matrix4;
+    getOutlinePoints(): Vector2[];
+}

package/dist/packages/360-images/src/annotation/Image360Annotation.d.ts

@@ -0,0 +1,34 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { Color, Vector3 } from 'three';
+import { AnnotationModel } from '@cognite/sdk';
+/**
+ * An annotation associated with a 360 image revision
+ */
+export interface Image360Annotation {
+    /**
+     * The underlying CDF annotation
+     */
+    readonly annotation: AnnotationModel;
+    /**
+     * Get the individual display color of this annotation.
+     */
+    getColor(): Color;
+    /**
+     * Set the display color of this annotation. Default: Random, based on annotation label
+     */
+    setColor(color?: Color): void;
+    /**
+     * Get whether this annotation is visible
+     */
+    getVisible(): boolean;
+    /**
+     * Set whether this annotation should be visible. Default: true
+     */
+    setVisible(visible?: boolean): void;
+    /**
+     * Get center of annotation, to e.g. point the camera toward it
+     */
+    getCenter(out?: Vector3): Vector3;
+}

package/dist/packages/360-images/src/annotation/Image360AnnotationFilter.d.ts

@@ -0,0 +1,12 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { AnnotationModel } from '@cognite/sdk';
+import { Image360AnnotationFilterOptions } from './types';
+export declare class Image360AnnotationFilter {
+    private readonly _annotationFilter;
+    private fillDefaultAnnotationOptionValues;
+    constructor(options: Image360AnnotationFilterOptions);
+    private filterStatus;
+    filter(annotation: AnnotationModel): boolean;
+}

package/dist/packages/360-images/src/annotation/Image360AnnotationIntersection.d.ts

@@ -0,0 +1,22 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { Image360Annotation } from './Image360Annotation';
+import { Vector3 } from 'three';
+/**
+ * Describes an intersection with a 360 image annotation
+ */
+export type Image360AnnotationIntersection = {
+    /**
+     * The intersection type.
+     */
+    type: 'image360Annotation';
+    /**
+     * The intersected annotation
+     */
+    annotation: Image360Annotation;
+    /**
+     * The world direction from the camera to the intersection point
+     */
+    direction: Vector3;
+};

package/dist/packages/360-images/src/annotation/ImageAnnotationData.d.ts

@@ -0,0 +1,9 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { BufferGeometry, Matrix4, Vector2 } from 'three';
+export interface ImageAnnotationObjectData {
+    getGeometry(): BufferGeometry;
+    getOutlinePoints(): Vector2[];
+    getNormalizationMatrix(): Matrix4;
+}

package/dist/packages/360-images/src/annotation/ImageAnnotationObject.d.ts

@@ -0,0 +1,38 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { AnnotationModel } from '@cognite/sdk';
+import { Image360FileDescriptor } from '../../../data-providers';
+import { Color, Vector3, Object3D, Raycaster } from 'three';
+import { Image360Annotation } from './Image360Annotation';
+import { Image360AnnotationAppearance } from './types';
+type FaceType = Image360FileDescriptor['face'];
+export declare class ImageAnnotationObject implements Image360Annotation {
+    private readonly _annotation;
+    private readonly _mesh;
+    private readonly _meshMaterial;
+    private readonly _line;
+    private readonly _objectGroup;
+    private _defaultAppearance;
+    private readonly _appearance;
+    get annotation(): AnnotationModel;
+    static createAnnotationObject(annotation: AnnotationModel, face: FaceType): ImageAnnotationObject | undefined;
+    private static createObjectData;
+    private static createObjectDetectionAnnotationData;
+    private static createAssetLinkAnnotationData;
+    private constructor();
+    private getRotationFromFace;
+    private initializeTransform;
+    getObject(): Object3D;
+    intersects(raycaster: Raycaster): boolean;
+    private updateMaterials;
+    setDefaultStyle(appearance: Image360AnnotationAppearance): void;
+    private getColorReference;
+    getColor(): Color;
+    setColor(color?: Color): void;
+    getVisible(): boolean;
+    setVisible(visible?: boolean): void;
+    dispose(): void;
+    getCenter(out?: Vector3): Vector3;
+}
+export {};

package/dist/packages/360-images/src/annotation/PolygonAnnotationData.d.ts

@@ -0,0 +1,15 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { BufferGeometry, Matrix4, ShapeGeometry, Vector2 } from 'three';
+import { AnnotationsPolygon } from '@cognite/sdk';
+import { ImageAnnotationObjectData } from './ImageAnnotationData';
+export declare class PolygonAnnotationData implements ImageAnnotationObjectData {
+    private readonly _geometry;
+    private readonly _outlinePoints;
+    constructor(polygon: AnnotationsPolygon);
+    createGeometry(polygon: AnnotationsPolygon): ShapeGeometry;
+    getGeometry(): BufferGeometry;
+    getNormalizationMatrix(): Matrix4;
+    getOutlinePoints(): Vector2[];
+}

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

@@ -0,0 +1,28 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { AnnotationStatus } from '@cognite/sdk';
+import { Color } from 'three';
+/**
+ * The appearance of a 360 image annotation
+ */
+export type Image360AnnotationAppearance = {
+    /**
+     * The color of the annotation. Default: Random, based on annotation label
+     */
+    color?: Color;
+    /**
+     * Whether the annotation is visible. Default: true
+     */
+    visible?: boolean;
+};
+/**
+ * Options for loading annotations in 360 images
+ */
+export type Image360AnnotationFilterOptions = {
+    /**
+     * Allow annotations matching this/these statuses. 'all' will match  all annotations
+     * @default 'approved'
+     */
+    status?: 'all' | AnnotationStatus | AnnotationStatus[];
+};

package/dist/packages/360-images/src/cache/Image360LoadingCache.d.ts

@@ -2,15 +2,17 @@
  * Copyright 2022 Cognite AS
  */
 import { Image360Entity } from '../entity/Image360Entity';
+import { Image360RevisionEntity } from '../entity/Image360RevisionEntity';
 export type DownloadRequest = {
     entity: Image360Entity;
-    firstCompleted: Promise<void>;
-    fullResolutionCompleted: Promise<void>;
+    revision: Image360RevisionEntity;
+    anyCompleted: Promise<void>;
+    allCompleted: Promise<void>;
     abort: () => void;
 };
 export type Loaded360Image = {
     entity: Image360Entity;
-    isFullResolution: boolean;
+    revision: Image360RevisionEntity;
 };
 export declare class Image360LoadingCache {
     private readonly _imageCacheSize;
@@ -18,13 +20,17 @@ export declare class Image360LoadingCache {
     private readonly _loaded360Images;
     private readonly _inProgressDownloads;
     private _lockedDownload;
-    get cachedEntities(): Image360Entity[];
+    get cachedRevisions(): Image360RevisionEntity[];
     get currentlyLoadingEntities(): DownloadRequest[];
-    getDownloadInProgress(entity: Image360Entity): DownloadRequest | undefined;
+    getDownloadInProgress(revision: Image360RevisionEntity): DownloadRequest | undefined;
     constructor(_imageCacheSize?: number, _downloadCacheSize?: number);
-    cachedPreload(entity: Image360Entity, lockDownload?: boolean): Promise<void>;
+    cachedPreload(entity: Image360Entity, revision: Image360RevisionEntity, lockDownload?: boolean): Promise<void>;
     purge(entity: Image360Entity): Promise<void>;
-    private addEntityToCache;
-    private abortLastRecentlyReqestedEntity;
+    private cacheWhenAllComplete;
+    private purgeFromInProgressDownloads;
+    private addRevisionToCache;
+    private abortLastRecentlyReqestedRevision;
+    private purgeRevision;
     private createAbortSignal;
+    private isRevisionVisible;
 }

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

@@ -2,10 +2,13 @@
  * Copyright 2023 Cognite AS
  */
 import { EventTrigger } from '../../../utilities';
-import { Image360Collection } from './Image360Collection';
+import { Image360AnnotationAssetFilter, Image360AnnotationAssetQueryResult, Image360Collection } from './Image360Collection';
 import { Image360Entity } from '../entity/Image360Entity';
 import { Image360EnteredDelegate, Image360ExitedDelegate } from '../types';
 import { IconCollection, IconCullingScheme } from '../icons/IconCollection';
+import { Image360AnnotationAppearance } from '../annotation/types';
+import { IdEither } from '@cognite/sdk';
+import { Image360DataProvider } from '../../../data-providers';
 /**
  * Default implementation of {@link Image360Collection}. Used for events when entering
  * and exiting 360 image mode
@@ -15,11 +18,23 @@ export declare class DefaultImage360Collection implements Image360Collection {
      * A list containing all the 360 images in this set.
      */
     readonly image360Entities: Image360Entity[];
+    /**
+     * If defined, any subsequently entered 360 images will load the revision that are closest to the target date.
+     * If undefined, the most recent revision will be loaded.
+     */
+    private _targetRevisionDate;
+    private _needsRedraw;
+    private _defaultStyle;
+    private readonly _image360DataProvider;
     private readonly _events;
     private readonly _icons;
     private _isCollectionVisible;
     private readonly _collectionId;
+    private readonly _collectionLabel;
     get id(): string;
+    get label(): string | undefined;
+    get targetRevisionDate(): Date | undefined;
+    set targetRevisionDate(date: Date | undefined);
     /**
      * The events from the image collection.
      */
@@ -28,7 +43,7 @@ export declare class DefaultImage360Collection implements Image360Collection {
         image360Exited: EventTrigger<Image360ExitedDelegate>;
     };
     get isCollectionVisible(): boolean;
-    constructor(collectionId: string, entities: Image360Entity[], icons: IconCollection);
+    constructor(collectionId: string, collectionLabel: string | undefined, entities: Image360Entity[], icons: IconCollection, image360DataProvider: Image360DataProvider);
     /**
      * Subscribes to events on 360 Image datasets. There are several event types:
      * 'image360Entered' - Subscribes to a event for entering 360 image mode.
@@ -56,8 +71,15 @@ export declare class DefaultImage360Collection implements Image360Collection {
      */
     off(event: 'image360Entered', callback: Image360EnteredDelegate): void;
     off(event: 'image360Exited', callback: Image360ExitedDelegate): void;
+    setSelectedForAll(selected: boolean): void;
     setSelectedVisibility(visible: boolean): void;
     setCullingScheme(scheme: IconCullingScheme): void;
     remove(entity: Image360Entity): void;
     dispose(): void;
+    get needsRedraw(): boolean;
+    resetRedraw(): void;
+    getDefaultAnnotationStyle(): Image360AnnotationAppearance;
+    setDefaultAnnotationStyle(defaultStyle: Image360AnnotationAppearance): void;
+    findImageAnnotations(filter: Image360AnnotationAssetFilter): Promise<Image360AnnotationAssetQueryResult[]>;
+    getAssetIds(): Promise<IdEither[]>;
 }

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

@@ -3,14 +3,59 @@
  */
 import { Image360 } from './../entity/Image360';
 import { Image360EnteredDelegate, Image360ExitedDelegate } from '../types';
+import { Image360AnnotationAppearance } from '../annotation/types';
+import { Image360Revision } from '../entity/Image360Revision';
+import { IdEither } from '@cognite/sdk';
+import { Image360Annotation } from '../annotation/Image360Annotation';
+/**
+ * Filter for finding annotations related to an asset
+ */
+export type Image360AnnotationAssetFilter = {
+    /**
+     * Reference to the wanted asset
+     */
+    assetRef: IdEither;
+};
+/**
+ * Result item from an asset annotation query
+ */
+export type Image360AnnotationAssetQueryResult = {
+    /**
+     * The Image360 to which the result annotation belongs
+     */
+    image: Image360;
+    /**
+     * The image revision to which the result annotation belongs
+     */
+    revision: Image360Revision;
+    /**
+     * The found annotation
+     */
+    annotation: Image360Annotation;
+};
 /**
  * A wrapper that represents a set of 360 images.
  */
 export interface Image360Collection {
+    /**
+     * The id of the collection.
+     * @returns The id of the collection.
+     */
+    readonly id: string;
+    /**
+     * The label of the collection.
+     * @returns The label of the collection.
+     */
+    readonly label: string | undefined;
     /**
      * A list containing all the 360 images in this set.
      */
     readonly image360Entities: Image360[];
+    /**
+     * If defined, any subsequently entered 360 images will load the revision that are closest to the target date.
+     * If undefined, the most recent revision will be loaded.
+     */
+    targetRevisionDate: Date | undefined;
     /**
      * Specify parameters used to determine the number of icons that are visible when entering 360 Images.
      * @param radius Only icons within the given radius will be made visible.
@@ -38,4 +83,20 @@ export interface Image360Collection {
      */
     off(event: 'image360Entered', callback: Image360EnteredDelegate): void;
     off(event: 'image360Exited', callback: Image360ExitedDelegate): void;
+    /**
+     * Get the assigned default style affecting all annotations
+     */
+    getDefaultAnnotationStyle(): Image360AnnotationAppearance;
+    /**
+     * Assign a default style which affects all annotations
+     */
+    setDefaultAnnotationStyle(appearance: Image360AnnotationAppearance): void;
+    /**
+     * Find 360 images associated with an asset through CDF annotations
+     */
+    findImageAnnotations(filter: Image360AnnotationAssetFilter): Promise<Image360AnnotationAssetQueryResult[]>;
+    /**
+     * Get IDs of all CDF assets associated with this 360 image collection through CDF annotations
+     */
+    getAssetIds(): Promise<IdEither[]>;
 }

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

@@ -4,11 +4,14 @@
 import { Image360Provider } from '../../../data-providers';
 import { BeforeSceneRenderedDelegate, DeviceDescriptor, EventTrigger, SceneHandler } from '../../../utilities';
 import { DefaultImage360Collection } from './DefaultImage360Collection';
+import { IconsOptions } from '../icons/IconCollection';
+import { Image360AnnotationFilterOptions } from '../annotation/types';
 export declare class Image360CollectionFactory<T> {
     private readonly _image360DataProvider;
     private readonly _sceneHandler;
     private readonly _onBeforeSceneRendered;
+    private readonly _iconsOptions;
     private readonly _device;
-    constructor(image360DataProvider: Image360Provider<T>, sceneHandler: SceneHandler, onBeforeSceneRendered: EventTrigger<BeforeSceneRenderedDelegate>, device: DeviceDescriptor);
-    create(dataProviderFilter: T, postTransform: THREE.Matrix4, preMultipliedRotation: boolean): Promise<DefaultImage360Collection>;
+    constructor(image360DataProvider: Image360Provider<T>, sceneHandler: SceneHandler, onBeforeSceneRendered: EventTrigger<BeforeSceneRenderedDelegate>, device: DeviceDescriptor, iconsOptions?: IconsOptions);
+    create(dataProviderFilter: T, postTransform: THREE.Matrix4, preMultipliedRotation: boolean, annotationFilter: Image360AnnotationFilterOptions): Promise<DefaultImage360Collection>;
 }

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

@@ -1,7 +1,12 @@
 /*!
  * Copyright 2022 Cognite AS
  */
+import { Image360Revision } from './Image360Revision';
 import { Image360Visualization } from './Image360Visualization';
+/**
+ * A single 360 image "station", which may consist of several revisions
+ * captured in approximately the same location
+ */
 export interface Image360 {
     /**
      * Get a copy of the model-to-world transformation matrix
@@ -14,4 +19,24 @@ export interface Image360 {
      * @returns Image360Visualization
      */
     readonly image360Visualization: Image360Visualization;
+    /**
+     * Get Id of 360 image entity.
+     * @returns Station Id
+     */
+    readonly id: string;
+    /**
+     * Get label of 360 image entity.
+     * @returns Station label
+     * */
+    readonly label: string | undefined;
+    /**
+     * List all historical images for this entity.
+     * @returns A list of available revisions.
+     */
+    getRevisions(): Image360Revision[];
+    /**
+     * Get the revision that is currently loaded for this entry.
+     * @returns The active revision.
+     */
+    getActiveRevision(): Image360Revision;
 }

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

@@ -1,19 +1,22 @@
 /*!
  * Copyright 2022 Cognite AS
  */
-import * as THREE from 'three';
-import { Image360Descriptor, Image360FileProvider } from '../../../data-providers';
 import { DeviceDescriptor, SceneHandler } from '../../../utilities';
-import { Image360Icon } from '../icons/Image360Icon';
-import { Image360VisualizationBox } from './Image360VisualizationBox';
+import { Image360DataProvider } from '../../../data-providers';
 import { Image360 } from './Image360';
+import { Historical360ImageSet } from '../../../data-providers/src/types';
+import { Image360RevisionEntity } from './Image360RevisionEntity';
+import { Image360VisualizationBox } from './Image360VisualizationBox';
+import { ImageAnnotationObject } from '../annotation/ImageAnnotationObject';
+import { Overlay3DIcon } from '../../../3d-overlays';
+import { Image360AnnotationFilter } from '../annotation/Image360AnnotationFilter';
 export declare class Image360Entity implements Image360 {
-    private readonly _imageProvider;
-    private readonly _image360Metadata;
+    private readonly _revisions;
+    private readonly _imageMetadata;
     private readonly _transform;
     private readonly _image360Icon;
-    private readonly _image360VisualzationBox;
-    private _getFullResolutionTextures;
+    private readonly _image360VisualizationBox;
+    private _activeRevision;
     /**
      * Get a copy of the model-to-world transformation matrix
      * of the given 360 image.
@@ -25,37 +28,48 @@ export declare class Image360Entity implements Image360 {
      * image during normal visualization.
      * @returns Image360Icon
      */
-    get icon(): Image360Icon;
+    get icon(): Overlay3DIcon;
     /**
      * The object containing the unit cube with the 360 images.
      * @returns Image360Visualization
      */
     get image360Visualization(): Image360VisualizationBox;
-    constructor(image360Metadata: Image360Descriptor, sceneHandler: SceneHandler, imageProvider: Image360FileProvider, transform: THREE.Matrix4, icon: Image360Icon, device: DeviceDescriptor);
     /**
-     * Loads the 360 image (6 faces) into the visualization object.
-     *
-     * This will start the download of both low and full resolution images and return one promise for when the first image set is ready
-     * and one promise for when both downloads are completed. If the low resolution images are completed first the full resolution
-     * download and texture loading will continue in the background, and applyFullResolution can be used to apply full resolution textures
-     * to the image360VisualzationBox at a desired time.
-     *
-     * @returns firstCompleted A promise for when the first set om images has been loaded and applied to the image360VisualzationBox.
-     * @returns fullResolutionCompleted A promise for when full resolution images are done loading.
+     * Get Id of 360 image entity.
+     * @returns Station Id
+     */
+    get id(): string;
+    /**
+     * Get label of 360 image entity.
+     * @returns Station label
+     * */
+    get label(): string | undefined;
+    constructor(image360Metadata: Historical360ImageSet, sceneHandler: SceneHandler, imageProvider: Image360DataProvider, annotationFilterer: Image360AnnotationFilter, transform: THREE.Matrix4, icon: Overlay3DIcon, device: DeviceDescriptor);
+    /**
+     * List all historical images for this entity.
+     * @returns A list of available revisions.
+     */
+    getRevisions(): Image360RevisionEntity[];
+    /**
+     * Get the revision that is currently loaded for this entry.
+     * @returns Returns the active revision.
      */
-    load360Image(abortSignal?: AbortSignal): {
-        firstCompleted: Promise<void>;
-        fullResolutionCompleted: Promise<void>;
-    };
+    getActiveRevision(): Image360RevisionEntity;
+    setActiveRevision(revision: Image360RevisionEntity): void;
+    applyFullResolutionTextures(): Promise<void>;
+    getMostRecentRevision(): Image360RevisionEntity;
     /**
-     * Apply full resolution textures to the image360VisualzationBox. This has no effect if full resolution has already been applied.
+     * Get the revision closest to the provided date.
+     * If all revisions are undated the first available revison is returned.
      */
-    applyFullResolution(): Promise<void>;
+    getRevisionClosestToDate(date: Date): Image360RevisionEntity;
+    intersectAnnotations(raycaster: THREE.Raycaster): ImageAnnotationObject | undefined;
     /**
      * Drops the GPU resources for the 360 image
-     * the icon will be preserved.
      */
-    unload360Image(): void;
+    unloadImage(): void;
+    activateAnnotations(): void;
+    deactivateAnnotations(): void;
     /**
      * @obvious
      */

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

@@ -0,0 +1,23 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { Image360Annotation } from '../annotation/Image360Annotation';
+/**
+ * Interface used to manage historical revisions of {@link Image360}.
+ * One instance represents one specific image revision.
+ */
+export interface Image360Revision {
+    /**
+     * The date of this revision. Undefined if the revision is undated.
+     * @returns Date | undefined
+     */
+    readonly date: Date | undefined;
+    /**
+     * The annotations associated with this revision.
+     */
+    getAnnotations(): Promise<Image360Annotation[]>;
+    /**
+     * Get the thumbnail url for this revision.
+     */
+    getPreviewThumbnailUrl(): Promise<string | undefined>;
+}