@cornerstonejs/tools 2.0.0-beta.20 → 2.0.0-beta.21

package/dist/esm/utilities/stackPrefetch/state.d.ts

@@ -1,3 +1,22 @@
+export interface StackPrefetchData {
+    indicesToRequest: number[];
+    currentImageIdIndex: number;
+    stackCount: number;
+    enabled: boolean;
+    direction: number;
+    cacheFill?: boolean;
+    stats: {
+        start: number;
+        imageIds: Map<string, number>;
+        decodeTimeInMS: number;
+        loadTimeInMS: number;
+        totalBytes: number;
+        initialTime?: number;
+        initialSize?: number;
+        fillTime?: number;
+        fillSize?: number;
+    };
+}
 declare function addToolState(element: HTMLDivElement, data: any): void;
-declare function getToolState(element: HTMLDivElement): any;
+declare function getToolState(element: HTMLDivElement): StackPrefetchData;
 export { addToolState, getToolState };

package/dist/esm/utilities/touch/index.d.ts

@@ -1,4 +1,4 @@
-import { IDistance, IPoints, ITouchPoints } from '../../types';
+import type { IDistance, IPoints, ITouchPoints } from '../../types';
 declare function getDeltaPoints(currentPoints: IPoints[], lastPoints: IPoints[]): IPoints;
 declare function getDeltaDistance(currentPoints: IPoints[], lastPoints: IPoints[]): IDistance;
 declare function getDeltaRotation(currentPoints: ITouchPoints[], lastPoints: ITouchPoints[]): void;

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

@@ -1,22 +1,2 @@
-declare class AnnotationRenderingEngine {
-    hasBeenDestroyed: boolean;
-    private _needsRender;
-    private _animationFrameSet;
-    private _animationFrameHandle;
-    private _viewportElements;
-    constructor();
-    addViewportElement(viewportId: string, element: HTMLDivElement): void;
-    removeViewportElement(viewportId: string, element: HTMLDivElement): void;
-    renderViewport(element: HTMLDivElement): void;
-    private _throwIfDestroyed;
-    private _renderFlaggedViewports;
-    private _setAllViewportsToBeRenderedNextFrame;
-    private _setViewportsToBeRenderedNextFrame;
-    private _render;
-    _triggerRender(element: any): void;
-    private _reset;
-}
-declare const annotationRenderingEngine: AnnotationRenderingEngine;
 declare function triggerAnnotationRender(element: HTMLDivElement): void;
-export { annotationRenderingEngine, triggerAnnotationRender };
 export default triggerAnnotationRender;

package/dist/esm/utilities/triggerAnnotationRender.js

@@ -1,116 +1,5 @@
-import { getEnabledElement, triggerEvent, getRenderingEngine, } from '@cornerstonejs/core';
-import { Events, ToolModes } from '../enums';
-import { draw as drawSvg } from '../drawingSvg';
-import getToolsWithModesForElement from './getToolsWithModesForElement';
-const { Active, Passive, Enabled } = ToolModes;
-class AnnotationRenderingEngine {
-    constructor() {
-        this._needsRender = new Set();
-        this._animationFrameSet = false;
-        this._animationFrameHandle = null;
-        this._renderFlaggedViewports = () => {
-            this._throwIfDestroyed();
-            const elements = Array.from(this._viewportElements.values());
-            for (let i = 0; i < elements.length; i++) {
-                const element = elements[i];
-                if (this._needsRender.has(element)) {
-                    this._triggerRender(element);
-                    this._needsRender.delete(element);
-                    if (this._needsRender.size === 0) {
-                        break;
-                    }
-                }
-            }
-            this._animationFrameSet = false;
-            this._animationFrameHandle = null;
-            this._render();
-        };
-        this._viewportElements = new Map();
-    }
-    addViewportElement(viewportId, element) {
-        this._viewportElements.set(viewportId, element);
-    }
-    removeViewportElement(viewportId, element) {
-        this._viewportElements.delete(viewportId);
-        this._needsRender.delete(element);
-        this._reset();
-    }
-    renderViewport(element) {
-        this._setViewportsToBeRenderedNextFrame([element]);
-    }
-    _throwIfDestroyed() {
-        if (this.hasBeenDestroyed) {
-            throw new Error('this.destroy() has been manually called to free up memory, can not longer use this instance. Instead make a new one.');
-        }
-    }
-    _setAllViewportsToBeRenderedNextFrame() {
-        const elements = [...this._viewportElements.values()];
-        elements.forEach((element) => {
-            this._needsRender.add(element);
-        });
-        this._renderFlaggedViewports();
-    }
-    _setViewportsToBeRenderedNextFrame(elements) {
-        const elementsEnabled = [...this._viewportElements.values()];
-        elements.forEach((element) => {
-            if (elementsEnabled.indexOf(element) !== -1) {
-                this._needsRender.add(element);
-            }
-        });
-        this._render();
-    }
-    _render() {
-        if (this._needsRender.size > 0 && this._animationFrameSet === false) {
-            this._animationFrameHandle = window.requestAnimationFrame(this._renderFlaggedViewports);
-            this._animationFrameSet = true;
-        }
-    }
-    _triggerRender(element) {
-        const enabledElement = getEnabledElement(element);
-        if (!enabledElement) {
-            return;
-        }
-        const renderingEngine = getRenderingEngine(enabledElement.renderingEngineId);
-        if (!renderingEngine) {
-            console.warn('rendering Engine has been destroyed');
-            return;
-        }
-        const enabledTools = getToolsWithModesForElement(element, [
-            Active,
-            Passive,
-            Enabled,
-        ]);
-        const { renderingEngineId, viewportId } = enabledElement;
-        const eventDetail = {
-            element,
-            renderingEngineId,
-            viewportId,
-        };
-        drawSvg(element, (svgDrawingHelper) => {
-            let anyRendered = false;
-            const handleDrawSvg = (tool) => {
-                if (tool.renderAnnotation) {
-                    const rendered = tool.renderAnnotation(enabledElement, svgDrawingHelper);
-                    anyRendered = anyRendered || rendered;
-                }
-            };
-            enabledTools.forEach(handleDrawSvg);
-            if (anyRendered) {
-                triggerEvent(element, Events.ANNOTATION_RENDERED, { ...eventDetail });
-            }
-        });
-    }
-    _reset() {
-        window.cancelAnimationFrame(this._animationFrameHandle);
-        this._needsRender.clear();
-        this._animationFrameSet = false;
-        this._animationFrameHandle = null;
-        this._setAllViewportsToBeRenderedNextFrame();
-    }
-}
-const annotationRenderingEngine = new AnnotationRenderingEngine();
+import { annotationRenderingEngine } from '../stateManagement/annotation/AnnotationRenderingEngine';
 function triggerAnnotationRender(element) {
     annotationRenderingEngine.renderViewport(element);
 }
-export { annotationRenderingEngine, triggerAnnotationRender };
 export default triggerAnnotationRender;

package/dist/esm/utilities/viewport/isViewportPreScaled.d.ts

@@ -1,3 +1,3 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 declare function isViewportPreScaled(viewport: Types.IStackViewport | Types.IVolumeViewport, targetId: string): boolean;
 export { isViewportPreScaled };

package/dist/esm/utilities/viewport/isViewportPreScaled.js

@@ -1,10 +1,7 @@
-import { cache, StackViewport, BaseVolumeViewport, } from '@cornerstonejs/core';
+import { cache, StackViewport, BaseVolumeViewport, utilities, } from '@cornerstonejs/core';
 function isViewportPreScaled(viewport, targetId) {
     if (viewport instanceof BaseVolumeViewport) {
-        const targetIdTokens = targetId.split('volumeId:');
-        const volumeId = targetIdTokens.length > 1
-            ? targetIdTokens[1].split('?')[0]
-            : targetIdTokens[0];
+        const volumeId = utilities.getVolumeId(targetId);
         const volume = cache.getVolume(volumeId);
         return !!volume?.scaling && Object.keys(volume.scaling).length > 0;
     }

package/dist/esm/utilities/viewport/jumpToSlice.d.ts

@@ -1,3 +1,3 @@
-import JumpToSliceOptions from '../../types/JumpToSliceOptions';
+import type JumpToSliceOptions from '../../types/JumpToSliceOptions';
 declare function jumpToSlice(element: HTMLDivElement, options?: JumpToSliceOptions): Promise<void>;
 export default jumpToSlice;

package/dist/esm/utilities/viewport/jumpToSlice.js

@@ -22,12 +22,10 @@ function _getImageSliceData(viewport, debounceLoading) {
                 : viewport.getCurrentImageIdIndex(),
         };
     }
-    else if (viewport instanceof VolumeViewport) {
-        return csUtils.getImageSliceDataForVolumeViewport(viewport);
-    }
-    else {
-        throw new Error('Unsupported viewport type');
-    }
+    return {
+        numberOfSlices: viewport.getNumberOfSlices(),
+        imageIndex: viewport.getSliceIndex(),
+    };
 }
 function _getImageIndexToJump(numberOfSlices, imageIndex) {
     const lastSliceIndex = numberOfSlices - 1;

package/dist/esm/utilities/voi/colorbar/ColorbarCanvas.d.ts

@@ -1,5 +1,5 @@
-import { IColorMapPreset } from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
-import { ColorbarCanvasProps } from './types/ColorbarCanvasProps';
+import type { IColorMapPreset } from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
+import type { ColorbarCanvasProps } from './types/ColorbarCanvasProps';
 import type { ColorbarImageRange, ColorbarVOIRange } from './types';
 import type { ColorbarSize } from './types/ColorbarSize';
 declare class ColorbarCanvas {

package/dist/esm/utilities/voi/colorbar/ViewportColorbar.d.ts

@@ -1,4 +1,4 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 import { Colorbar } from './Colorbar';
 import type { ViewportColorbarProps, ColorbarVOIRange } from './types';
 declare class ViewportColorbar extends Colorbar {

package/dist/esm/utilities/voi/colorbar/ViewportColorbar.js

@@ -28,7 +28,7 @@ class ViewportColorbar extends Colorbar {
             this.imageRange = ViewportColorbar._getImageRange(this._element);
         };
         this._imageVolumeModifiedCallback = (evt) => {
-            const { volumeId } = evt.detail.imageVolume;
+            const { volumeId } = evt.detail;
             if (volumeId !== this._volumeId) {
                 return;
             }

package/dist/esm/utilities/voi/colorbar/types/ColorbarCanvasProps.d.ts

@@ -1,4 +1,4 @@
-import { IColorMapPreset } from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
+import type { IColorMapPreset } from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
 import type { ColorbarImageRange } from './ColorbarImageRange';
 import type { ColorbarSize } from './ColorbarSize';
 import type { ColorbarVOIRange } from './ColorbarVOIRange';

package/dist/esm/utilities/voi/colorbar/types/ColorbarCommonProps.d.ts

@@ -1,4 +1,4 @@
-import { ColorbarRangeTextPosition } from '../enums/ColorbarRangeTextPosition';
+import type { ColorbarRangeTextPosition } from '../enums/ColorbarRangeTextPosition';
 import type { ColorbarImageRange, ColorbarTicksStyle, ColorbarVOIRange } from '.';
 export type ColorbarCommonProps = {
     imageRange?: ColorbarImageRange;

package/dist/esm/utilities/voi/colorbar/types/ColorbarProps.d.ts

@@ -1,6 +1,6 @@
-import { IColorMapPreset } from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
-import { WidgetProps } from '../../../../widgets/types';
-import { ColorbarCommonProps } from '.';
+import type { IColorMapPreset } from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
+import type { WidgetProps } from '../../../../widgets/types';
+import type { ColorbarCommonProps } from '.';
 export type ColorbarProps = (WidgetProps & ColorbarCommonProps) & {
     colormaps: IColorMapPreset[];
     activeColormapName?: string;

package/dist/esm/utilities/voi/windowlevel/extractWindowLevelRegionToolData.d.ts

@@ -1,4 +1,12 @@
 declare function extractWindowLevelRegionToolData(viewport: any): {
+    scalarData: import("packages/core/dist/esm/types").PixelDataTypedArray;
+    minPixelValue: number;
+    maxPixelValue: number;
+    width: number;
+    height: number;
+    rows: number;
+    columns: number;
+} | {
     scalarData: any;
     width: any;
     height: any;

package/dist/esm/utilities/voi/windowlevel/extractWindowLevelRegionToolData.js

@@ -11,20 +11,14 @@ function extractWindowLevelRegionToolData(viewport) {
 function extractImageDataVolume(viewport) {
     const { scalarData, width, height } = csUtils.getCurrentVolumeViewportSlice(viewport);
     const { min: minPixelValue, max: maxPixelValue } = csUtils.getMinMax(scalarData);
-    const volumeId = viewport.getVolumeId();
-    const volume = cache.getVolume(volumeId);
-    const { metadata, cornerstoneImageMetaData } = volume;
-    const { Rows: rows, Columns: columns } = metadata;
-    const { color } = cornerstoneImageMetaData;
     return {
         scalarData,
-        width,
-        height,
         minPixelValue,
         maxPixelValue,
-        rows,
-        columns,
-        color,
+        width,
+        height,
+        rows: width,
+        columns: height,
     };
 }
 function extractImageDataStack(viewport) {

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

@@ -1,2 +1,2 @@
-export { WidgetProps } from './WidgetProps';
-export { WidgetSize } from './WidgetSize';
+export type { WidgetProps } from './WidgetProps';
+export type { WidgetSize } from './WidgetSize';

package/dist/esm/workers/polySegConverters.js

@@ -1,14 +1,13 @@
 import { expose } from 'comlink';
+import { utilities } from '@cornerstonejs/core';
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
 import ICRPolySeg from '@icr/polyseg-wasm';
-import { utilities } from '@cornerstonejs/core';
 import vtkPlane from '@kitware/vtk.js/Common/DataModel/Plane';
 import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
 import vtkContourLoopExtraction from '@kitware/vtk.js/Filters/General/ContourLoopExtraction';
 import vtkCutter from '@kitware/vtk.js/Filters/Core/Cutter';
 import { getBoundingBoxAroundShapeWorld } from '../utilities/boundingBox';
-import { pointInShapeCallback } from '../utilities';
 import { containsPoint, getAABB, projectTo2D, } from '../utilities/math/polyline';
 import { isPlaneIntersectingAABB } from '../utilities/planar';
 const polySegConverters = {
@@ -57,7 +56,10 @@ const polySegConverters = {
             updateProgress: progressCallback,
         });
         const { segmentIndices, scalarData, annotationUIDsInSegmentMap, dimensions, origin, direction, spacing, } = args;
-        const segmentationVoxelManager = utilities.VoxelManager.createVolumeVoxelManager(dimensions, scalarData);
+        const segmentationVoxelManager = utilities.VoxelManager.createScalarVolumeVoxelManager({
+            dimensions,
+            scalarData,
+        });
         const imageData = vtkImageData.newInstance();
         imageData.setDimensions(dimensions);
         imageData.setOrigin(origin);
@@ -95,19 +97,27 @@ const polySegConverters = {
                 });
                 const firstDim = (sharedDimensionIndex + 1) % 3;
                 const secondDim = (sharedDimensionIndex + 2) % 3;
-                pointInShapeCallback(imageData, (pointLPS) => {
-                    const point2D = [pointLPS[firstDim], pointLPS[secondDim]];
-                    const isInside = containsPoint(projectedPolyline, point2D, {
-                        holes,
-                    });
-                    return isInside;
-                }, ({ pointIJK }) => {
+                const voxels = utilities.VoxelManager.createScalarVolumeVoxelManager({
+                    dimensions,
+                    scalarData,
+                });
+                voxels.forEach(({ pointIJK }) => {
                     segmentationVoxelManager.setAtIJKPoint(pointIJK, index);
-                }, [
-                    [iMin, iMax],
-                    [jMin, jMax],
-                    [kMin, kMax],
-                ]);
+                }, {
+                    imageData,
+                    isInObject: (pointLPS) => {
+                        const point2D = [pointLPS[firstDim], pointLPS[secondDim]];
+                        const isInside = containsPoint(projectedPolyline, point2D, {
+                            holes,
+                        });
+                        return isInside;
+                    },
+                    boundsIJK: [
+                        [iMin, iMax],
+                        [jMin, jMax],
+                        [kMin, kMax],
+                    ],
+                });
             }
         }
         return segmentationVoxelManager.scalarData;
@@ -122,7 +132,10 @@ const polySegConverters = {
         const segmentationVoxelManagers = new Map();
         segmentationsInfo.forEach((segmentationInfo, referencedImageId) => {
             const { dimensions, scalarData, direction, spacing, origin } = segmentationInfo;
-            const manager = utilities.VoxelManager.createVolumeVoxelManager(dimensions, scalarData);
+            const manager = utilities.VoxelManager.createScalarVolumeVoxelManager({
+                dimensions,
+                scalarData,
+            });
             const imageData = vtkImageData.newInstance();
             imageData.setDimensions(dimensions);
             imageData.setOrigin(origin);
@@ -163,19 +176,27 @@ const polySegConverters = {
                 });
                 const firstDim = (sharedDimensionIndex + 1) % 3;
                 const secondDim = (sharedDimensionIndex + 2) % 3;
-                pointInShapeCallback(imageData, (pointLPS) => {
-                    const point2D = [pointLPS[firstDim], pointLPS[secondDim]];
-                    const isInside = containsPoint(projectedPolyline, point2D, {
-                        holes,
-                    });
-                    return isInside;
-                }, ({ pointIJK }) => {
+                const voxels = utilities.VoxelManager.createScalarVolumeVoxelManager({
+                    dimensions: imageData.getDimensions(),
+                    scalarData: imageData.getPointData().getScalars().getData(),
+                });
+                voxels.forEach(({ pointIJK }) => {
                     segmentationVoxelManager.setAtIJKPoint(pointIJK, index);
-                }, [
-                    [iMin, iMax],
-                    [jMin, jMax],
-                    [kMin, kMax],
-                ]);
+                }, {
+                    imageData,
+                    isInObject: (pointLPS) => {
+                        const point2D = [pointLPS[firstDim], pointLPS[secondDim]];
+                        const isInside = containsPoint(projectedPolyline, point2D, {
+                            holes,
+                        });
+                        return isInside;
+                    },
+                    boundsIJK: [
+                        [iMin, iMax],
+                        [jMin, jMax],
+                        [kMin, kMax],
+                    ],
+                });
             }
         }
         segmentationsInfo.forEach((segmentationInfo, referencedImageId) => {
@@ -216,7 +237,12 @@ const polySegConverters = {
         });
         targetImageData.getPointData().setScalars(scalarArray);
         targetImageData.modified();
-        const segmentationVoxelManager = utilities.VoxelManager.createVolumeVoxelManager(args.dimensions, targetImageData.getPointData().getScalars().getData());
+        const { dimensions } = args;
+        const scalarData = targetImageData.getPointData().getScalars().getData();
+        const segmentationVoxelManager = utilities.VoxelManager.createScalarVolumeVoxelManager({
+            dimensions,
+            scalarData,
+        });
         const outputVolumesInfo = results.map((result) => {
             const { data, dimensions, direction, origin, spacing } = result;
             const volume = vtkImageData.newInstance();
@@ -231,7 +257,10 @@ const polySegConverters = {
             });
             volume.getPointData().setScalars(scalarArray);
             volume.modified();
-            const voxelManager = utilities.VoxelManager.createVolumeVoxelManager(dimensions, data);
+            const voxelManager = utilities.VoxelManager.createScalarVolumeVoxelManager({
+                dimensions,
+                scalarData: data,
+            });
             const extent = volume.getExtent();
             return {
                 volume,
@@ -241,7 +270,11 @@ const polySegConverters = {
                 segmentIndex: result.segmentIndex,
             };
         });
-        pointInShapeCallback(targetImageData, () => true, ({ pointIJK, pointLPS }) => {
+        const voxels = utilities.VoxelManager.createScalarVolumeVoxelManager({
+            dimensions: targetImageData.getDimensions(),
+            scalarData: targetImageData.getPointData().getScalars().getData(),
+        });
+        voxels.forEach(({ pointIJK, pointLPS }) => {
             try {
                 for (const volumeInfo of outputVolumesInfo) {
                     const { volume, extent, voxelManager, segmentIndex } = volumeInfo;
@@ -264,7 +297,7 @@ const polySegConverters = {
             }
             catch (error) {
             }
-        });
+        }, { imageData: targetImageData });
         return segmentationVoxelManager.scalarData;
     },
     getSurfacesAABBs({ surfacesInfo }) {