@cornerstonejs/core 2.0.0-beta.23 → 2.0.0-beta.24

package/dist/esm/RenderingEngine/BaseVolumeViewport.d.ts

@@ -1,11 +1,11 @@
 import type { mat4 } from 'gl-matrix';
 import type { BlendModes, InterpolationType, OrientationAxis } from '../enums';
-import type { FlipDirection, IImageData, IVolumeInput, OrientationVectors, Point2, Point3, VolumeViewportProperties, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewReference, IVolumeViewport } from '../types';
+import type { FlipDirection, IImageData, IVolumeInput, OrientationVectors, Point2, Point3, VolumeViewportProperties, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewReference, IBaseVolumeViewport } from '../types';
 import type { VoiModifiedEventDetail } from '../types/EventTypes';
 import type { ViewportInput } from '../types/IViewport';
 import type { TransferFunctionNodes } from '../types/ITransferFunctionNode';
 import Viewport from './Viewport';
-declare abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
+declare abstract class BaseVolumeViewport extends Viewport implements IBaseVolumeViewport {
     useCPURendering: boolean;
     private _FrameOfReferenceUID;
     protected initialTransferFunctionNodes: TransferFunctionNodes;

package/dist/esm/RenderingEngine/BaseVolumeViewport.js

@@ -419,6 +419,7 @@ class BaseVolumeViewport extends Viewport {
         const volumeIdToUse = applicableVolumeActorInfo.volumeId;
         let voiRangeToUse = voiRange;
         if (typeof voiRangeToUse === 'undefined') {
+            throw new Error('voiRangeToUse is undefined, need to implement this in the new volume model');
             const imageData = volumeActor.getMapper().getInputData();
             const range = imageData.getPointData().getScalars().getRange();
             const maxVoiRange = { lower: range[0], upper: range[1] };

package/dist/esm/RenderingEngine/StackViewport.js

@@ -1663,9 +1663,10 @@ class StackViewport extends Viewport {
             return options.asVolume;
         }
         let testIndex = this.getCurrentImageIdIndex();
-        const currentImageId = this.imageIds[testIndex];
+        let currentImageId = this.imageIds[testIndex];
         if (options.withNavigation && typeof sliceIndex === 'number') {
             testIndex = sliceIndex;
+            currentImageId = this.imageIds[testIndex];
         }
         if (!currentImageId) {
             return false;
@@ -1822,17 +1823,17 @@ class StackViewport extends Viewport {
     }
     _getImagePlaneModule(imageId) {
         const imagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, imageId);
+        this.hasPixelSpacing =
+            !imagePlaneModule.usingDefaultValues || this.calibration?.scale > 0;
         this.calibration ||= imagePlaneModule.calibration;
         const newImagePlaneModule = {
             ...imagePlaneModule,
         };
         if (!newImagePlaneModule.columnPixelSpacing) {
             newImagePlaneModule.columnPixelSpacing = 1;
-            this.hasPixelSpacing = this.calibration?.scale > 0;
         }
         if (!newImagePlaneModule.rowPixelSpacing) {
             newImagePlaneModule.rowPixelSpacing = 1;
-            this.hasPixelSpacing = this.calibration?.scale > 0;
         }
         if (!newImagePlaneModule.columnCosines) {
             newImagePlaneModule.columnCosines = [0, 1, 0];

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

@@ -42,4 +42,4 @@ declare class Cache implements ICache {
 }
 declare const cache: Cache;
 export default cache;
-export { Cache };
+export { Cache, cache };

package/dist/esm/cache/cache.js

@@ -498,4 +498,4 @@ class Cache {
 }
 const cache = new Cache();
 export default cache;
-export { Cache };
+export { Cache, cache };

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

@@ -7,7 +7,6 @@ import ImageVolume from './ImageVolume';
 import ProgressiveRetrieveImages from '../../loaders/ProgressiveRetrieveImages';
 import { canRenderFloatTextures } from '../../init';
 import { loadAndCacheImage } from '../../loaders/imageLoader';
-import StreamingImageVolume from './StreamingImageVolume';
 const requestTypeDefault = RequestType.Prefetch;
 export default class BaseStreamingImageVolume extends ImageVolume {
     constructor(imageVolumeProperties, streamingProperties) {

package/dist/esm/loaders/volumeLoader.js

@@ -68,14 +68,6 @@ export function createAndCacheDerivedVolume(referencedVolumeId, options) {
     }
     const { metadata, dimensions, spacing, origin, direction } = referencedVolume;
     const referencedImageIds = referencedVolume.imageIds ?? [];
-    const byteLength = referencedImageIds.reduce((total, imageId) => {
-        const image = cache.getImage(imageId);
-        return total + image.sizeInBytes;
-    }, 0);
-    const isCacheable = cache.isCacheable(byteLength);
-    if (!isCacheable) {
-        throw new Error(`Cannot created derived volume: Referenced volume with id ${referencedVolumeId} does not exist.`);
-    }
     const derivedImages = createAndCacheDerivedImages(referencedImageIds, {
         targetBufferType: options.targetBufferType,
     });

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

@@ -0,0 +1,2 @@
+import type BaseVolumeViewport from '../RenderingEngine/BaseVolumeViewport';
+export type IBaseVolumeViewport = BaseVolumeViewport;

package/dist/esm/types/IBaseVolumeViewport.js

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

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

@@ -1,69 +1,2 @@
-import type CPUIImageData from './CPUIImageData';
-import type { ActorEntry } from './IActor';
-import type ICamera from './ICamera';
-import type IImage from './IImage';
-import type IImageData from './IImageData';
-import type { IStackInput } from './IStackInput';
-import type { IViewport } from './IViewport';
-import type Point2 from './Point2';
-import type Point3 from './Point3';
-import type { Scaling } from './ScalingParameters';
-import type StackViewportProperties from './StackViewportProperties';
-import type { ViewReference, ViewReferenceSpecifier, ReferenceCompatibleOptions } from '../types/IViewport';
-import type { ImageDataMetaData } from '../RenderingEngine/StackViewport';
-import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
-export default interface IStackViewport extends IViewport {
-    setUseCPURendering(value: boolean): void;
-    updateRenderingPipeline(): void;
-    getImageData(): IImageData | CPUIImageData;
-    getCamera(): ICamera;
-    setCamera(cameraInterface: ICamera, storeAsInitialCamera?: boolean): void;
-    getRotation(): number;
-    unsetColormap(): void;
-    getImageIds(): string[];
-    setStack(imageIds: string[], imageIdIndex?: number): Promise<string>;
-    resetCamera(options?: unknown): boolean;
-    canvasToWorld(canvasPos: Point2): Point3;
-    worldToCanvas(worldPos: Point3): Point2;
-    getRenderer(): vtkRenderer;
-    getDefaultActor(): ActorEntry;
-    getActors(): ActorEntry[];
-    getActor(actorUID: string): ActorEntry;
-    setActors(actors: ActorEntry[]): void;
-    addActors(actors: ActorEntry[]): void;
-    addActor(actorEntry: ActorEntry): void;
-    removeAllActors(): void;
-    getFrameOfReferenceUID(): string;
-    addImages(images: IStackInput[], immediateRender?: boolean, suppressEvents?: boolean): void;
-    renderImageObject(image: unknown): void;
-    setProperties(properties: StackViewportProperties, suppressEvents?: boolean): void;
-    getCurrentImageId(): string;
-    getImageDataMetadata(image: IImage): ImageDataMetaData;
-    resize(): void;
-    setDefaultProperties(ViewportProperties: StackViewportProperties, imageId?: string): void;
-    clearDefaultProperties(imageId?: string): void;
-    getDefaultProperties(imageId?: string): StackViewportProperties;
-    getProperties(): StackViewportProperties;
-    getCurrentImageIdIndex(): number;
-    hasImageId(imageId: string): boolean;
-    hasImageURI(imageURI: string): boolean;
-    customRenderViewportToCanvas(): {
-        canvas: HTMLCanvasElement;
-        element: HTMLDivElement;
-        viewportId: string;
-        renderingEngineId: string;
-    };
-    getCornerstoneImage(): IImage;
-    resetToDefaultProperties(): void;
-    resetProperties(): void;
-    setImageIdIndex(imageIdIndex: number): Promise<string>;
-    calibrateSpacing(imageId: string): void;
-    isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean | unknown;
-    getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
-    setViewReference(viewRef: ViewReference): void;
-    getViewReferenceId(specifier?: ViewReferenceSpecifier): string;
-    modality: string;
-    scaling: Scaling;
-    stackActorReInitialized: boolean;
-    scroll(delta: number, debounceLoading?: boolean, loop?: boolean): void;
-}
+import type { StackViewport } from '../RenderingEngine';
+export type { StackViewport as default };

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

@@ -1,40 +1,2 @@
-import type { IViewport } from './IViewport';
-import type { PixelDataTypedArray } from './PixelDataTypedArray';
-import type VideoViewportProperties from './VideoViewportProperties';
-import type { VOIRange } from './voi';
-import type { SpeedUnit } from '../enums/VideoEnums';
-import type IImageData from './IImageData';
-import type CPUIImageData from './CPUIImageData';
-export interface IVideoViewport extends IViewport {
-    modality: string;
-    canvasContext: CanvasRenderingContext2D;
-    setVideo(imageId: string, frameNumber?: number): Promise<unknown>;
-    setVideoURL(videoURL: string): Promise<unknown>;
-    togglePlayPause(): boolean;
-    play(): Promise<void>;
-    pause(): void;
-    scroll(delta?: number): Promise<void>;
-    start(): Promise<void>;
-    end(): Promise<void>;
-    setTime(timeInSeconds: number): Promise<void>;
-    setFrameNumber(frame: number): Promise<void>;
-    setFrameRange(frameRange: number[]): void;
-    getFrameRange(): [number, number];
-    setProperties(props: VideoViewportProperties): void;
-    setPlaybackRate(rate?: number): void;
-    setScrollSpeed(scrollSpeed?: number, unit?: SpeedUnit): void;
-    getProperties(): VideoViewportProperties;
-    resetProperties(): void;
-    setVOI(voiRange: VOIRange): void;
-    setWindowLevel(windowWidth?: number, windowCenter?: number): void;
-    setAverageWhite(averageWhite: [number, number, number]): void;
-    getFrameNumber(): number;
-    getFrameRate(): number;
-    getMiddleSliceData(): PixelDataTypedArray;
-    getImageData(): IImageData | CPUIImageData;
-    getCurrentImageId(): string;
-    hasImageURI(imageURI: string): boolean;
-    getNumberOfSlices(): number;
-    customRenderViewportToCanvas(): void;
-    useCustomRenderingPipeline: boolean;
-}
+import type VideoViewport from '../RenderingEngine/VideoViewport';
+export type IVideoViewport = VideoViewport;

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

@@ -1,17 +1,10 @@
-import type ICamera from './ICamera';
 import type Point2 from './Point2';
 import type Point3 from './Point3';
 import type ViewportInputOptions from './ViewportInputOptions';
-import type { ActorEntry } from './IActor';
 import type ViewportType from '../enums/ViewportType';
-import type ViewportStatus from '../enums/ViewportStatus';
 import type DisplayArea from './displayArea';
 import type { BoundsLPS } from './BoundsLPS';
-import type { mat4 } from 'gl-matrix';
-import type IRenderingEngine from './IRenderingEngine';
-import type IImageData from './IImageData';
-import type CPUIImageData from './CPUIImageData';
-import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
+import type Viewport from '../RenderingEngine/Viewport';
 export interface ViewReferenceSpecifier {
     sliceIndex?: number | [number, number];
     forFrameOfReference?: boolean;
@@ -56,86 +49,7 @@ export interface DataSetOptions {
     viewSelector?: ViewPresentationSelector;
     viewReference?: ViewReferenceSpecifier;
 }
-interface IViewport {
-    id: string;
-    getImageData: () => IImageData | CPUIImageData | undefined;
-    getWidget: (id: string) => unknown;
-    addWidget: (id: string, widget: unknown) => void;
-    getWidgets: () => unknown;
-    removeWidgets: () => void;
-    renderingEngineId: string;
-    type: ViewportType;
-    canvas: HTMLCanvasElement;
-    element: HTMLDivElement;
-    sx: number;
-    sy: number;
-    sWidth: number;
-    sHeight: number;
-    _actors: Map<string, unknown>;
-    defaultOptions: unknown;
-    options: ViewportInputOptions;
-    suppressEvents: boolean;
-    isDisabled: boolean;
-    viewportStatus: ViewportStatus;
-    getRotation: () => number;
-    getFrameOfReferenceUID: () => string;
-    canvasToWorld: (canvasPos: Point2) => Point3;
-    worldToCanvas: (worldPos: Point3) => Point2;
-    getDefaultActor(): ActorEntry;
-    getActors(): ActorEntry[];
-    getActor(actorUID: string): ActorEntry;
-    getActorUIDByIndex(index: number): string;
-    getActorByIndex(index: number): ActorEntry;
-    setActors(actors: ActorEntry[]): void;
-    addActors(actors: ActorEntry[]): void;
-    addActor(actorEntry: ActorEntry): void;
-    getActorUIDs(): string[];
-    removeAllActors(): void;
-    removeActors(actorUIDs: string[]): void;
-    getRenderingEngine(): IRenderingEngine;
-    getRenderer(): vtkRenderer;
-    render(): void;
-    setOptions(options: ViewportInputOptions, immediate: boolean): void;
-    setDisplayArea(displayArea: DisplayArea, callResetCamera?: boolean, suppressEvents?: boolean): any;
-    getDisplayArea(): DisplayArea | undefined;
-    reset(immediate: boolean): void;
-    getCanvas(): HTMLCanvasElement;
-    getCamera(): ICamera;
-    setRendered(): void;
-    getZoom(): number;
-    setZoom(zoom: number, storeAsInitialCamera?: boolean): any;
-    getPan(): Point2;
-    setPan(pan: Point2, storeAsInitialCamera?: boolean): any;
-    setCamera(cameraInterface: ICamera, storeAsInitialCamera?: boolean): void;
-    resetCamera({ resetPan, resetZoom, resetToCenter, storeAsInitialCamera, }?: {
-        resetPan?: boolean;
-        resetZoom?: boolean;
-        resetToCenter?: boolean;
-        storeAsInitialCamera?: boolean;
-    }): boolean;
-    getNumberOfSlices(): number;
-    getCurrentImageIdIndex(): number;
-    getSliceIndex(): number;
-    getSliceViewInfo(): {
-        width: number;
-        height: number;
-        sliceIndex: number;
-        slicePlane: number;
-        sliceToIndexMatrix: mat4;
-        indexToSliceMatrix: mat4;
-    };
-    getViewReferenceId(viewRefSpecifier?: ViewReferenceSpecifier): string;
-    getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
-    isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean | unknown;
-    getViewPresentation(viewPresSel?: ViewPresentationSelector): ViewPresentation;
-    setViewReference(viewRef: ViewReference): any;
-    setViewPresentation(viewPres: ViewPresentation): any;
-    customRenderViewportToCanvas: () => unknown;
-    _getCorners(bounds: number[]): number[][];
-    updateRenderingPipeline: () => void;
-    getTargetId?: () => string;
-    setDataIds(dataIds: string[], options?: DataSetOptions): void;
-}
+type IViewport = Viewport;
 interface PublicViewportInput {
     element: HTMLDivElement;
     viewportId: string;

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

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

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

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

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

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

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

@@ -35,6 +35,7 @@ export interface ImagePlaneModuleMetadata {
     pixelSpacing: number[];
     rowPixelSpacing: number | null;
     columnPixelSpacing: number | null;
+    usingDefaultValues: boolean;
 }
 export interface ImagePixelModuleMetadata {
     samplesPerPixel: number;

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

@@ -93,4 +93,5 @@ import type { DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, Ima
 import type { IVoxelManager } from './IVoxelManager';
 import type { IRLEVoxelMap, RLERun } from './IRLEVoxelMap';
 import type ImageLoadRequests from './ImageLoadRequests';
-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, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, PixelDataTypedArrayString, ImagePixelModule, ImagePlaneModule, AffineMatrix, ImageLoadListener, InternalVideoCamera, VideoViewportInput, WSIViewportInput, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, IImageFrame, DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, ImagePlaneModuleMetadata, SopCommonModuleMetadata, ImagePixelModuleMetadata, PatientStudyModuleMetadata, TransferSyntaxMetadata, LocalVolumeOptions, IVoxelManager, IRLEVoxelMap, RLERun, ViewportInput, ImageLoadRequests, };
+import type { IBaseVolumeViewport } from './IBaseVolumeViewport';
+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, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, PixelDataTypedArrayString, ImagePixelModule, ImagePlaneModule, AffineMatrix, ImageLoadListener, InternalVideoCamera, VideoViewportInput, WSIViewportInput, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, IImageFrame, DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, ImagePlaneModuleMetadata, SopCommonModuleMetadata, ImagePixelModuleMetadata, PatientStudyModuleMetadata, TransferSyntaxMetadata, LocalVolumeOptions, IVoxelManager, IRLEVoxelMap, RLERun, ViewportInput, ImageLoadRequests, IBaseVolumeViewport, };

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

@@ -17,7 +17,7 @@ export default class VoxelManager<T> implements IVoxelManager<T> {
     width: number;
     frameSize: number;
     _get: (index: number) => T;
-    _set: (index: number, v: T) => boolean | void;
+    _set: (index: number, v: T) => boolean;
     _getConstructor?: () => new (length: number) => PixelDataTypedArray;
     _getScalarDataLength?: () => number;
     _getScalarData?: () => PixelDataTypedArray;
@@ -25,13 +25,13 @@ export default class VoxelManager<T> implements IVoxelManager<T> {
         sliceIndex: number;
         slicePlane: number;
     }) => PixelDataTypedArray;
-    constructor(dimensions: any, _get: (index: number) => T, _set?: (index: number, v: T) => boolean | void);
+    constructor(dimensions: any, _get: (index: number) => T, _set?: (index: number, v: T) => boolean);
     getAtIJK: (i: any, j: any, k: any) => T;
-    setAtIJK: (i: number, j: number, k: number, v: any) => void;
+    setAtIJK: (i: number, j: number, k: number, v: any) => boolean;
     getAtIJKPoint: ([i, j, k]: [any, any, any]) => T;
     setAtIJKPoint: ([i, j, k]: Point3, v: any) => void;
     getAtIndex: (index: any) => T;
-    setAtIndex: (index: any, v: any) => void;
+    setAtIndex: (index: any, v: any) => boolean;
     toIJK(index: number): Point3;
     getMiddleSliceData: () => PixelDataTypedArray;
     toIndex(ijk: Point3): number;
@@ -53,7 +53,8 @@ export default class VoxelManager<T> implements IVoxelManager<T> {
     get bytePerVoxel(): number;
     clear(): void;
     getConstructor(): new (length: number) => PixelDataTypedArray;
-    getArrayOfSlices(): number[];
+    getArrayOfModifiedSlices(): number[];
+    resetModifiedSlices(): void;
     static addBounds(bounds: BoundsIJK, point: Point3): void;
     addPoint(point: Point3 | number): void;
     getPoints(): Point3[];

package/dist/esm/utilities/VoxelManager.js

@@ -20,10 +20,12 @@ export default class VoxelManager {
         };
         this.setAtIJK = (i, j, k, v) => {
             const index = this.toIndex([i, j, k]);
-            if (this._set(index, v) !== false) {
+            const changed = this._set(index, v);
+            if (changed) {
                 this.modifiedSlices.add(k);
                 VoxelManager.addBounds(this.boundsIJK, [i, j, k]);
             }
+            return changed;
         };
         this.getAtIJKPoint = ([i, j, k]) => this.getAtIJK(i, j, k);
         this.setAtIJKPoint = ([i, j, k], v) => {
@@ -31,11 +33,13 @@ export default class VoxelManager {
         };
         this.getAtIndex = (index) => this._get(index);
         this.setAtIndex = (index, v) => {
-            if (this._set(index, v) !== false) {
+            const changed = this._set(index, v);
+            if (changed) {
                 const pointIJK = this.toIJK(index);
                 this.modifiedSlices.add(pointIJK[2]);
                 VoxelManager.addBounds(this.boundsIJK, pointIJK);
             }
+            return changed;
         };
         this.getMiddleSliceData = () => {
             const middleSliceIndex = Math.floor(this.dimensions[2] / 2);
@@ -263,9 +267,12 @@ export default class VoxelManager {
         console.warn('No scalar data available or can be used to get the constructor');
         return Float32Array;
     }
-    getArrayOfSlices() {
+    getArrayOfModifiedSlices() {
         return Array.from(this.modifiedSlices);
     }
+    resetModifiedSlices() {
+        this.modifiedSlices.clear();
+    }
     static addBounds(bounds, point) {
         if (!bounds) {
             bounds = [
@@ -613,6 +620,7 @@ export default class VoxelManager {
                 map.set(k, layer);
             }
             layer[index % planeSize] = v;
+            return true;
         });
         voxelManager.map = map;
         return voxelManager;
@@ -622,6 +630,7 @@ export default class VoxelManager {
         const map = new RLEVoxelMap(width, height, depth);
         const voxelManager = new VoxelManager(dimensions, (index) => map.get(index), (index, v) => {
             map.set(index, v);
+            return true;
         });
         voxelManager.map = map;
         voxelManager.getPixelData = map.getPixelData.bind(map);

package/dist/esm/utilities/generateVolumePropsFromImageIds.js

@@ -14,7 +14,7 @@ function generateVolumePropsFromImageIds(imageIds, volumeId) {
     const { zSpacing, origin, sortedImageIds } = sortImageIdsAndGetSpacing(imageIds, scanAxisNormal);
     const numFrames = imageIds.length;
     const spacing = [PixelSpacing[1], PixelSpacing[0], zSpacing];
-    const dimensions = [Columns, Rows, numFrames];
+    const dimensions = [Columns, Rows, numFrames].map((it) => Math.floor(it));
     const direction = [
         ...rowCosineVec,
         ...colCosineVec,
@@ -34,7 +34,7 @@ function generateVolumePropsFromImageIds(imageIds, volumeId) {
     };
 }
 function _determineDataType(imageIds, volumeMetadata) {
-    const { BitsAllocated, PixelRepresentation, PhotometricInterpretation } = volumeMetadata;
+    const { BitsAllocated, PixelRepresentation, x } = volumeMetadata;
     const signed = PixelRepresentation === 1;
     const imageIdIndex = Math.floor(imageIds.length / 2);
     const imageId = imageIds[imageIdIndex];