@ohif/app 3.11.0-beta.98 → 3.11.0

package/dist/{6216.bundle.48ff7813b6b3b8aba5f0.js → 2345.bundle.1fedf5750caf46ce99d9.js}

@@ -1,5 +1,5 @@
 "use strict";
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[6216],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[2345],{
 
 /***/ 1239:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
@@ -1282,40 +1282,6 @@ function lightenColor(r, g, b, a, factor = 0.4) {
 }
 
 
-/***/ }),
-
-/***/ 26384:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   l: () => (/* binding */ isAxisAlignedRectangle)
-/* harmony export */ });
-/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3823);
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(15327);
-
-
-const { isEqual } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.utilities;
-const iAxis = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.fromValues */ .eR.fromValues(1, 0, 0);
-const jAxis = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.fromValues */ .eR.fromValues(0, 1, 0);
-const kAxis = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.fromValues */ .eR.fromValues(0, 0, 1);
-const axisList = [iAxis, jAxis, kAxis];
-function isAxisAlignedRectangle(rectangleCornersIJK) {
-    const rectangleVec1 = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.subtract */ .eR.subtract(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create(), rectangleCornersIJK[0], rectangleCornersIJK[1]);
-    const rectangleVec2 = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.subtract */ .eR.subtract(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create(), rectangleCornersIJK[0], rectangleCornersIJK[2]);
-    const anglesVec1 = calculateAnglesWithAxes(rectangleVec1, axisList);
-    const anglesVec2 = calculateAnglesWithAxes(rectangleVec2, axisList);
-    const isAligned = [...anglesVec1, ...anglesVec2].every((angle) => isEqual(angle, 0) ||
-        isEqual(angle, 90) ||
-        isEqual(angle, 180) ||
-        isEqual(angle, 270));
-    return isAligned;
-}
-function calculateAnglesWithAxes(vec, axes) {
-    return axes.map((axis) => (gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.angle */ .eR.angle(vec, axis) * 180) / Math.PI);
-}
-
-
-
 /***/ }),
 
 /***/ 27730:

package/dist/{2701.bundle.d5c7ef6ec8b6cd9c2dfa.js → 2701.bundle.f2c7a5ab4a8b49d73bff.js}

@@ -23,8 +23,8 @@ var src = __webpack_require__(15871);
 var dicomSRModule = __webpack_require__(76654);
 // EXTERNAL MODULE: ../../../extensions/cornerstone-dicom-sr/src/utils/createReferencedImageDisplaySet.ts
 var createReferencedImageDisplaySet = __webpack_require__(92643);
-// EXTERNAL MODULE: ../../../extensions/cornerstone/src/index.tsx + 177 modules
-var cornerstone_src = __webpack_require__(56972);
+// EXTERNAL MODULE: ../../../extensions/cornerstone/src/index.tsx + 184 modules
+var cornerstone_src = __webpack_require__(20557);
 // EXTERNAL MODULE: ../../ui-next/src/index.ts + 3072 modules
 var ui_next_src = __webpack_require__(42606);
 // EXTERNAL MODULE: ../../core/src/contextProviders/SystemProvider.tsx
@@ -90,17 +90,11 @@ function OHIFCornerstoneSRMeasurementViewport(props) {
   const updateViewport = (0,react.useCallback)(newMeasurementSelected => {
     const {
       StudyInstanceUID,
-      displaySetInstanceUID,
-      sopClassUids
+      displaySetInstanceUID
     } = srDisplaySet;
     if (!StudyInstanceUID || !displaySetInstanceUID) {
       return;
     }
-    if (sopClassUids && sopClassUids.length > 1) {
-      // Todo: what happens if there are multiple SOP Classes? Why we are
-      // not throwing an error?
-      console.warn('More than one SOPClassUID in the same series is not yet supported.');
-    }
     _getViewportReferencedDisplaySetData(srDisplaySet, newMeasurementSelected, displaySetService).then(({
       referencedDisplaySet,
       referencedDisplaySetMetadata
@@ -261,6 +255,12 @@ async function _getViewportReferencedDisplaySetData(displaySet, measurementSelec
     };
   }
   const referencedDisplaySet = displaySetService.getDisplaySetByUID(displaySetInstanceUID);
+  if (!referencedDisplaySet?.images) {
+    return {
+      referencedDisplaySetMetadata: null,
+      referencedDisplaySet: null
+    };
+  }
   const image0 = referencedDisplaySet.images[0];
   const referencedDisplaySetMetadata = {
     PatientID: image0.PatientID,

package/dist/{2974.bundle.54d5903a8b29f1b09299.js → 2974.bundle.ec95e58b346dbe30a362.js}

@@ -74999,6 +74999,8 @@ var Events;
     Events["TOOLGROUP_VIEWPORT_REMOVED"] = "CORNERSTONE_TOOLS_TOOLGROUP_VIEWPORT_REMOVED";
     Events["TOOL_MODE_CHANGED"] = "CORNERSTONE_TOOLS_TOOL_MODE_CHANGED";
     Events["CROSSHAIR_TOOL_CENTER_CHANGED"] = "CORNERSTONE_TOOLS_CROSSHAIR_TOOL_CENTER_CHANGED";
+    Events["VOLUMECROPPINGCONTROL_TOOL_CHANGED"] = "CORNERSTONE_TOOLS_VOLUMECROPPINGCONTROL_TOOL_CHANGED";
+    Events["VOLUMECROPPING_TOOL_CHANGED"] = "CORNERSTONE_TOOLS_VOLUMECROPPING_TOOL_CHANGED";
     Events["ANNOTATION_ADDED"] = "CORNERSTONE_TOOLS_ANNOTATION_ADDED";
     Events["ANNOTATION_COMPLETED"] = "CORNERSTONE_TOOLS_ANNOTATION_COMPLETED";
     Events["ANNOTATION_MODIFIED"] = "CORNERSTONE_TOOLS_ANNOTATION_MODIFIED";

package/dist/{7750.bundle.216dafe3c87d611928da.js → 319.bundle.45c1c250b562a3feefa5.js}

@@ -1,5 +1,5 @@
 "use strict";
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[7750],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[319],{
 
 /***/ 405:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
@@ -23,6 +23,234 @@ function intersectPolyline(sourcePolyline, targetPolyline) {
 }
 
 
+/***/ }),
+
+/***/ 1060:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Ay: () => (/* binding */ vtkSphereSource$1)
+/* harmony export */ });
+/* unused harmony exports extend, newInstance */
+/* harmony import */ var _macros2_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(28906);
+/* harmony import */ var _Common_DataModel_PolyData_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(87275);
+/* harmony import */ var _Common_Core_DataArray_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(42008);
+
+
+
+
+// ----------------------------------------------------------------------------
+// vtkSphereSource methods
+// ----------------------------------------------------------------------------
+
+function vtkSphereSource(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkSphereSource');
+  publicAPI.requestData = (inData, outData) => {
+    if (model.deleted) {
+      return;
+    }
+    let dataset = outData[0];
+    const pointDataType = dataset ? dataset.getPoints().getDataType() : model.pointType;
+    dataset = _Common_DataModel_PolyData_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"].newInstance */ .Ay.newInstance();
+
+    // ----------------------------------------------------------------------
+    let numPoles = 0;
+
+    // Check data, determine increments, and convert to radians
+    let {
+      thetaResolution
+    } = model;
+    let startTheta = model.startTheta < model.endTheta ? model.startTheta : model.endTheta;
+    startTheta *= Math.PI / 180.0;
+    let endTheta = model.endTheta > model.startTheta ? model.endTheta : model.startTheta;
+    endTheta *= Math.PI / 180.0;
+    let startPhi = model.startPhi < model.endPhi ? model.startPhi : model.endPhi;
+    startPhi *= Math.PI / 180.0;
+    let endPhi = model.endPhi > model.startPhi ? model.endPhi : model.startPhi;
+    endPhi *= Math.PI / 180.0;
+    if (Math.abs(startTheta - endTheta) < 2.0 * Math.PI) {
+      ++thetaResolution;
+    }
+    const deltaTheta = (endTheta - startTheta) / model.thetaResolution;
+    const jStart = model.startPhi <= 0.0 ? 1 : 0;
+    const jEnd = model.phiResolution + (model.endPhi >= 180.0 ? -1 : 0);
+    const numPts = model.phiResolution * thetaResolution + 2;
+    const numPolys = model.phiResolution * 2 * model.thetaResolution;
+
+    // Points
+    let pointIdx = 0;
+    let points = _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.newTypedArray(pointDataType, numPts * 3);
+
+    // Normals
+    let normals = new Float32Array(numPts * 3);
+
+    // Cells
+    let cellLocation = 0;
+    let polys = new Uint32Array(numPolys * 5);
+
+    // Create north pole if needed
+    if (model.startPhi <= 0.0) {
+      points[pointIdx * 3 + 0] = model.center[0];
+      points[pointIdx * 3 + 1] = model.center[1];
+      points[pointIdx * 3 + 2] = model.center[2] + model.radius;
+      normals[pointIdx * 3 + 0] = 0;
+      normals[pointIdx * 3 + 1] = 0;
+      normals[pointIdx * 3 + 2] = 1;
+      pointIdx++;
+      numPoles++;
+    }
+
+    // Create south pole if needed
+    if (model.endPhi >= 180.0) {
+      points[pointIdx * 3 + 0] = model.center[0];
+      points[pointIdx * 3 + 1] = model.center[1];
+      points[pointIdx * 3 + 2] = model.center[2] - model.radius;
+      normals[pointIdx * 3 + 0] = 0;
+      normals[pointIdx * 3 + 1] = 0;
+      normals[pointIdx * 3 + 2] = -1;
+      pointIdx++;
+      numPoles++;
+    }
+    const phiResolution = model.phiResolution - numPoles;
+    const deltaPhi = (endPhi - startPhi) / (model.phiResolution - 1);
+
+    // Create intermediate points
+    for (let i = 0; i < thetaResolution; i++) {
+      const theta = startTheta + i * deltaTheta;
+      for (let j = jStart; j < jEnd; j++) {
+        const phi = startPhi + j * deltaPhi;
+        const radius = model.radius * Math.sin(phi);
+        normals[pointIdx * 3 + 0] = radius * Math.cos(theta);
+        normals[pointIdx * 3 + 1] = radius * Math.sin(theta);
+        normals[pointIdx * 3 + 2] = model.radius * Math.cos(phi);
+        points[pointIdx * 3 + 0] = normals[pointIdx * 3 + 0] + model.center[0];
+        points[pointIdx * 3 + 1] = normals[pointIdx * 3 + 1] + model.center[1];
+        points[pointIdx * 3 + 2] = normals[pointIdx * 3 + 2] + model.center[2];
+        let norm = Math.sqrt(normals[pointIdx * 3 + 0] * normals[pointIdx * 3 + 0] + normals[pointIdx * 3 + 1] * normals[pointIdx * 3 + 1] + normals[pointIdx * 3 + 2] * normals[pointIdx * 3 + 2]);
+        norm = norm === 0 ? 1 : norm;
+        normals[pointIdx * 3 + 0] /= norm;
+        normals[pointIdx * 3 + 1] /= norm;
+        normals[pointIdx * 3 + 2] /= norm;
+        pointIdx++;
+      }
+    }
+
+    // Generate mesh connectivity
+    const base = phiResolution * thetaResolution;
+    if (Math.abs(startTheta - endTheta) < 2.0 * Math.PI) {
+      --thetaResolution;
+    }
+
+    // around north pole
+    if (model.startPhi <= 0.0) {
+      for (let i = 0; i < thetaResolution; i++) {
+        polys[cellLocation++] = 3;
+        polys[cellLocation++] = phiResolution * i + numPoles;
+        polys[cellLocation++] = phiResolution * (i + 1) % base + numPoles;
+        polys[cellLocation++] = 0;
+      }
+    }
+
+    // around south pole
+    if (model.endPhi >= 180.0) {
+      const numOffset = phiResolution - 1 + numPoles;
+      for (let i = 0; i < thetaResolution; i++) {
+        polys[cellLocation++] = 3;
+        polys[cellLocation++] = phiResolution * i + numOffset;
+        polys[cellLocation++] = numPoles - 1;
+        polys[cellLocation++] = phiResolution * (i + 1) % base + numOffset;
+      }
+    }
+
+    // bands in-between poles
+    for (let i = 0; i < thetaResolution; i++) {
+      for (let j = 0; j < phiResolution - 1; j++) {
+        const a = phiResolution * i + j + numPoles;
+        const b = a + 1;
+        const c = (phiResolution * (i + 1) + j) % base + numPoles + 1;
+        if (!model.latLongTessellation) {
+          polys[cellLocation++] = 3;
+          polys[cellLocation++] = a;
+          polys[cellLocation++] = b;
+          polys[cellLocation++] = c;
+          polys[cellLocation++] = 3;
+          polys[cellLocation++] = a;
+          polys[cellLocation++] = c;
+          polys[cellLocation++] = c - 1;
+        } else {
+          polys[cellLocation++] = 4;
+          polys[cellLocation++] = a;
+          polys[cellLocation++] = b;
+          polys[cellLocation++] = c;
+          polys[cellLocation++] = c - 1;
+        }
+      }
+    }
+
+    // Squeeze
+    points = points.subarray(0, pointIdx * 3);
+    dataset.getPoints().setData(points, 3);
+    normals = normals.subarray(0, pointIdx * 3);
+    const normalArray = _Common_Core_DataArray_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"].newInstance */ .Ay.newInstance({
+      name: 'Normals',
+      values: normals,
+      numberOfComponents: 3
+    });
+    dataset.getPointData().setNormals(normalArray);
+    polys = polys.subarray(0, cellLocation);
+    dataset.getPolys().setData(polys, 1);
+
+    // Update output
+    outData[0] = dataset;
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  radius: 0.5,
+  latLongTessellation: false,
+  thetaResolution: 8,
+  startTheta: 0.0,
+  endTheta: 360.0,
+  phiResolution: 8,
+  startPhi: 0.0,
+  endPhi: 180.0,
+  center: [0, 0, 0],
+  pointType: 'Float64Array'
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Build VTK API
+  _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.obj(publicAPI, model);
+  _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.setGet(publicAPI, model, ['radius', 'latLongTessellation', 'thetaResolution', 'startTheta', 'endTheta', 'phiResolution', 'startPhi', 'endPhi']);
+  _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.setGetArray(publicAPI, model, ['center'], 3);
+  _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.algo(publicAPI, model, 0, 1);
+  vtkSphereSource(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.newInstance(extend, 'vtkSphereSource');
+
+// ----------------------------------------------------------------------------
+
+var vtkSphereSource$1 = {
+  newInstance,
+  extend
+};
+
+
+
+
 /***/ }),
 
 /***/ 4239:
@@ -895,67 +1123,6 @@ function getNormal2(polyline) {
 }
 
 
-/***/ }),
-
-/***/ 11683:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-// ESM COMPAT FLAG
-__webpack_require__.r(__webpack_exports__);
-
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-  getCanvasEllipseCorners: () => (/* reexport */ getCanvasEllipseCorners/* default */.A),
-  pointInEllipse: () => (/* reexport */ pointInEllipse),
-  precalculatePointInEllipse: () => (/* reexport */ precalculatePointInEllipse)
-});
-
-;// ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/ellipse/pointInEllipse.js
-function pointInEllipse(ellipse, pointLPS, inverts = {}) {
-    if (!inverts.precalculated) {
-        precalculatePointInEllipse(ellipse, inverts);
-    }
-    return inverts.precalculated(pointLPS);
-}
-const precalculatePointInEllipse = (ellipse, inverts = {}) => {
-    const { xRadius, yRadius, zRadius } = ellipse;
-    if (inverts.invXRadiusSq === undefined ||
-        inverts.invYRadiusSq === undefined ||
-        inverts.invZRadiusSq === undefined) {
-        inverts.invXRadiusSq = xRadius !== 0 ? 1 / xRadius ** 2 : 0;
-        inverts.invYRadiusSq = yRadius !== 0 ? 1 / yRadius ** 2 : 0;
-        inverts.invZRadiusSq = zRadius !== 0 ? 1 / zRadius ** 2 : 0;
-    }
-    const { invXRadiusSq, invYRadiusSq, invZRadiusSq } = inverts;
-    const { center } = ellipse;
-    const [centerL, centerP, centerS] = center;
-    inverts.precalculated = (pointLPS) => {
-        const dx = pointLPS[0] - centerL;
-        let inside = dx * dx * invXRadiusSq;
-        if (inside > 1) {
-            return false;
-        }
-        const dy = pointLPS[1] - centerP;
-        inside += dy * dy * invYRadiusSq;
-        if (inside > 1) {
-            return false;
-        }
-        const dz = pointLPS[2] - centerS;
-        inside += dz * dz * invZRadiusSq;
-        return inside <= 1;
-    };
-    return inverts;
-};
-
-
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/ellipse/getCanvasEllipseCorners.js
-var getCanvasEllipseCorners = __webpack_require__(2222);
-;// ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/ellipse/index.js
-
-
-
-
-
 /***/ }),
 
 /***/ 13165:
@@ -7462,6 +7629,73 @@ function getArea(points) {
 }
 
 
+/***/ }),
+
+/***/ 87009:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  getCanvasEllipseCorners: () => (/* reexport */ getCanvasEllipseCorners),
+  pointInEllipse: () => (/* reexport */ pointInEllipse),
+  precalculatePointInEllipse: () => (/* reexport */ precalculatePointInEllipse)
+});
+
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/ellipse/pointInEllipse.js
+function pointInEllipse(ellipse, pointLPS, inverts = {}) {
+    if (!inverts.precalculated) {
+        precalculatePointInEllipse(ellipse, inverts);
+    }
+    return inverts.precalculated(pointLPS);
+}
+const precalculatePointInEllipse = (ellipse, inverts = {}) => {
+    const { xRadius, yRadius, zRadius } = ellipse;
+    if (inverts.invXRadiusSq === undefined ||
+        inverts.invYRadiusSq === undefined ||
+        inverts.invZRadiusSq === undefined) {
+        inverts.invXRadiusSq = xRadius !== 0 ? 1 / xRadius ** 2 : 0;
+        inverts.invYRadiusSq = yRadius !== 0 ? 1 / yRadius ** 2 : 0;
+        inverts.invZRadiusSq = zRadius !== 0 ? 1 / zRadius ** 2 : 0;
+    }
+    const { invXRadiusSq, invYRadiusSq, invZRadiusSq } = inverts;
+    const { center } = ellipse;
+    const [centerL, centerP, centerS] = center;
+    inverts.precalculated = (pointLPS) => {
+        const dx = pointLPS[0] - centerL;
+        let inside = dx * dx * invXRadiusSq;
+        if (inside > 1) {
+            return false;
+        }
+        const dy = pointLPS[1] - centerP;
+        inside += dy * dy * invYRadiusSq;
+        if (inside > 1) {
+            return false;
+        }
+        const dz = pointLPS[2] - centerS;
+        inside += dz * dz * invZRadiusSq;
+        return inside <= 1;
+    };
+    return inverts;
+};
+
+
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/ellipse/getCanvasEllipseCorners.js
+function getCanvasEllipseCorners(ellipseCanvasPoints) {
+    const [bottom, top, left, right] = ellipseCanvasPoints;
+    const topLeft = [left[0], top[1]];
+    const bottomRight = [right[0], bottom[1]];
+    return [topLeft, bottomRight];
+}
+
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/ellipse/index.js
+
+
+
+
+
 /***/ }),
 
 /***/ 88638:

package/dist/{3658.bundle.6093e112080735acc799.js → 3658.bundle.4b03e3bc783328aab18f.js}

@@ -22,8 +22,8 @@ const id = package_namespaceObject.UU;
 var react = __webpack_require__(86326);
 // EXTERNAL MODULE: ../../ui-next/src/index.ts + 3072 modules
 var src = __webpack_require__(42606);
-// EXTERNAL MODULE: ../../../extensions/default/src/index.ts + 140 modules
-var default_src = __webpack_require__(49625);
+// EXTERNAL MODULE: ../../../extensions/default/src/index.ts + 139 modules
+var default_src = __webpack_require__(11447);
 // EXTERNAL MODULE: ../../core/src/index.ts + 68 modules
 var core_src = __webpack_require__(15871);
 // EXTERNAL MODULE: ../../../node_modules/react-i18next/dist/es/index.js + 15 modules