@cornerstonejs/tools 2.0.0-beta.6 → 2.0.0-beta.7

package/src/tools/segmentation/strategies/compositions/islandRemoval.ts

@@ -0,0 +1,178 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+import floodFill from '../../../../utilities/segmentation/floodFill';
+import { triggerSegmentationDataModified } from '../../../../stateManagement/segmentation/triggerSegmentationEvents';
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+
+/**
+ * Removes external islands and fills internal islands.
+ * External islands are areas of preview which are not connected via fill or
+ * preview colours to the clicked/dragged over points.
+ * Internal islands are areas of non-preview which are entirely surrounded by
+ * colours connected to the clicked/dragged over points.
+ */
+export default {
+  [StrategyCallbacks.OnInteractionEnd]: (
+    operationData: InitializedOperationData
+  ) => {
+    const {
+      previewVoxelManager: previewVoxelManager,
+      segmentationVoxelManager: segmentationVoxelManager,
+      strategySpecificConfiguration,
+      previewSegmentIndex,
+      segmentIndex,
+    } = operationData;
+
+    if (!strategySpecificConfiguration.THRESHOLD || segmentIndex === null) {
+      return;
+    }
+
+    const clickedPoints = previewVoxelManager.getPoints();
+    if (!clickedPoints?.length) {
+      return;
+    }
+
+    if (previewSegmentIndex === undefined) {
+      return;
+    }
+
+    // Ensure the bounds includes the clicked points, otherwise the fill
+    // fails.
+    const boundsIJK = previewVoxelManager
+      .getBoundsIJK()
+      .map((bound, i) => [
+        Math.min(bound[0], ...clickedPoints.map((point) => point[i])),
+        Math.max(bound[1], ...clickedPoints.map((point) => point[i])),
+      ]);
+
+    if (boundsIJK.find((it) => it[0] < 0 || it[1] > 65535)) {
+      // Nothing done, so just skip this
+      return;
+    }
+
+    const floodedSet = new Set<number>();
+    // Returns true for new colour, and false otherwise
+    const getter = (i, j, k) => {
+      if (
+        i < boundsIJK[0][0] ||
+        i > boundsIJK[0][1] ||
+        j < boundsIJK[1][0] ||
+        j > boundsIJK[1][1] ||
+        k < boundsIJK[2][0] ||
+        k > boundsIJK[2][1]
+      ) {
+        return -1;
+      }
+      const index = segmentationVoxelManager.toIndex([i, j, k]);
+      if (floodedSet.has(index)) {
+        // Values already flooded
+        return -2;
+      }
+      const oldVal = segmentationVoxelManager.getAtIndex(index);
+      const isIn =
+        oldVal === previewSegmentIndex || oldVal === segmentIndex ? 1 : 0;
+      if (!isIn) {
+        segmentationVoxelManager.addPoint(index);
+      }
+      // 1 is values that are preview/segment index, 0 is everything else
+      return isIn;
+    };
+
+    let floodedCount = 0;
+
+    const onFlood = (i, j, k) => {
+      const index = segmentationVoxelManager.toIndex([i, j, k]);
+      if (floodedSet.has(index)) {
+        return;
+      }
+      // Fill this point with an indicator that this point is connected
+      previewVoxelManager.setAtIJK(i, j, k, previewSegmentIndex);
+      floodedSet.add(index);
+      floodedCount++;
+    };
+    clickedPoints.forEach((clickedPoint) => {
+      // @ts-ignore - need to ignore the spread appication to array params
+      if (getter(...clickedPoint) === 1) {
+        floodFill(getter, clickedPoint, {
+          onFlood,
+          diagonals: true,
+        });
+      }
+    });
+
+    let clearedCount = 0;
+    let previewCount = 0;
+
+    const callback = ({ index, pointIJK, value: trackValue }) => {
+      const value = segmentationVoxelManager.getAtIndex(index);
+      if (floodedSet.has(index)) {
+        previewCount++;
+        const newValue =
+          trackValue === segmentIndex ? segmentIndex : previewSegmentIndex;
+        previewVoxelManager.setAtIJKPoint(pointIJK, newValue);
+      } else if (value === previewSegmentIndex) {
+        clearedCount++;
+        const newValue = trackValue ?? 0;
+        previewVoxelManager.setAtIJKPoint(pointIJK, newValue);
+      }
+    };
+
+    previewVoxelManager.forEach(callback, {});
+
+    if (floodedCount - previewCount !== 0) {
+      console.warn(
+        'There were flooded=',
+        floodedCount,
+        'cleared=',
+        clearedCount,
+        'preview count=',
+        previewCount,
+        'not handled',
+        floodedCount - previewCount
+      );
+    }
+    const islandMap = new Set(segmentationVoxelManager.points || []);
+    floodedSet.clear();
+
+    for (const index of islandMap.keys()) {
+      if (floodedSet.has(index)) {
+        continue;
+      }
+      let isInternal = true;
+      const internalSet = new Set<number>();
+      const onFloodInternal = (i, j, k) => {
+        const floodIndex = previewVoxelManager.toIndex([i, j, k]);
+        floodedSet.add(floodIndex);
+        if (
+          (boundsIJK[0][0] !== boundsIJK[0][1] &&
+            (i === boundsIJK[0][0] || i === boundsIJK[0][1])) ||
+          (boundsIJK[1][0] !== boundsIJK[1][1] &&
+            (j === boundsIJK[1][0] || j === boundsIJK[1][1])) ||
+          (boundsIJK[2][0] !== boundsIJK[2][1] &&
+            (k === boundsIJK[2][0] || k === boundsIJK[2][1]))
+        ) {
+          isInternal = false;
+        }
+        if (isInternal) {
+          internalSet.add(floodIndex);
+        }
+      };
+      const pointIJK = previewVoxelManager.toIJK(index);
+      if (getter(...pointIJK) !== 0) {
+        continue;
+      }
+      floodFill(getter, pointIJK, {
+        onFlood: onFloodInternal,
+        diagonals: false,
+      });
+      if (isInternal) {
+        for (const index of internalSet) {
+          previewVoxelManager.setAtIndex(index, previewSegmentIndex);
+        }
+      }
+    }
+    triggerSegmentationDataModified(
+      operationData.segmentationId,
+      previewVoxelManager.getArrayOfSlices()
+    );
+  },
+};

package/src/tools/segmentation/strategies/compositions/preview.ts

@@ -0,0 +1,148 @@
+import type { Types } from '@cornerstonejs/core';
+import type { InitializedOperationData } from '../BrushStrategy';
+import { triggerSegmentationDataModified } from '../../../../stateManagement/segmentation/triggerSegmentationEvents';
+import { config as segmentationConfig } from '../../../../stateManagement/segmentation';
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+
+function lightenColor(r, g, b, a, factor = 0.4) {
+  return [
+    Math.round(r + (255 - r) * factor),
+    Math.round(g + (255 - g) * factor),
+    Math.round(b + (255 - b) * factor),
+    a,
+  ];
+}
+
+/**
+ * Sets up a preview to use an alternate set of colors.  First fills the
+ * preview segment index with the final one for all pixels, then resets
+ * the preview colors.
+ * This is only activated when the preview segment index is defined, either
+ * from the initial state or from the global state.
+ */
+export default {
+  [StrategyCallbacks.Preview]: function (
+    operationData: InitializedOperationData
+  ) {
+    const { previewColors, strategySpecificConfiguration, enabledElement } =
+      operationData;
+    if (!previewColors || !strategySpecificConfiguration) {
+      return;
+    }
+
+    // Clean up old preview data
+    if (operationData.preview) {
+      delete operationData.preview;
+    }
+    delete strategySpecificConfiguration.centerSegmentIndex;
+
+    // Now generate a normal preview as though the user had clicked, filled, released
+    this.onInteractionStart?.(enabledElement, operationData);
+    const preview = this.fill(enabledElement, operationData);
+    if (preview) {
+      preview.isPreviewFromHover = true;
+      operationData.preview = preview;
+      this.onInteractionEnd?.(enabledElement, operationData);
+    }
+    return preview;
+  },
+
+  [StrategyCallbacks.Initialize]: (operationData: InitializedOperationData) => {
+    const {
+      toolGroupId,
+      segmentIndex,
+      segmentationRepresentationUID,
+      previewSegmentIndex,
+      previewColors,
+      preview,
+    } = operationData;
+    if (previewColors === undefined) {
+      return;
+    }
+    if (preview) {
+      preview.previewVoxelManager.sourceVoxelManager =
+        operationData.segmentationVoxelManager;
+      // And use the preview data associated with this tracking object as needed
+      operationData.previewVoxelManager = preview.previewVoxelManager;
+    }
+
+    if (segmentIndex === null || !previewSegmentIndex) {
+      // Null means to reset the value, so we don't change the preview colour
+      return;
+    }
+
+    const configColor = previewColors?.[segmentIndex];
+    const segmentColor = segmentationConfig.color.getColorForSegmentIndex(
+      toolGroupId,
+      segmentationRepresentationUID,
+      segmentIndex
+    );
+    if (!configColor && !segmentColor) {
+      return;
+    }
+    const previewColor = configColor || lightenColor(...segmentColor);
+
+    segmentationConfig.color.setColorForSegmentIndex(
+      toolGroupId,
+      segmentationRepresentationUID,
+      previewSegmentIndex,
+      previewColor as Types.Color
+    );
+  },
+
+  [StrategyCallbacks.AcceptPreview]: (
+    operationData: InitializedOperationData
+  ) => {
+    const {
+      segmentationVoxelManager: segmentationVoxelManager,
+      previewVoxelManager: previewVoxelManager,
+      previewSegmentIndex,
+      preview,
+    } = operationData || {};
+    if (previewSegmentIndex === undefined) {
+      return;
+    }
+    const segmentIndex = preview?.segmentIndex ?? operationData.segmentIndex;
+    const tracking = previewVoxelManager;
+    if (!tracking || tracking.modifiedSlices.size === 0) {
+      return;
+    }
+
+    const callback = ({ index }) => {
+      const oldValue = segmentationVoxelManager.getAtIndex(index);
+      if (oldValue === previewSegmentIndex) {
+        segmentationVoxelManager.setAtIndex(index, segmentIndex);
+      }
+    };
+    tracking.forEach(callback, {});
+
+    triggerSegmentationDataModified(
+      operationData.segmentationId,
+      tracking.getArrayOfSlices()
+    );
+    tracking.clear();
+  },
+
+  [StrategyCallbacks.RejectPreview]: (
+    operationData: InitializedOperationData
+  ) => {
+    const {
+      previewVoxelManager: previewVoxelManager,
+      segmentationVoxelManager: segmentationVoxelManager,
+    } = operationData;
+    if (previewVoxelManager.modifiedSlices.size === 0) {
+      return;
+    }
+
+    const callback = ({ index, value }) => {
+      segmentationVoxelManager.setAtIndex(index, value);
+    };
+    previewVoxelManager.forEach(callback);
+
+    triggerSegmentationDataModified(
+      operationData.segmentationId,
+      previewVoxelManager.getArrayOfSlices()
+    );
+    previewVoxelManager.clear();
+  },
+};

package/src/tools/segmentation/strategies/compositions/regionFill.ts

@@ -0,0 +1,45 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+import pointInShapeCallback from '../../../../utilities/pointInShapeCallback';
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+
+/**
+ * Creates a fill strategy that uses the isWithinThreshold created by the
+ * createIsInThreshold and the bounds specified in the boundsIJK to go over
+ * the specified area, checking if in threshold, and if so, filling that area
+ * with the new segment by calling the setValue function.
+ */
+export default {
+  [StrategyCallbacks.Fill]: (operationData: InitializedOperationData) => {
+    const {
+      segmentsLocked,
+      segmentationImageData,
+      segmentationVoxelManager: segmentationVoxelManager,
+      previewVoxelManager: previewVoxelManager,
+      imageVoxelManager: imageVoxelManager,
+      brushStrategy,
+      centerIJK,
+    } = operationData;
+    const isWithinThreshold =
+      brushStrategy.createIsInThreshold?.(operationData);
+    const { setValue } = brushStrategy;
+
+    const callback = isWithinThreshold
+      ? (data) => {
+          const { value, index } = data;
+          if (segmentsLocked.includes(value) || !isWithinThreshold(index)) {
+            return;
+          }
+          setValue(operationData, data);
+        }
+      : (data) => setValue(operationData, data);
+
+    pointInShapeCallback(
+      segmentationImageData as unknown,
+      imageVoxelManager?.isInObject || segmentationVoxelManager.isInObject,
+      callback,
+      segmentationVoxelManager.boundsIJK
+    );
+
+    previewVoxelManager.addPoint(centerIJK);
+  },
+};

package/src/tools/segmentation/strategies/compositions/setValue.ts

@@ -0,0 +1,50 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+
+/**
+ * Creates a set value function which will apply the specified segmentIndex
+ * to the given location.
+ * If segmentIndex is null, it will clear the given segment index instead
+ * This is all done through the previewVoxelManager so that values can be recorded
+ * as changed, and the original values remembered.
+ */
+export default {
+  [StrategyCallbacks.INTERNAL_setValue]: (
+    operationData: InitializedOperationData,
+    { value, index }
+  ) => {
+    const {
+      segmentsLocked,
+      segmentIndex,
+      previewVoxelManager: previewVoxelManager,
+      previewSegmentIndex,
+      segmentationVoxelManager: segmentationVoxelManager,
+    } = operationData;
+    const existingValue = segmentationVoxelManager.getAtIndex(index);
+    if (segmentIndex === null) {
+      const oldValue = previewVoxelManager.getAtIndex(index);
+      if (oldValue !== undefined) {
+        previewVoxelManager.setAtIndex(index, oldValue);
+      }
+      return;
+    }
+
+    if (existingValue === segmentIndex || segmentsLocked.includes(value)) {
+      return;
+    }
+    // Correct for preview data getting into the image area and not accepted/rejected
+    if (existingValue === previewSegmentIndex) {
+      if (previewVoxelManager.getAtIndex(index) === undefined) {
+        // Reset the value to ensure preview gets added to the indices
+        segmentationVoxelManager.setAtIndex(index, segmentIndex);
+      } else {
+        return;
+      }
+    }
+
+    // Now, just update the displayed value
+    const useSegmentIndex = previewSegmentIndex ?? segmentIndex;
+
+    previewVoxelManager.setAtIndex(index, useSegmentIndex);
+  },
+};

package/src/tools/segmentation/strategies/compositions/threshold.ts

@@ -0,0 +1,37 @@
+import { vec3 } from 'gl-matrix';
+import type { Types } from '@cornerstonejs/core';
+import type { InitializedOperationData } from '../BrushStrategy';
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+
+/**
+ * Adds an isWithinThreshold to the operation data that checks that the
+ * image value is within threshold[0]...threshold[1]
+ * No-op if threshold not defined.
+ */
+export default {
+  [StrategyCallbacks.CreateIsInThreshold]: (
+    operationData: InitializedOperationData
+  ) => {
+    const { imageVoxelManager, strategySpecificConfiguration, segmentIndex } =
+      operationData;
+    if (!strategySpecificConfiguration || !segmentIndex) {
+      return;
+    }
+    return (index) => {
+      const { THRESHOLD, THRESHOLD_INSIDE_CIRCLE } =
+        strategySpecificConfiguration;
+
+      const voxelValue = imageVoxelManager.getAtIndex(index);
+      const gray = Array.isArray(voxelValue)
+        ? vec3.length(voxelValue as Types.Point3)
+        : voxelValue;
+      // Prefer the generic version of the THRESHOLD configuration, but fallback
+      // to the older THRESHOLD_INSIDE_CIRCLE version.
+      const { threshold } = THRESHOLD || THRESHOLD_INSIDE_CIRCLE || {};
+      if (!threshold?.length) {
+        return true;
+      }
+      return threshold[0] <= gray && gray <= threshold[1];
+    };
+  },
+};

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

@@ -1,30 +1,13 @@
-import type { Types } from '@cornerstonejs/core';
+import BrushStrategy from './BrushStrategy';
+import { CIRCLE_STRATEGY } from './fillCircle';
+import compositions from './compositions';
 
-import { fillInsideCircle } from './fillCircle';
+const ERASE_CIRCLE_STRATEGY = new BrushStrategy(
+  'EraseCircle',
+  compositions.erase,
+  ...CIRCLE_STRATEGY.compositions
+);
 
-type OperationData = {
-  segmentationId: string;
-  imageVolume: Types.IImageVolume;
-  points: any; // Todo:fix
-  volume: Types.IImageVolume;
-  segmentIndex: number;
-  segmentsLocked: number[];
-  viewPlaneNormal: number[];
-  viewUp: number[];
-  strategySpecificConfiguration: any;
-  constraintFn: () => boolean;
-};
+const eraseInsideCircle = ERASE_CIRCLE_STRATEGY.strategyFunction;
 
-export function eraseInsideCircle(
-  enabledElement: Types.IEnabledElement,
-  operationData: OperationData
-): void {
-  // Take the arguments and set the segmentIndex to 0,
-  // Then use existing fillInsideCircle functionality.
-  const eraseOperationData = {
-    ...operationData,
-    segmentIndex: 0,
-  };
-
-  fillInsideCircle(enabledElement, eraseOperationData);
-}
+export { eraseInsideCircle };

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

@@ -1,64 +1,35 @@
-import { ImageVolume, utilities as csUtils } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 
-import { getBoundingBoxAroundShape } from '../../../utilities/boundingBox';
-import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
-import { pointInShapeCallback } from '../../../utilities';
+import { LabelmapToolOperationData } from '../../../types';
+import { fillInsideRectangle } from './fillRectangle';
 
-const { transformWorldToIndex } = csUtils;
-
-type EraseOperationData = {
-  segmentationId: string;
+type OperationData = LabelmapToolOperationData & {
   points: [Types.Point3, Types.Point3, Types.Point3, Types.Point3];
-  volume: ImageVolume;
-  constraintFn: (x: [number, number, number]) => boolean;
-  segmentsLocked: number[];
 };
 
 function eraseRectangle(
   enabledElement: Types.IEnabledElement,
-  operationData: EraseOperationData,
+  operationData: OperationData,
   inside = true
 ): void {
-  const {
-    volume: segmentation,
-    points,
-    segmentsLocked,
-    segmentationId,
-  } = operationData;
-  const { imageData, dimensions } = segmentation;
-  const scalarData = segmentation.getScalarData();
-
-  const rectangleCornersIJK = points.map((world) => {
-    return transformWorldToIndex(imageData, world);
+  // Take the arguments and set the segmentIndex to 0,
+  // Then use existing fillRectangle functionality.
+  const eraseOperationData = Object.assign({}, operationData, {
+    segmentIndex: 0,
   });
 
-  const boundsIJK = getBoundingBoxAroundShape(rectangleCornersIJK, dimensions);
-
-  // Since always all points inside the boundsIJK is inside the rectangle...
-  const pointInShape = () => true;
-
-  const callback = ({ value, index }) => {
-    if (segmentsLocked.includes(value)) {
-      return;
-    }
-    scalarData[index] = 0;
-  };
-
-  pointInShapeCallback(imageData, pointInShape, callback, boundsIJK);
-
-  triggerSegmentationDataModified(segmentationId);
+  fillInsideRectangle(enabledElement, eraseOperationData);
 }
 
 /**
  * Erase the rectangle region segment inside the segmentation defined by the operationData.
  * It erases the segmentation pixels inside the defined rectangle.
  * @param enabledElement - The element for which the segment is being erased.
- * @param operationData - EraseOperationData
+ * @param operationData - OperationData
  */
 export function eraseInsideRectangle(
   enabledElement: Types.IEnabledElement,
-  operationData: EraseOperationData
+  operationData: OperationData
 ): void {
   eraseRectangle(enabledElement, operationData, true);
 }
@@ -67,11 +38,11 @@ export function eraseInsideRectangle(
  * Erase the rectangle region segment inside the segmentation defined by the operationData.
  * It erases the segmentation pixels outside the defined rectangle.
  * @param enabledElement - The element for which the segment is being erased.
- * @param operationData - EraseOperationData
+ * @param operationData - OperationData
  */
 export function eraseOutsideRectangle(
   enabledElement: Types.IEnabledElement,
-  operationData: EraseOperationData
+  operationData: OperationData
 ): void {
   eraseRectangle(enabledElement, operationData, false);
 }

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

@@ -1,29 +1,13 @@
-import type { Types } from '@cornerstonejs/core';
+import BrushStrategy from './BrushStrategy';
+import { SPHERE_STRATEGY } from './fillSphere';
+import compositions from './compositions';
 
-import { fillInsideSphere } from './fillSphere';
+const ERASE_SPHERE_STRATEGY = new BrushStrategy(
+  'EraseSphere',
+  compositions.erase,
+  ...SPHERE_STRATEGY.compositions
+);
 
-type OperationData = {
-  points: [Types.Point3, Types.Point3, Types.Point3, Types.Point3];
-  imageVolume: Types.IImageVolume;
-  volume: Types.IImageVolume;
-  segmentIndex: number;
-  segmentationId: string;
-  segmentsLocked: number[];
-  viewPlaneNormal: Types.Point3;
-  viewUp: Types.Point3;
-  constraintFn: () => boolean;
-  strategySpecificConfiguration: any;
-};
+const eraseInsideSphere = ERASE_SPHERE_STRATEGY.strategyFunction;
 
-export function eraseInsideSphere(
-  enabledElement: Types.IEnabledElement,
-  operationData: OperationData
-): void {
-  // Take the arguments and set the segmentIndex to 0,
-  // Then use existing fillInsideCircle functionality.
-  const eraseOperationData = Object.assign({}, operationData, {
-    segmentIndex: 0,
-  });
-
-  fillInsideSphere(enabledElement, eraseOperationData);
-}
+export { eraseInsideSphere };