@cornerstonejs/tools 1.36.3 → 1.37.1

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

@@ -0,0 +1,179 @@
+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, index) => {
+      // @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,138 @@
+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';
+
+/**
+ * Sets up a preview to use an alternate set of colours.  First fills the
+ * preview segment index with the final one for all pixels, then resets
+ * the preview colours.
+ * 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 || segmentColor.map((it) => it * 0.9);
+    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,
+      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,35 @@
+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: imageVoxelManager,
+      strategySpecificConfiguration,
+      segmentIndex,
+    } = operationData;
+    if (!strategySpecificConfiguration || !segmentIndex) {
+      return;
+    }
+    return (index) => {
+      const { THRESHOLD, THRESHOLD_INSIDE_CIRCLE } =
+        strategySpecificConfiguration;
+
+      const voxelValue = imageVoxelManager.getAtIndex(index);
+      // 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] <= voxelValue && voxelValue <= threshold[1];
+    };
+  },
+};

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

@@ -1,22 +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';
-import { LabelmapToolOperationData } from '../../../types';
+const ERASE_CIRCLE_STRATEGY = new BrushStrategy(
+  'EraseCircle',
+  compositions.erase,
+  ...CIRCLE_STRATEGY.compositions
+);
 
-type OperationData = LabelmapToolOperationData & {
-  points: any; // todo fix
-};
+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/eraseSphere.ts

@@ -1,21 +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';
-import { LabelmapToolOperationData } from '../../../types';
+const ERASE_SPHERE_STRATEGY = new BrushStrategy(
+  'EraseSphere',
+  compositions.erase,
+  ...SPHERE_STRATEGY.compositions
+);
 
-type OperationData = LabelmapToolOperationData & {
-  points: [Types.Point3, Types.Point3, Types.Point3, Types.Point3];
-};
+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 };