@cornerstonejs/tools 1.54.2 → 1.56.0

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

@@ -0,0 +1,105 @@
+import type { Types } from '@cornerstonejs/core';
+import * as mathLine from '../line';
+
+const DEFAULT_EPSILON = 0.1;
+
+/**
+ * Ramer–Douglas–Peucker algorithm implementation to decimate a polyline
+ * to a similar polyline with fewer points
+ *
+ * https://en.wikipedia.org/wiki/Ramer%E2%80%93Douglas%E2%80%93Peucker_algorithm
+ * https://rosettacode.org/wiki/Ramer-Douglas-Peucker_line_simplification
+ * https://karthaus.nl/rdp/
+ *
+ * @param polyline - Polyline to decimate
+ * @param epsilon - A maximum given distance 'epsilon' to decide if a point
+ * should or shouldn't be added the decimated polyline version. In each
+ * iteration the polyline is split into two polylines and the distance of each
+ * point from those new polylines are checked against the line that connects
+ * the first and last points.
+ * @returns Decimated polyline
+ */
+export default function decimate(
+  polyline: Types.Point2[],
+  epsilon = DEFAULT_EPSILON
+) {
+  const numPoints = polyline.length;
+
+  // The polyline must have at least a start and end points
+  if (numPoints < 3) {
+    return polyline;
+  }
+
+  const epsilonSquared = epsilon * epsilon;
+  const partitionQueue = [[0, numPoints - 1]];
+
+  // Used a boolean array to set each point that will be in the decimated polyline
+  // because pre-allocated arrays are 3-4x faster than thousands of push() calls
+  // to add all points to a new array.
+  const polylinePointFlags = new Array(numPoints).fill(false);
+
+  // Start and end points are always added to the decimated polyline
+  let numDecimatedPoints = 2;
+
+  // Add start and end points to the decimated polyline
+  polylinePointFlags[0] = true;
+  polylinePointFlags[numPoints - 1] = true;
+
+  // Iterative approach using a queue instead of recursion to reduce the number
+  // of function calls (performance)
+  while (partitionQueue.length) {
+    const [startIndex, endIndex] = partitionQueue.pop();
+
+    // Return if there is no point between the start and end points
+    if (endIndex - startIndex === 1) {
+      continue;
+    }
+
+    const startPoint = polyline[startIndex];
+    const endPoint = polyline[endIndex];
+    let maxDistSquared = -Infinity;
+    let maxDistIndex = -1;
+
+    // Search for the furthest point
+    for (let i = startIndex + 1; i < endIndex; i++) {
+      const currentPoint = polyline[i];
+      const distSquared = mathLine.distanceToPointSquared(
+        startPoint,
+        endPoint,
+        currentPoint
+      );
+
+      if (distSquared > maxDistSquared) {
+        maxDistSquared = distSquared;
+        maxDistIndex = i;
+      }
+    }
+
+    // Do not add any of the points because the fursthest one is very close to
+    // the line based on the epsilon value
+    if (maxDistSquared < epsilonSquared) {
+      continue;
+    }
+
+    // Update the flag for the furthest point because it will be added to the
+    // decimated polyline
+    polylinePointFlags[maxDistIndex] = true;
+    numDecimatedPoints++;
+
+    // Partition the points into two parts using maxDistIndex as the pivot point
+    // and process both sides
+    partitionQueue.push([maxDistIndex, endIndex]);
+    partitionQueue.push([startIndex, maxDistIndex]);
+  }
+
+  // A pre-allocated array is 3-4x faster then multiple push() calls
+  const decimatedPolyline: Types.Point2[] = new Array(numDecimatedPoints);
+
+  for (let srcIndex = 0, dstIndex = 0; srcIndex < numPoints; srcIndex++) {
+    if (polylinePointFlags[srcIndex]) {
+      decimatedPolyline[dstIndex++] = polyline[srcIndex];
+    }
+  }
+
+  return decimatedPolyline;
+}

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

@@ -9,6 +9,7 @@ import getNormal3 from './getNormal3';
 import getNormal2 from './getNormal2';
 import { mergePolylines, subtractPolylines } from './combinePolyline';
 import intersectPolyline from './intersectPolyline';
+import decimate from './decimate';
 import getFirstLineSegmentIntersectionIndexes from './getFirstLineSegmentIntersectionIndexes';
 import getLineSegmentIntersectionsIndexes from './getLineSegmentIntersectionsIndexes';
 import getLineSegmentIntersectionsCoordinates from './getLineSegmentIntersectionsCoordinates';
@@ -30,6 +31,7 @@ export {
   getNormal3,
   getNormal2,
   intersectPolyline,
+  decimate,
   getFirstLineSegmentIntersectionIndexes,
   getLineSegmentIntersectionsIndexes,
   getLineSegmentIntersectionsCoordinates,

package/src/utilities/pointInShapeCallback.ts

@@ -47,6 +47,7 @@ export default function pointInShapeCallback(
   let iMin, iMax, jMin, jMax, kMin, kMax;
 
   let scalarData;
+  const { numComps } = imageData as any;
 
   // if getScalarData is a method on imageData
   if ((imageData as Types.CPUImageData).getScalarData) {
@@ -103,6 +104,7 @@ export default function pointInShapeCallback(
   );
 
   const xMultiple =
+    numComps ||
     scalarData.length / dimensions[2] / dimensions[1] / dimensions[0];
   const yMultiple = dimensions[0] * xMultiple;
   const zMultiple = dimensions[1] * yMultiple;

package/src/utilities/segmentation/floodFill.ts

@@ -7,22 +7,25 @@ import { Types } from '@cornerstonejs/core';
 
 /**
  * floodFill.js - Taken from MIT OSS lib - https://github.com/tuzz/n-dimensional-flood-fill
- * Refactored to ES6.
+ * Refactored to ES6.  Fixed the bounds/visits checks to use integer keys, restricting the
+ * total search spacing to +/- 32k in each dimension, but resulting in about a hundred time
+ * performance gain for larger regions since JavaScript does not have a hash map to allow the
+ * map to work on keys.
  *
- * @param {function} getter The getter to the elements of your data structure,
+ * @param getter The getter to the elements of your data structure,
  *                          e.g. getter(x,y) for a 2D interprettation of your structure.
- * @param {number[]} seed The seed for your fill. The dimensionality is infered
+ * @param seed The seed for your fill. The dimensionality is infered
  *                        by the number of dimensions of the seed.
- * @param {function} [options.onFlood] An optional callback to execute when each pixel is flooded.
+ * @param options.onFlood - An optional callback to execute when each pixel is flooded.
  *                             e.g. onFlood(x,y).
- * @param {function} [options.onBoundary] An optional callback to execute whenever a boundary is reached.
+ * @param options.onBoundary - An optional callback to execute whenever a boundary is reached.
  *                                a boundary could be another segmentIndex, or the edge of your
  *                                data structure (i.e. when your getter returns undefined).
- * @param {function} [options.equals] An optional equality method for your datastructure.
+ * @param options.equals - An optional equality method for your datastructure.
  *                            Default is simply value1 = value2.
- * @param {boolean} [options.diagonals] Whether you allow flooding through diagonals. Defaults to false.
+ * @param options.diagonals - Whether you allow flooding through diagonals. Defaults to false.
  *
- * @returns {Object}
+ * @returns Flood fill results
  */
 function floodFill(
   getter: FloodFillGetter,
@@ -31,14 +34,14 @@ function floodFill(
 ): FloodFillResult {
   const onFlood = options.onFlood;
   const onBoundary = options.onBoundary;
-  const equals = options.equals || defaultEquals;
+  const equals = options.equals;
   const diagonals = options.diagonals || false;
   const startNode = get(seed);
   const permutations = prunedPermutations();
   const stack = [];
   const flooded = [];
-  const visits = {};
-  const bounds = {};
+  const visits = new Set();
+  const bounds = new Map();
 
   stack.push({ currentArgs: seed });
 
@@ -68,18 +71,28 @@ function floodFill(
     }
   }
 
+  /**
+   * Indicates if the key has been visited.
+   * @param key is a 2 or 3 element vector with values -32768...32767
+   */
   function visited(key) {
-    return visits[key] === true;
+    const [x, y, z = 0] = key;
+    // Use an integer key value for checking visited, since JavaScript does not
+    // provide a generic hash key indexed hash map.
+    const iKey = x + 32768 + 65536 * (y + 32768 + 65536 * (z + 32768));
+    return visits.has(iKey);
   }
 
   function markAsVisited(key) {
-    visits[key] = true;
+    const [x, y, z = 0] = key;
+    const iKey = x + 32768 + 65536 * (y + 32768 + 65536 * (z + 32768));
+    visits.add(iKey);
   }
 
   function member(getArgs) {
-    const node = safely(get, [getArgs]);
+    const node = get(getArgs);
 
-    return safely(equals, [node, startNode]);
+    return equals ? equals(node, startNode) : node === startNode;
   }
 
   function markAsFlooded(getArgs) {
@@ -91,7 +104,11 @@ function floodFill(
   }
 
   function markAsBoundary(prevArgs) {
-    bounds[prevArgs] = prevArgs;
+    const [x, y, z = 0] = prevArgs;
+    // Use an integer key value for checking visited, since JavaScript does not
+    // provide a generic hash key indexed hash map.
+    const iKey = x + 32768 + 65536 * (y + 32768 + 65536 * (z + 32768));
+    bounds.set(iKey, prevArgs);
     if (onBoundary) {
       //@ts-ignore
       onBoundary(...prevArgs);
@@ -119,13 +136,15 @@ function floodFill(
     return getter(...getArgs);
   }
 
-  function safely(f, args) {
-    try {
-      return f(...args);
-    } catch (error) {
-      return;
-    }
-  }
+  // This is a significant performance hit - should be done as a wrapper
+  // only when needed.
+  // function safely(f, args) {
+  //   try {
+  //     return f(...args);
+  //   } catch (error) {
+  //     return;
+  //   }
+  // }
 
   function prunedPermutations() {
     const permutations = permute(seed.length);
@@ -156,14 +175,8 @@ function floodFill(
   }
 
   function boundaries() {
-    const array = [];
-
-    for (const key in bounds) {
-      if (bounds[key] !== undefined) {
-        array.unshift(bounds[key]);
-      }
-    }
-
+    const array = Array.from(bounds.values());
+    array.reverse();
     return array;
   }
 }

package/src/utilities/segmentation/getSegmentAtLabelmapBorder.ts

@@ -84,12 +84,13 @@ export function getSegmentAtLabelmapBorder(
   const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
 
   const dimensions = imageData.getDimensions();
-  const voxelManager = utilities.VoxelManager.createVolumeVoxelManager(
-    dimensions,
-    imageData.getPointData().getScalars().getData()
-  );
+  const voxelManager = (imageData.voxelManager ||
+    utilities.VoxelManager.createVolumeVoxelManager(
+      dimensions,
+      imageData.getPointData().getScalars().getData()
+    )) as utilities.VoxelManager<number>;
 
-  const segmentIndex = voxelManager.getAtIJK(...(indexIJK as Types.Point3));
+  const segmentIndex = voxelManager.getAtIJKPoint(indexIJK as Types.Point3);
 
   const onEdge = isSegmentOnEdgeIJK(
     indexIJK as Types.Point3,

package/src/utilities/segmentation/getSegmentAtWorldPoint.ts

@@ -110,12 +110,13 @@ export function getSegmentAtWorldForLabelmap(
   const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
 
   const dimensions = imageData.getDimensions();
-  const voxelManager = utilities.VoxelManager.createVolumeVoxelManager(
-    dimensions,
-    imageData.getPointData().getScalars().getData()
-  );
+  const voxelManager = (imageData.voxelManager ||
+    utilities.VoxelManager.createVolumeVoxelManager(
+      dimensions,
+      imageData.getPointData().getScalars().getData()
+    )) as utilities.VoxelManager<number>;
 
-  const segmentIndex = voxelManager.getAtIJK(...(indexIJK as Types.Point3));
+  const segmentIndex = voxelManager.getAtIJKPoint(indexIJK as Types.Point3);
 
   return segmentIndex;
 }