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

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

@@ -1,9 +1,9 @@
-declare type VOI = {
+interface VOI {
     windowWidth: number;
     windowCenter: number;
-};
-declare type VOIRange = {
+}
+interface VOIRange {
     upper: number;
     lower: number;
-};
+}
 export type { VOI, VOIRange };

package/dist/esm/types/voi.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=voi.js.map

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

@@ -0,0 +1,31 @@
+import type { IPointsManager, PolyDataPointConfiguration } from '../types';
+import type Point2 from '../types/Point2';
+import type Point3 from '../types/Point3';
+import type { PointsXYZ } from '../types/Point3';
+export default class PointsManager<T> implements IPointsManager<T> {
+    kIndex: number;
+    sources: IPointsManager<T>[];
+    data: Float32Array;
+    _dimensions: number;
+    _length: number;
+    _byteSize: number;
+    growSize: number;
+    array: ArrayBuffer;
+    constructor(configuration?: PolyDataPointConfiguration);
+    forEach(func: (value: T, index: number) => void): void;
+    get length(): number;
+    get dimensions(): number;
+    get dimensionLength(): number;
+    getPoint(index: number): T;
+    getPointArray(index: number): T;
+    protected grow(additionalSize?: number, growSize?: number): void;
+    reverse(): void;
+    push(point: T): void;
+    map<R>(f: (value: any, index: number) => R): R[];
+    get points(): T[];
+    toXYZ(): PointsXYZ;
+    static fromXYZ({ x, y, z }: PointsXYZ): IPointsManager<Point3>;
+    subselect(count?: number, offset?: number): IPointsManager<T>;
+    static create3(initialSize?: number): PointsManager<Point3>;
+    static create2(initialSize?: number): PointsManager<Point2>;
+}

package/dist/esm/utilities/PointsManager.js

@@ -0,0 +1,137 @@
+export default class PointsManager {
+    constructor(configuration = {}) {
+        this._dimensions = 3;
+        this._length = 0;
+        this._byteSize = 4;
+        this.growSize = 128;
+        const { initialSize = 1024, dimensions = 3, growSize = 128, } = configuration;
+        const itemLength = initialSize * dimensions;
+        this.growSize = growSize;
+        this.array = new ArrayBuffer(itemLength * this._byteSize);
+        this.data = new Float32Array(this.array);
+        this._dimensions = dimensions;
+    }
+    forEach(func) {
+        for (let i = 0; i < this._length; i++) {
+            func(this.getPoint(i), i);
+        }
+    }
+    get length() {
+        return this._length;
+    }
+    get dimensions() {
+        return this._dimensions;
+    }
+    get dimensionLength() {
+        return this._length * this._dimensions;
+    }
+    getPoint(index) {
+        if (index < 0) {
+            index += this._length;
+        }
+        if (index < 0 || index >= this._length) {
+            return;
+        }
+        const offset = this._dimensions * index;
+        return this.data.subarray(offset, offset + this._dimensions);
+    }
+    getPointArray(index) {
+        const array = [];
+        if (index < 0) {
+            index += this._length;
+        }
+        if (index < 0 || index >= this._length) {
+            return;
+        }
+        const offset = this._dimensions * index;
+        for (let i = 0; i < this._dimensions; i++) {
+            array.push(this.data[i + offset]);
+        }
+        return array;
+    }
+    grow(additionalSize = 1, growSize = this.growSize) {
+        if (this.dimensionLength + additionalSize * this._dimensions <=
+            this.data.length) {
+            return;
+        }
+        const newSize = this.data.length + growSize;
+        const newArray = new ArrayBuffer(newSize * this._dimensions * this._byteSize);
+        const newData = new Float32Array(newArray);
+        newData.set(this.data);
+        this.data = newData;
+        this.array = newArray;
+    }
+    reverse() {
+        const midLength = Math.floor(this._length / 2);
+        for (let i = 0; i < midLength; i++) {
+            const indexStart = i * this._dimensions;
+            const indexEnd = (this._length - 1 - i) * this._dimensions;
+            for (let dimension = 0; dimension < this._dimensions; dimension++) {
+                const valueStart = this.data[indexStart + dimension];
+                this.data[indexStart + dimension] = this.data[indexEnd + dimension];
+                this.data[indexEnd + dimension] = valueStart;
+            }
+        }
+    }
+    push(point) {
+        this.grow(1);
+        const offset = this.length * this._dimensions;
+        for (let i = 0; i < this._dimensions; i++) {
+            this.data[i + offset] = point[i];
+        }
+        this._length++;
+    }
+    map(f) {
+        const mapData = [];
+        for (let i = 0; i < this._length; i++) {
+            mapData.push(f(this.getPoint(i), i));
+        }
+        return mapData;
+    }
+    get points() {
+        return this.map((p) => p);
+    }
+    toXYZ() {
+        const xyz = { x: [], y: [] };
+        if (this._dimensions >= 3) {
+            xyz.z = [];
+        }
+        const { x, y, z } = xyz;
+        this.forEach((p) => {
+            x.push(p[0]);
+            y.push(p[1]);
+            if (z) {
+                z.push(p[2]);
+            }
+        });
+        return xyz;
+    }
+    static fromXYZ({ x, y, z }) {
+        const array = PointsManager.create3(x.length);
+        let offset = 0;
+        for (let i = 0; i < x.length; i++) {
+            array.data[offset++] = x[i];
+            array.data[offset++] = y[i];
+            array.data[offset++] = z ? z[i] : 0;
+        }
+        array._length = x.length;
+        return array;
+    }
+    subselect(count = 10, offset = 0) {
+        const selected = new PointsManager({
+            initialSize: count,
+            dimensions: this._dimensions,
+        });
+        for (let i = 0; i < count; i++) {
+            const index = (offset + Math.floor((this.length * i) / count)) % this.length;
+            selected.push(this.getPoint(index));
+        }
+        return selected;
+    }
+    static create3(initialSize = 128) {
+        return new PointsManager({ initialSize, dimensions: 3 });
+    }
+    static create2(initialSize = 128) {
+        return new PointsManager({ initialSize, dimensions: 2 });
+    }
+}

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

@@ -0,0 +1,24 @@
+export declare class PromiseIterator<T> extends Promise<T> {
+    iterator?: ProgressiveIterator<T>;
+}
+export type ErrorCallback = (message: string | Error) => void;
+export default class ProgressiveIterator<T> {
+    done: any;
+    name?: string;
+    private nextValue;
+    private waiting;
+    private rejectReason;
+    constructor(name?: any);
+    static as(promise: any): any;
+    add(x: T, done?: boolean): void;
+    resolve(): void;
+    reject(reason: Error): void;
+    getRecent(): T;
+    [Symbol.asyncIterator](): AsyncGenerator<any, void, unknown>;
+    forEach(callback: any, errorCallback: any): Promise<void>;
+    generate(processFunction: any, errorCallback?: ErrorCallback): Promise<unknown>;
+    nextPromise(): Promise<T>;
+    donePromise(): Promise<T>;
+    getNextPromise(): PromiseIterator<T>;
+    getDonePromise(): PromiseIterator<T>;
+}

package/dist/esm/utilities/ProgressiveIterator.js

@@ -0,0 +1,141 @@
+export class PromiseIterator extends Promise {
+}
+export default class ProgressiveIterator {
+    constructor(name) {
+        this.name = name || 'unknown';
+    }
+    static as(promise) {
+        if (promise.iterator) {
+            return promise.iterator;
+        }
+        const iterator = new ProgressiveIterator('as iterator');
+        promise.then((v) => {
+            try {
+                iterator.add(v, true);
+            }
+            catch (e) {
+                iterator.reject(e);
+            }
+        }, (reason) => {
+            iterator.reject(reason);
+        });
+        return iterator;
+    }
+    add(x, done = false) {
+        this.nextValue = x;
+        this.done ||= done;
+        if (this.waiting) {
+            this.waiting.resolve(x);
+            this.waiting = undefined;
+        }
+    }
+    resolve() {
+        this.done = true;
+        if (this.waiting) {
+            this.waiting.resolve(this.nextValue);
+            this.waiting = undefined;
+        }
+    }
+    reject(reason) {
+        this.rejectReason = reason;
+        this.waiting?.reject(reason);
+    }
+    getRecent() {
+        if (this.rejectReason) {
+            throw this.rejectReason;
+        }
+        return this.nextValue;
+    }
+    async *[Symbol.asyncIterator]() {
+        while (!this.done) {
+            if (this.rejectReason) {
+                throw this.rejectReason;
+            }
+            if (this.nextValue !== undefined) {
+                yield this.nextValue;
+                if (this.done) {
+                    break;
+                }
+            }
+            if (!this.waiting) {
+                this.waiting = {};
+                this.waiting.promise = new Promise((resolve, reject) => {
+                    this.waiting.resolve = resolve;
+                    this.waiting.reject = reject;
+                });
+            }
+            await this.waiting.promise;
+        }
+        yield this.nextValue;
+    }
+    async forEach(callback, errorCallback) {
+        let index = 0;
+        try {
+            for await (const value of this) {
+                const { done } = this;
+                try {
+                    await callback(value, done, index);
+                    index++;
+                }
+                catch (e) {
+                    if (!done) {
+                        console.warn('Caught exception in intermediate value', e);
+                        continue;
+                    }
+                    if (errorCallback) {
+                        errorCallback(e, done);
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }
+        }
+        catch (e) {
+            if (errorCallback) {
+                errorCallback(e, true);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    generate(processFunction, errorCallback) {
+        return processFunction(this, this.reject.bind(this)).then(() => {
+            if (!this.done) {
+                this.resolve();
+            }
+        }, (reason) => {
+            this.reject(reason);
+            if (errorCallback) {
+                errorCallback(reason);
+            }
+            else {
+                console.warn("Couldn't process because", reason);
+            }
+        });
+    }
+    async nextPromise() {
+        for await (const i of this) {
+            if (i) {
+                return i;
+            }
+        }
+        return this.nextValue;
+    }
+    async donePromise() {
+        for await (const i of this) {
+        }
+        return this.nextValue;
+    }
+    getNextPromise() {
+        const promise = this.nextPromise();
+        promise.iterator = this;
+        return promise;
+    }
+    getDonePromise() {
+        const promise = this.donePromise();
+        promise.iterator = this;
+        return promise;
+    }
+}

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

@@ -0,0 +1,21 @@
+import type { IRLEVoxelMap, PixelDataTypedArray, RLERun } from '../types';
+export default class RLEVoxelMap<T> implements IRLEVoxelMap<T> {
+    protected rows: Map<number, RLERun<T>[]>;
+    protected height: number;
+    protected width: number;
+    protected depth: number;
+    protected jMultiple: number;
+    protected kMultiple: number;
+    protected numberOfComponents: number;
+    defaultValue: T;
+    pixelDataConstructor: Uint8ArrayConstructor;
+    constructor(width: number, height: number, depth?: number);
+    get: (index: number) => T;
+    protected getRLE(i: number, j: number, k?: number): RLERun<T>;
+    protected findIndex(row: RLERun<T>[], i: number): number;
+    getRun: (j: number, k: number) => RLERun<T>[];
+    set: (index: number, value: T) => void;
+    clear(): void;
+    keys(): number[];
+    getPixelData(k?: number, pixelData?: PixelDataTypedArray): PixelDataTypedArray;
+}

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.numberOfComponents = 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.numberOfComponents);
+        }
+        else {
+            pixelData.fill(0);
+        }
+        const { width, height, numberOfComponents } = this;
+        for (let j = 0; j < height; j++) {
+            const row = this.getRun(j, k);
+            if (!row) {
+                continue;
+            }
+            if (numberOfComponents === 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 * numberOfComponents;
+                    const { start, end, value } = rle;
+                    for (let i = start; i < end; i += numberOfComponents) {
+                        for (let comp = 0; comp < numberOfComponents; comp++) {
+                            pixelData[rowOffset + i + comp] = value[comp];
+                        }
+                    }
+                }
+            }
+        }
+        return pixelData;
+    }
+}

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

@@ -0,0 +1,106 @@
+import type { BoundsIJK, Point3, PixelDataTypedArray, IImage, RGB, CPUImageData, IVoxelManager, IRLEVoxelMap } from '../types';
+import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+export default class VoxelManager<T> implements IVoxelManager<T> {
+    modifiedSlices: Set<number>;
+    boundsIJK: BoundsIJK;
+    map: Map<number, T> | IRLEVoxelMap<T>;
+    sourceVoxelManager: IVoxelManager<T>;
+    isInObject: (pointLPS: any, pointIJK: any) => boolean;
+    readonly dimensions: Point3;
+    numberOfComponents: number;
+    getCompleteScalarDataArray?: () => ArrayLike<number>;
+    setCompleteScalarDataArray?: (scalarData: ArrayLike<number>) => void;
+    getRange: () => [number, number];
+    private scalarData;
+    private _sliceDataCache;
+    points: Set<number>;
+    width: number;
+    frameSize: number;
+    _get: (index: number) => T;
+    _set: (index: number, v: T) => boolean | void;
+    _getConstructor?: () => new (length: number) => PixelDataTypedArray;
+    _getScalarDataLength?: () => number;
+    _getScalarData?: () => PixelDataTypedArray;
+    _getSliceData: (args: {
+        sliceIndex: number;
+        slicePlane: number;
+    }) => PixelDataTypedArray;
+    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;
+    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;
+    getMiddleSliceData: () => PixelDataTypedArray;
+    toIndex(ijk: Point3): number;
+    getBoundsIJK(): BoundsIJK;
+    forEach: (callback: (args: {
+        value: unknown;
+        index: number;
+        pointIJK: Point3;
+        pointLPS: Point3;
+    }) => void, options?: {
+        boundsIJK?: BoundsIJK;
+        isInObject?: (pointLPS: any, pointIJK: any) => boolean;
+        returnPoints?: boolean;
+        imageData?: vtkImageData | CPUImageData;
+    }) => any[];
+    getScalarData(): PixelDataTypedArray;
+    getScalarDataLength(): number;
+    get sizeInBytes(): number;
+    get bytePerVoxel(): number;
+    clear(): void;
+    getConstructor(): new (length: number) => PixelDataTypedArray;
+    getArrayOfSlices(): number[];
+    static addBounds(bounds: BoundsIJK, point: Point3): void;
+    addPoint(point: Point3 | number): void;
+    getPoints(): Point3[];
+    getSliceData: ({ sliceIndex, slicePlane, }: {
+        sliceIndex: number;
+        slicePlane: number;
+    }) => PixelDataTypedArray;
+    private setSliceDataValue;
+    private toNumber;
+    private static _createRGBScalarVolumeVoxelManager;
+    static createImageVolumeVoxelManager({ dimensions, imageIds, numberOfComponents, }: {
+        dimensions: Point3;
+        imageIds: string[];
+        numberOfComponents: number;
+    }): IVoxelManager<number> | IVoxelManager<RGB>;
+    static createScalarVolumeVoxelManager({ dimensions, scalarData, numberOfComponents, }: {
+        dimensions: Point3;
+        scalarData: any;
+        numberOfComponents?: number;
+    }): IVoxelManager<number> | IVoxelManager<RGB>;
+    static createScalarDynamicVolumeVoxelManager({ imageIdGroups, dimensions, timePoint, numberOfComponents, }: {
+        imageIdGroups: string[][];
+        dimensions: Point3;
+        timePoint: number;
+        numberOfComponents?: number;
+    }): IVoxelManager<number> | IVoxelManager<RGB>;
+    static createImageVoxelManager({ width, height, scalarData, numberOfComponents, }: {
+        width: number;
+        height: number;
+        scalarData: PixelDataTypedArray;
+        numberOfComponents?: number;
+    }): IVoxelManager<number> | IVoxelManager<RGB>;
+    private static _createNumberVolumeVoxelManager;
+    static createMapVoxelManager<T>({ dimension, }: {
+        dimension: Point3;
+    }): IVoxelManager<T>;
+    static createHistoryVoxelManager<T>({ sourceVoxelManager, }: {
+        sourceVoxelManager: VoxelManager<T>;
+    }): VoxelManager<T>;
+    static createLazyVoxelManager<T>({ dimensions, planeFactory, }: {
+        dimensions: Point3;
+        planeFactory: (width: number, height: number) => T;
+    }): VoxelManager<T>;
+    static createRLEVoxelManager<T>({ dimensions, }: {
+        dimensions: Point3;
+    }): VoxelManager<T>;
+    static addInstanceToImage(image: IImage): void;
+    static: any;
+}
+export type { VoxelManager };