@cornerstonejs/tools 2.0.0-beta.1 → 2.0.0-beta.3

package/src/utilities/math/angle/angleBetweenLines.ts

@@ -1,17 +1,14 @@
 import type { Types } from '@cornerstonejs/core';
-import { vec3 } from 'gl-matrix';
+import { vec2, vec3 } from 'gl-matrix';
 
-type Line = [Types.Point3, Types.Point3];
+type Line2D = [Types.Point2, Types.Point2];
+type Line3D = [Types.Point3, Types.Point3];
+type Line = Line2D | Line3D;
 
 /**
- * It returns the angle between two lines in degrees.
- * The angle measured is that between the vectors
- * line1[1]->line1[0] AND line2[0]->line2[1].
- * @param line1 - Line = [p1, p2]
- * @param line2 - Line = [p3, p4]
- * @returns The angle between two lines in degrees.
+ * Calculates the angle between two 3D lines.
  */
-export default function angleBetweenLines(line1: Line, line2: Line): number {
+function angleBetween3DLines(line1: Line3D, line2: Line3D): number {
   const [p1, p2] = line1;
   const [p3, p4] = line2;
 
@@ -29,3 +26,36 @@ export default function angleBetweenLines(line1: Line, line2: Line): number {
 
   return (radian * 180) / Math.PI;
 }
+
+/**
+ * Calculates the angle between two 2D lines.
+ */
+function angleBetween2DLines(line1: Line2D, line2: Line2D): number {
+  const [p1, p2] = line1;
+  const [p3, p4] = line2;
+
+  const v1 = vec2.sub(vec2.create(), p2, p1);
+  const v2 = vec2.sub(vec2.create(), p3, p4);
+
+  const dot = vec2.dot(v1, v2);
+  const v1Length = vec2.length(v1);
+  const v2Length = vec2.length(v2);
+
+  const cos = dot / (v1Length * v2Length);
+  return Math.acos(cos) * (180 / Math.PI);
+}
+
+/**
+ * Returns the angle between two lines in degrees.
+ * The angle measured is that between the vectors
+ * line1[1]->line1[0] AND line2[0]->line2[1].
+ * @param line1 - Line = [p1, p2]
+ * @param line2 - Line = [p3, p4]
+ * @returns The angle between two lines in degrees.
+ */
+export default function angleBetweenLines(line1: Line, line2: Line): number {
+  const is3D = line1[0].length === 3;
+  return is3D
+    ? angleBetween3DLines(line1 as Line3D, line2 as Line3D)
+    : angleBetween2DLines(line1 as Line2D, line2 as Line2D);
+}

package/src/utilities/math/basic/BasicStatsCalculator.ts

@@ -0,0 +1,60 @@
+import { Statistics } from '../../../types';
+import Calculator from './Calculator';
+
+export default class BasicStatsCalculator extends Calculator {
+  private static max = -Infinity;
+  private static currentMax = 0;
+  private static sum = 0;
+  private static sumSquares = 0;
+  private static squaredDiffSum = 0;
+  private static count = 0;
+
+  /**
+   * This callback is used when we verify if the point is in the annotion drawn so we can get every point
+   * in the shape to calculate the statistics
+   * @param value of the point in the shape of the annotation
+   */
+  static statsCallback = ({ value: newValue }): void => {
+    if (newValue > this.max) {
+      this.max = newValue;
+      this.currentMax = newValue;
+    }
+
+    this.count += 1;
+
+    this.sum += newValue;
+    this.sumSquares += newValue ** 2;
+    this.squaredDiffSum += Math.pow(newValue - this.sum / this.count, 2);
+  };
+
+  /**
+   * Basic function that calculates statictics for a given array of points.
+   * @param points
+   * @returns An object that contains :
+   * max : The maximum value of the array
+   * mean : mean of the array
+   * stdDev : standard deviation of the array
+   * stdDevWithSumSquare : standard deviation of the array using sum²
+   */
+
+  static getStatistics = (): Statistics[] => {
+    const mean = this.sum / this.count;
+    const stdDev = Math.sqrt(this.squaredDiffSum / this.count);
+    const stdDevWithSumSquare = Math.sqrt(
+      this.sumSquares / this.count - mean ** 2
+    );
+
+    this.max = -Infinity;
+    this.sum = 0;
+    this.sumSquares = 0;
+    this.squaredDiffSum = 0;
+    this.count = 0;
+
+    return [
+      { name: 'max', value: this.currentMax, unit: null },
+      { name: 'mean', value: mean, unit: null },
+      { name: 'stdDev', value: stdDev, unit: null },
+      { name: 'stdDevWithSumSquare', value: stdDevWithSumSquare, unit: null },
+    ];
+  };
+}

package/src/utilities/math/basic/Calculator.ts

@@ -0,0 +1,8 @@
+import { Statistics } from '../../../types';
+
+abstract class Calculator {
+  static run: ({ value }) => void;
+  static getStatistics: () => Statistics[];
+}
+
+export default Calculator;

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

@@ -0,0 +1,4 @@
+import BasicStatsCalculator from './BasicStatsCalculator';
+import Calculator from './Calculator';
+
+export { BasicStatsCalculator, Calculator };

package/src/utilities/math/index.ts

@@ -4,5 +4,14 @@ import * as lineSegment from './line';
 import * as rectangle from './rectangle';
 import * as polyline from './polyline';
 import * as point from './point';
+import * as BasicStatsCalculator from './basic';
 
-export { vec2, ellipse, lineSegment, rectangle, polyline, point };
+export {
+  vec2,
+  ellipse,
+  lineSegment,
+  rectangle,
+  polyline,
+  point,
+  BasicStatsCalculator,
+};

package/src/utilities/math/midPoint.ts

@@ -12,7 +12,9 @@ const midPoint = (
   for (const arg of args) {
     ret[0] += arg[0] / len;
     ret[1] += arg[1] / len;
-    if (ret.length === 3) ret[2] += arg[2] / len;
+    if (ret.length === 3) {
+      ret[2] += arg[2] / len;
+    }
   }
   return ret;
 };

package/src/utilities/math/polyline/pointInPolyline.ts

@@ -11,7 +11,9 @@ export default function pointInPolyline(
     pointEnd[1],
   ]);
 
-  if (intersections.length % 2 === 0) return false;
+  if (intersections.length % 2 === 0) {
+    return false;
+  }
 
   return true;
 }

package/src/utilities/math/vec2/liangBarksyClip.ts

@@ -14,15 +14,25 @@ const OUTSIDE = 0;
 
 function clipT(num, denom, c) {
   const [tE, tL] = c;
-  if (Math.abs(denom) < EPSILON) return num < 0;
+  if (Math.abs(denom) < EPSILON) {
+    return num < 0;
+  }
   const t = num / denom;
 
   if (denom > 0) {
-    if (t > tL) return 0;
-    if (t > tE) c[0] = t;
+    if (t > tL) {
+      return 0;
+    }
+    if (t > tE) {
+      c[0] = t;
+    }
   } else {
-    if (t < tE) return 0;
-    if (t < tL) c[1] = t;
+    if (t < tE) {
+      return 0;
+    }
+    if (t < tL) {
+      c[1] = t;
+    }
   }
   return 1;
 }

package/src/utilities/pointInShapeCallback.ts

@@ -3,6 +3,13 @@ import type { Types } from '@cornerstonejs/core';
 import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
 import BoundsIJK from '../types/BoundsIJK';
 
+export type PointInShape = {
+  value: number;
+  index: number;
+  pointIJK: Types.Point3;
+  pointLPS: Types.Point3;
+};
+
 export type PointInShapeCallback = ({
   value,
   index,
@@ -37,9 +44,9 @@ export type ShapeFnCriteria = (
 export default function pointInShapeCallback(
   imageData: vtkImageData | Types.CPUImageData,
   pointInShapeFn: ShapeFnCriteria,
-  callback: PointInShapeCallback,
+  callback?: PointInShapeCallback,
   boundsIJK?: BoundsIJK
-): void {
+): Array<PointInShape> {
   let iMin, iMax, jMin, jMax, kMin, kMax;
 
   let scalarData;
@@ -101,6 +108,7 @@ export default function pointInShapeCallback(
   const yMultiple = dimensions[0];
   const zMultiple = dimensions[0] * dimensions[1];
 
+  const pointsInShape: Array<PointInShape> = [];
   for (let k = kMin; k <= kMax; k++) {
     for (let j = jMin; j <= jMax; j++) {
       for (let i = iMin; i <= iMax; i++) {
@@ -130,9 +138,13 @@ export default function pointInShapeCallback(
           const index = k * zMultiple + j * yMultiple + i;
           const value = scalarData[index];
 
-          callback({ value, index, pointIJK, pointLPS });
+          pointsInShape.push({ value, index, pointIJK, pointLPS });
+          if (callback !== null) {
+            callback({ value, index, pointIJK, pointLPS });
+          }
         }
       }
     }
   }
+  return pointsInShape;
 }

package/src/utilities/roundNumber.ts

@@ -11,9 +11,13 @@
  * @param precision - defining how many digits after 1..9 are desired
  */
 function roundNumber(value: string | number, precision = 2): string {
-  if (value === undefined || value === null || value === '') return 'NaN';
+  if (value === undefined || value === null || value === '') {
+    return 'NaN';
+  }
   value = Number(value);
-  if (value < 0.0001) return `${value}`;
+  if (value < 0.0001) {
+    return `${value}`;
+  }
   const fixedPrecision =
     value >= 100
       ? precision - 2

package/src/utilities/segmentation/brushSizeForToolGroup.ts

@@ -4,9 +4,17 @@ import triggerAnnotationRenderForViewportIds from '../triggerAnnotationRenderFor
 import { getRenderingEngine } from '@cornerstonejs/core';
 import getBrushToolInstances from './utilities';
 
+/**
+ * Sets the brush size for all brush-based tools in a given tool group.
+ * @param toolGroupId - The ID of the tool group to set the brush size for.
+ * @param brushSize - The new brush size to set.
+ * @param toolName - The name of the specific tool to set the brush size for (optional)
+ * If not provided, all brush-based tools in the tool group will be affected.
+ */
 export function setBrushSizeForToolGroup(
   toolGroupId: string,
-  brushSize: number
+  brushSize: number,
+  toolName?: string
 ): void {
   const toolGroup = getToolGroup(toolGroupId);
 
@@ -14,7 +22,7 @@ export function setBrushSizeForToolGroup(
     return;
   }
 
-  const brushBasedToolInstances = getBrushToolInstances(toolGroupId);
+  const brushBasedToolInstances = getBrushToolInstances(toolGroupId, toolName);
 
   brushBasedToolInstances.forEach((tool: BrushTool) => {
     tool.configuration.brushSize = brushSize;
@@ -45,7 +53,17 @@ export function setBrushSizeForToolGroup(
   triggerAnnotationRenderForViewportIds(renderingEngine, viewportIds);
 }
 
-export function getBrushSizeForToolGroup(toolGroupId: string): void {
+/**
+ * Gets the brush size for the first brush-based tool instance in a given tool group.
+ * @param toolGroupId - The ID of the tool group to get the brush size for.
+ * @param toolName - The name of the specific tool to get the brush size for (Optional)
+ * If not provided, the first brush-based tool instance in the tool group will be used.
+ * @returns The brush size of the selected tool instance, or undefined if no brush-based tool instance is found.
+ */
+export function getBrushSizeForToolGroup(
+  toolGroupId: string,
+  toolName?: string
+): void {
   const toolGroup = getToolGroup(toolGroupId);
 
   if (toolGroup === undefined) {
@@ -58,7 +76,7 @@ export function getBrushSizeForToolGroup(toolGroupId: string): void {
     return;
   }
 
-  const brushBasedToolInstances = getBrushToolInstances(toolGroupId);
+  const brushBasedToolInstances = getBrushToolInstances(toolGroupId, toolName);
 
   // one is enough as they share the same brush size
   const brushToolInstance = brushBasedToolInstances[0];

package/src/utilities/segmentation/thresholdVolumeByRange.ts

@@ -137,7 +137,9 @@ function thresholdVolumeByRange(
     }
 
     // Todo: make the segmentIndex a parameter
-    if (insert) scalarData[index] = 1;
+    if (insert) {
+      scalarData[index] = 1;
+    }
   };
 
   pointInShapeCallback(segmentationImageData, () => true, callback, boundsIJK);

package/src/utilities/segmentation/utilities.ts

@@ -10,7 +10,10 @@ export type ThresholdInformation = {
   upper: number;
 };
 
-export default function getBrushToolInstances(toolGroupId) {
+export default function getBrushToolInstances(
+  toolGroupId: string,
+  toolName?: string
+) {
   const toolGroup = getToolGroup(toolGroupId);
 
   if (toolGroup === undefined) {
@@ -23,6 +26,10 @@ export default function getBrushToolInstances(toolGroupId) {
     return;
   }
 
+  if (toolName && toolInstances[toolName]) {
+    return [toolInstances[toolName]];
+  }
+
   // For each tool that has BrushTool as base class, set the brush size.
   const brushBasedToolInstances = Object.values(toolInstances).filter(
     (toolInstance) => toolInstance instanceof BrushTool

package/src/utilities/stackPrefetch/index.ts

@@ -1,8 +1,4 @@
-import {
-  enable,
-  disable,
-  setConfiguration,
-  getConfiguration,
-} from './stackPrefetch';
+import stackPrefetch from './stackPrefetch';
+import stackContextPrefetch from './stackContextPrefetch';
 
-export { enable, disable, setConfiguration, getConfiguration };
+export { stackPrefetch, stackContextPrefetch };