@cornerstonejs/core 2.3.3 → 2.5.0

package/dist/esm/RenderingEngine/helpers/setDefaultVolumeVOI.js

@@ -1,6 +1,5 @@
 import { loadAndCacheImage } from '../../loaders/imageLoader';
 import * as metaData from '../../metaData';
-import getMinMax from '../../utilities/getMinMax';
 import * as windowLevel from '../../utilities/windowLevel';
 import { RequestType } from '../../enums';
 import cache from '../../cache/cache';
@@ -95,8 +94,11 @@ async function getVOIFromMiddleSliceMinMax(imageVolume) {
     if (!imageVolume.referencedImageIds?.length) {
         image = await loadAndCacheImage(imageId, { ...options, ignoreCache: true });
     }
-    const imageScalarData = image.getPixelData();
-    const { min, max } = getMinMax(imageScalarData);
+    let { min, max } = image.voxelManager.getMinMax();
+    if (min.length > 1) {
+        min = Math.min(...min);
+        max = Math.max(...max);
+    }
     return {
         lower: min,
         upper: max,

package/dist/esm/enums/VoxelManagerEnum.d.ts

@@ -0,0 +1,5 @@
+declare enum VoxelManagerEnum {
+    RLE = "RLE",
+    Volume = "Volume"
+}
+export default VoxelManagerEnum;

package/dist/esm/enums/VoxelManagerEnum.js

@@ -0,0 +1,6 @@
+var VoxelManagerEnum;
+(function (VoxelManagerEnum) {
+    VoxelManagerEnum["RLE"] = "RLE";
+    VoxelManagerEnum["Volume"] = "Volume";
+})(VoxelManagerEnum || (VoxelManagerEnum = {}));
+export default VoxelManagerEnum;

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

@@ -14,4 +14,5 @@ import ImageQualityStatus from './ImageQualityStatus';
 import * as VideoEnums from './VideoEnums';
 import MetadataModules from './MetadataModules';
 import { GenerateImageType } from './GenerateImageType';
-export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, GeometryType, ContourType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, GenerateImageType, };
+import VoxelManagerEnum from './VoxelManagerEnum';
+export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, GeometryType, ContourType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, };

package/dist/esm/enums/index.js

@@ -14,4 +14,5 @@ import ImageQualityStatus from './ImageQualityStatus';
 import * as VideoEnums from './VideoEnums';
 import MetadataModules from './MetadataModules';
 import { GenerateImageType } from './GenerateImageType';
-export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, GeometryType, ContourType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, GenerateImageType, };
+import VoxelManagerEnum from './VoxelManagerEnum';
+export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, GeometryType, ContourType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, };

package/dist/esm/loaders/imageLoader.d.ts

@@ -1,4 +1,5 @@
 import type { IImage, ImageLoaderFn, Point2, Point3, Mat3, PixelDataTypedArrayString, PixelDataTypedArray } from '../types';
+import VoxelManagerEnum from '../enums/VoxelManagerEnum';
 export interface ImageLoaderOptions {
     priority: number;
     requestType: string;
@@ -11,6 +12,7 @@ interface LocalImageOptions {
     targetBuffer?: {
         type: PixelDataTypedArrayString;
     };
+    voxelRepresentation?: VoxelManagerEnum;
     dimensions?: Point2;
     spacing?: Point2;
     origin?: Point3;
@@ -31,6 +33,7 @@ export declare function createAndCacheDerivedImages(referencedImageIds: string[]
     targetBuffer?: {
         type: PixelDataTypedArrayString;
     };
+    voxelRepresentation?: VoxelManagerEnum;
 }): IImage[];
 export declare function createAndCacheLocalImage(imageId: string, options: LocalImageOptions): IImage;
 export declare function cancelLoadImage(imageId: string): void;

package/dist/esm/loaders/imageLoader.js

@@ -8,6 +8,7 @@ import uuidv4 from '../utilities/uuidv4';
 import VoxelManager from '../utilities/VoxelManager';
 import imageLoadPoolManager from '../requestPool/imageLoadPoolManager';
 import * as metaData from '../metaData';
+import VoxelManagerEnum from '../enums/VoxelManagerEnum';
 const imageLoaders = {};
 let unknownImageLoader;
 function loadImageFromImageLoader(imageId, options) {
@@ -85,7 +86,7 @@ export function createAndCacheDerivedImage(referencedImageId, options = {}) {
     if (options.imageId === undefined) {
         options.imageId = `derived:${uuidv4()}`;
     }
-    const { imageId, skipCreateBuffer, onCacheAdd } = options;
+    const { imageId, skipCreateBuffer, onCacheAdd, voxelRepresentation } = options;
     const imagePlaneModule = metaData.get('imagePlaneModule', referencedImageId);
     const length = imagePlaneModule.rows * imagePlaneModule.columns;
     const { TypedArrayConstructor } = getBufferConfiguration(options.targetBuffer?.type, length);
@@ -126,6 +127,7 @@ export function createAndCacheDerivedImage(referencedImageId, options = {}) {
         targetBuffer: {
             type: imageScalarData.constructor.name,
         },
+        voxelRepresentation,
         dimensions: [imagePlaneModule.columns, imagePlaneModule.rows],
         spacing: [
             imagePlaneModule.columnPixelSpacing,
@@ -161,7 +163,7 @@ export function createAndCacheDerivedImages(referencedImageIds, options = {}) {
     return images;
 }
 export function createAndCacheLocalImage(imageId, options) {
-    const { scalarData, origin, direction, targetBuffer, skipCreateBuffer, onCacheAdd, frameOfReferenceUID, } = options;
+    const { scalarData, origin, direction, targetBuffer, skipCreateBuffer, onCacheAdd, frameOfReferenceUID, voxelRepresentation, } = options;
     const dimensions = options.dimensions;
     const spacing = options.spacing;
     if (!dimensions || !spacing) {
@@ -196,7 +198,7 @@ export function createAndCacheLocalImage(imageId, options) {
         scalarDataToUse = scalarData;
     }
     else if (!skipCreateBuffer) {
-        const { numBytes, TypedArrayConstructor } = getBufferConfiguration(targetBuffer?.type, length);
+        const { TypedArrayConstructor } = getBufferConfiguration(targetBuffer?.type, length);
         const imageScalarData = new TypedArrayConstructor(length);
         scalarDataToUse = imageScalarData;
     }
@@ -245,12 +247,14 @@ export function createAndCacheLocalImage(imageId, options) {
             metadata: metadata[type] || {},
         });
     });
-    const voxelManager = VoxelManager.createImageVoxelManager({
-        height,
-        width,
-        numberOfComponents,
-        scalarData: scalarDataToUse,
-    });
+    const voxelManager = (voxelRepresentation === VoxelManagerEnum.RLE &&
+        VoxelManager.createRLEImageVoxelManager({ dimensions })) ||
+        VoxelManager.createImageVoxelManager({
+            height,
+            width,
+            numberOfComponents,
+            scalarData: scalarDataToUse,
+        });
     let minPixelValue = scalarDataToUse[0];
     let maxPixelValue = scalarDataToUse[0];
     for (let i = 1; i < scalarDataToUse.length; i++) {

package/dist/esm/loaders/volumeLoader.d.ts

@@ -1,4 +1,5 @@
 import '@kitware/vtk.js/Rendering/Profiles/Volume';
+import type VoxelManagerEnum from '../enums/VoxelManagerEnum';
 import type { Point3, Metadata, Mat3, IImageVolume, VolumeLoaderFn, PixelDataTypedArray, PixelDataTypedArrayString, IStreamingImageVolume } from '../types';
 interface VolumeLoaderOptions {
     imageIds: string[];
@@ -9,6 +10,7 @@ interface DerivedVolumeOptions {
     targetBuffer?: {
         type: PixelDataTypedArrayString;
     };
+    voxelRepresentation?: VoxelManagerEnum;
 }
 export interface LocalVolumeOptions {
     metadata: Metadata;

package/dist/esm/loaders/volumeLoader.js

@@ -65,6 +65,7 @@ export function createAndCacheDerivedVolume(referencedVolumeId, options) {
         throw new Error(`Cannot created derived volume: Referenced volume with id ${referencedVolumeId} does not exist.`);
     }
     let { volumeId } = options;
+    const { voxelRepresentation } = options;
     if (volumeId === undefined) {
         volumeId = uuidv4();
     }
@@ -74,6 +75,7 @@ export function createAndCacheDerivedVolume(referencedVolumeId, options) {
         : referencedVolume.imageIds ?? [];
     const derivedImages = createAndCacheDerivedImages(referencedImageIds, {
         targetBuffer: options.targetBuffer,
+        voxelRepresentation,
     });
     const dataType = derivedImages[0].dataType;
     const derivedVolumeImageIds = derivedImages.map((image) => image.imageId);
@@ -222,7 +224,10 @@ export function getUnknownVolumeLoaderSchema() {
 export function createAndCacheDerivedLabelmapVolume(referencedVolumeId, options = {}) {
     return createAndCacheDerivedVolume(referencedVolumeId, {
         ...options,
-        targetBuffer: { type: 'Uint8Array' },
+        targetBuffer: {
+            type: 'Uint8Array',
+            ...options?.targetBuffer,
+        },
     });
 }
 export function createLocalLabelmapVolume(options, volumeId, preventCache = false) {

package/dist/esm/types/PixelDataTypedArray.d.ts

@@ -1,2 +1,2 @@
 export type PixelDataTypedArray = Float32Array | Int16Array | Uint16Array | Uint8Array | Int8Array | Uint8ClampedArray;
-export type PixelDataTypedArrayString = 'Float32Array' | 'Int16Array' | 'Uint16Array' | 'Uint8Array' | 'Int8Array' | 'Uint8ClampedArray';
+export type PixelDataTypedArrayString = 'Float32Array' | 'Int16Array' | 'Uint16Array' | 'Uint8Array' | 'Int8Array' | 'Uint8ClampedArray' | 'none';

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

@@ -20,6 +20,7 @@ export default class PointsManager<T> {
     getPointArray(index: number): T;
     protected grow(additionalSize?: number, growSize?: number): void;
     reverse(): void;
+    getTypedArray(): Float32Array;
     push(point: T): void;
     map<R>(f: (value: any, index: number) => R): R[];
     get points(): T[];

package/dist/esm/utilities/PointsManager.js

@@ -73,6 +73,9 @@ export default class PointsManager {
             }
         }
     }
+    getTypedArray() {
+        return this.data;
+    }
     push(point) {
         this.grow(1);
         const offset = this.length * this._dimensions;

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

@@ -1,21 +1,57 @@
-import type { PixelDataTypedArray, RLERun } from '../types';
+import type Point3 from '../types/Point3';
+import type BoundsIJK from '../types/BoundsIJK';
+import type { PixelDataTypedArray } from '../types';
+export type RLERun<T> = {
+    value: T;
+    start: number;
+    end: number;
+};
+export type PlaneNormalizer = {
+    toIJK: (ijkPrime: Point3) => Point3;
+    fromIJK: (ijk: Point3) => Point3;
+    boundsIJKPrime: BoundsIJK;
+};
 export default class RLEVoxelMap<T> {
+    normalizer: PlaneNormalizer;
     protected rows: Map<number, RLERun<T>[]>;
-    protected height: number;
-    protected width: number;
-    protected depth: number;
+    height: number;
+    width: number;
+    depth: number;
     protected jMultiple: number;
     protected kMultiple: number;
-    protected numberOfComponents: number;
+    protected numComps: number;
     defaultValue: T;
     pixelDataConstructor: Uint8ArrayConstructor;
+    static copyMap<T>(destination: RLEVoxelMap<T>, source: RLEVoxelMap<T>): void;
     constructor(width: number, height: number, depth?: number);
+    static getScalarData: (ArrayType?: Uint8ClampedArrayConstructor) => Uint8ClampedArray;
+    updateScalarData: (scalarData: PixelDataTypedArray) => void;
     get: (index: number) => T;
-    protected getRLE(i: number, j: number, k?: number): RLERun<T> | undefined;
+    toIJK(index: number): Point3;
+    toIndex([i, j, k]: Point3): number;
+    protected getRLE(i: number, j: number, k?: number): RLERun<T>;
+    has(index: number): boolean;
+    delete(index: number): void;
     protected findIndex(row: RLERun<T>[], i: number): number;
+    forEach(callback: any, options?: {
+        rowModified?: boolean;
+    }): void;
+    forEachRow(callback: any): void;
     getRun: (j: number, k: number) => RLERun<T>[];
     set: (index: number, value: T) => void;
     clear(): void;
     keys(): number[];
     getPixelData(k?: number, pixelData?: PixelDataTypedArray): PixelDataTypedArray;
+    floodFill(i: number, j: number, k: number, value: T, options?: {
+        planar?: boolean;
+        diagonals?: boolean;
+        singlePlane?: boolean;
+    }): number;
+    private flood;
+    fillFrom(getter: (i: number, j: number, k: number) => T, boundsIJK: BoundsIJK): void;
+    findAdjacents(item: [RLERun<T>, number, number, Point3[]?], { diagonals, planar, singlePlane }: {
+        diagonals?: boolean;
+        planar?: boolean;
+        singlePlane?: boolean;
+    }): any[];
 }

package/dist/esm/utilities/RLEVoxelMap.js

@@ -1,4 +1,29 @@
+const ADJACENT_ALL = [
+    [0, -1, 0],
+    [0, 1, 0],
+    [0, 0, -1],
+    [0, 0, 1],
+];
+const ADJACENT_SINGLE_PLANE = [
+    [0, -1, 0],
+    [0, 1, 0],
+];
+const ADJACENT_IN = [
+    [0, -1, 0],
+    [0, 1, 0],
+    [0, 0, -1],
+];
+const ADJACENT_OUT = [
+    [0, -1, 0],
+    [0, 1, 0],
+    [0, 0, 1],
+];
 export default class RLEVoxelMap {
+    static copyMap(destination, source) {
+        for (const [index, row] of source.rows) {
+            destination.rows.set(index, structuredClone(row));
+        }
+    }
     constructor(width, height, depth = 1) {
         this.rows = new Map();
         this.height = 1;
@@ -6,14 +31,23 @@ export default class RLEVoxelMap {
         this.depth = 1;
         this.jMultiple = 1;
         this.kMultiple = 1;
-        this.numberOfComponents = 1;
-        this.defaultValue = 0;
+        this.numComps = 1;
         this.pixelDataConstructor = Uint8Array;
+        this.updateScalarData = function (scalarData) {
+            scalarData.fill(0);
+            const callback = (index, rle, row) => {
+                const { start, end, value } = rle;
+                for (let i = start; i < end; i++) {
+                    scalarData[index + i] = value;
+                }
+            };
+            this.forEach(callback);
+        };
         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;
+            return rle?.value ?? this.defaultValue;
         };
         this.getRun = (j, k) => {
             const runIndex = j + k * this.height;
@@ -21,7 +55,7 @@ export default class RLEVoxelMap {
         };
         this.set = (index, value) => {
             if (value === undefined) {
-                throw new Error(`Can't set undefined at ${index % this.width}`);
+                return;
             }
             const i = index % this.width;
             const j = (index - i) / this.width;
@@ -50,7 +84,7 @@ export default class RLEVoxelMap {
             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) {
+            if (rlePrev?.value === value && rlePrev?.end === i) {
                 rlePrev.end++;
                 if (rleNext?.value === value && rleNext.start === i + 1) {
                     rlePrev.end = rleNext.end;
@@ -82,7 +116,7 @@ export default class RLEVoxelMap {
             if (rleNext?.start === i && rleNext.end === i + 1) {
                 rleNext.value = value;
                 const nextnext = row[rleIndex + 1];
-                if (nextnext?.start == i + 1 && nextnext?.value === value) {
+                if (nextnext?.start == i + 1 && nextnext.value === value) {
                     row.splice(rleIndex + 1, 1);
                     rleNext.end = nextnext.end;
                 }
@@ -111,6 +145,20 @@ export default class RLEVoxelMap {
         this.jMultiple = width;
         this.kMultiple = this.jMultiple * height;
     }
+    static { this.getScalarData = function (ArrayType = Uint8ClampedArray) {
+        const scalarData = new ArrayType(this.frameSize);
+        this.map.updateScalarData(scalarData);
+        return scalarData;
+    }; }
+    toIJK(index) {
+        const i = index % this.jMultiple;
+        const j = ((index - i) / this.jMultiple) % this.height;
+        const k = Math.floor(index / this.kMultiple);
+        return [i, j, k];
+    }
+    toIndex([i, j, k]) {
+        return i + k * this.kMultiple + j * this.jMultiple;
+    }
     getRLE(i, j, k = 0) {
         const row = this.rows.get(j + k * this.height);
         if (!row) {
@@ -120,6 +168,46 @@ export default class RLEVoxelMap {
         const rle = row[index];
         return i >= rle?.start ? rle : undefined;
     }
+    has(index) {
+        const i = index % this.jMultiple;
+        const j = (index - i) / this.jMultiple;
+        const rle = this.getRLE(i, j);
+        return rle?.value !== undefined;
+    }
+    delete(index) {
+        const i = index % this.width;
+        const j = (index - i) / this.width;
+        const row = this.rows.get(j);
+        if (!row) {
+            return;
+        }
+        const rleIndex = this.findIndex(row, i);
+        const rle = row[rleIndex];
+        if (!rle || rle.start > i) {
+            return;
+        }
+        if (rle.end === i + 1) {
+            rle.end--;
+            if (rle.start >= rle.end) {
+                row.splice(rleIndex, 1);
+                if (!row.length) {
+                    this.rows.delete(j);
+                }
+            }
+            return;
+        }
+        if (rle.start === i) {
+            rle.start++;
+            return;
+        }
+        const newRle = {
+            value: rle.value,
+            start: i + 1,
+            end: rle.end,
+        };
+        rle.end = i;
+        row.splice(rleIndex + 1, 0, newRle);
+    }
     findIndex(row, i) {
         for (let index = 0; index < row.length; index++) {
             const { end: iEnd } = row[index];
@@ -129,6 +217,20 @@ export default class RLEVoxelMap {
         }
         return row.length;
     }
+    forEach(callback, options) {
+        const rowModified = options?.rowModified;
+        for (const [baseIndex, row] of this.rows) {
+            const rowToUse = rowModified ? [...row] : row;
+            for (const rle of rowToUse) {
+                callback(baseIndex * this.width, rle, row);
+            }
+        }
+    }
+    forEachRow(callback) {
+        for (const [baseIndex, row] of this.rows) {
+            callback(baseIndex * this.width, row);
+        }
+    }
     clear() {
         this.rows.clear();
     }
@@ -137,18 +239,18 @@ export default class RLEVoxelMap {
     }
     getPixelData(k = 0, pixelData) {
         if (!pixelData) {
-            pixelData = new this.pixelDataConstructor(this.width * this.height * this.numberOfComponents);
+            pixelData = new this.pixelDataConstructor(this.width * this.height * this.numComps);
         }
         else {
             pixelData.fill(0);
         }
-        const { width, height, numberOfComponents } = this;
+        const { width, height, numComps } = this;
         for (let j = 0; j < height; j++) {
             const row = this.getRun(j, k);
             if (!row) {
                 continue;
             }
-            if (numberOfComponents === 1) {
+            if (numComps === 1) {
                 for (const rle of row) {
                     const rowOffset = j * width;
                     const { start, end, value } = rle;
@@ -159,10 +261,10 @@ export default class RLEVoxelMap {
             }
             else {
                 for (const rle of row) {
-                    const rowOffset = j * width * numberOfComponents;
+                    const rowOffset = j * width * numComps;
                     const { start, end, value } = rle;
-                    for (let i = start; i < end; i += numberOfComponents) {
-                        for (let comp = 0; comp < numberOfComponents; comp++) {
+                    for (let i = start; i < end; i += numComps) {
+                        for (let comp = 0; comp < numComps; comp++) {
                             pixelData[rowOffset + i + comp] = value[comp];
                         }
                     }
@@ -171,4 +273,103 @@ export default class RLEVoxelMap {
         }
         return pixelData;
     }
+    floodFill(i, j, k, value, options) {
+        const rle = this.getRLE(i, j, k);
+        if (!rle) {
+            throw new Error(`Initial point ${i},${j},${k} isn't in the RLE`);
+        }
+        const stack = [[rle, j, k]];
+        const replaceValue = rle.value;
+        if (replaceValue === value) {
+            throw new Error(`source (${replaceValue}) and destination (${value}) are identical`);
+        }
+        return this.flood(stack, replaceValue, value, options);
+    }
+    flood(stack, sourceValue, value, options) {
+        let sum = 0;
+        const { planar = true, diagonals = true, singlePlane = false, } = options || {};
+        const childOptions = { planar, diagonals, singlePlane };
+        while (stack.length) {
+            const top = stack.pop();
+            const [current] = top;
+            if (current.value !== sourceValue) {
+                continue;
+            }
+            current.value = value;
+            sum += current.end - current.start;
+            const adjacents = this.findAdjacents(top, childOptions).filter((adjacent) => adjacent && adjacent[0].value === sourceValue);
+            stack.push(...adjacents);
+        }
+        return sum;
+    }
+    fillFrom(getter, boundsIJK) {
+        for (let k = boundsIJK[2][0]; k <= boundsIJK[2][1]; k++) {
+            for (let j = boundsIJK[1][0]; j <= boundsIJK[1][1]; j++) {
+                let rle;
+                let row;
+                for (let i = boundsIJK[0][0]; i <= boundsIJK[0][1]; i++) {
+                    const value = getter(i, j, k);
+                    if (value === undefined) {
+                        rle = undefined;
+                        continue;
+                    }
+                    if (!row) {
+                        row = [];
+                        this.rows.set(j + k * this.height, row);
+                    }
+                    if (rle && rle.value !== value) {
+                        rle = undefined;
+                    }
+                    if (!rle) {
+                        rle = { start: i, end: i, value };
+                        row.push(rle);
+                    }
+                    rle.end++;
+                }
+            }
+        }
+    }
+    findAdjacents(item, { diagonals = true, planar = true, singlePlane = false }) {
+        const [rle, j, k, adjacentsDelta] = item;
+        const { start, end } = rle;
+        const leftRle = start > 0 && this.getRLE(start - 1, j, k);
+        const rightRle = end < this.width && this.getRLE(end, j, k);
+        const range = diagonals
+            ? [start > 0 ? start - 1 : start, end < this.width ? end + 1 : end]
+            : [start, end];
+        const adjacents = [];
+        if (leftRle) {
+            adjacents.push([leftRle, j, k]);
+        }
+        if (rightRle) {
+            adjacents.push([rightRle, j, k]);
+        }
+        for (const delta of adjacentsDelta ||
+            (singlePlane ? ADJACENT_SINGLE_PLANE : ADJACENT_ALL)) {
+            const [, delta1, delta2] = delta;
+            const testJ = delta1 + j;
+            const testK = delta2 + k;
+            if (testJ < 0 || testJ >= this.height) {
+                continue;
+            }
+            if (testK < 0 || testK >= this.depth) {
+                continue;
+            }
+            const row = this.getRun(testJ, testK);
+            if (!row) {
+                continue;
+            }
+            for (const testRle of row) {
+                const newAdjacentDelta = adjacentsDelta ||
+                    (singlePlane && ADJACENT_SINGLE_PLANE) ||
+                    (planar && delta2 > 0 && ADJACENT_OUT) ||
+                    (planar && delta2 < 0 && ADJACENT_IN) ||
+                    ADJACENT_ALL;
+                if (!(testRle.end <= range[0] || testRle.start >= range[1])) {
+                    adjacents.push([testRle, testJ, testK, newAdjacentDelta]);
+                }
+            }
+        }
+        return adjacents;
+    }
 }

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

@@ -1,4 +1,4 @@
-import type { BoundsIJK, Point3, PixelDataTypedArray, IImage, RGB, CPUImageData, IVoxelManager, IRLEVoxelMap } from '../types';
+import type { BoundsIJK, Point3, PixelDataTypedArray, IImage, RGB, CPUImageData, IVoxelManager, IRLEVoxelMap, Point2 } from '../types';
 import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 export default class VoxelManager<T> {
     modifiedSlices: Set<number>;
@@ -7,30 +7,45 @@ export default class VoxelManager<T> {
     sourceVoxelManager: IVoxelManager<T>;
     isInObject: (pointLPS: any, pointIJK: any) => boolean;
     readonly dimensions: Point3;
-    numberOfComponents: number;
+    readonly numberOfComponents: any;
     getCompleteScalarDataArray?: () => ArrayLike<number>;
     setCompleteScalarDataArray?: (scalarData: ArrayLike<number>) => void;
     getRange: () => [number, number];
     private scalarData;
     private _sliceDataCache;
+    readonly _id: string;
     points: Set<number>;
     width: number;
     frameSize: number;
-    _get: (index: number) => T;
-    _set: (index: number, v: T) => boolean;
-    _getConstructor?: () => new (length: number) => PixelDataTypedArray;
+    readonly _get: (index: number) => T;
+    readonly _set: (index: number, v: T) => boolean;
+    readonly _getConstructor?: () => new (length: number) => PixelDataTypedArray;
     _getScalarDataLength?: () => number;
-    _getScalarData?: () => PixelDataTypedArray;
+    _getScalarData?: () => ArrayLike<number>;
+    _updateScalarData?: (scalarData: ArrayLike<number>) => PixelDataTypedArray;
     _getSliceData: (args: {
         sliceIndex: number;
         slicePlane: number;
     }) => PixelDataTypedArray;
-    constructor(dimensions: any, _get: (index: number) => T, _set?: (index: number, v: T) => boolean);
+    constructor(dimensions: any, options: {
+        _get: (index: number) => T;
+        _set?: (index: number, v: T) => boolean;
+        _getScalarData?: () => ArrayLike<number>;
+        _id?: string;
+        _updateScalarData?: (scalarData: ArrayLike<number>) => PixelDataTypedArray;
+        numberOfComponents?: number;
+        scalarData?: ArrayLike<number>;
+        _getConstructor?: () => new (length: number) => PixelDataTypedArray;
+    });
     getAtIJK: (i: any, j: any, k: any) => T;
     setAtIJK: (i: number, j: number, k: number, v: any) => boolean;
     getAtIJKPoint: ([i, j, k]: [any, any, any]) => T;
     setAtIJKPoint: ([i, j, k]: Point3, v: any) => void;
     getAtIndex: (index: any) => T;
+    getMinMax(): {
+        min: any;
+        max: any;
+    };
     setAtIndex: (index: any, v: any) => boolean;
     toIJK(index: number): Point3;
     getMiddleSliceData: () => PixelDataTypedArray;
@@ -47,8 +62,9 @@ export default class VoxelManager<T> {
         isInObject?: (pointLPS: any, pointIJK: any) => boolean;
         returnPoints?: boolean;
         imageData?: vtkImageData | CPUImageData;
-    }) => any[];
-    getScalarData(): PixelDataTypedArray;
+    }) => void | any[];
+    rleForEach(callback: any, options?: any): void;
+    getScalarData(storeScalarData?: boolean): PixelDataTypedArray;
     setScalarData(newScalarData: PixelDataTypedArray): void;
     getScalarDataLength(): number;
     get sizeInBytes(): number;
@@ -96,13 +112,17 @@ export default class VoxelManager<T> {
     static createHistoryVoxelManager<T>({ sourceVoxelManager, }: {
         sourceVoxelManager: VoxelManager<T>;
     }): VoxelManager<T>;
+    static createRLEHistoryVoxelManager<T>(sourceVoxelManager: VoxelManager<T>): VoxelManager<T>;
     static createLazyVoxelManager<T>({ dimensions, planeFactory, }: {
         dimensions: Point3;
         planeFactory: (width: number, height: number) => T;
     }): VoxelManager<T>;
-    static createRLEVoxelManager<T>({ dimensions, }: {
+    static createRLEVolumeVoxelManager<T>({ dimensions, }: {
         dimensions: Point3;
     }): VoxelManager<T>;
+    static createRLEImageVoxelManager<T>({ dimensions, }: {
+        dimensions: Point2;
+    }): VoxelManager<T>;
     static addInstanceToImage(image: IImage): void;
     static: any;
 }