@cornerstonejs/core 2.0.0-beta.22 → 2.0.0-beta.24

package/dist/esm/enums/Events.d.ts

@@ -33,6 +33,7 @@ declare enum Events {
     VOLUME_VIEWPORT_SCROLL = "VOLUME_VIEWPORT_SCROLL",
     CLIPPING_PLANES_UPDATED = "CORNERSTONE_CLIPPING_PLANES_UPDATED",
     WEB_WORKER_PROGRESS = "CORNERSTONE_WEB_WORKER_PROGRESS",
-    COLORMAP_MODIFIED = "CORNERSTONE_COLORMAP_MODIFIED"
+    COLORMAP_MODIFIED = "CORNERSTONE_COLORMAP_MODIFIED",
+    DYNAMIC_VOLUME_TIME_POINT_INDEX_CHANGED = "DYNAMIC_VOLUME_TIME_POINT_INDEX_CHANGED"
 }
 export default Events;

package/dist/esm/enums/Events.js

@@ -35,5 +35,6 @@ var Events;
     Events["CLIPPING_PLANES_UPDATED"] = "CORNERSTONE_CLIPPING_PLANES_UPDATED";
     Events["WEB_WORKER_PROGRESS"] = "CORNERSTONE_WEB_WORKER_PROGRESS";
     Events["COLORMAP_MODIFIED"] = "CORNERSTONE_COLORMAP_MODIFIED";
+    Events["DYNAMIC_VOLUME_TIME_POINT_INDEX_CHANGED"] = "DYNAMIC_VOLUME_TIME_POINT_INDEX_CHANGED";
 })(Events || (Events = {}));
 export default Events;

package/dist/esm/index.d.ts

@@ -31,6 +31,8 @@ import type { IRetrieveConfiguration, IImagesLoader, RetrieveOptions, RetrieveSt
 import * as utilities from './utilities';
 import { registerImageLoader } from './loaders/imageLoader';
 import triggerEvent from './utilities/triggerEvent';
+import { cornerstoneStreamingImageVolumeLoader } from './loaders/cornerstoneStreamingImageVolumeLoader';
+import { cornerstoneStreamingDynamicImageVolumeLoader } from './loaders/cornerstoneStreamingDynamicImageVolumeLoader';
 import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports } from './RenderingEngine/helpers';
 export type { Types, IRetrieveConfiguration, RetrieveOptions, RetrieveStage, ImageLoadListener, IImagesLoader, };
-export { init, isCornerstoneInitialized, peerImport, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, getOrCreateCanvas, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, ProgressiveRetrieveImages, };
+export { init, isCornerstoneInitialized, peerImport, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, getOrCreateCanvas, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, ProgressiveRetrieveImages, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, };

package/dist/esm/index.js

@@ -29,5 +29,7 @@ import ProgressiveRetrieveImages from './loaders/ProgressiveRetrieveImages';
 import * as utilities from './utilities';
 import { registerImageLoader } from './loaders/imageLoader';
 import triggerEvent from './utilities/triggerEvent';
+import { cornerstoneStreamingImageVolumeLoader } from './loaders/cornerstoneStreamingImageVolumeLoader';
+import { cornerstoneStreamingDynamicImageVolumeLoader } from './loaders/cornerstoneStreamingDynamicImageVolumeLoader';
 import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, } from './RenderingEngine/helpers';
-export { init, isCornerstoneInitialized, peerImport, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, getOrCreateCanvas, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, ProgressiveRetrieveImages, };
+export { init, isCornerstoneInitialized, peerImport, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, getOrCreateCanvas, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, ProgressiveRetrieveImages, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, };

package/dist/esm/loaders/cornerstoneStreamingDynamicImageVolumeLoader.d.ts

@@ -0,0 +1,10 @@
+import { StreamingDynamicImageVolume } from '../cache';
+interface IVolumeLoader {
+    promise: Promise<StreamingDynamicImageVolume>;
+    cancel: () => void;
+    decache: () => void;
+}
+declare function cornerstoneStreamingDynamicImageVolumeLoader(volumeId: string, options: {
+    imageIds: string[];
+}): IVolumeLoader;
+export { cornerstoneStreamingDynamicImageVolumeLoader };

package/dist/esm/loaders/cornerstoneStreamingDynamicImageVolumeLoader.js

@@ -0,0 +1,58 @@
+import { StreamingDynamicImageVolume } from '../cache';
+import { generateVolumePropsFromImageIds, sortImageIdsAndGetSpacing, splitImageIdsBy4DTags, VoxelManager, } from '../utilities';
+function cornerstoneStreamingDynamicImageVolumeLoader(volumeId, options) {
+    if (!options || !options.imageIds || !options.imageIds.length) {
+        throw new Error('ImageIds must be provided to create a 4D streaming image volume');
+    }
+    const { imageIds } = options;
+    const { splittingTag, imageIdGroups } = splitImageIdsBy4DTags(imageIds);
+    const volumeProps = generateVolumePropsFromImageIds(imageIdGroups[0], volumeId);
+    const { metadata: volumeMetadata, dimensions, spacing, direction, sizeInBytes, origin, numberOfComponents, dataType, } = volumeProps;
+    const scanAxisNormal = direction.slice(6, 9);
+    const sortedImageIdGroups = imageIdGroups.map((imageIds) => {
+        const sortedImageIds = sortImageIdsAndGetSpacing(imageIds, scanAxisNormal).sortedImageIds;
+        return sortedImageIds;
+    });
+    const sortedFlatImageIds = sortedImageIdGroups.flat();
+    const voxelManager = VoxelManager.createScalarDynamicVolumeVoxelManager({
+        dimensions,
+        imageIdGroups: sortedImageIdGroups,
+        timePoint: 0,
+        numberOfComponents,
+    });
+    let streamingImageVolume = new StreamingDynamicImageVolume({
+        volumeId,
+        metadata: volumeMetadata,
+        dimensions,
+        spacing,
+        origin,
+        direction,
+        sizeInBytes,
+        imageIds: sortedFlatImageIds,
+        imageIdGroups: sortedImageIdGroups,
+        splittingTag,
+        voxelManager,
+        numberOfComponents,
+        dataType,
+    }, {
+        imageIds: sortedFlatImageIds,
+        loadStatus: {
+            loaded: false,
+            loading: false,
+            cancelled: false,
+            cachedFrames: [],
+            callbacks: [],
+        },
+    });
+    return {
+        promise: Promise.resolve(streamingImageVolume),
+        decache: () => {
+            streamingImageVolume.destroy();
+            streamingImageVolume = null;
+        },
+        cancel: () => {
+            streamingImageVolume.cancelLoading();
+        },
+    };
+}
+export { cornerstoneStreamingDynamicImageVolumeLoader };

package/dist/esm/loaders/cornerstoneStreamingImageVolumeLoader.d.ts

@@ -0,0 +1,12 @@
+import StreamingImageVolume from '../cache/classes/StreamingImageVolume';
+import type { IRetrieveConfiguration } from '../types';
+interface IVolumeLoader {
+    promise: Promise<StreamingImageVolume>;
+    cancel: () => void;
+    decache: () => void;
+}
+declare function cornerstoneStreamingImageVolumeLoader(volumeId: string, options: {
+    imageIds: string[];
+    progressiveRendering?: boolean | IRetrieveConfiguration;
+}): IVolumeLoader;
+export { cornerstoneStreamingImageVolumeLoader };

package/dist/esm/loaders/cornerstoneStreamingImageVolumeLoader.js

@@ -0,0 +1,73 @@
+import StreamingImageVolume from '../cache/classes/StreamingImageVolume';
+import { RequestType } from '../enums';
+import imageLoadPoolManager from '../requestPool/imageLoadPoolManager';
+import { generateVolumePropsFromImageIds } from '../utilities';
+import { loadImage } from './imageLoader';
+function cornerstoneStreamingImageVolumeLoader(volumeId, options) {
+    if (!options || !options.imageIds || !options.imageIds.length) {
+        throw new Error('ImageIds must be provided to create a streaming image volume');
+    }
+    async function getStreamingImageVolume() {
+        if (options.imageIds[0].split(':')[0] === 'wadouri') {
+            const [middleImageIndex, lastImageIndex] = [
+                Math.floor(options.imageIds.length / 2),
+                options.imageIds.length - 1,
+            ];
+            const indexesToPrefetch = [0, middleImageIndex, lastImageIndex];
+            await Promise.all(indexesToPrefetch.map((index) => {
+                return new Promise((resolve, reject) => {
+                    const imageId = options.imageIds[index];
+                    imageLoadPoolManager.addRequest(async () => {
+                        loadImage(imageId)
+                            .then(() => {
+                            console.log(`Prefetched imageId: ${imageId}`);
+                            resolve(true);
+                        })
+                            .catch((err) => {
+                            reject(err);
+                        });
+                    }, RequestType.Prefetch, { volumeId }, 1);
+                });
+            })).catch(console.error);
+        }
+        const volumeProps = generateVolumePropsFromImageIds(options.imageIds, volumeId);
+        const { dimensions, spacing, origin, direction, metadata, imageIds, dataType, numberOfComponents, } = volumeProps;
+        const streamingImageVolume = new StreamingImageVolume({
+            volumeId,
+            metadata,
+            dimensions,
+            spacing,
+            origin,
+            direction,
+            imageIds,
+            dataType,
+            numberOfComponents,
+        }, {
+            imageIds,
+            loadStatus: {
+                loaded: false,
+                loading: false,
+                cancelled: false,
+                cachedFrames: [],
+                callbacks: [],
+            },
+        });
+        return streamingImageVolume;
+    }
+    const streamingImageVolumePromise = getStreamingImageVolume();
+    return {
+        promise: streamingImageVolumePromise,
+        decache: () => {
+            streamingImageVolumePromise.then((streamingImageVolume) => {
+                streamingImageVolume.destroy();
+                streamingImageVolume = null;
+            });
+        },
+        cancel: () => {
+            streamingImageVolumePromise.then((streamingImageVolume) => {
+                streamingImageVolume.cancelLoading();
+            });
+        },
+    };
+}
+export { cornerstoneStreamingImageVolumeLoader };

package/dist/esm/loaders/volumeLoader.js

@@ -68,14 +68,6 @@ export function createAndCacheDerivedVolume(referencedVolumeId, options) {
     }
     const { metadata, dimensions, spacing, origin, direction } = referencedVolume;
     const referencedImageIds = referencedVolume.imageIds ?? [];
-    const byteLength = referencedImageIds.reduce((total, imageId) => {
-        const image = cache.getImage(imageId);
-        return total + image.sizeInBytes;
-    }, 0);
-    const isCacheable = cache.isCacheable(byteLength);
-    if (!isCacheable) {
-        throw new Error(`Cannot created derived volume: Referenced volume with id ${referencedVolumeId} does not exist.`);
-    }
     const derivedImages = createAndCacheDerivedImages(referencedImageIds, {
         targetBufferType: options.targetBufferType,
     });

package/dist/esm/types/IBaseVolumeViewport.d.ts

@@ -0,0 +1,2 @@
+import type BaseVolumeViewport from '../RenderingEngine/BaseVolumeViewport';
+export type IBaseVolumeViewport = BaseVolumeViewport;

package/dist/esm/types/IBaseVolumeViewport.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/IStackViewport.d.ts

@@ -1,69 +1,2 @@
-import type CPUIImageData from './CPUIImageData';
-import type { ActorEntry } from './IActor';
-import type ICamera from './ICamera';
-import type IImage from './IImage';
-import type IImageData from './IImageData';
-import type { IStackInput } from './IStackInput';
-import type { IViewport } from './IViewport';
-import type Point2 from './Point2';
-import type Point3 from './Point3';
-import type { Scaling } from './ScalingParameters';
-import type StackViewportProperties from './StackViewportProperties';
-import type { ViewReference, ViewReferenceSpecifier, ReferenceCompatibleOptions } from '../types/IViewport';
-import type { ImageDataMetaData } from '../RenderingEngine/StackViewport';
-import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
-export default interface IStackViewport extends IViewport {
-    setUseCPURendering(value: boolean): void;
-    updateRenderingPipeline(): void;
-    getImageData(): IImageData | CPUIImageData;
-    getCamera(): ICamera;
-    setCamera(cameraInterface: ICamera, storeAsInitialCamera?: boolean): void;
-    getRotation(): number;
-    unsetColormap(): void;
-    getImageIds(): string[];
-    setStack(imageIds: string[], imageIdIndex?: number): Promise<string>;
-    resetCamera(options?: unknown): boolean;
-    canvasToWorld(canvasPos: Point2): Point3;
-    worldToCanvas(worldPos: Point3): Point2;
-    getRenderer(): vtkRenderer;
-    getDefaultActor(): ActorEntry;
-    getActors(): ActorEntry[];
-    getActor(actorUID: string): ActorEntry;
-    setActors(actors: ActorEntry[]): void;
-    addActors(actors: ActorEntry[]): void;
-    addActor(actorEntry: ActorEntry): void;
-    removeAllActors(): void;
-    getFrameOfReferenceUID(): string;
-    addImages(images: IStackInput[], immediateRender?: boolean, suppressEvents?: boolean): void;
-    renderImageObject(image: unknown): void;
-    setProperties(properties: StackViewportProperties, suppressEvents?: boolean): void;
-    getCurrentImageId(): string;
-    getImageDataMetadata(image: IImage): ImageDataMetaData;
-    resize(): void;
-    setDefaultProperties(ViewportProperties: StackViewportProperties, imageId?: string): void;
-    clearDefaultProperties(imageId?: string): void;
-    getDefaultProperties(imageId?: string): StackViewportProperties;
-    getProperties(): StackViewportProperties;
-    getCurrentImageIdIndex(): number;
-    hasImageId(imageId: string): boolean;
-    hasImageURI(imageURI: string): boolean;
-    customRenderViewportToCanvas(): {
-        canvas: HTMLCanvasElement;
-        element: HTMLDivElement;
-        viewportId: string;
-        renderingEngineId: string;
-    };
-    getCornerstoneImage(): IImage;
-    resetToDefaultProperties(): void;
-    resetProperties(): void;
-    setImageIdIndex(imageIdIndex: number): Promise<string>;
-    calibrateSpacing(imageId: string): void;
-    isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean | unknown;
-    getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
-    setViewReference(viewRef: ViewReference): void;
-    getViewReferenceId(specifier?: ViewReferenceSpecifier): string;
-    modality: string;
-    scaling: Scaling;
-    stackActorReInitialized: boolean;
-    scroll(delta: number, debounceLoading?: boolean, loop?: boolean): void;
-}
+import type { StackViewport } from '../RenderingEngine';
+export type { StackViewport as default };

package/dist/esm/types/IVideoViewport.d.ts

@@ -1,40 +1,2 @@
-import type { IViewport } from './IViewport';
-import type { PixelDataTypedArray } from './PixelDataTypedArray';
-import type VideoViewportProperties from './VideoViewportProperties';
-import type { VOIRange } from './voi';
-import type { SpeedUnit } from '../enums/VideoEnums';
-import type IImageData from './IImageData';
-import type CPUIImageData from './CPUIImageData';
-export interface IVideoViewport extends IViewport {
-    modality: string;
-    canvasContext: CanvasRenderingContext2D;
-    setVideo(imageId: string, frameNumber?: number): Promise<unknown>;
-    setVideoURL(videoURL: string): Promise<unknown>;
-    togglePlayPause(): boolean;
-    play(): Promise<void>;
-    pause(): void;
-    scroll(delta?: number): Promise<void>;
-    start(): Promise<void>;
-    end(): Promise<void>;
-    setTime(timeInSeconds: number): Promise<void>;
-    setFrameNumber(frame: number): Promise<void>;
-    setFrameRange(frameRange: number[]): void;
-    getFrameRange(): [number, number];
-    setProperties(props: VideoViewportProperties): void;
-    setPlaybackRate(rate?: number): void;
-    setScrollSpeed(scrollSpeed?: number, unit?: SpeedUnit): void;
-    getProperties(): VideoViewportProperties;
-    resetProperties(): void;
-    setVOI(voiRange: VOIRange): void;
-    setWindowLevel(windowWidth?: number, windowCenter?: number): void;
-    setAverageWhite(averageWhite: [number, number, number]): void;
-    getFrameNumber(): number;
-    getFrameRate(): number;
-    getMiddleSliceData(): PixelDataTypedArray;
-    getImageData(): IImageData | CPUIImageData;
-    getCurrentImageId(): string;
-    hasImageURI(imageURI: string): boolean;
-    getNumberOfSlices(): number;
-    customRenderViewportToCanvas(): void;
-    useCustomRenderingPipeline: boolean;
-}
+import type VideoViewport from '../RenderingEngine/VideoViewport';
+export type IVideoViewport = VideoViewport;

package/dist/esm/types/IViewport.d.ts

@@ -1,17 +1,10 @@
-import type ICamera from './ICamera';
 import type Point2 from './Point2';
 import type Point3 from './Point3';
 import type ViewportInputOptions from './ViewportInputOptions';
-import type { ActorEntry } from './IActor';
 import type ViewportType from '../enums/ViewportType';
-import type ViewportStatus from '../enums/ViewportStatus';
 import type DisplayArea from './displayArea';
 import type { BoundsLPS } from './BoundsLPS';
-import type { mat4 } from 'gl-matrix';
-import type IRenderingEngine from './IRenderingEngine';
-import type IImageData from './IImageData';
-import type CPUIImageData from './CPUIImageData';
-import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
+import type Viewport from '../RenderingEngine/Viewport';
 export interface ViewReferenceSpecifier {
     sliceIndex?: number | [number, number];
     forFrameOfReference?: boolean;
@@ -56,86 +49,7 @@ export interface DataSetOptions {
     viewSelector?: ViewPresentationSelector;
     viewReference?: ViewReferenceSpecifier;
 }
-interface IViewport {
-    id: string;
-    getImageData: () => IImageData | CPUIImageData | undefined;
-    getWidget: (id: string) => unknown;
-    addWidget: (id: string, widget: unknown) => void;
-    getWidgets: () => unknown;
-    removeWidgets: () => void;
-    renderingEngineId: string;
-    type: ViewportType;
-    canvas: HTMLCanvasElement;
-    element: HTMLDivElement;
-    sx: number;
-    sy: number;
-    sWidth: number;
-    sHeight: number;
-    _actors: Map<string, unknown>;
-    defaultOptions: unknown;
-    options: ViewportInputOptions;
-    suppressEvents: boolean;
-    isDisabled: boolean;
-    viewportStatus: ViewportStatus;
-    getRotation: () => number;
-    getFrameOfReferenceUID: () => string;
-    canvasToWorld: (canvasPos: Point2) => Point3;
-    worldToCanvas: (worldPos: Point3) => Point2;
-    getDefaultActor(): ActorEntry;
-    getActors(): ActorEntry[];
-    getActor(actorUID: string): ActorEntry;
-    getActorUIDByIndex(index: number): string;
-    getActorByIndex(index: number): ActorEntry;
-    setActors(actors: ActorEntry[]): void;
-    addActors(actors: ActorEntry[]): void;
-    addActor(actorEntry: ActorEntry): void;
-    getActorUIDs(): string[];
-    removeAllActors(): void;
-    removeActors(actorUIDs: string[]): void;
-    getRenderingEngine(): IRenderingEngine;
-    getRenderer(): vtkRenderer;
-    render(): void;
-    setOptions(options: ViewportInputOptions, immediate: boolean): void;
-    setDisplayArea(displayArea: DisplayArea, callResetCamera?: boolean, suppressEvents?: boolean): any;
-    getDisplayArea(): DisplayArea | undefined;
-    reset(immediate: boolean): void;
-    getCanvas(): HTMLCanvasElement;
-    getCamera(): ICamera;
-    setRendered(): void;
-    getZoom(): number;
-    setZoom(zoom: number, storeAsInitialCamera?: boolean): any;
-    getPan(): Point2;
-    setPan(pan: Point2, storeAsInitialCamera?: boolean): any;
-    setCamera(cameraInterface: ICamera, storeAsInitialCamera?: boolean): void;
-    resetCamera({ resetPan, resetZoom, resetToCenter, storeAsInitialCamera, }?: {
-        resetPan?: boolean;
-        resetZoom?: boolean;
-        resetToCenter?: boolean;
-        storeAsInitialCamera?: boolean;
-    }): boolean;
-    getNumberOfSlices(): number;
-    getCurrentImageIdIndex(): number;
-    getSliceIndex(): number;
-    getSliceViewInfo(): {
-        width: number;
-        height: number;
-        sliceIndex: number;
-        slicePlane: number;
-        sliceToIndexMatrix: mat4;
-        indexToSliceMatrix: mat4;
-    };
-    getViewReferenceId(viewRefSpecifier?: ViewReferenceSpecifier): string;
-    getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
-    isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean | unknown;
-    getViewPresentation(viewPresSel?: ViewPresentationSelector): ViewPresentation;
-    setViewReference(viewRef: ViewReference): any;
-    setViewPresentation(viewPres: ViewPresentation): any;
-    customRenderViewportToCanvas: () => unknown;
-    _getCorners(bounds: number[]): number[][];
-    updateRenderingPipeline: () => void;
-    getTargetId?: () => string;
-    setDataIds(dataIds: string[], options?: DataSetOptions): void;
-}
+type IViewport = Viewport;
 interface PublicViewportInput {
     element: HTMLDivElement;
     viewportId: string;

package/dist/esm/types/IVolumeViewport.d.ts

@@ -1,45 +1,3 @@
-import type Point2 from './Point2';
-import type Point3 from './Point3';
-import type { IViewport } from './IViewport';
-import type { IVolumeInput } from './IVolumeInput';
-import type FlipDirection from './FlipDirection';
-import type IImageData from './IImageData';
-import type { BlendModes, OrientationAxis } from '../enums';
-import type VolumeViewportProperties from './VolumeViewportProperties';
-export default interface IVolumeViewport extends IViewport {
-    useCPURendering: boolean;
-    getFrameOfReferenceUID: () => string;
-    getDefaultProperties: (volumeId?: string) => VolumeViewportProperties;
-    getProperties: (volumeId?: string) => VolumeViewportProperties;
-    canvasToWorld: (canvasPos: Point2) => Point3;
-    worldToCanvas: (worldPos: Point3) => Point2;
-    getImageIds: (volumeId?: string) => string[];
-    getCurrentImageIdIndex: () => number;
-    hasVolumeId: (volumeId: string) => boolean;
-    hasImageURI: (imageURI: string) => boolean;
-    getCurrentImageId: () => string | undefined;
-    setDefaultProperties(ViewportProperties: VolumeViewportProperties, volumeId?: string): void;
-    clearDefaultProperties(volumeId?: string): void;
-    setProperties({ voiRange }: VolumeViewportProperties, volumeId?: string, suppressEvents?: boolean): void;
-    resetProperties(volumeId: string): void;
-    setVolumes(volumeInputArray: IVolumeInput[], immediate?: boolean, suppressEvents?: boolean): Promise<void>;
-    addVolumes(volumeInputArray: IVolumeInput[], immediate?: boolean, suppressEvents?: boolean): Promise<void>;
-    removeVolumeActors(actorUIDs: string[], immediate?: boolean): void;
-    getIntensityFromWorld(point: Point3): number;
-    getBounds(): number[];
-    flip(flipDirection: FlipDirection): void;
-    resetCamera({ resetPan, resetZoom, resetToCenter, resetRotation, suppressEvents, }?: {
-        resetPan?: boolean;
-        resetZoom?: boolean;
-        resetToCenter?: boolean;
-        resetRotation?: boolean;
-        suppressEvents?: boolean;
-    }): boolean;
-    resetSlabThickness(): void;
-    setBlendMode(blendMode: BlendModes, filterActorUIDs?: string[], immediate?: boolean): void;
-    setSlabThickness(slabThickness: number, filterActorUIDs?: string[]): void;
-    getSlabThickness(): number;
-    getImageData: (volumeId?: string) => IImageData | undefined;
-    setOrientation(orientation: OrientationAxis): void;
-    getVolumeId(): string | undefined;
-}
+import type { VolumeViewport } from '../RenderingEngine';
+type IVolumeViewport = VolumeViewport;
+export type { IVolumeViewport as default };

package/dist/esm/types/IVoxelManager.d.ts

@@ -1,54 +1,2 @@
-import type { BoundsIJK, Point3, PixelDataTypedArray, CPUImageData, IRLEVoxelMap } from '../types';
-import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
-interface IVoxelManager<T> {
-    _get: (index: number) => T;
-    _set: (index: number, v: T) => boolean | void;
-    modifiedSlices: Set<number>;
-    boundsIJK: BoundsIJK;
-    map: Map<number, T> | IRLEVoxelMap<T>;
-    sourceVoxelManager: IVoxelManager<T>;
-    isInObject: (pointLPS: Point3, pointIJK: Point3) => boolean;
-    readonly dimensions: Point3;
-    numberOfComponents: number;
-    getCompleteScalarDataArray?: () => ArrayLike<number>;
-    setCompleteScalarDataArray?: (scalarData: ArrayLike<number>) => void;
-    getRange: () => [number, number];
-    points: Set<number>;
-    width: number;
-    frameSize: number;
-    getAtIJK(i: number, j: number, k: number): T;
-    setAtIJK(i: number, j: number, k: number, v: T): void;
-    getAtIJKPoint(point: Point3): T;
-    setAtIJKPoint(point: Point3, v: T): void;
-    getAtIndex(index: number): T;
-    setAtIndex(index: number, v: T): void;
-    toIJK(index: number): Point3;
-    getMiddleSliceData(): PixelDataTypedArray;
-    toIndex(ijk: Point3): number;
-    getBoundsIJK(): BoundsIJK;
-    forEach(callback: (args: {
-        value: unknown;
-        index: number;
-        pointIJK: Point3;
-        pointLPS: Point3;
-    }) => void, options?: {
-        boundsIJK?: BoundsIJK;
-        isInObject?: (pointLPS: Point3, pointIJK: Point3) => boolean;
-        returnPoints?: boolean;
-        imageData?: vtkImageData | CPUImageData;
-    }): unknown[];
-    getScalarData(): PixelDataTypedArray;
-    getScalarDataLength(): number;
-    get sizeInBytes(): number;
-    get bytePerVoxel(): number;
-    clear(): void;
-    getConstructor(): new (length: number) => PixelDataTypedArray;
-    getArrayOfSlices(): number[];
-    addPoint(point: Point3 | number): void;
-    getPoints(): Point3[];
-    getSliceData(args: {
-        sliceIndex: number;
-        slicePlane: number;
-    }): PixelDataTypedArray;
-}
-export type { IVoxelManager };
+import type { VoxelManager } from '../utilities';
+export type IVoxelManager<T> = VoxelManager<T>;

package/dist/esm/types/IWSIViewport.d.ts

@@ -1,16 +1,3 @@
-import type { IViewport } from './IViewport';
-import type WSIViewportProperties from './WSIViewportProperties';
-export default interface IWSIViewport extends IViewport {
-    resize: () => void;
-    setProperties(props: WSIViewportProperties, suppressEvents?: boolean): void;
-    getProperties: () => WSIViewportProperties;
-    setWSI: (imageIds: string[], client: any) => Promise<unknown>;
-    resetProperties(): void;
-    getCurrentImageId(): string;
-    getFrameNumber(): number;
-    setFrameNumber(frameNo: number): any;
-    resetCamera(options?: {
-        resetPan?: boolean;
-        resetZoom?: boolean;
-    }): boolean;
-}
+import type WSIViewport from '../RenderingEngine/WSIViewport';
+type IWSIViewport = WSIViewport;
+export type { IWSIViewport as default };

package/dist/esm/types/ImageLoadRequests.d.ts

@@ -0,0 +1,24 @@
+import type { RequestType } from '../enums';
+import type { ScalingParameters } from './ScalingParameters';
+export default interface ImageLoadRequests {
+    callLoadImage: (imageId: string, imageIdIndex: number, options: unknown) => Promise<void>;
+    imageId: string;
+    imageIdIndex: number;
+    options: {
+        targetBuffer: {
+            type: string;
+            rows: number;
+            columns: number;
+        };
+        preScale: {
+            enabled: boolean;
+            scalingParameters: ScalingParameters;
+        };
+        transferPixelData: boolean;
+    };
+    priority: number;
+    requestType: RequestType;
+    additionalDetails: {
+        volumeId: string;
+    };
+}

package/dist/esm/types/ImageLoadRequests.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/MetadataModuleTypes.d.ts

@@ -35,6 +35,7 @@ export interface ImagePlaneModuleMetadata {
     pixelSpacing: number[];
     rowPixelSpacing: number | null;
     columnPixelSpacing: number | null;
+    usingDefaultValues: boolean;
 }
 export interface ImagePixelModuleMetadata {
     samplesPerPixel: number;

package/dist/esm/types/index.d.ts

@@ -92,4 +92,6 @@ import type IImageFrame from './IImageFrame';
 import type { DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, ImagePlaneModuleMetadata, SopCommonModuleMetadata, ImagePixelModuleMetadata, PatientStudyModuleMetadata, TransferSyntaxMetadata } from './MetadataModuleTypes';
 import type { IVoxelManager } from './IVoxelManager';
 import type { IRLEVoxelMap, RLERun } from './IRLEVoxelMap';
-export type { Cornerstone3DConfig, ICamera, IStackViewport, IVideoViewport, IWSIViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, IViewportId, IImageVolume, ImageVolumeProps, IDynamicImageVolume, IRenderingEngine, ScalingParameters, PTScaling, IPointsManager, PolyDataPointConfiguration, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, ViewReference, DataSetOptions as ImageSetOptions, ViewPresentation, ViewPresentationSelector, ReferenceCompatibleOptions, ViewReferenceSpecifier, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, ImageActor, ICanvasActor, IImageLoadObject, IVolumeLoadObject, IVolumeInput, VolumeInputCallback, IStackInput, StackInputCallback, ViewportPreset, Metadata, OrientationVectors, AABB2, AABB3, Point2, Point3, PointsXYZ, Point4, Mat3, Plane, ViewportInputOptions, VideoViewportProperties, WSIViewportProperties, VOIRange, VOI, DisplayArea, FlipDirection, ICachedImage, ICachedVolume, CPUFallbackEnabledElement, CPUFallbackViewport, CPUFallbackTransform, CPUFallbackColormapData, CPUFallbackViewportDisplayedArea, CPUFallbackColormapsData, CPUFallbackColormap, TransformMatrix2D, CPUFallbackLookupTable, CPUFallbackLUT, CPUFallbackRenderingTools, CustomEventType, ActorSliceRange, ImageSliceData, IGeometry, IGeometryLoadObject, ICachedGeometry, PublicContourSetData, ContourSetData, ContourData, IContourSet, IContour, PublicSurfaceData, SurfaceData, ISurface, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, PixelDataTypedArrayString, ImagePixelModule, ImagePlaneModule, AffineMatrix, ImageLoadListener, InternalVideoCamera, VideoViewportInput, WSIViewportInput, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, IImageFrame, DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, ImagePlaneModuleMetadata, SopCommonModuleMetadata, ImagePixelModuleMetadata, PatientStudyModuleMetadata, TransferSyntaxMetadata, LocalVolumeOptions, IVoxelManager, IRLEVoxelMap, RLERun, ViewportInput, };
+import type ImageLoadRequests from './ImageLoadRequests';
+import type { IBaseVolumeViewport } from './IBaseVolumeViewport';
+export type { Cornerstone3DConfig, ICamera, IStackViewport, IVideoViewport, IWSIViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, IViewportId, IImageVolume, ImageVolumeProps, IDynamicImageVolume, IRenderingEngine, ScalingParameters, PTScaling, IPointsManager, PolyDataPointConfiguration, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, ViewReference, DataSetOptions as ImageSetOptions, ViewPresentation, ViewPresentationSelector, ReferenceCompatibleOptions, ViewReferenceSpecifier, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, ImageActor, ICanvasActor, IImageLoadObject, IVolumeLoadObject, IVolumeInput, VolumeInputCallback, IStackInput, StackInputCallback, ViewportPreset, Metadata, OrientationVectors, AABB2, AABB3, Point2, Point3, PointsXYZ, Point4, Mat3, Plane, ViewportInputOptions, VideoViewportProperties, WSIViewportProperties, VOIRange, VOI, DisplayArea, FlipDirection, ICachedImage, ICachedVolume, CPUFallbackEnabledElement, CPUFallbackViewport, CPUFallbackTransform, CPUFallbackColormapData, CPUFallbackViewportDisplayedArea, CPUFallbackColormapsData, CPUFallbackColormap, TransformMatrix2D, CPUFallbackLookupTable, CPUFallbackLUT, CPUFallbackRenderingTools, CustomEventType, ActorSliceRange, ImageSliceData, IGeometry, IGeometryLoadObject, ICachedGeometry, PublicContourSetData, ContourSetData, ContourData, IContourSet, IContour, PublicSurfaceData, SurfaceData, ISurface, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, PixelDataTypedArrayString, ImagePixelModule, ImagePlaneModule, AffineMatrix, ImageLoadListener, InternalVideoCamera, VideoViewportInput, WSIViewportInput, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, IImageFrame, DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, ImagePlaneModuleMetadata, SopCommonModuleMetadata, ImagePixelModuleMetadata, PatientStudyModuleMetadata, TransferSyntaxMetadata, LocalVolumeOptions, IVoxelManager, IRLEVoxelMap, RLERun, ViewportInput, ImageLoadRequests, IBaseVolumeViewport, };