@cornerstonejs/tools 1.36.3 → 1.37.0

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

@@ -1,111 +1,155 @@
 import { vec3 } from 'gl-matrix';
-import type { Types } from '@cornerstonejs/core';
-import { cache } from '@cornerstonejs/core';
 import { utilities as csUtils } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 
 import {
   getCanvasEllipseCorners,
-  pointInEllipse,
+  precalculatePointInEllipse,
 } from '../../../utilities/math/ellipse';
+import pointInSphere from '../../../utilities/math/sphere/pointInSphere';
 import { getBoundingBoxAroundShape } from '../../../utilities/boundingBox';
-import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
-import { pointInShapeCallback } from '../../../utilities';
-import isWithinThreshold from './utils/isWithinThreshold';
-import { LabelmapToolOperationData } from '../../../types';
-import { getStrategyData } from './utils/getStrategyData';
-import { isVolumeSegmentation } from './utils/stackVolumeCheck';
+import BrushStrategy from './BrushStrategy';
+import type { Composition, InitializedOperationData } from './BrushStrategy';
+import type { CanvasCoordinates } from '../../../types';
+import { StrategyCallbacks } from '../../../enums';
+import compositions from './compositions';
 
 const { transformWorldToIndex } = csUtils;
+const EPSILON = 1e-4;
+const nearOrZero = (testValue, nearValue) =>
+  Math.abs(testValue) < EPSILON || Math.abs(testValue - nearValue) < EPSILON;
+
+const initializeCircle = {
+  [StrategyCallbacks.Initialize]: (operationData: InitializedOperationData) => {
+    const {
+      points,
+      imageVoxelManager: imageVoxelManager,
+      viewport,
+      segmentationImageData,
+      segmentationVoxelManager: segmentationVoxelManager,
+    } = operationData;
+
+    // Happens on a preview setup
+    if (!points) {
+      return;
+    }
+    // Average the points to get the center of the ellipse
+    const center = vec3.fromValues(0, 0, 0);
+    points.forEach((point) => {
+      vec3.add(center, center, point);
+    });
+    vec3.scale(center, center, 1 / points.length);
+
+    operationData.centerWorld = center as Types.Point3;
+    operationData.centerIJK = transformWorldToIndex(
+      segmentationImageData,
+      center as Types.Point3
+    );
+    const canvasCoordinates = points.map((p) =>
+      viewport.worldToCanvas(p)
+    ) as CanvasCoordinates;
+
+    // 1. From the drawn tool: Get the ellipse (circle) topLeft and bottomRight
+    // corners in canvas coordinates
+    const [topLeftCanvas, bottomRightCanvas] =
+      getCanvasEllipseCorners(canvasCoordinates);
+
+    // 2. Find the extent of the ellipse (circle) in IJK index space of the image
+    const topLeftWorld = viewport.canvasToWorld(topLeftCanvas);
+    const bottomRightWorld = viewport.canvasToWorld(bottomRightCanvas);
+
+    const ellipsoidCornersIJK = [
+      <Types.Point3>transformWorldToIndex(segmentationImageData, topLeftWorld),
+      <Types.Point3>(
+        transformWorldToIndex(segmentationImageData, bottomRightWorld)
+      ),
+    ];
+
+    segmentationVoxelManager.boundsIJK = getBoundingBoxAroundShape(
+      ellipsoidCornersIJK,
+      segmentationVoxelManager.dimensions
+    );
+    imageVoxelManager.isInObject = createPointInEllipse({
+      topLeftWorld,
+      bottomRightWorld,
+      center,
+    });
+  },
+} as Composition;
 
-type OperationData = LabelmapToolOperationData & {
-  points: [Types.Point3, Types.Point3, Types.Point3, Types.Point3];
-};
-
-function fillCircle(
-  enabledElement: Types.IEnabledElement,
-  operationData: OperationData,
-  threshold = false
-): void {
-  const {
-    points,
-    segmentsLocked,
-    segmentIndex,
-    segmentationId,
-    strategySpecificConfiguration,
-  } = operationData;
-
-  const { viewport } = enabledElement;
-  const data = getStrategyData({ operationData, viewport });
-
-  if (!data) {
-    console.warn('No data found for fillCircle');
-    return;
-  }
-
-  const { imageScalarData, segmentationImageData, segmentationScalarData } =
-    data;
-
-  const { ellipseObj, boundsIJK } = getEllipse(
-    viewport,
-    segmentationImageData,
-    points
-  );
-
-  const modifiedSlicesToUse = new Set() as Set<number>;
-
-  let callback;
-
-  if (threshold) {
-    callback = ({ value, index, pointIJK }) => {
-      if (segmentsLocked.includes(value)) {
-        return;
-      }
-
-      if (
-        isWithinThreshold(index, imageScalarData, strategySpecificConfiguration)
-      ) {
-        segmentationScalarData[index] = segmentIndex;
-        //Todo: I don't think this will always be index 2 in streamingImageVolume?
-        modifiedSlicesToUse.add(pointIJK[2]);
-      }
-    };
-  } else {
-    callback = ({ value, index, pointIJK }) => {
-      if (segmentsLocked.includes(value)) {
-        return;
-      }
-      segmentationScalarData[index] = segmentIndex;
-      modifiedSlicesToUse.add(pointIJK[2]);
+/**
+ * Creates a function that tells the user if the provided point in LPS space
+ * is inside the ellipse.
+ *
+ * This will return a sphere test function if the bounds are a circle or
+ * sphere shape (same radius in two or three dimensions), or an elliptical shape
+ * if they differ.
+ */
+function createPointInEllipse(worldInfo: {
+  topLeftWorld: Types.Point3;
+  bottomRightWorld: Types.Point3;
+  center: Types.Point3 | vec3;
+}) {
+  const { topLeftWorld, bottomRightWorld, center } = worldInfo;
+
+  const xRadius = Math.abs(topLeftWorld[0] - bottomRightWorld[0]) / 2;
+  const yRadius = Math.abs(topLeftWorld[1] - bottomRightWorld[1]) / 2;
+  const zRadius = Math.abs(topLeftWorld[2] - bottomRightWorld[2]) / 2;
+
+  const radius = Math.max(xRadius, yRadius, zRadius);
+  if (
+    nearOrZero(xRadius, radius) &&
+    nearOrZero(yRadius, radius) &&
+    nearOrZero(zRadius, radius)
+  ) {
+    const sphereObj = {
+      center,
+      radius,
+      radius2: radius * radius,
     };
+    return (pointLPS) => pointInSphere(sphereObj, pointLPS);
   }
+  // using circle as a form of ellipse
+  const ellipseObj = {
+    center: center as Types.Point3,
+    xRadius,
+    yRadius,
+    zRadius,
+  };
+  const inverts = precalculatePointInEllipse(ellipseObj);
+  const { precalculated } = inverts;
 
-  pointInShapeCallback(
-    segmentationImageData,
-    (pointLPS) =>
-      pointInEllipse(ellipseObj, pointLPS, {
-        fast: true,
-      }),
-    callback,
-    boundsIJK
-  );
-
-  const arrayOfSlices: number[] = Array.from(modifiedSlicesToUse);
-
-  triggerSegmentationDataModified(segmentationId, arrayOfSlices);
+  return precalculated;
 }
 
+const CIRCLE_STRATEGY = new BrushStrategy(
+  'Circle',
+  compositions.regionFill,
+  compositions.setValue,
+  initializeCircle,
+  compositions.determineSegmentIndex,
+  compositions.preview
+);
+
+const CIRCLE_THRESHOLD_STRATEGY = new BrushStrategy(
+  'CircleThreshold',
+  compositions.regionFill,
+  compositions.setValue,
+  initializeCircle,
+  compositions.determineSegmentIndex,
+  compositions.dynamicThreshold,
+  compositions.threshold,
+  compositions.preview,
+  compositions.islandRemoval
+);
+
 /**
  * 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 erased.
  * @param operationData - EraseOperationData
  */
-export function fillInsideCircle(
-  enabledElement: Types.IEnabledElement,
-  operationData: OperationData
-): void {
-  fillCircle(enabledElement, operationData, false);
-}
+const fillInsideCircle = CIRCLE_STRATEGY.strategyFunction;
 
 /**
  * Fill inside the circular region segment inside the segmentation defined by the operationData.
@@ -113,89 +157,22 @@ export function fillInsideCircle(
  * @param enabledElement - The element for which the segment is being erased.
  * @param operationData - EraseOperationData
  */
-export function thresholdInsideCircle(
-  enabledElement: Types.IEnabledElement,
-  operationData: OperationData
-): void {
-  if (isVolumeSegmentation(operationData)) {
-    const { referencedVolumeId, volumeId } = operationData;
-
-    const imageVolume = cache.getVolume(referencedVolumeId);
-    const segmentation = cache.getVolume(volumeId);
-
-    if (
-      !csUtils.isEqual(segmentation.dimensions, imageVolume.dimensions) ||
-      !csUtils.isEqual(segmentation.direction, imageVolume.direction)
-    ) {
-      throw new Error(
-        'Only source data the same dimensions/size/orientation as the segmentation currently supported.'
-      );
-    }
-  }
-
-  fillCircle(enabledElement, operationData, true);
-}
+const thresholdInsideCircle = CIRCLE_THRESHOLD_STRATEGY.strategyFunction;
 
 /**
  * Fill outside the circular region segment inside the segmentation defined by the operationData.
  * It fills the segmentation pixels outside the  defined circle.
-j * @param enabledElement - The element for which the segment is being erased.
- * @param operationData - EraseOperationData
- */
-export function fillOutsideCircle(
-  enabledElement: Types.IEnabledElement,
-  operationData: OperationData
-): void {
-  throw new Error('Not yet implemented');
-}
-
-/**
- * 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 erased.
  * @param operationData - EraseOperationData
  */
-function getCenter(points) {
-  // Average the points to get the center of the ellipse
-  const center = vec3.fromValues(0, 0, 0);
-  points.forEach((point) => {
-    vec3.add(center, center, point);
-  });
-  vec3.scale(center, center, 1 / points.length);
-  return center;
+export function fillOutsideCircle(): void {
+  throw new Error('Not yet implemented');
 }
 
-function getEllipse(viewport, imageData, points) {
-  const center = getCenter(points);
-  const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
-  const dimensions = imageData.getDimensions();
-
-  // 1. From the drawn tool: Get the ellipse (circle) topLeft and bottomRight
-  // corners in canvas coordinates
-  const [topLeftCanvas, bottomRightCanvas] =
-    getCanvasEllipseCorners(canvasCoordinates);
-
-  // 2. Find the extent of the ellipse (circle) in IJK index space of the image
-  const topLeftWorld = viewport.canvasToWorld(topLeftCanvas);
-  const bottomRightWorld = viewport.canvasToWorld(bottomRightCanvas);
-
-  const ellipsoidCornersIJK = [
-    <Types.Point3>transformWorldToIndex(imageData, topLeftWorld),
-    <Types.Point3>transformWorldToIndex(imageData, bottomRightWorld),
-  ];
-
-  const boundsIJK = getBoundingBoxAroundShape(ellipsoidCornersIJK, dimensions);
-
-  if (boundsIJK.every(([min, max]) => min !== max)) {
-    throw new Error('Oblique segmentation tools are not supported yet');
-  }
-
-  // using circle as a form of ellipse
-  const ellipseObj = {
-    center: center as Types.Point3,
-    xRadius: Math.abs(topLeftWorld[0] - bottomRightWorld[0]) / 2,
-    yRadius: Math.abs(topLeftWorld[1] - bottomRightWorld[1]) / 2,
-    zRadius: Math.abs(topLeftWorld[2] - bottomRightWorld[2]) / 2,
-  };
-  return { ellipseObj, boundsIJK };
-}
+export {
+  CIRCLE_STRATEGY,
+  CIRCLE_THRESHOLD_STRATEGY,
+  fillInsideCircle,
+  thresholdInsideCircle,
+  createPointInEllipse as createEllipseInPoint,
+};

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

@@ -18,7 +18,6 @@ type OperationData = LabelmapToolOperationData & {
  * the rectangle, set the scalar value to the segmentIndex
  * @param toolGroupId - string
  * @param operationData - OperationData
- * @param constraintFn - can be used to perform threshold segmentation
  * @param inside - boolean
  */
 // Todo: why we have another constraintFn? in addition to the one in the operationData?
@@ -27,7 +26,7 @@ function fillRectangle(
   operationData: OperationData,
   inside = true
 ): void {
-  const { points, segmentsLocked, segmentIndex, segmentationId, constraintFn } =
+  const { points, segmentsLocked, segmentIndex, segmentationId } =
     operationData;
 
   const strategyData = getStrategyData({
@@ -61,19 +60,12 @@ function fillRectangle(
   // Since always all points inside the boundsIJK is inside the rectangle...
   const pointInRectangle = () => true;
 
-  const callback = ({ value, index, pointIJK }) => {
+  const callback = ({ value, index }) => {
     if (segmentsLocked.includes(value)) {
       return;
     }
 
-    if (!constraintFn) {
-      segmentationScalarData[index] = segmentIndex;
-      return;
-    }
-
-    if (constraintFn(pointIJK)) {
-      segmentationScalarData[index] = segmentIndex;
-    }
+    segmentationScalarData[index] = segmentIndex;
   };
 
   pointInShapeCallback(
@@ -91,7 +83,6 @@ function fillRectangle(
  * @param toolGroupId - The unique identifier of the tool group.
  * @param operationData - The data that will be used to create the
  * new rectangle.
- * @param constraintFn - can be used to perform threshold segmentation
  */
 export function fillInsideRectangle(
   enabledElement: Types.IEnabledElement,
@@ -105,7 +96,6 @@ export function fillInsideRectangle(
  * @param toolGroupId - The unique identifier of the tool group.
  * @param operationData - The data that will be used to create the
  * new rectangle.
- * @param constraintFn - can be used to perform threshold segmentation
  */
 export function fillOutsideRectangle(
   enabledElement: Types.IEnabledElement,

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

@@ -1,94 +1,97 @@
 import type { Types } from '@cornerstonejs/core';
-import { cache, utilities as csUtils } from '@cornerstonejs/core';
-
-import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
-import { pointInSurroundingSphereCallback } from '../../../utilities';
-import isWithinThreshold from './utils/isWithinThreshold';
-import { LabelmapToolOperationData } from '../../../types';
-import { getStrategyData } from './utils/getStrategyData';
-import { isVolumeSegmentation } from './utils/stackVolumeCheck';
-
-type OperationData = LabelmapToolOperationData & {
-  points: [Types.Point3, Types.Point3, Types.Point3, Types.Point3];
-};
-
-function fillSphere(
-  enabledElement: Types.IEnabledElement,
-  operationData: OperationData,
-  _inside = true,
-  threshold = false
-): void {
-  const { viewport } = enabledElement;
-  const {
-    segmentsLocked,
-    segmentIndex,
-    strategySpecificConfiguration,
-    points,
-  } = operationData;
-
-  const strategyData = getStrategyData({ operationData, viewport });
-
-  if (!strategyData) {
-    console.warn('No data found for fillSphere');
-    return;
-  }
-
-  const { imageScalarData, segmentationImageData, segmentationScalarData } =
-    strategyData;
-
-  const scalarIndex = [];
-
-  let callback;
-
-  if (threshold) {
-    callback = ({ value, index }) => {
-      if (segmentsLocked.includes(value)) {
-        return;
-      }
-
-      if (
-        isWithinThreshold(index, imageScalarData, strategySpecificConfiguration)
-      ) {
-        segmentationScalarData[index] = segmentIndex;
-        scalarIndex.push(index);
-      }
-    };
-  } else {
-    callback = ({ index, value }) => {
-      if (segmentsLocked.includes(value)) {
-        return;
-      }
-      segmentationScalarData[index] = segmentIndex;
-      scalarIndex.push(index);
-    };
-  }
-
-  pointInSurroundingSphereCallback(
-    segmentationImageData,
-    [points[0], points[1]],
-    callback,
-    viewport as Types.IVolumeViewport
-  );
-
-  const dimensions = segmentationImageData.getDimensions();
-
-  let sliceArray;
-  if (isVolumeSegmentation(operationData)) {
-    // Since the scalar indexes start from the top left corner of the cube, the first
-    // slice that needs to be rendered can be calculated from the first mask coordinate
-    // divided by the zMultiple, as well as the last slice for the last coordinate
-    const zMultiple = dimensions[0] * dimensions[1];
-    const minSlice = Math.floor(scalarIndex[0] / zMultiple);
-    const maxSlice = Math.floor(
-      scalarIndex[scalarIndex.length - 1] / zMultiple
+import { utilities as csUtils } from '@cornerstonejs/core';
+import { vec3 } from 'gl-matrix';
+
+import { getCanvasEllipseCorners } from '../../../utilities/math/ellipse';
+import { getBoundingBoxAroundShape } from '../../../utilities/boundingBox';
+import BrushStrategy from './BrushStrategy';
+import type { InitializedOperationData, Composition } from './BrushStrategy';
+import type { CanvasCoordinates } from '../../../types';
+import compositions from './compositions';
+import StrategyCallbacks from '../../../enums/StrategyCallbacks';
+import { createEllipseInPoint } from './fillCircle';
+const { transformWorldToIndex } = csUtils;
+
+const sphereComposition = {
+  [StrategyCallbacks.Initialize]: (operationData: InitializedOperationData) => {
+    const {
+      points,
+      imageVoxelManager: imageVoxelManager,
+      viewport,
+      segmentationImageData,
+      segmentationVoxelManager: segmentationVoxelManager,
+    } = operationData;
+
+    // Happens on a preview setup
+    if (!points) {
+      return;
+    }
+    // Average the points to get the center of the ellipse
+    const center = vec3.fromValues(0, 0, 0);
+    points.forEach((point) => {
+      vec3.add(center, center, point);
+    });
+    vec3.scale(center, center, 1 / points.length);
+
+    operationData.centerWorld = center as Types.Point3;
+    operationData.centerIJK = transformWorldToIndex(
+      segmentationImageData,
+      center as Types.Point3
     );
-    sliceArray = Array.from(
-      { length: maxSlice - minSlice + 1 },
-      (v, k) => k + minSlice
+    const canvasCoordinates = points.map((p) =>
+      viewport.worldToCanvas(p)
+    ) as CanvasCoordinates;
+
+    // 1. From the drawn tool: Get the ellipse (circle) topLeft and bottomRight
+    // corners in canvas coordinates
+    const [topLeftCanvas, bottomRightCanvas] =
+      getCanvasEllipseCorners(canvasCoordinates);
+
+    // 2. Find the extent of the ellipse (circle) in IJK index space of the image
+    const topLeftWorld = viewport.canvasToWorld(topLeftCanvas);
+    const bottomRightWorld = viewport.canvasToWorld(bottomRightCanvas);
+    // This will be 2d, now expand to 3d
+    const diameters = topLeftWorld.map((left, index) =>
+      Math.abs(bottomRightWorld[index] - left)
     );
-    triggerSegmentationDataModified(operationData.volumeId, sliceArray);
-  }
-}
+    const radius = Math.max(...diameters) / 2;
+    // Make 3d sphere
+    topLeftWorld.forEach((left, index) => {
+      const right = bottomRightWorld[index];
+      if (left === right) {
+        topLeftWorld[index] = left - radius;
+        bottomRightWorld[index] = left + radius;
+      }
+    });
+
+    const ellipsoidCornersIJK = [
+      <Types.Point3>transformWorldToIndex(segmentationImageData, topLeftWorld),
+      <Types.Point3>(
+        transformWorldToIndex(segmentationImageData, bottomRightWorld)
+      ),
+    ];
+
+    segmentationVoxelManager.boundsIJK = getBoundingBoxAroundShape(
+      ellipsoidCornersIJK,
+      segmentationVoxelManager.dimensions
+    );
+
+    imageVoxelManager.isInObject = createEllipseInPoint({
+      topLeftWorld,
+      bottomRightWorld,
+      center,
+    });
+  },
+} as Composition;
+
+const SPHERE_STRATEGY = new BrushStrategy(
+  'Sphere',
+  compositions.regionFill,
+  compositions.setValue,
+  sphereComposition,
+  compositions.determineSegmentIndex,
+  compositions.preview
+);
 
 /**
  * Fill inside a sphere with the given segment index in the given operation data. The
@@ -96,12 +99,15 @@ function fillSphere(
  * @param enabledElement - The element that is enabled and selected.
  * @param operationData - OperationData
  */
-export function fillInsideSphere(
-  enabledElement: Types.IEnabledElement,
-  operationData: OperationData
-): void {
-  fillSphere(enabledElement, operationData, true);
-}
+const fillInsideSphere = SPHERE_STRATEGY.strategyFunction;
+
+const SPHERE_THRESHOLD_STRATEGY = new BrushStrategy(
+  'SphereThreshold',
+  ...SPHERE_STRATEGY.compositions,
+  compositions.dynamicThreshold,
+  compositions.threshold,
+  compositions.islandRemoval
+);
 
 /**
  * Fill inside the circular region segment inside the segmentation defined by the operationData.
@@ -109,28 +115,8 @@ export function fillInsideSphere(
  * @param enabledElement - The element for which the segment is being filled.
  * @param operationData - EraseOperationData
  */
-export function thresholdInsideSphere(
-  enabledElement: Types.IEnabledElement,
-  operationData: OperationData
-): void {
-  if (isVolumeSegmentation(operationData)) {
-    const { referencedVolumeId, volumeId } = operationData;
-
-    const imageVolume = cache.getVolume(referencedVolumeId);
-    const segmentation = cache.getVolume(volumeId);
-
-    if (
-      !csUtils.isEqual(segmentation.dimensions, imageVolume.dimensions) ||
-      !csUtils.isEqual(segmentation.direction, imageVolume.direction)
-    ) {
-      throw new Error(
-        'Only source data the same dimensions/size/orientation as the segmentation currently supported.'
-      );
-    }
-  }
 
-  fillSphere(enabledElement, operationData, true, true);
-}
+const thresholdInsideSphere = SPHERE_THRESHOLD_STRATEGY.strategyFunction;
 
 /**
  * Fill outside a sphere with the given segment index in the given operation data. The
@@ -138,9 +124,8 @@ export function thresholdInsideSphere(
  * @param enabledElement - The element that is enabled and selected.
  * @param operationData - OperationData
  */
-export function fillOutsideSphere(
-  enabledElement: Types.IEnabledElement,
-  operationData: OperationData
-): void {
-  fillSphere(enabledElement, operationData, false);
+export function fillOutsideSphere(): void {
+  throw new Error('fill outside sphere not implemented');
 }
+
+export { fillInsideSphere, thresholdInsideSphere, SPHERE_STRATEGY };