@cornerstonejs/core 2.3.2 → 2.4.0

package/dist/esm/utilities/VoxelManager.js

@@ -2,16 +2,16 @@ import { vec3 } from 'gl-matrix';
 import cache from '../cache/cache';
 import RLEVoxelMap from './RLEVoxelMap';
 import isEqual from './isEqual';
+import { iterateOverPointsInShapeVoxelManager } from './pointInShapeCallback';
 const DEFAULT_RLE_SIZE = 5 * 1024;
 export default class VoxelManager {
-    constructor(dimensions, _get, _set) {
+    constructor(dimensions, options) {
         this.modifiedSlices = new Set();
         this.boundsIJK = [
             [Infinity, -Infinity],
             [Infinity, -Infinity],
             [Infinity, -Infinity],
         ];
-        this.numberOfComponents = 1;
         this.scalarData = null;
         this._sliceDataCache = null;
         this.getAtIJK = (i, j, k) => {
@@ -61,51 +61,23 @@ export default class VoxelManager {
             const kMax = Math.max(isInObjectBoundsIJK[2][0], isInObjectBoundsIJK[2][1]);
             const pointsInShape = [];
             if (useLPSTransform) {
-                const { imageData } = options;
-                const direction = imageData.getDirection();
-                const rowCosines = direction.slice(0, 3);
-                const columnCosines = direction.slice(3, 6);
-                const scanAxisNormal = direction.slice(6, 9);
-                const spacing = imageData.getSpacing();
-                const [rowSpacing, columnSpacing, scanAxisSpacing] = spacing;
-                const start = vec3.fromValues(iMin, jMin, kMin);
-                const worldPosStart = imageData.indexToWorld(start);
-                const rowStep = vec3.fromValues(rowCosines[0] * rowSpacing, rowCosines[1] * rowSpacing, rowCosines[2] * rowSpacing);
-                const columnStep = vec3.fromValues(columnCosines[0] * columnSpacing, columnCosines[1] * columnSpacing, columnCosines[2] * columnSpacing);
-                const scanAxisStep = vec3.fromValues(scanAxisNormal[0] * scanAxisSpacing, scanAxisNormal[1] * scanAxisSpacing, scanAxisNormal[2] * scanAxisSpacing);
-                const currentPos = vec3.clone(worldPosStart);
-                for (let k = kMin; k <= kMax; k++) {
-                    const startPosJ = vec3.clone(currentPos);
-                    for (let j = jMin; j <= jMax; j++) {
-                        const startPosI = vec3.clone(currentPos);
-                        for (let i = iMin; i <= iMax; i++) {
-                            const pointIJK = [i, j, k];
-                            if (isInObject(currentPos, pointIJK)) {
-                                const index = this.toIndex(pointIJK);
-                                const value = this._get(index);
-                                if (returnPoints) {
-                                    pointsInShape.push({
-                                        value,
-                                        index,
-                                        pointIJK,
-                                        pointLPS: currentPos.slice(),
-                                    });
-                                }
-                                if (callback) {
-                                    callback({ value, index, pointIJK, pointLPS: currentPos });
-                                }
-                            }
-                            vec3.add(currentPos, currentPos, rowStep);
-                        }
-                        vec3.copy(currentPos, startPosI);
-                        vec3.add(currentPos, currentPos, columnStep);
-                    }
-                    vec3.copy(currentPos, startPosJ);
-                    vec3.add(currentPos, currentPos, scanAxisStep);
-                }
+                const pointsInShape = iterateOverPointsInShapeVoxelManager({
+                    voxelManager: this,
+                    imageData: options.imageData,
+                    bounds: [
+                        [iMin, iMax],
+                        [jMin, jMax],
+                        [kMin, kMax],
+                    ],
+                    pointInShapeFn: isInObject,
+                    callback,
+                });
                 return pointsInShape;
             }
             if (this.map) {
+                if (this.map instanceof RLEVoxelMap) {
+                    return this.rleForEach(callback, options);
+                }
                 for (const index of this.map.keys()) {
                     const pointIJK = this.toIJK(index);
                     if (!isInObject(null, pointIJK)) {
@@ -199,8 +171,36 @@ export default class VoxelManager {
         this.dimensions = dimensions;
         this.width = dimensions[0];
         this.frameSize = this.width * dimensions[1];
-        this._get = _get;
-        this._set = _set;
+        this._get = options._get;
+        this._set = options._set;
+        this._id = options._id || '';
+        this._getConstructor = options._getConstructor;
+        this.numberOfComponents = this.numberOfComponents || 1;
+        this.scalarData = options.scalarData;
+        this._getScalarData = options._getScalarData;
+        this._updateScalarData = options._updateScalarData;
+    }
+    getMinMax() {
+        let min, max;
+        const callback = ({ value: v }) => {
+            const isArray = Array.isArray(v);
+            if (min === undefined) {
+                min = isArray ? [...v] : v;
+                max = isArray ? [...v] : v;
+            }
+            if (isArray) {
+                for (let i = 0; i < v.length; i++) {
+                    min[i] = Math.min(min[i], v[i]);
+                    max[i] = Math.max(max[i], v[i]);
+                }
+            }
+            else {
+                min = Math.min(min, v);
+                max = Math.max(max, v);
+            }
+        };
+        this.forEach(callback, { boundsIJK: this.getDefaultBounds() });
+        return { min, max };
     }
     toIJK(index) {
         return [
@@ -221,12 +221,46 @@ export default class VoxelManager {
         }
         return this.getDefaultBounds();
     }
-    getScalarData() {
+    rleForEach(callback, options) {
+        const boundsIJK = options?.boundsIJK || this.getBoundsIJK();
+        const { isWithinObject } = options || {};
+        const map = this.map;
+        map.defaultValue = undefined;
+        for (let k = boundsIJK[2][0]; k <= boundsIJK[2][1]; k++) {
+            for (let j = boundsIJK[1][0]; j <= boundsIJK[1][1]; j++) {
+                const row = map.getRun(j, k);
+                if (!row) {
+                    continue;
+                }
+                for (const rle of row) {
+                    const { start, end, value } = rle;
+                    const baseIndex = this.toIndex([0, j, k]);
+                    for (let i = start; i < end; i++) {
+                        const callbackArguments = {
+                            value,
+                            index: baseIndex + i,
+                            pointIJK: [i, j, k],
+                        };
+                        if (isWithinObject?.(callbackArguments) === false) {
+                            continue;
+                        }
+                        callback(callbackArguments);
+                    }
+                }
+            }
+        }
+    }
+    getScalarData(storeScalarData = false) {
         if (this.scalarData) {
+            this._updateScalarData?.(this.scalarData);
             return this.scalarData;
         }
         if (this._getScalarData) {
-            return this._getScalarData();
+            const scalarData = this._getScalarData();
+            if (storeScalarData) {
+                console.log('Not transient, should store value', scalarData);
+            }
+            return scalarData;
         }
         throw new Error('No scalar data available');
     }
@@ -328,25 +362,36 @@ export default class VoxelManager {
         return 0;
     }
     static _createRGBScalarVolumeVoxelManager({ dimensions, scalarData, numberOfComponents = 3, }) {
-        const voxels = new VoxelManager(dimensions, (index) => {
-            index *= numberOfComponents;
-            return [scalarData[index++], scalarData[index++], scalarData[index++]];
-        }, (index, v) => {
-            index *= 3;
-            const isChanged = !isEqual(scalarData[index], v);
-            scalarData[index++] = v[0];
-            scalarData[index++] = v[1];
-            scalarData[index++] = v[2];
-            return isChanged;
+        const voxels = new VoxelManager(dimensions, {
+            _get: (index) => {
+                index *= numberOfComponents;
+                return [
+                    scalarData[index++],
+                    scalarData[index++],
+                    scalarData[index++],
+                ];
+            },
+            _id: '_createRGBScalarVolumeVoxelManager',
+            _set: (index, v) => {
+                index *= 3;
+                const isChanged = !isEqual(scalarData[index], v);
+                scalarData[index++] = v[0];
+                scalarData[index++] = v[1];
+                scalarData[index++] = v[2];
+                return isChanged;
+            },
+            numberOfComponents,
+            scalarData,
         });
-        voxels.numberOfComponents = numberOfComponents;
-        voxels.scalarData = scalarData;
         return voxels;
     }
     static createImageVolumeVoxelManager({ dimensions, imageIds, numberOfComponents = 1, }) {
         const pixelsPerSlice = dimensions[0] * dimensions[1];
         function getPixelInfo(index) {
             const sliceIndex = Math.floor(index / pixelsPerSlice);
+            if (sliceIndex < 0 || sliceIndex >= dimensions[2]) {
+                return {};
+            }
             const imageId = imageIds[sliceIndex];
             if (!imageId) {
                 console.warn(`ImageId not found for sliceIndex: ${sliceIndex}`);
@@ -357,58 +402,44 @@ export default class VoxelManager {
                 console.warn(`Image not found for imageId: ${imageId}`);
                 return { pixelData: null, pixelIndex: null };
             }
-            const pixelData = image.voxelManager.getScalarData();
-            const pixelIndex = (index % pixelsPerSlice) * numberOfComponents;
-            return { pixelData, pixelIndex };
+            const voxelManager = image.voxelManager;
+            const pixelIndex = index % pixelsPerSlice;
+            return { voxelManager, pixelIndex };
         }
         function getVoxelValue(index) {
-            const { pixelData, pixelIndex } = getPixelInfo(index);
-            if (!pixelData || pixelIndex === null) {
+            const { voxelManager: imageVoxelManager, pixelIndex } = getPixelInfo(index);
+            if (!imageVoxelManager || pixelIndex === null) {
                 return null;
             }
-            if (numberOfComponents === 1) {
-                return pixelData[pixelIndex];
-            }
-            else {
-                return [
-                    pixelData[pixelIndex],
-                    pixelData[pixelIndex + 1],
-                    pixelData[pixelIndex + 2],
-                ];
-            }
+            return imageVoxelManager.getAtIndex(pixelIndex);
         }
         function setVoxelValue(index, v) {
-            const { pixelData, pixelIndex } = getPixelInfo(index);
-            if (!pixelData || pixelIndex === null) {
+            const { voxelManager: imageVoxelManager, pixelIndex } = getPixelInfo(index);
+            if (!imageVoxelManager || pixelIndex === null) {
                 return false;
             }
-            let isChanged = false;
-            if (numberOfComponents === 1) {
-                if (pixelData[pixelIndex] !== v) {
-                    pixelData[pixelIndex] = v;
-                    isChanged = true;
-                }
-            }
-            else {
-                const rgbValue = v;
-                for (let i = 0; i < numberOfComponents; i++) {
-                    if (pixelData[pixelIndex + i] !== rgbValue[i]) {
-                        pixelData[pixelIndex + i] = rgbValue[i];
-                        isChanged = true;
-                    }
-                }
+            const currentValue = imageVoxelManager.getAtIndex(pixelIndex);
+            const isChanged = !isEqual(v, currentValue);
+            if (!isChanged) {
+                return isChanged;
             }
-            return isChanged;
+            imageVoxelManager.setAtIndex(pixelIndex, v);
+            return true;
         }
-        const voxelManager = new VoxelManager(dimensions, (index) => getVoxelValue(index), (index, v) => setVoxelValue(index, v));
-        voxelManager.numberOfComponents = numberOfComponents;
-        voxelManager._getConstructor = () => {
+        const _getConstructor = () => {
             const pixelInfo = getPixelInfo(0);
-            if (!pixelInfo.pixelData) {
+            if (!pixelInfo?.pixelData) {
                 return null;
             }
             return pixelInfo.pixelData.constructor;
         };
+        const voxelManager = new VoxelManager(dimensions, {
+            _get: getVoxelValue,
+            _set: setVoxelValue,
+            numberOfComponents,
+            _getConstructor,
+            _id: 'createImageVolumeVoxelManager',
+        });
         voxelManager.getMiddleSliceData = () => {
             const middleSliceIndex = Math.floor(dimensions[2] / 2);
             return voxelManager.getSliceData({
@@ -543,8 +574,12 @@ export default class VoxelManager {
                 numberOfComponents,
             });
         });
-        const voxelManager = new VoxelManager(dimensions, (index) => voxelGroups[timePoint]._get(index), (index, v) => voxelGroups[timePoint]._set(index, v));
-        voxelManager.numberOfComponents = numberOfComponents;
+        const voxelManager = new VoxelManager(dimensions, {
+            _get: (index) => voxelGroups[timePoint]._get(index),
+            _set: (index, v) => voxelGroups[timePoint]._set(index, v),
+            numberOfComponents,
+            _id: 'createScalarDynamicVolumeVoxelManager',
+        });
         voxelManager.getScalarDataLength = () => {
             return voxelGroups[timePoint].getScalarDataLength();
         };
@@ -599,10 +634,14 @@ export default class VoxelManager {
         });
     }
     static _createNumberVolumeVoxelManager({ dimensions, scalarData, }) {
-        const voxels = new VoxelManager(dimensions, (index) => scalarData[index], (index, v) => {
-            const isChanged = scalarData[index] !== v;
-            scalarData[index] = v;
-            return isChanged;
+        const voxels = new VoxelManager(dimensions, {
+            _get: (index) => scalarData[index],
+            _set: (index, v) => {
+                const isChanged = scalarData[index] !== v;
+                scalarData[index] = v;
+                return isChanged;
+            },
+            _id: '_createNumberVolumeVoxelManager',
         });
         voxels.scalarData = scalarData;
         voxels.getMiddleSliceData = () => {
@@ -616,59 +655,117 @@ export default class VoxelManager {
     }
     static createMapVoxelManager({ dimension, }) {
         const map = new Map();
-        const voxelManager = new VoxelManager(dimension, map.get.bind(map), (index, v) => map.set(index, v) && true);
+        const voxelManager = new VoxelManager(dimension, {
+            _get: map.get.bind(map),
+            _set: (index, v) => map.set(index, v) && true,
+            _id: 'createMapVoxelManager',
+        });
         voxelManager.map = map;
         return voxelManager;
     }
     static createHistoryVoxelManager({ sourceVoxelManager, }) {
         const map = new Map();
         const { dimensions } = sourceVoxelManager;
-        const voxelManager = new VoxelManager(dimensions, (index) => map.get(index), function (index, v) {
-            if (!map.has(index)) {
-                const oldV = this.sourceVoxelManager.getAtIndex(index);
-                if (oldV === v) {
-                    return false;
+        const voxelManager = new VoxelManager(dimensions, {
+            _get: (index) => map.get(index),
+            _set: function (index, v) {
+                if (!map.has(index)) {
+                    const oldV = this.sourceVoxelManager.getAtIndex(index);
+                    if (oldV === v) {
+                        return false;
+                    }
+                    map.set(index, oldV);
                 }
-                map.set(index, oldV);
-            }
-            else if (v === map.get(index)) {
-                map.delete(index);
-            }
-            this.sourceVoxelManager.setAtIndex(index, v);
+                else if (v === map.get(index)) {
+                    map.delete(index);
+                }
+                this.sourceVoxelManager.setAtIndex(index, v);
+            },
+            _id: 'createHistoryVoxelManager',
         });
         voxelManager.map = map;
         voxelManager.scalarData = sourceVoxelManager.scalarData;
         voxelManager.sourceVoxelManager = sourceVoxelManager;
         return voxelManager;
     }
+    static createRLEHistoryVoxelManager(sourceVoxelManager) {
+        const { dimensions } = sourceVoxelManager;
+        const map = new RLEVoxelMap(dimensions[0], dimensions[1], dimensions[2]);
+        const voxelManager = new VoxelManager(dimensions, {
+            _get: (index) => map.get(index),
+            _set: function (index, v) {
+                const originalV = map.get(index);
+                if (originalV === undefined) {
+                    const oldV = this.sourceVoxelManager.getAtIndex(index);
+                    if (oldV === v || (oldV === undefined && v === 0) || v === null) {
+                        return false;
+                    }
+                    map.set(index, oldV ?? 0);
+                }
+                else if (v === originalV || v === null) {
+                    map.delete(index);
+                    v = originalV;
+                }
+                this.sourceVoxelManager.setAtIndex(index, v);
+            },
+            _getScalarData: RLEVoxelMap.getScalarData,
+            _updateScalarData: (scalarData) => {
+                map.updateScalarData(scalarData);
+                return scalarData;
+            },
+            _id: 'createRLEHistoryVoxelManager',
+        });
+        voxelManager.map = map;
+        voxelManager.sourceVoxelManager = sourceVoxelManager;
+        return voxelManager;
+    }
     static createLazyVoxelManager({ dimensions, planeFactory, }) {
         const map = new Map();
         const [width, height] = dimensions;
         const planeSize = width * height;
-        const voxelManager = new VoxelManager(dimensions, (index) => map.get(Math.floor(index / planeSize))[index % planeSize], (index, v) => {
-            const k = Math.floor(index / planeSize);
-            let layer = map.get(k);
-            if (!layer) {
-                layer = planeFactory(width, height);
-                map.set(k, layer);
-            }
-            layer[index % planeSize] = v;
-            return true;
+        const voxelManager = new VoxelManager(dimensions, {
+            _get: (index) => map.get(Math.floor(index / planeSize))[index % planeSize],
+            _set: (index, v) => {
+                const k = Math.floor(index / planeSize);
+                let layer = map.get(k);
+                if (!layer) {
+                    layer = planeFactory(width, height);
+                    map.set(k, layer);
+                }
+                layer[index % planeSize] = v;
+                return true;
+            },
+            _id: 'createLazyVoxelManager',
         });
         voxelManager.map = map;
         return voxelManager;
     }
-    static createRLEVoxelManager({ dimensions, }) {
+    static createRLEVolumeVoxelManager({ dimensions, }) {
         const [width, height, depth] = dimensions;
         const map = new RLEVoxelMap(width, height, depth);
-        const voxelManager = new VoxelManager(dimensions, (index) => map.get(index), (index, v) => {
-            map.set(index, v);
-            return true;
+        const voxelManager = new VoxelManager(dimensions, {
+            _get: (index) => map.get(index),
+            _set: (index, v) => {
+                map.set(index, v);
+                return true;
+            },
+            _getScalarData: RLEVoxelMap.getScalarData,
+            _updateScalarData: (scalarData) => {
+                map.updateScalarData(scalarData);
+                return scalarData;
+            },
+            _id: 'createRLEVolumeVoxelManager',
         });
         voxelManager.map = map;
         voxelManager.getPixelData = map.getPixelData.bind(map);
         return voxelManager;
     }
+    static createRLEImageVoxelManager({ dimensions, }) {
+        const [width, height] = dimensions;
+        return VoxelManager.createRLEVolumeVoxelManager({
+            dimensions: [width, height, 1],
+        });
+    }
     static addInstanceToImage(image) {
         const { width, height } = image;
         const scalarData = image.voxelManager.getScalarData();
@@ -679,7 +776,7 @@ export default class VoxelManager {
             });
             return;
         }
-        image.voxelManager = VoxelManager.createRLEVoxelManager({
+        image.voxelManager = VoxelManager.createRLEVolumeVoxelManager({
             dimensions: [width, height, 1],
         });
         image.getPixelData = image.voxelManager.getPixelData;

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

@@ -0,0 +1,2 @@
+import type { Point3 } from '../types';
+export declare function createPositionCallback(imageData: any): (ijk: any, destPoint?: any) => Point3;

package/dist/esm/utilities/createPositionCallback.js

@@ -0,0 +1,42 @@
+import * as vec3 from 'gl-matrix/vec3';
+import PointsManager from './PointsManager';
+export function createPositionCallback(imageData) {
+    const currentPos = vec3.create();
+    const dimensions = imageData.getDimensions();
+    const positionI = PointsManager.create3(dimensions[0]);
+    const positionJ = PointsManager.create3(dimensions[1]);
+    const positionK = PointsManager.create3(dimensions[2]);
+    const direction = imageData.getDirection();
+    const rowCosines = direction.slice(0, 3);
+    const columnCosines = direction.slice(3, 6);
+    const scanAxisNormal = direction.slice(6, 9);
+    const spacing = imageData.getSpacing();
+    const [rowSpacing, columnSpacing, scanAxisSpacing] = spacing;
+    const worldPosStart = imageData.indexToWorld([0, 0, 0]);
+    const rowStep = vec3.fromValues(rowCosines[0] * rowSpacing, rowCosines[1] * rowSpacing, rowCosines[2] * rowSpacing);
+    const columnStep = vec3.fromValues(columnCosines[0] * columnSpacing, columnCosines[1] * columnSpacing, columnCosines[2] * columnSpacing);
+    const scanAxisStep = vec3.fromValues(scanAxisNormal[0] * scanAxisSpacing, scanAxisNormal[1] * scanAxisSpacing, scanAxisNormal[2] * scanAxisSpacing);
+    const scaled = vec3.create();
+    for (let i = 0; i < dimensions[0]; i++) {
+        positionI.push(vec3.add(scaled, worldPosStart, vec3.scale(scaled, rowStep, i)));
+    }
+    for (let j = 0; j < dimensions[0]; j++) {
+        positionJ.push(vec3.scale(scaled, columnStep, j));
+    }
+    for (let k = 0; k < dimensions[0]; k++) {
+        positionK.push(vec3.scale(scaled, scanAxisStep, k));
+    }
+    const dataI = positionI.getTypedArray();
+    const dataJ = positionJ.getTypedArray();
+    const dataK = positionK.getTypedArray();
+    return (ijk, destPoint = currentPos) => {
+        const [i, j, k] = ijk;
+        const offsetI = i * 3;
+        const offsetJ = j * 3;
+        const offsetK = k * 3;
+        destPoint[0] = dataI[offsetI] + dataJ[offsetJ] + dataK[offsetK];
+        destPoint[1] = dataI[offsetI + 1] + dataJ[offsetJ + 1] + dataK[offsetK + 1];
+        destPoint[2] = dataI[offsetI + 2] + dataJ[offsetJ + 2] + dataK[offsetK + 2];
+        return destPoint;
+    };
+}

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

@@ -1,4 +1,4 @@
-import { vec3 } from 'gl-matrix';
+import type { vec3 } from 'gl-matrix';
 import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
 import type BoundsIJK from '../types/BoundsIJK';
 import type { CPUImageData, Point3 } from '../types';
@@ -22,3 +22,17 @@ export interface PointInShapeOptions {
     returnPoints?: boolean;
 }
 export declare function pointInShapeCallback(imageData: vtkImageData | CPUImageData, options: PointInShapeOptions): Array<PointInShape> | undefined;
+export declare function iterateOverPointsInShape({ imageData, bounds, scalarData, pointInShapeFn, callback, }: {
+    imageData: any;
+    bounds: any;
+    scalarData: any;
+    pointInShapeFn: any;
+    callback: any;
+}): PointInShape[];
+export declare function iterateOverPointsInShapeVoxelManager({ voxelManager, bounds, imageData, pointInShapeFn, callback, }: {
+    voxelManager: any;
+    bounds: any;
+    imageData: any;
+    pointInShapeFn: any;
+    callback: any;
+}): PointInShape[];