@cornerstonejs/tools 1.32.3 → 1.33.0

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,
 };

package/src/utilities/math/ellipse/pointInEllipse.ts

@@ -1,39 +1,60 @@
-import type { Types } from '@cornerstonejs/core';
-import { vec3 } from 'gl-matrix';
-
-type Ellipse = {
-  center: Types.Point3;
-  xRadius: number;
-  yRadius: number;
-  zRadius: number;
-};
+interface Inverts {
+  invXRadiusSq?: number;
+  invYRadiusSq?: number;
+  invZRadiusSq?: number;
+  fast?: boolean;
+}
 
 /**
  * Given an ellipse and a point, return true if the point is inside the ellipse
  * @param ellipse - The ellipse object to check against.
  * @param pointLPS - The point in LPS space to test.
+ * @param inverts - An object to cache the inverted radius squared values, if you
+ * are testing multiple points against the same ellipse then it is recommended to
+ * pass in the same object to cache the values. However, there is a simpler way
+ * to do this by passing in the fast flag as true, then on the first iteration
+ * the values will be cached and on subsequent iterations the cached values will
+ * be used.
+ *
  * @returns A boolean value.
  */
 export default function pointInEllipse(
-  ellipse: Ellipse,
-  pointLPS: vec3
-): boolean {
-  const { center: circleCenterWorld, xRadius, yRadius, zRadius } = ellipse;
-  const [x, y, z] = pointLPS;
-  const [x0, y0, z0] = circleCenterWorld;
+  ellipse,
+  pointLPS,
+  inverts: Inverts = {}
+) {
+  const { center, xRadius, yRadius, zRadius } = ellipse;
 
-  let inside = 0;
-  if (xRadius !== 0) {
-    inside += ((x - x0) * (x - x0)) / (xRadius * xRadius);
+  // This will run only once since we are caching the values in the same
+  // object that is passed in.
+  if (
+    inverts.invXRadiusSq === undefined ||
+    inverts.invYRadiusSq === undefined ||
+    inverts.invZRadiusSq === undefined
+  ) {
+    inverts.invXRadiusSq = xRadius !== 0 ? 1 / xRadius ** 2 : 0;
+    inverts.invYRadiusSq = yRadius !== 0 ? 1 / yRadius ** 2 : 0;
+    inverts.invZRadiusSq = zRadius !== 0 ? 1 / zRadius ** 2 : 0;
   }
 
-  if (yRadius !== 0) {
-    inside += ((y - y0) * (y - y0)) / (yRadius * yRadius);
+  let inside = 0;
+
+  // Calculate the sum of normalized squared distances
+  const dx = pointLPS[0] - center[0];
+  inside += dx * dx * inverts.invXRadiusSq;
+  if (inside > 1) {
+    return false;
   }
 
-  if (zRadius !== 0) {
-    inside += ((z - z0) * (z - z0)) / (zRadius * zRadius);
+  const dy = pointLPS[1] - center[1];
+  inside += dy * dy * inverts.invYRadiusSq;
+  if (inside > 1) {
+    return false;
   }
 
+  const dz = pointLPS[2] - center[2];
+  inside += dz * dz * inverts.invZRadiusSq;
+
+  // Check if the point is inside the ellipse
   return inside <= 1;
 }