@cornerstonejs/core 4.22.13 → 5.0.0

package/dist/esm/loaders/cornerstoneMeshLoader.js

@@ -1,7 +1,7 @@
 import { createMesh } from './utils/mesh/createMesh';
 import { Events } from '../enums';
 import eventTarget from '../eventTarget';
-import { triggerEvent } from '../utilities';
+import triggerEvent from '../utilities/triggerEvent';
 function fetchArrayBuffer({ url, signal, onload, loaderOptions, }) {
     return new Promise(async (resolve, reject) => {
         const xhr = new XMLHttpRequest();

package/dist/esm/loaders/imageLoader.d.ts

@@ -1,10 +1,11 @@
-import type { IImage, ImageLoaderFn, Point2, Point3, Mat3, PixelDataTypedArrayString, PixelDataTypedArray } from '../types';
+import type { IImage, ImageLoaderFn, Point2, Point3, Mat3, PixelDataTypedArrayString, PixelDataTypedArray, RetrieveOptions } from '../types';
 import VoxelManagerEnum from '../enums/VoxelManagerEnum';
 export interface ImageLoaderOptions {
     priority: number;
     requestType: string;
     additionalDetails?: Record<string, unknown>;
     ignoreCache?: boolean;
+    retrieveOptions?: RetrieveOptions;
 }
 interface LocalImageOptions {
     frameOfReferenceUID?: string;

package/dist/esm/loaders/imageLoader.js

@@ -1,5 +1,7 @@
 import cache from '../cache/cache';
 import Events from '../enums/Events';
+import MetadataModules from '../enums/MetadataModules';
+import { ImageQualityStatus } from '../enums';
 import eventTarget from '../eventTarget';
 import genericMetadataProvider from '../utilities/genericMetadataProvider';
 import { getBufferConfiguration } from '../utilities/getBufferConfiguration';
@@ -11,12 +13,25 @@ import * as metaData from '../metaData';
 import VoxelManagerEnum from '../enums/VoxelManagerEnum';
 const imageLoaders = {};
 let unknownImageLoader;
+function getRequestedImageQualityStatus(options) {
+    return (options.retrieveOptions?.imageQualityStatus ??
+        ImageQualityStatus.FULL_RESOLUTION);
+}
 function loadImageFromImageLoader(imageId, options) {
-    const cachedImageLoadObject = cache.getImageLoadObject(imageId);
+    const cachedImageLoadObject = !options.ignoreCache && cache.getImageLoadObject(imageId);
     if (cachedImageLoadObject) {
         handleImageLoadPromise(cachedImageLoadObject.promise, imageId);
         return cachedImageLoadObject;
     }
+    const cachedImage = !options.ignoreCache &&
+        cache.getImage(imageId, getRequestedImageQualityStatus(options));
+    if (cachedImage) {
+        const imageLoadObject = {
+            promise: Promise.resolve(cachedImage),
+        };
+        handleImageLoadPromise(imageLoadObject.promise, imageId);
+        return imageLoadObject;
+    }
     const scheme = imageId.split(':')[0];
     const loader = imageLoaders[scheme] || unknownImageLoader;
     if (!loader) {
@@ -87,30 +102,30 @@ export function createAndCacheDerivedImage(referencedImageId, options = {}) {
         options.imageId = `derived:${uuidv4()}`;
     }
     const { imageId, skipCreateBuffer, onCacheAdd, voxelRepresentation } = options;
-    const imagePlaneModule = metaData.get('imagePlaneModule', referencedImageId);
+    const imagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, referencedImageId);
     const length = imagePlaneModule.rows * imagePlaneModule.columns;
     const { TypedArrayConstructor } = getBufferConfiguration(options.targetBuffer?.type, length);
     const imageScalarData = new TypedArrayConstructor(skipCreateBuffer ? 1 : length);
     const derivedImageId = imageId;
-    const referencedImagePlaneMetadata = metaData.get('imagePlaneModule', referencedImageId);
+    const referencedImagePlaneMetadata = metaData.get(MetadataModules.IMAGE_PLANE, referencedImageId);
     genericMetadataProvider.add(derivedImageId, {
-        type: 'imagePlaneModule',
+        type: MetadataModules.IMAGE_PLANE,
         metadata: referencedImagePlaneMetadata,
     });
-    const referencedImageGeneralSeriesMetadata = metaData.get('generalSeriesModule', referencedImageId);
+    const referencedImageGeneralSeriesMetadata = metaData.get(MetadataModules.GENERAL_SERIES, referencedImageId);
     genericMetadataProvider.add(derivedImageId, {
-        type: 'generalSeriesModule',
+        type: MetadataModules.GENERAL_SERIES,
         metadata: referencedImageGeneralSeriesMetadata,
     });
     genericMetadataProvider.add(derivedImageId, {
-        type: 'generalImageModule',
+        type: MetadataModules.GENERAL_IMAGE,
         metadata: {
             instanceNumber: options.instanceNumber,
         },
     });
-    const imagePixelModule = metaData.get('imagePixelModule', referencedImageId);
+    const imagePixelModule = metaData.get(MetadataModules.IMAGE_PIXEL, referencedImageId);
     genericMetadataProvider.add(derivedImageId, {
-        type: 'imagePixelModule',
+        type: MetadataModules.IMAGE_PIXEL,
         metadata: {
             ...imagePixelModule,
             bitsAllocated: 8,
@@ -242,7 +257,7 @@ export function createAndCacheLocalImage(imageId, options) {
         imagePlaneModule,
         imagePixelModule,
     };
-    ['imagePlaneModule', 'imagePixelModule'].forEach((type) => {
+    [MetadataModules.IMAGE_PLANE, MetadataModules.IMAGE_PIXEL].forEach((type) => {
         genericMetadataProvider.add(imageId, {
             type,
             metadata: metadata[type] || {},

package/dist/esm/loaders/volumeLoader.js

@@ -4,6 +4,7 @@ import cache from '../cache/cache';
 import Events from '../enums/Events';
 import eventTarget from '../eventTarget';
 import triggerEvent from '../utilities/triggerEvent';
+import { deepClone } from '../utilities/deepClone';
 import uuidv4 from '../utilities/uuidv4';
 import VoxelManager from '../utilities/VoxelManager';
 import { createAndCacheLocalImage, createAndCacheDerivedImages, } from './imageLoader';
@@ -82,7 +83,7 @@ export function createAndCacheDerivedVolume(referencedVolumeId, options) {
     const derivedVolume = new ImageVolume({
         volumeId,
         dataType,
-        metadata: structuredClone(metadata),
+        metadata: deepClone(metadata),
         dimensions: [dimensions[0], dimensions[1], dimensions[2]],
         spacing,
         origin,
@@ -129,7 +130,7 @@ export function createAndCacheVolumeFromImagesSync(volumeId, imageIds) {
     const derivedVolume = new ImageVolume({
         volumeId,
         dataType: volumeProps.dataType,
-        metadata: structuredClone(volumeProps.metadata),
+        metadata: deepClone(volumeProps.metadata),
         dimensions: volumeProps.dimensions,
         spacing: volumeProps.spacing,
         origin: volumeProps.origin,
@@ -142,7 +143,7 @@ export function createAndCacheVolumeFromImagesSync(volumeId, imageIds) {
     return derivedVolume;
 }
 export function createLocalVolume(volumeId, options = {}) {
-    const { metadata, dimensions, spacing, origin, direction, scalarData, targetBuffer, preventCache = false, } = options;
+    const { metadata, dimensions, spacing, origin, direction, scalarData, referencedImageIds, referencedVolumeId, targetBuffer, preventCache = false, } = options;
     const cachedVolume = cache.getVolume(volumeId);
     if (cachedVolume) {
         return cachedVolume;
@@ -182,19 +183,22 @@ export function createLocalVolume(volumeId, options = {}) {
             spacing: [spacing[0], spacing[1]],
             origin,
             direction,
+            referencedImageId: referencedImageIds?.[i],
             targetBuffer: { type: dataType },
         });
         derivedImages.push(derivedImage);
     }
     const imageVolume = new ImageVolume({
         volumeId,
-        metadata: structuredClone(metadata),
+        metadata: deepClone(metadata),
         dimensions: [dimensions[0], dimensions[1], dimensions[2]],
         spacing,
         origin,
         direction,
         imageIds,
         dataType,
+        referencedVolumeId,
+        referencedImageIds,
     });
     const voxelManager = VoxelManager.createImageVolumeVoxelManager({
         imageIds,

package/dist/esm/metaData.d.ts

@@ -1,8 +1,2 @@
-export declare function addProvider(provider: (type: string, ...query: string[]) => unknown, priority?: number): void;
-export declare function removeProvider(provider: (type: string, query: unknown) => unknown): void;
-export declare function removeAllProviders(): void;
-declare function getMetaData(type: string, ...queries: any[]): any;
-export declare function getNormalized(imageId: string, types: string[], metaDataProvider?: typeof getMetaData): {};
-export declare const toUpperCamelTag: (tag: string) => string;
-export declare const toLowerCamelTag: (tag: string) => string;
-export { getMetaData as get };
+import { metaData } from '@cornerstonejs/metadata';
+export declare const addProvider: typeof metaData.addProvider, removeProvider: typeof metaData.removeProvider, removeAllProviders: typeof metaData.removeAllProviders, getMetaData: typeof metaData.getMetaData, getTyped: typeof metaData.getTyped, get: (type: string, ...queries: string[]) => any, getNormalized: typeof metaData.getNormalized, toUpperCamelTag: (tag: string) => string, toLowerCamelTag: (tag: string) => string;

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/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;

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/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;
 }
@@ -71,6 +73,9 @@ export type DataSetOptions = {
     viewReference?: ViewReferenceSpecifier;
 };
 type IViewport = Viewport;
+interface RenderingEngineResizeOptions {
+    keepCamera?: boolean;
+}
 interface PublicViewportInput {
     element: HTMLDivElement;
     viewportId: string;
@@ -81,6 +86,7 @@ interface NormalizedViewportInput {
     element: HTMLDivElement;
     viewportId: string;
     type: ViewportType;
+    requestedType?: ViewportType;
     defaultOptions: ViewportInputOptions;
 }
 interface InternalViewportInput {
@@ -88,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;
@@ -102,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/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,7 +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, 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, 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 };