@cornerstonejs/tools 1.13.2 → 1.13.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.13.2",
+  "version": "1.13.3",
   "description": "Cornerstone3D Tools",
   "main": "dist/umd/index.js",
   "types": "dist/esm/index.d.ts",
@@ -29,7 +29,7 @@
     "webpack:watch": "webpack --mode development --progress --watch  --config ./.webpack/webpack.dev.js"
   },
   "dependencies": {
-    "@cornerstonejs/core": "^1.13.2",
+    "@cornerstonejs/core": "^1.13.3",
     "lodash.clonedeep": "4.5.0",
     "lodash.get": "^4.4.2"
   },
@@ -52,5 +52,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "b41b433d7c4062667a7b51ca8ad37c4ff939ba09"
+  "gitHead": "c6b8f5db43f3ae2e397240bf7d0da0be7a4fd434"
 }

package/src/drawingSvg/drawCircle.ts

@@ -15,13 +15,23 @@ function drawCircle(
   options = {},
   dataId = ''
 ): void {
-  const { color, fill, width, lineWidth, lineDash } = Object.assign(
+  const {
+    color,
+    fill,
+    width,
+    lineWidth,
+    lineDash,
+    fillOpacity,
+    strokeOpacity,
+  } = Object.assign(
     {
       color: 'dodgerblue',
       fill: 'transparent',
       width: '2',
       lineDash: undefined,
       lineWidth: undefined,
+      strokeOpacity: 1,
+      fillOpacity: 1,
     },
     options
   );
@@ -42,6 +52,8 @@ function drawCircle(
     fill,
     'stroke-width': strokeWidth,
     'stroke-dasharray': lineDash,
+    'fill-opacity': fillOpacity, // setting fill opacity
+    'stroke-opacity': strokeOpacity, // setting stroke opacity
   };
 
   if (existingCircleElement) {

package/src/store/ToolGroupManager/ToolGroup.ts

@@ -621,7 +621,10 @@ export default class ToolGroup implements IToolGroup {
     if (overwrite) {
       _configuration = configuration;
     } else {
-      _configuration = csUtils.deepMerge(
+      // We should not deep copy here, it is the job of the application to
+      // deep copy the configuration before passing it to the toolGroup, otherwise
+      // some strange appending behaviour happens for the arrays
+      _configuration = Object.assign(
         this._toolInstances[toolName].configuration,
         configuration
       );

package/src/tools/base/AnnotationTool.ts

@@ -200,24 +200,26 @@ abstract class AnnotationTool extends AnnotationDisplayTool {
 
     const { data } = annotation;
     const { points, textBox } = data.handles;
-    const { worldBoundingBox } = textBox;
 
-    if (worldBoundingBox) {
-      const canvasBoundingBox = {
-        topLeft: viewport.worldToCanvas(worldBoundingBox.topLeft),
-        topRight: viewport.worldToCanvas(worldBoundingBox.topRight),
-        bottomLeft: viewport.worldToCanvas(worldBoundingBox.bottomLeft),
-        bottomRight: viewport.worldToCanvas(worldBoundingBox.bottomRight),
-      };
-
-      if (
-        canvasCoords[0] >= canvasBoundingBox.topLeft[0] &&
-        canvasCoords[0] <= canvasBoundingBox.bottomRight[0] &&
-        canvasCoords[1] >= canvasBoundingBox.topLeft[1] &&
-        canvasCoords[1] <= canvasBoundingBox.bottomRight[1]
-      ) {
-        data.handles.activeHandleIndex = null;
-        return textBox;
+    if (textBox) {
+      const { worldBoundingBox } = textBox;
+      if (worldBoundingBox) {
+        const canvasBoundingBox = {
+          topLeft: viewport.worldToCanvas(worldBoundingBox.topLeft),
+          topRight: viewport.worldToCanvas(worldBoundingBox.topRight),
+          bottomLeft: viewport.worldToCanvas(worldBoundingBox.bottomLeft),
+          bottomRight: viewport.worldToCanvas(worldBoundingBox.bottomRight),
+        };
+
+        if (
+          canvasCoords[0] >= canvasBoundingBox.topLeft[0] &&
+          canvasCoords[0] <= canvasBoundingBox.bottomRight[0] &&
+          canvasCoords[1] >= canvasBoundingBox.topLeft[1] &&
+          canvasCoords[1] <= canvasBoundingBox.bottomRight[1]
+        ) {
+          data.handles.activeHandleIndex = null;
+          return textBox;
+        }
       }
     }
 

package/src/tools/segmentation/BrushTool.ts

@@ -1,4 +1,5 @@
 import { cache, getEnabledElement, StackViewport } from '@cornerstonejs/core';
+import { vec3 } from 'gl-matrix';
 
 import type { Types } from '@cornerstonejs/core';
 import type {
@@ -8,7 +9,10 @@ import type {
   SVGDrawingHelper,
 } from '../../types';
 import { BaseTool } from '../base';
-import { fillInsideSphere } from './strategies/fillSphere';
+import {
+  fillInsideSphere,
+  thresholdInsideSphere,
+} from './strategies/fillSphere';
 import { eraseInsideSphere } from './strategies/eraseSphere';
 import {
   thresholdInsideCircle,
@@ -59,10 +63,11 @@ class BrushTool extends BaseTool {
       configuration: {
         strategies: {
           FILL_INSIDE_CIRCLE: fillInsideCircle,
-          THRESHOLD_INSIDE_CIRCLE: thresholdInsideCircle,
           ERASE_INSIDE_CIRCLE: eraseInsideCircle,
           FILL_INSIDE_SPHERE: fillInsideSphere,
           ERASE_INSIDE_SPHERE: eraseInsideSphere,
+          THRESHOLD_INSIDE_CIRCLE: thresholdInsideCircle,
+          THRESHOLD_INSIDE_SPHERE: thresholdInsideSphere,
         },
         strategySpecificConfiguration: {
           THRESHOLD_INSIDE_CIRCLE: {
@@ -277,24 +282,42 @@ class BrushTool extends BaseTool {
     const enabledElement = getEnabledElement(element);
     const { viewport } = enabledElement;
     const { canvasToWorld } = viewport;
+    const camera = viewport.getCamera();
     const { brushSize } = this.configuration;
-    // Center of circle in canvas Coordinates
 
-    const radius = brushSize;
+    const viewUp = vec3.fromValues(
+      camera.viewUp[0],
+      camera.viewUp[1],
+      camera.viewUp[2]
+    );
+    const viewPlaneNormal = vec3.fromValues(
+      camera.viewPlaneNormal[0],
+      camera.viewPlaneNormal[1],
+      camera.viewPlaneNormal[2]
+    );
+    const viewRight = vec3.create();
 
-    const bottomCanvas: Types.Point2 = [
+    vec3.cross(viewRight, viewUp, viewPlaneNormal);
+
+    // in the world coordinate system, the brushSize is the radius of the circle
+    // in mm
+    const centerCursorInWorld: Types.Point3 = canvasToWorld([
       centerCanvas[0],
-      centerCanvas[1] + radius,
-    ];
-    const topCanvas: Types.Point2 = [centerCanvas[0], centerCanvas[1] - radius];
-    const leftCanvas: Types.Point2 = [
-      centerCanvas[0] - radius,
-      centerCanvas[1],
-    ];
-    const rightCanvas: Types.Point2 = [
-      centerCanvas[0] + radius,
       centerCanvas[1],
-    ];
+    ]);
+
+    const bottomCursorInWorld = vec3.create();
+    const topCursorInWorld = vec3.create();
+    const leftCursorInWorld = vec3.create();
+    const rightCursorInWorld = vec3.create();
+
+    // Calculate the bottom and top points of the circle in world coordinates
+    for (let i = 0; i <= 2; i++) {
+      bottomCursorInWorld[i] = centerCursorInWorld[i] - viewUp[i] * brushSize;
+      topCursorInWorld[i] = centerCursorInWorld[i] + viewUp[i] * brushSize;
+      leftCursorInWorld[i] = centerCursorInWorld[i] - viewRight[i] * brushSize;
+      rightCursorInWorld[i] = centerCursorInWorld[i] + viewRight[i] * brushSize;
+    }
 
     const { brushCursor } = this._hoverData;
     const { data } = brushCursor;
@@ -304,10 +327,10 @@ class BrushTool extends BaseTool {
     }
 
     data.handles.points = [
-      canvasToWorld(bottomCanvas),
-      canvasToWorld(topCanvas),
-      canvasToWorld(leftCanvas),
-      canvasToWorld(rightCanvas),
+      bottomCursorInWorld,
+      topCursorInWorld,
+      leftCursorInWorld,
+      rightCursorInWorld,
     ];
 
     data.invalidated = false;

package/src/tools/segmentation/strategies/eraseSphere.ts

@@ -4,6 +4,7 @@ import { fillInsideSphere } from './fillSphere';
 
 type OperationData = {
   points: [Types.Point3, Types.Point3, Types.Point3, Types.Point3];
+  imageVolume: Types.IImageVolume;
   volume: Types.IImageVolume;
   segmentIndex: number;
   segmentationId: string;
@@ -11,6 +12,7 @@ type OperationData = {
   viewPlaneNormal: Types.Point3;
   viewUp: Types.Point3;
   constraintFn: () => boolean;
+  strategySpecificConfiguration: any;
 };
 
 export function eraseInsideSphere(

package/src/tools/segmentation/strategies/fillCircle.ts

@@ -9,6 +9,7 @@ import {
 import { getBoundingBoxAroundShape } from '../../../utilities/boundingBox';
 import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
 import { pointInShapeCallback } from '../../../utilities';
+import isWithinThreshold from './utils/isWithinThreshold';
 
 const { transformWorldToIndex } = csUtils;
 
@@ -117,19 +118,6 @@ function fillCircle(
   triggerSegmentationDataModified(segmentationId, arrayOfSlices);
 }
 
-function isWithinThreshold(
-  index: number,
-  imageVolume: Types.IImageVolume,
-  strategySpecificConfiguration: any
-) {
-  const { THRESHOLD_INSIDE_CIRCLE } = strategySpecificConfiguration;
-
-  const voxelValue = imageVolume.getScalarData()[index];
-  const { threshold } = THRESHOLD_INSIDE_CIRCLE;
-
-  return threshold[0] <= voxelValue && voxelValue <= threshold[1];
-}
-
 /**
  * Fill inside the circular region segment inside the segmentation defined by the operationData.
  * It fills the segmentation pixels inside the defined circle.

package/src/tools/segmentation/strategies/fillSphere.ts

@@ -1,29 +1,36 @@
 import type { Types } from '@cornerstonejs/core';
+import { utilities as csUtils } from '@cornerstonejs/core';
 
 import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
 import { pointInSurroundingSphereCallback } from '../../../utilities';
+import isWithinThreshold from './utils/isWithinThreshold';
 
 type OperationData = {
   points: [Types.Point3, Types.Point3, Types.Point3, Types.Point3];
   volume: Types.IImageVolume;
+  imageVolume: Types.IImageVolume;
   segmentIndex: number;
   segmentationId: string;
   segmentsLocked: number[];
   viewPlaneNormal: Types.Point3;
   viewUp: Types.Point3;
+  strategySpecificConfiguration: any;
   constraintFn: () => boolean;
 };
 
 function fillSphere(
   enabledElement: Types.IEnabledElement,
   operationData: OperationData,
-  _inside = true
+  _inside = true,
+  threshold = false
 ): void {
   const { viewport } = enabledElement;
   const {
     volume: segmentation,
     segmentsLocked,
     segmentIndex,
+    imageVolume,
+    strategySpecificConfiguration,
     segmentationId,
     points,
   } = operationData;
@@ -32,13 +39,30 @@ function fillSphere(
   const scalarData = segmentation.getScalarData();
   const scalarIndex = [];
 
-  const callback = ({ index, value }) => {
-    if (segmentsLocked.includes(value)) {
-      return;
-    }
-    scalarData[index] = segmentIndex;
-    scalarIndex.push(index);
-  };
+  let callback;
+
+  if (threshold) {
+    callback = ({ value, index, pointIJK }) => {
+      if (segmentsLocked.includes(value)) {
+        return;
+      }
+
+      if (
+        isWithinThreshold(index, imageVolume, strategySpecificConfiguration)
+      ) {
+        scalarData[index] = segmentIndex;
+        scalarIndex.push(index);
+      }
+    };
+  } else {
+    callback = ({ index, value }) => {
+      if (segmentsLocked.includes(value)) {
+        return;
+      }
+      scalarData[index] = segmentIndex;
+      scalarIndex.push(index);
+    };
+  }
 
   pointInSurroundingSphereCallback(
     imageData,
@@ -74,6 +98,30 @@ export function fillInsideSphere(
   fillSphere(enabledElement, operationData, true);
 }
 
+/**
+ * Fill inside the circular region segment inside the segmentation defined by the operationData.
+ * It fills the segmentation pixels inside the defined circle.
+ * @param enabledElement - The element for which the segment is being filled.
+ * @param operationData - EraseOperationData
+ */
+export function thresholdInsideSphere(
+  enabledElement: Types.IEnabledElement,
+  operationData: OperationData
+): void {
+  const { volume, imageVolume } = operationData;
+
+  if (
+    !csUtils.isEqual(volume.dimensions, imageVolume.dimensions) ||
+    !csUtils.isEqual(volume.direction, imageVolume.direction)
+  ) {
+    throw new Error(
+      'Only source data the same dimensions/size/orientation as the segmentation currently supported.'
+    );
+  }
+
+  fillSphere(enabledElement, operationData, true, true);
+}
+
 /**
  * Fill outside a sphere with the given segment index in the given operation data. The
  * operation data contains the sphere required points.

package/src/tools/segmentation/strategies/utils/isWithinThreshold.ts

@@ -0,0 +1,16 @@
+import { Types } from '@cornerstonejs/core';
+
+function isWithinThreshold(
+  index: number,
+  imageVolume: Types.IImageVolume,
+  strategySpecificConfiguration: any
+) {
+  const { THRESHOLD_INSIDE_CIRCLE } = strategySpecificConfiguration;
+
+  const voxelValue = imageVolume.getScalarData()[index];
+  const { threshold } = THRESHOLD_INSIDE_CIRCLE;
+
+  return threshold[0] <= voxelValue && voxelValue <= threshold[1];
+}
+
+export default isWithinThreshold;