@cornerstonejs/core 3.10.31 → 3.11.1

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

@@ -43,6 +43,7 @@ declare abstract class BaseVolumeViewport extends Viewport {
     scroll(delta?: number): void;
     abstract isInAcquisitionPlane(): boolean;
     setViewReference(viewRef: ViewReference): void;
+    private setThreshold;
     setProperties({ voiRange, VOILUTFunction, invert, colormap, preset, interpolationType, slabThickness, }?: VolumeViewportProperties, volumeId?: string, suppressEvents?: boolean): void;
     resetToDefaultProperties(volumeId: string): void;
     private setPreset;
@@ -72,6 +73,7 @@ declare abstract class BaseVolumeViewport extends Viewport {
     worldToCanvas: (worldPos: Point3) => Point2;
     hasImageURI: (imageURI: string) => boolean;
     protected _getOrientationVectors(orientation: OrientationAxis | OrientationVectors): OrientationVectors;
+    protected _getAcquisitionPlaneOrientation(): OrientationVectors;
     getSlabThickness(): number;
     getIntensityFromWorld(point: Point3): number;
     getImageIds: (volumeId?: string) => string[];

package/dist/esm/RenderingEngine/BaseVolumeViewport.js

@@ -13,7 +13,7 @@ import * as colormapUtils from '../utilities/colormap';
 import invertRgbTransferFunction from '../utilities/invertRgbTransferFunction';
 import createSigmoidRGBTransferFunction from '../utilities/createSigmoidRGBTransferFunction';
 import transformWorldToIndex from '../utilities/transformWorldToIndex';
-import { findMatchingColormap } from '../utilities/colormap';
+import { findMatchingColormap, updateOpacity as colormapUpdateOpacity, updateThreshold as colormapUpdateThreshold, } from '../utilities/colormap';
 import { getTransferFunctionNodes } from '../utilities/transferFunctionUtils';
 import createVolumeActor from './helpers/createVolumeActor';
 import volumeNewImageEventDispatcher, { resetVolumeNewImageState, } from './helpers/volumeNewImageEventDispatcher';
@@ -334,19 +334,14 @@ class BaseVolumeViewport extends Viewport {
         const { volumeActor } = applicableVolumeActorInfo;
         const ofun = vtkPiecewiseFunction.newInstance();
         if (typeof colormap.opacity === 'number') {
-            const range = volumeActor
-                .getProperty()
-                .getRGBTransferFunction(0)
-                .getRange();
-            ofun.addPoint(range[0], colormap.opacity);
-            ofun.addPoint(range[1], colormap.opacity);
+            colormapUpdateOpacity(volumeActor, colormap.opacity);
         }
         else {
             colormap.opacity.forEach(({ opacity, value }) => {
                 ofun.addPoint(value, opacity);
             });
+            volumeActor.getProperty().setScalarOpacity(0, ofun);
         }
-        volumeActor.getProperty().setScalarOpacity(0, ofun);
         if (!this.viewportProperties.colormap) {
             this.viewportProperties.colormap = {};
         }
@@ -580,6 +575,18 @@ class BaseVolumeViewport extends Viewport {
             throw new Error(`Incompatible view refs: ${refFrameOfReference}!==${this.getFrameOfReferenceUID()}`);
         }
     }
+    setThreshold(colormap, volumeId) {
+        const applicableVolumeActorInfo = this._getApplicableVolumeActor(volumeId);
+        if (!applicableVolumeActorInfo) {
+            return;
+        }
+        const { volumeActor } = applicableVolumeActorInfo;
+        colormapUpdateThreshold(volumeActor, colormap.threshold);
+        if (!this.viewportProperties.colormap) {
+            this.viewportProperties.colormap = {};
+        }
+        this.viewportProperties.colormap.threshold = colormap.threshold;
+    }
     setProperties({ voiRange, VOILUTFunction, invert, colormap, preset, interpolationType, slabThickness, } = {}, volumeId, suppressEvents = false) {
         if (this.globalDefaultProperties == null) {
             this.setDefaultProperties({
@@ -600,6 +607,9 @@ class BaseVolumeViewport extends Viewport {
         if (colormap?.opacity != null) {
             this.setOpacity(colormap, volumeId);
         }
+        if (colormap?.threshold != null) {
+            this.setThreshold(colormap, volumeId);
+        }
         if (voiRange !== undefined) {
             this.setVOI(voiRange, volumeId, suppressEvents);
         }
@@ -862,14 +872,34 @@ class BaseVolumeViewport extends Viewport {
                 throw new Error('Invalid orientation object. It must contain viewPlaneNormal and viewUp');
             }
         }
-        else if (typeof orientation === 'string' &&
-            MPR_CAMERA_VALUES[orientation]) {
-            this.viewportProperties.orientation = orientation;
-            return MPR_CAMERA_VALUES[orientation];
+        else if (typeof orientation === 'string') {
+            if (orientation === 'acquisition') {
+                return this._getAcquisitionPlaneOrientation();
+            }
+            else if (MPR_CAMERA_VALUES[orientation]) {
+                this.viewportProperties.orientation = orientation;
+                return MPR_CAMERA_VALUES[orientation];
+            }
         }
-        else {
-            throw new Error(`Invalid orientation: ${orientation}. Valid orientations are: ${Object.keys(MPR_CAMERA_VALUES).join(', ')}`);
+        throw new Error(`Invalid orientation: ${orientation}. Valid orientations are: ${Object.keys(MPR_CAMERA_VALUES).join(', ')}`);
+    }
+    _getAcquisitionPlaneOrientation() {
+        const actorEntry = this.getDefaultActor();
+        if (!actorEntry) {
+            return;
+        }
+        const volumeId = this.getVolumeId();
+        const imageVolume = cache.getVolume(volumeId);
+        if (!imageVolume) {
+            throw new Error(`imageVolume with id: ${volumeId} does not exist in cache`);
         }
+        const { direction } = imageVolume;
+        const viewPlaneNormal = direction.slice(6, 9).map((x) => -x);
+        const viewUp = direction.slice(3, 6).map((x) => -x);
+        return {
+            viewPlaneNormal,
+            viewUp,
+        };
     }
     getSlabThickness() {
         const actors = this.getActors();

package/dist/esm/RenderingEngine/StackViewport.js

@@ -1195,6 +1195,10 @@ class StackViewport extends Viewport {
             origin = [0, 0, 0];
         }
         this._imageData.setOrigin(origin);
+        const actor = this.getActor(this.id);
+        if (actor) {
+            actor.referencedId = image.imageId;
+        }
         updateVTKImageDataWithCornerstoneImage(this._imageData, image);
     }
     _loadAndDisplayImage(imageId, imageIdIndex) {
@@ -1462,7 +1466,7 @@ class StackViewport extends Viewport {
             oldActors[0].actor = actor;
         }
         else {
-            oldActors.unshift({ uid: this.id, actor });
+            oldActors.unshift({ uid: this.id, actor, referencedId: image.imageId });
         }
         this.setActors(oldActors);
         const { viewPlaneNormal, viewUp } = this._getCameraOrientation(direction);

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

@@ -76,7 +76,7 @@ declare class Viewport {
     getActorUIDByIndex(index: number): string;
     getActorByIndex(index: number): ActorEntry;
     setActors(actors: ActorEntry[]): void;
-    _removeActor(actorUID: string): void;
+    _removeActor(actorUID: string): ActorEntry | undefined;
     removeActors(actorUIDs: string[]): void;
     addActors(actors: ActorEntry[], options?: {
         resetCamera?: boolean;

package/dist/esm/RenderingEngine/Viewport.js

@@ -211,22 +211,41 @@ class Viewport {
         return this.getActors()[index];
     }
     setActors(actors) {
+        const currentActors = this.getActors();
         this.removeAllActors();
         this.addActors(actors, { resetCamera: true });
+        triggerEvent(this.element, Events.ACTORS_CHANGED, {
+            viewportId: this.id,
+            removedActors: currentActors,
+            addedActors: actors,
+            currentActors: actors,
+        });
     }
     _removeActor(actorUID) {
         const actorEntry = this.getActor(actorUID);
         if (!actorEntry) {
-            console.warn(`Actor ${actorUID} does not exist for this viewport`);
+            console.warn(`Actor ${actorUID} does not exist in ${this.id}, can't remove`);
             return;
         }
         const renderer = this.getRenderer();
-        renderer.removeViewProp(actorEntry.actor);
+        renderer.removeActor(actorEntry.actor);
         this._actors.delete(actorUID);
+        return actorEntry;
     }
     removeActors(actorUIDs) {
+        const removedActors = [];
         actorUIDs.forEach((actorUID) => {
-            this._removeActor(actorUID);
+            const removedActor = this._removeActor(actorUID);
+            if (removedActor) {
+                removedActors.push(removedActor);
+            }
+        });
+        const currentActors = this.getActors();
+        triggerEvent(this.element, Events.ACTORS_CHANGED, {
+            viewportId: this.id,
+            removedActors,
+            addedActors: [],
+            currentActors,
         });
     }
     addActors(actors, options = {}) {
@@ -246,6 +265,12 @@ class Viewport {
             this.setViewReference(prevViewRef);
             this.setViewPresentation(prevViewPresentation);
         }
+        triggerEvent(this.element, Events.ACTORS_CHANGED, {
+            viewportId: this.id,
+            removedActors: [],
+            addedActors: actors,
+            currentActors: this.getActors(),
+        });
     }
     addActor(actorEntry) {
         const { uid: actorUID, actor } = actorEntry;
@@ -265,10 +290,23 @@ class Viewport {
         renderer?.addActor(actor);
         this._actors.set(actorUID, Object.assign({}, actorEntry));
         this.updateCameraClippingPlanesAndRange();
+        triggerEvent(this.element, Events.ACTORS_CHANGED, {
+            viewportId: this.id,
+            removedActors: [],
+            addedActors: [actorEntry],
+            currentActors: this.getActors(),
+        });
     }
     removeAllActors() {
+        const currentActors = this.getActors();
         this.getRenderer()?.removeAllViewProps();
         this._actors = new Map();
+        triggerEvent(this.element, Events.ACTORS_CHANGED, {
+            viewportId: this.id,
+            removedActors: currentActors,
+            addedActors: [],
+            currentActors: [],
+        });
         return;
     }
     resetCameraNoEvent() {

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

@@ -13,7 +13,6 @@ declare class VolumeViewport extends BaseVolumeViewport {
     jumpToWorld(worldPos: Point3): boolean;
     setOrientation(orientation: OrientationAxis | OrientationVectors, immediate?: boolean): void;
     protected setCameraClippingRange(): void;
-    private _getAcquisitionPlaneOrientation;
     private _setViewPlaneToAcquisitionPlane;
     getBlendMode(filterActorUIDs?: string[]): BlendModes;
     setBlendMode(blendMode: BlendModes, filterActorUIDs?: any[], immediate?: boolean): void;

package/dist/esm/RenderingEngine/VolumeViewport.js

@@ -131,11 +131,11 @@ class VolumeViewport extends BaseVolumeViewport {
     setOrientation(orientation, immediate = true) {
         let viewPlaneNormal, viewUp;
         if (typeof orientation === 'string') {
-            if (MPR_CAMERA_VALUES[orientation]) {
-                ({ viewPlaneNormal, viewUp } = MPR_CAMERA_VALUES[orientation]);
+            if (orientation === OrientationAxis.ACQUISITION) {
+                ({ viewPlaneNormal, viewUp } = super._getAcquisitionPlaneOrientation());
             }
-            else if (orientation === 'acquisition') {
-                ({ viewPlaneNormal, viewUp } = this._getAcquisitionPlaneOrientation());
+            else if (MPR_CAMERA_VALUES[orientation]) {
+                ({ viewPlaneNormal, viewUp } = MPR_CAMERA_VALUES[orientation]);
             }
             else {
                 throw new Error(`Invalid orientation: ${orientation}. Use Enums.OrientationAxis instead.`);
@@ -168,24 +168,6 @@ class VolumeViewport extends BaseVolumeViewport {
             activeCamera.setClippingRange(RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS, RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE);
         }
     }
-    _getAcquisitionPlaneOrientation() {
-        const actorEntry = this.getDefaultActor();
-        if (!actorEntry) {
-            return;
-        }
-        const volumeId = this.getVolumeId();
-        const imageVolume = cache.getVolume(volumeId);
-        if (!imageVolume) {
-            throw new Error(`imageVolume with id: ${volumeId} does not exist in cache`);
-        }
-        const { direction } = imageVolume;
-        const viewPlaneNormal = direction.slice(6, 9).map((x) => -x);
-        const viewUp = direction.slice(3, 6).map((x) => -x);
-        return {
-            viewPlaneNormal,
-            viewUp,
-        };
-    }
     _setViewPlaneToAcquisitionPlane(imageVolume) {
         let viewPlaneNormal, viewUp;
         if (imageVolume) {

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

@@ -206,11 +206,12 @@ export default class BaseStreamingImageVolume extends ImageVolume {
             rescaleIntercept: modalityLutModule.rescaleIntercept,
             modality: generalSeriesModule.modality,
         };
-        if (scalingParameters.modality === 'PT') {
-            const suvFactor = metaData.get('scalingModule', imageId);
-            if (suvFactor) {
-                this._addScalingToVolume(suvFactor);
-                scalingParameters.suvbw = suvFactor.suvbw;
+        const modality = scalingParameters.modality;
+        if (modality === 'PT' || modality === 'RTDOSE') {
+            const scalingFactor = metaData.get('scalingModule', imageId);
+            if (scalingFactor) {
+                this._addScalingToVolume(scalingFactor);
+                Object.assign(scalingParameters, scalingFactor);
             }
         }
         const floatAfterScale = hasFloatScalingParameters(scalingParameters);

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

@@ -42,6 +42,7 @@ declare enum Events {
     DYNAMIC_VOLUME_TIME_POINT_LOADED = "DYNAMIC_VOLUME_TIME_POINT_LOADED",
     GEOMETRY_LOADED = "GEOMETRY_LOADED",
     GEOMETRY_LOAD_PROGRESS = "GEOMETRY_LOAD_PROGRESS",
-    GEOMETRY_LOADED_FAILED = "GEOMETRY_LOADED_FAILED"
+    GEOMETRY_LOADED_FAILED = "GEOMETRY_LOADED_FAILED",
+    ACTORS_CHANGED = "CORNERSTONE_ACTORS_CHANGED"
 }
 export default Events;

package/dist/esm/enums/Events.js

@@ -44,5 +44,6 @@ var Events;
     Events["GEOMETRY_LOADED"] = "GEOMETRY_LOADED";
     Events["GEOMETRY_LOAD_PROGRESS"] = "GEOMETRY_LOAD_PROGRESS";
     Events["GEOMETRY_LOADED_FAILED"] = "GEOMETRY_LOADED_FAILED";
+    Events["ACTORS_CHANGED"] = "CORNERSTONE_ACTORS_CHANGED";
 })(Events || (Events = {}));
 export default Events;

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

@@ -12,5 +12,6 @@ interface OpacityMapping {
 interface ColormapPublic {
     name?: string;
     opacity?: OpacityMapping[] | number;
+    threshold?: number;
 }
 export type { ColormapRegistration, ColormapPublic, OpacityMapping };

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

@@ -13,6 +13,7 @@ import type DisplayArea from './displayArea';
 import type IImageCalibration from './IImageCalibration';
 import type { ColormapPublic } from './Colormap';
 import type IVolumeViewport from './IVolumeViewport';
+import type { ActorEntry } from './IActor';
 interface CameraModifiedEventDetail {
     previousCamera: ICamera;
     camera: ICamera;
@@ -184,4 +185,11 @@ type StackViewportNewStackEvent = CustomEventType<StackViewportNewStackEventDeta
 type StackViewportScrollEvent = CustomEventType<StackViewportScrollEventDetail>;
 type StackScrollOutOfBoundsEvent = CustomEventType<StackScrollOutOfBoundsEventDetail>;
 type VolumeScrollOutOfBoundsEvent = CustomEventType<VolumeScrollOutOfBoundsEventDetail>;
-export type { VolumeScrollOutOfBoundsEventDetail, VolumeScrollOutOfBoundsEvent, CameraModifiedEventDetail, CameraModifiedEvent, VoiModifiedEvent, VoiModifiedEventDetail, ColormapModifiedEvent, ColormapModifiedEventDetail, DisplayAreaModifiedEvent, DisplayAreaModifiedEventDetail, ElementDisabledEvent, ElementDisabledEventDetail, ElementEnabledEvent, ElementEnabledEventDetail, ImageRenderedEventDetail, ImageRenderedEvent, ImageVolumeModifiedEvent, ImageVolumeModifiedEventDetail, ImageVolumeLoadingCompletedEvent, ImageVolumeLoadingCompletedEventDetail, ImageLoadedEvent, ImageLoadedEventDetail, ImageLoadedFailedEventDetail, ImageLoadedFailedEvent, VolumeLoadedEvent, VolumeLoadedEventDetail, VolumeLoadedFailedEvent, VolumeLoadedFailedEventDetail, ImageCacheImageAddedEvent, ImageCacheImageAddedEventDetail, ImageCacheImageRemovedEvent, ImageCacheImageRemovedEventDetail, VolumeCacheVolumeAddedEvent, VolumeCacheVolumeAddedEventDetail, VolumeCacheVolumeRemovedEvent, VolumeCacheVolumeRemovedEventDetail, StackNewImageEvent, StackNewImageEventDetail, PreStackNewImageEvent, PreStackNewImageEventDetail, ImageSpacingCalibratedEvent, ImageSpacingCalibratedEventDetail, VolumeNewImageEvent, VolumeNewImageEventDetail, StackViewportNewStackEvent, StackViewportNewStackEventDetail, StackViewportScrollEvent, StackViewportScrollEventDetail, StackScrollOutOfBoundsEvent, StackScrollOutOfBoundsEventDetail, CameraResetEvent, CameraResetEventDetail, };
+interface ActorsChangedEventDetail {
+    viewportId: string;
+    removedActors: ActorEntry[];
+    addedActors: ActorEntry[];
+    currentActors: ActorEntry[];
+}
+type ActorsChangedEvent = CustomEventType<ActorsChangedEventDetail>;
+export type { VolumeScrollOutOfBoundsEventDetail, VolumeScrollOutOfBoundsEvent, ActorsChangedEventDetail, ActorsChangedEvent, CameraModifiedEventDetail, CameraModifiedEvent, VoiModifiedEvent, VoiModifiedEventDetail, ColormapModifiedEvent, ColormapModifiedEventDetail, DisplayAreaModifiedEvent, DisplayAreaModifiedEventDetail, ElementDisabledEvent, ElementDisabledEventDetail, ElementEnabledEvent, ElementEnabledEventDetail, ImageRenderedEventDetail, ImageRenderedEvent, ImageVolumeModifiedEvent, ImageVolumeModifiedEventDetail, ImageVolumeLoadingCompletedEvent, ImageVolumeLoadingCompletedEventDetail, ImageLoadedEvent, ImageLoadedEventDetail, ImageLoadedFailedEventDetail, ImageLoadedFailedEvent, VolumeLoadedEvent, VolumeLoadedEventDetail, VolumeLoadedFailedEvent, VolumeLoadedFailedEventDetail, ImageCacheImageAddedEvent, ImageCacheImageAddedEventDetail, ImageCacheImageRemovedEvent, ImageCacheImageRemovedEventDetail, VolumeCacheVolumeAddedEvent, VolumeCacheVolumeAddedEventDetail, VolumeCacheVolumeRemovedEvent, VolumeCacheVolumeRemovedEventDetail, StackNewImageEvent, StackNewImageEventDetail, PreStackNewImageEvent, PreStackNewImageEventDetail, ImageSpacingCalibratedEvent, ImageSpacingCalibratedEventDetail, VolumeNewImageEvent, VolumeNewImageEventDetail, StackViewportNewStackEvent, StackViewportNewStackEventDetail, StackViewportScrollEvent, StackViewportScrollEventDetail, StackScrollOutOfBoundsEvent, StackScrollOutOfBoundsEventDetail, CameraResetEvent, CameraResetEventDetail, };

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

@@ -1,2 +1,2 @@
-export type PixelDataTypedArray = Float32Array | Int16Array | Uint16Array | Uint8Array | Int8Array | Uint8ClampedArray;
-export type PixelDataTypedArrayString = 'Float32Array' | 'Int16Array' | 'Uint16Array' | 'Uint8Array' | 'Int8Array' | 'Uint8ClampedArray' | 'none';
+export type PixelDataTypedArray = Float32Array | Int16Array | Uint16Array | Uint8Array | Int8Array | Uint8ClampedArray | Uint32Array | Int32Array;
+export type PixelDataTypedArrayString = 'Float32Array' | 'Int16Array' | 'Uint16Array' | 'Uint8Array' | 'Int8Array' | 'Uint8ClampedArray' | 'Uint32Array' | 'Int32Array' | 'none';

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

@@ -3,4 +3,7 @@ declare function registerColormap(colormap: ColormapRegistration): void;
 declare function getColormap(name: any): any;
 declare function getColormapNames(): any[];
 declare function findMatchingColormap(rgbPoints: any, actor: any): ColormapPublic | null;
+export declare function setColorMapTransferFunctionForVolumeActor(volumeInfo: any): void;
+export declare function updateOpacity(volumeActor: any, newOpacity: any): void;
+export declare function updateThreshold(volumeActor: any, newThreshold: any): void;
 export { getColormap, getColormapNames, registerColormap, findMatchingColormap, };

package/dist/esm/utilities/colormap.js

@@ -1,4 +1,6 @@
 import vtkColorMaps from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
+import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
+import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
 import isEqual from './isEqual';
 import { actorIsA } from './actorCheck';
 const _colormaps = new Map();
@@ -54,4 +56,78 @@ function findMatchingColormap(rgbPoints, actor) {
         opacity,
     };
 }
+export function setColorMapTransferFunctionForVolumeActor(volumeInfo) {
+    const { volumeActor, preset, opacity = 0.9, threshold = null, colorRange = [0, 5], } = volumeInfo;
+    const mapper = volumeActor.getMapper();
+    mapper.setSampleDistance(1.0);
+    const cfun = vtkColorTransferFunction.newInstance();
+    const presetToUse = preset || vtkColorMaps.getPresetByName('hsv');
+    cfun.applyColorMap(presetToUse);
+    cfun.setMappingRange(colorRange[0], colorRange[1]);
+    volumeActor.getProperty().setRGBTransferFunction(0, cfun);
+    updateOpacityWithThreshold(volumeActor, opacity, threshold);
+}
+export function updateOpacity(volumeActor, newOpacity) {
+    const currentThreshold = getThresholdValue(volumeActor);
+    updateOpacityWithThreshold(volumeActor, newOpacity, currentThreshold);
+}
+export function updateThreshold(volumeActor, newThreshold) {
+    const currentOpacity = getMaxOpacity(volumeActor);
+    updateOpacityWithThreshold(volumeActor, currentOpacity, newThreshold);
+}
+function updateOpacityWithThreshold(volumeActor, opacity, threshold) {
+    const transferFunction = volumeActor.getProperty().getRGBTransferFunction(0);
+    const range = transferFunction.getRange();
+    const ofun = vtkPiecewiseFunction.newInstance();
+    if (threshold !== null) {
+        const delta = Math.abs(range[1] - range[0]) * 0.001;
+        const thresholdValue = Math.max(range[0], Math.min(range[1], threshold));
+        ofun.addPoint(range[0], 0);
+        ofun.addPoint(thresholdValue - delta, 0);
+        ofun.addPoint(thresholdValue, opacity);
+        ofun.addPoint(range[1], opacity);
+    }
+    else {
+        ofun.addPoint(range[0], opacity);
+        ofun.addPoint(range[1], opacity);
+    }
+    volumeActor.getProperty().setScalarOpacity(0, ofun);
+}
+function getThresholdValue(volumeActor) {
+    const opacityFunction = volumeActor.getProperty().getScalarOpacity(0);
+    if (!opacityFunction) {
+        return null;
+    }
+    const dataArray = opacityFunction.getDataPointer();
+    if (!dataArray || dataArray.length <= 4) {
+        return null;
+    }
+    for (let i = 0; i < dataArray.length - 2; i += 2) {
+        const x1 = dataArray[i];
+        const y1 = dataArray[i + 1];
+        const x2 = dataArray[i + 2];
+        const y2 = dataArray[i + 3];
+        if (y1 === 0 && y2 > 0) {
+            return x2;
+        }
+    }
+    return null;
+}
+function getMaxOpacity(volumeActor) {
+    const opacityFunction = volumeActor.getProperty().getScalarOpacity(0);
+    if (!opacityFunction) {
+        return 1.0;
+    }
+    const dataArray = opacityFunction.getDataPointer();
+    if (!dataArray || dataArray.length === 0) {
+        return 1.0;
+    }
+    let maxOpacity = 0;
+    for (let i = 1; i < dataArray.length; i += 2) {
+        if (dataArray[i] > maxOpacity) {
+            maxOpacity = dataArray[i];
+        }
+    }
+    return maxOpacity;
+}
 export { getColormap, getColormapNames, registerColormap, findMatchingColormap, };

package/dist/esm/utilities/getBufferConfiguration.js

@@ -4,6 +4,8 @@ function getConstructorFromType(bufferType, isVolumeBuffer) {
             return Float32Array;
         case 'Uint8Array':
             return Uint8Array;
+        case 'Uint32Array':
+            return Uint32Array;
         case 'Uint16Array':
         case 'Int16Array':
             if (!isVolumeBuffer) {
@@ -15,7 +17,7 @@ function getConstructorFromType(bufferType, isVolumeBuffer) {
             }
         default:
             if (bufferType) {
-                throw new Error('TargetBuffer should be Float32Array, Uint8Array, Uint16Array, or Int16Array');
+                throw new Error('TargetBuffer should be Float32Array, Uint8Array, Uint16Array, Int16Array, or Uint32Array');
             }
             else {
                 return Float32Array;

package/dist/esm/utilities/getClosestImageId.js

@@ -1,7 +1,9 @@
 import { vec3 } from 'gl-matrix';
 import * as metaData from '../metaData';
+import { coreLog } from './logger';
 import getSpacingInNormalDirection from './getSpacingInNormalDirection';
 import { EPSILON } from '../constants';
+const log = coreLog.getLogger('utilities', 'getClosestImageId');
 export default function getClosestImageId(imageVolume, worldPos, viewPlaneNormal, options) {
     const { direction, spacing, imageIds } = imageVolume;
     const { ignoreSpacing = false } = options || {};
@@ -11,7 +13,6 @@ export default function getClosestImageId(imageVolume, worldPos, viewPlaneNormal
     const kVector = direction.slice(6, 9);
     const dotProduct = vec3.dot(kVector, viewPlaneNormal);
     if (Math.abs(dotProduct) < 1 - EPSILON) {
-        console.debug('View plane normal is not parallel to the image scan axis. Unable to find closest imageId.');
         return;
     }
     let halfSpacingInNormalDirection;
@@ -25,7 +26,7 @@ export default function getClosestImageId(imageVolume, worldPos, viewPlaneNormal
         const imageId = imageIds[i];
         const imagePlaneModule = metaData.get('imagePlaneModule', imageId);
         if (!imagePlaneModule?.imagePositionPatient) {
-            console.warn(`Missing imagePositionPatient for imageId: ${imageId}`);
+            log.warn(`Missing imagePositionPatient for imageId: ${imageId}`);
             continue;
         }
         const { imagePositionPatient } = imagePlaneModule;
@@ -46,7 +47,7 @@ export default function getClosestImageId(imageVolume, worldPos, viewPlaneNormal
         }
     }
     if (closestImageId === undefined) {
-        console.debug('No imageId found within the specified criteria (half spacing or absolute closest).');
+        log.warn('No imageId found within the specified criteria (half spacing or absolute closest).');
     }
     return closestImageId;
 }

package/dist/esm/utilities/getScalingParameters.js

@@ -8,13 +8,19 @@ export default function getScalingParameters(imageId) {
         rescaleIntercept: modalityLutModule.rescaleIntercept ?? 0,
         modality,
     };
-    const suvFactor = metaData.get('scalingModule', imageId) || {};
+    const scalingModules = metaData.get('scalingModule', imageId) || {};
     return {
         ...scalingParameters,
         ...(modality === 'PT' && {
-            suvbw: suvFactor.suvbw,
-            suvbsa: suvFactor.suvbsa,
-            suvlbm: suvFactor.suvlbm,
+            suvbw: scalingModules.suvbw,
+            suvbsa: scalingModules.suvbsa,
+            suvlbm: scalingModules.suvlbm,
+        }),
+        ...(modality === 'RTDOSE' && {
+            doseGridScaling: scalingModules.DoseGridScaling,
+            doseSummation: scalingModules.DoseSummation,
+            doseType: scalingModules.DoseType,
+            doseUnit: scalingModules.DoseUnit,
         }),
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "3.10.31",
+  "version": "3.11.1",
   "description": "Cornerstone3D Core",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -91,5 +91,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "f7d656d8b175c3ff00b145cdd5ceedf910afeda1"
+  "gitHead": "9e71e94884bd1c8734911b98ac67a5676fcaaecb"
 }