@cornerstonejs/core 2.16.0 → 2.17.0

package/dist/esm/RenderingEngine/vtkClasses/vtkStreamingOpenGLTexture.js

@@ -88,7 +88,7 @@ function vtkStreamingOpenGLTexture(publicAPI, model) {
     }
     function updateDynamicVolumeTexture() {
         const volume = cache.getVolume(model.volumeId);
-        const imageIds = volume.getCurrentTimePointImageIds();
+        const imageIds = volume.getCurrentDimensionGroupImageIds();
         if (!imageIds.length) {
             return false;
         }

package/dist/esm/cache/classes/BaseStreamingImageVolume.d.ts

@@ -81,5 +81,5 @@ export default class BaseStreamingImageVolume extends ImageVolume implements IIm
     loadImages(): Promise<boolean>;
     private _prefetchImageIds;
     private _addScalingToVolume;
-    protected checkTimePointCompletion(imageIdIndex: number): void;
+    protected checkDimensionGroupCompletion(imageIdIndex: number): void;
 }

package/dist/esm/cache/classes/BaseStreamingImageVolume.js

@@ -127,7 +127,7 @@ export default class BaseStreamingImageVolume extends ImageVolume {
         }
         this.updateTextureAndTriggerEvents(imageIdIndex, imageId, imageQualityStatus);
         if (this.isDynamicVolume()) {
-            this.checkTimePointCompletion(imageIdIndex);
+            this.checkDimensionGroupCompletion(imageIdIndex);
         }
     }
     errorCallback(imageId, permanent, error) {
@@ -343,5 +343,5 @@ export default class BaseStreamingImageVolume extends ImageVolume {
         }
         this.scaling = { PT: petScaling };
     }
-    checkTimePointCompletion(imageIdIndex) { }
+    checkDimensionGroupCompletion(imageIdIndex) { }
 }

package/dist/esm/cache/classes/ImageVolume.d.ts

@@ -10,7 +10,6 @@ export declare class ImageVolume {
     private _imageIds;
     private _imageIdsIndexMap;
     private _imageURIsIndexMap;
-    protected numFrames: number;
     protected totalNumFrames: number;
     protected cornerstoneImageMetaData: any;
     readonly volumeId: string;
@@ -39,6 +38,7 @@ export declare class ImageVolume {
     voxelManager?: IVoxelManager<number> | IVoxelManager<RGB>;
     dataType?: PixelDataTypedArrayString;
     numTimePoints?: number;
+    numFrames: number;
     constructor(props: ImageVolumeProps);
     get sizeInBytes(): number;
     get imageIds(): string[];

package/dist/esm/cache/classes/ImageVolume.js

@@ -10,6 +10,7 @@ export class ImageVolume {
         this.cornerstoneImageMetaData = null;
         this.isPreScaled = false;
         this.numTimePoints = null;
+        this.numFrames = null;
         const { imageIds, scaling, dimensions, spacing, origin, direction, dataType, volumeId, referencedVolumeId, metadata, referencedImageIds, additionalDetails, voxelManager, numberOfComponents, } = props;
         if (!dataType) {
             throw new Error('Data type is required, please provide a data type as string such as "Uint8Array", "Float32Array", etc.');

package/dist/esm/cache/classes/StreamingDynamicImageVolume.d.ts

@@ -1,10 +1,11 @@
 import type { IDynamicImageVolume, ImageVolumeProps, IStreamingVolumeProperties } from '../../types';
 import BaseStreamingImageVolume from './BaseStreamingImageVolume';
 export default class StreamingDynamicImageVolume extends BaseStreamingImageVolume implements IDynamicImageVolume {
-    private _timePointIndex;
+    private _dimensionGroupNumber;
     private _splittingTag;
     private _imageIdGroups;
-    private _loadedTimePoints;
+    private _loadedDimensionGroups;
+    numDimensionGroups: number;
     numTimePoints: number;
     constructor(imageVolumeProperties: ImageVolumeProps & {
         splittingTag: string;
@@ -13,11 +14,15 @@ export default class StreamingDynamicImageVolume extends BaseStreamingImageVolum
     private _getImageIdsToLoad;
     private _getImageIdRequests;
     getImageIdsToLoad(): string[];
-    get timePointIndex(): number;
+    get dimensionGroupNumber(): number;
     set timePointIndex(index: number);
+    set dimensionGroupNumber(dimensionGroupNumber: number);
+    get timePointIndex(): number;
     scroll(delta: number): void;
+    getCurrentDimensionGroupImageIds(): string[];
     getCurrentTimePointImageIds(): string[];
     flatImageIdIndexToTimePointIndex(flatImageIdIndex: number): number;
+    flatImageIdIndexToDimensionGroupNumber(flatImageIdIndex: number): number;
     flatImageIdIndexToImageIdIndex(flatImageIdIndex: number): number;
     get splittingTag(): string;
     getImageLoadRequests: (priority: number) => {
@@ -51,6 +56,8 @@ export default class StreamingDynamicImageVolume extends BaseStreamingImageVolum
         };
     }[];
     isTimePointLoaded(timePointIndex: number): boolean;
-    private markTimePointAsLoaded;
+    isDimensionGroupLoaded(dimensionGroupNumber: number): boolean;
+    private markDimensionGroupAsLoaded;
     protected checkTimePointCompletion(imageIdIndex: number): void;
+    protected checkDimensionGroupCompletion(imageIdIndex: number): void;
 }

package/dist/esm/cache/classes/StreamingDynamicImageVolume.js

@@ -5,8 +5,8 @@ import BaseStreamingImageVolume from './BaseStreamingImageVolume';
 export default class StreamingDynamicImageVolume extends BaseStreamingImageVolume {
     constructor(imageVolumeProperties, streamingProperties) {
         super(imageVolumeProperties, streamingProperties);
-        this._timePointIndex = 0;
-        this._loadedTimePoints = new Set();
+        this._dimensionGroupNumber = 1;
+        this._loadedDimensionGroups = new Set();
         this._getImageIdRequests = (imageIds, priority) => {
             return this.getImageIdsRequests(imageIds, priority);
         };
@@ -17,11 +17,12 @@ export default class StreamingDynamicImageVolume extends BaseStreamingImageVolum
         const { imageIdGroups, splittingTag } = imageVolumeProperties;
         this._splittingTag = splittingTag;
         this._imageIdGroups = imageIdGroups;
-        this.numTimePoints = this._imageIdGroups.length;
+        this.numDimensionGroups = this._imageIdGroups.length;
+        this.numTimePoints = this.numDimensionGroups;
     }
     _getImageIdsToLoad() {
         const imageIdGroups = this._imageIdGroups;
-        const initialImageIdGroupIndex = this._timePointIndex;
+        const initialImageIdGroupIndex = this._dimensionGroupNumber - 1;
         const imageIds = [...imageIdGroups[initialImageIdGroupIndex]];
         let leftIndex = initialImageIdGroupIndex - 1;
         let rightIndex = initialImageIdGroupIndex + 1;
@@ -38,42 +39,66 @@ export default class StreamingDynamicImageVolume extends BaseStreamingImageVolum
     getImageIdsToLoad() {
         return this._getImageIdsToLoad();
     }
-    get timePointIndex() {
-        return this._timePointIndex;
+    get dimensionGroupNumber() {
+        return this._dimensionGroupNumber;
     }
     set timePointIndex(index) {
-        if (this._timePointIndex === index) {
+        console.warn('Warning: timePointIndex is deprecated. Please use dimensionGroupNumber instead. Note that timePointIndex is zero-based while dimensionGroupNumber starts at 1.');
+        this.dimensionGroupNumber = index + 1;
+    }
+    set dimensionGroupNumber(dimensionGroupNumber) {
+        if (this._dimensionGroupNumber === dimensionGroupNumber) {
             return;
         }
-        this._timePointIndex = index;
-        this.voxelManager.setTimePoint(index);
+        this._dimensionGroupNumber = dimensionGroupNumber;
+        this.voxelManager.setDimensionGroupNumber(dimensionGroupNumber);
         this.invalidateVolume(true);
+        triggerEvent(eventTarget, Events.DYNAMIC_VOLUME_DIMENSION_GROUP_CHANGED, {
+            volumeId: this.volumeId,
+            dimensionGroupNumber: dimensionGroupNumber,
+            numDimensionGroups: this.numDimensionGroups,
+            imageIdGroupIndex: dimensionGroupNumber - 1,
+            numImageIdGroups: this.numDimensionGroups,
+            splittingTag: this.splittingTag,
+        });
         triggerEvent(eventTarget, Events.DYNAMIC_VOLUME_TIME_POINT_INDEX_CHANGED, {
             volumeId: this.volumeId,
-            timePointIndex: index,
-            numTimePoints: this.numTimePoints,
-            imageIdGroupIndex: index,
-            numImageIdGroups: this.numTimePoints,
+            timePointIndex: dimensionGroupNumber - 1,
+            numTimePoints: this.numDimensionGroups,
+            imageIdGroupIndex: dimensionGroupNumber - 1,
+            numImageIdGroups: this.numDimensionGroups,
             splittingTag: this.splittingTag,
         });
     }
+    get timePointIndex() {
+        console.warn('Warning: timePointIndex is deprecated. Please use dimensionGroupNumber instead. Note that timePointIndex is zero-based while dimensionGroupNumber starts at 1.');
+        return this._dimensionGroupNumber - 1;
+    }
     scroll(delta) {
-        const newIndex = this._timePointIndex + delta;
-        if (newIndex < 0) {
-            this.timePointIndex = this.numTimePoints - 1;
+        const newDimensionGroupNumber = this._dimensionGroupNumber + delta;
+        if (newDimensionGroupNumber < 1) {
+            this.dimensionGroupNumber = this.numDimensionGroups;
         }
-        else if (newIndex >= this.numTimePoints) {
-            this.timePointIndex = 0;
+        else if (newDimensionGroupNumber > this.numDimensionGroups) {
+            this.dimensionGroupNumber = 1;
         }
         else {
-            this.timePointIndex = newIndex;
+            this.dimensionGroupNumber = newDimensionGroupNumber;
         }
     }
+    getCurrentDimensionGroupImageIds() {
+        return this._imageIdGroups[this._dimensionGroupNumber - 1];
+    }
     getCurrentTimePointImageIds() {
-        return this._imageIdGroups[this._timePointIndex];
+        console.warn('Warning: getCurrentTimePointImageIds is deprecated. Please use getCurrentDimensionGroupImageIds instead.');
+        return this.getCurrentDimensionGroupImageIds();
     }
     flatImageIdIndexToTimePointIndex(flatImageIdIndex) {
-        return Math.floor(flatImageIdIndex / this._imageIdGroups[0].length);
+        console.warn('Warning: flatImageIdIndexToTimePointIndex is deprecated. Please use flatImageIdIndexToDimensionGroupNumber instead.');
+        return this.flatImageIdIndexToDimensionGroupNumber(flatImageIdIndex) - 1;
+    }
+    flatImageIdIndexToDimensionGroupNumber(flatImageIdIndex) {
+        return Math.floor(flatImageIdIndex / this._imageIdGroups[0].length) + 1;
     }
     flatImageIdIndexToImageIdIndex(flatImageIdIndex) {
         return flatImageIdIndex % this._imageIdGroups[0].length;
@@ -82,24 +107,36 @@ export default class StreamingDynamicImageVolume extends BaseStreamingImageVolum
         return this._splittingTag;
     }
     isTimePointLoaded(timePointIndex) {
-        return this._loadedTimePoints.has(timePointIndex);
+        console.warn('Warning: isTimePointLoaded is deprecated. Please use isDimensionGroupLoaded instead. Note that timePointIndex is zero-based while dimensionGroupNumber starts at 1.');
+        return this.isDimensionGroupLoaded(timePointIndex + 1);
+    }
+    isDimensionGroupLoaded(dimensionGroupNumber) {
+        return this._loadedDimensionGroups.has(dimensionGroupNumber);
     }
-    markTimePointAsLoaded(timePointIndex) {
-        this._loadedTimePoints.add(timePointIndex);
+    markDimensionGroupAsLoaded(dimensionGroupNumber) {
+        this._loadedDimensionGroups.add(dimensionGroupNumber);
+        triggerEvent(eventTarget, Events.DYNAMIC_VOLUME_DIMENSION_GROUP_LOADED, {
+            volumeId: this.volumeId,
+            dimensionGroupNumber: dimensionGroupNumber,
+        });
         triggerEvent(eventTarget, Events.DYNAMIC_VOLUME_TIME_POINT_LOADED, {
             volumeId: this.volumeId,
-            timePointIndex,
+            timePointIndex: dimensionGroupNumber - 1,
         });
     }
     checkTimePointCompletion(imageIdIndex) {
-        const timePointIndex = this.flatImageIdIndexToTimePointIndex(imageIdIndex);
-        const imageIdsInTimePoint = this._imageIdGroups[timePointIndex];
-        const allLoaded = imageIdsInTimePoint.every((imageId) => {
+        console.warn('Warning: checkTimePointCompletion is deprecated. Please use checkDimensionGroupCompletion instead.');
+        this.checkDimensionGroupCompletion(imageIdIndex);
+    }
+    checkDimensionGroupCompletion(imageIdIndex) {
+        const dimensionGroupNumber = this.flatImageIdIndexToDimensionGroupNumber(imageIdIndex);
+        const imageIdsInDimensionGroup = this._imageIdGroups[dimensionGroupNumber - 1];
+        const allLoaded = imageIdsInDimensionGroup.every((imageId) => {
             const index = this.getImageIdIndex(imageId);
             return this.cachedFrames[index] === ImageQualityStatus.FULL_RESOLUTION;
         });
-        if (allLoaded && !this.isTimePointLoaded(timePointIndex)) {
-            this.markTimePointAsLoaded(timePointIndex);
+        if (allLoaded && !this.isDimensionGroupLoaded(dimensionGroupNumber)) {
+            this.markDimensionGroupAsLoaded(dimensionGroupNumber);
         }
     }
 }

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

@@ -36,7 +36,9 @@ declare enum Events {
     CLIPPING_PLANES_UPDATED = "CORNERSTONE_CLIPPING_PLANES_UPDATED",
     WEB_WORKER_PROGRESS = "CORNERSTONE_WEB_WORKER_PROGRESS",
     COLORMAP_MODIFIED = "CORNERSTONE_COLORMAP_MODIFIED",
+    DYNAMIC_VOLUME_DIMENSION_GROUP_CHANGED = "DYNAMIC_VOLUME_DIMENSION_GROUP_CHANGED",
     DYNAMIC_VOLUME_TIME_POINT_INDEX_CHANGED = "DYNAMIC_VOLUME_TIME_POINT_INDEX_CHANGED",
+    DYNAMIC_VOLUME_DIMENSION_GROUP_LOADED = "DYNAMIC_VOLUME_DIMENSION_GROUP_LOADED",
     DYNAMIC_VOLUME_TIME_POINT_LOADED = "DYNAMIC_VOLUME_TIME_POINT_LOADED",
     GEOMETRY_LOADED = "GEOMETRY_LOADED",
     GEOMETRY_LOADED_FAILED = "GEOMETRY_LOADED_FAILED"

package/dist/esm/enums/Events.js

@@ -37,7 +37,9 @@ 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_DIMENSION_GROUP_CHANGED"] = "DYNAMIC_VOLUME_DIMENSION_GROUP_CHANGED";
     Events["DYNAMIC_VOLUME_TIME_POINT_INDEX_CHANGED"] = "DYNAMIC_VOLUME_TIME_POINT_INDEX_CHANGED";
+    Events["DYNAMIC_VOLUME_DIMENSION_GROUP_LOADED"] = "DYNAMIC_VOLUME_DIMENSION_GROUP_LOADED";
     Events["DYNAMIC_VOLUME_TIME_POINT_LOADED"] = "DYNAMIC_VOLUME_TIME_POINT_LOADED";
     Events["GEOMETRY_LOADED"] = "GEOMETRY_LOADED";
     Events["GEOMETRY_LOADED_FAILED"] = "GEOMETRY_LOADED_FAILED";

package/dist/esm/loaders/cornerstoneStreamingDynamicImageVolumeLoader.js

@@ -18,7 +18,7 @@ function cornerstoneStreamingDynamicImageVolumeLoader(volumeId, options) {
     const voxelManager = VoxelManager.createScalarDynamicVolumeVoxelManager({
         dimensions,
         imageIdGroups: sortedImageIdGroups,
-        timePoint: 0,
+        dimensionGroupNumber: 1,
         numberOfComponents,
     });
     let streamingImageVolume = new StreamingDynamicImageVolume({

package/dist/esm/loaders/volumeLoader.js

@@ -71,7 +71,7 @@ export function createAndCacheDerivedVolume(referencedVolumeId, options) {
     }
     const { metadata, dimensions, spacing, origin, direction } = referencedVolume;
     const referencedImageIds = referencedVolume.isDynamicVolume()
-        ? referencedVolume.getCurrentTimePointImageIds()
+        ? referencedVolume.getCurrentDimensionGroupImageIds()
         : referencedVolume.imageIds ?? [];
     const derivedImages = createAndCacheDerivedImages(referencedImageIds, {
         targetBuffer: options.targetBuffer,

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

@@ -1,7 +1,10 @@
 import type IImageVolume from './IImageVolume';
 interface IDynamicImageVolume extends IImageVolume {
+    get dimensionGroupNumber(): number;
+    set dimensionGroupNumber(dimensionGroupNumber: number);
+    get numDimensionGroups(): number;
     get timePointIndex(): number;
-    set timePointIndex(newTimePointIndex: number);
+    set timePointIndex(timePointIndex: number);
     get numTimePoints(): number;
     scroll(delta: number): void;
 }

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

@@ -93,10 +93,11 @@ export default class VoxelManager<T> {
         scalarData: any;
         numberOfComponents?: number;
     }): IVoxelManager<number> | IVoxelManager<RGB>;
-    static createScalarDynamicVolumeVoxelManager({ imageIdGroups, dimensions, timePoint, numberOfComponents, }: {
+    static createScalarDynamicVolumeVoxelManager({ imageIdGroups, dimensions, dimensionGroupNumber, timePoint, numberOfComponents, }: {
         imageIdGroups: string[][];
         dimensions: Point3;
-        timePoint: number;
+        dimensionGroupNumber?: number;
+        timePoint?: number;
         numberOfComponents?: number;
     }): IVoxelManager<number> | IVoxelManager<RGB>;
     static createImageVoxelManager({ width, height, scalarData, numberOfComponents, }: {

package/dist/esm/utilities/VoxelManager.js

@@ -71,6 +71,7 @@ export default class VoxelManager {
                     ],
                     pointInShapeFn: isInObject,
                     callback,
+                    returnPoints,
                 });
                 return pointsInShape;
             }
@@ -570,7 +571,15 @@ export default class VoxelManager {
             scalarData,
         });
     }
-    static createScalarDynamicVolumeVoxelManager({ imageIdGroups, dimensions, timePoint = 0, numberOfComponents = 1, }) {
+    static createScalarDynamicVolumeVoxelManager({ imageIdGroups, dimensions, dimensionGroupNumber = 1, timePoint = 0, numberOfComponents = 1, }) {
+        let activeDimensionGroup = 0;
+        if (dimensionGroupNumber !== undefined) {
+            activeDimensionGroup = dimensionGroupNumber - 1;
+        }
+        else if (timePoint !== undefined) {
+            console.warn('Warning: timePoint parameter is deprecated. Please use dimensionGroupNumber instead. timePoint is zero-based while dimensionGroupNumber starts at 1.');
+            activeDimensionGroup = timePoint;
+        }
         if (!numberOfComponents) {
             const firstImage = cache.getImage(imageIdGroups[0][0]);
             if (!firstImage) {
@@ -592,39 +601,59 @@ export default class VoxelManager {
             });
         });
         const voxelManager = new VoxelManager(dimensions, {
-            _get: (index) => voxelGroups[timePoint]._get(index),
-            _set: (index, v) => voxelGroups[timePoint]._set(index, v),
+            _get: (index) => voxelGroups[activeDimensionGroup]._get(index),
+            _set: (index, v) => voxelGroups[activeDimensionGroup]._set(index, v),
             numberOfComponents,
             _id: 'createScalarDynamicVolumeVoxelManager',
         });
         voxelManager.getScalarDataLength = () => {
-            return voxelGroups[timePoint].getScalarDataLength();
+            return voxelGroups[activeDimensionGroup].getScalarDataLength();
         };
         voxelManager.getConstructor = () => {
-            return voxelGroups[timePoint].getConstructor();
+            return voxelGroups[activeDimensionGroup].getConstructor();
         };
         voxelManager.getRange = () => {
-            return voxelGroups[timePoint].getRange();
+            return voxelGroups[activeDimensionGroup].getRange();
         };
         voxelManager.getMiddleSliceData = () => {
-            return voxelGroups[timePoint].getMiddleSliceData();
+            return voxelGroups[activeDimensionGroup].getMiddleSliceData();
         };
         voxelManager.setTimePoint = (newTimePoint) => {
-            timePoint = newTimePoint;
-            voxelManager._get = (index) => voxelGroups[timePoint]._get(index);
-            voxelManager._set = (index, v) => voxelGroups[timePoint]._set(index, v);
+            console.warn('Warning: setTimePoint is deprecated. Please use setDimensionGroupNumber instead. Note that timePoint is zero-based while dimensionGroupNumber starts at 1.');
+            voxelManager.setDimensionGroupNumber(newTimePoint + 1);
+        };
+        voxelManager.setDimensionGroupNumber = (newDimensionGroupNumber) => {
+            activeDimensionGroup = newDimensionGroupNumber - 1;
+            voxelManager._get = (index) => voxelGroups[activeDimensionGroup]._get(index);
+            voxelManager._set = (index, v) => voxelGroups[activeDimensionGroup]._set(index, v);
         };
         voxelManager.getAtIndexAndTimePoint = (index, tp) => {
-            return voxelGroups[tp]._get(index);
+            console.warn('Warning: getAtIndexAndTimePoint is deprecated. Please use getAtIndexAndDimensionGroup instead. Note that timePoint is zero-based while dimensionGroupNumber starts at 1.');
+            return voxelManager.getAtIndexAndDimensionGroup(index, tp + 1);
         };
-        voxelManager.getTimePointScalarData = (tp) => {
-            return voxelGroups[tp].getCompleteScalarDataArray();
+        voxelManager.getAtIndexAndDimensionGroup = (index, dimensionGroupNumber) => {
+            return voxelGroups[dimensionGroupNumber - 1]._get(index);
         };
         voxelManager.getTimePointScalarData = (tp) => {
-            return voxelGroups[tp].getCompleteScalarDataArray();
+            console.warn('Warning: getTimePointScalarData is deprecated. Please use getDimensionGroupScalarData instead. Note that timePoint is zero-based while dimensionGroupNumber starts at 1.');
+            return voxelManager.getDimensionGroupScalarData(tp + 1);
+        };
+        voxelManager.getDimensionGroupScalarData = (dimensionGroupNumber) => {
+            return voxelGroups[dimensionGroupNumber - 1].getCompleteScalarDataArray();
         };
         voxelManager.getCurrentTimePointScalarData = () => {
-            return voxelGroups[timePoint].getCompleteScalarDataArray();
+            console.warn('Warning: getCurrentTimePointScalarData is deprecated. Please use getCurrentDimensionGroupScalarData instead.');
+            return voxelManager.getCurrentDimensionGroupScalarData();
+        };
+        voxelManager.getCurrentDimensionGroupScalarData = () => {
+            return voxelGroups[activeDimensionGroup].getCompleteScalarDataArray();
+        };
+        voxelManager.getCurrentTimePoint = () => {
+            console.warn('Warning: getCurrentTimePoint is deprecated. Please use getCurrentDimensionGroupNumber instead. Note that timePoint is zero-based while dimensionGroupNumber starts at 1.');
+            return activeDimensionGroup;
+        };
+        voxelManager.getCurrentDimensionGroupNumber = () => {
+            return activeDimensionGroup + 1;
         };
         return voxelManager;
     }

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.16.0",
+  "version": "2.17.0",
   "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": "9cbc1919dc5f7a19762d526e3e3d42eec05a0e21"
+  "gitHead": "912559cd9b86ddac21f2e0d6087980fc02343f52"
 }