@cornerstonejs/tools 1.13.1 → 1.13.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.13.1",
+  "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.1",
+    "@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": "3a64e9b77ad6549529d665c8fda89dc2235accf1"
+  "gitHead": "c6b8f5db43f3ae2e397240bf7d0da0be7a4fd434"
 }

package/src/drawingSvg/drawCircle.ts

@@ -3,8 +3,8 @@ import { SVGDrawingHelper } from '../types';
 
 import _getHash from './_getHash';
 
-import _setAttributesIfNecessary from './_setAttributesIfNecessary';
-import _setNewAttributesIfValid from './_setNewAttributesIfValid';
+import setAttributesIfNecessary from './setAttributesIfNecessary';
+import setNewAttributesIfValid from './setNewAttributesIfValid';
 
 function drawCircle(
   svgDrawingHelper: SVGDrawingHelper,
@@ -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,10 +52,12 @@ function drawCircle(
     fill,
     'stroke-width': strokeWidth,
     'stroke-dasharray': lineDash,
+    'fill-opacity': fillOpacity, // setting fill opacity
+    'stroke-opacity': strokeOpacity, // setting stroke opacity
   };
 
   if (existingCircleElement) {
-    _setAttributesIfNecessary(attributes, existingCircleElement);
+    setAttributesIfNecessary(attributes, existingCircleElement);
 
     svgDrawingHelper.setNodeTouched(svgNodeHash);
   } else {
@@ -55,7 +67,7 @@ function drawCircle(
       newCircleElement.setAttribute('data-id', dataId);
     }
 
-    _setNewAttributesIfValid(attributes, newCircleElement);
+    setNewAttributesIfValid(attributes, newCircleElement);
 
     svgDrawingHelper.appendNode(newCircleElement, svgNodeHash);
   }

package/src/drawingSvg/drawEllipse.ts

@@ -2,8 +2,8 @@ import type { Types } from '@cornerstonejs/core';
 import { SVGDrawingHelper } from '../types';
 
 import _getHash from './_getHash';
-import _setAttributesIfNecessary from './_setAttributesIfNecessary';
-import _setNewAttributesIfValid from './_setNewAttributesIfValid';
+import setAttributesIfNecessary from './setAttributesIfNecessary';
+import setNewAttributesIfValid from './setNewAttributesIfValid';
 
 function drawEllipse(
   svgDrawingHelper: SVGDrawingHelper,
@@ -52,7 +52,7 @@ function drawEllipse(
   };
 
   if (existingEllipse) {
-    _setAttributesIfNecessary(attributes, existingEllipse);
+    setAttributesIfNecessary(attributes, existingEllipse);
 
     svgDrawingHelper.setNodeTouched(svgNodeHash);
   } else {
@@ -62,7 +62,7 @@ function drawEllipse(
       svgEllipseElement.setAttribute('data-id', dataId);
     }
 
-    _setNewAttributesIfValid(attributes, svgEllipseElement);
+    setNewAttributesIfValid(attributes, svgEllipseElement);
 
     svgDrawingHelper.appendNode(svgEllipseElement, svgNodeHash);
   }

package/src/drawingSvg/drawHandles.ts

@@ -1,8 +1,8 @@
 import type { Types } from '@cornerstonejs/core';
 
 import _getHash from './_getHash';
-import _setNewAttributesIfValid from './_setNewAttributesIfValid';
-import _setAttributesIfNecessary from './_setAttributesIfNecessary';
+import setNewAttributesIfValid from './setNewAttributesIfValid';
+import setAttributesIfNecessary from './setAttributesIfNecessary';
 import { SVGDrawingHelper } from '../types';
 
 function drawHandles(
@@ -75,13 +75,13 @@ function drawHandles(
     const existingHandleElement = svgDrawingHelper.getSvgNode(svgNodeHash);
 
     if (existingHandleElement) {
-      _setAttributesIfNecessary(attributes, existingHandleElement);
+      setAttributesIfNecessary(attributes, existingHandleElement);
 
       svgDrawingHelper.setNodeTouched(svgNodeHash);
     } else {
       const newHandleElement = document.createElementNS(svgns, type);
 
-      _setNewAttributesIfValid(attributes, newHandleElement);
+      setNewAttributesIfValid(attributes, newHandleElement);
 
       svgDrawingHelper.appendNode(newHandleElement, svgNodeHash);
     }

package/src/drawingSvg/drawLine.ts

@@ -1,8 +1,8 @@
 import type { Types } from '@cornerstonejs/core';
 
 import _getHash from './_getHash';
-import _setNewAttributesIfValid from './_setNewAttributesIfValid';
-import _setAttributesIfNecessary from './_setAttributesIfNecessary';
+import setNewAttributesIfValid from './setNewAttributesIfValid';
+import setAttributesIfNecessary from './setAttributesIfNecessary';
 import { SVGDrawingHelper } from '../types';
 
 export default function drawLine(
@@ -53,7 +53,7 @@ export default function drawLine(
 
   if (existingLine) {
     // This is run to avoid re-rendering annotations that actually haven't changed
-    _setAttributesIfNecessary(attributes, existingLine);
+    setAttributesIfNecessary(attributes, existingLine);
 
     svgDrawingHelper.setNodeTouched(svgNodeHash);
   } else {
@@ -63,7 +63,7 @@ export default function drawLine(
       newLine.setAttribute('data-id', dataId);
     }
 
-    _setNewAttributesIfValid(attributes, newLine);
+    setNewAttributesIfValid(attributes, newLine);
 
     svgDrawingHelper.appendNode(newLine, svgNodeHash);
   }

package/src/drawingSvg/drawPolyline.ts

@@ -1,7 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
 import _getHash from './_getHash';
-import _setNewAttributesIfValid from './_setNewAttributesIfValid';
-import _setAttributesIfNecessary from './_setAttributesIfNecessary';
+import setNewAttributesIfValid from './setNewAttributesIfValid';
+import setAttributesIfNecessary from './setAttributesIfNecessary';
 import { SVGDrawingHelper } from '../types';
 
 /**
@@ -67,13 +67,13 @@ export default function drawPolyline(
 
   if (existingPolyLine) {
     // This is run to avoid re-rendering annotations that actually haven't changed
-    _setAttributesIfNecessary(attributes, existingPolyLine);
+    setAttributesIfNecessary(attributes, existingPolyLine);
 
     svgDrawingHelper.setNodeTouched(svgNodeHash);
   } else {
     const newPolyLine = document.createElementNS(svgns, 'polyline');
 
-    _setNewAttributesIfValid(attributes, newPolyLine);
+    setNewAttributesIfValid(attributes, newPolyLine);
 
     svgDrawingHelper.appendNode(newPolyLine, svgNodeHash);
   }

package/src/drawingSvg/drawRect.ts

@@ -1,8 +1,8 @@
 import type { Types } from '@cornerstonejs/core';
 
 import _getHash from './_getHash';
-import _setAttributesIfNecessary from './_setAttributesIfNecessary';
-import _setNewAttributesIfValid from './_setNewAttributesIfValid';
+import setAttributesIfNecessary from './setAttributesIfNecessary';
+import setNewAttributesIfValid from './setNewAttributesIfValid';
 import { SVGDrawingHelper } from '../types';
 
 // <rect x="120" y="100" width="100" height="100" />
@@ -53,7 +53,7 @@ export default function drawRect(
   };
 
   if (existingRect) {
-    _setAttributesIfNecessary(attributes, existingRect);
+    setAttributesIfNecessary(attributes, existingRect);
 
     svgDrawingHelper.setNodeTouched(svgNodeHash);
   } else {
@@ -63,7 +63,7 @@ export default function drawRect(
       svgRectElement.setAttribute('data-id', dataId);
     }
 
-    _setNewAttributesIfValid(attributes, svgRectElement);
+    setNewAttributesIfValid(attributes, svgRectElement);
 
     svgDrawingHelper.appendNode(svgRectElement, svgNodeHash);
   }

package/src/drawingSvg/drawTextBox.ts

@@ -2,7 +2,7 @@ import type { Types } from '@cornerstonejs/core';
 import { SVGDrawingHelper } from '../types';
 
 import _getHash from './_getHash';
-import _setAttributesIfNecessary from './_setAttributesIfNecessary';
+import setAttributesIfNecessary from './setAttributesIfNecessary';
 
 /**
  * Draws a textBox.
@@ -100,8 +100,8 @@ function _drawTextGroup(
     };
 
     // Todo: for some reason this does not work to not re-render the textBox
-    _setAttributesIfNecessary(textAttributes, textElement);
-    _setAttributesIfNecessary(textGroupAttributes, existingTextGroup);
+    setAttributesIfNecessary(textAttributes, textElement);
+    setAttributesIfNecessary(textGroupAttributes, existingTextGroup);
 
     textGroupBoundingBox = _drawTextBackground(existingTextGroup, background);
 
@@ -205,7 +205,7 @@ function _drawTextBackground(group: SVGGElement, color: string) {
     fill: color,
   };
 
-  _setAttributesIfNecessary(attributes, element);
+  setAttributesIfNecessary(attributes, element);
 
   return bBox;
 }

package/src/drawingSvg/index.ts

@@ -8,6 +8,8 @@ import drawLinkedTextBox from './drawLinkedTextBox';
 import drawRect from './drawRect';
 import drawTextBox from './drawTextBox';
 import drawArrow from './drawArrow';
+import setAttributesIfNecessary from './setAttributesIfNecessary';
+import setNewAttributesIfValid from './setNewAttributesIfValid';
 
 export {
   draw,
@@ -20,4 +22,6 @@ export {
   drawRect,
   drawTextBox,
   drawArrow,
+  setAttributesIfNecessary,
+  setNewAttributesIfValid,
 };

package/src/drawingSvg/{_setAttributesIfNecessary.ts → setAttributesIfNecessary.ts}

@@ -1,4 +1,4 @@
-export function _setAttributesIfNecessary(attributes, svgNode) {
+export function setAttributesIfNecessary(attributes, svgNode) {
   Object.keys(attributes).forEach((key) => {
     const currentValue = svgNode.getAttribute(key);
     const newValue = attributes[key];
@@ -10,4 +10,4 @@ export function _setAttributesIfNecessary(attributes, svgNode) {
   });
 }
 
-export default _setAttributesIfNecessary;
+export default setAttributesIfNecessary;

package/src/drawingSvg/{_setNewAttributesIfValid.ts → setNewAttributesIfValid.ts}

@@ -1,4 +1,4 @@
-export function _setNewAttributesIfValid(attributes, svgNode) {
+export function setNewAttributesIfValid(attributes, svgNode) {
   Object.keys(attributes).forEach((key) => {
     const newValue = attributes[key];
     if (newValue !== undefined && newValue !== '') {
@@ -7,4 +7,4 @@ export function _setNewAttributesIfValid(attributes, svgNode) {
   });
 }
 
-export default _setNewAttributesIfValid;
+export default setNewAttributesIfValid;

package/src/index.ts

@@ -23,6 +23,7 @@ import * as segmentation from './stateManagement/segmentation';
 import {
   BaseTool,
   AnnotationTool,
+  AnnotationDisplayTool,
   PanTool,
   TrackballRotateTool,
   DragProbeTool,
@@ -71,6 +72,7 @@ export {
   // Base Tools
   BaseTool,
   AnnotationTool,
+  AnnotationDisplayTool,
   // Manipulation Tools
   PanTool,
   TrackballRotateTool,

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/base/index.ts

@@ -1,4 +1,5 @@
 import BaseTool from './BaseTool';
 import AnnotationTool from './AnnotationTool';
+import AnnotationDisplayTool from './AnnotationDisplayTool';
 
-export { BaseTool, AnnotationTool };
+export { BaseTool, AnnotationTool, AnnotationDisplayTool };

package/src/tools/index.ts

@@ -1,4 +1,4 @@
-import { BaseTool, AnnotationTool } from './base';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool } from './base';
 import PanTool from './PanTool';
 import TrackballRotateTool from './TrackballRotateTool';
 import WindowLevelTool from './WindowLevelTool';
@@ -43,6 +43,7 @@ export {
   // ~~ BASE
   BaseTool,
   AnnotationTool,
+  AnnotationDisplayTool,
   // Manipulation Tools
   PanTool,
   TrackballRotateTool,

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;

package/dist/cjs/drawingSvg/_setAttributesIfNecessary.d.ts

@@ -1,2 +0,0 @@
-export declare function _setAttributesIfNecessary(attributes: any, svgNode: any): void;
-export default _setAttributesIfNecessary;