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

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

@@ -1,11 +1,11 @@
-import Point2 from './Point2';
-import Point3 from './Point3';
-import { IViewport } from './IViewport';
-import { IVolumeInput } from './IVolumeInput';
-import FlipDirection from './FlipDirection';
-import IImageData from './IImageData';
-import { BlendModes, OrientationAxis } from '../enums';
-import { VolumeViewportProperties } from '.';
+import type Point2 from './Point2';
+import type Point3 from './Point3';
+import type { IViewport } from './IViewport';
+import type { IVolumeInput } from './IVolumeInput';
+import type FlipDirection from './FlipDirection';
+import type IImageData from './IImageData';
+import type { BlendModes, OrientationAxis } from '../enums';
+import type VolumeViewportProperties from './VolumeViewportProperties';
 export default interface IVolumeViewport extends IViewport {
     useCPURendering: boolean;
     getFrameOfReferenceUID: () => string;
@@ -17,16 +17,16 @@ export default interface IVolumeViewport extends IViewport {
     getCurrentImageIdIndex: () => number;
     hasVolumeId: (volumeId: string) => boolean;
     hasImageURI: (imageURI: string) => boolean;
-    getCurrentImageId: () => string;
+    getCurrentImageId: () => string | undefined;
     setDefaultProperties(ViewportProperties: VolumeViewportProperties, volumeId?: string): void;
     clearDefaultProperties(volumeId?: string): void;
     setProperties({ voiRange }: VolumeViewportProperties, volumeId?: string, suppressEvents?: boolean): void;
     resetProperties(volumeId: string): void;
-    setVolumes(volumeInputArray: Array<IVolumeInput>, immediate?: boolean, suppressEvents?: boolean): Promise<void>;
-    addVolumes(volumeInputArray: Array<IVolumeInput>, immediate?: boolean, suppressEvents?: boolean): Promise<void>;
-    removeVolumeActors(actorUIDs: Array<string>, immediate?: boolean): void;
+    setVolumes(volumeInputArray: IVolumeInput[], immediate?: boolean, suppressEvents?: boolean): Promise<void>;
+    addVolumes(volumeInputArray: IVolumeInput[], immediate?: boolean, suppressEvents?: boolean): Promise<void>;
+    removeVolumeActors(actorUIDs: string[], immediate?: boolean): void;
     getIntensityFromWorld(point: Point3): number;
-    getBounds(): any;
+    getBounds(): number[];
     flip(flipDirection: FlipDirection): void;
     resetCamera({ resetPan, resetZoom, resetToCenter, resetRotation, suppressEvents, }?: {
         resetPan?: boolean;
@@ -36,9 +36,10 @@ export default interface IVolumeViewport extends IViewport {
         suppressEvents?: boolean;
     }): boolean;
     resetSlabThickness(): void;
-    setBlendMode(blendMode: BlendModes, filterActorUIDs?: Array<string>, immediate?: boolean): void;
-    setSlabThickness(slabThickness: number, filterActorUIDs?: Array<string>): void;
+    setBlendMode(blendMode: BlendModes, filterActorUIDs?: string[], immediate?: boolean): void;
+    setSlabThickness(slabThickness: number, filterActorUIDs?: string[]): void;
     getSlabThickness(): number;
-    getImageData(volumeId?: string): IImageData | undefined;
+    getImageData: (volumeId?: string) => IImageData | undefined;
     setOrientation(orientation: OrientationAxis): void;
+    getVolumeId(): string | undefined;
 }

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

@@ -0,0 +1,54 @@
+import type { BoundsIJK, Point3, PixelDataTypedArray, CPUImageData, IRLEVoxelMap } from '../types';
+import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+interface IVoxelManager<T> {
+    _get: (index: number) => T;
+    _set: (index: number, v: T) => boolean | void;
+    modifiedSlices: Set<number>;
+    boundsIJK: BoundsIJK;
+    map: Map<number, T> | IRLEVoxelMap<T>;
+    sourceVoxelManager: IVoxelManager<T>;
+    isInObject: (pointLPS: Point3, pointIJK: Point3) => boolean;
+    readonly dimensions: Point3;
+    numberOfComponents: number;
+    getCompleteScalarDataArray?: () => ArrayLike<number>;
+    setCompleteScalarDataArray?: (scalarData: ArrayLike<number>) => void;
+    getRange: () => [number, number];
+    points: Set<number>;
+    width: number;
+    frameSize: number;
+    getAtIJK(i: number, j: number, k: number): T;
+    setAtIJK(i: number, j: number, k: number, v: T): void;
+    getAtIJKPoint(point: Point3): T;
+    setAtIJKPoint(point: Point3, v: T): void;
+    getAtIndex(index: number): T;
+    setAtIndex(index: number, v: T): 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: Point3, pointIJK: Point3) => boolean;
+        returnPoints?: boolean;
+        imageData?: vtkImageData | CPUImageData;
+    }): unknown[];
+    getScalarData(): PixelDataTypedArray;
+    getScalarDataLength(): number;
+    get sizeInBytes(): number;
+    get bytePerVoxel(): number;
+    clear(): void;
+    getConstructor(): new (length: number) => PixelDataTypedArray;
+    getArrayOfSlices(): number[];
+    addPoint(point: Point3 | number): void;
+    getPoints(): Point3[];
+    getSliceData(args: {
+        sliceIndex: number;
+        slicePlane: number;
+    }): PixelDataTypedArray;
+}
+export type { IVoxelManager };

package/dist/esm/types/IVoxelManager.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,16 @@
+import type { IViewport } from './IViewport';
+import type WSIViewportProperties from './WSIViewportProperties';
+export default interface IWSIViewport extends IViewport {
+    resize: () => void;
+    setProperties(props: WSIViewportProperties, suppressEvents?: boolean): void;
+    getProperties: () => WSIViewportProperties;
+    setWSI: (imageIds: string[], client: any) => Promise<unknown>;
+    resetProperties(): void;
+    getCurrentImageId(): string;
+    getFrameNumber(): number;
+    setFrameNumber(frameNo: number): any;
+    resetCamera(options?: {
+        resetPan?: boolean;
+        resetZoom?: boolean;
+    }): boolean;
+}

package/dist/esm/types/IWSIViewport.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,5 +1,5 @@
-export type ImageLoadListener = {
+export interface ImageLoadListener {
     successCallback: (imageId: any, image: any) => void;
     errorCallback: (imageId: any, permanent: any, reason: any) => void;
     getLoaderImageOptions?: (imageId: any) => Record<string, unknown>;
-};
+}

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

@@ -1,6 +1,6 @@
-type ImageLoaderFn = (imageId: string, options?: Record<string, any>) => {
-    promise: Promise<Record<string, any>>;
+type ImageLoaderFn = (imageId: string, options?: Record<string, unknown>) => {
+    promise: Promise<Record<string, unknown>>;
     cancelFn?: () => void | undefined;
     decache?: () => void | undefined;
 };
-export default ImageLoaderFn;
+export type { ImageLoaderFn as default };

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

@@ -1,4 +1,4 @@
-import { VOILUTFunctionType } from '../enums';
+import type { VOILUTFunctionType } from '../enums';
 export interface ImagePixelModule {
     bitsAllocated: number;
     bitsStored: number;

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

@@ -1,5 +1,5 @@
-import Point2 from './Point2';
-import Point3 from './Point3';
+import type Point2 from './Point2';
+import type Point3 from './Point3';
 export interface ImagePlaneModule {
     columnCosines?: Point3;
     columnPixelSpacing?: number;

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

@@ -1,5 +1,5 @@
-type ImageSliceData = {
+interface ImageSliceData {
     numberOfSlices: number;
     imageIndex: number;
-};
-export default ImageSliceData;
+}
+export type { ImageSliceData as default };

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

@@ -1,6 +1,6 @@
-import { VolumeProps } from '.';
+import type { VolumeProps } from './VolumeProps';
 interface ImageVolumeProps extends VolumeProps {
-    imageIds: Array<string>;
-    referencedImageIds?: Array<string>;
+    imageIds: string[];
+    referencedImageIds?: string[];
 }
-export { ImageVolumeProps };
+export type { ImageVolumeProps };

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

@@ -1,2 +1,2 @@
 type Mat3 = [number, number, number, number, number, number, number, number, number] | Float32Array;
-export default Mat3;
+export type { Mat3 as default };

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

@@ -1,5 +1,5 @@
 import type { VOI } from './voi';
-type Metadata = {
+interface Metadata {
     BitsAllocated: number;
     BitsStored: number;
     SamplesPerPixel: number;
@@ -8,12 +8,12 @@ type Metadata = {
     PixelRepresentation: number;
     Modality: string;
     SeriesInstanceUID?: string;
-    ImageOrientationPatient: Array<number>;
-    PixelSpacing: Array<number>;
+    ImageOrientationPatient: number[];
+    PixelSpacing: number[];
     FrameOfReferenceUID: string;
     Columns: number;
     Rows: number;
-    voiLut: Array<VOI>;
+    voiLut: VOI[];
     VOILUTFunction: string;
-};
-export default Metadata;
+}
+export type { Metadata as default };

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

@@ -0,0 +1,65 @@
+export interface DicomDateObject {
+    year: number;
+    month: number;
+    day: number;
+}
+export interface DicomTimeObject {
+    hours: number;
+    minutes?: number;
+    seconds?: number;
+    fractionalSeconds?: number;
+}
+export interface GeneralSeriesModuleMetadata {
+    modality: string;
+    seriesInstanceUID: string;
+    seriesNumber: number;
+    studyInstanceUID: string;
+    seriesDate: DicomDateObject;
+    seriesTime: DicomTimeObject;
+}
+export interface PatientStudyModuleMetadata {
+    patientAge: number;
+    patientSize: number;
+    patientWeight: number;
+}
+export interface ImagePlaneModuleMetadata {
+    frameOfReferenceUID: string;
+    rows: string;
+    columns: string;
+    imageOrientationPatient: number[];
+    rowCosines: number[];
+    columnCosines: number[];
+    imagePositionPatient: number[];
+    sliceThickness: string;
+    sliceLocation: string;
+    pixelSpacing: number[];
+    rowPixelSpacing: number | null;
+    columnPixelSpacing: number | null;
+}
+export interface ImagePixelModuleMetadata {
+    samplesPerPixel: number;
+    photometricInterpretation: string;
+    rows: number;
+    columns: number;
+    bitsAllocated: number;
+    bitsStored: number;
+    highBit: number;
+    pixelRepresentation: number;
+    planarConfiguration: number;
+    pixelAspectRatio: string;
+    redPaletteColorLookupTableDescriptor: number[];
+    greenPaletteColorLookupTableDescriptor: number[];
+    bluePaletteColorLookupTableDescriptor: number[];
+    redPaletteColorLookupTableData: number[];
+    greenPaletteColorLookupTableData: number[];
+    bluePaletteColorLookupTableData: number[];
+    smallestPixelValue?: number;
+    largestPixelValue?: number;
+}
+export interface SopCommonModuleMetadata {
+    sopClassUID: string;
+    sopInstanceUID: string;
+}
+export interface TransferSyntaxMetadata {
+    transferSyntaxUID: string;
+}

package/dist/esm/types/MetadataModuleTypes.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,6 +1,6 @@
-import { Point3 } from '../types';
-type OrientationVectors = {
+import type { Point3 } from './Point3';
+interface OrientationVectors {
     viewPlaneNormal: Point3;
     viewUp: Point3;
-};
-export default OrientationVectors;
+}
+export type { OrientationVectors as default };

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

@@ -1,2 +1,2 @@
 type Plane = [number, number, number, number];
-export default Plane;
+export type { Plane as default };

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

@@ -1,2 +1,2 @@
 type Point2 = [number, number];
-export default Point2;
+export type { Point2 as default };

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

@@ -1,7 +1,7 @@
 export type Point3 = [number, number, number];
-export type PointsXYZ = {
+export interface PointsXYZ {
     x: number[];
     y: number[];
     z: number[];
-};
-export default Point3;
+}
+export type { Point3 as default };

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

@@ -1,2 +1,2 @@
 type Point4 = [number, number, number, number];
-export default Point4;
+export type { Point4 as default };

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

@@ -1,2 +1,2 @@
 type RGB = [number, number, number];
-export default RGB;
+export type { RGB as default };

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

@@ -1,19 +1,19 @@
-type ScalingParameters = {
+interface ScalingParameters {
     rescaleSlope: number;
     rescaleIntercept: number;
     modality: string;
     suvbw?: number;
     suvlbm?: number;
     suvbsa?: number;
-};
-type PTScaling = {
+}
+interface PTScaling {
     suvbwToSuvlbm?: number;
     suvbwToSuvbsa?: number;
     suvbw?: number;
     suvlbm?: number;
     suvbsa?: number;
-};
-type Scaling = {
+}
+interface Scaling {
     PT?: PTScaling;
-};
-export { PTScaling, Scaling, ScalingParameters };
+}
+export type { PTScaling, Scaling, ScalingParameters };

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

@@ -1,8 +1,8 @@
-import InterpolationType from '../enums/InterpolationType';
-import { ViewportProperties } from './ViewportProperties';
+import type InterpolationType from '../enums/InterpolationType';
+import type { ViewportProperties } from './ViewportProperties';
 type StackViewportProperties = ViewportProperties & {
     interpolationType?: InterpolationType;
     suppressEvents?: boolean;
     isComputedVOI?: boolean;
 };
-export default StackViewportProperties;
+export type { StackViewportProperties as default };

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

@@ -1,12 +1,12 @@
-import Point3 from './Point3';
-type PublicSurfaceData = {
+import type Point3 from './Point3';
+interface PublicSurfaceData {
     id: string;
     data: SurfaceData;
     frameOfReferenceUID: string;
     color?: Point3;
-};
-type SurfaceData = {
+}
+interface SurfaceData {
     points: number[];
     polys: number[];
-};
+}
 export type { PublicSurfaceData, SurfaceData };

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

@@ -1,2 +1,2 @@
 type TransformMatrix2D = [number, number, number, number, number, number];
-export default TransformMatrix2D;
+export type { TransformMatrix2D as default };

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

@@ -1,5 +1,5 @@
-import { ViewportProperties } from './ViewportProperties';
-import Point2 from './Point2';
+import type { ViewportProperties } from './ViewportProperties';
+import type Point2 from './Point2';
 type VideoViewportProperties = ViewportProperties & {
     loop?: boolean;
     muted?: boolean;
@@ -7,4 +7,4 @@ type VideoViewportProperties = ViewportProperties & {
     playbackRate?: number;
     scrollSpeed?: number;
 };
-export default VideoViewportProperties;
+export type { VideoViewportProperties as default };

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

@@ -1,10 +1,10 @@
-import { ViewportType } from '../enums';
-import Point2 from './Point2';
-export type InternalVideoCamera = {
+import type { ViewportType } from '../enums';
+import type Point2 from './Point2';
+export interface InternalVideoCamera {
     panWorld?: Point2;
     parallelScale?: number;
-};
-export type VideoViewportInput = {
+}
+export interface VideoViewportInput {
     id: string;
     renderingEngineId: string;
     type: ViewportType;
@@ -13,6 +13,6 @@ export type VideoViewportInput = {
     sy: number;
     sWidth: number;
     sHeight: number;
-    defaultOptions: any;
+    defaultOptions: unknown;
     canvas: HTMLCanvasElement;
-};
+}

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

@@ -1,12 +1,12 @@
-import { OrientationAxis } from '../enums';
-import OrientationVectors from './OrientationVectors';
-import DisplayArea from './displayArea';
-import RGB from './RGB';
-type ViewportInputOptions = {
+import type { OrientationAxis } from '../enums';
+import type OrientationVectors from './OrientationVectors';
+import type DisplayArea from './displayArea';
+import type RGB from './RGB';
+interface ViewportInputOptions {
     background?: RGB;
     orientation?: OrientationAxis | OrientationVectors;
     displayArea?: DisplayArea;
     suppressEvents?: boolean;
     parallelProjection?: boolean;
-};
-export default ViewportInputOptions;
+}
+export type { ViewportInputOptions as default };

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

@@ -10,4 +10,4 @@ interface ViewportPreset {
     diffuse: string;
     interpolation: string;
 }
-export default ViewportPreset;
+export type { ViewportPreset as default };

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

@@ -1,10 +1,10 @@
-import { InterpolationType, VOILUTFunctionType } from '../enums';
-import { VOIRange } from './voi';
-import { ColormapPublic } from './Colormap';
-export type ViewportProperties = {
+import type { InterpolationType, VOILUTFunctionType } from '../enums';
+import type { VOIRange } from './voi';
+import type { ColormapPublic } from './Colormap';
+export interface ViewportProperties {
     voiRange?: VOIRange;
     VOILUTFunction?: VOILUTFunctionType;
     invert?: boolean;
     colormap?: ColormapPublic;
     interpolationType?: InterpolationType;
-};
+}

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

@@ -1,6 +1,7 @@
-type VolumeLoaderFn = (volumeId: string, options?: Record<string, any>) => {
-    promise: Promise<Record<string, any>>;
+import type IImageVolume from './IImageVolume';
+type VolumeLoaderFn = (volumeId: string, options?: Record<string, unknown>) => {
+    promise: Promise<IImageVolume>;
     cancelFn?: () => void | undefined;
     decache?: () => void | undefined;
 };
-export default VolumeLoaderFn;
+export type { VolumeLoaderFn as default };

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

@@ -1,8 +1,10 @@
 import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
 import type Point3 from './Point3';
 import type Metadata from './Metadata';
-import Mat3 from './Mat3';
-import { PixelDataTypedArray } from './PixelDataTypedArray';
+import type Mat3 from './Mat3';
+import type { PixelDataTypedArray, PixelDataTypedArrayString } from './PixelDataTypedArray';
+import type RGB from './RGB';
+import type { IVoxelManager } from './IVoxelManager';
 interface VolumeProps {
     volumeId: string;
     metadata: Metadata;
@@ -11,9 +13,11 @@ interface VolumeProps {
     origin: Point3;
     direction: Mat3;
     imageData?: vtkImageData;
-    scalarData: PixelDataTypedArray | Array<PixelDataTypedArray>;
+    voxelManager?: IVoxelManager<number> | IVoxelManager<RGB>;
+    dataType: PixelDataTypedArrayString;
+    scalarData?: PixelDataTypedArray | PixelDataTypedArray[];
     sizeInBytes?: number;
-    additionalDetails?: Record<string, any>;
+    additionalDetails?: Record<string, unknown>;
     scaling?: {
         PT?: {
             SUVlbmFactor?: number;
@@ -23,5 +27,6 @@ interface VolumeProps {
         };
     };
     referencedVolumeId?: string;
+    numberOfComponents?: number;
 }
-export { VolumeProps };
+export type { VolumeProps };

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

@@ -1,8 +1,8 @@
-import { ViewportProperties } from './ViewportProperties';
-import { OrientationAxis } from '../enums';
+import type { ViewportProperties } from './ViewportProperties';
+import type { OrientationAxis } from '../enums';
 type VolumeViewportProperties = ViewportProperties & {
     preset?: string;
     slabThickness?: number;
     orientation?: OrientationAxis;
 };
-export default VolumeViewportProperties;
+export type { VolumeViewportProperties as default };

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

@@ -0,0 +1,3 @@
+import type { ViewportProperties } from './ViewportProperties';
+export type WSIViewportProperties = ViewportProperties;
+export type { WSIViewportProperties as default };

package/dist/esm/types/WSIViewportProperties.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,13 @@
+import type { ViewportType } from '../enums';
+export interface WSIViewportInput {
+    id: string;
+    renderingEngineId: string;
+    type: ViewportType;
+    element: HTMLDivElement;
+    sx: number;
+    sy: number;
+    sWidth: number;
+    sHeight: number;
+    defaultOptions: Record<string, unknown>;
+    canvas: HTMLCanvasElement;
+}

package/dist/esm/types/WSIViewportTypes.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,5 +1,5 @@
-import InterpolationType from '../enums/InterpolationType';
-type DisplayArea = {
+import type InterpolationType from '../enums/InterpolationType';
+interface DisplayArea {
     type?: 'SCALE' | 'FIT';
     scale?: number;
     interpolationType?: InterpolationType;
@@ -9,5 +9,5 @@ type DisplayArea = {
         canvasPoint?: [number, number];
     };
     storeAsInitialCamera?: boolean;
-};
-export default DisplayArea;
+}
+export type { DisplayArea as default };