@cornerstonejs/core 2.0.0-beta.7 → 2.0.0

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

@@ -0,0 +1,99 @@
+import type Cornerstone3DConfig from './Cornerstone3DConfig';
+import type ICamera from './ICamera';
+import type IEnabledElement from './IEnabledElement';
+import type ICache from './ICache';
+import type { IVolume } from './IVolume';
+import type { VOI, VOIRange } from './voi';
+import type DisplayArea from './displayArea';
+import type ImageLoaderFn from './ImageLoaderFn';
+import type IImageVolume from './IImageVolume';
+import type IDynamicImageVolume from './IDynamicImageVolume';
+import type VolumeLoaderFn from './VolumeLoaderFn';
+import type IRegisterImageLoader from './IRegisterImageLoader';
+import type IStreamingVolumeProperties from './IStreamingVolumeProperties';
+import type CustomEventType from './CustomEventType';
+import type { LocalVolumeOptions } from './../loaders/volumeLoader';
+import type { IViewport, PublicViewportInput, ViewReferenceSpecifier, DataSetOptions, ReferenceCompatibleOptions, ViewReference, ViewPresentation, ViewPresentationSelector, ViewportInput } from './IViewport';
+import type { VolumeActor, Actor, ActorEntry, ImageActor, ICanvasActor } from './IActor';
+import type { IImageLoadObject, IVolumeLoadObject, IGeometryLoadObject } from './ILoadObject';
+import type Metadata from './Metadata';
+import type OrientationVectors from './OrientationVectors';
+import type AABB2 from './AABB2';
+import type AABB3 from './AABB3';
+import type Point2 from './Point2';
+import type Point3 from './Point3';
+import type Point4 from './Point4';
+import type { PointsXYZ } from './Point3';
+import type Mat3 from './Mat3';
+import type Plane from './Plane';
+import type IStreamingImageVolume from './IStreamingImageVolume';
+import type ViewportInputOptions from './ViewportInputOptions';
+import type IImageData from './IImageData';
+import type IImageCalibration from './IImageCalibration';
+import type CPUIImageData from './CPUIImageData';
+import type { CPUImageData } from './CPUIImageData';
+import type IImage from './IImage';
+import type { PTScaling, Scaling, ScalingParameters } from './ScalingParameters';
+import type StackViewportProperties from './StackViewportProperties';
+import type VolumeViewportProperties from './VolumeViewportProperties';
+import type IViewportId from './IViewportId';
+import type FlipDirection from './FlipDirection';
+import type ICachedImage from './ICachedImage';
+import type ICachedVolume from './ICachedVolume';
+import type IStackViewport from './IStackViewport';
+import type IWSIViewport from './IWSIViewport';
+import type IVolumeViewport from './IVolumeViewport';
+import type ViewportPreset from './ViewportPreset';
+import type CPUFallbackEnabledElement from './CPUFallbackEnabledElement';
+import type CPUFallbackViewport from './CPUFallbackViewport';
+import type CPUFallbackTransform from './CPUFallbackTransform';
+import type CPUFallbackColormapData from './CPUFallbackColormapData';
+import type CPUFallbackViewportDisplayedArea from './CPUFallbackViewportDisplayedArea';
+import type { CPUFallbackColormapsData } from './CPUFallbackColormapsData';
+import type CPUFallbackColormap from './CPUFallbackColormap';
+import type TransformMatrix2D from './TransformMatrix2D';
+import type CPUFallbackLookupTable from './CPUFallbackLookupTable';
+import type CPUFallbackLUT from './CPUFallbackLUT';
+import type CPUFallbackRenderingTools from './CPUFallbackRenderingTools';
+import type { IVolumeInput, VolumeInputCallback } from './IVolumeInput';
+import type { IStackInput, StackInputCallback } from './IStackInput';
+import type * as EventTypes from './EventTypes';
+import type IRenderingEngine from './IRenderingEngine';
+import type ActorSliceRange from './ActorSliceRange';
+import type ImageSliceData from './ImageSliceData';
+import type IGeometry from './IGeometry';
+import type { PublicContourSetData, ContourSetData, ContourData } from './ContourData';
+import type { PublicSurfaceData, SurfaceData } from './SurfaceData';
+import type ICachedGeometry from './ICachedGeometry';
+import type { IContourSet } from './IContourSet';
+import type { IContour } from './IContour';
+import type RGB from './RGB';
+import type { ColormapPublic, ColormapRegistration } from './Colormap';
+import type { ViewportProperties } from './ViewportProperties';
+import type { PixelDataTypedArray, PixelDataTypedArrayString } from './PixelDataTypedArray';
+import type { ImagePixelModule } from './ImagePixelModule';
+import type { ImagePlaneModule } from './ImagePlaneModule';
+import type { AffineMatrix } from './AffineMatrix';
+export type { RetrieveStage, RetrieveOptions, RangeRetrieveOptions, StreamingRetrieveOptions, NearbyFrames, IRetrieveConfiguration, IImagesLoader, } from './IRetrieveConfiguration';
+import type { ImageLoadListener } from './ImageLoadListener';
+import type { Color, ColorLUT } from './Color';
+import type VideoViewportProperties from './VideoViewportProperties';
+import type WSIViewportProperties from './WSIViewportProperties';
+import type { IVideoViewport } from './IVideoViewport';
+import type { InternalVideoCamera, VideoViewportInput } from './VideoViewportTypes';
+import type { ISurface } from './ISurface';
+import type BoundsIJK from './BoundsIJK';
+import type { ImageVolumeProps } from './ImageVolumeProps';
+import type { VolumeProps } from './VolumeProps';
+import type { BoundsLPS } from './BoundsLPS';
+import type { IPointsManager, PolyDataPointConfiguration } from './IPointsManager';
+import type IImageFrame from './IImageFrame';
+import type { DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, ImagePlaneModuleMetadata, SopCommonModuleMetadata, ImagePixelModuleMetadata, PatientStudyModuleMetadata, TransferSyntaxMetadata } from './MetadataModuleTypes';
+import type { IVoxelManager } from './IVoxelManager';
+import type { IRLEVoxelMap, RLERun } from './IRLEVoxelMap';
+import type ImageLoadRequests from './ImageLoadRequests';
+import type { IBaseVolumeViewport } from './IBaseVolumeViewport';
+import type ScrollOptions from './ScrollOptions';
+import type JumpToSliceOptions from './JumpToSliceOptions';
+import type GeometryLoaderFn from './GeometryLoaderFn';
+export type { Cornerstone3DConfig, ICamera, IStackViewport, IVideoViewport, IWSIViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, IViewportId, IImageVolume, ImageVolumeProps, IDynamicImageVolume, IRenderingEngine, ScalingParameters, PTScaling, IPointsManager, PolyDataPointConfiguration, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, ViewReference, DataSetOptions as ImageSetOptions, ViewPresentation, ViewPresentationSelector, ReferenceCompatibleOptions, ViewReferenceSpecifier, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, ImageActor, ICanvasActor, IImageLoadObject, IVolumeLoadObject, IVolumeInput, VolumeInputCallback, IStackInput, StackInputCallback, ViewportPreset, Metadata, OrientationVectors, AABB2, AABB3, Point2, Point3, PointsXYZ, Point4, Mat3, Plane, ViewportInputOptions, VideoViewportProperties, WSIViewportProperties, VOIRange, VOI, DisplayArea, FlipDirection, ICachedImage, ICachedVolume, CPUFallbackEnabledElement, CPUFallbackViewport, CPUFallbackTransform, CPUFallbackColormapData, CPUFallbackViewportDisplayedArea, CPUFallbackColormapsData, CPUFallbackColormap, TransformMatrix2D, CPUFallbackLookupTable, CPUFallbackLUT, CPUFallbackRenderingTools, CustomEventType, ActorSliceRange, ImageSliceData, IGeometry, IGeometryLoadObject, ICachedGeometry, PublicContourSetData, ContourSetData, ContourData, IContourSet, IContour, PublicSurfaceData, SurfaceData, ISurface, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, PixelDataTypedArrayString, ImagePixelModule, ImagePlaneModule, AffineMatrix, ImageLoadListener, InternalVideoCamera, VideoViewportInput, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, IImageFrame, DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, ImagePlaneModuleMetadata, SopCommonModuleMetadata, ImagePixelModuleMetadata, PatientStudyModuleMetadata, TransferSyntaxMetadata, LocalVolumeOptions, IVoxelManager, IRLEVoxelMap, RLERun, ViewportInput, ImageLoadRequests, IBaseVolumeViewport, GeometryLoaderFn, ScrollOptions, JumpToSliceOptions, };

package/dist/esm/types/index.js

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

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

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

package/dist/esm/types/voi.js

@@ -1,2 +0,0 @@
-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> {
+    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

@@ -135,4 +135,3 @@ export default class PointsManager {
         return new PointsManager({ initialSize, dimensions: 2 });
     }
 }
-//# sourceMappingURL=PointsManager.js.map

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

@@ -16,7 +16,9 @@ export default class ProgressiveIterator {
             catch (e) {
                 iterator.reject(e);
             }
-        }, (reason) => iterator.reject(reason));
+        }, (reason) => {
+            iterator.reject(reason);
+        });
         return iterator;
     }
     add(x, done = false) {
@@ -137,4 +139,3 @@ export default class ProgressiveIterator {
         return promise;
     }
 }
-//# sourceMappingURL=ProgressiveIterator.js.map

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

@@ -0,0 +1,21 @@
+import type { PixelDataTypedArray, RLERun } from '../types';
+export default class RLEVoxelMap<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> | undefined;
+    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

@@ -6,7 +6,7 @@ export default class RLEVoxelMap {
         this.depth = 1;
         this.jMultiple = 1;
         this.kMultiple = 1;
-        this.numComps = 1;
+        this.numberOfComponents = 1;
         this.defaultValue = 0;
         this.pixelDataConstructor = Uint8Array;
         this.get = (index) => {
@@ -50,7 +50,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 +82,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;
                 }
@@ -137,18 +137,18 @@ export default class RLEVoxelMap {
     }
     getPixelData(k = 0, pixelData) {
         if (!pixelData) {
-            pixelData = new this.pixelDataConstructor(this.width * this.height * this.numComps);
+            pixelData = new this.pixelDataConstructor(this.width * this.height * this.numberOfComponents);
         }
         else {
             pixelData.fill(0);
         }
-        const { width, height, numComps } = this;
+        const { width, height, numberOfComponents } = this;
         for (let j = 0; j < height; j++) {
             const row = this.getRun(j, k);
             if (!row) {
                 continue;
             }
-            if (numComps === 1) {
+            if (numberOfComponents === 1) {
                 for (const rle of row) {
                     const rowOffset = j * width;
                     const { start, end, value } = rle;
@@ -159,10 +159,10 @@ export default class RLEVoxelMap {
             }
             else {
                 for (const rle of row) {
-                    const rowOffset = j * width * numComps;
+                    const rowOffset = j * width * numberOfComponents;
                     const { start, end, value } = rle;
-                    for (let i = start; i < end; i += numComps) {
-                        for (let comp = 0; comp < numComps; comp++) {
+                    for (let i = start; i < end; i += numberOfComponents) {
+                        for (let comp = 0; comp < numberOfComponents; comp++) {
                             pixelData[rowOffset + i + comp] = value[comp];
                         }
                     }
@@ -172,4 +172,3 @@ export default class RLEVoxelMap {
         return pixelData;
     }
 }
-//# sourceMappingURL=RLEVoxelMap.js.map

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

@@ -0,0 +1,109 @@
+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> {
+    modifiedSlices: Set<number>;
+    private 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;
+    _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);
+    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;
+    setAtIndex: (index: any, v: any) => boolean;
+    toIJK(index: number): Point3;
+    getMiddleSliceData: () => PixelDataTypedArray;
+    toIndex(ijk: Point3): number;
+    getDefaultBounds(): BoundsIJK;
+    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;
+    setScalarData(newScalarData: PixelDataTypedArray): void;
+    getScalarDataLength(): number;
+    get sizeInBytes(): number;
+    get bytePerVoxel(): number;
+    clear(): void;
+    getConstructor(): new (length: number) => PixelDataTypedArray;
+    getArrayOfModifiedSlices(): number[];
+    resetModifiedSlices(): void;
+    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 };