@cornerstonejs/tools 1.32.3 → 1.34.0

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

@@ -1,5 +1,6 @@
 import { vec3 } from 'gl-matrix';
 import type { Types } from '@cornerstonejs/core';
+import { cache } from '@cornerstonejs/core';
 import { utilities as csUtils } from '@cornerstonejs/core';
 
 import {
@@ -10,20 +11,14 @@ 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';
 
 const { transformWorldToIndex } = csUtils;
 
-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;
+type OperationData = LabelmapToolOperationData & {
+  points: [Types.Point3, Types.Point3, Types.Point3, Types.Point3];
 };
 
 function fillCircle(
@@ -32,50 +27,29 @@ function fillCircle(
   threshold = false
 ): void {
   const {
-    volume: segmentationVolume,
-    imageVolume,
     points,
     segmentsLocked,
     segmentIndex,
     segmentationId,
     strategySpecificConfiguration,
   } = operationData;
-  const { imageData, dimensions } = segmentationVolume;
-  const scalarData = segmentationVolume.getScalarData();
-  const { viewport } = enabledElement;
-
-  // 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);
-
-  const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
 
-  // 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 { viewport } = enabledElement;
+  const data = getStrategyData({ operationData, viewport });
 
-  const ellipsoidCornersIJK = [
-    <Types.Point3>transformWorldToIndex(imageData, topLeftWorld),
-    <Types.Point3>transformWorldToIndex(imageData, bottomRightWorld),
-  ];
+  if (!data) {
+    console.warn('No data found for fillCircle');
+    return;
+  }
 
-  const boundsIJK = getBoundingBoxAroundShape(ellipsoidCornersIJK, dimensions);
+  const { imageScalarData, segmentationImageData, segmentationScalarData } =
+    data;
 
-  // 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,
-  };
+  const { ellipseObj, boundsIJK } = getEllipse(
+    viewport,
+    segmentationImageData,
+    points
+  );
 
   const modifiedSlicesToUse = new Set() as Set<number>;
 
@@ -88,9 +62,9 @@ function fillCircle(
       }
 
       if (
-        isWithinThreshold(index, imageVolume, strategySpecificConfiguration)
+        isWithinThreshold(index, imageScalarData, strategySpecificConfiguration)
       ) {
-        scalarData[index] = segmentIndex;
+        segmentationScalarData[index] = segmentIndex;
         //Todo: I don't think this will always be index 2 in streamingImageVolume?
         modifiedSlicesToUse.add(pointIJK[2]);
       }
@@ -100,15 +74,17 @@ function fillCircle(
       if (segmentsLocked.includes(value)) {
         return;
       }
-      scalarData[index] = segmentIndex;
-      //Todo: I don't think this will always be index 2 in streamingImageVolume?
+      segmentationScalarData[index] = segmentIndex;
       modifiedSlicesToUse.add(pointIJK[2]);
     };
   }
 
   pointInShapeCallback(
-    imageData,
-    (pointLPS, pointIJK) => pointInEllipse(ellipseObj, pointLPS),
+    segmentationImageData,
+    (pointLPS) =>
+      pointInEllipse(ellipseObj, pointLPS, {
+        fast: true,
+      }),
     callback,
     boundsIJK
   );
@@ -141,15 +117,20 @@ export function thresholdInsideCircle(
   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.'
-    );
+  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);
@@ -158,7 +139,7 @@ export function thresholdInsideCircle(
 /**
  * Fill outside the circular region segment inside the segmentation defined by the operationData.
  * It fills the segmentation pixels outside the  defined circle.
- * @param enabledElement - The element for which the segment is being erased.
+j * @param enabledElement - The element for which the segment is being erased.
  * @param operationData - EraseOperationData
  */
 export function fillOutsideCircle(
@@ -167,3 +148,54 @@ export function fillOutsideCircle(
 ): 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;
+}
+
+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 };
+}

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

@@ -1,19 +1,16 @@
-import { ImageVolume, utilities as csUtils } from '@cornerstonejs/core';
+import { utilities as csUtils } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 
 import { getBoundingBoxAroundShape } from '../../../utilities/boundingBox';
 import { pointInShapeCallback } from '../../../utilities';
 import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
+import { LabelmapToolOperationData } from '../../../types';
+import { getStrategyData } from './utils/getStrategyData';
 
 const { transformWorldToIndex } = csUtils;
 
-type OperationData = {
-  segmentationId: string;
+type OperationData = LabelmapToolOperationData & {
   points: [Types.Point3, Types.Point3, Types.Point3, Types.Point3];
-  volume: ImageVolume;
-  constraintFn: (x: [number, number, number]) => boolean;
-  segmentIndex: number;
-  segmentsLocked: number[];
 };
 
 /**
@@ -30,19 +27,23 @@ function fillRectangle(
   operationData: OperationData,
   inside = true
 ): void {
-  const {
-    volume: segmentation,
-    points,
-    segmentsLocked,
-    segmentIndex,
-    segmentationId,
-    constraintFn,
-  } = operationData;
-  const { imageData, dimensions } = segmentation;
-  const scalarData = segmentation.getScalarData();
+  const { points, segmentsLocked, segmentIndex, segmentationId, constraintFn } =
+    operationData;
+
+  const strategyData = getStrategyData({
+    operationData,
+    viewport: enabledElement.viewport,
+  });
+
+  if (!strategyData) {
+    console.warn('No data found for fillRectangle');
+    return;
+  }
+
+  const { segmentationImageData, segmentationScalarData } = strategyData;
 
   let rectangleCornersIJK = points.map((world) => {
-    return transformWorldToIndex(imageData, world);
+    return transformWorldToIndex(segmentationImageData, world);
   });
 
   // math round
@@ -52,7 +53,10 @@ function fillRectangle(
     });
   });
 
-  const boundsIJK = getBoundingBoxAroundShape(rectangleCornersIJK, dimensions);
+  const boundsIJK = getBoundingBoxAroundShape(
+    rectangleCornersIJK,
+    segmentationImageData.getDimensions()
+  );
 
   // Since always all points inside the boundsIJK is inside the rectangle...
   const pointInRectangle = () => true;
@@ -63,16 +67,21 @@ function fillRectangle(
     }
 
     if (!constraintFn) {
-      scalarData[index] = segmentIndex;
+      segmentationScalarData[index] = segmentIndex;
       return;
     }
 
     if (constraintFn(pointIJK)) {
-      scalarData[index] = segmentIndex;
+      segmentationScalarData[index] = segmentIndex;
     }
   };
 
-  pointInShapeCallback(imageData, pointInRectangle, callback, boundsIJK);
+  pointInShapeCallback(
+    segmentationImageData,
+    pointInRectangle,
+    callback,
+    boundsIJK
+  );
 
   triggerSegmentationDataModified(segmentationId);
 }

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

@@ -1,21 +1,15 @@
 import type { Types } from '@cornerstonejs/core';
-import { utilities as csUtils } 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 = {
+type OperationData = LabelmapToolOperationData & {
   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(
@@ -26,31 +20,36 @@ function fillSphere(
 ): void {
   const { viewport } = enabledElement;
   const {
-    volume: segmentation,
     segmentsLocked,
     segmentIndex,
-    imageVolume,
     strategySpecificConfiguration,
-    segmentationId,
     points,
   } = operationData;
 
-  const { imageData, dimensions } = segmentation;
-  const scalarData = segmentation.getScalarData();
+  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, pointIJK }) => {
+    callback = ({ value, index }) => {
       if (segmentsLocked.includes(value)) {
         return;
       }
 
       if (
-        isWithinThreshold(index, imageVolume, strategySpecificConfiguration)
+        isWithinThreshold(index, imageScalarData, strategySpecificConfiguration)
       ) {
-        scalarData[index] = segmentIndex;
+        segmentationScalarData[index] = segmentIndex;
         scalarIndex.push(index);
       }
     };
@@ -59,30 +58,36 @@ function fillSphere(
       if (segmentsLocked.includes(value)) {
         return;
       }
-      scalarData[index] = segmentIndex;
+      segmentationScalarData[index] = segmentIndex;
       scalarIndex.push(index);
     };
   }
 
   pointInSurroundingSphereCallback(
-    imageData,
+    segmentationImageData,
     [points[0], points[1]],
     callback,
     viewport as Types.IVolumeViewport
   );
 
-  // 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);
-  const sliceArray = Array.from(
-    { length: maxSlice - minSlice + 1 },
-    (v, k) => k + minSlice
-  );
+  const dimensions = segmentationImageData.getDimensions();
 
-  triggerSegmentationDataModified(segmentationId, sliceArray);
+  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
+    );
+    sliceArray = Array.from(
+      { length: maxSlice - minSlice + 1 },
+      (v, k) => k + minSlice
+    );
+    triggerSegmentationDataModified(operationData.volumeId, sliceArray);
+  }
 }
 
 /**
@@ -108,15 +113,20 @@ 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.'
-    );
+  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);

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

@@ -0,0 +1,58 @@
+import { cache } from '@cornerstonejs/core';
+import { isVolumeSegmentation } from './stackVolumeCheck';
+import { LabelmapToolOperationDataStack } from '../../../../types';
+
+function getStrategyData({ operationData, viewport }) {
+  let segmentationImageData, segmentationScalarData, imageScalarData;
+  if (isVolumeSegmentation(operationData)) {
+    const { volumeId, referencedVolumeId } = operationData;
+
+    const segmentationVolume = cache.getVolume(volumeId);
+    const imageVolume = cache.getVolume(referencedVolumeId);
+
+    if (!segmentationVolume || !imageVolume) {
+      return;
+    }
+
+    ({ imageData: segmentationImageData } = segmentationVolume);
+    segmentationScalarData = segmentationVolume.getScalarData();
+    imageScalarData = imageVolume.getScalarData();
+  } else {
+    const { imageIdReferenceMap, segmentationRepresentationUID } =
+      operationData as LabelmapToolOperationDataStack;
+
+    if (!imageIdReferenceMap) {
+      return;
+    }
+
+    const currentImageId = viewport.getCurrentImageId();
+    if (!currentImageId) {
+      return;
+    }
+
+    // we know that the segmentationRepresentationUID is the name of the actor always
+    // and always circle modifies the current imageId which in fact is the imageData
+    // of that actor at that moment so we have the imageData already
+    const actor = viewport.getActor(segmentationRepresentationUID);
+    segmentationImageData = actor.actor.getMapper().getInputData();
+    const currentSegmentationImageId = imageIdReferenceMap.get(currentImageId);
+
+    const segmentationImage = cache.getImage(currentSegmentationImageId);
+    segmentationScalarData = segmentationImage.getPixelData();
+
+    const image = cache.getImage(currentImageId);
+
+    // VERY IMPORTANT
+    // This is the pixel data of the image that is being segmented in the cache
+    // and we need to use this to for the modification
+    imageScalarData = image.getPixelData();
+  }
+
+  return {
+    segmentationImageData,
+    segmentationScalarData,
+    imageScalarData,
+  };
+}
+
+export { getStrategyData };

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

@@ -1,13 +1,14 @@
 import { Types } from '@cornerstonejs/core';
+import { TypedArray } from '@kitware/vtk.js/types';
 
 function isWithinThreshold(
   index: number,
-  imageVolume: Types.IImageVolume,
+  imageScalarData: TypedArray,
   strategySpecificConfiguration: any
 ) {
   const { THRESHOLD_INSIDE_CIRCLE } = strategySpecificConfiguration;
 
-  const voxelValue = imageVolume.getScalarData()[index];
+  const voxelValue = imageScalarData[index];
   const { threshold } = THRESHOLD_INSIDE_CIRCLE;
 
   return threshold[0] <= voxelValue && voxelValue <= threshold[1];

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

@@ -0,0 +1,33 @@
+import {
+  LabelmapSegmentationData,
+  LabelmapSegmentationDataStack,
+  LabelmapSegmentationDataVolume,
+} from '../../../../types/LabelmapTypes';
+import {
+  LabelmapToolOperationData,
+  LabelmapToolOperationDataStack,
+  LabelmapToolOperationDataVolume,
+} from '../../../../types';
+
+function isStackSegmentation(
+  operationData: LabelmapToolOperationData | LabelmapSegmentationData
+): operationData is
+  | LabelmapToolOperationDataStack
+  | LabelmapSegmentationDataStack {
+  return (
+    (operationData as LabelmapToolOperationDataStack).imageIdReferenceMap !==
+    undefined
+  );
+}
+
+function isVolumeSegmentation(
+  operationData: LabelmapToolOperationData | LabelmapSegmentationData
+): operationData is
+  | LabelmapToolOperationDataVolume
+  | LabelmapSegmentationDataVolume {
+  return (
+    (operationData as LabelmapToolOperationDataVolume).volumeId !== undefined
+  );
+}
+
+export { isStackSegmentation, isVolumeSegmentation };

package/src/types/LabelmapToolOperationData.ts

@@ -0,0 +1,27 @@
+import {
+  LabelmapSegmentationDataStack,
+  LabelmapSegmentationDataVolume,
+} from './LabelmapTypes';
+
+type LabelmapToolOperationData = {
+  segmentationId: string;
+  segmentIndex: number;
+  segmentsLocked: number[];
+  viewPlaneNormal: number[];
+  viewUp: number[];
+  strategySpecificConfiguration: any;
+  constraintFn: (pointIJK: number) => boolean;
+  segmentationRepresentationUID: string;
+};
+
+type LabelmapToolOperationDataStack = LabelmapToolOperationData &
+  LabelmapSegmentationDataStack;
+
+type LabelmapToolOperationDataVolume = LabelmapToolOperationData &
+  LabelmapSegmentationDataVolume;
+
+export {
+  LabelmapToolOperationData,
+  LabelmapToolOperationDataStack,
+  LabelmapToolOperationDataVolume,
+};

package/src/types/LabelmapTypes.ts

@@ -35,7 +35,22 @@ export type LabelmapRenderingConfig = {
   ofun?: vtkPiecewiseFunction;
 };
 
-export type LabelmapSegmentationData = {
+export type LabelmapSegmentationDataVolume = {
   volumeId: string;
   referencedVolumeId?: string;
 };
+
+export type LabelmapSegmentationDataStack = {
+  /**
+   * This is a Map from referenced imageId to the segmentation (Derived) imageId that
+   * has been used to create the derived labelmap.
+   * Todo: later I guess we can have it as Record<string, metadata> where metadata
+   * can contain a derived image arbitrary information, for use cases such that the labelmap is
+   * derived from another image that is irrelevant to the current viewport.
+   */
+  imageIdReferenceMap: Map<string, string>;
+};
+
+export type LabelmapSegmentationData =
+  | LabelmapSegmentationDataVolume
+  | LabelmapSegmentationDataStack;

package/src/types/index.ts

@@ -58,6 +58,11 @@ import type { ContourSegmentationData } from './ContourTypes';
 import type IAnnotationManager from './IAnnotationManager';
 import type AnnotationGroupSelector from './AnnotationGroupSelector';
 import type { Statistics } from './CalculatorTypes';
+import {
+  LabelmapToolOperationData,
+  LabelmapToolOperationDataStack,
+  LabelmapToolOperationDataVolume,
+} from './LabelmapToolOperationData';
 
 export type {
   // AnnotationState
@@ -124,4 +129,7 @@ export type {
   ContourSegmentationData,
   //Statistics
   Statistics,
+  LabelmapToolOperationData,
+  LabelmapToolOperationDataStack,
+  LabelmapToolOperationDataVolume,
 };