@cornerstonejs/adapters 1.54.2 → 1.55.0

package/dist/adapters.es.js

@@ -38850,7 +38850,7 @@ class ProgressiveIterator {
   }
 }
 
-function decimate(list, interleave, offset = 0) {
+function decimate$1(list, interleave, offset = 0) {
   const interleaveIndices = [];
   for (let i = offset; i < list.length; i += interleave) {
     interleaveIndices.push(i);
@@ -42463,7 +42463,7 @@ var utilities = /*#__PURE__*/Object.freeze({
   createSigmoidRGBTransferFunction: createSigmoidRGBTransferFunction,
   createUint16SharedArray: createUint16SharedArray,
   createUint8SharedArray: createUint8SharedArray,
-  decimate: decimate,
+  decimate: decimate$1,
   deepMerge: deepMerge$1,
   eventListener: index$2,
   generateVolumePropsFromImageIds: generateVolumePropsFromImageIds,
@@ -44074,7 +44074,7 @@ class ProgressiveRetrieveImagesInstance {
       imageRequests.set(imageId, request);
     };
     for (const stage of this.stages) {
-      const indices = stage.positions || decimate(this.imageIds, stage.decimate || 1, stage.offset ?? 0);
+      const indices = stage.positions || decimate$1(this.imageIds, stage.decimate || 1, stage.offset ?? 0);
       indices.forEach(index => addStageInstance(stage, index));
     }
     return interleaved;
@@ -48505,6 +48505,32 @@ function getContourHolesDataCanvas(annotation, viewport) {
   return canvasHoleContours;
 }
 
+function distanceToPointSquaredInfo(lineStart, lineEnd, point) {
+  let closestPoint;
+  const distanceSquared = distanceToPointSquared(lineStart, lineEnd);
+  if (lineStart[0] === lineEnd[0] && lineStart[1] === lineEnd[1]) {
+    closestPoint = lineStart;
+  }
+  if (!closestPoint) {
+    const dotProduct = ((point[0] - lineStart[0]) * (lineEnd[0] - lineStart[0]) + (point[1] - lineStart[1]) * (lineEnd[1] - lineStart[1])) / distanceSquared;
+    if (dotProduct < 0) {
+      closestPoint = lineStart;
+    } else if (dotProduct > 1) {
+      closestPoint = lineEnd;
+    } else {
+      closestPoint = [lineStart[0] + dotProduct * (lineEnd[0] - lineStart[0]), lineStart[1] + dotProduct * (lineEnd[1] - lineStart[1])];
+    }
+  }
+  return {
+    point: [...closestPoint],
+    distanceSquared: distanceToPointSquared(point, closestPoint)
+  };
+}
+
+function distanceToPointSquared$1(lineStart, lineEnd, point) {
+  return distanceToPointSquaredInfo(lineStart, lineEnd, point).distanceSquared;
+}
+
 function distanceToPointSquared(p1, p2) {
   if (p1.length !== p2.length) {
     throw Error('Both points should have the same dimensionality');
@@ -48539,7 +48565,53 @@ function getWindingDirection(polyline) {
   return signedArea >= 0 ? 1 : -1;
 }
 
-function updateContourPolyline(annotation, polylineData, transforms) {
+const DEFAULT_EPSILON = 0.1;
+function decimate(polyline, epsilon = DEFAULT_EPSILON) {
+  const numPoints = polyline.length;
+  if (numPoints < 3) {
+    return polyline;
+  }
+  const epsilonSquared = epsilon * epsilon;
+  const partitionQueue = [[0, numPoints - 1]];
+  const polylinePointFlags = new Array(numPoints).fill(false);
+  let numDecimatedPoints = 2;
+  polylinePointFlags[0] = true;
+  polylinePointFlags[numPoints - 1] = true;
+  while (partitionQueue.length) {
+    const [startIndex, endIndex] = partitionQueue.pop();
+    if (endIndex - startIndex === 1) {
+      continue;
+    }
+    const startPoint = polyline[startIndex];
+    const endPoint = polyline[endIndex];
+    let maxDistSquared = -Infinity;
+    let maxDistIndex = -1;
+    for (let i = startIndex + 1; i < endIndex; i++) {
+      const currentPoint = polyline[i];
+      const distSquared = distanceToPointSquared$1(startPoint, endPoint, currentPoint);
+      if (distSquared > maxDistSquared) {
+        maxDistSquared = distSquared;
+        maxDistIndex = i;
+      }
+    }
+    if (maxDistSquared < epsilonSquared) {
+      continue;
+    }
+    polylinePointFlags[maxDistIndex] = true;
+    numDecimatedPoints++;
+    partitionQueue.push([maxDistIndex, endIndex]);
+    partitionQueue.push([startIndex, maxDistIndex]);
+  }
+  const decimatedPolyline = new Array(numDecimatedPoints);
+  for (let srcIndex = 0, dstIndex = 0; srcIndex < numPoints; srcIndex++) {
+    if (polylinePointFlags[srcIndex]) {
+      decimatedPolyline[dstIndex++] = polyline[srcIndex];
+    }
+  }
+  return decimatedPolyline;
+}
+
+function updateContourPolyline(annotation, polylineData, transforms, options) {
   const {
     canvasToWorld
   } = transforms;
@@ -48547,9 +48619,14 @@ function updateContourPolyline(annotation, polylineData, transforms) {
     data
   } = annotation;
   const {
-    points: polyline,
     targetWindingDirection
   } = polylineData;
+  let {
+    points: polyline
+  } = polylineData;
+  if (options?.decimate?.enabled) {
+    polyline = decimate(polylineData.points, options?.decimate?.epsilon);
+  }
   let {
     closed
   } = polylineData;