@cornerstonejs/core 2.3.3 → 2.5.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/historyMemo/index.d.ts

@@ -0,0 +1,21 @@
+export type Memo = {
+    restoreMemo: (undo?: boolean) => void;
+};
+export type Memoable = {
+    createMemo: () => Memo;
+};
+export declare class HistoryMemo {
+    readonly label: any;
+    private _size;
+    private position;
+    private redoAvailable;
+    private undoAvailable;
+    private ring;
+    constructor(label?: string, size?: number);
+    get size(): any;
+    undo(items?: number): void;
+    redo(items?: number): void;
+    push(item: Memo | Memoable): Memo;
+}
+declare const DefaultHistoryMemo: HistoryMemo;
+export { DefaultHistoryMemo };

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

@@ -0,0 +1,54 @@
+export class HistoryMemo {
+    constructor(label = 'Tools', size = 50) {
+        this.position = -1;
+        this.redoAvailable = 0;
+        this.undoAvailable = 0;
+        this.ring = new Array();
+        this.label = label;
+        this._size = size;
+    }
+    get size() {
+        return this._size;
+    }
+    undo(items = 1) {
+        while (items > 0 && this.undoAvailable > 0) {
+            const item = this.ring[this.position];
+            item.restoreMemo(true);
+            items--;
+            this.redoAvailable++;
+            this.undoAvailable--;
+            this.position = (this.position - 1 + this.size) % this.size;
+        }
+    }
+    redo(items = 1) {
+        while (items > 0 && this.redoAvailable > 0) {
+            const newPosition = (this.position + 1) % this.size;
+            const item = this.ring[newPosition];
+            item.restoreMemo(false);
+            items--;
+            this.position = newPosition;
+            this.undoAvailable++;
+            this.redoAvailable--;
+        }
+    }
+    push(item) {
+        if (!item) {
+            return;
+        }
+        const memo = item.restoreMemo
+            ? item
+            : item.createMemo?.();
+        if (!memo) {
+            return;
+        }
+        this.redoAvailable = 0;
+        if (this.undoAvailable < this._size) {
+            this.undoAvailable++;
+        }
+        this.position = (this.position + 1) % this._size;
+        this.ring[this.position] = memo;
+        return memo;
+    }
+}
+const DefaultHistoryMemo = new HistoryMemo();
+export { DefaultHistoryMemo };

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

@@ -23,6 +23,7 @@ import getViewportsWithVolumeId from './getViewportsWithVolumeId';
 import transformWorldToIndex from './transformWorldToIndex';
 import transformIndexToWorld from './transformIndexToWorld';
 import loadImageToCanvas from './loadImageToCanvas';
+import * as HistoryMemo from './historyMemo';
 import renderToCanvasCPU from './renderToCanvasCPU';
 import renderToCanvasGPU from './renderToCanvasGPU';
 import worldToImageCoords from './worldToImageCoords';
@@ -84,4 +85,4 @@ import { jumpToSlice } from './jumpToSlice';
 import scroll from './scroll';
 import clip from './clip';
 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, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, };
+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, };

package/dist/esm/utilities/index.js

@@ -23,6 +23,7 @@ import getViewportsWithVolumeId from './getViewportsWithVolumeId';
 import transformWorldToIndex from './transformWorldToIndex';
 import transformIndexToWorld from './transformIndexToWorld';
 import loadImageToCanvas from './loadImageToCanvas';
+import * as HistoryMemo from './historyMemo';
 import renderToCanvasCPU from './renderToCanvasCPU';
 import renderToCanvasGPU from './renderToCanvasGPU';
 import worldToImageCoords from './worldToImageCoords';
@@ -85,4 +86,4 @@ import { jumpToSlice } from './jumpToSlice';
 import scroll from './scroll';
 import clip from './clip';
 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, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, };
+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, };