@cornerstonejs/core 2.0.0-beta.7 → 2.0.0

package/dist/esm/utilities/actorCheck.d.ts

@@ -0,0 +1,5 @@
+import type { Types } from '..';
+type actorTypes = 'vtkActor' | 'vtkVolume' | 'vtkImageSlice';
+export declare function isImageActor(actorEntry: Types.ActorEntry): boolean;
+export declare function actorIsA(actorEntry: Types.ActorEntry | Types.Actor, actorType: actorTypes): boolean;
+export {};

package/dist/esm/utilities/actorCheck.js

@@ -5,4 +5,3 @@ export function actorIsA(actorEntry, actorType) {
     const actorToCheck = 'isA' in actorEntry ? actorEntry : actorEntry.actor;
     return !!actorToCheck.isA(actorType);
 }
-//# sourceMappingURL=actorCheck.js.map

package/dist/esm/utilities/applyPreset.d.ts

@@ -0,0 +1,3 @@
+import type { ViewportPreset } from '../types';
+import type { VolumeActor } from '../types/IActor';
+export default function applyPreset(actor: VolumeActor, preset: ViewportPreset): void;

package/dist/esm/utilities/applyPreset.js

@@ -87,4 +87,3 @@ function applyPointsToPiecewiseFunction(points, range, pwf) {
     rescaled.forEach(([x, y]) => pwf.addPoint(x, y));
     return rescaled;
 }
-//# sourceMappingURL=applyPreset.js.map

package/dist/esm/utilities/autoLoad.d.ts

@@ -0,0 +1,2 @@
+declare const autoLoad: (volumeId: string) => void;
+export default autoLoad;

package/dist/esm/utilities/autoLoad.js

@@ -0,0 +1,28 @@
+import { getRenderingEngines } from '../RenderingEngine/getRenderingEngine';
+import getViewportsWithVolumeId from './getViewportsWithVolumeId';
+const autoLoad = (volumeId) => {
+    const renderingEngineAndViewportIds = getRenderingEngineAndViewportsContainingVolume(volumeId);
+    if (!renderingEngineAndViewportIds?.length) {
+        return;
+    }
+    renderingEngineAndViewportIds.forEach(({ renderingEngine, viewportIds }) => {
+        if (!renderingEngine.hasBeenDestroyed) {
+            renderingEngine.renderViewports(viewportIds);
+        }
+    });
+};
+function getRenderingEngineAndViewportsContainingVolume(volumeId) {
+    const renderingEnginesArray = getRenderingEngines();
+    const renderingEngineAndViewportIds = [];
+    renderingEnginesArray.forEach((renderingEngine) => {
+        const viewports = getViewportsWithVolumeId(volumeId);
+        if (viewports.length) {
+            renderingEngineAndViewportIds.push({
+                renderingEngine,
+                viewportIds: viewports.map((viewport) => viewport.id),
+            });
+        }
+    });
+    return renderingEngineAndViewportIds;
+}
+export default autoLoad;

package/dist/esm/utilities/calculateViewportsSpatialRegistration.d.ts

@@ -0,0 +1,3 @@
+import type { IStackViewport, IVolumeViewport } from '../types';
+declare function calculateViewportsSpatialRegistration(viewport1: IStackViewport | IVolumeViewport, viewport2: IStackViewport | IVolumeViewport): void;
+export default calculateViewportsSpatialRegistration;

package/dist/esm/utilities/calculateViewportsSpatialRegistration.js

@@ -1,12 +1,12 @@
 import { vec3, mat4 } from 'gl-matrix';
 import spatialRegistrationMetadataProvider from './spatialRegistrationMetadataProvider';
-import { metaData } from '..';
+import { get } from '../metaData';
 const ALLOWED_DELTA = 0.05;
 function calculateViewportsSpatialRegistration(viewport1, viewport2) {
-    const imageId1 = viewport1.getCurrentImageId();
-    const imageId2 = viewport2.getCurrentImageId();
-    const imagePlaneModule1 = metaData.get('imagePlaneModule', imageId1);
-    const imagePlaneModule2 = metaData.get('imagePlaneModule', imageId2);
+    const imageId1 = viewport1.getSliceIndex();
+    const imageId2 = viewport2.getSliceIndex();
+    const imagePlaneModule1 = get('imagePlaneModule', imageId1.toString());
+    const imagePlaneModule2 = get('imagePlaneModule', imageId2.toString());
     if (!imagePlaneModule1 || !imagePlaneModule2) {
         console.log('Viewport spatial registration requires image plane module');
         return;
@@ -24,4 +24,3 @@ function calculateViewportsSpatialRegistration(viewport1, viewport2) {
     spatialRegistrationMetadataProvider.add([viewport1.id, viewport2.id], mat);
 }
 export default calculateViewportsSpatialRegistration;
-//# sourceMappingURL=calculateViewportsSpatialRegistration.js.map

package/dist/esm/utilities/calibratedPixelSpacingMetadataProvider.d.ts

@@ -0,0 +1,6 @@
+import type { IImageCalibration } from '../types/IImageCalibration';
+declare const metadataProvider: {
+    add: (imageId: string, payload: IImageCalibration) => void;
+    get: (type: string, imageId: string) => IImageCalibration;
+};
+export default metadataProvider;

package/dist/esm/utilities/calibratedPixelSpacingMetadataProvider.js

@@ -13,4 +13,3 @@ const metadataProvider = {
     },
 };
 export default metadataProvider;
-//# sourceMappingURL=calibratedPixelSpacingMetadataProvider.js.map

package/dist/esm/utilities/clamp.d.ts

@@ -0,0 +1,2 @@
+declare function clamp(value: number, min: number, max: number): number;
+export { clamp as default, clamp };

package/dist/esm/utilities/clamp.js

@@ -2,4 +2,3 @@ function clamp(value, min, max) {
     return Math.max(min, Math.min(max, value));
 }
 export { clamp as default, clamp };
-//# sourceMappingURL=clamp.js.map

package/dist/esm/utilities/clip.d.ts

@@ -0,0 +1,9 @@
+export declare function clip(val: number, low: number, high: number): number;
+export declare function clipToBox(point: {
+    x: number;
+    y: number;
+}, box: {
+    width: number;
+    height: number;
+}): void;
+export default clip;

package/dist/esm/utilities/clip.js

@@ -0,0 +1,8 @@
+export function clip(val, low, high) {
+    return Math.min(Math.max(low, val), high);
+}
+export function clipToBox(point, box) {
+    point.x = clip(point.x, 0, box.width);
+    point.y = clip(point.y, 0, box.height);
+}
+export default clip;

package/dist/esm/utilities/color.d.ts

@@ -0,0 +1,7 @@
+declare function rgbToHex(r: any, g: any, b: any): string;
+declare function hexToRgb(hex: any): {
+    r: number;
+    g: number;
+    b: number;
+};
+export { hexToRgb, rgbToHex };

package/dist/esm/utilities/color.js

@@ -16,4 +16,3 @@ function hexToRgb(hex) {
         : null;
 }
 export { hexToRgb, rgbToHex };
-//# sourceMappingURL=color.js.map

package/dist/esm/utilities/colormap.d.ts

@@ -0,0 +1,6 @@
+import type { ColormapPublic, ColormapRegistration } from '../types';
+declare function registerColormap(colormap: ColormapRegistration): void;
+declare function getColormap(name: any): any;
+declare function getColormapNames(): any[];
+declare function findMatchingColormap(rgbPoints: any, actor: any): ColormapPublic | null;
+export { getColormap, getColormapNames, registerColormap, findMatchingColormap, };

package/dist/esm/utilities/colormap.js

@@ -54,4 +54,3 @@ function findMatchingColormap(rgbPoints, actor) {
     };
 }
 export { getColormap, getColormapNames, registerColormap, findMatchingColormap, };
-//# sourceMappingURL=colormap.js.map

package/dist/esm/utilities/convertStackToVolumeViewport.d.ts

@@ -0,0 +1,12 @@
+import type { IStackViewport, IVolumeViewport, Point3 } from '../types';
+import type { OrientationAxis } from '../enums';
+declare function convertStackToVolumeViewport({ viewport, options, }: {
+    viewport: IStackViewport;
+    options?: {
+        volumeId?: string;
+        viewportId?: string;
+        background?: Point3;
+        orientation?: OrientationAxis;
+    };
+}): Promise<IVolumeViewport>;
+export { convertStackToVolumeViewport };

package/dist/esm/utilities/convertStackToVolumeViewport.js

@@ -1,17 +1,19 @@
 import { setVolumesForViewports } from '../RenderingEngine/helpers';
 import { createAndCacheVolume, getUnknownVolumeLoaderSchema, } from '../loaders/volumeLoader';
 import { Events, ViewportType } from '../enums';
-async function convertStackToVolumeViewport({ viewport, options, }) {
+import uuidv4 from './uuidv4';
+async function convertStackToVolumeViewport({ viewport, options = {}, }) {
     const renderingEngine = viewport.getRenderingEngine();
-    let { volumeId } = options;
-    if (volumeId.split(':').length === 1) {
+    let volumeId = options.volumeId || `${uuidv4()}`;
+    if (volumeId.split(':').length === 0) {
         const schema = getUnknownVolumeLoaderSchema();
         volumeId = `${schema}:${volumeId}`;
     }
     const { id, element } = viewport;
     const viewportId = options.viewportId || id;
     const imageIds = viewport.getImageIds();
-    const prevCamera = viewport.getCamera();
+    const prevViewPresentation = viewport.getViewPresentation();
+    const prevViewReference = viewport.getViewReference();
     renderingEngine.enableElement({
         viewportId,
         type: ViewportType.ORTHOGRAPHIC,
@@ -21,22 +23,17 @@ async function convertStackToVolumeViewport({ viewport, options, }) {
             orientation: options.orientation,
         },
     });
-    const volume = await createAndCacheVolume(volumeId, {
+    const volume = (await createAndCacheVolume(volumeId, {
         imageIds,
-    });
+    }));
     volume.load();
-    const volumeViewport = (renderingEngine.getViewport(viewportId));
-    setVolumesForViewports(renderingEngine, [
+    const volumeViewport = renderingEngine.getViewport(viewportId);
+    await setVolumesForViewports(renderingEngine, [
         {
             volumeId,
         },
     ], [viewportId]);
     const volumeViewportNewVolumeHandler = () => {
-        if (!options.orientation) {
-            volumeViewport.setCamera({
-                ...prevCamera,
-            });
-        }
         volumeViewport.render();
         element.removeEventListener(Events.VOLUME_VIEWPORT_NEW_VOLUME, volumeViewportNewVolumeHandler);
     };
@@ -44,8 +41,9 @@ async function convertStackToVolumeViewport({ viewport, options, }) {
         element.addEventListener(Events.VOLUME_VIEWPORT_NEW_VOLUME, volumeViewportNewVolumeHandler);
     };
     addVolumeViewportNewVolumeListener();
+    volumeViewport.setViewPresentation(prevViewPresentation);
+    volumeViewport.setViewReference(prevViewReference);
     volumeViewport.render();
     return volumeViewport;
 }
 export { convertStackToVolumeViewport };
-//# sourceMappingURL=convertStackToVolumeViewport.js.map

package/dist/esm/utilities/convertToGrayscale.d.ts

@@ -0,0 +1 @@
+export default function convertToGrayscale(scalarData: any, width: number, height: number): any;

package/dist/esm/utilities/convertToGrayscale.js

@@ -22,4 +22,3 @@ export default function convertToGrayscale(scalarData, width, height) {
         return scalarData;
     }
 }
-//# sourceMappingURL=convertToGrayscale.js.map

package/dist/esm/utilities/convertVolumeToStackViewport.d.ts

@@ -0,0 +1,9 @@
+import type * as Types from '../types';
+declare function convertVolumeToStackViewport({ viewport, options, }: {
+    viewport: Types.IVolumeViewport;
+    options: {
+        viewportId?: string;
+        background?: Types.Point3;
+    };
+}): Promise<Types.IStackViewport>;
+export { convertVolumeToStackViewport };

package/dist/esm/utilities/convertVolumeToStackViewport.js

@@ -1,15 +1,13 @@
-import cache, { ImageVolume } from '../cache';
+import cache from '../cache/cache';
+import { ImageVolume } from '../cache/classes/ImageVolume';
 import { ViewportType } from '../enums';
 async function convertVolumeToStackViewport({ viewport, options, }) {
     const volumeViewport = viewport;
     const { id, element } = volumeViewport;
     const renderingEngine = viewport.getRenderingEngine();
-    const imageIdIndex = viewport.getCurrentImageIdIndex();
     const { background } = options;
     const viewportId = options.viewportId || id;
-    const actorEntry = volumeViewport.getDefaultActor();
-    const { uid: volumeId } = actorEntry;
-    const volume = cache.getVolume(volumeId);
+    const volume = cache.getVolume(volumeViewport.getVolumeId());
     if (!(volume instanceof ImageVolume)) {
         throw new Error('Currently, you cannot decache a volume that is not an ImageVolume. So, unfortunately, volumes such as nifti  (which are basic Volume, without imageIds) cannot be decached.');
     }
@@ -21,38 +19,12 @@ async function convertVolumeToStackViewport({ viewport, options, }) {
             background,
         },
     };
+    const prevView = volumeViewport.getViewReference();
     renderingEngine.enableElement(viewportInput);
-    const stackViewport = (renderingEngine.getViewport(viewportId));
-    const hasCachedImages = volume.imageCacheOffsetMap.size > 0;
-    let isAllImagesCached = false;
-    if (hasCachedImages) {
-        isAllImagesCached = volume.imageIds.every((imageId) => cache.getImage(imageId));
-    }
-    const volumeUsedInOtherViewports = renderingEngine
-        .getVolumeViewports()
-        .find((vp) => vp.hasVolumeId(volumeId));
-    volume.decache(!volumeUsedInOtherViewports && isAllImagesCached);
-    const stack = [...volume.imageIds].reverse();
-    let imageIdIndexToJump = Math.max(volume.imageIds.length - imageIdIndex - 1, 0);
-    const imageToJump = cache.getImage(stack[imageIdIndexToJump]);
-    if (!imageToJump) {
-        let minDistance = Infinity;
-        let minDistanceIndex = null;
-        stack.forEach((imageId, index) => {
-            const image = cache.getImage(imageId);
-            if (image) {
-                const distance = Math.abs(imageIdIndexToJump - index);
-                if (distance < minDistance) {
-                    minDistance = distance;
-                    minDistanceIndex = index;
-                }
-            }
-        });
-        imageIdIndexToJump = minDistanceIndex;
-    }
-    await stackViewport.setStack(stack, imageIdIndexToJump ?? 0);
+    const stackViewport = renderingEngine.getViewport(viewportId);
+    await stackViewport.setStack(volume.imageIds);
+    stackViewport.setViewReference(prevView);
     stackViewport.render();
     return stackViewport;
 }
 export { convertVolumeToStackViewport };
-//# sourceMappingURL=convertVolumeToStackViewport.js.map

package/dist/esm/utilities/createLinearRGBTransferFunction.d.ts

@@ -0,0 +1,3 @@
+import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
+import type { VOIRange } from '../types/voi';
+export default function createLinearRGBTransferFunction(voiRange: VOIRange): vtkColorTransferFunction;

package/dist/esm/utilities/createLinearRGBTransferFunction.js

@@ -3,9 +3,7 @@ export default function createLinearRGBTransferFunction(voiRange) {
     const cfun = vtkColorTransferFunction.newInstance();
     let lower = 0;
     let upper = 1024;
-    if (voiRange &&
-        voiRange.lower !== undefined &&
-        voiRange.upper !== undefined) {
+    if (voiRange.lower !== undefined && voiRange.upper !== undefined) {
         lower = voiRange.lower;
         upper = voiRange.upper;
     }
@@ -13,4 +11,3 @@ export default function createLinearRGBTransferFunction(voiRange) {
     cfun.addRGBPoint(upper, 1.0, 1.0, 1.0);
     return cfun;
 }
-//# sourceMappingURL=createLinearRGBTransferFunction.js.map

package/dist/esm/utilities/createSigmoidRGBTransferFunction.d.ts

@@ -0,0 +1,3 @@
+import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
+import type { VOIRange } from '../types/voi';
+export default function createSigmoidRGBTransferFunction(voiRange: VOIRange, approximationNodes?: number): vtkColorTransferFunction;

package/dist/esm/utilities/createSigmoidRGBTransferFunction.js

@@ -9,15 +9,15 @@ export default function createSigmoidRGBTransferFunction(voiRange, approximation
     const logit = (y, wc, ww) => {
         return wc - (ww / 4) * Math.log((1 - y) / y);
     };
-    const range = [...Array(approximationNodes + 2).keys()]
-        .map((v) => v / (approximationNodes + 2))
-        .slice(1, -1);
-    const table = range.reduce((res, y) => {
+    const range = Array.from({ length: approximationNodes }, (_, i) => (i + 1) / (approximationNodes + 2));
+    const table = range.flatMap((y) => {
         const x = logit(y, windowCenter, windowWidth);
-        return res.concat(x, y, y, y, 0.5, 0.0);
-    }, []);
+        return [x, y, y, y, 0.5, 0.0];
+    });
     const cfun = vtkColorTransferFunction.newInstance();
-    cfun.buildFunctionFromArray(vtkDataArray.newInstance({ values: table, numberOfComponents: 6 }));
+    cfun.buildFunctionFromArray(vtkDataArray.newInstance({
+        values: table,
+        numberOfComponents: 6,
+    }));
     return cfun;
 }
-//# sourceMappingURL=createSigmoidRGBTransferFunction.js.map

package/dist/esm/utilities/decimate.d.ts

@@ -0,0 +1 @@
+export default function decimate(list: unknown[], interleave: number, offset?: number): number[];

package/dist/esm/utilities/decimate.js

@@ -5,4 +5,3 @@ export default function decimate(list, interleave, offset = 0) {
     }
     return interleaveIndices;
 }
-//# sourceMappingURL=decimate.js.map

package/dist/esm/utilities/deepClone.d.ts

@@ -0,0 +1 @@
+export declare function deepClone(obj: unknown): unknown;

package/dist/esm/utilities/deepClone.js

@@ -0,0 +1,23 @@
+export function deepClone(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    if (typeof obj === 'function') {
+        return obj;
+    }
+    if (typeof structuredClone === 'function') {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(deepClone);
+    }
+    else {
+        const clonedObj = {};
+        for (const key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                clonedObj[key] = deepClone(obj[key]);
+            }
+        }
+        return clonedObj;
+    }
+}

package/dist/esm/utilities/deepEqual.d.ts

@@ -0,0 +1 @@
+export declare function deepEqual(obj1: unknown, obj2: unknown): boolean;

package/dist/esm/utilities/deepEqual.js

@@ -0,0 +1,15 @@
+export function deepEqual(obj1, obj2) {
+    if (obj1 === obj2) {
+        return true;
+    }
+    if (obj1 == null || obj2 == null) {
+        return false;
+    }
+    try {
+        return JSON.stringify(obj1) === JSON.stringify(obj2);
+    }
+    catch (error) {
+        console.debug('Error in JSON.stringify during deep comparison:', error);
+        return obj1 === obj2;
+    }
+}

package/dist/esm/utilities/deepFreeze.d.ts

@@ -0,0 +1,2 @@
+declare function deepFreeze(object: any): any;
+export default deepFreeze;

package/dist/esm/utilities/deepFreeze.js

@@ -9,4 +9,3 @@ function deepFreeze(object) {
     return Object.freeze(object);
 }
 export default deepFreeze;
-//# sourceMappingURL=deepFreeze.js.map

package/dist/esm/utilities/deepMerge.d.ts

@@ -0,0 +1,2 @@
+declare const deepMerge: (target?: {}, source?: {}, optionsArgument?: any) => any;
+export default deepMerge;

package/dist/esm/utilities/deepMerge.js

@@ -58,4 +58,3 @@ const deepMerge = (target = {}, source = {}, optionsArgument = undefined) => {
     return mergeObject(target, source, optionsArgument);
 };
 export default deepMerge;
-//# sourceMappingURL=deepMerge.js.map

package/dist/esm/utilities/eventListener/MultiTargetEventListenerManager.d.ts

@@ -0,0 +1,7 @@
+declare class MultiTargetEventListenerManager {
+    private _targetsEventListeners;
+    addEventListener(target: EventTarget, type: string, callback: EventListener, options?: AddEventListenerOptions): void;
+    removeEventListener(target: EventTarget, type: string, callback?: EventListener, options?: EventListenerOptions): void;
+    reset(): void;
+}
+export { MultiTargetEventListenerManager as default, MultiTargetEventListenerManager, };

package/dist/esm/utilities/eventListener/MultiTargetEventListenerManager.js

@@ -29,4 +29,3 @@ class MultiTargetEventListenerManager {
     }
 }
 export { MultiTargetEventListenerManager as default, MultiTargetEventListenerManager, };
-//# sourceMappingURL=MultiTargetEventListenerManager.js.map

package/dist/esm/utilities/eventListener/TargetEventListeners.d.ts

@@ -0,0 +1,15 @@
+declare class TargetEventListeners {
+    private _target;
+    private _eventListeners;
+    private _children;
+    constructor(target: EventTarget);
+    get isEmpty(): boolean;
+    addEventListener(type: string, callback: EventListener, options?: AddEventListenerOptions): void;
+    removeEventListener(type: string, callback?: EventListener, options?: EventListenerOptions): void;
+    reset(): void;
+    private _addEventListener;
+    private _removeEventListener;
+    private _unregisterAllListeners;
+    private _unregisterAllEvents;
+}
+export { TargetEventListeners as default, TargetEventListeners };

package/dist/esm/utilities/eventListener/TargetEventListeners.js

@@ -80,7 +80,7 @@ class TargetEventListeners {
         this._target.addEventListener(type, callback, options);
     }
     _removeEventListener(type, callback, options) {
-        const useCapture = options?.capture ?? false;
+        const useCapture = options.capture ?? false;
         const listenerPhase = useCapture
             ? EventListenerPhases.Capture
             : EventListenerPhases.Bubble;
@@ -122,8 +122,9 @@ class TargetEventListeners {
         });
     }
     _unregisterAllEvents() {
-        Array.from(this._eventListeners.entries()).forEach(([type, listenersMap]) => this._unregisterAllListeners(type, listenersMap));
+        Array.from(this._eventListeners.entries()).forEach(([type, listenersMap]) => {
+            this._unregisterAllListeners(type, listenersMap);
+        });
     }
 }
 export { TargetEventListeners as default, TargetEventListeners };
-//# sourceMappingURL=TargetEventListeners.js.map

package/dist/esm/utilities/eventListener/index.js

@@ -1,3 +1,2 @@
 export { TargetEventListeners } from './TargetEventListeners';
 export { MultiTargetEventListenerManager } from './MultiTargetEventListenerManager';
-//# sourceMappingURL=index.js.map

package/dist/esm/utilities/generateVolumePropsFromImageIds.d.ts

@@ -0,0 +1,3 @@
+import type { ImageVolumeProps } from '../types';
+declare function generateVolumePropsFromImageIds(imageIds: string[], volumeId: string): ImageVolumeProps;
+export { generateVolumePropsFromImageIds };