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

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

@@ -12,7 +12,8 @@ import type VolumeLoaderFn from './VolumeLoaderFn';
 import type IRegisterImageLoader from './IRegisterImageLoader';
 import type IStreamingVolumeProperties from './IStreamingVolumeProperties';
 import type CustomEventType from './CustomEventType';
-import type { IViewport, PublicViewportInput, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewReference, ViewPresentation, ViewPresentationSelector } from './IViewport';
+import type { LocalVolumeOptions } from './../loaders/volumeLoader';
+import type { IViewport, PublicViewportInput, ViewReferenceSpecifier, DataSetOptions, ReferenceCompatibleOptions, ViewReference, ViewPresentation, ViewPresentationSelector } from './IViewport';
 import type { VolumeActor, Actor, ActorEntry, ImageActor, ICanvasActor } from './IActor';
 import type { IImageLoadObject, IVolumeLoadObject, IGeometryLoadObject } from './ILoadObject';
 import type Metadata from './Metadata';
@@ -40,6 +41,7 @@ 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';
@@ -47,7 +49,7 @@ 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 { CPUFallbackColormapsData } from './CPUFallbackColormapsData';
 import type CPUFallbackColormap from './CPUFallbackColormap';
 import type TransformMatrix2D from './TransformMatrix2D';
 import type CPUFallbackLookupTable from './CPUFallbackLookupTable';
@@ -66,7 +68,7 @@ import type ICachedGeometry from './ICachedGeometry';
 import type { IContourSet } from './IContourSet';
 import type { IContour } from './IContour';
 import type RGB from './RGB';
-import { ColormapPublic, ColormapRegistration } from './Colormap';
+import type { ColormapPublic, ColormapRegistration } from './Colormap';
 import type { ViewportProperties } from './ViewportProperties';
 import type { PixelDataTypedArray, PixelDataTypedArrayString } from './PixelDataTypedArray';
 import type { ImagePixelModule } from './ImagePixelModule';
@@ -76,12 +78,18 @@ export type { RetrieveStage, RetrieveOptions, RangeRetrieveOptions, StreamingRet
 import type { ImageLoadListener } from './ImageLoadListener';
 import type { Color, ColorLUT } from './Color';
 import type VideoViewportProperties from './VideoViewportProperties';
-import type IVideoViewport from './IVideoViewport';
+import type WSIViewportProperties from './WSIViewportProperties';
+import type { IVideoViewport } from './IVideoViewport';
 import type { InternalVideoCamera, VideoViewportInput } from './VideoViewportTypes';
-import { ISurface } from './ISurface';
+import type { WSIViewportInput } from './WSIViewportTypes';
+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 PointsManager from '../utilities/PointsManager';
-export type { Cornerstone3DConfig, ICamera, IStackViewport, IVideoViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, IViewportId, IImageVolume, ImageVolumeProps, IDynamicImageVolume, IRenderingEngine, ScalingParameters, PTScaling, PointsManager, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, ViewReference, 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, 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, };
+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';
+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, WSIViewportInput, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, IImageFrame, DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, ImagePlaneModuleMetadata, SopCommonModuleMetadata, ImagePixelModuleMetadata, PatientStudyModuleMetadata, TransferSyntaxMetadata, LocalVolumeOptions, IVoxelManager, IRLEVoxelMap, RLERun, };

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

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

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

@@ -1,12 +1,10 @@
-import type { Point2, Point3, PointsXYZ } from '../types';
-export type PolyDataPointConfiguration = {
-    dimensions?: number;
-    initialSize?: number;
-    growSize?: number;
-};
-export default class PointsManager<T> {
+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: PointsManager<T>[];
+    sources: IPointsManager<T>[];
     data: Float32Array;
     _dimensions: number;
     _length: number;
@@ -26,8 +24,8 @@ export default class PointsManager<T> {
     map<R>(f: (value: any, index: number) => R): R[];
     get points(): T[];
     toXYZ(): PointsXYZ;
-    static fromXYZ({ x, y, z }: PointsXYZ): PointsManager<Point3>;
-    subselect(count?: number, offset?: number): PointsManager<T>;
+    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/ProgressiveIterator.d.ts

@@ -16,7 +16,7 @@ export default class ProgressiveIterator<T> {
     getRecent(): T;
     [Symbol.asyncIterator](): AsyncGenerator<any, void, unknown>;
     forEach(callback: any, errorCallback: any): Promise<void>;
-    generate(processFunction: any, errorCallback?: ErrorCallback): Promise<any>;
+    generate(processFunction: any, errorCallback?: ErrorCallback): Promise<unknown>;
     nextPromise(): Promise<T>;
     donePromise(): Promise<T>;
     getNextPromise(): 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) {

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

@@ -1,17 +1,12 @@
-import { PixelDataTypedArray } from '../types';
-export type RLERun<T> = {
-    value: T;
-    start: number;
-    end: number;
-};
-export default class RLEVoxelMap<T> {
+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 numComps: number;
+    protected numberOfComponents: number;
     defaultValue: T;
     pixelDataConstructor: Uint8ArrayConstructor;
     constructor(width: number, height: number, depth?: number);

package/dist/esm/utilities/RLEVoxelMap.js

@@ -6,14 +6,14 @@ 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) => {
             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;
@@ -50,18 +50,18 @@ 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) {
+                if (rleNext.value === value && rleNext.start === i + 1) {
                     rlePrev.end = rleNext.end;
                     row.splice(rleIndex, 1);
                 }
-                else if (rleNext?.start === i) {
+                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) {
+                        if (rleNext.start === i + 1 && rleNext.value === value) {
                             rlePrev.end = rleNext.end;
                             row.splice(rleIndex, 1);
                         }
@@ -69,9 +69,9 @@ export default class RLEVoxelMap {
                 }
                 return;
             }
-            if (rleNext?.value === value && rleNext.start === i + 1) {
+            if (rleNext.value === value && rleNext.start === i + 1) {
                 rleNext.start--;
-                if (rlePrev?.end > i) {
+                if (rlePrev.end > i) {
                     rlePrev.end = i;
                     if (rlePrev.end === rlePrev.start) {
                         row.splice(rleIndex, 1);
@@ -79,16 +79,16 @@ export default class RLEVoxelMap {
                 }
                 return;
             }
-            if (rleNext?.start === i && rleNext.end === i + 1) {
+            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;
                 }
                 return;
             }
-            if (i === rleNext?.start) {
+            if (i === rleNext.start) {
                 rleNext.start++;
             }
             if (isAfter && end > i + 1) {
@@ -101,7 +101,7 @@ export default class RLEVoxelMap {
             else {
                 row.splice(insertIndex, 0, rleInsert);
             }
-            if (rlePrev?.end > i) {
+            if (rlePrev.end > i) {
                 rlePrev.end = i;
             }
         };
@@ -118,7 +118,7 @@ export default class RLEVoxelMap {
         }
         const index = this.findIndex(row, i);
         const rle = row[index];
-        return i >= rle?.start ? rle : undefined;
+        return i >= rle.start ? rle : undefined;
     }
     findIndex(row, i) {
         for (let index = 0; index < row.length; index++) {
@@ -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];
                         }
                     }

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

@@ -1,44 +1,106 @@
-import type { BoundsIJK, Point3, PixelDataTypedArray, IImage, RGB } from '../types';
-import RLEVoxelMap from './RLEVoxelMap';
-export default class VoxelManager<T> {
+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;
-    scalarData: PixelDataTypedArray;
-    map: Map<number, T> | RLEVoxelMap<T>;
-    sourceVoxelManager: VoxelManager<T>;
-    isInObject: (pointIPS: any, pointIJK: any) => boolean;
+    map: Map<number, T> | IRLEVoxelMap<T>;
+    sourceVoxelManager: IVoxelManager<T>;
+    isInObject: (pointLPS: any, pointIJK: any) => boolean;
     readonly dimensions: Point3;
-    numComps: number;
+    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;
-    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;
+    getMiddleSliceData: () => PixelDataTypedArray;
     toIndex(ijk: Point3): number;
     getBoundsIJK(): BoundsIJK;
-    forEach: (callback: any, options?: any) => void;
+    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;
-    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>;
+    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 };