@cornerstonejs/core 4.0.0-beta.2 → 4.0.0-beta.4

package/dist/esm/enums/index.js

@@ -16,4 +16,5 @@ import * as VideoEnums from './VideoEnums';
 import MetadataModules from './MetadataModules';
 import { GenerateImageType } from './GenerateImageType';
 import VoxelManagerEnum from './VoxelManagerEnum';
-export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, GeometryType, ContourType, MeshType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, };
+import RenderingEngineModeEnum from './RenderingEngineModeEnum';
+export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, GeometryType, ContourType, MeshType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, RenderingEngineModeEnum, };

package/dist/esm/index.d.ts

@@ -1,7 +1,7 @@
 import * as Enums from './enums';
 import * as CONSTANTS from './constants';
 import { Events } from './enums';
-import RenderingEngine from './RenderingEngine';
+import RenderingEngine, { BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine } from './RenderingEngine';
 import createVolumeActor from './RenderingEngine/helpers/createVolumeActor';
 import createVolumeMapper, { convertMapperToNotSharedMapper } from './RenderingEngine/helpers/createVolumeMapper';
 export * from './RenderingEngine/helpers/getOrCreateCanvas';
@@ -37,4 +37,4 @@ import { cornerstoneStreamingDynamicImageVolumeLoader } from './loaders/cornerst
 import { cornerstoneMeshLoader } from './loaders/cornerstoneMeshLoader';
 import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports } from './RenderingEngine/helpers';
 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, RenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };
+export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };

package/dist/esm/index.js

@@ -1,7 +1,7 @@
 import * as Enums from './enums';
 import * as CONSTANTS from './constants';
 import { Events } from './enums';
-import RenderingEngine from './RenderingEngine';
+import RenderingEngine, { BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, } from './RenderingEngine';
 import createVolumeActor from './RenderingEngine/helpers/createVolumeActor';
 import createVolumeMapper, { convertMapperToNotSharedMapper, } from './RenderingEngine/helpers/createVolumeMapper';
 export * from './RenderingEngine/helpers/getOrCreateCanvas';
@@ -34,4 +34,4 @@ import { cornerstoneStreamingImageVolumeLoader } from './loaders/cornerstoneStre
 import { cornerstoneStreamingDynamicImageVolumeLoader } from './loaders/cornerstoneStreamingDynamicImageVolumeLoader';
 import { cornerstoneMeshLoader } from './loaders/cornerstoneMeshLoader';
 import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, } from './RenderingEngine/helpers';
-export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };
+export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };

package/dist/esm/init.js

@@ -3,6 +3,7 @@ let csRenderInitialized = false;
 import deepMerge from './utilities/deepMerge';
 import CentralizedWebWorkerManager from './webWorkerManager/webWorkerManager';
 import { getSupportedTextureFormats } from './utilities/textureSupport';
+import { RenderingEngineModeEnum } from './enums';
 const defaultConfig = {
     gpuTier: { tier: 2 },
     isMobile: false,
@@ -10,6 +11,14 @@ const defaultConfig = {
         useCPURendering: false,
         preferSizeOverAccuracy: false,
         strictZSpacingForVolumeViewport: true,
+        renderingEngineMode: RenderingEngineModeEnum.ContextPool,
+        webGlContextCount: 7,
+        volumeRendering: {
+            sampleDistanceMultiplier: 1,
+        },
+    },
+    debug: {
+        statsOverlay: false,
     },
     peerImport: (moduleId) => null,
 };
@@ -50,6 +59,9 @@ function init(configuration = config) {
     }
     canUseNorm16Texture = _hasNorm16TextureSupport();
     config = deepMerge(defaultConfig, configuration);
+    if (config.isMobile) {
+        config.rendering.webGlContextCount = 1;
+    }
     if (isIOS()) {
         if (configuration.rendering?.preferSizeOverAccuracy) {
             config.rendering.preferSizeOverAccuracy = true;

package/dist/esm/loaders/volumeLoader.js

@@ -72,7 +72,7 @@ export function createAndCacheDerivedVolume(referencedVolumeId, options) {
     const { metadata, dimensions, spacing, origin, direction } = referencedVolume;
     const referencedImageIds = referencedVolume.isDynamicVolume()
         ? referencedVolume.getCurrentDimensionGroupImageIds()
-        : referencedVolume.imageIds ?? [];
+        : (referencedVolume.imageIds ?? []);
     const derivedImages = createAndCacheDerivedImages(referencedImageIds, {
         targetBuffer: options.targetBuffer,
         voxelRepresentation,
@@ -150,7 +150,7 @@ export function createLocalVolume(volumeId, options = {}) {
     const sliceLength = dimensions[0] * dimensions[1];
     const dataType = scalarData
         ? scalarData.constructor.name
-        : targetBuffer?.type ?? 'Float32Array';
+        : (targetBuffer?.type ?? 'Float32Array');
     const totalNumberOfVoxels = sliceLength * dimensions[2];
     let byteLength;
     switch (dataType) {

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

@@ -1,12 +1,21 @@
+import type { RenderingEngineModeType } from '../types';
 interface Cornerstone3DConfig {
-    gpuTier: {
-        tier: number;
+    gpuTier?: {
+        tier?: number;
     };
-    isMobile: boolean;
-    rendering: {
-        preferSizeOverAccuracy: boolean;
-        useCPURendering: boolean;
-        strictZSpacingForVolumeViewport: boolean;
+    isMobile?: boolean;
+    rendering?: {
+        preferSizeOverAccuracy?: boolean;
+        useCPURendering?: boolean;
+        strictZSpacingForVolumeViewport?: boolean;
+        renderingEngineMode?: RenderingEngineModeType;
+        webGlContextCount?: number;
+        volumeRendering?: {
+            sampleDistanceMultiplier?: number;
+        };
+    };
+    debug: {
+        statsOverlay?: boolean;
     };
     peerImport?: (moduleId: string) => Promise<any>;
 }

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

@@ -1,3 +1,3 @@
-import type RenderingEngine from '../RenderingEngine/RenderingEngine';
+import type { RenderingEngine } from '../RenderingEngine';
 type IRenderingEngine = RenderingEngine;
 export type { IRenderingEngine as default };

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

@@ -24,8 +24,15 @@ export interface ReferenceCompatibleOptions {
 export type ReferencedImageRange = ViewReference & {
     referencedImageId: string;
 };
-export type ViewReference = {
+export type PlaneRestriction = {
+    FrameOfReferenceUID: string;
+    point: Point3;
+    inPlaneVector1?: Point3;
+    inPlaneVector2?: Point3;
+};
+export interface ViewReference {
     FrameOfReferenceUID?: string;
+    planeRestriction?: PlaneRestriction;
     referencedImageId?: string;
     referencedImageURI?: string;
     multiSliceReference?: ReferencedImageRange;
@@ -35,7 +42,7 @@ export type ViewReference = {
     sliceIndex?: number;
     volumeId?: string;
     bounds?: BoundsLPS;
-};
+}
 export interface ViewPresentation {
     slabThickness?: number;
     rotation?: number;

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

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

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

@@ -0,0 +1,2 @@
+type RenderingEngineModeType = 'tiled' | 'contextPool';
+export type { RenderingEngineModeType };

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

@@ -8,4 +8,5 @@ export interface ViewportProperties {
     colormap?: ColormapPublic;
     interpolationType?: InterpolationType;
     preset?: string;
+    sampleDistanceMultiplier?: number;
 }

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

@@ -0,0 +1,37 @@
+import type { vtkObject } from '@kitware/vtk.js/interfaces';
+import type vtkStreamingOpenGLRenderWindow from '../RenderingEngine/vtkClasses/vtkStreamingOpenGLRenderWindow';
+import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
+import type vtkRenderWindow from '@kitware/vtk.js/Rendering/Core/RenderWindow';
+import type vtkRenderWindowInteractor from '@kitware/vtk.js/Rendering/Core/RenderWindowInteractor';
+import '@kitware/vtk.js/Common/Core/Points';
+import '@kitware/vtk.js/Common/Core/DataArray';
+import '@kitware/vtk.js/Common/DataModel/PolyData';
+import '@kitware/vtk.js/Rendering/Core/Actor';
+import '@kitware/vtk.js/Rendering/Core/Mapper';
+type Viewport = [number, number, number, number];
+interface RendererConfig {
+    id: string;
+    viewport: Viewport;
+    background?: [number, number, number];
+}
+export interface VtkOffscreenMultiRenderWindow extends vtkObject {
+    renderWindow: vtkRenderWindow;
+    getRenderWindow: () => vtkRenderWindow;
+    openGLRenderWindow: ReturnType<typeof vtkStreamingOpenGLRenderWindow.newInstance>;
+    getOpenGLRenderWindow: () => ReturnType<typeof vtkStreamingOpenGLRenderWindow.newInstance>;
+    interactor: vtkRenderWindowInteractor;
+    getInteractor: () => vtkRenderWindowInteractor;
+    container: HTMLDivElement | null;
+    getContainer: () => HTMLDivElement | null;
+    addRenderer: (config: RendererConfig) => void;
+    removeRenderer: (id: string) => void;
+    getRenderer: (id: string) => vtkRenderer;
+    getRenderers: () => Array<{
+        id: string;
+        renderer: vtkRenderer;
+    }>;
+    resize: () => void;
+    setContainer: (el: HTMLDivElement) => void;
+    destroy: () => void;
+}
+export {};

package/dist/esm/types/VtkOffscreenMultiRenderWindow.js

@@ -0,0 +1,5 @@
+import '@kitware/vtk.js/Common/Core/Points';
+import '@kitware/vtk.js/Common/Core/DataArray';
+import '@kitware/vtk.js/Common/DataModel/PolyData';
+import '@kitware/vtk.js/Rendering/Core/Actor';
+import '@kitware/vtk.js/Rendering/Core/Mapper';

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

@@ -101,4 +101,6 @@ import type { IBaseVolumeViewport } from './IBaseVolumeViewport';
 import type ScrollOptions from './ScrollOptions';
 import type JumpToSliceOptions from './JumpToSliceOptions';
 import type GeometryLoaderFn from './GeometryLoaderFn';
-export type { Cornerstone3DConfig, ICamera, IStackViewport, IVideoViewport, IWSIViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, IViewportId, IImageVolume, ImageVolumeProps, IDynamicImageVolume, IRenderingEngine, ScalingParameters, PTScaling, IPointsManager, PolyDataPointConfiguration, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, ViewReference, DataSetOptions as ImageSetOptions, ViewPresentation, ViewPresentationSelector, ReferenceCompatibleOptions, ViewReferenceSpecifier, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, ImageActor, ICanvasActor, IImageLoadObject, IVolumeLoadObject, IVolumeInput, VolumeInputCallback, IStackInput, StackInputCallback, ViewportPreset, Metadata, OrientationVectors, AABB2, AABB3, Point2, Point3, PointsXYZ, Point4, Mat3, Plane, ViewportInputOptions, VideoViewportProperties, WSIViewportProperties, VOIRange, VOI, DisplayArea, FlipDirection, ICachedImage, ICachedVolume, CPUFallbackEnabledElement, CPUFallbackViewport, CPUFallbackTransform, CPUFallbackColormapData, CPUFallbackViewportDisplayedArea, CPUFallbackColormapsData, CPUFallbackColormap, TransformMatrix2D, CPUFallbackLookupTable, CPUFallbackLUT, CPUFallbackRenderingTools, CustomEventType, ActorSliceRange, ImageSliceData, IGeometry, IGeometryLoadObject, ICachedGeometry, PublicContourSetData, ContourSetData, ContourData, IContourSet, IContour, PublicSurfaceData, SurfaceData, ISurface, PublicMeshData, MeshData, IMesh, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, PixelDataTypedArrayString, ImagePixelModule, ImagePlaneModule, AffineMatrix, ImageLoadListener, InternalVideoCamera, VideoViewportInput, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, IImageFrame, DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, ImagePlaneModuleMetadata, SopCommonModuleMetadata, ImagePixelModuleMetadata, PatientStudyModuleMetadata, TransferSyntaxMetadata, LocalVolumeOptions, IVoxelManager, IRLEVoxelMap, RLERun, ViewportInput, ImageLoadRequests, IBaseVolumeViewport, GeometryLoaderFn, ScrollOptions, JumpToSliceOptions, Memo, HistoryMemo, VoxelManager, RLEVoxelMap, };
+import type { RenderingEngineModeType } from './RenderingEngineMode';
+import type { VtkOffscreenMultiRenderWindow } from './VtkOffscreenMultiRenderWindow';
+export type { Cornerstone3DConfig, ICamera, IStackViewport, IVideoViewport, IWSIViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, IViewportId, IImageVolume, ImageVolumeProps, IDynamicImageVolume, IRenderingEngine, ScalingParameters, PTScaling, IPointsManager, PolyDataPointConfiguration, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, ViewReference, DataSetOptions as ImageSetOptions, ViewPresentation, ViewPresentationSelector, ReferenceCompatibleOptions, ViewReferenceSpecifier, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, ImageActor, ICanvasActor, IImageLoadObject, IVolumeLoadObject, IVolumeInput, VolumeInputCallback, IStackInput, StackInputCallback, ViewportPreset, Metadata, OrientationVectors, AABB2, AABB3, Point2, Point3, PointsXYZ, Point4, Mat3, Plane, ViewportInputOptions, VideoViewportProperties, WSIViewportProperties, VOIRange, VOI, DisplayArea, FlipDirection, ICachedImage, ICachedVolume, CPUFallbackEnabledElement, CPUFallbackViewport, CPUFallbackTransform, CPUFallbackColormapData, CPUFallbackViewportDisplayedArea, CPUFallbackColormapsData, CPUFallbackColormap, TransformMatrix2D, CPUFallbackLookupTable, CPUFallbackLUT, CPUFallbackRenderingTools, CustomEventType, ActorSliceRange, ImageSliceData, IGeometry, IGeometryLoadObject, ICachedGeometry, PublicContourSetData, ContourSetData, ContourData, IContourSet, IContour, PublicSurfaceData, SurfaceData, ISurface, PublicMeshData, MeshData, IMesh, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, PixelDataTypedArrayString, ImagePixelModule, ImagePlaneModule, AffineMatrix, ImageLoadListener, InternalVideoCamera, VideoViewportInput, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, IImageFrame, DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, ImagePlaneModuleMetadata, SopCommonModuleMetadata, ImagePixelModuleMetadata, PatientStudyModuleMetadata, TransferSyntaxMetadata, LocalVolumeOptions, IVoxelManager, IRLEVoxelMap, RLERun, ViewportInput, ImageLoadRequests, IBaseVolumeViewport, GeometryLoaderFn, ScrollOptions, JumpToSliceOptions, Memo, HistoryMemo, VoxelManager, RLEVoxelMap, RenderingEngineModeType, VtkOffscreenMultiRenderWindow, };

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

@@ -0,0 +1 @@
+export declare function asArray<T>(item: T | T[]): T[];

package/dist/esm/utilities/asArray.js

@@ -0,0 +1,6 @@
+export function asArray(item) {
+    if (Array.isArray(item)) {
+        return item;
+    }
+    return [item];
+}

package/dist/esm/utilities/colormap.js

@@ -51,10 +51,12 @@ function findMatchingColormap(rgbPoints, actor) {
             });
         }
     }
-    return {
+    const result = {
         name: matchedColormap.Name,
-        opacity,
+        ...(Array.isArray(opacity) && opacity.length > 0 && { opacity }),
+        ...(typeof opacity === 'number' && { opacity }),
     };
+    return result;
 }
 export function setColorMapTransferFunctionForVolumeActor(volumeInfo) {
     const { volumeActor, preset, opacity = 0.9, threshold = null, colorRange = [0, 5], } = volumeInfo;

package/dist/esm/utilities/getPixelSpacingInformation.js

@@ -72,7 +72,10 @@ function calculateUSPixelSpacing(instance) {
     const { PhysicalDeltaX, PhysicalDeltaY } = isArrayOfSequences
         ? SequenceOfUltrasoundRegions[0]
         : SequenceOfUltrasoundRegions;
-    const USPixelSpacing = [PhysicalDeltaX * 10, PhysicalDeltaY * 10];
+    const USPixelSpacing = [
+        Math.abs(PhysicalDeltaX) * 10,
+        Math.abs(PhysicalDeltaY) * 10,
+    ];
     return {
         PixelSpacing: USPixelSpacing,
     };

package/dist/esm/utilities/historyMemo/index.d.ts

@@ -14,12 +14,21 @@ export declare class HistoryMemo {
     private redoAvailable;
     private undoAvailable;
     private ring;
+    private isRecordingGrouped;
     constructor(label?: string, size?: number);
     get size(): number;
     set size(newSize: number);
+    get canUndo(): boolean;
+    get canRedo(): boolean;
     undo(items?: number): void;
-    undoIf(condition: (item: Memo) => boolean): boolean;
+    undoIf(condition: (item: Memo | Memo[]) => boolean): boolean;
+    private dispatchHistoryEvent;
     redo(items?: number): void;
+    private initializeGroupItem;
+    startGroupRecording(): void;
+    private rollbackUnusedGroupItem;
+    endGroupRecording(): void;
+    private pushGrouped;
     push(item: Memo | Memoable): Memo;
 }
 declare const DefaultHistoryMemo: HistoryMemo;

package/dist/esm/utilities/historyMemo/index.js

@@ -1,4 +1,5 @@
 import eventTarget from '../../eventTarget';
+import { asArray } from '../asArray';
 const Events = {
     HISTORY_UNDO: 'CORNERSTONE_TOOLS_HISTORY_UNDO',
     HISTORY_REDO: 'CORNERSTONE_TOOLS_HISTORY_REDO',
@@ -9,6 +10,7 @@ export class HistoryMemo {
         this.redoAvailable = 0;
         this.undoAvailable = 0;
         this.ring = new Array();
+        this.isRecordingGrouped = false;
         this.label = label;
         this._size = size;
     }
@@ -22,19 +24,18 @@ export class HistoryMemo {
         this.redoAvailable = 0;
         this.undoAvailable = 0;
     }
+    get canUndo() {
+        return this.undoAvailable > 0;
+    }
+    get canRedo() {
+        return this.redoAvailable > 0;
+    }
     undo(items = 1) {
         while (items > 0 && this.undoAvailable > 0) {
             const item = this.ring[this.position];
-            item.restoreMemo(true);
-            if (item.id) {
-                eventTarget.dispatchEvent(new CustomEvent(Events.HISTORY_UNDO, {
-                    detail: {
-                        isUndo: true,
-                        id: item.id,
-                        operationType: item.operationType || 'annotation',
-                        memo: item,
-                    },
-                }));
+            for (const subitem of asArray(item).reverse()) {
+                subitem.restoreMemo(true);
+                this.dispatchHistoryEvent({ item: subitem, isUndo: true });
             }
             items--;
             this.redoAvailable++;
@@ -49,20 +50,25 @@ export class HistoryMemo {
         }
         return false;
     }
+    dispatchHistoryEvent({ item, isUndo }) {
+        if (item.id) {
+            eventTarget.dispatchEvent(new CustomEvent(isUndo ? Events.HISTORY_UNDO : Events.HISTORY_REDO, {
+                detail: {
+                    isUndo,
+                    id: item.id,
+                    operationType: item.operationType || 'annotation',
+                    memo: item,
+                },
+            }));
+        }
+    }
     redo(items = 1) {
         while (items > 0 && this.redoAvailable > 0) {
             const newPosition = (this.position + 1) % this.size;
             const item = this.ring[newPosition];
-            item.restoreMemo(false);
-            if (item.id) {
-                eventTarget.dispatchEvent(new CustomEvent(Events.HISTORY_REDO, {
-                    detail: {
-                        isUndo: false,
-                        id: item.id,
-                        operationType: item.operationType || 'annotation',
-                        memo: item,
-                    },
-                }));
+            for (const subitem of asArray(item).reverse()) {
+                subitem.restoreMemo(false);
+                this.dispatchHistoryEvent({ item: subitem, isUndo: false });
             }
             items--;
             this.position = newPosition;
@@ -70,6 +76,39 @@ export class HistoryMemo {
             this.redoAvailable--;
         }
     }
+    initializeGroupItem() {
+        this.redoAvailable = 0;
+        if (this.undoAvailable < this._size) {
+            this.undoAvailable++;
+        }
+        this.position = (this.position + 1) % this._size;
+        this.ring[this.position] = [];
+    }
+    startGroupRecording() {
+        this.isRecordingGrouped = true;
+        this.initializeGroupItem();
+    }
+    rollbackUnusedGroupItem() {
+        this.ring[this.position] = undefined;
+        this.position = (this.position - 1) % this._size;
+        this.undoAvailable--;
+    }
+    endGroupRecording() {
+        this.isRecordingGrouped = false;
+        const lastItem = this.ring[this.position];
+        const lastItemIsEmpty = Array.isArray(lastItem) && lastItem.length === 0;
+        if (lastItemIsEmpty) {
+            this.rollbackUnusedGroupItem();
+        }
+    }
+    pushGrouped(memo) {
+        const lastMemo = this.ring[this.position];
+        if (Array.isArray(lastMemo)) {
+            lastMemo.push(memo);
+            return memo;
+        }
+        throw new Error('Last item should be an array for grouped memos.');
+    }
     push(item) {
         if (!item) {
             return;
@@ -80,6 +119,9 @@ export class HistoryMemo {
         if (!memo) {
             return;
         }
+        if (this.isRecordingGrouped) {
+            return this.pushGrouped(memo);
+        }
         this.redoAvailable = 0;
         if (this.undoAvailable < this._size) {
             this.undoAvailable++;

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

@@ -93,6 +93,8 @@ import calculateSpacingBetweenImageIds from './calculateSpacingBetweenImageIds';
 export * as logger from './logger';
 import { calculateNeighborhoodStats } from './calculateNeighborhoodStats';
 import getPixelSpacingInformation from './getPixelSpacingInformation';
+import { asArray } from './asArray';
+export { updatePlaneRestriction } from './updatePlaneRestriction';
 declare const getViewportModality: (viewport: IViewport, volumeId?: string) => string;
 export * from './isEqual';
-export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, getRuntimeId, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, getPixelSpacingInformation, };
+export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, getRuntimeId, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, getPixelSpacingInformation, asArray, };

package/dist/esm/utilities/index.js

@@ -94,6 +94,8 @@ import calculateSpacingBetweenImageIds from './calculateSpacingBetweenImageIds';
 export * as logger from './logger';
 import { calculateNeighborhoodStats } from './calculateNeighborhoodStats';
 import getPixelSpacingInformation from './getPixelSpacingInformation';
+import { asArray } from './asArray';
+export { updatePlaneRestriction } from './updatePlaneRestriction';
 const getViewportModality = (viewport, volumeId) => _getViewportModality(viewport, volumeId, cache.getVolume);
 export * from './isEqual';
-export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, getRuntimeId, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, getPixelSpacingInformation, };
+export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, getRuntimeId, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, getPixelSpacingInformation, asArray, };

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

@@ -1,5 +1,5 @@
-export default function isEqual<ValueType>(v1: ValueType, v2: ValueType, tolerance?: number): boolean;
-declare const isEqualNegative: <ValueType>(v1: ValueType, v2: ValueType, tolerance?: any) => boolean;
-declare const isEqualAbs: <ValueType>(v1: ValueType, v2: ValueType, tolerance?: any) => boolean;
-declare function isNumber(n: number[] | number): boolean;
-export { isEqualNegative, isEqual, isEqualAbs, isNumber };
+export declare function isEqual<ValueType>(v1: ValueType, v2: ValueType, tolerance?: number): boolean;
+export declare const isEqualNegative: <ValueType>(v1: ValueType, v2: ValueType, tolerance?: any) => boolean;
+export declare const isEqualAbs: <ValueType>(v1: ValueType, v2: ValueType, tolerance?: any) => boolean;
+export declare function isNumber(n: number[] | number): boolean;
+export default isEqual;

package/dist/esm/utilities/isEqual.js

@@ -23,7 +23,7 @@ function isNumberArrayLike(value) {
         value.length > 0 &&
         typeof value[0] === 'number');
 }
-export default function isEqual(v1, v2, tolerance = 1e-5) {
+export function isEqual(v1, v2, tolerance = 1e-5) {
     if (typeof v1 !== typeof v2 || v1 === null || v2 === null) {
         return false;
     }
@@ -37,12 +37,12 @@ export default function isEqual(v1, v2, tolerance = 1e-5) {
 }
 const negative = (v) => typeof v === 'number' ? -v : v?.map ? v.map(negative) : !v;
 const abs = (v) => typeof v === 'number' ? Math.abs(v) : v?.map ? v.map(abs) : v;
-const isEqualNegative = (v1, v2, tolerance = undefined) => isEqual(v1, negative(v2), tolerance);
-const isEqualAbs = (v1, v2, tolerance = undefined) => isEqual(abs(v1), abs(v2), tolerance);
-function isNumber(n) {
+export const isEqualNegative = (v1, v2, tolerance = undefined) => isEqual(v1, negative(v2), tolerance);
+export const isEqualAbs = (v1, v2, tolerance = undefined) => isEqual(abs(v1), abs(v2), tolerance);
+export function isNumber(n) {
     if (Array.isArray(n)) {
         return isNumber(n[0]);
     }
     return isFinite(n) && !isNaN(n);
 }
-export { isEqualNegative, isEqual, isEqualAbs, isNumber };
+export default isEqual;

package/dist/esm/utilities/renderToCanvasGPU.js

@@ -2,7 +2,7 @@ import { vec3 } from 'gl-matrix';
 import getOrCreateCanvas, { EPSILON, } from '../RenderingEngine/helpers/getOrCreateCanvas';
 import { ViewportType, Events } from '../enums';
 import { getRenderingEngine } from '../RenderingEngine/getRenderingEngine';
-import RenderingEngine from '../RenderingEngine';
+import TiledRenderingEngine from '../RenderingEngine/TiledRenderingEngine';
 import isPTPrescaledWithSUV from './isPTPrescaledWithSUV';
 export default function renderToCanvasGPU(canvas, imageOrVolume, modality = undefined, renderingEngineId = '_thumbnails', viewportOptions = {
     displayArea: { imageArea: [1, 1] },
@@ -31,7 +31,7 @@ export default function renderToCanvasGPU(canvas, imageOrVolume, modality = unde
     element.setAttribute('viewport-id-for-remove', uniqueId);
     const temporaryCanvas = getOrCreateCanvas(element);
     const renderingEngine = getRenderingEngine(renderingEngineId) ||
-        new RenderingEngine(renderingEngineId);
+        new TiledRenderingEngine(renderingEngineId);
     let viewport = renderingEngine.getViewport(viewportId);
     if (!viewport) {
         const viewportInput = {

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

@@ -0,0 +1,2 @@
+import type { Point3, ViewReference } from '../types';
+export declare function updatePlaneRestriction(points: Point3[], reference: ViewReference): import("../types/IViewport").PlaneRestriction;

package/dist/esm/utilities/updatePlaneRestriction.js

@@ -0,0 +1,41 @@
+import { isEqual } from '../utilities/isEqual';
+import { vec3 } from 'gl-matrix';
+const ORTHOGONAL_TEST_VALUE = 0.95;
+export function updatePlaneRestriction(points, reference) {
+    if (!points?.length || !reference.FrameOfReferenceUID) {
+        return;
+    }
+    reference.planeRestriction ||= {
+        FrameOfReferenceUID: reference.FrameOfReferenceUID,
+        point: points[0],
+        inPlaneVector1: null,
+        inPlaneVector2: null,
+    };
+    const { planeRestriction } = reference;
+    if (points.length === 1) {
+        planeRestriction.inPlaneVector1 = null;
+        planeRestriction.inPlaneVector2 = null;
+        return planeRestriction;
+    }
+    const v1 = vec3.sub(vec3.create(), points[0], points[Math.floor(points.length / 2)]);
+    vec3.normalize(v1, v1);
+    planeRestriction.inPlaneVector1 = v1;
+    planeRestriction.inPlaneVector2 = null;
+    const n = points.length;
+    if (n > 2) {
+        for (let i = Math.floor(n / 3); i < n; i++) {
+            const testVector = vec3.sub(vec3.create(), points[i], points[0]);
+            const length = vec3.length(testVector);
+            if (isEqual(length, 0)) {
+                continue;
+            }
+            if (vec3.dot(testVector, planeRestriction.inPlaneVector1) <
+                length * ORTHOGONAL_TEST_VALUE) {
+                vec3.normalize(testVector, testVector);
+                planeRestriction.inPlaneVector2 = testVector;
+                return planeRestriction;
+            }
+        }
+    }
+    return planeRestriction;
+}

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "3.26.2";
+export declare const version = "4.0.0-beta.4";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '3.26.2';
+export const version = '4.0.0-beta.4';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "4.0.0-beta.2",
+  "version": "4.0.0-beta.4",
   "description": "Cornerstone3D Core",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -76,8 +76,8 @@
     "build": "yarn run build:esm",
     "build:all": "yarn run build:esm",
     "dev": "tsc --project ./tsconfig.json --watch",
-    "format-check": "npx eslint ./src --quiet",
     "api-check": "api-extractor --debug run ",
+    "lint": "oxlint .",
     "prepublishOnly": "yarn run build"
   },
   "dependencies": {
@@ -96,5 +96,6 @@
   "funding": {
     "type": "individual",
     "url": "https://ohif.org/donate"
-  }
+  },
+  "gitHead": "bd2215216a08cc0c953c6523b16892b3aee6f9be"
 }