@cornerstonejs/core 2.15.5 → 2.16.1

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

@@ -17,6 +17,7 @@ export interface ImageDataMetaData {
 }
 declare class StackViewport extends Viewport {
     private imageIds;
+    private imageKeyToIndexMap;
     private currentImageIdIndex;
     private targetImageIdIndex;
     private debouncedTimeout;
@@ -199,8 +200,9 @@ declare class StackViewport extends Viewport {
     setViewReference(viewRef: ViewReference): void;
     getViewReferenceId(specifier?: ViewReferenceSpecifier): string;
     getTargetImageIdIndex: () => number;
+    getSliceIndexForImage(reference: string | ViewReference): number;
     getImageIds: () => string[];
-    getCurrentImageId: () => string;
+    getCurrentImageId: (index?: number) => string;
     hasImageId: (imageId: string) => boolean;
     hasImageURI: (imageURI: string) => boolean;
     private getCPUFallbackError;

package/dist/esm/RenderingEngine/StackViewport.js

@@ -43,6 +43,10 @@ const EPSILON = 1;
 class StackViewport extends Viewport {
     constructor(props) {
         super(props);
+        this.imageIds = [];
+        this.imageKeyToIndexMap = new Map();
+        this.currentImageIdIndex = 0;
+        this.targetImageIdIndex = 0;
         this.imagesLoader = this;
         this.globalDefaultProperties = {};
         this.perImageIdDefaultProperties = new Map();
@@ -245,20 +249,14 @@ class StackViewport extends Viewport {
         this.getImageIds = () => {
             return this.imageIds;
         };
-        this.getCurrentImageId = () => {
-            return this.imageIds[this.currentImageIdIndex];
+        this.getCurrentImageId = (index = this.getCurrentImageIdIndex()) => {
+            return this.imageIds[index];
         };
         this.hasImageId = (imageId) => {
-            return this.imageIds.includes(imageId);
+            return this.imageKeyToIndexMap.has(imageId);
         };
         this.hasImageURI = (imageURI) => {
-            const imageIds = this.imageIds;
-            for (let i = 0; i < imageIds.length; i++) {
-                if (imageIdToURI(imageIds[i]) === imageURI) {
-                    return true;
-                }
-            }
-            return false;
+            return this.imageKeyToIndexMap.has(imageURI);
         };
         this.customRenderViewportToCanvas = () => {
             if (!this.useCPURendering) {
@@ -392,7 +390,6 @@ class StackViewport extends Viewport {
         const result = this.useCPURendering
             ? this._resetCPUFallbackElement()
             : this._resetGPUViewport();
-        this.imageIds = [];
         this.currentImageIdIndex = 0;
         this.targetImageIdIndex = 0;
         this.resetCamera();
@@ -1164,6 +1161,11 @@ class StackViewport extends Viewport {
     async setStack(imageIds, currentImageIdIndex = 0) {
         this._throwIfDestroyed();
         this.imageIds = imageIds;
+        this.imageKeyToIndexMap.clear();
+        imageIds.forEach((imageId, index) => {
+            this.imageKeyToIndexMap.set(imageId, index);
+            this.imageKeyToIndexMap.set(imageIdToURI(imageId), index);
+        });
         this.currentImageIdIndex = currentImageIdIndex;
         this.targetImageIdIndex = currentImageIdIndex;
         const imageRetrieveConfiguration = metaData.get(imageRetrieveMetadataProvider.IMAGE_RETRIEVE_CONFIGURATION, imageIds[currentImageIdIndex], 'stack');
@@ -1709,36 +1711,40 @@ class StackViewport extends Viewport {
         };
     }
     isReferenceViewable(viewRef, options = {}) {
-        if (!super.isReferenceViewable(viewRef, options)) {
+        const testIndex = this.getCurrentImageIdIndex();
+        const currentImageId = this.imageIds[testIndex];
+        if (!currentImageId || !viewRef) {
             return false;
         }
-        const { referencedImageId, sliceIndex } = viewRef;
-        if (viewRef.volumeId && !referencedImageId) {
-            return options.asVolume;
-        }
-        let testIndex = this.getCurrentImageIdIndex();
-        let currentImageId = this.imageIds[testIndex];
-        if (options.withNavigation && typeof sliceIndex === 'number') {
-            testIndex = sliceIndex;
-            currentImageId = this.imageIds[testIndex];
-        }
-        if (!currentImageId) {
-            return false;
-        }
-        if (options.asOverlay && referencedImageId) {
-            const matchedImageId = this.matchImagesForOverlay(currentImageId, referencedImageId);
-            if (matchedImageId) {
+        const { referencedImageId, multiSliceReference } = viewRef;
+        if (referencedImageId) {
+            if (referencedImageId === currentImageId) {
                 return true;
             }
+            viewRef.referencedImageURI ||= imageIdToURI(referencedImageId);
+            const { referencedImageURI: referencedImageURI } = viewRef;
+            const foundSliceIndex = this.imageKeyToIndexMap.get(referencedImageURI);
+            if (options.asOverlay) {
+                const matchedImageId = this.matchImagesForOverlay(currentImageId, referencedImageId);
+                if (matchedImageId) {
+                    return true;
+                }
+            }
+            if (foundSliceIndex === undefined) {
+                return false;
+            }
+            if (options.withNavigation) {
+                return true;
+            }
+            const rangeEndSliceIndex = multiSliceReference &&
+                this.imageKeyToIndexMap.get(multiSliceReference.referencedImageId);
+            return testIndex <= rangeEndSliceIndex && testIndex >= foundSliceIndex;
         }
-        let { imageURI } = options;
-        if (!imageURI) {
-            imageURI = imageIdToURI(currentImageId);
+        if (!super.isReferenceViewable(viewRef, options)) {
+            return false;
         }
-        const referencedImageURI = imageIdToURI(referencedImageId);
-        const matches = referencedImageURI === imageURI;
-        if (matches) {
-            return matches;
+        if (viewRef.volumeId) {
+            return options.asVolume;
         }
         const { cameraFocalPoint } = viewRef;
         if (options.asNearbyProjection && cameraFocalPoint) {
@@ -1757,7 +1763,7 @@ class StackViewport extends Viewport {
     getViewReference(viewRefSpecifier = {}) {
         const { sliceIndex = this.getCurrentImageIdIndex() } = viewRefSpecifier;
         const reference = super.getViewReference(viewRefSpecifier);
-        const referencedImageId = this.imageIds[sliceIndex];
+        const referencedImageId = this.getCurrentImageId(sliceIndex);
         if (!referencedImageId) {
             return;
         }
@@ -1772,32 +1778,38 @@ class StackViewport extends Viewport {
         return reference;
     }
     setViewReference(viewRef) {
-        if (!viewRef) {
+        if (!viewRef?.referencedImageId) {
+            if (viewRef?.sliceIndex !== undefined) {
+                this.scroll(viewRef.sliceIndex - this.targetImageIdIndex);
+            }
             return;
         }
-        const { referencedImageId, sliceIndex } = viewRef;
-        if (typeof sliceIndex === 'number' &&
-            referencedImageId &&
-            referencedImageId === this.imageIds[sliceIndex]) {
-            this.scroll(sliceIndex - this.targetImageIdIndex);
-        }
-        else {
-            const foundIndex = this.imageIds.indexOf(referencedImageId);
-            if (foundIndex !== -1) {
-                this.scroll(foundIndex - this.targetImageIdIndex);
-            }
-            else {
-                throw new Error('Unsupported - referenced image id not found');
-            }
+        const { referencedImageId } = viewRef;
+        viewRef.referencedImageURI ||= imageIdToURI(referencedImageId);
+        const { referencedImageURI: referencedImageURI } = viewRef;
+        const sliceIndex = this.imageKeyToIndexMap.get(referencedImageURI);
+        if (sliceIndex === undefined) {
+            console.error(`No image URI found for ${referencedImageURI}`);
+            return;
         }
+        this.scroll(sliceIndex - this.targetImageIdIndex);
     }
     getViewReferenceId(specifier = {}) {
-        const { sliceIndex: sliceIndex = this.currentImageIdIndex } = specifier;
-        if (Array.isArray(sliceIndex)) {
-            throw new Error('Use of slice ranges for stacks not supported');
-        }
+        const { sliceIndex = this.currentImageIdIndex } = specifier;
         return `imageId:${this.imageIds[sliceIndex]}`;
     }
+    getSliceIndexForImage(reference) {
+        if (!reference) {
+            return;
+        }
+        if (typeof reference === 'string') {
+            return this.imageKeyToIndexMap.get(reference);
+        }
+        if (reference.referencedImageId) {
+            return this.imageKeyToIndexMap.get(reference.referencedImageId);
+        }
+        return;
+    }
     getCPUFallbackError(method) {
         return new Error(`method ${method} cannot be used during CPU Fallback mode`);
     }

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

@@ -72,6 +72,7 @@ declare class VideoViewport extends Viewport {
     };
     setFrameNumber(frame: number): Promise<void>;
     setFrameRange(frameRange: number[]): void;
+    getSliceIndexForImage(reference: string | ViewReference): number;
     getFrameRange(): [number, number];
     setProperties(props: VideoViewportProperties): void;
     setPlaybackRate(rate?: number): void;
@@ -88,7 +89,7 @@ declare class VideoViewport extends Viewport {
     setAverageWhite(averageWhite: [number, number, number]): void;
     protected setColorTransform(): void;
     setCamera(camera: ICamera): void;
-    getCurrentImageId(): string;
+    getCurrentImageId(index?: number): string;
     getViewReferenceId(specifier?: ViewReferenceSpecifier): string;
     isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean;
     setViewReference(viewRef: ViewReference): void;

package/dist/esm/RenderingEngine/VideoViewport.js

@@ -8,6 +8,7 @@ import { getOrCreateCanvas } from './helpers';
 import CanvasActor from './CanvasActor';
 import cache from '../cache/cache';
 import uuidv4 from '../utilities/uuidv4';
+import FrameRange from '../utilities/FrameRange';
 import { pointInShapeCallback } from '../utilities/pointInShapeCallback';
 class VideoViewport extends Viewport {
     static { this.frameRangeExtractor = /(\/frames\/|[&?]frameNumber=)([^/&?]*)/i; }
@@ -383,6 +384,18 @@ class VideoViewport extends Viewport {
         }
         this.frameRange = [frameRange[0], frameRange[1]];
     }
+    getSliceIndexForImage(reference) {
+        if (!reference) {
+            return;
+        }
+        if (typeof reference === 'string') {
+            return FrameRange.imageIdToFrameStart(reference);
+        }
+        if (reference.referencedImageId) {
+            return FrameRange.imageIdToFrameStart(reference.referencedImageId);
+        }
+        return;
+    }
     getFrameRange() {
         return this.frameRange;
     }
@@ -579,10 +592,8 @@ class VideoViewport extends Viewport {
             this.renderFrame();
         }
     }
-    getCurrentImageId() {
-        const current = this.imageId.replace('/frames/1', this.isPlaying
-            ? `/frames/${this.frameRange[0]}-${this.frameRange[1]}`
-            : `/frames/${this.getFrameNumber()}`);
+    getCurrentImageId(index = this.getCurrentImageIdIndex()) {
+        const current = this.imageId.replace('/frames/1', `/frames/${index + 1}`);
         return current;
     }
     getViewReferenceId(specifier = {}) {
@@ -598,7 +609,7 @@ class VideoViewport extends Viewport {
     }
     isReferenceViewable(viewRef, options = {}) {
         let { imageURI } = options;
-        const { referencedImageId, sliceIndex: sliceIndex } = viewRef;
+        const { referencedImageId, sliceIndex, multiSliceReference } = viewRef;
         if (!super.isReferenceViewable(viewRef)) {
             return false;
         }
@@ -611,8 +622,9 @@ class VideoViewport extends Viewport {
             return true;
         }
         const currentIndex = this.getSliceIndex();
-        if (Array.isArray(sliceIndex)) {
-            return currentIndex >= sliceIndex[0] && currentIndex <= sliceIndex[1];
+        if (multiSliceReference) {
+            const rangeEndSliceIndex = FrameRange.imageIdToFrameEnd(multiSliceReference.referencedImageId);
+            return currentIndex >= sliceIndex && currentIndex <= rangeEndSliceIndex;
         }
         if (sliceIndex !== undefined) {
             return currentIndex === sliceIndex;
@@ -640,16 +652,21 @@ class VideoViewport extends Viewport {
         }
     }
     getViewReference(viewRefSpecifier) {
-        let sliceIndex = viewRefSpecifier?.sliceIndex;
-        if (!sliceIndex) {
-            sliceIndex = this.isPlaying
-                ? [this.frameRange[0] - 1, this.frameRange[1] - 1]
-                : this.getCurrentImageIdIndex();
-        }
+        const sliceIndex = viewRefSpecifier?.sliceIndex ??
+            (this.isPlaying ? this.frameRange[0] : this.getCurrentImageIdIndex());
+        const rangeEndSliceIndex = viewRefSpecifier?.rangeEndSliceIndex ??
+            (this.isPlaying ? this.frameRange[1] - 1 : undefined);
+        const multiSliceReference = rangeEndSliceIndex > sliceIndex
+            ? {
+                sliceIndex: rangeEndSliceIndex,
+                referencedImageId: this.getCurrentImageId(rangeEndSliceIndex),
+            }
+            : undefined;
         return {
             ...super.getViewReference(viewRefSpecifier),
             referencedImageId: this.getViewReferenceId(viewRefSpecifier),
-            sliceIndex: sliceIndex,
+            sliceIndex,
+            multiSliceReference,
         };
     }
     getFrameNumber() {

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

@@ -120,7 +120,7 @@ declare class Viewport {
     getClippingPlanesForActor(actorEntry?: ActorEntry): vtkPlane[];
     private _getWorldDistanceViewUpAndViewRight;
     getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
-    isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean | unknown;
+    isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean;
     getViewPresentation(viewPresSel?: ViewPresentationSelector): ViewPresentation;
     setViewReference(viewRef: ViewReference): void;
     setViewPresentation(viewPres: ViewPresentation): void;

package/dist/esm/RenderingEngine/Viewport.js

@@ -834,14 +834,14 @@ class Viewport {
         }
         return { widthWorld: maxX - minX, heightWorld: maxY - minY };
     }
-    getViewReference(viewRefSpecifier = {}) {
+    getViewReference(viewRefSpecifier) {
         const { focalPoint: cameraFocalPoint, viewPlaneNormal, viewUp, } = this.getCamera();
         const target = {
             FrameOfReferenceUID: this.getFrameOfReferenceUID(),
             cameraFocalPoint,
             viewPlaneNormal,
             viewUp,
-            sliceIndex: viewRefSpecifier.sliceIndex ?? this.getSliceIndex(),
+            sliceIndex: viewRefSpecifier?.sliceIndex ?? this.getSliceIndex(),
         };
         return target;
     }

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

@@ -5,12 +5,14 @@ import type ViewportType from '../enums/ViewportType';
 import type DisplayArea from './displayArea';
 import type { BoundsLPS } from './BoundsLPS';
 import type Viewport from '../RenderingEngine/Viewport';
-export interface ViewReferenceSpecifier {
-    sliceIndex?: number | [number, number];
+export type ViewReferenceSpecifier = {
+    sliceIndex?: number;
+    rangeEndSliceIndex?: number;
+    frameNumber?: number;
     forFrameOfReference?: boolean;
     points?: Point3[];
     volumeId?: string;
-}
+};
 export interface ReferenceCompatibleOptions {
     withNavigation?: boolean;
     asVolume?: boolean;
@@ -19,16 +21,21 @@ export interface ReferenceCompatibleOptions {
     asNearbyProjection?: boolean;
     asOverlay?: boolean;
 }
-export interface ViewReference {
+export type ReferencedImageRange = ViewReference & {
+    referencedImageId: string;
+};
+export type ViewReference = {
     FrameOfReferenceUID?: string;
     referencedImageId?: string;
+    referencedImageURI?: string;
+    multiSliceReference?: ReferencedImageRange;
     cameraFocalPoint?: Point3;
     viewPlaneNormal?: Point3;
     viewUp?: Point3;
-    sliceIndex?: number | [number, number];
+    sliceIndex?: number;
     volumeId?: string;
     bounds?: BoundsLPS;
-}
+};
 export interface ViewPresentation {
     slabThickness?: number;
     rotation?: number;

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

@@ -0,0 +1,9 @@
+export type FramesRange = [number, number] | number;
+export default class FrameRange {
+    protected static frameRangeExtractor: RegExp;
+    protected static imageIdToFrames(imageId: string): FramesRange;
+    static imageIdToFrameEnd(imageId: string): number;
+    static imageIdToFrameStart(imageId: string): number;
+    static framesToString(range: any): string;
+    protected static framesToImageId(imageId: string, range: FramesRange | string): string;
+}

package/dist/esm/utilities/FrameRange.js

@@ -0,0 +1,36 @@
+export default class FrameRange {
+    static { this.frameRangeExtractor = /(\/frames\/|[&?]frameNumber=)([^/&?]*)/i; }
+    static imageIdToFrames(imageId) {
+        const match = imageId.match(this.frameRangeExtractor);
+        if (!match || !match[2]) {
+            return null;
+        }
+        const range = match[2].split('-').map((it) => Number(it));
+        if (range.length === 1) {
+            return range[0];
+        }
+        return range;
+    }
+    static imageIdToFrameEnd(imageId) {
+        const range = this.imageIdToFrames(imageId);
+        return Array.isArray(range) ? range[1] : range;
+    }
+    static imageIdToFrameStart(imageId) {
+        const range = this.imageIdToFrames(imageId);
+        return Array.isArray(range) ? range[0] : range;
+    }
+    static framesToString(range) {
+        if (Array.isArray(range)) {
+            return `${range[0]}-${range[1]}`;
+        }
+        return String(range);
+    }
+    static framesToImageId(imageId, range) {
+        const match = imageId.match(this.frameRangeExtractor);
+        if (!match || !match[2]) {
+            return null;
+        }
+        const newRangeString = this.framesToString(range);
+        return imageId.replace(this.frameRangeExtractor, `${match[1]}${newRangeString}`);
+    }
+}

package/dist/esm/utilities/VoxelManager.js

@@ -71,6 +71,7 @@ export default class VoxelManager {
                     ],
                     pointInShapeFn: isInObject,
                     callback,
+                    returnPoints,
                 });
                 return pointsInShape;
             }

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

@@ -76,6 +76,7 @@ import * as transferFunctionUtils from './transferFunctionUtils';
 import * as color from './color';
 import { deepEqual } from './deepEqual';
 import type { IViewport } from '../types/IViewport';
+import FrameRange from './FrameRange';
 import getDynamicVolumeInfo from './getDynamicVolumeInfo';
 import autoLoad from './autoLoad';
 import scaleArray from './scaleArray';
@@ -87,4 +88,4 @@ import clip from './clip';
 import createSubVolume from './createSubVolume';
 import getVolumeDirectionVectors from './getVolumeDirectionVectors';
 declare const getViewportModality: (viewport: IViewport, volumeId?: string) => string;
-export { eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, planar, getMinMax, getRuntimeId, isEqual, isEqualAbs, isEqualNegative, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, };
+export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, planar, getMinMax, getRuntimeId, isEqual, isEqualAbs, isEqualNegative, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, };

package/dist/esm/utilities/index.js

@@ -75,6 +75,7 @@ import * as colormap from './colormap';
 import * as transferFunctionUtils from './transferFunctionUtils';
 import * as color from './color';
 import { deepEqual } from './deepEqual';
+import FrameRange from './FrameRange';
 import { _getViewportModality } from './getViewportModality';
 import cache from '../cache/cache';
 import getDynamicVolumeInfo from './getDynamicVolumeInfo';
@@ -88,4 +89,4 @@ import clip from './clip';
 import createSubVolume from './createSubVolume';
 import getVolumeDirectionVectors from './getVolumeDirectionVectors';
 const getViewportModality = (viewport, volumeId) => _getViewportModality(viewport, volumeId, cache.getVolume);
-export { eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, planar, getMinMax, getRuntimeId, isEqual, isEqualAbs, isEqualNegative, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, };
+export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, planar, getMinMax, getRuntimeId, isEqual, isEqualAbs, isEqualNegative, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, };

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

@@ -29,10 +29,11 @@ export declare function iterateOverPointsInShape({ imageData, bounds, scalarData
     pointInShapeFn: any;
     callback: any;
 }): PointInShape[];
-export declare function iterateOverPointsInShapeVoxelManager({ voxelManager, bounds, imageData, pointInShapeFn, callback, }: {
+export declare function iterateOverPointsInShapeVoxelManager({ voxelManager, bounds, imageData, pointInShapeFn, callback, returnPoints, }: {
     voxelManager: any;
     bounds: any;
     imageData: any;
     pointInShapeFn: any;
     callback: any;
+    returnPoints: any;
 }): PointInShape[];

package/dist/esm/utilities/pointInShapeCallback.js

@@ -73,7 +73,7 @@ export function iterateOverPointsInShape({ imageData, bounds, scalarData, pointI
     }
     return pointsInShape;
 }
-export function iterateOverPointsInShapeVoxelManager({ voxelManager, bounds, imageData, pointInShapeFn, callback, }) {
+export function iterateOverPointsInShapeVoxelManager({ voxelManager, bounds, imageData, pointInShapeFn, callback, returnPoints, }) {
     const [[iMin, iMax], [jMin, jMax], [kMin, kMax]] = bounds;
     const indexToWorld = createPositionCallback(imageData);
     const pointIJK = [0, 0, 0];
@@ -88,12 +88,14 @@ export function iterateOverPointsInShapeVoxelManager({ voxelManager, bounds, ima
                 if (pointInShapeFn(pointLPS, pointIJK)) {
                     const index = voxelManager.toIndex(pointIJK);
                     const value = voxelManager.getAtIndex(index);
-                    pointsInShape.push({
-                        value,
-                        index,
-                        pointIJK: [...pointIJK],
-                        pointLPS: pointLPS.slice(),
-                    });
+                    if (returnPoints) {
+                        pointsInShape.push({
+                            value,
+                            index,
+                            pointIJK: [...pointIJK],
+                            pointLPS: pointLPS.slice(),
+                        });
+                    }
                     callback?.({ value, index, pointIJK, pointLPS });
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "2.15.5",
+  "version": "2.16.1",
   "description": "Cornerstone3D Core",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -82,5 +82,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "382df4deb7311b011fed61935d1cccf28a27c4b8"
+  "gitHead": "bbe715cbc6c3e791783196b5016a1bdec47f46be"
 }