@cornerstonejs/core 4.22.13 → 5.0.0

package/dist/esm/RenderingEngine/vtkClasses/vtkStreamingOpenGLVolumeMapper.js

@@ -247,12 +247,18 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
                 currentTexture.enableUseHalfFloat(false);
                 const previousTextureParameters = currentTexture.getTextureParameters();
                 const dataType = imageData.get('dataType').dataType;
+                const textureNumberOfComponents = imageData.getPointData()?.getScalars()?.getNumberOfComponents?.() ??
+                    imageData.get('numberOfComponents').numberOfComponents ??
+                    1;
                 let shouldReset = true;
                 if (previousTextureParameters?.dataType === dataType) {
                     if (previousTextureParameters?.width === dims[0]) {
                         if (previousTextureParameters?.height === dims[1]) {
                             if (previousTextureParameters?.depth === dims[2]) {
-                                shouldReset = false;
+                                if (previousTextureParameters?.numberOfComponents ===
+                                    textureNumberOfComponents) {
+                                    shouldReset = false;
+                                }
                             }
                         }
                     }
@@ -265,14 +271,14 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
                         width: dims[0],
                         height: dims[1],
                         depth: dims[2],
-                        numberOfComponents: numIComps,
+                        numberOfComponents: textureNumberOfComponents,
                         dataType,
                     });
                     currentTexture.create3DFromRaw({
                         width: dims[0],
                         height: dims[1],
                         depth: dims[2],
-                        numComps: numIComps,
+                        numComps: textureNumberOfComponents,
                         dataType,
                         data: null,
                     });

package/dist/esm/cache/cache.d.ts

@@ -45,7 +45,7 @@ declare class Cache {
     decrementGeometryCacheSize: (decrement: number) => void;
     getImageByReferencedImageId: (referencedImageId: string) => IImage | undefined;
     getImage: (imageId: string, minQuality?: ImageQualityStatus) => IImage | undefined;
-    setPartialImage(imageId: string, partialImage?: IImage): void;
+    setPartialImage(imageId: string, partialImage?: IImage, removeImageLoadObject?: boolean): void;
     getImageQuality(imageId: string): ImageQualityStatus;
     getVolume: (volumeId: string, allowPartialMatch?: boolean) => IImageVolume | IBaseStreamingImageVolume | undefined;
     getVolumes: () => IImageVolume[];

package/dist/esm/cache/cache.js

@@ -645,7 +645,7 @@ class Cache {
             throw error;
         }
     }
-    setPartialImage(imageId, partialImage) {
+    setPartialImage(imageId, partialImage, removeImageLoadObject = false) {
         const cachedImage = this._imageCache.get(imageId);
         if (!cachedImage) {
             if (partialImage) {
@@ -667,6 +667,9 @@ class Cache {
             cachedImage.image = partialImage || cachedImage.image;
         }
         else {
+            if (removeImageLoadObject) {
+                cachedImage.imageLoadObject = null;
+            }
             cachedImage.image = partialImage || cachedImage.image;
         }
     }

package/dist/esm/cache/classes/BaseStreamingImageVolume.js

@@ -1,5 +1,5 @@
 import * as metaData from '../../metaData';
-import { Events, ImageQualityStatus, RequestType } from '../../enums';
+import { Events, ImageQualityStatus, MetadataModules, RequestType, } from '../../enums';
 import eventTarget from '../../eventTarget';
 import imageLoadPoolManager from '../../requestPool/imageLoadPoolManager';
 import ProgressiveIterator from '../../utilities/ProgressiveIterator';
@@ -164,7 +164,7 @@ export class BaseStreamingImageVolume extends ImageVolume {
     }
     load(callback) {
         const { imageIds, loadStatus, numFrames } = this;
-        const { transferSyntaxUID } = metaData.get('transferSyntax', imageIds[0]) || {};
+        const { transferSyntaxUID } = metaData.get(MetadataModules.TRANSFER_SYNTAX, imageIds[0]) || {};
         const imageRetrieveConfiguration = metaData.get(imageRetrieveMetadataProvider.IMAGE_RETRIEVE_CONFIGURATION, this.volumeId, transferSyntaxUID, 'volume');
         this.imagesLoader = this.isDynamicVolume()
             ? this
@@ -195,12 +195,12 @@ export class BaseStreamingImageVolume extends ImageVolume {
         this._prefetchImageIds();
     }
     getLoaderImageOptions(imageId) {
-        const { transferSyntaxUID: transferSyntaxUID } = metaData.get('transferSyntax', imageId) || {};
+        const { transferSyntaxUID: transferSyntaxUID } = metaData.get(MetadataModules.TRANSFER_SYNTAX, imageId) || {};
         const targetRows = this.dimensions[1];
         const targetCols = this.dimensions[0];
         const imageIdIndex = this.getImageIdIndex(imageId);
-        const modalityLutModule = metaData.get('modalityLutModule', imageId) || {};
-        const generalSeriesModule = metaData.get('generalSeriesModule', imageId) || {};
+        const modalityLutModule = metaData.get(MetadataModules.MODALITY_LUT, imageId) || {};
+        const generalSeriesModule = metaData.get(MetadataModules.GENERAL_SERIES, imageId) || {};
         const scalingParameters = {
             rescaleSlope: modalityLutModule.rescaleSlope,
             rescaleIntercept: modalityLutModule.rescaleIntercept,
@@ -208,7 +208,7 @@ export class BaseStreamingImageVolume extends ImageVolume {
         };
         const modality = scalingParameters.modality;
         if (modality === 'PT' || modality === 'RTDOSE') {
-            const scalingFactor = metaData.get('scalingModule', imageId);
+            const scalingFactor = metaData.get(MetadataModules.SCALING, imageId);
             if (scalingFactor) {
                 this._addScalingToVolume(scalingFactor);
                 Object.assign(scalingParameters, scalingFactor);

package/dist/esm/cache/classes/ImageVolume.js

@@ -29,6 +29,11 @@ export class ImageVolume {
         this.origin = origin;
         this.direction = direction;
         this.dataType = dataType;
+        this.hasPixelSpacing =
+            Number.isFinite(spacing[0]) &&
+                spacing[0] > 0 &&
+                Number.isFinite(spacing[1]) &&
+                spacing[1] > 0;
         this.vtkOpenGLTexture = vtkStreamingOpenGLTexture.newInstance();
         this.vtkOpenGLTexture.setVolumeId(volumeId);
         this.voxelManager =

package/dist/esm/enums/CalibrationTypes.d.ts

@@ -1,12 +1,4 @@
-export declare enum CalibrationTypes {
-    NOT_APPLICABLE = "",
-    ERMF = "ERMF",
-    USER = "User",
-    PROJECTION = "Proj",
-    REGION = "Region",
-    ERROR = "Error",
-    UNCALIBRATED = "Uncalibrated",
-    CALIBRATED = "Calibrated",
-    UNKNOWN = "Unknown"
-}
-export default CalibrationTypes;
+import { Enums } from '@cornerstonejs/metadata';
+export declare const CalibrationTypes: typeof Enums.CalibrationTypes;
+declare const _default: typeof Enums.CalibrationTypes;
+export default _default;

package/dist/esm/enums/CalibrationTypes.js

@@ -1,13 +1,3 @@
-export var CalibrationTypes;
-(function (CalibrationTypes) {
-    CalibrationTypes["NOT_APPLICABLE"] = "";
-    CalibrationTypes["ERMF"] = "ERMF";
-    CalibrationTypes["USER"] = "User";
-    CalibrationTypes["PROJECTION"] = "Proj";
-    CalibrationTypes["REGION"] = "Region";
-    CalibrationTypes["ERROR"] = "Error";
-    CalibrationTypes["UNCALIBRATED"] = "Uncalibrated";
-    CalibrationTypes["CALIBRATED"] = "Calibrated";
-    CalibrationTypes["UNKNOWN"] = "Unknown";
-})(CalibrationTypes || (CalibrationTypes = {}));
-export default CalibrationTypes;
+import { Enums } from '@cornerstonejs/metadata';
+export const CalibrationTypes = Enums.CalibrationTypes;
+export default Enums.CalibrationTypes;

package/dist/esm/enums/MetadataModules.d.ts

@@ -1,38 +1,3 @@
-declare enum MetadataModules {
-    CALIBRATION = "calibrationModule",
-    CINE = "cineModule",
-    GENERAL_IMAGE = "generalImageModule",
-    GENERAL_SERIES = "generalSeriesModule",
-    GENERAL_STUDY = "generalStudyModule",
-    IMAGE_PIXEL = "imagePixelModule",
-    IMAGE_PLANE = "imagePlaneModule",
-    IMAGE_URL = "imageUrlModule",
-    MODALITY_LUT = "modalityLutModule",
-    MULTIFRAME = "multiframeModule",
-    NM_MULTIFRAME_GEOMETRY = "nmMultiframeGeometryModule",
-    OVERLAY_PLANE = "overlayPlaneModule",
-    PATIENT = "patientModule",
-    PATIENT_STUDY = "patientStudyModule",
-    PET_IMAGE = "petImageModule",
-    PET_ISOTOPE = "petIsotopeModule",
-    PET_SERIES = "petSeriesModule",
-    SOP_COMMON = "sopCommonModule",
-    ULTRASOUND_ENHANCED_REGION = "ultrasoundEnhancedRegionModule",
-    ECG = "ecgModule",
-    VOI_LUT = "voiLutModule",
-    FRAME_MODULE = "frameModule",
-    WADO_WEB_CLIENT = "wadoWebClient",
-    INSTANCE = "instance",
-    IMAGE_SOP_INSTANCE_REFERENCE = "ImageSopInstanceReference",
-    REFERENCED_SERIES_REFERENCE = "ReferencedSeriesReference",
-    PREDECESSOR_SEQUENCE = "PredecessorSequence",
-    STUDY_DATA = "StudyData",
-    SERIES_DATA = "SeriesData",
-    IMAGE_DATA = "ImageData",
-    RTSS_INSTANCE_DATA = "RtssInstanceData",
-    NEW_INSTANCE_DATA = "NewInstanceData",
-    RTSS_CONTOUR = "metaRTSSContour",
-    SEG_BIT = "metaSegBitmap",
-    SR_ANNOTATION = "metaSrAnnotation"
-}
-export default MetadataModules;
+import { Enums } from '@cornerstonejs/metadata';
+declare const _default: typeof Enums.MetadataModules;
+export default _default;

package/dist/esm/enums/MetadataModules.js

@@ -1,39 +1,2 @@
-var MetadataModules;
-(function (MetadataModules) {
-    MetadataModules["CALIBRATION"] = "calibrationModule";
-    MetadataModules["CINE"] = "cineModule";
-    MetadataModules["GENERAL_IMAGE"] = "generalImageModule";
-    MetadataModules["GENERAL_SERIES"] = "generalSeriesModule";
-    MetadataModules["GENERAL_STUDY"] = "generalStudyModule";
-    MetadataModules["IMAGE_PIXEL"] = "imagePixelModule";
-    MetadataModules["IMAGE_PLANE"] = "imagePlaneModule";
-    MetadataModules["IMAGE_URL"] = "imageUrlModule";
-    MetadataModules["MODALITY_LUT"] = "modalityLutModule";
-    MetadataModules["MULTIFRAME"] = "multiframeModule";
-    MetadataModules["NM_MULTIFRAME_GEOMETRY"] = "nmMultiframeGeometryModule";
-    MetadataModules["OVERLAY_PLANE"] = "overlayPlaneModule";
-    MetadataModules["PATIENT"] = "patientModule";
-    MetadataModules["PATIENT_STUDY"] = "patientStudyModule";
-    MetadataModules["PET_IMAGE"] = "petImageModule";
-    MetadataModules["PET_ISOTOPE"] = "petIsotopeModule";
-    MetadataModules["PET_SERIES"] = "petSeriesModule";
-    MetadataModules["SOP_COMMON"] = "sopCommonModule";
-    MetadataModules["ULTRASOUND_ENHANCED_REGION"] = "ultrasoundEnhancedRegionModule";
-    MetadataModules["ECG"] = "ecgModule";
-    MetadataModules["VOI_LUT"] = "voiLutModule";
-    MetadataModules["FRAME_MODULE"] = "frameModule";
-    MetadataModules["WADO_WEB_CLIENT"] = "wadoWebClient";
-    MetadataModules["INSTANCE"] = "instance";
-    MetadataModules["IMAGE_SOP_INSTANCE_REFERENCE"] = "ImageSopInstanceReference";
-    MetadataModules["REFERENCED_SERIES_REFERENCE"] = "ReferencedSeriesReference";
-    MetadataModules["PREDECESSOR_SEQUENCE"] = "PredecessorSequence";
-    MetadataModules["STUDY_DATA"] = "StudyData";
-    MetadataModules["SERIES_DATA"] = "SeriesData";
-    MetadataModules["IMAGE_DATA"] = "ImageData";
-    MetadataModules["RTSS_INSTANCE_DATA"] = "RtssInstanceData";
-    MetadataModules["NEW_INSTANCE_DATA"] = "NewInstanceData";
-    MetadataModules["RTSS_CONTOUR"] = "metaRTSSContour";
-    MetadataModules["SEG_BIT"] = "metaSegBitmap";
-    MetadataModules["SR_ANNOTATION"] = "metaSrAnnotation";
-})(MetadataModules || (MetadataModules = {}));
-export default MetadataModules;
+import { Enums } from '@cornerstonejs/metadata';
+export default Enums.MetadataModules;

package/dist/esm/enums/ViewportType.d.ts

@@ -3,8 +3,13 @@ declare enum ViewportType {
     ORTHOGRAPHIC = "orthographic",
     PERSPECTIVE = "perspective",
     VOLUME_3D = "volume3d",
+    VOLUME_3D_NEXT = "volume3dNext",
+    PLANAR_NEXT = "planarNext",
     VIDEO = "video",
+    VIDEO_NEXT = "videoNext",
     WHOLE_SLIDE = "wholeSlide",
-    ECG = "ecg"
+    WHOLE_SLIDE_NEXT = "wholeSlideNext",
+    ECG = "ecg",
+    ECG_NEXT = "ecgNext"
 }
 export default ViewportType;

package/dist/esm/enums/ViewportType.js

@@ -4,8 +4,13 @@ var ViewportType;
     ViewportType["ORTHOGRAPHIC"] = "orthographic";
     ViewportType["PERSPECTIVE"] = "perspective";
     ViewportType["VOLUME_3D"] = "volume3d";
+    ViewportType["VOLUME_3D_NEXT"] = "volume3dNext";
+    ViewportType["PLANAR_NEXT"] = "planarNext";
     ViewportType["VIDEO"] = "video";
+    ViewportType["VIDEO_NEXT"] = "videoNext";
     ViewportType["WHOLE_SLIDE"] = "wholeSlide";
+    ViewportType["WHOLE_SLIDE_NEXT"] = "wholeSlideNext";
     ViewportType["ECG"] = "ecg";
+    ViewportType["ECG_NEXT"] = "ecgNext";
 })(ViewportType || (ViewportType = {}));
 export default ViewportType;

package/dist/esm/enums/ViewportTypes.d.ts

@@ -0,0 +1,5 @@
+import type { ViewportTypeConstants } from '../types/ViewportTypeRegistry';
+export type ViewportTypesMap = ViewportTypeConstants;
+declare const ViewportTypes: ViewportTypesMap;
+export declare function registerViewportTypesConstant<Name extends keyof ViewportTypeConstants>(name: Name, type: ViewportTypeConstants[Name]): void;
+export default ViewportTypes;

package/dist/esm/enums/ViewportTypes.js

@@ -0,0 +1,23 @@
+import ViewportType from './ViewportType';
+const builtInViewportTypes = {
+    STACK: ViewportType.STACK,
+    ORTHOGRAPHIC: ViewportType.ORTHOGRAPHIC,
+    PERSPECTIVE: ViewportType.PERSPECTIVE,
+    VOLUME_3D: ViewportType.VOLUME_3D,
+    VOLUME_3D_NEXT: ViewportType.VOLUME_3D_NEXT,
+    PLANAR_NEXT: ViewportType.PLANAR_NEXT,
+    VIDEO: ViewportType.VIDEO,
+    VIDEO_NEXT: ViewportType.VIDEO_NEXT,
+    WHOLE_SLIDE: ViewportType.WHOLE_SLIDE,
+    WHOLE_SLIDE_NEXT: ViewportType.WHOLE_SLIDE_NEXT,
+    ECG: ViewportType.ECG,
+    ECG_NEXT: ViewportType.ECG_NEXT,
+};
+const ViewportTypes = builtInViewportTypes;
+export function registerViewportTypesConstant(name, type) {
+    if (Object.prototype.hasOwnProperty.call(ViewportTypes, name)) {
+        throw new Error(`Viewport type constant "${String(name)}" already exists`);
+    }
+    ViewportTypes[name] = type;
+}
+export default ViewportTypes;

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

@@ -1,6 +1,7 @@
 import Events from './Events';
 import RequestType from './RequestType';
 import ViewportType from './ViewportType';
+import ViewportTypes, { type ViewportTypesMap } from './ViewportTypes';
 import InterpolationType from './InterpolationType';
 import BlendModes from './BlendModes';
 import OrientationAxis from './OrientationAxis';
@@ -17,4 +18,4 @@ import MetadataModules from './MetadataModules';
 import { GenerateImageType } from './GenerateImageType';
 import VoxelManagerEnum from './VoxelManagerEnum';
 import RenderingEngineModeEnum from './RenderingEngineModeEnum';
-export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, GeometryType, ContourType, MeshType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, RenderingEngineModeEnum, };
+export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, ViewportTypes, type ViewportTypesMap, OrientationAxis, GeometryType, ContourType, MeshType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, RenderingEngineModeEnum, };

package/dist/esm/enums/index.js

@@ -1,6 +1,7 @@
 import Events from './Events';
 import RequestType from './RequestType';
 import ViewportType from './ViewportType';
+import ViewportTypes, {} from './ViewportTypes';
 import InterpolationType from './InterpolationType';
 import BlendModes from './BlendModes';
 import OrientationAxis from './OrientationAxis';
@@ -17,4 +18,4 @@ import MetadataModules from './MetadataModules';
 import { GenerateImageType } from './GenerateImageType';
 import VoxelManagerEnum from './VoxelManagerEnum';
 import RenderingEngineModeEnum from './RenderingEngineModeEnum';
-export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, GeometryType, ContourType, MeshType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, RenderingEngineModeEnum, };
+export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, ViewportTypes, OrientationAxis, GeometryType, ContourType, MeshType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, RenderingEngineModeEnum, };

package/dist/esm/getEnabledElement.js

@@ -1,4 +1,5 @@
 import getRenderingEngine, { getRenderingEngines, } from './RenderingEngine/getRenderingEngine';
+import { viewportHasFrameOfReferenceUID } from './RenderingEngine/GenericViewport/ViewportArchitectureTypes';
 export default function getEnabledElement(element) {
     if (!element) {
         return;
@@ -18,7 +19,9 @@ export function getEnabledElementByIds(viewportId, renderingEngineId) {
     if (!viewport) {
         return;
     }
-    const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+    const FrameOfReferenceUID = viewportHasFrameOfReferenceUID(viewport)
+        ? viewport.getFrameOfReferenceUID()
+        : undefined;
     return {
         viewport,
         renderingEngine,

package/dist/esm/index.d.ts

@@ -12,6 +12,18 @@ import StackViewport from './RenderingEngine/StackViewport';
 import VideoViewport from './RenderingEngine/VideoViewport';
 import WSIViewport from './RenderingEngine/WSIViewport';
 import ECGViewport from './RenderingEngine/ECGViewport';
+import { defaultRenderPathResolver, DefaultRenderPathResolver, viewportHasCanvasWorldTransform, viewportHasFrameOfReferenceUID, viewportHasPan, viewportHasZoom, GenericViewport, ViewportProjectionService, viewportProjection } from './RenderingEngine/GenericViewport';
+import ECGGenericViewport, { createDefaultECGRenderPaths, createECGRenderPathResolver, DefaultECGDataProvider, ecgProjection } from './RenderingEngine/GenericViewport/ECG';
+import VideoGenericViewport, { createDefaultVideoRenderPaths, createVideoRenderPathResolver, DefaultVideoDataProvider, videoProjection } from './RenderingEngine/GenericViewport/Video';
+import PlanarViewport, { createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, DefaultPlanarDataProvider, planarProjection } from './RenderingEngine/GenericViewport/Planar';
+import GenericVolumeViewport3D, { createDefaultVolume3DRenderPaths, createVolume3DRenderPathResolver, DefaultVolume3DDataProvider, volume3DProjection } from './RenderingEngine/GenericViewport/Volume3D';
+import WSIGenericViewport, { createDefaultWSIRenderPaths, createWSIRenderPathResolver, DefaultWSIDataProvider, wsiProjection } from './RenderingEngine/GenericViewport/WSI';
+export type { BuiltInViewportProjectionByKind, BuiltInViewportProjectionByType, BuiltInViewportProjectionKind, BuiltInViewportProjectionType, ProjectionPresentationForKind, ProjectionPresentationForViewport, ProjectionPresentationForViewportType, ProjectionPosition, ProjectionPresentation, ProjectionRequest, ProjectionScale, ProjectionSnapshotForKind, ProjectionSnapshotForViewport, ProjectionSnapshotForViewportType, ProjectionSnapshot, ProjectionSpaces, ProjectionTransforms, ProjectionViewStateForKind, ProjectionViewStateForViewport, ProjectionViewStateForViewportType, ProjectionWriteOptions, ViewportDataReference, ViewportProjectionAdapter, } from './RenderingEngine/GenericViewport';
+export type { ECGProjectionPresentation, ECGProjectionRequest, ECGProjectionSnapshot, ECGViewState, } from './RenderingEngine/GenericViewport/ECG';
+export type { VideoProjectionPresentation, VideoProjectionRequest, VideoProjectionSnapshot, VideoViewState, } from './RenderingEngine/GenericViewport/Video';
+export type { PlanarResolvedICamera, PlanarSliceBasis, PlanarDisplayArea, PlanarProjectionPresentation, PlanarProjectionRequest, PlanarProjectionSnapshot, PlanarViewPresentation, PlanarViewPresentationSelector, PlanarViewState, } from './RenderingEngine/GenericViewport/Planar';
+export type { WSIProjectionPresentation, WSIProjectionRequest, WSIProjectionSnapshot, WSIViewState, } from './RenderingEngine/GenericViewport/WSI';
+export type { Volume3DCamera, Volume3DProjectionPresentation, Volume3DProjectionRequest, Volume3DProjectionSnapshot, } from './RenderingEngine/GenericViewport/Volume3D';
 import Viewport from './RenderingEngine/Viewport';
 import eventTarget from './eventTarget';
 import { version } from './version';
@@ -22,7 +34,7 @@ import imageRetrievalPoolManager from './requestPool/imageRetrievalPoolManager';
 import imageLoadPoolManager from './requestPool/imageLoadPoolManager';
 import getEnabledElement, { getEnabledElementByIds, getEnabledElementByViewportId, getEnabledElements } from './getEnabledElement';
 import * as metaData from './metaData';
-import { init, getShouldUseCPURendering, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization } from './init';
+import { init, getShouldUseCPURendering, getUseGenericViewport, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization } from './init';
 import Settings from './Settings';
 import * as volumeLoader from './loaders/volumeLoader';
 import * as imageLoader from './loaders/imageLoader';
@@ -31,6 +43,7 @@ import ProgressiveRetrieveImages from './loaders/ProgressiveRetrieveImages';
 import { decimatedVolumeLoader } from './loaders/decimatedVolumeLoader';
 import type * as Types from './types';
 import type { IRetrieveConfiguration, IImagesLoader, RetrieveOptions, RetrieveStage, ImageLoadListener } from './types';
+import { ActorRenderMode } from './types';
 import * as utilities from './utilities';
 import { registerImageLoader } from './loaders/imageLoader';
 import triggerEvent from './utilities/triggerEvent';
@@ -39,6 +52,63 @@ import { cornerstoneStreamingImageVolumeLoader } from './loaders/cornerstoneStre
 import { cornerstoneStreamingDynamicImageVolumeLoader } from './loaders/cornerstoneStreamingDynamicImageVolumeLoader';
 import { cornerstoneMeshLoader } from './loaders/cornerstoneMeshLoader';
 import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, getProjectionScaleMatrix } from './RenderingEngine/helpers';
+import { registerViewportType, isRegisteredViewportType } from './RenderingEngine/helpers/viewportTypeToViewportClass';
+export type { ViewportType, ViewportTypeConstants, ViewportTypeRegistry, } from './types/ViewportTypeRegistry';
+export type { ViewportTypesMap } from './enums/ViewportTypes';
 export * from './loaders/decimatedVolumeLoader';
+declare const renderingEngineExportsV2: {
+    GenericViewport: typeof GenericViewport;
+    DefaultRenderPathResolver: typeof DefaultRenderPathResolver;
+    defaultRenderPathResolver: DefaultRenderPathResolver;
+    ECGGenericViewport: typeof ECGGenericViewport;
+    createDefaultECGRenderPaths: typeof createDefaultECGRenderPaths;
+    createECGRenderPathResolver: typeof createECGRenderPathResolver;
+    DefaultECGDataProvider: typeof DefaultECGDataProvider;
+    ecgProjection: {
+        adapter: import(".").ViewportProjectionAdapter<import(".").ECGViewState, Types.ViewPresentation, import(".").ECGProjectionSnapshot>;
+        getSnapshot: typeof import("./RenderingEngine/GenericViewport/ECG/ecgProjectionSnapshot").getECGProjectionSnapshot;
+    };
+    VideoGenericViewport: typeof VideoGenericViewport;
+    createDefaultVideoRenderPaths: typeof createDefaultVideoRenderPaths;
+    createVideoRenderPathResolver: typeof createVideoRenderPathResolver;
+    DefaultVideoDataProvider: typeof DefaultVideoDataProvider;
+    videoProjection: {
+        adapter: import(".").ViewportProjectionAdapter<import(".").VideoViewState, Types.ViewPresentation, import(".").VideoProjectionSnapshot>;
+        getSnapshot: typeof import("./RenderingEngine/GenericViewport/Video/videoProjectionSnapshot").getVideoProjectionSnapshot;
+    };
+    PlanarViewport: typeof PlanarViewport;
+    createDefaultPlanarRenderPaths: typeof createDefaultPlanarRenderPaths;
+    createPlanarRenderPathResolver: typeof createPlanarRenderPathResolver;
+    DefaultPlanarDataProvider: typeof DefaultPlanarDataProvider;
+    planarProjection: {
+        adapter: import(".").ViewportProjectionAdapter<import(".").PlanarViewState, import(".").PlanarViewPresentation, import(".").PlanarProjectionSnapshot>;
+        getSnapshot: typeof import("./RenderingEngine/GenericViewport/Planar/planarProjectionSnapshot").getPlanarProjectionSnapshot;
+        getZoom: typeof import("./RenderingEngine/GenericViewport/Planar/planarProjectionSnapshot").getPlanarProjectionZoom;
+        getScale: typeof import("./RenderingEngine/GenericViewport/Planar/planarProjectionSnapshot").getPlanarProjectionScale;
+        getPan: typeof import("./RenderingEngine/GenericViewport/Planar/planarProjectionSnapshot").getPlanarProjectionPan;
+        resolveICamera: typeof import("./RenderingEngine/GenericViewport/Planar/planarRenderCamera").resolvePlanarICamera;
+        derivePresentation: typeof import("./RenderingEngine/GenericViewport/Planar/planarRenderCamera").derivePlanarPresentation;
+        applyToRenderer: typeof import("./RenderingEngine/GenericViewport/Planar/planarRenderCamera").applyPlanarICameraToRenderer;
+        createImageSliceBasis: typeof import("./RenderingEngine/GenericViewport/Planar/planarSliceBasis").createPlanarImageSliceBasis;
+        createVolumeSliceBasis: typeof import("./RenderingEngine/GenericViewport/Planar/planarSliceBasis").createPlanarVolumeSliceBasis;
+    };
+    VolumeViewport3D: typeof GenericVolumeViewport3D;
+    createDefaultVolume3DRenderPaths: typeof createDefaultVolume3DRenderPaths;
+    createVolume3DRenderPathResolver: typeof createVolume3DRenderPathResolver;
+    DefaultVolume3DDataProvider: typeof DefaultVolume3DDataProvider;
+    volume3DProjection: {
+        adapter: import(".").ViewportProjectionAdapter<import(".").Volume3DCamera, import(".").Volume3DProjectionPresentation, import(".").Volume3DProjectionSnapshot>;
+        getSnapshot: typeof import("./RenderingEngine/GenericViewport/Volume3D/volume3DProjectionSnapshot").getVolume3DProjectionSnapshot;
+    };
+    WSIGenericViewport: typeof WSIGenericViewport;
+    createDefaultWSIRenderPaths: typeof createDefaultWSIRenderPaths;
+    createWSIRenderPathResolver: typeof createWSIRenderPathResolver;
+    DefaultWSIDataProvider: typeof DefaultWSIDataProvider;
+    wsiProjection: {
+        adapter: import(".").ViewportProjectionAdapter<import(".").WSIViewState, Types.ViewPresentation, import(".").WSIProjectionSnapshot>;
+        getSnapshot: typeof import("./RenderingEngine/GenericViewport/WSI/wsiProjectionSnapshot").getWSIProjectionSnapshot;
+    };
+};
+declare const LegacyVolumeViewport3D: typeof VolumeViewport3D;
 export type { Types, IRetrieveConfiguration, RetrieveOptions, RetrieveStage, ImageLoadListener, IImagesLoader, };
-export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, ECGViewport, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, convertColorArrayToRgbString, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, getProjectionScaleMatrix, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, decimatedVolumeLoader, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };
+export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, LegacyVolumeViewport3D, VolumeViewport3D, GenericVolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, ECGViewport, ECGGenericViewport, GenericViewport, ViewportProjectionService, viewportProjection, viewportHasCanvasWorldTransform, viewportHasFrameOfReferenceUID, viewportHasPan, viewportHasZoom, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, convertColorArrayToRgbString, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, DefaultRenderPathResolver, defaultRenderPathResolver, createDefaultECGRenderPaths, createECGRenderPathResolver, DefaultECGDataProvider, ecgProjection, VideoGenericViewport, createDefaultVideoRenderPaths, createVideoRenderPathResolver, DefaultVideoDataProvider, videoProjection, PlanarViewport, createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, DefaultPlanarDataProvider, planarProjection, createDefaultVolume3DRenderPaths, createVolume3DRenderPathResolver, DefaultVolume3DDataProvider, volume3DProjection, WSIGenericViewport, createDefaultWSIRenderPaths, createWSIRenderPathResolver, DefaultWSIDataProvider, wsiProjection, renderingEngineExportsV2, getProjectionScaleMatrix, registerViewportType, isRegisteredViewportType, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getUseGenericViewport, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, decimatedVolumeLoader, ActorRenderMode, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };

package/dist/esm/index.js

@@ -12,6 +12,12 @@ import StackViewport from './RenderingEngine/StackViewport';
 import VideoViewport from './RenderingEngine/VideoViewport';
 import WSIViewport from './RenderingEngine/WSIViewport';
 import ECGViewport from './RenderingEngine/ECGViewport';
+import { defaultRenderPathResolver, DefaultRenderPathResolver, viewportHasCanvasWorldTransform, viewportHasFrameOfReferenceUID, viewportHasPan, viewportHasZoom, GenericViewport, ViewportProjectionService, viewportProjection, } from './RenderingEngine/GenericViewport';
+import ECGGenericViewport, { createDefaultECGRenderPaths, createECGRenderPathResolver, DefaultECGDataProvider, ecgProjection, } from './RenderingEngine/GenericViewport/ECG';
+import VideoGenericViewport, { createDefaultVideoRenderPaths, createVideoRenderPathResolver, DefaultVideoDataProvider, videoProjection, } from './RenderingEngine/GenericViewport/Video';
+import PlanarViewport, { createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, DefaultPlanarDataProvider, planarProjection, } from './RenderingEngine/GenericViewport/Planar';
+import GenericVolumeViewport3D, { createDefaultVolume3DRenderPaths, createVolume3DRenderPathResolver, DefaultVolume3DDataProvider, volume3DProjection, } from './RenderingEngine/GenericViewport/Volume3D';
+import WSIGenericViewport, { createDefaultWSIRenderPaths, createWSIRenderPathResolver, DefaultWSIDataProvider, wsiProjection, } from './RenderingEngine/GenericViewport/WSI';
 import Viewport from './RenderingEngine/Viewport';
 import eventTarget from './eventTarget';
 import { version } from './version';
@@ -22,13 +28,14 @@ import imageRetrievalPoolManager from './requestPool/imageRetrievalPoolManager';
 import imageLoadPoolManager from './requestPool/imageLoadPoolManager';
 import getEnabledElement, { getEnabledElementByIds, getEnabledElementByViewportId, getEnabledElements, } from './getEnabledElement';
 import * as metaData from './metaData';
-import { init, getShouldUseCPURendering, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization, } from './init';
+import { init, getShouldUseCPURendering, getUseGenericViewport, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization, } from './init';
 import Settings from './Settings';
 import * as volumeLoader from './loaders/volumeLoader';
 import * as imageLoader from './loaders/imageLoader';
 import * as geometryLoader from './loaders/geometryLoader';
 import ProgressiveRetrieveImages from './loaders/ProgressiveRetrieveImages';
 import { decimatedVolumeLoader } from './loaders/decimatedVolumeLoader';
+import { ActorRenderMode } from './types';
 import * as utilities from './utilities';
 import { registerImageLoader } from './loaders/imageLoader';
 import triggerEvent from './utilities/triggerEvent';
@@ -37,5 +44,37 @@ import { cornerstoneStreamingImageVolumeLoader } from './loaders/cornerstoneStre
 import { cornerstoneStreamingDynamicImageVolumeLoader } from './loaders/cornerstoneStreamingDynamicImageVolumeLoader';
 import { cornerstoneMeshLoader } from './loaders/cornerstoneMeshLoader';
 import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, getProjectionScaleMatrix, } from './RenderingEngine/helpers';
+import { registerViewportType, isRegisteredViewportType, } from './RenderingEngine/helpers/viewportTypeToViewportClass';
 export * from './loaders/decimatedVolumeLoader';
-export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, ECGViewport, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, convertColorArrayToRgbString, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, getProjectionScaleMatrix, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, decimatedVolumeLoader, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };
+const renderingEngineExportsV2 = {
+    GenericViewport,
+    DefaultRenderPathResolver,
+    defaultRenderPathResolver,
+    ECGGenericViewport,
+    createDefaultECGRenderPaths,
+    createECGRenderPathResolver,
+    DefaultECGDataProvider,
+    ecgProjection,
+    VideoGenericViewport,
+    createDefaultVideoRenderPaths,
+    createVideoRenderPathResolver,
+    DefaultVideoDataProvider,
+    videoProjection,
+    PlanarViewport,
+    createDefaultPlanarRenderPaths,
+    createPlanarRenderPathResolver,
+    DefaultPlanarDataProvider,
+    planarProjection,
+    VolumeViewport3D: GenericVolumeViewport3D,
+    createDefaultVolume3DRenderPaths,
+    createVolume3DRenderPathResolver,
+    DefaultVolume3DDataProvider,
+    volume3DProjection,
+    WSIGenericViewport,
+    createDefaultWSIRenderPaths,
+    createWSIRenderPathResolver,
+    DefaultWSIDataProvider,
+    wsiProjection,
+};
+const LegacyVolumeViewport3D = VolumeViewport3D;
+export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, LegacyVolumeViewport3D, VolumeViewport3D, GenericVolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, ECGViewport, ECGGenericViewport, GenericViewport, ViewportProjectionService, viewportProjection, viewportHasCanvasWorldTransform, viewportHasFrameOfReferenceUID, viewportHasPan, viewportHasZoom, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, convertColorArrayToRgbString, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, DefaultRenderPathResolver, defaultRenderPathResolver, createDefaultECGRenderPaths, createECGRenderPathResolver, DefaultECGDataProvider, ecgProjection, VideoGenericViewport, createDefaultVideoRenderPaths, createVideoRenderPathResolver, DefaultVideoDataProvider, videoProjection, PlanarViewport, createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, DefaultPlanarDataProvider, planarProjection, createDefaultVolume3DRenderPaths, createVolume3DRenderPathResolver, DefaultVolume3DDataProvider, volume3DProjection, WSIGenericViewport, createDefaultWSIRenderPaths, createWSIRenderPathResolver, DefaultWSIDataProvider, wsiProjection, renderingEngineExportsV2, getProjectionScaleMatrix, registerViewportType, isRegisteredViewportType, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getUseGenericViewport, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, decimatedVolumeLoader, ActorRenderMode, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };

package/dist/esm/init.d.ts

@@ -7,10 +7,11 @@ declare function setPreferSizeOverAccuracy(status: boolean): void;
 declare function canRenderFloatTextures(): boolean;
 declare function resetUseCPURendering(): void;
 declare function getShouldUseCPURendering(): boolean;
+declare function getUseGenericViewport(): boolean;
 declare function isCornerstoneInitialized(): boolean;
 declare function resetInitialization(): void;
 declare function getConfiguration(): Cornerstone3DConfig;
 declare function setConfiguration(c: Cornerstone3DConfig): void;
 declare function getWebWorkerManager(): CentralizedWebWorkerManager;
 declare function peerImport(moduleId: string): Promise<any>;
-export { init, getShouldUseCPURendering, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization, getCanUseNorm16Texture, };
+export { init, getShouldUseCPURendering, getUseGenericViewport, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization, getCanUseNorm16Texture, };

package/dist/esm/init.js

@@ -14,6 +14,16 @@ const defaultConfig = {
         strictZSpacingForVolumeViewport: true,
         renderingEngineMode: RenderingEngineModeEnum.ContextPool,
         webGlContextCount: 7,
+        planar: {
+            cpuThresholds: {
+                image: 64 * 1024 * 1024,
+                volume: 64 * 1024 * 1024,
+            },
+            cpuVolume: {
+                useViewportSamplingForLinear: true,
+                volumeModifiedThrottleMs: 5000,
+            },
+        },
         volumeRendering: {
             sampleDistanceMultiplier: 1,
         },
@@ -113,6 +123,9 @@ function resetUseCPURendering() {
 function getShouldUseCPURendering() {
     return config.rendering.useCPURendering;
 }
+function getUseGenericViewport() {
+    return config.rendering.useGenericViewport === true;
+}
 function isCornerstoneInitialized() {
     return csRenderInitialized;
 }
@@ -142,4 +155,4 @@ function getWebWorkerManager() {
 async function peerImport(moduleId) {
     return config.peerImport(moduleId);
 }
-export { init, getShouldUseCPURendering, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization, getCanUseNorm16Texture, };
+export { init, getShouldUseCPURendering, getUseGenericViewport, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization, getCanUseNorm16Texture, };

package/dist/esm/loaders/ProgressiveRetrieveImages.js

@@ -12,16 +12,6 @@ import eventTarget from '../eventTarget';
 import { fillNearbyFrames } from './fillNearbyFrames';
 export { sequentialRetrieveStages, interleavedRetrieveStages, singleRetrieveStages, };
 export class ProgressiveRetrieveImages {
-    static { this.createProgressive = createProgressive; }
-    static { this.interleavedRetrieveStages = {
-        stages: interleavedRetrieveStages,
-    }; }
-    static { this.singleRetrieveStages = {
-        stages: singleRetrieveStages,
-    }; }
-    static { this.sequentialRetrieveStages = {
-        stages: sequentialRetrieveStages,
-    }; }
     constructor(imageRetrieveConfiguration) {
         this.stages = imageRetrieveConfiguration.stages || singleRetrieveStages;
         this.retrieveOptions = imageRetrieveConfiguration.retrieveOptions || {};
@@ -31,6 +21,16 @@ export class ProgressiveRetrieveImages {
         return instance.loadImages();
     }
 }
+ProgressiveRetrieveImages.createProgressive = createProgressive;
+ProgressiveRetrieveImages.interleavedRetrieveStages = {
+    stages: interleavedRetrieveStages,
+};
+ProgressiveRetrieveImages.singleRetrieveStages = {
+    stages: singleRetrieveStages,
+};
+ProgressiveRetrieveImages.sequentialRetrieveStages = {
+    stages: sequentialRetrieveStages,
+};
 class ProgressiveRetrieveImagesInstance {
     constructor(configuration, imageIds, listener) {
         this.outstandingRequests = 0;
@@ -85,7 +85,7 @@ class ProgressiveRetrieveImagesInstance {
         }, errorCallback)
             .finally(() => {
             if (!complete && next) {
-                cache.setPartialImage(imageId);
+                cache.setPartialImage(imageId, undefined, true);
                 this.addRequest(next, options.streamingData);
             }
             else {