@ohif/app 3.9.0-beta.23 → 3.9.0-beta.24

package/dist/{501.bundle.7d5003758fa3ffbb344b.js → 501.bundle.3dcc63f03d9c252a9bee.js}

@@ -8345,9 +8345,7 @@ async function createVolumeActor(props, element, viewportId, suppressEvents = fa
     if (numberOfComponents === 3) {
         volumeActor.getProperty().setIndependentComponents(false);
     }
-    if (imageVolume.imageIds?.length) {
-        await (0,setDefaultVolumeVOI/* default */.A)(volumeActor, imageVolume, useNativeDataType);
-    }
+    await (0,setDefaultVolumeVOI/* default */.A)(volumeActor, imageVolume, useNativeDataType);
     if (callback) {
         callback({ volumeActor, volumeId });
     }
@@ -8438,21 +8436,19 @@ const PRIORITY = 0;
 const REQUEST_TYPE = _enums__WEBPACK_IMPORTED_MODULE_3__.RequestType.Prefetch;
 async function setDefaultVolumeVOI(volumeActor, imageVolume, useNativeDataType) {
     let voi = getVOIFromMetadata(imageVolume);
-    if (!voi) {
+    if (!voi && imageVolume?.imageIds?.length) {
         voi = await getVOIFromMinMax(imageVolume, useNativeDataType);
+        voi = handlePreScaledVolume(imageVolume, voi);
     }
-    if (!voi || voi.lower === undefined || voi.upper === undefined) {
-        throw new Error('Could not get VOI from metadata, nor from the min max of the image middle slice');
-    }
-    voi = handlePreScaledVolume(imageVolume, voi);
-    const { lower, upper } = voi;
-    if (lower === 0 && upper === 0) {
+    if ((voi?.lower === 0 && voi?.upper === 0) ||
+        voi?.lower === undefined ||
+        voi?.upper === undefined) {
         return;
     }
     volumeActor
         .getProperty()
         .getRGBTransferFunction(0)
-        .setMappingRange(lower, upper);
+        .setMappingRange(voi.lower, voi.upper);
 }
 function handlePreScaledVolume(imageVolume, voi) {
     const imageIds = imageVolume.imageIds;
@@ -8468,18 +8464,26 @@ function handlePreScaledVolume(imageVolume, voi) {
     return voi;
 }
 function getVOIFromMetadata(imageVolume) {
-    const { imageIds } = imageVolume;
-    const imageIdIndex = Math.floor(imageIds.length / 2);
-    const imageId = imageIds[imageIdIndex];
-    const voiLutModule = _metaData__WEBPACK_IMPORTED_MODULE_1__.get('voiLutModule', imageId);
-    if (voiLutModule && voiLutModule.windowWidth && voiLutModule.windowCenter) {
-        const { windowWidth, windowCenter } = voiLutModule;
-        const voi = {
-            windowWidth: Array.isArray(windowWidth) ? windowWidth[0] : windowWidth,
-            windowCenter: Array.isArray(windowCenter)
-                ? windowCenter[0]
-                : windowCenter,
-        };
+    const { imageIds, metadata } = imageVolume;
+    let voi;
+    if (imageIds.length) {
+        const imageIdIndex = Math.floor(imageIds.length / 2);
+        const imageId = imageIds[imageIdIndex];
+        const voiLutModule = _metaData__WEBPACK_IMPORTED_MODULE_1__.get('voiLutModule', imageId);
+        if (voiLutModule && voiLutModule.windowWidth && voiLutModule.windowCenter) {
+            const { windowWidth, windowCenter } = voiLutModule;
+            voi = {
+                windowWidth: Array.isArray(windowWidth) ? windowWidth[0] : windowWidth,
+                windowCenter: Array.isArray(windowCenter)
+                    ? windowCenter[0]
+                    : windowCenter,
+            };
+        }
+    }
+    else {
+        voi = metadata?.voiLut?.[0];
+    }
+    if (voi) {
         const { lower, upper } = _utilities__WEBPACK_IMPORTED_MODULE_2__.windowLevel.toLowHighRange(Number(voi.windowWidth), Number(voi.windowCenter));
         return {
             lower,
@@ -8542,13 +8546,13 @@ async function getVOIFromMinMax(imageVolume, useNativeDataType) {
 }
 function _getImageScalarDataFromImageVolume(imageVolume, byteOffset, bytePerPixel, voxelsPerImage) {
     const { scalarData } = imageVolume;
-    const { volumeBuffer } = scalarData;
+    const { buffer } = scalarData;
     if (scalarData.BYTES_PER_ELEMENT !== bytePerPixel) {
         byteOffset *= scalarData.BYTES_PER_ELEMENT / bytePerPixel;
     }
     const TypedArray = scalarData.constructor;
     const imageScalarData = new TypedArray(voxelsPerImage);
-    const volumeBufferView = new TypedArray(volumeBuffer, byteOffset, voxelsPerImage);
+    const volumeBufferView = new TypedArray(buffer, byteOffset, voxelsPerImage);
     imageScalarData.set(volumeBufferView);
     return imageScalarData;
 }
@@ -25644,23 +25648,28 @@ const isPTPrescaledWithSUV = (image) => {
 
 
 
-function renderToCanvasGPU(canvas, image, modality = undefined, renderingEngineId = '_thumbnails', viewportOptions = { displayArea: { imageArea: [1, 1] } }) {
+function renderToCanvasGPU(canvas, imageOrVolume, modality = undefined, renderingEngineId = '_thumbnails', viewportOptions = {
+    displayArea: { imageArea: [1, 1] },
+}) {
     if (!canvas || !(canvas instanceof HTMLCanvasElement)) {
         throw new Error('canvas element is required');
     }
-    const imageIdToPrint = image.imageId;
+    const isVolume = !imageOrVolume.imageId;
+    const image = !isVolume && imageOrVolume;
+    const volume = isVolume && imageOrVolume;
+    const imageIdToPrint = image?.imageId || volume?.volumeId;
     const viewportId = `renderGPUViewport-${imageIdToPrint}`;
-    const imageId = image.imageId;
     const element = document.createElement('div');
     const devicePixelRatio = window.devicePixelRatio || 1;
+    if (!viewportOptions.displayArea) {
+        viewportOptions.displayArea = { imageArea: [1, 1] };
+    }
     const originalWidth = canvas.width;
     const originalHeight = canvas.height;
-    element.style.width = `${originalWidth + getOrCreateCanvas/* EPSILON */.p8}px`;
-    element.style.height = `${originalHeight + getOrCreateCanvas/* EPSILON */.p8}px`;
+    element.style.width = `${originalWidth / devicePixelRatio + getOrCreateCanvas/* EPSILON */.p8}px`;
+    element.style.height = `${originalHeight / devicePixelRatio + getOrCreateCanvas/* EPSILON */.p8}px`;
     element.style.visibility = 'hidden';
     element.style.position = 'absolute';
-    canvas.width = originalWidth * devicePixelRatio;
-    canvas.height = originalHeight * devicePixelRatio;
     document.body.appendChild(element);
     const uniqueId = viewportId.split(':').join('-');
     element.setAttribute('viewport-id-for-remove', uniqueId);
@@ -25669,26 +25678,44 @@ function renderToCanvasGPU(canvas, image, modality = undefined, renderingEngineI
         new RenderingEngine/* default */.Ay(renderingEngineId);
     let viewport = renderingEngine.getViewport(viewportId);
     if (!viewport) {
-        const stackViewportInput = {
+        const viewportInput = {
             viewportId,
-            type: enums.ViewportType.STACK,
+            type: isVolume ? enums.ViewportType.ORTHOGRAPHIC : enums.ViewportType.STACK,
             element,
             defaultOptions: {
                 ...viewportOptions,
                 suppressEvents: true,
             },
         };
-        renderingEngine.enableElement(stackViewportInput);
+        renderingEngine.enableElement(viewportInput);
         viewport = renderingEngine.getViewport(viewportId);
     }
     return new Promise((resolve) => {
         let elementRendered = false;
+        let { viewReference } = viewportOptions;
         const onImageRendered = (eventDetail) => {
             if (elementRendered) {
                 return;
             }
+            if (viewReference) {
+                const useViewRef = viewReference;
+                viewReference = null;
+                viewport.setViewReference(useViewRef);
+                viewport.render();
+                return;
+            }
             const context = canvas.getContext('2d');
             context.drawImage(temporaryCanvas, 0, 0, temporaryCanvas.width, temporaryCanvas.height, 0, 0, canvas.width, canvas.height);
+            const origin = viewport.canvasToWorld([0, 0]);
+            const topRight = viewport.canvasToWorld([
+                temporaryCanvas.width / devicePixelRatio,
+                0,
+            ]);
+            const bottomLeft = viewport.canvasToWorld([
+                0,
+                temporaryCanvas.height / devicePixelRatio,
+            ]);
+            const thicknessMm = 1;
             elementRendered = true;
             element.removeEventListener(enums.Events.IMAGE_RENDERED, onImageRendered);
             setTimeout(() => {
@@ -25698,10 +25725,20 @@ function renderToCanvasGPU(canvas, image, modality = undefined, renderingEngineI
                     element.remove();
                 });
             }, 0);
-            resolve(imageId);
+            resolve({
+                origin,
+                bottomLeft,
+                topRight,
+                thicknessMm,
+            });
         };
         element.addEventListener(enums.Events.IMAGE_RENDERED, onImageRendered);
-        viewport.renderImageObject(image);
+        if (isVolume) {
+            viewport.setVolumes([volume], false, true);
+        }
+        else {
+            viewport.renderImageObject(imageOrVolume);
+        }
         viewport.resetCamera();
         if (modality === 'PT' && !utilities_isPTPrescaledWithSUV(image)) {
             viewport.setProperties({
@@ -25725,7 +25762,12 @@ var drawImageSync = __webpack_require__(49892);
 
 
 
-function renderToCanvasCPU(canvas, image, modality, _renderingEngineId, _viewportOptions) {
+function renderToCanvasCPU(canvas, imageOrVolume, modality, _renderingEngineId, _viewportOptions) {
+    const volume = imageOrVolume;
+    if (volume.volumeId) {
+        throw new Error('Unsupported volume rendering for CPU');
+    }
+    const image = imageOrVolume;
     const viewport = (0,getDefaultViewport/* default */.A)(canvas, image, modality);
     const enabledElement = {
         canvas,
@@ -25737,7 +25779,7 @@ function renderToCanvasCPU(canvas, image, modality, _renderingEngineId, _viewpor
     const invalidated = true;
     return new Promise((resolve, reject) => {
         (0,drawImageSync/* default */.A)(enabledElement, invalidated);
-        resolve(image.imageId);
+        resolve(null);
     });
 }
 
@@ -25749,28 +25791,36 @@ function renderToCanvasCPU(canvas, image, modality, _renderingEngineId, _viewpor
 
 
 
+
 function loadImageToCanvas(options) {
-    const { canvas, imageId, requestType = enums.RequestType.Thumbnail, priority = -5, renderingEngineId = '_thumbnails', useCPURendering = false, thumbnail = false, imageAspect = false, physicalPixels = false, viewportOptions, } = options;
-    const devicePixelRatio = window.devicePixelRatio || 1;
+    const { canvas, imageId, viewReference, requestType = enums.RequestType.Thumbnail, priority = -5, renderingEngineId = '_thumbnails', useCPURendering = false, thumbnail = false, imageAspect = false, viewportOptions: baseViewportOptions, } = options;
+    const volumeId = viewReference?.volumeId;
+    const isVolume = volumeId && !imageId;
+    const viewportOptions = viewReference && baseViewportOptions
+        ? { ...baseViewportOptions, viewReference }
+        : baseViewportOptions;
     const renderFn = useCPURendering ? renderToCanvasCPU : renderToCanvasGPU;
     return new Promise((resolve, reject) => {
-        function successCallback(image, imageId) {
+        function successCallback(imageOrVolume, imageId) {
             const { modality } = metaData.get('generalSeriesModule', imageId) || {};
-            image.isPreScaled = image.isPreScaled || image.preScale?.scaled;
+            const image = !isVolume && imageOrVolume;
+            const volume = isVolume && imageOrVolume;
+            if (image) {
+                image.isPreScaled = image.isPreScaled || image.preScale?.scaled;
+            }
             if (thumbnail) {
                 canvas.height = 256;
                 canvas.width = 256;
             }
-            if (physicalPixels) {
-                canvas.width = canvas.offsetWidth * devicePixelRatio;
-                canvas.height = canvas.offsetHeight * devicePixelRatio;
+            if (imageAspect && image) {
+                canvas.width = image && (canvas.height * image.width) / image.height;
             }
-            if (imageAspect) {
-                canvas.width = (canvas.height * image.width) / image.height;
+            canvas.style.width = `${canvas.width / devicePixelRatio}px`;
+            canvas.style.height = `${canvas.height / devicePixelRatio}px`;
+            if (volume && useCPURendering) {
+                reject(new Error('CPU rendering of volume not supported'));
             }
-            renderFn(canvas, image, modality, renderingEngineId, viewportOptions).then(() => {
-                resolve(imageId);
-            });
+            renderFn(canvas, imageOrVolume, modality, renderingEngineId, viewportOptions).then(resolve);
         }
         function errorCallback(error, imageId) {
             console.error(error, imageId);
@@ -25783,20 +25833,28 @@ function loadImageToCanvas(options) {
                 errorCallback.call(this, error, imageId);
             });
         }
-        const { useNorm16Texture, preferSizeOverAccuracy } = (0,init/* getConfiguration */.D0)().rendering;
-        const useNativeDataType = useNorm16Texture || preferSizeOverAccuracy;
+        const { useNorm16Texture } = (0,init/* getConfiguration */.D0)().rendering;
         const options = {
             targetBuffer: {
-                type: useNativeDataType ? undefined : 'Float32Array',
+                type: useNorm16Texture ? undefined : 'Float32Array',
             },
             preScale: {
                 enabled: true,
             },
-            useNativeDataType,
             useRGBA: !!useCPURendering,
             requestType,
         };
-        imageLoadPoolManager/* default */.A.addRequest(sendRequest.bind(null, imageId, null, options), requestType, { imageId }, priority);
+        if (volumeId) {
+            const volume = cache/* default */.Ay.getVolume(volumeId);
+            if (!volume) {
+                reject(new Error(`Volume id ${volumeId} not found in cache`));
+            }
+            const useImageId = volume.imageIds[0];
+            successCallback(volume, useImageId);
+        }
+        else {
+            imageLoadPoolManager/* default */.A.addRequest(sendRequest.bind(null, imageId, null, options), requestType, { imageId }, priority);
+        }
     });
 }
 
@@ -26522,8 +26580,8 @@ function getScalingParameters(imageId) {
     const generalSeriesModule = (0,metaData.get)('generalSeriesModule', imageId) || {};
     const { modality } = generalSeriesModule;
     const scalingParameters = {
-        rescaleSlope: modalityLutModule.rescaleSlope,
-        rescaleIntercept: modalityLutModule.rescaleIntercept,
+        rescaleSlope: modalityLutModule.rescaleSlope || 1,
+        rescaleIntercept: modalityLutModule.rescaleIntercept ?? 0,
         modality,
     };
     const suvFactor = (0,metaData.get)('scalingModule', imageId) || {};
@@ -26636,11 +26694,15 @@ function sortImageIdsAndGetSpacing(imageIds, scanAxisNormal) {
             Math.abs(distanceBetweenFirstAndMiddleImages) /
                 Math.floor(imageIds.length / 2);
     }
-    const { imagePositionPatient: origin, sliceThickness } = dist_esm.metaData.get('imagePlaneModule', sortedImageIds[0]);
+    const { imagePositionPatient: origin, sliceThickness, spacingBetweenSlices, } = dist_esm.metaData.get('imagePlaneModule', sortedImageIds[0]);
     const { strictZSpacingForVolumeViewport } = (0,dist_esm.getConfiguration)().rendering;
     if (zSpacing === 0 && !strictZSpacingForVolumeViewport) {
-        if (sliceThickness) {
-            console.log('Could not calculate zSpacing. Using sliceThickness');
+        if (sliceThickness && spacingBetweenSlices) {
+            console.log('Could not calculate zSpacing. Using spacingBetweenSlices');
+            zSpacing = spacingBetweenSlices;
+        }
+        else if (sliceThickness) {
+            console.log('Could not calculate zSpacing and no spacingBetweenSlices. Using sliceThickness');
             zSpacing = sliceThickness;
         }
         else {
@@ -27198,9 +27260,11 @@ async function convertStackToVolumeViewport({ viewport, options, }) {
         },
     ], [viewportId]);
     const volumeViewportNewVolumeHandler = () => {
-        volumeViewport.setCamera({
-            ...prevCamera,
-        });
+        if (!options.orientation) {
+            volumeViewport.setCamera({
+                ...prevCamera,
+            });
+        }
         volumeViewport.render();
         element.removeEventListener(enums.Events.VOLUME_VIEWPORT_NEW_VOLUME, volumeViewportNewVolumeHandler);
     };
@@ -30794,7 +30858,7 @@ function _imageChangeEventListener(evt) {
                         imageActor.getMapper().setInputData(imageData);
                     },
                 },
-            ], true, false);
+            ]);
             (0,segmentation_triggerSegmentationRender/* default */.Ay)(toolGroup.id);
             return;
         }
@@ -40860,6 +40924,7 @@ class AngleTool extends _base__WEBPACK_IMPORTED_MODULE_2__/* .AnnotationTool */
                     viewUp: [...viewUp],
                     FrameOfReferenceUID,
                     referencedImageId,
+                    ...viewport.getViewReference({ points: [worldPos] }),
                 },
                 data: {
                     handles: {
@@ -41325,6 +41390,7 @@ class ArrowAnnotateTool extends _base__WEBPACK_IMPORTED_MODULE_2__/* .Annotation
                     viewUp: [...viewUp],
                     FrameOfReferenceUID,
                     referencedImageId,
+                    ...viewport.getViewReference({ points: [worldPos] }),
                 },
                 data: {
                     text: '',
@@ -41792,6 +41858,7 @@ class CircleROITool extends _base__WEBPACK_IMPORTED_MODULE_0__/* .AnnotationTool
                     viewUp: [...viewUp],
                     FrameOfReferenceUID,
                     referencedImageId,
+                    ...viewport.getViewReference({ points: [worldPos] }),
                 },
                 data: {
                     label: '',
@@ -42400,6 +42467,7 @@ class CobbAngleTool extends _base__WEBPACK_IMPORTED_MODULE_3__/* .AnnotationTool
                     viewUp: [...viewUp],
                     FrameOfReferenceUID,
                     referencedImageId,
+                    ...viewport.getViewReference({ points: [worldPos] }),
                 },
                 data: {
                     handles: {
@@ -43266,6 +43334,7 @@ class EllipticalROITool extends _base__WEBPACK_IMPORTED_MODULE_0__/* .Annotation
                     viewUp: [...viewUp],
                     FrameOfReferenceUID,
                     referencedImageId,
+                    ...viewport.getViewReference({ points: [worldPos] }),
                 },
                 data: {
                     label: '',
@@ -45675,6 +45744,7 @@ class RectangleROITool extends _base__WEBPACK_IMPORTED_MODULE_0__/* .AnnotationT
                     viewUp: [...viewUp],
                     FrameOfReferenceUID,
                     referencedImageId,
+                    ...viewport.getViewReference({ points: [worldPos] }),
                 },
                 data: {
                     label: '',

package/dist/{717.bundle.06a976a9200c0c4fa395.js → 717.bundle.0c1736a0b34262585bbb.js}

@@ -766,7 +766,7 @@ async function promptSaveReport({
       const dataSources = extensionManager.getDataSources();
       const dataSource = dataSources[0];
       const measurements = measurementService.getMeasurements();
-      const trackedMeasurements = measurements.filter(m => trackedStudy === m.referenceStudyUID && trackedSeries.includes(m.referenceSeriesUID));
+      const trackedMeasurements = measurements.filter(m => trackedStudy === m.referenceStudyUID && trackedSeries.includes(m.referenceSeriesUID)).filter(m => m.referencedImageId != null);
       const SeriesDescription =
       // isUndefinedOrEmpty
       promptResult.value === undefined || promptResult.value === '' ? 'Research Derived Series' // default
@@ -2119,9 +2119,10 @@ function PanelMeasurementTableTracking({
       setDisplayMeasurements(measurements);
     }
   };
-  const displayMeasurementsWithoutFindings = displayMeasurements.filter(dm => dm.measurementType !== measurementService.VALUE_TYPES.POINT);
-  const additionalFindings = displayMeasurements.filter(dm => dm.measurementType === measurementService.VALUE_TYPES.POINT);
-  const disabled = additionalFindings.length === 0 && displayMeasurementsWithoutFindings.length === 0;
+  const displayMeasurementsWithoutFindings = displayMeasurements.filter(dm => dm.measurementType !== measurementService.VALUE_TYPES.POINT && dm.referencedImageId);
+  const additionalFindings = displayMeasurements.filter(dm => dm.measurementType === measurementService.VALUE_TYPES.POINT && dm.referencedImageId);
+  const nonAcquisitionMeasurements = displayMeasurements.filter(dm => dm.referencedImageId == null);
+  const disabled = additionalFindings.length === 0 && displayMeasurementsWithoutFindings.length === 0 && nonAcquisitionMeasurements.length === 0;
   return /*#__PURE__*/react.createElement(react.Fragment, null, /*#__PURE__*/react.createElement("div", {
     className: "invisible-scrollbar overflow-y-auto overflow-x-hidden",
     ref: measurementsPanelRef,
@@ -2142,12 +2143,18 @@ function PanelMeasurementTableTracking({
     servicesManager: servicesManager,
     onClick: jumpToImage,
     onEdit: onMeasurementItemEditHandler
+  }), nonAcquisitionMeasurements.length !== 0 && /*#__PURE__*/react.createElement(ui_src/* MeasurementTable */.V, {
+    title: "Non-tracked",
+    data: nonAcquisitionMeasurements,
+    servicesManager: servicesManager,
+    onClick: jumpToImage,
+    onEdit: onMeasurementItemEditHandler
   })), !appConfig?.disableEditing && /*#__PURE__*/react.createElement("div", {
     className: "flex justify-center p-4"
   }, /*#__PURE__*/react.createElement(ui_src/* ActionButtons */.wr, {
     t: t,
     actions: [{
-      label: 'Export',
+      label: 'Download CSV',
       onClick: exportReport
     }, {
       label: 'Create Report',
@@ -2195,7 +2202,8 @@ function _mapMeasurementToDisplay(measurement, types, displaySetService) {
     type,
     selected,
     findingSites,
-    finding
+    finding,
+    referencedImageId
   } = measurement;
   const firstSite = findingSites?.[0];
   const label = baseLabel || finding?.text || firstSite?.text || '(empty)';
@@ -2221,7 +2229,8 @@ function _mapMeasurementToDisplay(measurement, types, displaySetService) {
     baseDisplayText,
     isActive: selected,
     finding,
-    findingSites
+    findingSites,
+    referencedImageId
   };
 }
 /* harmony default export */ const panels_PanelMeasurementTableTracking = (PanelMeasurementTableTracking);