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

package/dist/esm/utilities/RLEVoxelMap.js

@@ -0,0 +1,174 @@
+export default class RLEVoxelMap {
+    constructor(width, height, depth = 1) {
+        this.rows = new Map();
+        this.height = 1;
+        this.width = 1;
+        this.depth = 1;
+        this.jMultiple = 1;
+        this.kMultiple = 1;
+        this.numComps = 1;
+        this.defaultValue = 0;
+        this.pixelDataConstructor = Uint8Array;
+        this.get = (index) => {
+            const i = index % this.jMultiple;
+            const j = (index - i) / this.jMultiple;
+            const rle = this.getRLE(i, j);
+            return rle?.value || this.defaultValue;
+        };
+        this.getRun = (j, k) => {
+            const runIndex = j + k * this.height;
+            return this.rows.get(runIndex);
+        };
+        this.set = (index, value) => {
+            if (value === undefined) {
+                throw new Error(`Can't set undefined at ${index % this.width}`);
+            }
+            const i = index % this.width;
+            const j = (index - i) / this.width;
+            const row = this.rows.get(j);
+            if (!row) {
+                this.rows.set(j, [{ start: i, end: i + 1, value }]);
+                return;
+            }
+            const rleIndex = this.findIndex(row, i);
+            const rle1 = row[rleIndex];
+            const rle0 = row[rleIndex - 1];
+            if (!rle1) {
+                if (!rle0 || rle0.value !== value || rle0.end !== i) {
+                    row[rleIndex] = { start: i, end: i + 1, value };
+                    return;
+                }
+                rle0.end++;
+                return;
+            }
+            const { start, end, value: oldValue } = rle1;
+            if (value === oldValue && i >= start) {
+                return;
+            }
+            const rleInsert = { start: i, end: i + 1, value };
+            const isAfter = i > start;
+            const insertIndex = isAfter ? rleIndex + 1 : rleIndex;
+            const rlePrev = isAfter ? rle1 : rle0;
+            let rleNext = isAfter ? row[rleIndex + 1] : rle1;
+            if (rlePrev?.value === value && rlePrev?.end === i) {
+                rlePrev.end++;
+                if (rleNext?.value === value && rleNext.start === i + 1) {
+                    rlePrev.end = rleNext.end;
+                    row.splice(rleIndex, 1);
+                }
+                else if (rleNext?.start === i) {
+                    rleNext.start++;
+                    if (rleNext.start === rleNext.end) {
+                        row.splice(rleIndex, 1);
+                        rleNext = row[rleIndex];
+                        if (rleNext?.start === i + 1 && rleNext.value === value) {
+                            rlePrev.end = rleNext.end;
+                            row.splice(rleIndex, 1);
+                        }
+                    }
+                }
+                return;
+            }
+            if (rleNext?.value === value && rleNext.start === i + 1) {
+                rleNext.start--;
+                if (rlePrev?.end > i) {
+                    rlePrev.end = i;
+                    if (rlePrev.end === rlePrev.start) {
+                        row.splice(rleIndex, 1);
+                    }
+                }
+                return;
+            }
+            if (rleNext?.start === i && rleNext.end === i + 1) {
+                rleNext.value = value;
+                const nextnext = row[rleIndex + 1];
+                if (nextnext?.start == i + 1 && nextnext.value === value) {
+                    row.splice(rleIndex + 1, 1);
+                    rleNext.end = nextnext.end;
+                }
+                return;
+            }
+            if (i === rleNext?.start) {
+                rleNext.start++;
+            }
+            if (isAfter && end > i + 1) {
+                row.splice(insertIndex, 0, rleInsert, {
+                    start: i + 1,
+                    end: rlePrev.end,
+                    value: rlePrev.value,
+                });
+            }
+            else {
+                row.splice(insertIndex, 0, rleInsert);
+            }
+            if (rlePrev?.end > i) {
+                rlePrev.end = i;
+            }
+        };
+        this.width = width;
+        this.height = height;
+        this.depth = depth;
+        this.jMultiple = width;
+        this.kMultiple = this.jMultiple * height;
+    }
+    getRLE(i, j, k = 0) {
+        const row = this.rows.get(j + k * this.height);
+        if (!row) {
+            return;
+        }
+        const index = this.findIndex(row, i);
+        const rle = row[index];
+        return i >= rle?.start ? rle : undefined;
+    }
+    findIndex(row, i) {
+        for (let index = 0; index < row.length; index++) {
+            const { end: iEnd } = row[index];
+            if (i < iEnd) {
+                return index;
+            }
+        }
+        return row.length;
+    }
+    clear() {
+        this.rows.clear();
+    }
+    keys() {
+        return [...this.rows.keys()];
+    }
+    getPixelData(k = 0, pixelData) {
+        if (!pixelData) {
+            pixelData = new this.pixelDataConstructor(this.width * this.height * this.numComps);
+        }
+        else {
+            pixelData.fill(0);
+        }
+        const { width, height, numComps } = this;
+        for (let j = 0; j < height; j++) {
+            const row = this.getRun(j, k);
+            if (!row) {
+                continue;
+            }
+            if (numComps === 1) {
+                for (const rle of row) {
+                    const rowOffset = j * width;
+                    const { start, end, value } = rle;
+                    for (let i = start; i < end; i++) {
+                        pixelData[rowOffset + i] = value;
+                    }
+                }
+            }
+            else {
+                for (const rle of row) {
+                    const rowOffset = j * width * numComps;
+                    const { start, end, value } = rle;
+                    for (let i = start; i < end; i += numComps) {
+                        for (let comp = 0; comp < numComps; comp++) {
+                            pixelData[rowOffset + i + comp] = value[comp];
+                        }
+                    }
+                }
+            }
+        }
+        return pixelData;
+    }
+}

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

@@ -0,0 +1,44 @@
+import type { BoundsIJK, Point3, PixelDataTypedArray, IImage, RGB } from '../types';
+import RLEVoxelMap from './RLEVoxelMap';
+export default class VoxelManager<T> {
+    modifiedSlices: Set<number>;
+    boundsIJK: BoundsIJK;
+    scalarData: PixelDataTypedArray;
+    map: Map<number, T> | RLEVoxelMap<T>;
+    sourceVoxelManager: VoxelManager<T>;
+    isInObject: (pointIPS: any, pointIJK: any) => boolean;
+    readonly dimensions: Point3;
+    numComps: number;
+    points: Set<number>;
+    width: number;
+    frameSize: number;
+    _get: (index: number) => T;
+    _set: (index: number, v: T) => boolean | void;
+    constructor(dimensions: any, _get: (index: number) => T, _set?: (index: number, v: T) => boolean | void);
+    getAtIJK: (i: any, j: any, k: any) => T;
+    setAtIJK: (i: number, j: number, k: number, v: any) => void;
+    addPoint(point: Point3 | number): void;
+    getPoints(): Point3[];
+    getPointIndices(): number[];
+    getAtIJKPoint: ([i, j, k]: [any, any, any]) => T;
+    setAtIJKPoint: ([i, j, k]: Point3, v: any) => void;
+    getAtIndex: (index: any) => T;
+    setAtIndex: (index: any, v: any) => void;
+    toIJK(index: number): Point3;
+    toIndex(ijk: Point3): number;
+    getBoundsIJK(): BoundsIJK;
+    forEach: (callback: any, options?: any) => void;
+    clear(): void;
+    getArrayOfSlices(): number[];
+    static addBounds(bounds: BoundsIJK, point: Point3): void;
+    getPixelData: (sliceIndex?: number, pixelData?: PixelDataTypedArray) => PixelDataTypedArray;
+    static createRGBVolumeVoxelManager(dimensions: Point3, scalarData: any, numComponents: any): VoxelManager<RGB>;
+    static createVolumeVoxelManager(dimensions: Point3, scalarData: any, numComponents?: number): VoxelManager<number> | VoxelManager<RGB>;
+    static createNumberVolumeVoxelManager(dimensions: Point3, scalarData: any): VoxelManager<number>;
+    static createMapVoxelManager<T>(dimension: Point3): VoxelManager<T>;
+    static createHistoryVoxelManager<T>(sourceVoxelManager: VoxelManager<T>): VoxelManager<T>;
+    static createLazyVoxelManager<T>(dimensions: Point3, planeFactory: (width: number, height: number) => T): VoxelManager<T>;
+    static createRLEVoxelManager<T>(dimensions: Point3): VoxelManager<T>;
+    static addInstanceToImage(image: IImage): void;
+}
+export type { VoxelManager };

package/dist/esm/utilities/VoxelManager.js

@@ -0,0 +1,240 @@
+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.numComps = 1;
+        this.getAtIJK = (i, j, k) => {
+            const index = i + j * this.width + k * this.frameSize;
+            return this._get(index);
+        };
+        this.setAtIJK = (i, j, k, v) => {
+            const index = i + j * this.width + k * this.frameSize;
+            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.getAtIndex = (index) => this._get(index);
+        this.setAtIndex = (index, v) => {
+            if (this._set(index, v) !== false) {
+                const pointIJK = this.toIJK(index);
+                this.modifiedSlices.add(pointIJK[2]);
+                VoxelManager.addBounds(this.boundsIJK, pointIJK);
+            }
+        };
+        this.forEach = (callback, options) => {
+            const boundsIJK = options?.boundsIJK || this.getBoundsIJK();
+            const { isWithinObject } = options || {};
+            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) {
+                        continue;
+                    }
+                    callback(callbackArguments);
+                }
+            }
+            else {
+                for (let k = boundsIJK[2][0]; k <= boundsIJK[2][1]; k++) {
+                    const kIndex = k * this.frameSize;
+                    for (let j = boundsIJK[1][0]; j <= boundsIJK[1][1]; j++) {
+                        const jIndex = kIndex + j * this.width;
+                        for (let i = boundsIJK[0][0], index = jIndex + i; i <= boundsIJK[0][1]; i++, index++) {
+                            const value = this.getAtIndex(index);
+                            const callbackArguments = { value, index, pointIJK: [i, j, k] };
+                            if (isWithinObject?.(callbackArguments) === false) {
+                                continue;
+                            }
+                            callback(callbackArguments);
+                        }
+                    }
+                }
+            }
+        };
+        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,
+            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;
+    }
+    getBoundsIJK() {
+        if (this.boundsIJK[0][0] < this.dimensions[0]) {
+            return this.boundsIJK;
+        }
+        return this.dimensions.map((dimension) => [0, dimension - 1]);
+    }
+    clear() {
+        if (this.map) {
+            this.map.clear();
+        }
+        this.boundsIJK.map((bound) => {
+            bound[0] = Infinity;
+            bound[1] = -Infinity;
+        });
+        this.modifiedSlices.clear();
+        this.points?.clear();
+    }
+    getArrayOfSlices() {
+        return Array.from(this.modifiedSlices);
+    }
+    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]);
+    }
+    static createRGBVolumeVoxelManager(dimensions, scalarData, numComponents) {
+        const voxels = new VoxelManager(dimensions, (index) => {
+            index *= numComponents;
+            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.numComps = numComponents;
+        voxels.scalarData = scalarData;
+        return voxels;
+    }
+    static createVolumeVoxelManager(dimensions, scalarData, numComponents = 0) {
+        if (dimensions.length !== 3) {
+            throw new Error('Dimensions must be provided as [number, number, number] for [width, height, depth]');
+        }
+        if (!numComponents) {
+            numComponents =
+                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 (numComponents > 1) {
+            return VoxelManager.createRGBVolumeVoxelManager(dimensions, scalarData, numComponents);
+        }
+        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;
+        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, depth] = 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;
+        });
+        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));
+        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);
+            return;
+        }
+        image.voxelManager = VoxelManager.createRLEVoxelManager([
+            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';
+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.js

@@ -33,24 +33,26 @@ export default function applyPreset(actor, preset) {
         normPoints.push([value, opacity]);
     }
     applyPointsToPiecewiseFunction(normPoints, shiftRange, ofun);
-    actor.getProperty().setScalarOpacity(0, ofun);
+    const property = actor.getProperty();
+    property.setScalarOpacity(0, ofun);
     const [gradientMinValue, gradientMinOpacity, gradientMaxValue, gradientMaxOpacity,] = preset.gradientOpacity.split(' ').splice(1).map(parseFloat);
-    actor.getProperty().setUseGradientOpacity(0, true);
-    actor.getProperty().setGradientOpacityMinimumValue(0, gradientMinValue);
-    actor.getProperty().setGradientOpacityMinimumOpacity(0, gradientMinOpacity);
-    actor.getProperty().setGradientOpacityMaximumValue(0, gradientMaxValue);
-    actor.getProperty().setGradientOpacityMaximumOpacity(0, gradientMaxOpacity);
+    property.setUseGradientOpacity(0, true);
+    property.setGradientOpacityMinimumValue(0, gradientMinValue);
+    property.setGradientOpacityMinimumOpacity(0, gradientMinOpacity);
+    property.setGradientOpacityMaximumValue(0, gradientMaxValue);
+    property.setGradientOpacityMaximumOpacity(0, gradientMaxOpacity);
     if (preset.interpolation === '1') {
-        actor.getProperty().setInterpolationTypeToFastLinear();
+        property.setInterpolationTypeToFastLinear();
     }
+    property.setShade(preset.shade === '1');
     const ambient = parseFloat(preset.ambient);
     const diffuse = parseFloat(preset.diffuse);
     const specular = parseFloat(preset.specular);
     const specularPower = parseFloat(preset.specularPower);
-    actor.getProperty().setAmbient(ambient);
-    actor.getProperty().setDiffuse(diffuse);
-    actor.getProperty().setSpecular(specular);
-    actor.getProperty().setSpecularPower(specularPower);
+    property.setAmbient(ambient);
+    property.setDiffuse(diffuse);
+    property.setSpecular(specular);
+    property.setSpecularPower(specularPower);
 }
 function getShiftRange(colorTransferArray) {
     let min = Infinity;
@@ -85,4 +87,3 @@ function applyPointsToPiecewiseFunction(points, range, pwf) {
     rescaled.forEach(([x, y]) => pwf.addPoint(x, y));
     return rescaled;
 }
-//# sourceMappingURL=applyPreset.js.map

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

@@ -0,0 +1,2 @@
+export declare function setupCacheOptimizationEventListener(volumeId: any): void;
+export declare function performCacheOptimizationForVolume(volume: any): void;

package/dist/esm/utilities/cacheUtils.js

@@ -0,0 +1,86 @@
+import cache, { ImageVolume } from '../cache';
+import { Events } from '../enums';
+import eventTarget from '../eventTarget';
+import { getConfiguration, getShouldUseSharedArrayBuffer } from '../init';
+export function setupCacheOptimizationEventListener(volumeId) {
+    const { enableCacheOptimization } = getConfiguration();
+    const shouldUseSAB = getShouldUseSharedArrayBuffer();
+    const performOptimization = enableCacheOptimization && shouldUseSAB;
+    if (!performOptimization) {
+        return;
+    }
+    eventTarget.addEventListenerOnce(Events.IMAGE_VOLUME_LOADING_COMPLETED, (evt) => {
+        if (evt.detail.volumeId !== volumeId) {
+            return;
+        }
+        const volume = cache.getVolume(volumeId);
+        performCacheOptimizationForVolume(volume);
+    });
+}
+export function performCacheOptimizationForVolume(volume) {
+    if (!(volume instanceof ImageVolume)) {
+        return;
+    }
+    if (!volume.imageIds?.length) {
+        console.warn(`Volume with ID ${volume.volumeId} does not have any images to optimize.`);
+        return;
+    }
+    const scalarData = volume.getScalarData();
+    volume.imageIds.forEach((imageId, imageIdIndex) => {
+        let image = cache.getImage(imageId);
+        if (image) {
+            if (image.bufferView) {
+                return;
+            }
+            const offset = _calculateOffset(volume, imageId, imageIdIndex);
+            _updateImageWithScalarDataView(image, scalarData, offset);
+            cache.decrementImageCacheSize(image.sizeInBytes);
+            return;
+        }
+        const inOffSetMap = volume.imageCacheOffsetMap.has(imageId) &&
+            volume.imageCacheOffsetMap.get(imageId).offset;
+        if (inOffSetMap) {
+            const image = cache.getImage(imageId);
+            const offset = volume.imageCacheOffsetMap.get(imageId).offset;
+            _updateImageWithScalarDataView(image, scalarData, offset);
+            cache.decrementImageCacheSize(image.sizeInBytes);
+            return;
+        }
+        image = volume.getCornerstoneImage(imageId, imageIdIndex);
+        if (!cache.getImageLoadObject(imageId)) {
+            cache.putImageSync(imageId, image);
+        }
+        let compatibleScalarData = scalarData;
+        const samplePixelData = image.imageFrame?.pixelData || image.getPixelData();
+        if (scalarData.constructor !== samplePixelData.constructor) {
+            compatibleScalarData = new samplePixelData.constructor(scalarData.length);
+            compatibleScalarData.set(scalarData);
+        }
+        const index = volume.getImageIdIndex(imageId);
+        const offset = index * image.getPixelData().byteLength;
+        _updateImageWithScalarDataView(image, compatibleScalarData, offset);
+        cache.decrementImageCacheSize(image.sizeInBytes);
+    });
+}
+function _updateImageWithScalarDataView(image, scalarData, offset) {
+    const pixelData = image.imageFrame
+        ? image.imageFrame.pixelData
+        : image.getPixelData();
+    const view = new pixelData.constructor(scalarData.buffer, offset, pixelData.length);
+    image.getPixelData = () => view;
+    if (image.imageFrame) {
+        image.imageFrame.pixelData = view;
+    }
+    image.bufferView = {
+        buffer: scalarData.buffer,
+        offset,
+    };
+}
+function _calculateOffset(volume, imageId, imageIdIndex) {
+    if (volume.imageCacheOffsetMap.has(imageId)) {
+        return volume.imageCacheOffsetMap.get(imageId).offset;
+    }
+    const image = volume.getCornerstoneImage(imageId, imageIdIndex);
+    const index = volume.getImageIdIndex(imageId);
+    return index * image.getPixelData().byteLength;
+}

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

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

package/dist/esm/utilities/calculateViewportsSpatialRegistration.js

@@ -24,4 +24,3 @@ function calculateViewportsSpatialRegistration(viewport1, viewport2) {
     spatialRegistrationMetadataProvider.add([viewport1.id, viewport2.id], mat);
 }
 export default calculateViewportsSpatialRegistration;
-//# sourceMappingURL=calculateViewportsSpatialRegistration.js.map

package/dist/esm/utilities/calibratedPixelSpacingMetadataProvider.js

@@ -13,4 +13,3 @@ const metadataProvider = {
     },
 };
 export default metadataProvider;
-//# sourceMappingURL=calibratedPixelSpacingMetadataProvider.js.map

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

@@ -0,0 +1,2 @@
+declare function clamp(value: number, min: number, max: number): number;
+export { clamp as default, clamp };

package/dist/esm/utilities/clamp.js

@@ -0,0 +1,4 @@
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+export { clamp as default, clamp };

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

@@ -0,0 +1,7 @@
+declare function rgbToHex(r: any, g: any, b: any): string;
+declare function hexToRgb(hex: any): {
+    r: number;
+    g: number;
+    b: number;
+};
+export { hexToRgb, rgbToHex };

package/dist/esm/utilities/color.js

@@ -0,0 +1,18 @@
+function componentToHex(c) {
+    const hex = c.toString(16);
+    return hex.length == 1 ? '0' + hex : hex;
+}
+function rgbToHex(r, g, b) {
+    return '#' + componentToHex(r) + componentToHex(g) + componentToHex(b);
+}
+function hexToRgb(hex) {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    return result
+        ? {
+            r: parseInt(result[1], 16),
+            g: parseInt(result[2], 16),
+            b: parseInt(result[3], 16),
+        }
+        : null;
+}
+export { hexToRgb, rgbToHex };

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

@@ -1,5 +1,6 @@
-import { ColormapRegistration } from '../types';
+import { ColormapPublic, ColormapRegistration } from '../types';
 declare function registerColormap(colormap: ColormapRegistration): void;
 declare function getColormap(name: any): any;
 declare function getColormapNames(): any[];
-export { getColormap, getColormapNames, registerColormap };
+declare function findMatchingColormap(rgbPoints: any, actor: any): ColormapPublic | null;
+export { getColormap, getColormapNames, registerColormap, findMatchingColormap, };