@ohif/app 3.9.1 → 3.9.2

package/dist/{5717.bundle.848e13f256818475f57f.js → 5717.bundle.32836c212103dbbe8e4a.js}

@@ -3489,6 +3489,15 @@ const imageRetrieveMetadataProvider = {
     add: (key, payload) => {
         retrieveConfigurationState.set(key, payload);
     },
+    clone: () => {
+        return new Map(retrieveConfigurationState);
+    },
+    restore: (state) => {
+        retrieveConfigurationState.clear();
+        state.forEach((value, key) => {
+            retrieveConfigurationState.set(key, value);
+        });
+    },
     get: (type, ...queries) => {
         if (type === IMAGE_RETRIEVE_CONFIGURATION) {
             return queries
@@ -4414,7 +4423,10 @@ function calculateViewportsSpatialRegistration(viewport1, viewport2) {
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/getViewportImageCornersInWorld.js
 function getViewportImageCornersInWorld(viewport) {
-    const { imageData, dimensions } = viewport.getImageData();
+    const { imageData, dimensions } = viewport.getImageData() || {};
+    if (!imageData || !dimensions) {
+        return [];
+    }
     const { canvas } = viewport;
     const ratio = window.devicePixelRatio;
     const topLeftCanvas = [0, 0];
@@ -9322,6 +9334,9 @@ class Synchronizer_Synchronizer {
         };
         viewports.forEach((vp) => {
             const eventSource = this.getEventSource(vp);
+            if (!eventSource) {
+                return;
+            }
             eventSource.removeEventListener(Enums.Events.ELEMENT_DISABLED, disableHandler);
             eventSource.addEventListener(Enums.Events.ELEMENT_DISABLED, disableHandler);
         });
@@ -9335,9 +9350,13 @@ class Synchronizer_Synchronizer {
         const { renderingEngineId, viewportId } = viewportInfo;
         const renderingEngine = getRenderingEngine(renderingEngineId);
         if (!renderingEngine) {
-            throw new Error(`No RenderingEngine for Id: ${renderingEngineId}`);
+            return null;
+        }
+        const viewport = renderingEngine.getViewport(viewportId);
+        if (!viewport) {
+            return null;
         }
-        return renderingEngine.getViewport(viewportId).element;
+        return viewport.element;
     }
 }
 function _getUniqueViewports(vp1, vp2) {
@@ -11710,16 +11729,10 @@ class CrosshairsTool extends base/* AnnotationTool */.EC {
             return otherViewportsAnnotationsWithUniqueCameras;
         };
         this._checkIfViewportsRenderingSameScene = (viewport, otherViewport) => {
-            const actors = viewport.getActors();
-            const otherViewportActors = otherViewport.getActors();
-            let sameScene = true;
-            actors.forEach((actor) => {
-                if (actors.length !== otherViewportActors.length ||
-                    otherViewportActors.find(({ uid }) => uid === actor.uid) === undefined) {
-                    sameScene = false;
-                }
-            });
-            return sameScene;
+            const volumeIds = viewport.getAllVolumeIds();
+            const otherVolumeIds = otherViewport.getAllVolumeIds();
+            return (volumeIds.length === otherVolumeIds.length &&
+                volumeIds.every((id) => otherVolumeIds.includes(id)));
         };
         this._jump = (enabledElement, jumpWorld) => {
             store_state/* state */.wk.isInteractingWithTool = true;
@@ -14368,7 +14381,7 @@ class ScaleOverlayTool extends AnnotationDisplayTool/* default */.A {
             }
             const { viewUp, viewPlaneNormal } = viewport.getCamera();
             const viewportCanvasCornersInWorld = esm.utilities.getViewportImageCornersInWorld(viewport);
-            let annotation = this.editData.annotation;
+            let annotation = this.editData?.annotation;
             const annotations = (0,annotationState.getAnnotations)(this.getToolName(), viewport.element);
             if (annotations.length) {
                 annotation = annotations.filter((thisAnnotation) => thisAnnotation.data.viewportId == viewport.id)[0];
@@ -14396,7 +14409,7 @@ class ScaleOverlayTool extends AnnotationDisplayTool/* default */.A {
                     annotation = newAnnotation;
                 }
             });
-            if (this.editData.annotation &&
+            if (this.editData?.annotation &&
                 this.editData.annotation.data.viewportId == viewport.id) {
                 this.editData.annotation.data.handles.points =
                     viewportCanvasCornersInWorld;
@@ -14611,7 +14624,7 @@ class ScaleOverlayTool extends AnnotationDisplayTool/* default */.A {
         };
     }
     renderAnnotation(enabledElement, svgDrawingHelper) {
-        if (!this.editData.viewport) {
+        if (!this.editData || !this.editData.viewport) {
             return;
         }
         const location = this.configuration.scaleLocation;
@@ -15117,7 +15130,7 @@ class LengthTool extends base/* AnnotationTool */.EC {
             const { currentPoints, element } = eventDetail;
             const worldPos = currentPoints.world;
             const enabledElement = (0,esm.getEnabledElement)(element);
-            const { viewport, renderingEngine } = enabledElement;
+            const { viewport } = enabledElement;
             (0,elementCursor.hideElementCursor)(element);
             this.isDrawing = true;
             const { viewPlaneNormal, viewUp, position: cameraPosition, } = viewport.getCamera();
@@ -15432,6 +15445,39 @@ class LengthTool extends base/* AnnotationTool */.EC {
         };
         this._throttledCalculateCachedStats = (0,throttle/* default */.A)(this._calculateCachedStats, 100, { trailing: true });
     }
+    static { this.hydrate = (viewportId, points, options) => {
+        const enabledElement = (0,esm.getEnabledElementByViewportId)(viewportId);
+        if (!enabledElement) {
+            return;
+        }
+        const { viewport } = enabledElement;
+        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+        const { viewPlaneNormal, viewUp } = viewport.getCamera();
+        const instance = new this();
+        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const annotation = {
+            annotationUID: options?.annotationUID || esm.utilities.uuidv4(),
+            data: {
+                handles: {
+                    points,
+                },
+            },
+            highlighted: false,
+            autoGenerated: false,
+            invalidated: false,
+            isLocked: false,
+            isVisible: true,
+            metadata: {
+                toolName: instance.getToolName(),
+                viewPlaneNormal,
+                FrameOfReferenceUID,
+                referencedImageId,
+                ...options,
+            },
+        };
+        (0,annotationState.addAnnotation)(annotation, viewport.element);
+        (0,triggerAnnotationRenderForViewportIds/* default */.A)([viewport.id]);
+    }; }
     handleSelectedCallback(evt, annotation, handle) {
         const eventDetail = evt.detail;
         const { element } = eventDetail;
@@ -16176,6 +16222,39 @@ class ProbeTool extends base/* AnnotationTool */.EC {
         return false;
     }
     toolSelectedCallback() { }
+    static { this.hydrate = (viewportId, points, options) => {
+        const enabledElement = (0,esm.getEnabledElementByViewportId)(viewportId);
+        if (!enabledElement) {
+            return;
+        }
+        const { viewport } = enabledElement;
+        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+        const { viewPlaneNormal, viewUp } = viewport.getCamera();
+        const instance = new this();
+        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const annotation = {
+            annotationUID: options?.annotationUID || esm.utilities.uuidv4(),
+            data: {
+                handles: {
+                    points,
+                },
+            },
+            highlighted: false,
+            autoGenerated: false,
+            invalidated: false,
+            isLocked: false,
+            isVisible: true,
+            metadata: {
+                toolName: instance.getToolName(),
+                viewPlaneNormal,
+                FrameOfReferenceUID,
+                referencedImageId,
+                ...options,
+            },
+        };
+        (0,annotationState.addAnnotation)(annotation, viewport.element);
+        (0,triggerAnnotationRenderForViewportIds/* default */.A)([viewport.id]);
+    }; }
     getHandleNearImagePoint(element, annotation, canvasCoords, proximity) {
         const enabledElement = (0,esm.getEnabledElement)(element);
         const { viewport } = enabledElement;
@@ -17665,6 +17744,52 @@ class CircleROITool extends base/* AnnotationTool */.EC {
         };
         this._throttledCalculateCachedStats = (0,throttle/* default */.A)(this._calculateCachedStats, 100, { trailing: true });
     }
+    static { this.hydrate = (viewportId, points, options) => {
+        const enabledElement = (0,esm.getEnabledElementByViewportId)(viewportId);
+        if (!enabledElement) {
+            return;
+        }
+        const { viewport } = enabledElement;
+        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+        const { viewPlaneNormal, viewUp } = viewport.getCamera();
+        const instance = new this();
+        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const annotation = {
+            annotationUID: options?.annotationUID || esm.utilities.uuidv4(),
+            data: {
+                handles: {
+                    points,
+                    textBox: {
+                        hasMoved: false,
+                        worldPosition: [0, 0, 0],
+                        worldBoundingBox: {
+                            topLeft: [0, 0, 0],
+                            topRight: [0, 0, 0],
+                            bottomLeft: [0, 0, 0],
+                            bottomRight: [0, 0, 0],
+                        },
+                    },
+                    activeHandleIndex: null,
+                },
+                label: '',
+                cachedStats: {},
+            },
+            highlighted: false,
+            autoGenerated: false,
+            invalidated: false,
+            isLocked: false,
+            isVisible: true,
+            metadata: {
+                toolName: instance.getToolName(),
+                viewPlaneNormal,
+                FrameOfReferenceUID,
+                referencedImageId,
+                ...options,
+            },
+        };
+        (0,annotationState.addAnnotation)(annotation, viewport.element);
+        (0,triggerAnnotationRenderForViewportIds/* default */.A)([viewport.id]);
+    }; }
 }
 function CircleROITool_defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
@@ -18185,8 +18310,6 @@ class SplineROITool extends ContourSegmentationBaseTool/* default */.A {
                 viewportIdsToRender,
                 movingTextBox: false,
             };
-            const enabledElement = (0,esm.getEnabledElement)(element);
-            const { renderingEngine } = enabledElement;
             this._activateModify(element);
             (0,esm_utilities.triggerAnnotationRenderForViewportIds)(viewportIdsToRender);
             evt.preventDefault();
@@ -18780,6 +18903,61 @@ class SplineROITool extends ContourSegmentationBaseTool/* default */.A {
         }
         return spline;
     }
+    static { this.hydrate = (viewportId, points, options) => {
+        const enabledElement = (0,esm.getEnabledElementByViewportId)(viewportId);
+        if (!enabledElement) {
+            return;
+        }
+        if (points.length < SPLINE_MIN_POINTS) {
+            console.warn('Spline requires at least 3 control points');
+            return;
+        }
+        const { viewport } = enabledElement;
+        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+        const { viewPlaneNormal, viewUp } = viewport.getCamera();
+        const instance = new this();
+        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const splineType = options?.splineType || SplineTypesEnum.CatmullRom;
+        const splineConfig = instance._getSplineConfig(splineType);
+        const SplineClass = splineConfig.Class;
+        const splineInstance = new SplineClass();
+        const canvasPoints = points.map((point) => viewport.worldToCanvas(point));
+        splineInstance.setControlPoints(canvasPoints);
+        const splinePolylineCanvas = splineInstance.getPolylinePoints();
+        const splinePolylineWorld = splinePolylineCanvas.map((point) => viewport.canvasToWorld(point));
+        const annotation = {
+            annotationUID: options?.annotationUID || esm.utilities.uuidv4(),
+            data: {
+                handles: {
+                    points,
+                },
+                label: '',
+                cachedStats: {},
+                spline: {
+                    type: splineType,
+                    instance: splineInstance,
+                },
+                contour: {
+                    closed: true,
+                    polyline: splinePolylineWorld,
+                },
+            },
+            highlighted: false,
+            autoGenerated: false,
+            invalidated: true,
+            isLocked: false,
+            isVisible: true,
+            metadata: {
+                toolName: instance.getToolName(),
+                viewPlaneNormal,
+                FrameOfReferenceUID,
+                referencedImageId,
+                ...options,
+            },
+        };
+        (0,annotationState.addAnnotation)(annotation, viewport.element);
+        (0,esm_utilities.triggerAnnotationRenderForViewportIds)([viewport.id]);
+    }; }
 }
 function SplineROITool_defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
@@ -25768,7 +25946,7 @@ class SegmentationStateManager {
             type,
             active: true,
             visible: true,
-            colorLUTIndex: 0,
+            colorLUTIndex: renderingConfig?.colorLUTIndex || 0,
             segments: segmentReps,
             config: {
                 ...getDefaultRenderingConfig(type),
@@ -26491,17 +26669,20 @@ function internalAddSegmentationRepresentation(viewportId, representationInput)
 }
 function getColorLUTIndex(config) {
     const { colorLUTOrIndex } = config || {};
-    const isIndexProvided = typeof colorLUTOrIndex === 'number';
-    const selectedColorLUT = isIndexProvided
-        ? (0,getColorLUT/* getColorLUT */.B)(colorLUTOrIndex)
-        : COLOR_LUT/* default */.A;
-    const colorLUTIndex = isIndexProvided
-        ? colorLUTOrIndex
-        : (0,getNextColorLUTIndex/* getNextColorLUTIndex */.u)();
-    if (!isIndexProvided) {
-        (0,addColorLUT/* addColorLUT */.u)(selectedColorLUT, colorLUTIndex);
+    if (colorLUTOrIndex === undefined) {
+        const index = (0,addColorLUT/* addColorLUT */.u)(JSON.parse(JSON.stringify(COLOR_LUT/* default */.A)));
+        return index;
+    }
+    if (typeof colorLUTOrIndex === 'number') {
+        return colorLUTOrIndex;
     }
-    return colorLUTIndex;
+    if (Array.isArray(colorLUTOrIndex) &&
+        colorLUTOrIndex.every((item) => Array.isArray(item) && item.length === 4)) {
+        const index = (0,addColorLUT/* addColorLUT */.u)(colorLUTOrIndex);
+        return index;
+    }
+    const index = (0,addColorLUT/* addColorLUT */.u)(JSON.parse(JSON.stringify(COLOR_LUT/* default */.A)));
+    return index;
 }
 
 
@@ -26796,23 +26977,6 @@ function getActiveSegmentation(viewportId) {
 }
 
 
-/***/ }),
-
-/***/ 50409:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-"use strict";
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   B: () => (/* binding */ getColorLUT)
-/* harmony export */ });
-/* harmony import */ var _SegmentationStateManager__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(59475);
-
-function getColorLUT(index) {
-    const segmentationStateManager = _SegmentationStateManager__WEBPACK_IMPORTED_MODULE_0__/* .defaultSegmentationStateManager */ ._6;
-    return segmentationStateManager.getColorLUT(index);
-}
-
-
 /***/ }),
 
 /***/ 97577:
@@ -26830,23 +26994,6 @@ function getCurrentLabelmapImageIdForViewport(viewportId, segmentationId) {
 }
 
 
-/***/ }),
-
-/***/ 70906:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-"use strict";
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   u: () => (/* binding */ getNextColorLUTIndex)
-/* harmony export */ });
-/* harmony import */ var _SegmentationStateManager__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(59475);
-
-function getNextColorLUTIndex() {
-    const segmentationStateManager = _SegmentationStateManager__WEBPACK_IMPORTED_MODULE_0__/* .defaultSegmentationStateManager */ ._6;
-    return segmentationStateManager.getNextColorLUTIndex();
-}
-
-
 /***/ }),
 
 /***/ 93210:
@@ -30844,6 +30991,42 @@ class RectangleROITool extends _base__WEBPACK_IMPORTED_MODULE_0__/* .AnnotationT
         };
         this._throttledCalculateCachedStats = (0,_utilities_throttle__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A)(this._calculateCachedStats, 100, { trailing: true });
     }
+    static { this.hydrate = (viewportId, points, options) => {
+        const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElementByViewportId)(viewportId);
+        if (!enabledElement) {
+            return;
+        }
+        const { viewport } = enabledElement;
+        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+        const { viewPlaneNormal, viewUp } = viewport.getCamera();
+        const instance = new this();
+        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const annotation = {
+            annotationUID: options?.annotationUID || _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.utilities.uuidv4(),
+            data: {
+                handles: {
+                    points,
+                    activeHandleIndex: null,
+                },
+                label: '',
+                cachedStats: {},
+            },
+            highlighted: false,
+            autoGenerated: false,
+            invalidated: false,
+            isLocked: false,
+            isVisible: true,
+            metadata: {
+                toolName: instance.getToolName(),
+                viewPlaneNormal,
+                FrameOfReferenceUID,
+                referencedImageId,
+                ...options,
+            },
+        };
+        (0,_stateManagement__WEBPACK_IMPORTED_MODULE_4__/* .addAnnotation */ .lC)(annotation, viewport.element);
+        (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_16__/* ["default"] */ .A)([viewport.id]);
+    }; }
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];

package/dist/{7197.bundle.c28453cdb392072d8bf8.js → 7197.bundle.42a975bb7ae4a8df2d00.js}

@@ -345,8 +345,8 @@ function getHangingProtocolModule() {
 }
 /* harmony default export */ const src_getHangingProtocolModule = (getHangingProtocolModule);
 
-// EXTERNAL MODULE: ../../../extensions/default/src/index.ts + 114 modules
-var default_src = __webpack_require__(71520);
+// EXTERNAL MODULE: ../../../extensions/default/src/index.ts + 115 modules
+var default_src = __webpack_require__(55630);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Filters/General/ImageMarchingSquares.js + 2 modules
 var ImageMarchingSquares = __webpack_require__(38993);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/DataArray.js

package/dist/{7955.bundle.6a255705b1ef5906f4a8.js → 7955.bundle.f6c5edb284bdf8b80f2a.js}

@@ -694,7 +694,7 @@ function modeFactory({
           lesionStats: 'Lesion Statistics',
           minValue: 'Minimum Value',
           maxValue: 'Maximum Value',
-          meanValue: 'Mean Value',
+          meanValue: 'Mean Value (ml)',
           volume: 'Volume',
           suvPeak: 'SUV Peak',
           suvMax: 'Maximum SUV',

package/dist/{8228.bundle.55ac03d7165248f47d4e.js → 8228.bundle.0a7997d04c82dd8c11c5.js}

@@ -19,8 +19,8 @@ var prop_types = __webpack_require__(97598);
 var prop_types_default = /*#__PURE__*/__webpack_require__.n(prop_types);
 // EXTERNAL MODULE: ../../ui/src/index.js + 690 modules
 var src = __webpack_require__(35647);
-// EXTERNAL MODULE: ../../../extensions/default/src/index.ts + 114 modules
-var default_src = __webpack_require__(71520);
+// EXTERNAL MODULE: ../../../extensions/default/src/index.ts + 115 modules
+var default_src = __webpack_require__(55630);
 ;// CONCATENATED MODULE: ../../../extensions/dicom-microscopy/src/DicomMicroscopyViewport.css
 // extracted by mini-css-extract-plugin
 

package/dist/{8523.bundle.648334132159465cdc41.js → 8523.bundle.c0ec85de98ba380ebeb4.js}

@@ -933,7 +933,7 @@ class BaseVolumeViewport extends _Viewport__WEBPACK_IMPORTED_MODULE_18__/* ["def
         sliceIndex ??= currentIndex;
         const { viewPlaneNormal, focalPoint } = this.getCamera();
         const querySeparator = volumeId.includes('?') ? '&' : '?';
-        return `volumeId:${volumeId}${querySeparator}sliceIndex=${sliceIndex}&viewPlaneNormal=${viewPlaneNormal.join(',')}&focalPoint=${focalPoint.join(',')}`;
+        return `volumeId:${volumeId}${querySeparator}sliceIndex=${sliceIndex}&viewPlaneNormal=${viewPlaneNormal.join(',')}`;
     }
     _addVolumeId(volumeId) {
         this.volumeIds.add(volumeId);
@@ -16552,6 +16552,12 @@ var cache = __webpack_require__(49038);
 
 
 
+function convertDataType(data, targetDataType) {
+    const Constructor = (0,getBufferConfiguration/* getConstructorFromType */.j)(targetDataType);
+    const convertedData = new Constructor(data.length);
+    convertedData.set(data);
+    return convertedData;
+}
 function vtkStreamingOpenGLTexture(publicAPI, model) {
     model.classHierarchy.push('vtkStreamingOpenGLTexture');
     model.updatedFrames = [];
@@ -16602,10 +16608,14 @@ function vtkStreamingOpenGLTexture(publicAPI, model) {
                 if (!image) {
                     continue;
                 }
-                const data = image.voxelManager.getScalarData();
+                let data = image.voxelManager.getScalarData();
                 const gl = model.context;
-                const dataType = data.constructor.name;
-                const [pixData] = publicAPI.updateArrayDataTypeForGL(dataType, [data]);
+                if (volume.dataType !== data.constructor.name) {
+                    data = convertDataType(data, volume.dataType);
+                }
+                const [pixData] = publicAPI.updateArrayDataTypeForGL(volume.dataType, [
+                    data,
+                ]);
                 publicAPI.bind();
                 const zOffset = i;
                 gl.texSubImage3D(model.target, 0, 0, 0, zOffset, model.width, model.height, 1, model.format, model.openGLDataType, pixData);
@@ -16639,8 +16649,12 @@ function vtkStreamingOpenGLTexture(publicAPI, model) {
                 constructor = data.constructor;
             }
             const gl = model.context;
-            const dataType = data.constructor.name;
-            const [pixData] = publicAPI.updateArrayDataTypeForGL(dataType, [data]);
+            if (volume.dataType !== data.constructor.name) {
+                data = convertDataType(data, volume.dataType);
+            }
+            const [pixData] = publicAPI.updateArrayDataTypeForGL(volume.dataType, [
+                data,
+            ]);
             publicAPI.bind();
             let zOffset = i;
             gl.texSubImage3D(model.target, 0, 0, 0, zOffset, model.width, model.height, 1, model.format, model.openGLDataType, pixData);
@@ -22061,12 +22075,20 @@ const deepMerge = (target = {}, source = {}, optionsArgument = undefined) => {
 /* harmony import */ var _getScalingParameters__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(32173);
 /* harmony import */ var _hasFloatScalingParameters__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(30169);
 /* harmony import */ var _init__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(59693);
+/* harmony import */ var _cache_cache__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(49038);
+
 
 
 
 
 
 
+const constructorToTypedArray = {
+    Uint8Array: 'Uint8Array',
+    Int16Array: 'Int16Array',
+    Uint16Array: 'Uint16Array',
+    Float32Array: 'Float32Array',
+};
 function generateVolumePropsFromImageIds(imageIds, volumeId) {
     const volumeMetadata = (0,_makeVolumeMetadata__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(imageIds);
     const { ImageOrientationPatient, PixelSpacing, Columns, Rows } = volumeMetadata;
@@ -22099,6 +22121,10 @@ function generateVolumePropsFromImageIds(imageIds, volumeId) {
 function _determineDataType(imageIds, volumeMetadata) {
     const { BitsAllocated, PixelRepresentation } = volumeMetadata;
     const signed = PixelRepresentation === 1;
+    const cachedDataType = _getDataTypeFromCache(imageIds);
+    if (cachedDataType) {
+        return cachedDataType;
+    }
     const [firstIndex, middleIndex, lastIndex] = [
         0,
         Math.floor(imageIds.length / 2),
@@ -22133,6 +22159,19 @@ function _determineDataType(imageIds, volumeMetadata) {
             throw new Error(`Bits allocated of ${BitsAllocated} is not defined to generate scalarData for the volume.`);
     }
 }
+function _getDataTypeFromCache(imageIds) {
+    const indices = [0, Math.floor(imageIds.length / 2), imageIds.length - 1];
+    const images = indices.map((i) => _cache_cache__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .Ay.getImage(imageIds[i]));
+    if (!images.every(Boolean)) {
+        return null;
+    }
+    const constructorName = images[0].getPixelData().constructor.name;
+    if (images.every((img) => img.getPixelData().constructor.name === constructorName) &&
+        constructorName in constructorToTypedArray) {
+        return constructorToTypedArray[constructorName];
+    }
+    return null;
+}
 
 
 
@@ -54877,7 +54916,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     }
     return result;
   };
-  publicAPI.useHalfFloat = () => model.enableHalfFloat && model.canUseHalfFloat;
+  publicAPI.useHalfFloat = () => model.enableUseHalfFloat && model.canUseHalfFloat;
 
   //----------------------------------------------------------------------------
   publicAPI.setInternalFormat = iFormat => {
@@ -55511,18 +55550,21 @@ function vtkOpenGLTexture(publicAPI, model) {
   }
   function setCanUseHalfFloat(dataType, offset, scale, preferSizeOverAccuracy) {
     publicAPI.getOpenGLDataType(dataType);
+
+    // Don't consider halfFloat and convert back to Float when the range of data does not generate an accurate halfFloat
+    // AND it is not preferable to have a smaller texture than an exact texture.
+    const isExactHalfFloat = hasExactHalfFloat(offset, scale) || preferSizeOverAccuracy;
     let useHalfFloat = false;
     if (model._openGLRenderWindow.getWebgl2()) {
-      useHalfFloat = model.openGLDataType === model.context.HALF_FLOAT;
+      // If OES_texture_float_linear is not available, and using a half float would still be exact, force half floats
+      // This is because half floats are always texture filterable in webgl2, while full *32F floats are not (unless the extension is present)
+      const forceHalfFloat = model.openGLDataType === model.context.FLOAT && model.context.getExtension('OES_texture_float_linear') === null && isExactHalfFloat;
+      useHalfFloat = forceHalfFloat || model.openGLDataType === model.context.HALF_FLOAT;
     } else {
       const halfFloatExt = model.context.getExtension('OES_texture_half_float');
       useHalfFloat = halfFloatExt && model.openGLDataType === halfFloatExt.HALF_FLOAT_OES;
     }
-
-    // Don't consider halfFloat and convert back to Float when the range of data does not generate an accurate halfFloat
-    // AND it is not preferable to have a smaller texture than an exact texture.
-    const isHalfFloat = useHalfFloat && (hasExactHalfFloat(offset, scale) || preferSizeOverAccuracy);
-    model.canUseHalfFloat = isHalfFloat;
+    model.canUseHalfFloat = useHalfFloat && isExactHalfFloat;
   }
   function processDataArray(dataArray, preferSizeOverAccuracy) {
     const numComps = dataArray.getNumberOfComponents();

package/dist/{9551.bundle.6c260a9869e14dcc3543.js → 9551.bundle.63b2679dd7beee6396d8.js}

@@ -632,7 +632,7 @@ function modeFactory({
           minValue: 'Minimum Value',
           maxValue: 'Maximum Value',
           meanValue: 'Mean Value',
-          volume: 'Volume',
+          volume: 'Volume (ml)',
           suvPeak: 'SUV Peak',
           suvMax: 'Maximum SUV',
           suvMaxIJK: 'SUV Max IJK',