@cornerstonejs/tools 1.36.2 → 1.37.0

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

@@ -1,9 +1,13 @@
-import { cache } from '@cornerstonejs/core';
+import { cache, utilities } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 import { isVolumeSegmentation } from './stackVolumeCheck';
 import { LabelmapToolOperationDataStack } from '../../../../types';
 
+const { VoxelManager } = utilities;
+
 function getStrategyData({ operationData, viewport }) {
   let segmentationImageData, segmentationScalarData, imageScalarData;
+  let dimensions: Types.Point3;
   if (isVolumeSegmentation(operationData)) {
     const { volumeId, referencedVolumeId } = operationData;
 
@@ -17,6 +21,7 @@ function getStrategyData({ operationData, viewport }) {
     ({ imageData: segmentationImageData } = segmentationVolume);
     segmentationScalarData = segmentationVolume.getScalarData();
     imageScalarData = imageVolume.getScalarData();
+    dimensions = imageVolume.dimensions;
   } else {
     const { imageIdReferenceMap, segmentationRepresentationUID } =
       operationData as LabelmapToolOperationDataStack;
@@ -46,12 +51,21 @@ function getStrategyData({ operationData, viewport }) {
     // 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();
+    dimensions = [image.columns, image.rows, 1];
   }
 
   return {
     segmentationImageData,
     segmentationScalarData,
+    segmentationVoxelManager: VoxelManager.createVolumeVoxelManager(
+      dimensions,
+      segmentationScalarData
+    ),
     imageScalarData,
+    imageVoxelManager: VoxelManager.createVolumeVoxelManager(
+      dimensions,
+      imageScalarData
+    ),
   };
 }
 

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

@@ -1,16 +1,16 @@
 import { Types } from '@cornerstonejs/core';
-import { TypedArray } from '@kitware/vtk.js/types';
 
 function isWithinThreshold(
   index: number,
-  imageScalarData: TypedArray,
+  imageScalarData: Types.VolumeScalarData,
   strategySpecificConfiguration: any
 ) {
-  const { THRESHOLD_INSIDE_CIRCLE } = strategySpecificConfiguration;
+  const { THRESHOLD, THRESHOLD_INSIDE_CIRCLE } = strategySpecificConfiguration;
 
   const voxelValue = imageScalarData[index];
-  const { threshold } = THRESHOLD_INSIDE_CIRCLE;
-
+  // Prefer the generic version of the THRESHOLD configuration, but fallback
+  // to the older THRESHOLD_INSIDE_CIRCLE version.
+  const { threshold } = THRESHOLD || THRESHOLD_INSIDE_CIRCLE;
   return threshold[0] <= voxelValue && voxelValue <= threshold[1];
 }
 

package/src/types/BoundsIJK.ts

@@ -1,5 +1,5 @@
 import type { Types } from '@cornerstonejs/core';
 
-type BoundsIJK = [Types.Point2, Types.Point2, Types.Point2];
+type BoundsIJK = Types.BoundsIJK;
 
 export default BoundsIJK;

package/src/types/FloodFillTypes.ts

@@ -5,13 +5,13 @@ type FloodFillResult = {
   boundaries: Types.Point2[] | Types.Point3[];
 };
 
-type FloodFillGetter3D = (x: number, y: number, z: number) => number;
-type FloodFillGetter2D = (x: number, y: number) => number;
+type FloodFillGetter3D = (x: number, y: number, z: number) => unknown;
+type FloodFillGetter2D = (x: number, y: number) => unknown;
 type FloodFillGetter = FloodFillGetter2D | FloodFillGetter3D;
 
 type FloodFillOptions = {
-  onFlood?: (x, y) => void;
-  onBoundary?: (x, y) => void;
+  onFlood?: (x: number, y: number, z?: number) => void;
+  onBoundary?: (x: number, y: number, z?: number) => void;
   equals?: (a, b) => boolean; // Equality operation for your datastructure. Defaults to a === b.
   diagonals?: boolean; // Whether to flood fill across diagonals. Default false.
 };

package/src/types/LabelmapToolOperationData.ts

@@ -1,3 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+
 import {
   LabelmapSegmentationDataStack,
   LabelmapSegmentationDataVolume,
@@ -6,12 +8,24 @@ import {
 type LabelmapToolOperationData = {
   segmentationId: string;
   segmentIndex: number;
+  /**
+   * The colours to use for previewing
+   */
+  previewColors?: Record<number, [number, number, number, number]>;
   segmentsLocked: number[];
   viewPlaneNormal: number[];
   viewUp: number[];
   strategySpecificConfiguration: any;
-  constraintFn: (pointIJK: number) => boolean;
+  // constraintFn: (pointIJK: number) => boolean;
   segmentationRepresentationUID: string;
+  points: Types.Point3[];
+  /**
+   * preview is used for sharing preview data between views/interactions with
+   * a tool, and needs to be maintained by the tool side in order to be able
+   * to accept/reject/update the preview information.
+   */
+  preview: any;
+  toolGroupId: string;
 };
 
 type LabelmapToolOperationDataStack = LabelmapToolOperationData &
@@ -20,8 +34,13 @@ type LabelmapToolOperationDataStack = LabelmapToolOperationData &
 type LabelmapToolOperationDataVolume = LabelmapToolOperationData &
   LabelmapSegmentationDataVolume;
 
+type LabelmapToolOperationDataAny =
+  | LabelmapToolOperationDataVolume
+  | LabelmapToolOperationDataStack;
+
 export {
   LabelmapToolOperationData,
+  LabelmapToolOperationDataAny,
   LabelmapToolOperationDataStack,
   LabelmapToolOperationDataVolume,
 };

package/src/types/index.ts

@@ -56,6 +56,7 @@ import type { ContourSegmentationData } from './ContourTypes';
 import type IAnnotationManager from './IAnnotationManager';
 import type AnnotationGroupSelector from './AnnotationGroupSelector';
 import type { Statistics } from './CalculatorTypes';
+import type { CanvasCoordinates } from '../utilities/math/ellipse/getCanvasEllipseCorners';
 import {
   LabelmapToolOperationData,
   LabelmapToolOperationDataStack,
@@ -77,6 +78,7 @@ export type {
   // AnnotationState
   Annotation,
   Annotations,
+  CanvasCoordinates,
   IAnnotationManager,
   GroupSpecificAnnotations,
   AnnotationState,

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

@@ -1,6 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
 
-type canvasCoordinates = [
+export type CanvasCoordinates = [
   Types.Point2, // bottom
   Types.Point2, // top
   Types.Point2, // left
@@ -15,7 +15,7 @@ type canvasCoordinates = [
  * @returns An array of two points.
  */
 export default function getCanvasEllipseCorners(
-  ellipseCanvasPoints: canvasCoordinates
+  ellipseCanvasPoints: CanvasCoordinates
 ): Array<Types.Point2> {
   const [bottom, top, left, right] = ellipseCanvasPoints;
 

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

@@ -1,4 +1,4 @@
-import pointInEllipse from './pointInEllipse';
+import pointInEllipse, { precalculatePointInEllipse } from './pointInEllipse';
 import getCanvasEllipseCorners from './getCanvasEllipseCorners';
 
-export { pointInEllipse, getCanvasEllipseCorners };
+export { pointInEllipse, precalculatePointInEllipse, getCanvasEllipseCorners };

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

@@ -1,8 +1,15 @@
+import type { Types } from '@cornerstonejs/core';
 interface Inverts {
   invXRadiusSq?: number;
   invYRadiusSq?: number;
   invZRadiusSq?: number;
   fast?: boolean;
+  /**
+   * If you call the pointInEllipse.precalculateInverts first, then you
+   * can call precalculated directly instead of having the extra time for
+   * the if conditions.
+   */
+  precalculated?: (pointLPS: Types.Point3) => boolean;
 }
 
 /**
@@ -23,7 +30,26 @@ export default function pointInEllipse(
   pointLPS,
   inverts: Inverts = {}
 ) {
-  const { center, xRadius, yRadius, zRadius } = ellipse;
+  if (!inverts.precalculated) {
+    precalculatePointInEllipse(ellipse, inverts);
+  }
+  return inverts.precalculated(pointLPS);
+}
+
+/**
+ * This will perform some precalculations to make things faster.
+ * Ideally, use the 'precalculated' function inside inverts to call the
+ * test function.  This minimizes re-reading of variables and only needs the
+ * LPS passed each time.
+ * That is:
+ *
+ * ```
+ *    const inverts = precalcualtePointInEllipse(ellipse);
+ *    if( inverts.precalculated(pointLPS) ) ...
+ * ```
+ */
+const precalculatePointInEllipse = (ellipse, inverts: Inverts = {}) => {
+  const { xRadius, yRadius, zRadius } = ellipse;
 
   // This will run only once since we are caching the values in the same
   // object that is passed in.
@@ -37,24 +63,32 @@ export default function pointInEllipse(
     inverts.invZRadiusSq = zRadius !== 0 ? 1 / zRadius ** 2 : 0;
   }
 
-  let inside = 0;
+  const { invXRadiusSq, invYRadiusSq, invZRadiusSq } = inverts;
+  const { center } = ellipse;
+  const [centerL, centerP, centerS] = center;
 
-  // Calculate the sum of normalized squared distances
-  const dx = pointLPS[0] - center[0];
-  inside += dx * dx * inverts.invXRadiusSq;
-  if (inside > 1) {
-    return false;
-  }
+  inverts.precalculated = (pointLPS) => {
+    // Calculate the sum of normalized squared distances
+    const dx = pointLPS[0] - centerL;
+    let inside = dx * dx * invXRadiusSq;
+    if (inside > 1) {
+      return false;
+    }
 
-  const dy = pointLPS[1] - center[1];
-  inside += dy * dy * inverts.invYRadiusSq;
-  if (inside > 1) {
-    return false;
-  }
+    const dy = pointLPS[1] - centerP;
+    inside += dy * dy * invYRadiusSq;
+    if (inside > 1) {
+      return false;
+    }
 
-  const dz = pointLPS[2] - center[2];
-  inside += dz * dz * inverts.invZRadiusSq;
+    const dz = pointLPS[2] - centerS;
+    inside += dz * dz * invZRadiusSq;
 
-  // Check if the point is inside the ellipse
-  return inside <= 1;
-}
+    // Check if the point is inside the ellipse
+    return inside <= 1;
+  };
+
+  return inverts;
+};
+
+export { precalculatePointInEllipse };

package/src/utilities/math/sphere/pointInSphere.ts

@@ -4,6 +4,8 @@ import { vec3 } from 'gl-matrix';
 type Sphere = {
   center: Types.Point3 | vec3;
   radius: number;
+  // Square of the radius
+  radius2?: number;
 };
 
 /**
@@ -12,17 +14,23 @@ type Sphere = {
  * ellipse's rotation in different views, we can use a simpler equation
  * which would be faster (no if statements).
  *
- * @param sphere - Sphere object with center and radius
+ * This is safe to call for point in circle as long as you don't call it with
+ * anything off-plane - that is, a circle is a degenerate sphere that is
+ * intersected with the primary plane.
+ *
+ * @param sphere - Sphere object with center and radius and radius squared
+ *     as radius2 if you are calling this a huge number of times.
  * @param pointLPS - the point to check in world coordinates
  * @returns boolean
  */
 export default function pointInSphere(sphere: Sphere, pointLPS: vec3): boolean {
   const { center, radius } = sphere;
+  const radius2 = sphere.radius2 || radius * radius;
 
   return (
     (pointLPS[0] - center[0]) * (pointLPS[0] - center[0]) +
       (pointLPS[1] - center[1]) * (pointLPS[1] - center[1]) +
       (pointLPS[2] - center[2]) * (pointLPS[2] - center[2]) <=
-    radius ** 2
+    radius2
   );
 }

package/src/utilities/segmentation/brushThresholdForToolGroup.ts

@@ -6,7 +6,8 @@ import getBrushToolInstances from './utilities';
 
 export function setBrushThresholdForToolGroup(
   toolGroupId: string,
-  threshold: Types.Point2
+  threshold: Types.Point2,
+  otherArgs: Record<string, unknown> = { isDynamic: false }
 ) {
   const toolGroup = getToolGroup(toolGroupId);
 
@@ -15,10 +16,16 @@ export function setBrushThresholdForToolGroup(
   }
 
   const brushBasedToolInstances = getBrushToolInstances(toolGroupId);
+  const configuration = {
+    ...otherArgs,
+    ...(threshold !== undefined && { threshold }),
+  };
 
   brushBasedToolInstances.forEach((tool) => {
-    tool.configuration.strategySpecificConfiguration.THRESHOLD_INSIDE_CIRCLE.threshold =
-      threshold;
+    tool.configuration.strategySpecificConfiguration.THRESHOLD = {
+      ...tool.configuration.strategySpecificConfiguration.THRESHOLD,
+      ...configuration,
+    };
   });
 
   // Trigger an annotation render for any viewports on the toolgroup
@@ -60,6 +67,6 @@ export function getBrushThresholdForToolGroup(toolGroupId: string) {
   }
 
   // TODO -> Assumes the
-  return brushToolInstance.configuration.strategySpecificConfiguration
-    .THRESHOLD_INSIDE_CIRCLE.threshold;
+  return brushToolInstance.configuration.strategySpecificConfiguration.THRESHOLD
+    .threshold;
 }