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

package/dist/esm/utilities/VoxelManager.js

@@ -1,3 +1,5 @@
+import { vec3 } from 'gl-matrix';
+import cache from '../cache';
 import RLEVoxelMap from './RLEVoxelMap';
 import isEqual from './isEqual';
 const DEFAULT_RLE_SIZE = 5 * 1024;
@@ -9,20 +11,24 @@ export default class VoxelManager {
             [Infinity, -Infinity],
             [Infinity, -Infinity],
         ];
-        this.numComps = 1;
+        this.numberOfComponents = 1;
+        this.scalarData = null;
+        this._sliceDataCache = null;
         this.getAtIJK = (i, j, k) => {
-            const index = i + j * this.width + k * this.frameSize;
+            const index = this.toIndex([i, j, k]);
             return this._get(index);
         };
         this.setAtIJK = (i, j, k, v) => {
-            const index = i + j * this.width + k * this.frameSize;
+            const index = this.toIndex([i, j, k]);
             if (this._set(index, v) !== false) {
                 this.modifiedSlices.add(k);
                 VoxelManager.addBounds(this.boundsIJK, [i, j, k]);
             }
         };
         this.getAtIJKPoint = ([i, j, k]) => this.getAtIJK(i, j, k);
-        this.setAtIJKPoint = ([i, j, k], v) => this.setAtIJK(i, j, k, v);
+        this.setAtIJKPoint = ([i, j, k], v) => {
+            this.setAtIJK(i, j, k, v);
+        };
         this.getAtIndex = (index) => this._get(index);
         this.setAtIndex = (index, v) => {
             if (this._set(index, v) !== false) {
@@ -31,60 +37,167 @@ export default class VoxelManager {
                 VoxelManager.addBounds(this.boundsIJK, pointIJK);
             }
         };
+        this.getMiddleSliceData = () => {
+            const middleSliceIndex = Math.floor(this.dimensions[2] / 2);
+            return this.getSliceData({
+                sliceIndex: middleSliceIndex,
+                slicePlane: 2,
+            });
+        };
         this.forEach = (callback, options) => {
-            const boundsIJK = options?.boundsIJK || this.getBoundsIJK();
-            const { isWithinObject } = options || {};
+            const boundsIJK = options.boundsIJK || this.getBoundsIJK();
+            const isInObject = options.isInObject || this.isInObject || (() => true);
+            const returnPoints = options.returnPoints || false;
+            const useLPSTransform = options.imageData;
+            const iMin = boundsIJK[0][0];
+            const iMax = boundsIJK[0][1];
+            const jMin = boundsIJK[1][0];
+            const jMax = boundsIJK[1][1];
+            const kMin = boundsIJK[2][0];
+            const kMax = boundsIJK[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);
+                }
+                return pointsInShape;
+            }
             if (this.map) {
                 for (const index of this.map.keys()) {
                     const pointIJK = this.toIJK(index);
-                    const value = this._get(index);
-                    const callbackArguments = { value, index, pointIJK };
-                    if (isWithinObject?.(callbackArguments) === false) {
+                    if (!isInObject(null, pointIJK)) {
                         continue;
                     }
-                    callback(callbackArguments);
+                    const value = this._get(index);
+                    if (returnPoints) {
+                        pointsInShape.push({
+                            value,
+                            index,
+                            pointIJK,
+                            pointLPS: null,
+                        });
+                    }
+                    callback({ value, index, pointIJK, pointLPS: null });
                 }
+                return pointsInShape;
             }
             else {
-                for (let k = boundsIJK[2][0]; k <= boundsIJK[2][1]; k++) {
+                for (let k = kMin; k <= kMax; k++) {
                     const kIndex = k * this.frameSize;
-                    for (let j = boundsIJK[1][0]; j <= boundsIJK[1][1]; j++) {
+                    for (let j = jMin; j <= jMax; j++) {
                         const jIndex = kIndex + j * this.width;
-                        for (let i = boundsIJK[0][0], index = jIndex + i; i <= boundsIJK[0][1]; i++, index++) {
+                        for (let i = iMin, index = jIndex + i; i <= iMax; i++, index++) {
                             const value = this.getAtIndex(index);
-                            const callbackArguments = { value, index, pointIJK: [i, j, k] };
-                            if (isWithinObject?.(callbackArguments) === false) {
+                            const pointIJK = [i, j, k];
+                            if (!isInObject(null, pointIJK)) {
                                 continue;
                             }
-                            callback(callbackArguments);
+                            if (returnPoints) {
+                                pointsInShape.push({
+                                    value,
+                                    index,
+                                    pointIJK,
+                                    pointLPS: null,
+                                });
+                            }
+                            callback({ value, index, pointIJK: [i, j, k], pointLPS: null });
                         }
                     }
                 }
+                return pointsInShape;
             }
         };
+        this.getSliceData = ({ sliceIndex, slicePlane, }) => {
+            const [width, height, depth] = this.dimensions;
+            const frameSize = width * height;
+            const startIndex = sliceIndex * frameSize;
+            let sliceSize;
+            const SliceDataConstructor = this.getConstructor();
+            function isValidConstructor(ctor) {
+                return typeof ctor === 'function';
+            }
+            if (!isValidConstructor(SliceDataConstructor)) {
+                return new Uint8Array(0);
+            }
+            let sliceData;
+            switch (slicePlane) {
+                case 0:
+                    sliceSize = height * depth;
+                    sliceData = new SliceDataConstructor(sliceSize);
+                    for (let i = 0; i < height; i++) {
+                        for (let j = 0; j < depth; j++) {
+                            const index = sliceIndex + i * width + j * frameSize;
+                            this.setSliceDataValue(sliceData, i * depth + j, this._get(index));
+                        }
+                    }
+                    break;
+                case 1:
+                    sliceSize = width * depth;
+                    sliceData = new SliceDataConstructor(sliceSize);
+                    for (let i = 0; i < width; i++) {
+                        for (let j = 0; j < depth; j++) {
+                            const index = i + sliceIndex * width + j * frameSize;
+                            this.setSliceDataValue(sliceData, i + j * width, this._get(index));
+                        }
+                    }
+                    break;
+                case 2:
+                    sliceSize = width * height;
+                    sliceData = new SliceDataConstructor(sliceSize);
+                    for (let i = 0; i < sliceSize; i++) {
+                        this.setSliceDataValue(sliceData, i, this._get(startIndex + i));
+                    }
+                    break;
+                default:
+                    throw new Error('Oblique plane - todo - implement as ortho normal vector');
+            }
+            return sliceData;
+        };
         this.dimensions = dimensions;
         this.width = dimensions[0];
         this.frameSize = this.width * dimensions[1];
         this._get = _get;
         this._set = _set;
     }
-    addPoint(point) {
-        const index = Array.isArray(point)
-            ? point[0] + this.width * point[1] + this.frameSize * point[2]
-            : point;
-        if (!this.points) {
-            this.points = new Set();
-        }
-        this.points.add(index);
-    }
-    getPoints() {
-        return this.points
-            ? [...this.points].map((index) => this.toIJK(index))
-            : [];
-    }
-    getPointIndices() {
-        return this.points ? [...this.points] : [];
-    }
     toIJK(index) {
         return [
             index % this.width,
@@ -101,6 +214,34 @@ export default class VoxelManager {
         }
         return this.dimensions.map((dimension) => [0, dimension - 1]);
     }
+    getScalarData() {
+        if (this.scalarData) {
+            return this.scalarData;
+        }
+        if (this._getScalarData) {
+            return this._getScalarData();
+        }
+        throw new Error('No scalar data available');
+    }
+    getScalarDataLength() {
+        if (this.scalarData) {
+            return this.scalarData.length;
+        }
+        if (this._getScalarDataLength) {
+            return this._getScalarDataLength();
+        }
+        throw new Error('No scalar data available');
+    }
+    get sizeInBytes() {
+        return this.getScalarDataLength() * this.bytePerVoxel;
+    }
+    get bytePerVoxel() {
+        if (this.scalarData) {
+            return this.scalarData.BYTES_PER_ELEMENT;
+        }
+        const value = this._get(0);
+        return value.BYTES_PER_ELEMENT;
+    }
     clear() {
         if (this.map) {
             this.map.clear();
@@ -112,6 +253,16 @@ export default class VoxelManager {
         this.modifiedSlices.clear();
         this.points?.clear();
     }
+    getConstructor() {
+        if (this.scalarData) {
+            return this.scalarData.constructor;
+        }
+        if (this._getConstructor) {
+            return this._getConstructor();
+        }
+        console.warn('No scalar data available or can be used to get the constructor');
+        return Float32Array;
+    }
     getArrayOfSlices() {
         return Array.from(this.modifiedSlices);
     }
@@ -130,9 +281,42 @@ export default class VoxelManager {
         bounds[2][0] = Math.min(point[2], bounds[2][0]);
         bounds[2][1] = Math.max(point[2], bounds[2][1]);
     }
-    static createRGBVolumeVoxelManager(dimensions, scalarData, numComponents) {
+    addPoint(point) {
+        const index = Array.isArray(point)
+            ? point[0] + this.width * point[1] + this.frameSize * point[2]
+            : point;
+        if (!this.points) {
+            this.points = new Set();
+        }
+        this.points.add(index);
+    }
+    getPoints() {
+        return this.points
+            ? [...this.points].map((index) => this.toIJK(index))
+            : [];
+    }
+    setSliceDataValue(sliceData, index, value) {
+        if (Array.isArray(value)) {
+            for (let i = 0; i < value.length; i++) {
+                sliceData[index * value.length + i] = this.toNumber(value[i]);
+            }
+        }
+        else {
+            sliceData[index] = this.toNumber(value);
+        }
+    }
+    toNumber(value) {
+        if (typeof value === 'number') {
+            return value;
+        }
+        if (Array.isArray(value)) {
+            return value[0] || 0;
+        }
+        return 0;
+    }
+    static _createRGBScalarVolumeVoxelManager({ dimensions, scalarData, numberOfComponents = 3, }) {
         const voxels = new VoxelManager(dimensions, (index) => {
-            index *= numComponents;
+            index *= numberOfComponents;
             return [scalarData[index++], scalarData[index++], scalarData[index++]];
         }, (index, v) => {
             index *= 3;
@@ -142,42 +326,261 @@ export default class VoxelManager {
             scalarData[index++] = v[2];
             return isChanged;
         });
-        voxels.numComps = numComponents;
+        voxels.numberOfComponents = numberOfComponents;
         voxels.scalarData = scalarData;
         return voxels;
     }
-    static createVolumeVoxelManager(dimensions, scalarData, numComponents = 0) {
+    static createImageVolumeVoxelManager({ dimensions, imageIds, numberOfComponents = 1, }) {
+        const pixelsPerSlice = dimensions[0] * dimensions[1];
+        function getPixelInfo(index) {
+            const sliceIndex = Math.floor(index / pixelsPerSlice);
+            const imageId = imageIds[sliceIndex];
+            const image = cache.getImage(imageId);
+            if (!image) {
+                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 };
+        }
+        function getVoxelValue(index) {
+            const { pixelData, pixelIndex } = getPixelInfo(index);
+            if (!pixelData || pixelIndex === null) {
+                return null;
+            }
+            if (numberOfComponents === 1) {
+                return pixelData[pixelIndex];
+            }
+            else {
+                return [
+                    pixelData[pixelIndex],
+                    pixelData[pixelIndex + 1],
+                    pixelData[pixelIndex + 2],
+                ];
+            }
+        }
+        function setVoxelValue(index, v) {
+            const { pixelData, pixelIndex } = getPixelInfo(index);
+            if (!pixelData || 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;
+                    }
+                }
+            }
+            return isChanged;
+        }
+        const voxelManager = new VoxelManager(dimensions, (index) => getVoxelValue(index), (index, v) => setVoxelValue(index, v));
+        voxelManager.numberOfComponents = numberOfComponents;
+        voxelManager._getConstructor = () => {
+            const { pixelData } = getPixelInfo(0);
+            return pixelData.constructor;
+        };
+        voxelManager.getMiddleSliceData = () => {
+            const middleSliceIndex = Math.floor(dimensions[2] / 2);
+            return voxelManager.getSliceData({
+                sliceIndex: middleSliceIndex,
+                slicePlane: 2,
+            });
+        };
+        voxelManager.getRange = () => {
+            let minValue, maxValue;
+            for (const imageId of imageIds) {
+                const image = cache.getImage(imageId);
+                if (image.minPixelValue < minValue) {
+                    minValue = image.minPixelValue;
+                }
+                if (image.maxPixelValue > maxValue) {
+                    maxValue = image.maxPixelValue;
+                }
+            }
+            return [minValue, maxValue];
+        };
+        voxelManager._getScalarDataLength = () => {
+            const { pixelData } = getPixelInfo(0);
+            return pixelData.length * dimensions[2];
+        };
+        voxelManager.getCompleteScalarDataArray = () => {
+            const ScalarDataConstructor = voxelManager._getConstructor();
+            const dataLength = voxelManager.getScalarDataLength();
+            const scalarData = new ScalarDataConstructor(dataLength);
+            const sliceSize = dimensions[0] * dimensions[1] * numberOfComponents;
+            for (let sliceIndex = 0; sliceIndex < dimensions[2]; sliceIndex++) {
+                const { pixelData } = getPixelInfo((sliceIndex * sliceSize) / numberOfComponents);
+                if (pixelData) {
+                    const sliceStart = sliceIndex * sliceSize;
+                    if (numberOfComponents === 1) {
+                        scalarData.set(pixelData, sliceStart);
+                    }
+                    else {
+                        for (let i = 0; i < pixelData.length; i += numberOfComponents) {
+                            for (let j = 0; j < numberOfComponents; j++) {
+                                scalarData[sliceStart + i + j] = pixelData[i + j];
+                            }
+                        }
+                    }
+                }
+            }
+            return scalarData;
+        };
+        voxelManager.setCompleteScalarDataArray = (scalarData) => {
+            const sliceSize = dimensions[0] * dimensions[1] * numberOfComponents;
+            const SliceDataConstructor = voxelManager._getConstructor();
+            for (let sliceIndex = 0; sliceIndex < dimensions[2]; sliceIndex++) {
+                const { pixelData } = getPixelInfo((sliceIndex * sliceSize) / numberOfComponents);
+                if (pixelData && SliceDataConstructor) {
+                    const sliceStart = sliceIndex * sliceSize;
+                    const sliceEnd = sliceStart + sliceSize;
+                    const sliceData = new SliceDataConstructor(sliceSize);
+                    sliceData.set(scalarData.subarray(sliceStart, sliceEnd));
+                    pixelData.set(sliceData);
+                }
+            }
+            for (let k = 0; k < dimensions[2]; k++) {
+                voxelManager.modifiedSlices.add(k);
+            }
+            voxelManager.boundsIJK = [
+                [0, dimensions[0] - 1],
+                [0, dimensions[1] - 1],
+                [0, dimensions[2] - 1],
+            ];
+        };
+        return voxelManager;
+    }
+    static createScalarVolumeVoxelManager({ dimensions, scalarData, numberOfComponents = 1, }) {
         if (dimensions.length !== 3) {
             throw new Error('Dimensions must be provided as [number, number, number] for [width, height, depth]');
         }
-        if (!numComponents) {
-            numComponents =
+        if (!numberOfComponents) {
+            numberOfComponents =
                 scalarData.length / dimensions[0] / dimensions[1] / dimensions[2];
-            if (numComponents > 4 || numComponents < 1 || numComponents === 2) {
-                throw new Error(`Number of components ${numComponents} must be 1, 3 or 4`);
+            if (numberOfComponents > 4 ||
+                numberOfComponents < 1 ||
+                numberOfComponents === 2) {
+                throw new Error(`Number of components ${numberOfComponents} must be 1, 3 or 4`);
+            }
+        }
+        if (numberOfComponents > 1) {
+            return VoxelManager._createRGBScalarVolumeVoxelManager({
+                dimensions,
+                scalarData,
+                numberOfComponents,
+            });
+        }
+        return VoxelManager._createNumberVolumeVoxelManager({
+            dimensions,
+            scalarData,
+        });
+    }
+    static createScalarDynamicVolumeVoxelManager({ imageIdGroups, dimensions, timePoint = 0, numberOfComponents = 1, }) {
+        if (!numberOfComponents) {
+            const firstImage = cache.getImage(imageIdGroups[0][0]);
+            if (!firstImage) {
+                throw new Error('Unable to determine number of components: No image found');
+            }
+            numberOfComponents =
+                firstImage.getPixelData().length / (dimensions[0] * dimensions[1]);
+            if (numberOfComponents > 4 ||
+                numberOfComponents < 1 ||
+                numberOfComponents === 2) {
+                throw new Error(`Number of components ${numberOfComponents} must be 1, 3 or 4`);
+            }
+        }
+        const voxelGroups = imageIdGroups.map((imageIds) => {
+            return VoxelManager.createImageVolumeVoxelManager({
+                dimensions,
+                imageIds,
+                numberOfComponents,
+            });
+        });
+        const voxelManager = new VoxelManager(dimensions, (index) => voxelGroups[timePoint]._get(index), (index, v) => voxelGroups[timePoint]._set(index, v));
+        voxelManager.numberOfComponents = numberOfComponents;
+        voxelManager.getScalarDataLength = () => {
+            return voxelGroups[timePoint].getScalarDataLength();
+        };
+        voxelManager.getConstructor = () => {
+            return voxelGroups[timePoint].getConstructor();
+        };
+        voxelManager.getRange = () => {
+            return voxelGroups[timePoint].getRange();
+        };
+        voxelManager.getMiddleSliceData = () => {
+            return voxelGroups[timePoint].getMiddleSliceData();
+        };
+        voxelManager.setTimePoint = (newTimePoint) => {
+            timePoint = newTimePoint;
+            voxelManager._get = (index) => voxelGroups[timePoint]._get(index);
+            voxelManager._set = (index, v) => voxelGroups[timePoint]._set(index, v);
+        };
+        voxelManager.getAtIndexAndTimePoint = (index, tp) => {
+            return voxelGroups[tp]._get(index);
+        };
+        voxelManager.getTimePointScalarData = (tp) => {
+            return voxelGroups[tp].getCompleteScalarDataArray();
+        };
+        voxelManager.getCurrentTimePointScalarData = () => {
+            return voxelGroups[timePoint].getCompleteScalarDataArray();
+        };
+        return voxelManager;
+    }
+    static createImageVoxelManager({ width, height, scalarData, numberOfComponents = 1, }) {
+        const dimensions = [width, height, 1];
+        if (!numberOfComponents) {
+            numberOfComponents = scalarData.length / width / height;
+            if (numberOfComponents > 4 ||
+                numberOfComponents < 1 ||
+                numberOfComponents === 2) {
+                throw new Error(`Number of components ${numberOfComponents} must be 1, 3 or 4`);
             }
         }
-        if (numComponents > 1) {
-            return VoxelManager.createRGBVolumeVoxelManager(dimensions, scalarData, numComponents);
+        if (numberOfComponents > 1) {
+            return VoxelManager._createRGBScalarVolumeVoxelManager({
+                dimensions,
+                scalarData,
+                numberOfComponents,
+            });
         }
-        return VoxelManager.createNumberVolumeVoxelManager(dimensions, scalarData);
+        return VoxelManager._createNumberVolumeVoxelManager({
+            dimensions,
+            scalarData,
+        });
     }
-    static createNumberVolumeVoxelManager(dimensions, scalarData) {
+    static _createNumberVolumeVoxelManager({ dimensions, scalarData, }) {
         const voxels = new VoxelManager(dimensions, (index) => scalarData[index], (index, v) => {
             const isChanged = scalarData[index] !== v;
             scalarData[index] = v;
             return isChanged;
         });
         voxels.scalarData = scalarData;
+        voxels.getMiddleSliceData = () => {
+            const middleSliceIndex = Math.floor(dimensions[2] / 2);
+            return voxels.getSliceData({
+                sliceIndex: middleSliceIndex,
+                slicePlane: 2,
+            });
+        };
         return voxels;
     }
-    static createMapVoxelManager(dimension) {
+    static createMapVoxelManager({ dimension, }) {
         const map = new Map();
         const voxelManager = new VoxelManager(dimension, map.get.bind(map), (index, v) => map.set(index, v) && true);
         voxelManager.map = map;
         return voxelManager;
     }
-    static createHistoryVoxelManager(sourceVoxelManager) {
+    static createHistoryVoxelManager({ sourceVoxelManager, }) {
         const map = new Map();
         const { dimensions } = sourceVoxelManager;
         const voxelManager = new VoxelManager(dimensions, (index) => map.get(index), function (index, v) {
@@ -198,11 +601,11 @@ export default class VoxelManager {
         voxelManager.sourceVoxelManager = sourceVoxelManager;
         return voxelManager;
     }
-    static createLazyVoxelManager(dimensions, planeFactory) {
+    static createLazyVoxelManager({ dimensions, planeFactory, }) {
         const map = new Map();
-        const [width, height, depth] = dimensions;
+        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 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) {
@@ -214,26 +617,29 @@ export default class VoxelManager {
         voxelManager.map = map;
         return voxelManager;
     }
-    static createRLEVoxelManager(dimensions) {
+    static createRLEVoxelManager({ 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));
+        const voxelManager = new VoxelManager(dimensions, (index) => map.get(index), (index, v) => {
+            map.set(index, v);
+        });
         voxelManager.map = map;
         voxelManager.getPixelData = map.getPixelData.bind(map);
         return voxelManager;
     }
     static addInstanceToImage(image) {
         const { width, height } = image;
-        const scalarData = image.getPixelData();
-        if (scalarData?.length >= width * height) {
-            image.voxelManager = VoxelManager.createVolumeVoxelManager([width, height, 1], scalarData);
+        const scalarData = image.voxelManager.getScalarData();
+        if (scalarData.length >= width * height) {
+            image.voxelManager = VoxelManager.createScalarVolumeVoxelManager({
+                dimensions: [width, height, 1],
+                scalarData,
+            });
             return;
         }
-        image.voxelManager = VoxelManager.createRLEVoxelManager([
-            width,
-            height,
-            1,
-        ]);
+        image.voxelManager = VoxelManager.createRLEVoxelManager({
+            dimensions: [width, height, 1],
+        });
         image.getPixelData = image.voxelManager.getPixelData;
         image.sizeInBytes = DEFAULT_RLE_SIZE;
     }

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

@@ -1,4 +1,4 @@
-import { Types } from '..';
+import type { Types } from '..';
 type actorTypes = 'vtkActor' | 'vtkVolume' | 'vtkImageSlice';
 export declare function isImageActor(actorEntry: Types.ActorEntry): boolean;
 export declare function actorIsA(actorEntry: Types.ActorEntry | Types.Actor, actorType: actorTypes): boolean;

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

@@ -1,3 +1,3 @@
-import { ViewportPreset } from '../types';
-import { VolumeActor } from '../types/IActor';
+import type { ViewportPreset } from '../types';
+import type { VolumeActor } from '../types/IActor';
 export default function applyPreset(actor: VolumeActor, preset: ViewportPreset): void;

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

@@ -1,3 +1,3 @@
-import { IStackViewport, IVolumeViewport } from '../types';
+import type { IStackViewport, IVolumeViewport } from '../types';
 declare function calculateViewportsSpatialRegistration(viewport1: IStackViewport | IVolumeViewport, viewport2: IStackViewport | IVolumeViewport): void;
 export default calculateViewportsSpatialRegistration;