@cornerstonejs/core 5.0.0-beta.1 → 5.0.1

package/dist/esm/metaData.js

@@ -1,75 +1,2 @@
-const providers = [];
-export function addProvider(provider, priority = 0) {
-    let i;
-    for (i = 0; i < providers.length; i++) {
-        if (providers[i].priority <= priority) {
-            break;
-        }
-    }
-    providers.splice(i, 0, {
-        priority,
-        provider,
-    });
-}
-export function removeProvider(provider) {
-    for (let i = 0; i < providers.length; i++) {
-        if (providers[i].provider === provider) {
-            providers.splice(i, 1);
-            break;
-        }
-    }
-}
-export function removeAllProviders() {
-    while (providers.length > 0) {
-        providers.pop();
-    }
-}
-function getMetaData(type, ...queries) {
-    for (let i = 0; i < providers.length; i++) {
-        const result = providers[i].provider(type, ...queries);
-        if (result !== undefined) {
-            return result;
-        }
-    }
-}
-export function getNormalized(imageId, types, metaDataProvider = getMetaData) {
-    const result = {};
-    for (const t of types) {
-        try {
-            const data = metaDataProvider(t, imageId);
-            if (data) {
-                const capitalizedData = {};
-                for (const key in data) {
-                    if (key in data) {
-                        const capitalizedKey = toUpperCamelTag(key);
-                        capitalizedData[capitalizedKey] = data[key];
-                    }
-                }
-                Object.assign(result, capitalizedData);
-            }
-        }
-        catch (error) {
-            console.error(`Error retrieving ${t} data:`, error);
-        }
-    }
-    return result;
-}
-export const toUpperCamelTag = (tag) => {
-    if (tag.startsWith('sop')) {
-        return `SOP${tag.substring(3)}`;
-    }
-    if (tag.endsWith('Id')) {
-        tag = `${tag.substring(0, tag.length - 2)}ID`;
-    }
-    return tag.charAt(0).toUpperCase() + tag.slice(1);
-};
-export const toLowerCamelTag = (tag) => {
-    if (tag.startsWith('SOP')) {
-        return `sop${tag.substring(3)}`;
-    }
-    if (tag.endsWith('ID')) {
-        tag = `${tag.substring(0, tag.length - 2)}Id`;
-    }
-    return tag.charAt(0).toLowerCase() + tag.slice(1);
-};
-export { getMetaData as get };
+import { metaData } from '@cornerstonejs/metadata';
+export const { addProvider, removeProvider, removeAllProviders, getMetaData, getTyped, get, getNormalized, toUpperCamelTag, toLowerCamelTag, } = metaData;

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

@@ -2,6 +2,7 @@ import type CPUFallbackViewportDisplayedArea from './CPUFallbackViewportDisplaye
 import type CPUFallbackColormap from './CPUFallbackColormap';
 import type CPUFallbackLUT from './CPUFallbackLUT';
 import type VOILUTFunctionType from '../enums/VOILUTFunctionType';
+import type Point2 from './Point2';
 interface CPUFallbackViewport {
     scale?: number;
     parallelScale?: number;
@@ -25,5 +26,6 @@ interface CPUFallbackViewport {
     colormap?: CPUFallbackColormap;
     displayedArea?: CPUFallbackViewportDisplayedArea;
     modality?: string;
+    aspectRatio?: Point2;
 }
 export type { CPUFallbackViewport as default };

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

@@ -11,9 +11,20 @@ interface Cornerstone3DConfig {
         strictZSpacingForVolumeViewport?: boolean;
         renderingEngineMode?: RenderingEngineModeType;
         webGlContextCount?: number;
+        planar?: {
+            cpuThresholds?: {
+                image?: number;
+                volume?: number;
+            };
+            cpuVolume?: {
+                useViewportSamplingForLinear?: boolean;
+                volumeModifiedThrottleMs?: number;
+            };
+        };
         volumeRendering?: {
             sampleDistanceMultiplier?: number;
         };
+        useGenericViewport?: boolean;
     };
     debug: {
         statsOverlay?: boolean;

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

@@ -15,14 +15,14 @@ import type { ColormapPublic } from './Colormap';
 import type IVolumeViewport from './IVolumeViewport';
 import type { ActorEntry } from './IActor';
 interface CameraModifiedEventDetail {
-    previousCamera: ICamera;
+    previousCamera?: ICamera;
     camera: ICamera;
-    element: HTMLDivElement;
+    element?: HTMLDivElement;
     viewportId: string;
     renderingEngineId: string;
 }
 interface CameraResetEventDetail {
-    element: HTMLDivElement;
+    element?: HTMLDivElement;
     viewportId: string;
     renderingEngineId: string;
     camera: ICamera;

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

@@ -1,15 +1,48 @@
 import type vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
+import type vtkImageMapper from '@kitware/vtk.js/Rendering/Core/ImageMapper';
+import type vtkImageResliceMapper from '@kitware/vtk.js/Rendering/Core/ImageResliceMapper';
 import type vtkImageSlice from '@kitware/vtk.js/Rendering/Core/ImageSlice';
 import type vtkVolume from '@kitware/vtk.js/Rendering/Core/Volume';
+import type vtkVolumeMapper from '@kitware/vtk.js/Rendering/Core/VolumeMapper';
 import type CanvasActor from '../RenderingEngine/CanvasActor';
+import type CanvasMapper from '../RenderingEngine/CanvasActor/CanvasMapper';
 import type { BlendModes } from '../enums';
 export type Actor = vtkActor;
 export type VolumeActor = vtkVolume;
 export type ImageActor = vtkImageSlice;
 export type ICanvasActor = CanvasActor;
+export declare enum ActorRenderMode {
+    VTK_IMAGE = "vtkImage",
+    VTK_VOLUME = "vtkVolume",
+    VTK_VOLUME_SLICE = "vtkVolumeSlice",
+    CPU_IMAGE = "cpuImage",
+    CPU_VOLUME = "cpuVolume"
+}
+export type ActorMapperProxy = {
+    renderMode: ActorRenderMode.VTK_IMAGE;
+    actor: ImageActor;
+    mapper: vtkImageMapper;
+} | {
+    renderMode: ActorRenderMode.VTK_VOLUME;
+    actor: VolumeActor;
+    mapper: vtkVolumeMapper;
+} | {
+    renderMode: ActorRenderMode.VTK_VOLUME_SLICE;
+    actor: ImageActor;
+    mapper: vtkImageResliceMapper;
+} | {
+    renderMode: ActorRenderMode.CPU_IMAGE;
+    actor: ICanvasActor;
+    mapper: CanvasMapper;
+} | {
+    renderMode: ActorRenderMode.CPU_VOLUME;
+    actor: ICanvasActor;
+    mapper: CanvasMapper;
+};
 export interface ActorEntry {
     uid: string;
     actor: Actor | VolumeActor | ImageActor | ICanvasActor;
+    actorMapper?: ActorMapperProxy;
     referencedId?: string;
     slabThickness?: number;
     clippingFilter?: any;

package/dist/esm/types/IActor.js

@@ -0,0 +1,8 @@
+export var ActorRenderMode;
+(function (ActorRenderMode) {
+    ActorRenderMode["VTK_IMAGE"] = "vtkImage";
+    ActorRenderMode["VTK_VOLUME"] = "vtkVolume";
+    ActorRenderMode["VTK_VOLUME_SLICE"] = "vtkVolumeSlice";
+    ActorRenderMode["CPU_IMAGE"] = "cpuImage";
+    ActorRenderMode["CPU_VOLUME"] = "cpuVolume";
+})(ActorRenderMode || (ActorRenderMode = {}));

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

@@ -1,10 +1,10 @@
 import type Point3 from './Point3';
 import type Point2 from './Point2';
-interface ICamera {
+interface ICamera<TScale = number> {
     focalPoint?: Point3;
     parallelProjection?: boolean;
     parallelScale?: number;
-    scale?: number;
+    scale?: TScale;
     position?: Point3;
     viewAngle?: number;
     viewPlaneNormal?: Point3;
@@ -13,5 +13,13 @@ interface ICamera {
     flipHorizontal?: boolean;
     flipVertical?: boolean;
     clippingRange?: Point2;
+    aspectRatio?: Point2;
+    isFitViewportAfterStretch?: boolean;
 }
-export type { ICamera as default };
+interface ResetCameraOptions {
+    resetPan?: boolean;
+    resetZoom?: boolean;
+    resetToCenter?: boolean;
+    resetAspectRatio?: boolean;
+}
+export type { ICamera as default, ResetCameraOptions };

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

@@ -6,6 +6,6 @@ interface IEnabledElement {
     renderingEngine: IRenderingEngine;
     viewportId: string;
     renderingEngineId: string;
-    FrameOfReferenceUID: string;
+    FrameOfReferenceUID?: string;
 }
 export type { IEnabledElement as default };

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

@@ -118,6 +118,7 @@ interface CPUFallbackEnabledElement {
         imagePixelModule?: ImagePixelModule;
     };
     voxelManager?: IVoxelManager<number> | IVoxelManager<RGB>;
+    aspectRatio?: Point2;
 }
 export type { IImage as default };
 export type { CPUFallbackEnabledElement };

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

@@ -1,11 +1,2 @@
-import type CalibrationTypes from '../enums/CalibrationTypes';
-export interface IImageCalibration {
-    rowPixelSpacing?: number;
-    columnPixelSpacing?: number;
-    scale?: number;
-    aspect?: number;
-    type: CalibrationTypes;
-    tooltip?: string;
-    sequenceOfUltrasoundRegions?: Record<string, unknown>[];
-}
-export type { IImageCalibration as default };
+export type { IImageCalibration } from '@cornerstonejs/metadata';
+export type { IImageCalibration as default } from '@cornerstonejs/metadata';

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

@@ -32,6 +32,7 @@ export type PlaneRestriction = {
 };
 export interface ViewReference {
     FrameOfReferenceUID?: string;
+    dataId?: string;
     planeRestriction?: PlaneRestriction;
     referencedImageId?: string;
     referencedImageURI?: string;
@@ -40,6 +41,7 @@ export interface ViewReference {
     viewPlaneNormal?: Point3;
     viewUp?: Point3;
     sliceIndex?: number;
+    dimensionGroupNumber?: number;
     volumeId?: string;
     bounds?: BoundsLPS;
 }
@@ -51,6 +53,7 @@ export interface ViewPresentation {
     pan?: Point2;
     flipHorizontal?: boolean;
     flipVertical?: boolean;
+    aspectRatio?: Point2;
 }
 export interface ViewPresentationSelector {
     slabThickness?: number;
@@ -58,6 +61,7 @@ export interface ViewPresentationSelector {
     displayArea?: boolean;
     zoom?: boolean;
     pan?: boolean;
+    aspectRatio?: boolean;
     flipHorizontal?: boolean;
     flipVertical?: boolean;
     windowLevel?: boolean;
@@ -69,6 +73,9 @@ export type DataSetOptions = {
     viewReference?: ViewReferenceSpecifier;
 };
 type IViewport = Viewport;
+interface RenderingEngineResizeOptions {
+    keepCamera?: boolean;
+}
 interface PublicViewportInput {
     element: HTMLDivElement;
     viewportId: string;
@@ -79,6 +86,7 @@ interface NormalizedViewportInput {
     element: HTMLDivElement;
     viewportId: string;
     type: ViewportType;
+    requestedType?: ViewportType;
     defaultOptions: ViewportInputOptions;
 }
 interface InternalViewportInput {
@@ -86,12 +94,14 @@ interface InternalViewportInput {
     canvas: HTMLCanvasElement;
     viewportId: string;
     type: ViewportType;
+    requestedType?: ViewportType;
     defaultOptions: ViewportInputOptions;
 }
 interface ViewportInput {
     id: string;
     renderingEngineId: string;
     type: ViewportType;
+    requestedType?: ViewportType;
     element: HTMLDivElement;
     sx: number;
     sy: number;
@@ -100,4 +110,4 @@ interface ViewportInput {
     defaultOptions: ViewportInputOptions;
     canvas: HTMLCanvasElement;
 }
-export type { IViewport, ViewportInput, PublicViewportInput, InternalViewportInput, NormalizedViewportInput, };
+export type { IViewport, RenderingEngineResizeOptions, ViewportInput, PublicViewportInput, InternalViewportInput, NormalizedViewportInput, };

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

@@ -1,3 +1,4 @@
-import type WSIViewport from '../RenderingEngine/WSIViewport';
-type IWSIViewport = WSIViewport;
+import type LegacyWSIViewport from '../RenderingEngine/WSIViewport';
+import type WSIViewport from '../RenderingEngine/GenericViewport/WSI/WSIViewport';
+type IWSIViewport = LegacyWSIViewport | WSIViewport;
 export type { IWSIViewport as default };

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

@@ -4,13 +4,15 @@ import type IImageCalibration from './IImageCalibration';
 export interface ImagePlaneModule {
     columnCosines?: Point3;
     columnPixelSpacing?: number;
-    imageOrientationPatient?: Float32Array;
+    imageOrientationPatient?: number[] | Float32Array;
     imagePositionPatient?: Point3;
     pixelSpacing?: Point2;
     rowCosines?: Point3;
     rowPixelSpacing?: number;
     sliceLocation?: number;
     sliceThickness?: number;
+    spacingBetweenSlices?: number;
+    pixelPaddingValue?: number;
     frameOfReferenceUID: string;
     columns: number;
     rows: number;

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

@@ -1,70 +1 @@
-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: number;
-    columns: number;
-    imageOrientationPatient: number[];
-    rowCosines: number[];
-    columnCosines: number[];
-    imagePositionPatient: number[];
-    sliceThickness: number;
-    sliceLocation: number;
-    pixelSpacing: number[];
-    rowPixelSpacing: number | null;
-    columnPixelSpacing: number | null;
-    usingDefaultValues: boolean;
-}
-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 FrameMetadata extends SopCommonModuleMetadata {
-    frameNumber: number;
-    numberOfFrames: number;
-}
-export interface TransferSyntaxMetadata {
-    transferSyntaxUID: string;
-}
+export type { DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, PatientStudyModuleMetadata, ImagePlaneModuleMetadata, ImagePixelModuleMetadata, SopCommonModuleMetadata, FrameMetadata, TransferSyntaxMetadata, } from '@cornerstonejs/metadata';

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

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

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

@@ -0,0 +1,33 @@
+export interface CoreViewportTypeRegistry {
+    stack: 'stack';
+    orthographic: 'orthographic';
+    perspective: 'perspective';
+    volume3d: 'volume3d';
+    volume3dNext: 'volume3dNext';
+    planarNext: 'planarNext';
+    video: 'video';
+    videoNext: 'videoNext';
+    wholeSlide: 'wholeSlide';
+    wholeSlideNext: 'wholeSlideNext';
+    ecg: 'ecg';
+    ecgNext: 'ecgNext';
+}
+export interface CoreViewportTypeConstants {
+    readonly STACK: 'stack';
+    readonly ORTHOGRAPHIC: 'orthographic';
+    readonly PERSPECTIVE: 'perspective';
+    readonly VOLUME_3D: 'volume3d';
+    readonly VOLUME_3D_NEXT: 'volume3dNext';
+    readonly PLANAR_NEXT: 'planarNext';
+    readonly VIDEO: 'video';
+    readonly VIDEO_NEXT: 'videoNext';
+    readonly WHOLE_SLIDE: 'wholeSlide';
+    readonly WHOLE_SLIDE_NEXT: 'wholeSlideNext';
+    readonly ECG: 'ecg';
+    readonly ECG_NEXT: 'ecgNext';
+}
+export interface ViewportTypeRegistry extends CoreViewportTypeRegistry {
+}
+export interface ViewportTypeConstants extends CoreViewportTypeConstants {
+}
+export type ViewportType = ViewportTypeRegistry[keyof ViewportTypeRegistry];

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

@@ -14,8 +14,9 @@ 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 { IViewport, PublicViewportInput, ViewReferenceSpecifier, DataSetOptions, ReferenceCompatibleOptions, ViewReference, ViewPresentation, ViewPresentationSelector, ViewportInput, RenderingEngineResizeOptions } from './IViewport';
+import type { VolumeActor, Actor, ActorEntry, ActorMapperProxy, ImageActor, ICanvasActor } from './IActor';
+import { ActorRenderMode } from './IActor';
 import type { IImageLoadObject, IVolumeLoadObject, IGeometryLoadObject } from './ILoadObject';
 import type Metadata from './Metadata';
 import type OrientationVectors from './OrientationVectors';
@@ -106,6 +107,10 @@ import type JumpToSliceOptions from './JumpToSliceOptions';
 import type GeometryLoaderFn from './GeometryLoaderFn';
 import type { RenderingEngineModeType } from './RenderingEngineMode';
 import type { VtkOffscreenMultiRenderWindow } from './VtkOffscreenMultiRenderWindow';
+import type { ViewportDataReference } from '../RenderingEngine/GenericViewport';
+import type { ResetCameraOptions } from './ICamera';
+import type { ViewportType, ViewportTypeConstants, ViewportTypeRegistry } from './ViewportTypeRegistry';
 export type * from './MetadataModuleTypes';
 export type * from './InstanceTypes';
-export type { Cornerstone3DConfig, IBaseStreamingImageVolume, ICamera, IStackViewport, IVideoViewport, IECGViewport, 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, PublicMeshData, MeshData, IMesh, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, PixelDataTypedArrayString, ImagePixelModule, ImagePlaneModule, AffineMatrix, ImageLoadListener, InternalVideoCamera, VideoViewportInput, InternalECGCamera, ECGViewportInput, ECGChannel, ECGWaveformData, ECGViewportProperties, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, IImageFrame, LocalVolumeOptions, IVoxelManager, IRLEVoxelMap, RLERun, ViewportInput, ImageLoadRequests, IBaseVolumeViewport, GeometryLoaderFn, ScrollOptions, JumpToSliceOptions, Memo, HistoryMemo, VoxelManager, RLEVoxelMap, RenderingEngineModeType, VtkOffscreenMultiRenderWindow, };
+export type { Cornerstone3DConfig, IBaseStreamingImageVolume, ICamera, ResetCameraOptions, IStackViewport, IVideoViewport, IECGViewport, 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, RenderingEngineResizeOptions, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, ActorMapperProxy, 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, PublicMeshData, MeshData, IMesh, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, PixelDataTypedArrayString, ImagePixelModule, ImagePlaneModule, AffineMatrix, ImageLoadListener, InternalVideoCamera, VideoViewportInput, InternalECGCamera, ECGViewportInput, ECGChannel, ECGWaveformData, ECGViewportProperties, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, IImageFrame, LocalVolumeOptions, IVoxelManager, IRLEVoxelMap, RLERun, ViewportInput, ImageLoadRequests, IBaseVolumeViewport, GeometryLoaderFn, ScrollOptions, JumpToSliceOptions, Memo, HistoryMemo, VoxelManager, RLEVoxelMap, RenderingEngineModeType, VtkOffscreenMultiRenderWindow, ViewportDataReference, ViewportType, ViewportTypeRegistry, ViewportTypeConstants, };
+export { ActorRenderMode };

package/dist/esm/types/index.js

@@ -0,0 +1,2 @@
+import { ActorRenderMode } from './IActor';
+export { ActorRenderMode };

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

@@ -0,0 +1,83 @@
+export declare const ECG_SECONDS_WIDTH = 150;
+export declare const ECG_CHANNEL_SPACING = 5;
+export declare const ECG_RENDERING_COLORS: {
+    readonly gridMajor: "#7f0000";
+    readonly gridMinor: "#3f0000";
+    readonly baseline: "#7f4c00";
+    readonly trace: "#ffffff";
+    readonly label: "#ffff00";
+    readonly background: "#000000";
+};
+export interface ECGChannelLike {
+    name: string;
+    data: Int16Array;
+    min: number;
+    max: number;
+    visible?: boolean;
+}
+export interface ECGWaveformLike<TChannel extends ECGChannelLike = ECGChannelLike> {
+    channels: TChannel[];
+    numberOfChannels: number;
+    numberOfSamples: number;
+    samplingFrequency: number;
+    bitsAllocated: number;
+    sampleInterpretation: string;
+    multiplexGroupLabel?: string;
+    calibration?: unknown;
+}
+export interface ECGChannelLayout<TChannel extends ECGChannelLike = ECGChannelLike> {
+    channel: TChannel;
+    itemHeight: number;
+    yOffset: number;
+    baseline: number;
+}
+export interface ECGRenderMetrics {
+    ecgWidth: number;
+    ecgHeight: number;
+    channelScale: number;
+    worldToCanvasRatio: number;
+    xOffsetCanvas: number;
+    yOffsetCanvas: number;
+}
+export interface ECGGridMetrics {
+    ecgWidth: number;
+    ecgHeight: number;
+    channelScale: number;
+}
+export declare function loadECGWaveform(dataId: string): Promise<{
+    waveform: ECGWaveformLike;
+    calibration: unknown;
+}>;
+export declare function computeECGMinMax(data: Int16Array): {
+    min: number;
+    max: number;
+};
+export declare function getDefaultECGValueRange(waveform: ECGWaveformLike): [number, number];
+export declare function getVisibleECGChannels<TChannel extends ECGChannelLike>(channels: TChannel[], visibleChannels?: number[]): TChannel[];
+export declare function getVisibleECGChannelsByFlag<TChannel extends ECGChannelLike>(channels: TChannel[]): TChannel[];
+export declare function computeECGHeight<TChannel extends ECGChannelLike>(visibleChannels: TChannel[], channelScale: number): number;
+export declare function computeECGChannelLayouts<TChannel extends ECGChannelLike>(args: {
+    visibleChannels: TChannel[];
+    channelScale: number;
+}): ECGChannelLayout<TChannel>[];
+export declare function computeECGRenderMetrics<TChannel extends ECGChannelLike>(args: {
+    canvas: HTMLCanvasElement;
+    visibleChannels: TChannel[];
+    windowMs: number;
+    valueRange: [number, number];
+}): ECGRenderMetrics;
+export declare function drawECGGrid(ctx: CanvasRenderingContext2D, metrics: ECGGridMetrics, options?: {
+    showGrid?: boolean;
+}): void;
+export declare function drawECGTraces<TChannel extends ECGChannelLike>(args: {
+    ctx: CanvasRenderingContext2D;
+    layouts: ECGChannelLayout<TChannel>[];
+    ecgWidth: number;
+    channelScale: number;
+    startIndex?: number;
+    endIndex?: number;
+    lineWidth?: number;
+    amplitudeScale?: number;
+}): void;
+export declare function drawECGLabels<TChannel extends ECGChannelLike>(ctx: CanvasRenderingContext2D, layouts: ECGChannelLayout<TChannel>[], worldToCanvasRatio: number): void;
+export declare function ensureECGCanvasSize(canvas: HTMLCanvasElement): void;