@cornerstonejs/core 5.0.16 → 5.1.1

package/dist/esm/RenderingEngine/GenericViewport/ViewportArchitectureTypes.d.ts

@@ -3,7 +3,7 @@ import type { ReferenceCompatibleOptions, ViewReference, ViewReferenceSpecifier
 import type ViewportType from '../../enums/ViewportType';
 import type ResolvedViewportView from './ResolvedViewportView';
 export type ViewportId = string;
-export type DataId = string;
+export type DisplaySetId = string;
 export type KnownViewportRenderContext = 'planar' | 'video' | 'ecg' | 'wsi' | '3d';
 export type ExtensionViewportRenderContext = string & {};
 export type ViewportRenderContextType = KnownViewportRenderContext | ExtensionViewportRenderContext;
@@ -36,7 +36,7 @@ export interface BasePresentationProps {
     opacity?: number;
 }
 export type LoadedData<TData extends object = object> = {
-    id: DataId;
+    id: DisplaySetId;
     type: LogicalDataType;
 } & TData;
 export type MountedRendering<TRendering extends {
@@ -75,7 +75,7 @@ export interface RenderPathResolver {
     resolve<TContext extends BaseViewportRenderContext>(type: ViewportType, data: LoadedData, options: DataAddOptions): RenderPathDefinition<TContext, BaseViewportRenderContext>;
 }
 export interface DataProvider<TData extends object = object, TOptions = unknown> {
-    load(dataId: DataId, options?: TOptions): Promise<LoadedData<TData>>;
+    load(dataId: DisplaySetId, options?: TOptions): Promise<LoadedData<TData>>;
 }
 export interface ViewportDataBinding<TPresentation = unknown> extends RenderPathAttachment<TPresentation> {
     data: LoadedData;
@@ -84,20 +84,24 @@ export interface ViewportDataBinding<TPresentation = unknown> extends RenderPath
 export interface ViewportController<TViewState = unknown, TDataPresentation = unknown> {
     readonly id: ViewportId;
     readonly type: ViewportType;
-    addDisplaySet(displaySetId: DataId, options: DataAddOptions): Promise<void>;
+    addDisplaySet(displaySetId: DisplaySetId, options: DataAddOptions): Promise<void>;
     setDisplaySets(...entries: Array<{
-        displaySetId: DataId;
+        displaySetId: DisplaySetId;
         options?: unknown;
     }>): Promise<void>;
-    removeData(dataId: DataId): void;
+    getDisplaySets(): Array<{
+        displaySetId: DisplaySetId;
+        options?: unknown;
+    }>;
+    removeData(displaySetId: DisplaySetId): void;
     setViewState(viewState: Partial<TViewState>): void;
     getViewState(): TViewState;
     getResolvedView(): ResolvedViewportView<unknown, ICamera<unknown>> | undefined;
     updateViewState(updater: Partial<TViewState> | ((viewState: TViewState) => Partial<TViewState> | void)): void;
     resetViewState(options?: unknown): boolean;
     setDisplaySetPresentation(props: Partial<TDataPresentation>): void;
-    setDisplaySetPresentation(displaySetId: DataId, props: Partial<TDataPresentation>): void;
-    getDisplaySetPresentation(dataId: DataId): TDataPresentation | undefined;
+    setDisplaySetPresentation(displaySetId: DisplaySetId, props: Partial<TDataPresentation>): void;
+    getDisplaySetPresentation(displaySetId: DisplaySetId): TDataPresentation | undefined;
     setViewReference(viewReference: ViewReference): void;
     getViewReference(specifier?: ViewReferenceSpecifier): ViewReference;
     getViewReferenceId(specifier?: ViewReferenceSpecifier): string;

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/DefaultVolume3DDataProvider.js

@@ -2,7 +2,7 @@ import cache from '../../../cache/cache';
 import { loadAndCacheGeometry } from '../../../loaders/geometryLoader';
 import { createAndCacheVolume } from '../../../loaders/volumeLoader';
 import resolveViewportVolumeId from '../../helpers/resolveViewportVolumeId';
-import { getGenericViewportImageDataSet, isGenericViewportImageDataSet, } from '../genericViewportDataSetAccess';
+import { getGenericViewportImageDisplaySet, isGenericViewportImageDisplaySet, } from '../genericViewportDisplaySetAccess';
 export class DefaultVolume3DDataProvider {
     async load(dataId, options) {
         if (!options) {
@@ -39,7 +39,7 @@ export class DefaultVolume3DDataProvider {
         };
     }
     getDataSet(dataId) {
-        const dataSet = getGenericViewportImageDataSet(dataId);
+        const dataSet = getGenericViewportImageDisplaySet(dataId);
         if (!isVolume3DRegisteredDataSet(dataSet)) {
             return;
         }
@@ -47,7 +47,7 @@ export class DefaultVolume3DDataProvider {
     }
 }
 function isVolume3DRegisteredDataSet(value) {
-    if (!isGenericViewportImageDataSet(value)) {
+    if (!isGenericViewportImageDisplaySet(value)) {
         return false;
     }
     return ((value.geometryId === undefined || typeof value.geometryId === 'string') &&

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/VolumeViewport3DLegacyAdapter.js

@@ -3,7 +3,7 @@ import { VIEWPORT_PRESETS } from '../../../constants';
 import { Events } from '../../../enums';
 import applyPreset from '../../../utilities/applyPreset';
 import triggerEvent from '../../../utilities/triggerEvent';
-import genericViewportDataSetMetadataProvider from '../../../utilities/genericViewportDataSetMetadataProvider';
+import genericViewportDisplaySetMetadataProvider from '../../../utilities/genericViewportDisplaySetMetadataProvider';
 import { viewportProjection } from '../viewportProjection';
 import VolumeViewport3D from './viewport3D';
 class VolumeViewport3DLegacyAdapter extends VolumeViewport3D {
@@ -142,7 +142,7 @@ class VolumeViewport3DLegacyAdapter extends VolumeViewport3D {
                     imageIds: cachedVolume.imageIds,
                     volumeId: volumeInput.volumeId,
                 };
-                genericViewportDataSetMetadataProvider.add(dataId, dataSet);
+                genericViewportDisplaySetMetadataProvider.add(dataId, dataSet);
                 this.managedDataIds.add(dataId);
                 this.volumeDataIds.set(volumeInput.volumeId, dataId);
                 dataIds.push(dataId);
@@ -268,7 +268,7 @@ class VolumeViewport3DLegacyAdapter extends VolumeViewport3D {
         if (!this.managedDataIds.delete(dataId)) {
             return;
         }
-        genericViewportDataSetMetadataProvider.remove(dataId);
+        genericViewportDisplaySetMetadataProvider.remove(dataId);
         this.legacyProperties.delete(dataId);
         this.defaultLegacyProperties.delete(dataId);
         for (const [volumeId, mappedDataId] of this.volumeDataIds.entries()) {
@@ -279,7 +279,7 @@ class VolumeViewport3DLegacyAdapter extends VolumeViewport3D {
     }
     onDestroy() {
         for (const dataId of Array.from(this.managedDataIds)) {
-            genericViewportDataSetMetadataProvider.remove(dataId);
+            genericViewportDisplaySetMetadataProvider.remove(dataId);
         }
         this.managedDataIds.clear();
         this.volumeDataIds.clear();

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/viewport3D.d.ts

@@ -41,7 +41,11 @@ declare class VolumeViewport3D extends GenericViewport<Volume3DCamera, Volume3DD
     getImageData(): IImageData | undefined;
     getActors(): ActorEntry[];
     getDefaultActor(): ActorEntry | undefined;
-    resetViewState(): boolean;
+    resetViewState(options?: {
+        resetPan?: boolean;
+        resetZoom?: boolean;
+        resetToCenter?: boolean;
+    }): boolean;
     resetViewStateForResize(): boolean;
     resize(): void;
     render(): void;

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/viewport3D.js

@@ -3,7 +3,7 @@ import { ViewportType } from '../../../enums';
 import renderingEngineCache from '../../renderingEngineCache';
 import GenericViewport from '../GenericViewport';
 import { getDimensionGroupReferenceContext, } from '../genericViewportReferenceCompatibility';
-import { getGenericViewportImageDataSet, isGenericViewportImageDataSet, } from '../genericViewportDataSetAccess';
+import { getGenericViewportImageDisplaySet, isGenericViewportImageDisplaySet, } from '../genericViewportDisplaySetAccess';
 import { DefaultVolume3DDataProvider } from './DefaultVolume3DDataProvider';
 import { createVolume3DRenderPathResolver } from './Volume3DRenderPathResolver';
 import Volume3DResolvedView from './Volume3DResolvedView';
@@ -25,6 +25,7 @@ class VolumeViewport3D extends GenericViewport {
         this.suppressEvents = false;
         this.renderingEngineId = args.renderingEngineId;
         this.canvas = args.canvas;
+        this.canvas.style.display = '';
         this.sWidth = args.sWidth;
         this.sHeight = args.sHeight;
         this.defaultOptions = args.defaultOptions || {};
@@ -230,11 +231,24 @@ class VolumeViewport3D extends GenericViewport {
         }
         return this.getActorEntriesForRendering(this.getVolume3DRendering(binding), data)[0];
     }
-    resetViewState() {
+    resetViewState(options) {
+        const { resetPan = true, resetZoom = true, resetToCenter = true, } = options || {};
         const previousCamera = this.getCameraForEvent();
         const renderer = this.getRenderer();
+        const camera = renderer.getActiveCamera();
+        const previousParallelScale = camera.getParallelScale();
+        const previousPosition = camera.getPosition();
+        const previousFocalPoint = camera.getFocalPoint();
         renderer.resetCamera();
         renderer.resetCameraClippingRange();
+        if (!resetZoom) {
+            camera.setParallelScale(previousParallelScale);
+        }
+        if (!resetPan || !resetToCenter) {
+            camera.setFocalPoint(...previousFocalPoint);
+            camera.setPosition(...previousPosition);
+            renderer.resetCameraClippingRange();
+        }
         this.viewState = this.getViewState();
         this.render();
         this.triggerCameraModifiedEvent(previousCamera);
@@ -322,7 +336,7 @@ class VolumeViewport3D extends GenericViewport {
         return 'vtkGeometry3d';
     }
     getDataSet(dataId) {
-        const dataSet = getGenericViewportImageDataSet(dataId);
+        const dataSet = getGenericViewportImageDisplaySet(dataId);
         if (!isVolume3DRegisteredDataSet(dataSet)) {
             return;
         }
@@ -388,7 +402,7 @@ function isVolume3DRendering(rendering) {
         rendering.renderMode === 'vtkGeometry3d');
 }
 function isVolume3DRegisteredDataSet(value) {
-    if (!isGenericViewportImageDataSet(value)) {
+    if (!isGenericViewportImageDisplaySet(value)) {
         return false;
     }
     return ((value.geometryId === undefined || typeof value.geometryId === 'string') &&

package/dist/esm/RenderingEngine/GenericViewport/WSI/DefaultWSIDataProvider.js

@@ -1,5 +1,5 @@
 import { addWSIMiniNavigationOverlayCss, loadWSIData, } from '../../../utilities/WSIUtilities';
-import { getGenericViewportWSIDataSet } from '../genericViewportDataSetAccess';
+import { getGenericViewportWSIDisplaySet } from '../genericViewportDisplaySetAccess';
 export class DefaultWSIDataProvider {
     async load(dataId) {
         const dataSet = this.getDataSet(dataId);
@@ -26,7 +26,7 @@ export class DefaultWSIDataProvider {
         };
     }
     getDataSet(dataId) {
-        const registered = getGenericViewportWSIDataSet(dataId);
+        const registered = getGenericViewportWSIDisplaySet(dataId);
         if (!registered) {
             return;
         }

package/dist/esm/RenderingEngine/GenericViewport/WSI/WSIViewportLegacyAdapter.js

@@ -1,6 +1,6 @@
 import { MetadataModules } from '../../../enums';
 import * as metaData from '../../../metaData';
-import genericViewportDataSetMetadataProvider from '../../../utilities/genericViewportDataSetMetadataProvider';
+import genericViewportDisplaySetMetadataProvider from '../../../utilities/genericViewportDisplaySetMetadataProvider';
 import { viewportProjection } from '../viewportProjection';
 import { canvasToIndexForWSI } from './wsiTransformUtils';
 import WSIViewport from './WSIViewport';
@@ -63,7 +63,7 @@ class WSIViewportLegacyAdapter extends WSIViewport {
         if (!webClient) {
             throw new Error(`To use setDataIds on WSI data, you must provide metaData.webClient for ${dataId}.`);
         }
-        genericViewportDataSetMetadataProvider.add(dataId, {
+        genericViewportDisplaySetMetadataProvider.add(dataId, {
             imageIds,
             kind: 'wsi',
             options: {

package/dist/esm/RenderingEngine/GenericViewport/genericViewportDisplaySetAccess.d.ts

@@ -0,0 +1,35 @@
+import type { IImage } from '../../types';
+import type { WSIClientLike } from '../../utilities/WSIUtilities';
+import type { ViewportDataReference } from './ViewportArchitectureTypes';
+export interface GenericViewportImageDisplaySet {
+    imageIds: string[];
+    [key: string]: unknown;
+}
+export interface GenericViewportPlanarDisplaySet extends GenericViewportImageDisplaySet {
+    kind?: 'planar';
+    initialImageIdIndex?: number;
+    volumeId?: string;
+    image?: IImage;
+    reference?: ViewportDataReference;
+}
+export interface GenericViewportSourceAliasDisplaySet {
+    kind: 'video' | 'ecg';
+    sourceDataId: string;
+}
+export interface GenericViewportWSIDisplaySet {
+    kind: 'wsi';
+    imageIds: string[];
+    options: {
+        miniNavigationOverlay?: boolean;
+        webClient: WSIClientLike;
+    };
+}
+export type GenericViewportRegisteredDisplaySet = string | string[] | GenericViewportPlanarDisplaySet | GenericViewportSourceAliasDisplaySet | GenericViewportWSIDisplaySet;
+export declare function getGenericViewportRegisteredDisplaySet(displaySetId: string): GenericViewportRegisteredDisplaySet | undefined;
+export declare function getGenericViewportImageDisplaySet(displaySetId: string): GenericViewportImageDisplaySet | undefined;
+export declare function getGenericViewportPlanarDisplaySet(displaySetId: string): GenericViewportPlanarDisplaySet | undefined;
+export declare function getGenericViewportWSIDisplaySet(displaySetId: string): GenericViewportWSIDisplaySet | undefined;
+export declare function getGenericViewportSourceDataId(displaySetId: string): string;
+export declare function isGenericViewportImageDisplaySet(value: unknown): value is GenericViewportImageDisplaySet;
+export declare function isGenericViewportWSIDisplaySet(value: unknown): value is GenericViewportWSIDisplaySet;
+export declare function isGenericViewportSourceAliasDisplaySet(value: unknown): value is GenericViewportSourceAliasDisplaySet;

package/dist/esm/RenderingEngine/GenericViewport/{genericViewportDataSetAccess.js → genericViewportDisplaySetAccess.js}

@@ -1,27 +1,27 @@
-import genericViewportDataSetMetadataProvider from '../../utilities/genericViewportDataSetMetadataProvider';
-export function getGenericViewportRegisteredData(dataId) {
-    return genericViewportDataSetMetadataProvider.get(genericViewportDataSetMetadataProvider.VIEWPORT_V2_DATA_SET, dataId);
+import genericViewportDisplaySetMetadataProvider from '../../utilities/genericViewportDisplaySetMetadataProvider';
+export function getGenericViewportRegisteredDisplaySet(displaySetId) {
+    return genericViewportDisplaySetMetadataProvider.get(genericViewportDisplaySetMetadataProvider.VIEWPORT_V2_DISPLAY_SET, displaySetId);
 }
-export function getGenericViewportImageDataSet(dataId) {
-    const registered = getGenericViewportRegisteredData(dataId);
+export function getGenericViewportImageDisplaySet(displaySetId) {
+    const registered = getGenericViewportRegisteredDisplaySet(displaySetId);
     if (isStringArray(registered)) {
         return {
             imageIds: registered,
         };
     }
-    if (!isGenericViewportImageDataSet(registered)) {
+    if (!isGenericViewportImageDisplaySet(registered)) {
         return;
     }
     return registered;
 }
-export function getGenericViewportPlanarDataSet(dataId) {
-    const registered = getGenericViewportRegisteredData(dataId);
+export function getGenericViewportPlanarDisplaySet(displaySetId) {
+    const registered = getGenericViewportRegisteredDisplaySet(displaySetId);
     if (isStringArray(registered)) {
         return {
             imageIds: registered,
         };
     }
-    if (!isGenericViewportImageDataSet(registered)) {
+    if (!isGenericViewportImageDisplaySet(registered)) {
         return;
     }
     if ('kind' in registered && registered.kind && registered.kind !== 'planar') {
@@ -29,9 +29,9 @@ export function getGenericViewportPlanarDataSet(dataId) {
     }
     return registered;
 }
-export function getGenericViewportWSIDataSet(dataId) {
-    const registered = getGenericViewportRegisteredData(dataId);
-    if (isGenericViewportWSIDataSet(registered)) {
+export function getGenericViewportWSIDisplaySet(displaySetId) {
+    const registered = getGenericViewportRegisteredDisplaySet(displaySetId);
+    if (isGenericViewportWSIDisplaySet(registered)) {
         return registered;
     }
     if (isRecord(registered) &&
@@ -48,30 +48,30 @@ export function getGenericViewportWSIDataSet(dataId) {
         };
     }
 }
-export function getGenericViewportSourceDataId(dataId) {
-    const registered = getGenericViewportRegisteredData(dataId);
+export function getGenericViewportSourceDataId(displaySetId) {
+    const registered = getGenericViewportRegisteredDisplaySet(displaySetId);
     if (typeof registered === 'string') {
         return registered;
     }
     if (isStringArray(registered) && registered[0]) {
         return registered[0];
     }
-    if (isGenericViewportSourceAliasDataSet(registered)) {
+    if (isGenericViewportSourceAliasDisplaySet(registered)) {
         return registered.sourceDataId;
     }
-    return dataId;
+    return displaySetId;
 }
-export function isGenericViewportImageDataSet(value) {
+export function isGenericViewportImageDisplaySet(value) {
     return isRecord(value) && isStringArray(value.imageIds);
 }
-export function isGenericViewportWSIDataSet(value) {
+export function isGenericViewportWSIDisplaySet(value) {
     return (isRecord(value) &&
         value.kind === 'wsi' &&
         isStringArray(value.imageIds) &&
         isRecord(value.options) &&
         isWSIClientLike(value.options.webClient));
 }
-export function isGenericViewportSourceAliasDataSet(value) {
+export function isGenericViewportSourceAliasDisplaySet(value) {
     return (isRecord(value) &&
         (value.kind === 'video' || value.kind === 'ecg') &&
         typeof value.sourceDataId === 'string');

package/dist/esm/RenderingEngine/GenericViewport/genericViewportReferenceCompatibility.js

@@ -189,15 +189,32 @@ function getReferencedImageRangeEndIndex(imageURIEntries, viewRef) {
     const rangeEndSliceIndex = imageURIEntries.findIndex((imageURIEntry) => imageURIEntryMatches(imageURIEntry, rangeEndImageURI));
     return rangeEndSliceIndex === -1 ? undefined : rangeEndSliceIndex;
 }
+const imageIdCompatibleURIsCache = new Map();
+const imageIdsURIEntriesCache = new WeakMap();
+function getImageIdsURIEntries(imageIds) {
+    let entries = imageIdsURIEntriesCache.get(imageIds);
+    if (!entries) {
+        entries = imageIds.map((imageId) => getImageIdCompatibleURIs(imageId));
+        imageIdsURIEntriesCache.set(imageIds, entries);
+    }
+    return entries;
+}
 function getContextImageURIEntries(context) {
-    const imageURIEntries = (context.imageIds || []).map((imageId) => getImageIdCompatibleURIs(imageId));
+    const baseEntries = context.imageIds?.length
+        ? getImageIdsURIEntries(context.imageIds)
+        : [];
+    const extraImageURIs = context.imageURIs;
+    if (!extraImageURIs?.length) {
+        return baseEntries;
+    }
+    const imageURIEntries = baseEntries.slice();
     const knownImageURIs = new Set();
-    for (const imageURIEntry of imageURIEntries) {
+    for (const imageURIEntry of baseEntries) {
         for (const imageURI of imageURIEntry) {
             knownImageURIs.add(imageURI);
         }
     }
-    for (const imageURI of context.imageURIs || []) {
+    for (const imageURI of extraImageURIs) {
         if (!knownImageURIs.has(imageURI)) {
             imageURIEntries.push([imageURI]);
             knownImageURIs.add(imageURI);
@@ -206,7 +223,12 @@ function getContextImageURIEntries(context) {
     return imageURIEntries;
 }
 function getImageIdCompatibleURIs(imageId) {
-    return uniqueStrings([imageIdToURI(imageId), getLegacyImageIdURI(imageId)]);
+    let uris = imageIdCompatibleURIsCache.get(imageId);
+    if (!uris) {
+        uris = uniqueStrings([imageIdToURI(imageId), getLegacyImageIdURI(imageId)]);
+        imageIdCompatibleURIsCache.set(imageId, uris);
+    }
+    return uris;
 }
 function getLegacyImageIdURI(imageId) {
     const colonIndex = imageId.indexOf(':');

package/dist/esm/RenderingEngine/GenericViewport/index.d.ts

@@ -4,7 +4,7 @@ export { ViewportProjectionService, viewportProjection, } from './viewportProjec
 export type { BuiltInViewportProjectionByKind, BuiltInViewportProjectionByType, BuiltInViewportProjectionKind, BuiltInViewportProjectionType, ProjectionPresentationForKind, ProjectionPresentationForViewport, ProjectionPresentationForViewportType, ProjectionSnapshotForKind, ProjectionSnapshotForViewport, ProjectionSnapshotForViewportType, ProjectionViewStateForKind, ProjectionViewStateForViewport, ProjectionViewStateForViewportType, } from './viewportProjection';
 export type { ProjectionPosition, ProjectionPresentation, ProjectionRequest, ProjectionScale, ProjectionSnapshot, ProjectionSpaces, ProjectionTransforms, ProjectionWriteOptions, ViewportProjectionAdapter, } from './ViewportProjectionTypes';
 export type { CameraFrame, CameraScale, CameraScaleMode, ViewAnchor, ViewportCameraBase, } from './ViewportCameraTypes';
-export type { BaseViewportRenderContext, BasePresentationProps, DataAddOptions, DataId, DataProvider, ICanvasWorldViewport, IFrameOfReferenceViewport, IPanViewport, IZoomViewport, LoadedData, MountedRendering, RenderPathDefinition, RenderPathAttachment, RenderPathResolver, RenderPath, ViewportDataBinding, ViewportDataReference, ViewportController, ViewportId, ViewportRenderContextType, } from './ViewportArchitectureTypes';
+export type { BaseViewportRenderContext, BasePresentationProps, DataAddOptions, DisplaySetId, DataProvider, ICanvasWorldViewport, IFrameOfReferenceViewport, IPanViewport, IZoomViewport, LoadedData, MountedRendering, RenderPathDefinition, RenderPathAttachment, RenderPathResolver, RenderPath, ViewportDataBinding, ViewportDataReference, ViewportController, ViewportId, ViewportRenderContextType, } from './ViewportArchitectureTypes';
 export { viewportHasCanvasWorldTransform, viewportHasFrameOfReferenceUID, viewportHasPan, viewportHasZoom, } from './ViewportArchitectureTypes';
 export { default as ECGViewport } from './ECG';
 export { createDefaultECGRenderPaths, createECGRenderPathResolver, DefaultECGDataProvider, ecgProjection, } from './ECG';

package/dist/esm/RenderingEngine/StackViewport.d.ts

@@ -142,6 +142,10 @@ declare class StackViewport extends Viewport {
     }): vtkImageDataType;
     private _createVTKImageData;
     setStack(imageIds: string[], currentImageIdIndex?: number): Promise<string>;
+    setDisplaySets(...entries: Array<{
+        displaySetId: string;
+        options?: unknown;
+    }>): Promise<void>;
     private _throwIfDestroyed;
     private _checkVTKImageDataMatchesCornerstoneImage;
     private _updateVTKImageDataFromCornerstoneImage;

package/dist/esm/RenderingEngine/StackViewport.js

@@ -8,6 +8,7 @@ import eventTarget from '../eventTarget';
 import * as metaData from '../metaData';
 import { getImageDataMetadata as getImageDataMetadataUtil } from '../utilities/getImageDataMetadata';
 import { coreLog } from '../utilities/logger';
+import { getGenericViewportImageDisplaySet } from './GenericViewport/genericViewportDisplaySetAccess';
 import { actorIsA, isImageActor } from '../utilities/actorCheck';
 import * as colormapUtils from '../utilities/colormap';
 import { getTransferFunctionNodes, setTransferFunctionNodes, } from '../utilities/transferFunctionUtils';
@@ -1304,6 +1305,7 @@ class StackViewport extends Viewport {
     }
     async setStack(imageIds, currentImageIdIndex = 0) {
         this._throwIfDestroyed();
+        this.clearDisplaySets();
         this.imageIds = imageIds;
         if (currentImageIdIndex > imageIds.length) {
             throw new Error('Current image index is greater than the number of images in the stack');
@@ -1341,6 +1343,18 @@ class StackViewport extends Viewport {
         triggerEvent(this.element, Events.VIEWPORT_NEW_IMAGE_SET, eventDetail);
         return imageId;
     }
+    async setDisplaySets(...entries) {
+        await this.mountDisplaySets(entries, async (entry) => {
+            const dataSet = getGenericViewportImageDisplaySet(entry.displaySetId);
+            if (!dataSet?.imageIds?.length) {
+                throw new Error(`[StackViewport] No registered imageIds for display set ${entry.displaySetId}`);
+            }
+            const initialImageIdIndex = typeof dataSet.initialImageIdIndex === 'number'
+                ? dataSet.initialImageIdIndex
+                : 0;
+            await this.setStack(dataSet.imageIds, initialImageIdIndex);
+        });
+    }
     _throwIfDestroyed() {
         if (this.isDisabled) {
             throw new Error('The stack viewport has been destroyed and is no longer usable. Renderings will not be performed. If you ' +

package/dist/esm/RenderingEngine/VideoViewport.d.ts

@@ -1,5 +1,6 @@
 import type { mat4 } from 'gl-matrix';
 import { VideoEnums as VideoViewportEnum } from '../enums';
+import type { DisplaySetId } from './GenericViewport/ViewportArchitectureTypes';
 import type { VideoViewportProperties, Point3, Point2, ICamera, VideoViewportInput, VOIRange, IImage, ViewReferenceSpecifier, ViewReference, ReferenceCompatibleOptions, ImageSetOptions, IStackInput, CPUIImageData, IImageData } from '../types';
 import { Transform } from './helpers/cpuFallback/rendering/transform';
 import Viewport from './Viewport';
@@ -44,6 +45,15 @@ declare class VideoViewport extends Viewport {
         dataId: string;
         options?: Record<string, unknown>;
     }>): Promise<unknown>;
+    setDisplaySets(...entries: Array<{
+        displaySetId: DisplaySetId;
+        options?: {
+            frameNumber?: number;
+            viewReference?: {
+                sliceIndex?: number;
+            };
+        };
+    }>): Promise<void>;
     setVideo(imageId: string, frameNumber?: number): Promise<unknown>;
     private setVideoURL;
     getImageIds(): string[];

package/dist/esm/RenderingEngine/VideoViewport.js

@@ -1,4 +1,5 @@
 import { Events as EVENTS, VideoEnums as VideoViewportEnum } from '../enums';
+import { getGenericViewportSourceDataId } from './GenericViewport/genericViewportDisplaySetAccess';
 import { Transform } from './helpers/cpuFallback/rendering/transform';
 import triggerEvent from '../utilities/triggerEvent';
 import Viewport from './Viewport';
@@ -204,7 +205,19 @@ class VideoViewport extends Viewport {
         }
         return this.setVideo(entries[0].dataId);
     }
+    async setDisplaySets(...entries) {
+        await this.mountDisplaySets(entries, async (entry) => {
+            const sourceDataId = getGenericViewportSourceDataId(entry.displaySetId);
+            const { frameNumber, viewReference } = entry.options ?? {};
+            const initialFrame = frameNumber ??
+                (typeof viewReference?.sliceIndex === 'number'
+                    ? viewReference.sliceIndex + 1
+                    : undefined);
+            await this.setVideo(sourceDataId, initialFrame);
+        });
+    }
     setVideo(imageId, frameNumber) {
+        this.clearDisplaySets();
         this.imageId = Array.isArray(imageId) ? imageId[0] : imageId;
         const stream = loadVideoStreamMetadata(imageId);
         this.modality = stream.modality;

package/dist/esm/RenderingEngine/Viewport.d.ts

@@ -28,6 +28,10 @@ declare class Viewport {
     sWidth: number;
     sHeight: number;
     _actors: Map<string, ActorEntry>;
+    protected _displaySets: Array<{
+        displaySetId: string;
+        options?: unknown;
+    }>;
     readonly defaultOptions: ViewportInputOptions;
     options: ViewportInputOptions;
     _suppressCameraModifiedEvents: boolean;
@@ -150,6 +154,19 @@ declare class Viewport {
         dataId: string;
         options?: DataSetOptions;
     }>): void;
+    setDisplaySets(...entries: Array<{
+        displaySetId: string;
+        options?: unknown;
+    }>): void | Promise<void>;
+    protected mountDisplaySets<TEntry extends {
+        displaySetId: string;
+        options?: unknown;
+    }>(entries: TEntry[], load: (sourceEntry: TEntry) => void | Promise<void>): Promise<void>;
+    getDisplaySets(): Array<{
+        displaySetId: string;
+        options?: unknown;
+    }>;
+    protected clearDisplaySets(): void;
 }
 export declare function getVolumeCenterIJK(dimensions: number[], direction: ArrayLike<number>, viewPlaneNormal: ArrayLike<number>): number[];
 export default Viewport;

package/dist/esm/RenderingEngine/Viewport.js

@@ -26,6 +26,7 @@ class Viewport {
         this.flipHorizontal = false;
         this.flipVertical = false;
         this.viewportStatus = ViewportStatus.NO_DATA;
+        this._displaySets = [];
         this._suppressCameraModifiedEvents = false;
         this.hasPixelSpacing = true;
         this.getProperties = () => ({});
@@ -1189,6 +1190,23 @@ class Viewport {
     setDataList(_entries) {
         throw new Error('Unsupported operation setDataList');
     }
+    setDisplaySets(...entries) {
+        this._displaySets = entries;
+    }
+    async mountDisplaySets(entries, load) {
+        const [entry] = entries;
+        if (!entry?.displaySetId) {
+            throw new Error(`${this.constructor.name}: setDisplaySets requires a displaySetId`);
+        }
+        await load(entry);
+        this._displaySets = [entry];
+    }
+    getDisplaySets() {
+        return this._displaySets;
+    }
+    clearDisplaySets() {
+        this._displaySets = [];
+    }
 }
 Viewport.CameraViewPresentation = {
     rotation: true,

package/dist/esm/RenderingEngine/WSIViewport.d.ts

@@ -61,6 +61,10 @@ declare class WSIViewport extends Viewport {
         webClient: WSIClientLike;
     }): Promise<void>;
     setWSI(imageIds: string[], client: WSIClientLike): Promise<void>;
+    setDisplaySets(...entries: Array<{
+        displaySetId: string;
+        options?: unknown;
+    }>): Promise<void>;
     postrender: () => void;
     scroll(delta: number): void;
     getRotation: () => number;

package/dist/esm/RenderingEngine/WSIViewport.js

@@ -9,6 +9,7 @@ import { EPSILON } from '../constants';
 import triggerEvent from '../utilities/triggerEvent';
 import eventTarget from '../eventTarget';
 import imageIdToURI from '../utilities/imageIdToURI';
+import { getGenericViewportWSIDisplaySet } from './GenericViewport/genericViewportDisplaySetAccess';
 import { addWSIMiniNavigationOverlayCss, getDicomMicroscopyViewer, loadWSIData, } from '../utilities/WSIUtilities';
 let WSIUtilFunctions = null;
 const EVENT_POSTRENDER = 'postrender';
@@ -341,7 +342,7 @@ class WSIViewport extends Viewport {
             return;
         }
         const { dataId } = entries[0];
-        const dataSet = metaData.get('genericViewportDataSet', dataId);
+        const dataSet = metaData.get('genericViewportDisplaySet', dataId);
         if (dataSet?.imageIds) {
             return this.setDataIds(dataSet.imageIds, {
                 webClient: dataSet.options?.webClient,
@@ -361,6 +362,7 @@ class WSIViewport extends Viewport {
         return this.setWSI(imageIds, webClient);
     }
     async setWSI(imageIds, client) {
+        this.clearDisplaySets();
         this.microscopyElement.style.background = 'black';
         this.microscopyElement.innerText = 'Loading';
         this.imageIds = imageIds;
@@ -397,6 +399,18 @@ class WSIViewport extends Viewport {
             background: 'none',
         });
     }
+    async setDisplaySets(...entries) {
+        await this.mountDisplaySets(entries, async (entry) => {
+            const dataSet = getGenericViewportWSIDisplaySet(entry.displaySetId);
+            if (!dataSet?.imageIds?.length || !dataSet.options?.webClient) {
+                throw new Error(`[WSIViewport] No registered WSI dataset (imageIds + webClient) for display set ${entry.displaySetId}`);
+            }
+            if (dataSet.options.miniNavigationOverlay !== false) {
+                addWSIMiniNavigationOverlayCss();
+            }
+            await WSIViewport.prototype.setWSI.call(this, dataSet.imageIds, dataSet.options.webClient);
+        });
+    }
     scroll(delta) {
         const camera = this.getCamera();
         this.setCamera({