@cornerstonejs/tools 1.82.6 → 1.83.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.82.6",
+  "version": "1.83.0",
   "description": "Cornerstone3D Tools",
   "main": "src/index.ts",
   "types": "dist/types/index.d.ts",
@@ -29,7 +29,7 @@
     "webpack:watch": "webpack --mode development --progress --watch  --config ./.webpack/webpack.dev.js"
   },
   "dependencies": {
-    "@cornerstonejs/core": "^1.82.6",
+    "@cornerstonejs/core": "^1.83.0",
     "@icr/polyseg-wasm": "0.4.0",
     "@types/offscreencanvas": "2019.7.3",
     "comlink": "^4.4.1",
@@ -59,5 +59,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "bf783ebd34b0da4a0c80ed5c5339cdb3d24f980e"
+  "gitHead": "b6bbf9b56de9aab45972d53e0c311280d5d8453f"
 }

package/src/tools/segmentation/CircleROIStartEndThresholdTool.ts

@@ -267,18 +267,6 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
       removeAnnotation(annotation.annotationUID);
     }
 
-    const targetId = this.getTargetId(enabledElement.viewport);
-    const imageVolume = cache.getVolume(targetId.split(/volumeId:|\?/)[1]);
-
-    if (this.configuration.calculatePointsInsideVolume) {
-      this._computePointsInsideVolume(
-        annotation,
-        imageVolume,
-        targetId,
-        enabledElement
-      );
-    }
-
     triggerAnnotationRenderForViewportIds(
       enabledElement.renderingEngine,
       viewportIdsToRender
@@ -346,53 +334,67 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
       const focalPoint = viewport.getCamera().focalPoint;
       const viewplaneNormal = viewport.getCamera().viewPlaneNormal;
 
-      let startCoord: number | vec3 = startCoordinate;
-      let endCoord: number | vec3 = endCoordinate;
+      let tempStartCoordinate: number | vec3 = startCoordinate;
+      let tempEndCoordinate: number | vec3 = endCoordinate;
       if (Array.isArray(startCoordinate)) {
-        startCoord = this._getCoordinateForViewplaneNormal(
-          startCoord,
+        tempStartCoordinate = this._getCoordinateForViewplaneNormal(
+          tempStartCoordinate,
           viewplaneNormal
         );
+        data.startCoordinate = tempStartCoordinate;
       }
       if (Array.isArray(endCoordinate)) {
-        endCoord = this._getCoordinateForViewplaneNormal(
-          endCoord,
+        tempEndCoordinate = this._getCoordinateForViewplaneNormal(
+          tempEndCoordinate,
           viewplaneNormal
         );
+        data.endCoordinate = tempEndCoordinate;
       }
 
-      const roundedStartCoord = coreUtils.roundToPrecision(startCoord);
-      const roundedEndCoord = coreUtils.roundToPrecision(endCoord);
+      const roundedStartCoordinate = coreUtils.roundToPrecision(
+        data.startCoordinate
+      );
+      const roundedEndCoordinate = coreUtils.roundToPrecision(
+        data.endCoordinate
+      );
 
-      const coord = this._getCoordinateForViewplaneNormal(
+      const cameraCoordinate = this._getCoordinateForViewplaneNormal(
         focalPoint,
         viewplaneNormal
       );
-      const roundedCoord = coreUtils.roundToPrecision(coord);
+      const roundedCameraCoordinate =
+        coreUtils.roundToPrecision(cameraCoordinate);
 
       // if the focalpoint is outside the start/end coordinates, we don't render
       if (
-        roundedCoord < Math.min(roundedStartCoord, roundedEndCoord) ||
-        roundedCoord > Math.max(roundedStartCoord, roundedEndCoord)
+        roundedCameraCoordinate <
+          Math.min(roundedStartCoordinate, roundedEndCoordinate) ||
+        roundedCameraCoordinate >
+          Math.max(roundedStartCoordinate, roundedEndCoordinate)
       ) {
         continue;
       }
-      // WE HAVE TO CACHE STATS BEFORE FETCHING TEXT
-
-      if (annotation.invalidated) {
-        this._throttledCalculateCachedStats(annotation, enabledElement);
-      }
-
-      const middleCoord = coreUtils.roundToPrecision(
-        (startCoord + endCoord) / 2
+      const middleCoordinate = coreUtils.roundToPrecision(
+        (data.startCoordinate + data.endCoordinate) / 2
       );
       // if it is inside the start/end slice, but not exactly the first or
       // last slice, we render the line in dash, but not the handles
 
       let isMiddleSlice = false;
-      if (roundedCoord === middleCoord) {
+      if (roundedCameraCoordinate === middleCoordinate) {
         isMiddleSlice = true;
       }
+
+      data.handles.points[0][
+        this._getIndexOfCoordinatesForViewplaneNormal(viewplaneNormal)
+      ] = middleCoordinate;
+
+      // WE HAVE TO CACHE STATS BEFORE FETCHING TEXT
+
+      if (annotation.invalidated) {
+        this._throttledCalculateCachedStats(annotation, enabledElement);
+      }
+
       // If rendering engine has been destroyed while rendering
       if (!viewport.getRenderingEngine()) {
         console.warn('Rendering Engine has been destroyed');
@@ -768,6 +770,15 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
     // bring the logic for handle to some cachedStats calculation
     this._computeProjectionPoints(annotation, imageVolume);
 
+    if (this.configuration.calculatePointsInsideVolume) {
+      this._computePointsInsideVolume(
+        annotation,
+        imageVolume,
+        targetId,
+        enabledElement
+      );
+    }
+
     annotation.invalidated = false;
 
     triggerAnnotationModified(annotation, viewport.element);

package/src/tools/segmentation/RectangleROIStartEndThresholdTool.ts

@@ -259,18 +259,6 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
       removeAnnotation(annotation.annotationUID);
     }
 
-    const targetId = this.getTargetId(enabledElement.viewport);
-    const imageVolume = cache.getVolume(targetId.split(/volumeId:|\?/)[1]);
-
-    if (this.configuration.calculatePointsInsideVolume) {
-      this._computePointsInsideVolume(
-        annotation,
-        targetId,
-        imageVolume,
-        enabledElement
-      );
-    }
-
     triggerAnnotationRenderForViewportIds(
       enabledElement.renderingEngine,
       viewportIdsToRender
@@ -320,7 +308,6 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
 
     // distance between start and end slice in the world coordinate
     const distance = vec3.distance(startWorld, endWorld);
-
     // for each point inside points, navigate in the direction of the viewPlaneNormal
     // with amount of spacingInNormal, and calculate the next slice until we reach the distance
     const newProjectionPoints = [];
@@ -334,7 +321,6 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
         })
       );
     }
-
     data.cachedStats.projectionPoints = newProjectionPoints;
   }
 
@@ -481,6 +467,15 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
     // bring the logic for handle to some cachedStats calculation
     this._computeProjectionPoints(annotation, imageVolume);
 
+    if (this.configuration.calculatePointsInsideVolume) {
+      this._computePointsInsideVolume(
+        annotation,
+        targetId,
+        imageVolume,
+        enabledElement
+      );
+    }
+
     annotation.invalidated = false;
 
     // Dispatching annotation modified
@@ -547,6 +542,10 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
           startCoord,
           viewplaneNormal
         );
+        data.startCoordinate = startCoord;
+        data.handles.points[0][
+          this._getIndexOfCoordinatesForViewplaneNormal(viewplaneNormal)
+        ] = startCoord;
       }
 
       if (Array.isArray(endCoordinate)) {
@@ -554,6 +553,7 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
           endCoord,
           viewplaneNormal
         );
+        data.endCoordinate = endCoord;
       }
 
       const roundedStartCoord = coreUtils.roundToPrecision(startCoord);