@cornerstonejs/core 2.0.0-beta.3 → 2.0.0-beta.30

package/dist/esm/utilities/VoxelManager.js

@@ -0,0 +1,664 @@
+import { vec3 } from 'gl-matrix';
+import cache from '../cache/cache';
+import RLEVoxelMap from './RLEVoxelMap';
+import isEqual from './isEqual';
+const DEFAULT_RLE_SIZE = 5 * 1024;
+export default class VoxelManager {
+    constructor(dimensions, _get, _set) {
+        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) => {
+            const index = this.toIndex([i, j, k]);
+            return this._get(index);
+        };
+        this.setAtIJK = (i, j, k, v) => {
+            const index = this.toIndex([i, j, k]);
+            const changed = this._set(index, v);
+            if (changed !== false) {
+                this.modifiedSlices.add(k);
+                VoxelManager.addBounds(this.boundsIJK, [i, j, k]);
+            }
+            return changed;
+        };
+        this.getAtIJKPoint = ([i, j, k]) => this.getAtIJK(i, j, k);
+        this.setAtIJKPoint = ([i, j, k], v) => {
+            this.setAtIJK(i, j, k, v);
+        };
+        this.getAtIndex = (index) => this._get(index);
+        this.setAtIndex = (index, v) => {
+            const changed = this._set(index, v);
+            if (changed !== false) {
+                const pointIJK = this.toIJK(index);
+                this.modifiedSlices.add(pointIJK[2]);
+                VoxelManager.addBounds(this.boundsIJK, pointIJK);
+            }
+            return changed;
+        };
+        this.getMiddleSliceData = () => {
+            const middleSliceIndex = Math.floor(this.dimensions[2] / 2);
+            return this.getSliceData({
+                sliceIndex: middleSliceIndex,
+                slicePlane: 2,
+            });
+        };
+        this.forEach = (callback, options = {}) => {
+            const isInObjectBoundsIJK = options.boundsIJK || this.getBoundsIJK();
+            const isInObject = options.isInObject || this.isInObject || (() => true);
+            const returnPoints = options.returnPoints || false;
+            const useLPSTransform = options.imageData;
+            const iMin = Math.min(isInObjectBoundsIJK[0][0], isInObjectBoundsIJK[0][1]);
+            const iMax = Math.max(isInObjectBoundsIJK[0][0], isInObjectBoundsIJK[0][1]);
+            const jMin = Math.min(isInObjectBoundsIJK[1][0], isInObjectBoundsIJK[1][1]);
+            const jMax = Math.max(isInObjectBoundsIJK[1][0], isInObjectBoundsIJK[1][1]);
+            const kMin = Math.min(isInObjectBoundsIJK[2][0], isInObjectBoundsIJK[2][1]);
+            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);
+                }
+                return pointsInShape;
+            }
+            if (this.map) {
+                for (const index of this.map.keys()) {
+                    const pointIJK = this.toIJK(index);
+                    if (!isInObject(null, pointIJK)) {
+                        continue;
+                    }
+                    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 = kMin; k <= kMax; k++) {
+                    const kIndex = k * this.frameSize;
+                    for (let j = jMin; j <= jMax; j++) {
+                        const jIndex = kIndex + j * this.width;
+                        for (let i = iMin, index = jIndex + i; i <= iMax; i++, index++) {
+                            const value = this.getAtIndex(index);
+                            const pointIJK = [i, j, k];
+                            if (!isInObject(null, pointIJK)) {
+                                continue;
+                            }
+                            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;
+    }
+    toIJK(index) {
+        return [
+            index % this.width,
+            Math.floor((index % this.frameSize) / this.width),
+            Math.floor(index / this.frameSize),
+        ];
+    }
+    toIndex(ijk) {
+        return ijk[0] + ijk[1] * this.width + ijk[2] * this.frameSize;
+    }
+    getDefaultBounds() {
+        return this.dimensions.map((dimension) => [0, dimension - 1]);
+    }
+    getBoundsIJK() {
+        if (this.boundsIJK[0][0] < this.dimensions[0]) {
+            return this.boundsIJK;
+        }
+        return this.getDefaultBounds();
+    }
+    getScalarData() {
+        if (this.scalarData) {
+            return this.scalarData;
+        }
+        if (this._getScalarData) {
+            return this._getScalarData();
+        }
+        throw new Error('No scalar data available');
+    }
+    setScalarData(newScalarData) {
+        this.scalarData = newScalarData;
+    }
+    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();
+        }
+        this.boundsIJK.map((bound) => {
+            bound[0] = Infinity;
+            bound[1] = -Infinity;
+        });
+        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;
+    }
+    getArrayOfModifiedSlices() {
+        return Array.from(this.modifiedSlices);
+    }
+    resetModifiedSlices() {
+        this.modifiedSlices.clear();
+    }
+    static addBounds(bounds, point) {
+        if (!bounds) {
+            bounds = [
+                [Infinity, -Infinity],
+                [Infinity, -Infinity],
+                [Infinity, -Infinity],
+            ];
+        }
+        bounds[0][0] = Math.min(point[0], bounds[0][0]);
+        bounds[0][1] = Math.max(point[0], bounds[0][1]);
+        bounds[1][0] = Math.min(point[1], bounds[1][0]);
+        bounds[1][1] = Math.max(point[1], bounds[1][1]);
+        bounds[2][0] = Math.min(point[2], bounds[2][0]);
+        bounds[2][1] = Math.max(point[2], bounds[2][1]);
+    }
+    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 *= 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;
+        });
+        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);
+            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 (!numberOfComponents) {
+            numberOfComponents =
+                scalarData.length / dimensions[0] / dimensions[1] / dimensions[2];
+            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 - 1]._get(index), (index, v) => voxelGroups[timePoint - 1]._set(index, v));
+        voxelManager.numberOfComponents = numberOfComponents;
+        voxelManager.getScalarDataLength = () => {
+            return voxelGroups[timePoint - 1].getScalarDataLength();
+        };
+        voxelManager.getConstructor = () => {
+            return voxelGroups[timePoint - 1].getConstructor();
+        };
+        voxelManager.getRange = () => {
+            return voxelGroups[timePoint - 1].getRange();
+        };
+        voxelManager.getMiddleSliceData = () => {
+            return voxelGroups[timePoint - 1].getMiddleSliceData();
+        };
+        voxelManager.setTimePoint = (newTimePoint) => {
+            timePoint = newTimePoint;
+            voxelManager._get = (index) => voxelGroups[timePoint - 1]._get(index);
+            voxelManager._set = (index, v) => voxelGroups[timePoint - 1]._set(index, v);
+        };
+        voxelManager.getAtIndexAndTimePoint = (index, tp) => {
+            return voxelGroups[tp - 1]._get(index);
+        };
+        voxelManager.getTimePointScalarData = (tp) => {
+            return voxelGroups[tp - 1].getCompleteScalarDataArray();
+        };
+        voxelManager.getTimePointScalarData = (tp) => {
+            return voxelGroups[tp - 1].getCompleteScalarDataArray();
+        };
+        voxelManager.getCurrentTimePointScalarData = () => {
+            return voxelGroups[timePoint - 1].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 (numberOfComponents > 1) {
+            return VoxelManager._createRGBScalarVolumeVoxelManager({
+                dimensions,
+                scalarData,
+                numberOfComponents,
+            });
+        }
+        return VoxelManager._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, }) {
+        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, }) {
+        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;
+                }
+                map.set(index, oldV);
+            }
+            else if (v === map.get(index)) {
+                map.delete(index);
+            }
+            this.sourceVoxelManager.setAtIndex(index, v);
+        });
+        voxelManager.map = map;
+        voxelManager.scalarData = sourceVoxelManager.scalarData;
+        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;
+        });
+        voxelManager.map = map;
+        return voxelManager;
+    }
+    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);
+            return true;
+        });
+        voxelManager.map = map;
+        voxelManager.getPixelData = map.getPixelData.bind(map);
+        return voxelManager;
+    }
+    static addInstanceToImage(image) {
+        const { width, height } = image;
+        const scalarData = image.voxelManager.getScalarData();
+        if (scalarData.length >= width * height) {
+            image.voxelManager = VoxelManager.createScalarVolumeVoxelManager({
+                dimensions: [width, height, 1],
+                scalarData,
+            });
+            return;
+        }
+        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,5 +1,5 @@
-import { Types } from '..';
-declare type actorTypes = 'vtkActor' | 'vtkVolume' | 'vtkImageSlice';
+import type { Types } from '..';
+type actorTypes = 'vtkActor' | 'vtkVolume' | 'vtkImageSlice';
 export declare function isImageActor(actorEntry: Types.ActorEntry): boolean;
-export declare function actorIsA(actorEntry: Types.ActorEntry, actorType: actorTypes): boolean;
+export declare function actorIsA(actorEntry: Types.ActorEntry | Types.Actor, actorType: actorTypes): boolean;
 export {};

package/dist/esm/utilities/actorCheck.js

@@ -2,7 +2,6 @@ export function isImageActor(actorEntry) {
     return (actorIsA(actorEntry, 'vtkVolume') || actorIsA(actorEntry, 'vtkImageSlice'));
 }
 export function actorIsA(actorEntry, actorType) {
-    const actor = actorEntry.actor;
-    return !!actor.isA(actorType);
+    const actorToCheck = 'isA' in actorEntry ? actorEntry : actorEntry.actor;
+    return !!actorToCheck.isA(actorType);
 }
-//# sourceMappingURL=actorCheck.js.map

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;