@cornerstonejs/adapters 1.51.5 → 1.53.0

package/dist/adapters.es.js

@@ -38144,6 +38144,164 @@ function applyPointsToPiecewiseFunction(points, range, pwf) {
   return rescaled;
 }
 
+let PointsManager$2 = class PointsManager {
+  constructor(configuration = {}) {
+    this._dimensions = 3;
+    this._length = 0;
+    this._byteSize = 4;
+    this.growSize = 128;
+    const {
+      initialSize = 1024,
+      dimensions = 3,
+      growSize = 128
+    } = configuration;
+    const itemLength = initialSize * dimensions;
+    this.growSize = growSize;
+    this.array = new ArrayBuffer(itemLength * this._byteSize);
+    this.data = new Float32Array(this.array);
+    this._dimensions = dimensions;
+  }
+  forEach(func) {
+    for (let i = 0; i < this._length; i++) {
+      func(this.getPoint(i), i);
+    }
+  }
+  get length() {
+    return this._length;
+  }
+  get dimensions() {
+    return this._dimensions;
+  }
+  get dimensionLength() {
+    return this._length * this._dimensions;
+  }
+  getPoint(index) {
+    if (index < 0) {
+      index += this._length;
+    }
+    if (index < 0 || index >= this._length) {
+      return;
+    }
+    const offset = this._dimensions * index;
+    return this.data.subarray(offset, offset + this._dimensions);
+  }
+  getPointArray(index) {
+    const array = [];
+    if (index < 0) {
+      index += this._length;
+    }
+    if (index < 0 || index >= this._length) {
+      return;
+    }
+    const offset = this._dimensions * index;
+    for (let i = 0; i < this._dimensions; i++) {
+      array.push(this.data[i + offset]);
+    }
+    return array;
+  }
+  grow(additionalSize = 1, growSize = this.growSize) {
+    if (this.dimensionLength + additionalSize * this._dimensions <= this.data.length) {
+      return;
+    }
+    const newSize = this.data.length + growSize;
+    const newArray = new ArrayBuffer(newSize * this._dimensions * this._byteSize);
+    const newData = new Float32Array(newArray);
+    newData.set(this.data);
+    this.data = newData;
+    this.array = newArray;
+  }
+  reverse() {
+    const midLength = Math.floor(this._length / 2);
+    for (let i = 0; i < midLength; i++) {
+      const indexStart = i * this._dimensions;
+      const indexEnd = (this._length - 1 - i) * this._dimensions;
+      for (let dimension = 0; dimension < this._dimensions; dimension++) {
+        const valueStart = this.data[indexStart + dimension];
+        this.data[indexStart + dimension] = this.data[indexEnd + dimension];
+        this.data[indexEnd + dimension] = valueStart;
+      }
+    }
+  }
+  push(point) {
+    this.grow(1);
+    const offset = this.length * this._dimensions;
+    for (let i = 0; i < this._dimensions; i++) {
+      this.data[i + offset] = point[i];
+    }
+    this._length++;
+  }
+  map(f) {
+    const mapData = [];
+    for (let i = 0; i < this._length; i++) {
+      mapData.push(f(this.getPoint(i), i));
+    }
+    return mapData;
+  }
+  get points() {
+    return this.map(p => p);
+  }
+  toXYZ() {
+    const xyz = {
+      x: [],
+      y: []
+    };
+    if (this._dimensions >= 3) {
+      xyz.z = [];
+    }
+    const {
+      x,
+      y,
+      z
+    } = xyz;
+    this.forEach(p => {
+      x.push(p[0]);
+      y.push(p[1]);
+      if (z) {
+        z.push(p[2]);
+      }
+    });
+    return xyz;
+  }
+  static fromXYZ({
+    x,
+    y,
+    z
+  }) {
+    const array = PointsManager.create3(x.length);
+    let offset = 0;
+    for (let i = 0; i < x.length; i++) {
+      array.data[offset++] = x[i];
+      array.data[offset++] = y[i];
+      array.data[offset++] = z ? z[i] : 0;
+    }
+    array._length = x.length;
+    return array;
+  }
+  subselect(count = 10, offset = 0) {
+    const selected = new PointsManager({
+      initialSize: count,
+      dimensions: this._dimensions
+    });
+    for (let i = 0; i < count; i++) {
+      const index = (offset + Math.floor(this.length * i / count)) % this.length;
+      selected.push(this.getPoint(index));
+    }
+    return selected;
+  }
+  static create3(initialSize = 128) {
+    return new PointsManager({
+      initialSize,
+      dimensions: 3
+    });
+  }
+  static create2(initialSize = 128) {
+    return new PointsManager({
+      initialSize,
+      dimensions: 2
+    });
+  }
+};
+
 const isMergeableObject = val => {
   const nonNullObject = val && typeof val === 'object';
   return nonNullObject && Object.prototype.toString.call(val) !== '[object RegExp]' && Object.prototype.toString.call(val) !== '[object Date]';
@@ -42216,6 +42374,7 @@ var colormap = /*#__PURE__*/Object.freeze({
 
 var utilities = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  PointsManager: PointsManager$2,
   ProgressiveIterator: ProgressiveIterator,
   VoxelManager: VoxelManager,
   actorIsA: actorIsA,
@@ -45160,7 +45319,9 @@ class StackViewport extends Viewport$1 {
     }
     const csImgFrame = this.csImage?.imageFrame;
     const imgFrame = image?.imageFrame;
-    if (csImgFrame?.photometricInterpretation !== imgFrame?.photometricInterpretation || this.csImage?.photometricInterpretation !== image?.photometricInterpretation) {
+    const photometricInterpretation = csImgFrame?.photometricInterpretation || this.csImage?.photometricInterpretation;
+    const newPhotometricInterpretation = imgFrame?.photometricInterpretation || image?.photometricInterpretation;
+    if (photometricInterpretation !== newPhotometricInterpretation) {
       this.stackInvalidated = true;
     }
     this._setCSImage(image);
@@ -47039,6 +47200,7 @@ var ChangeTypes;
   ChangeTypes["StatsUpdated"] = "StatsUpdated";
   ChangeTypes["InitialSetup"] = "InitialSetup";
   ChangeTypes["Completed"] = "Completed";
+  ChangeTypes["InterpolationUpdated"] = "InterpolationUpdated";
 })(ChangeTypes || (ChangeTypes = {}));
 var ChangeTypes$1 = ChangeTypes;
 
@@ -48208,6 +48370,100 @@ let AnnotationToPointData$1 = class AnnotationToPointData {
 AnnotationToPointData$1.register(RectangleROIStartEndThreshold$1);
 var AnnotationToPointData$2 = AnnotationToPointData$1;
 
+function getContourHolesDataWorld(annotation) {
+  const childAnnotationUIDs = annotation.childAnnotationUIDs ?? [];
+  return childAnnotationUIDs.map(uid => getAnnotation(uid).data.contour.polyline);
+}
+
+function getContourHolesDataCanvas(annotation, viewport) {
+  const worldHoleContours = getContourHolesDataWorld(annotation);
+  const canvasHoleContours = [];
+  worldHoleContours.forEach(worldHoleContour => {
+    const numPoints = worldHoleContour.length;
+    const canvasHoleContour = new Array(numPoints);
+    for (let i = 0; i < numPoints; i++) {
+      canvasHoleContour[i] = viewport.worldToCanvas(worldHoleContour[i]);
+    }
+    canvasHoleContours.push(canvasHoleContour);
+  });
+  return canvasHoleContours;
+}
+
+function distanceToPointSquared(p1, p2) {
+  if (p1.length !== p2.length) {
+    throw Error('Both points should have the same dimensionality');
+  }
+  const [x1, y1, z1 = 0] = p1;
+  const [x2, y2, z2 = 0] = p2;
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  const dz = z2 - z1;
+  return dx * dx + dy * dy + dz * dz;
+}
+
+function getSignedArea(polyline) {
+  const refPoint = polyline[0];
+  let area = 0;
+  for (let i = 0, len = polyline.length; i < len; i++) {
+    const p1 = polyline[i];
+    const p2Index = i === len - 1 ? 0 : i + 1;
+    const p2 = polyline[p2Index];
+    const aX = p1[0] - refPoint[0];
+    const aY = p1[1] - refPoint[1];
+    const bX = p2[0] - refPoint[0];
+    const bY = p2[1] - refPoint[1];
+    area += aX * bY - aY * bX;
+  }
+  area *= 0.5;
+  return area;
+}
+
+function getWindingDirection(polyline) {
+  const signedArea = getSignedArea(polyline);
+  return signedArea >= 0 ? 1 : -1;
+}
+
+function updateContourPolyline(annotation, polylineData, transforms) {
+  const {
+    canvasToWorld
+  } = transforms;
+  const {
+    data
+  } = annotation;
+  const {
+    points: polyline,
+    targetWindingDirection
+  } = polylineData;
+  let {
+    closed
+  } = polylineData;
+  const numPoints = polyline.length;
+  const polylineWorldPoints = new Array(numPoints);
+  const currentWindingDirection = getWindingDirection(polyline);
+  const parentAnnotation = getParentAnnotation(annotation);
+  if (closed === undefined) {
+    let currentClosedState = false;
+    if (polyline.length > 3) {
+      const lastToFirstDist = distanceToPointSquared(polyline[0], polyline[numPoints - 1]);
+      currentClosedState = isEqual$2(0, lastToFirstDist);
+    }
+    closed = currentClosedState;
+  }
+  let windingDirection = parentAnnotation ? parentAnnotation.data.contour.windingDirection * -1 : targetWindingDirection;
+  if (windingDirection === undefined) {
+    windingDirection = currentWindingDirection;
+  } else if (windingDirection !== currentWindingDirection) {
+    polyline.reverse();
+  }
+  for (let i = 0; i < numPoints; i++) {
+    polylineWorldPoints[i] = canvasToWorld(polyline[i]);
+  }
+  data.contour.polyline = polylineWorldPoints;
+  data.contour.closed = closed;
+  data.contour.windingDirection = windingDirection;
+  invalidateAnnotation(annotation);
+}
+
 function getInterpolationData(viewportData, filterParams = []) {
   const {
     viewport,
@@ -48231,7 +48487,9 @@ function getInterpolationData(viewportData, filterParams = []) {
         return value === x.value;
       });
     });
-    interpolationDatas.set(i, filteredInterpolatedAnnotations);
+    if (filteredInterpolatedAnnotations.length) {
+      interpolationDatas.set(i, filteredInterpolatedAnnotations);
+    }
   }
   return interpolationDatas;
 }
@@ -48264,7 +48522,8 @@ function createPolylineToolData(polyline, handlePoints, referencedToolData) {
   });
   Object.assign(annotation.data, {
     handles: {
-      points: handlePoints || [],
+      points: handlePoints.points || handlePoints || [],
+      interpolationSources: handlePoints.sources,
       activeHandleIndex: null,
       textBox: {
         hasMoved: false,
@@ -48334,7 +48593,7 @@ function _getSlicePositionOfToolData(interpolationData, annotationUID) {
 }
 function _sliceNeedsInterpolating(interpolationData, sliceIndex) {
   const annotations = interpolationData.get(sliceIndex);
-  return !annotations || annotations.length === 1 && annotations[0].autoGenerated;
+  return !annotations?.length || annotations.length === 1 && annotations[0].autoGenerated;
 }
 function _appendInterpolationList(contourPair, interpolationList, itemIndex) {
   const [startIndex] = contourPair;
@@ -48382,99 +48641,182 @@ function _getBoundingPair(sliceIndex, sliceRange, interpolationData) {
   return annotationPair;
 }
 
-class PointsArray {
-  constructor(configuration = {}) {
-    this.dimensions = 3;
-    this.length = 0;
-    const {
-      initialSize = 1024,
-      dimensions = 3
-    } = configuration;
-    this.data = new Float32Array(initialSize * dimensions);
-    this.dimensions = dimensions;
-  }
-  forEach(func, point) {
-    for (let i = 0; i < this.length; i++) {
-      func(this.getPoint(i, point), i);
-    }
-  }
-  reverse() {
-    const midLength = Math.floor(this.length / 2);
-    for (let i = 0; i < midLength; i++) {
-      const indexStart = i * this.dimensions;
-      const indexEnd = (this.length - 1 - i) * this.dimensions;
-      for (let dimension = 0; dimension < this.dimensions; dimension++) {
-        const valueStart = this.data[indexStart + dimension];
-        this.data[indexStart + dimension] = this.data[indexEnd + dimension];
-        this.data[indexEnd + dimension] = valueStart;
+const {
+  PointsManager: PointsManager$1
+} = utilities;
+function selectHandles(polyline, handleCount = 8) {
+  const handles = PointsManager$1.create3(handleCount);
+  handles.sources = [];
+  const {
+    sources: destPoints
+  } = handles;
+  const {
+    length,
+    sources: sourcePoints = []
+  } = polyline;
+  const distance = 6;
+  if (length < distance * 3) {
+    console.log('Adding subselect handles', handleCount, length);
+    return polyline.subselect(handleCount);
+  }
+  const interval = Math.min(30, Math.floor(length / 3));
+  sourcePoints.forEach(() => destPoints.push(PointsManager$1.create3(handleCount)));
+  const dotValues = createDotValues(polyline, distance);
+  const minimumRegions = findMinimumRegions(dotValues, handleCount);
+  const indices = [];
+  if (minimumRegions?.length > 2) {
+    let lastHandle = -1;
+    const thirdInterval = interval / 3;
+    minimumRegions.forEach(region => {
+      const [start,, end] = region;
+      const midIndex = Math.ceil((start + end) / 2);
+      if (end - lastHandle < thirdInterval) {
+        return;
+      }
+      if (midIndex - start > 2 * thirdInterval) {
+        addInterval(indices, lastHandle, start, interval, length);
+        lastHandle = addInterval(indices, start, midIndex, interval, length);
+      } else {
+        lastHandle = addInterval(indices, lastHandle, midIndex, interval, length);
+      }
+      if (end - lastHandle > thirdInterval) {
+        lastHandle = addInterval(indices, lastHandle, end, interval, length);
       }
+    });
+    const firstHandle = indices[0];
+    const lastDistance = indexValue(firstHandle + length - lastHandle, length);
+    if (lastDistance > 2 * thirdInterval) {
+      addInterval(indices, lastHandle, firstHandle - thirdInterval, interval, length);
     }
+  } else {
+    const interval = Math.floor(length / handleCount);
+    addInterval(indices, -1, length - interval, interval, length);
   }
-  map(f, factory) {
-    const mapData = [];
-    for (let i = 0; i < this.length; i++) {
-      mapData.push(f(this.getPoint(i, factory(i)), i));
+  indices.forEach(index => {
+    const point = polyline.getPointArray(index);
+    handles.push(point);
+    sourcePoints.forEach((source, destSourceIndex) => destPoints[destSourceIndex].push(source.getPoint(index)));
+  });
+  return handles;
+}
+function createDotValues(polyline, distance = 6) {
+  const {
+    length
+  } = polyline;
+  const prevVec3 = vec3.create();
+  const nextVec3 = vec3.create();
+  const dotValues = new Float32Array(length);
+  for (let i = 0; i < length; i++) {
+    const point = polyline.getPoint(i);
+    const prevPoint = polyline.getPoint(i - distance);
+    const nextPoint = polyline.getPoint((i + distance) % length);
+    vec3.sub(prevVec3, point, prevPoint);
+    vec3.sub(nextVec3, nextPoint, point);
+    const dot = vec3.dot(prevVec3, nextVec3) / (vec3.len(prevVec3) * vec3.len(nextVec3));
+    dotValues[i] = dot;
+  }
+  return dotValues;
+}
+function findMinimumRegions(dotValues, handleCount) {
+  const {
+    max,
+    deviation
+  } = getStats(dotValues);
+  const {
+    length
+  } = dotValues;
+  if (deviation < 0.01 || length < handleCount * 3) {
+    return [0, Math.floor(length / 3), Math.floor(length * 2 / 3)];
+  }
+  const inflection = [];
+  let pair = null;
+  let minValue;
+  let minIndex = 0;
+  for (let i = 0; i < length; i++) {
+    const dot = dotValues[i];
+    if (dot < max - deviation) {
+      if (pair) {
+        pair[2] = i;
+        if (dot < minValue) {
+          minValue = dot;
+          minIndex = i;
+        }
+        pair[1] = minIndex;
+      } else {
+        minValue = dot;
+        minIndex = i;
+        pair = [i, i, i];
+      }
+    } else {
+      if (pair) {
+        inflection.push(pair);
+        pair = null;
+      }
     }
-    return mapData;
   }
-  static fromXYZ({
-    x,
-    y,
-    z
-  }) {
-    const array = new PointsArray3({
-      initialSize: x.length
-    });
-    let offset = 0;
-    for (let i = 0; i < x.length; i++) {
-      array.data[offset++] = x[i];
-      array.data[offset++] = y[i];
-      array.data[offset++] = z[i];
+  if (pair) {
+    if (inflection[0][0] === 0) {
+      inflection[0][0] = pair[0];
+    } else {
+      pair[1] = minIndex;
+      pair[2] = length - 1;
+      inflection.push(pair);
     }
-    array.length = x.length;
-    return array;
   }
+  return inflection;
 }
-class PointsArray3 extends PointsArray {
-  constructor(configuration = {}) {
-    super({
-      ...configuration,
-      dimensions: 3
-    });
+function addInterval(indices, start, finish, interval, length) {
+  if (finish < start) {
+    finish += length;
   }
-  forEach(func, point = vec3.create()) {
-    super.forEach(func, point);
-  }
-  getPoint(index, point = vec3.create()) {
-    if (index >= this.length) {
-      return;
+  const distance = finish - start;
+  const count = Math.ceil(distance / interval);
+  if (count <= 0) {
+    if (indices[indices.length - 1] !== finish) {
+      indices.push(indexValue(finish, length));
     }
-    const index2 = index * 3;
-    point[0] = this.data[index2];
-    point[1] = this.data[index2 + 1];
-    point[2] = this.data[index2 + 2];
-    return point;
+    return finish;
   }
-  get points() {
-    return this.map(point => point, () => vec3.create());
+  for (let i = 1; i <= count; i++) {
+    const index = indexValue(start + i * distance / count, length);
+    indices.push(index);
   }
-  getXYZ() {
-    const x = [];
-    const y = [];
-    const z = [];
-    this.forEach(point => {
-      x.push(point[0]);
-      y.push(point[1]);
-      z.push(point[2]);
-    });
-    return {
-      x,
-      y,
-      z
-    };
+  return indices[indices.length - 1];
+}
+function indexValue(v, length) {
+  return (Math.round(v) + length) % length;
+}
+function getStats(dotValues) {
+  const {
+    length
+  } = dotValues;
+  let sum = 0;
+  let min = Infinity;
+  let max = -Infinity;
+  let sumSq = 0;
+  for (let i = 0; i < length; i++) {
+    const dot = dotValues[i];
+    sum += dot;
+    min = Math.min(min, dot);
+    max = Math.max(max, dot);
+  }
+  const mean = sum / length;
+  for (let i = 0; i < length; i++) {
+    const valueDiff = dotValues[i] - mean;
+    sumSq += valueDiff * valueDiff;
   }
+  return {
+    mean,
+    max,
+    min,
+    sumSq,
+    deviation: Math.sqrt(sumSq / length)
+  };
 }
 
+const {
+  PointsManager
+} = utilities;
 const dP = 0.2;
 let interpolating = false;
 function interpolate(viewportData) {
@@ -48482,11 +48824,24 @@ function interpolate(viewportData) {
     return;
   }
   interpolating = true;
-  try {
-    startInterpolation(viewportData);
-  } finally {
-    interpolating = false;
-  }
+  const {
+    isInterpolationUpdate,
+    annotation
+  } = viewportData;
+  queueMicrotask(() => {
+    try {
+      if (isInterpolationUpdate) {
+        annotation.isInterpolationUpdate = true;
+        annotation.autoGenerated = false;
+      }
+      startInterpolation(viewportData);
+    } finally {
+      interpolating = false;
+      if (isInterpolationUpdate) {
+        annotation.autoGenerated = true;
+      }
+    }
+  });
 }
 function startInterpolation(viewportData) {
   const toolData = viewportData.annotation;
@@ -48526,6 +48881,8 @@ function _linearlyInterpolateBetween(indices, annotationPair, interpolationData,
     c1Interp,
     c2Interp
   } = _generateInterpolationContourPair(c1, c2);
+  c1Interp.kIndex = annotationPair[0];
+  c2Interp.kIndex = annotationPair[1];
   indices.forEach(function (index) {
     _linearlyInterpolateContour(c1Interp, c2Interp, index, annotationPair, interpolationData, c1.x.length > c2.x.length, eventData);
   });
@@ -48535,30 +48892,15 @@ function _linearlyInterpolateContour(c1Interp, c2Interp, sliceIndex, annotationP
   const zInterp = (sliceIndex - startIndex) / (endIndex - startIndex);
   const interpolated3DPoints = _generateInterpolatedOpenContour(c1Interp, c2Interp, zInterp, c1HasMoreNodes);
   const nearestAnnotation = interpolationData.get(annotationPair[zInterp > 0.5 ? 1 : 0])[0];
-  const handleCount = Math.round(Math.max(8, interpolationData.get(startIndex)[0].data.handles.points.length, interpolationData.get(endIndex)[0].data.handles.points.length, interpolated3DPoints.x.length / 50));
-  const handlePoints = _subselect(interpolated3DPoints, handleCount);
+  const handlePoints = selectHandles(interpolated3DPoints);
   if (interpolationData.has(sliceIndex)) {
     _editInterpolatedContour(interpolated3DPoints, handlePoints, sliceIndex, nearestAnnotation, eventData);
   } else {
     _addInterpolatedContour(interpolated3DPoints, handlePoints, sliceIndex, nearestAnnotation, eventData);
   }
 }
-function _subselect(points, count = 10) {
-  const handles = [];
-  const {
-    length
-  } = points.x;
-  if (!length) {
-    return handles;
-  }
-  for (let i = 0; i < count; i++) {
-    const handleIndex = Math.floor(length * i / count);
-    handles.push(vec3.fromValues(points.x[handleIndex], points.y[handleIndex], points.z[handleIndex]));
-  }
-  return handles;
-}
 function _addInterpolatedContour(interpolated3DPoints, handlePoints, sliceIndex, referencedToolData, eventData) {
-  const points = PointsArray.fromXYZ(interpolated3DPoints).points;
+  const points = interpolated3DPoints.points;
   const {
     viewport
   } = eventData;
@@ -48569,7 +48911,7 @@ function _addInterpolatedContour(interpolated3DPoints, handlePoints, sliceIndex,
   interpolatedAnnotation.metadata.referencedImageId = targetId;
   interpolatedAnnotation.metadata.referencedSliceIndex = sliceIndex;
   addAnnotation(interpolatedAnnotation, viewport.element);
-  referencedToolData.postInterpolateAction?.(interpolatedAnnotation, referencedToolData);
+  referencedToolData.onInterpolationComplete?.(interpolatedAnnotation, referencedToolData);
 }
 function _editInterpolatedContour(interpolated3DPoints, handlePoints, sliceIndex, referencedToolData, eventData) {
   const {
@@ -48589,26 +48931,37 @@ function _editInterpolatedContour(interpolated3DPoints, handlePoints, sliceIndex
     return;
   }
   const oldToolData = annotations[toolDataIndex];
-  const points = PointsArray.fromXYZ(interpolated3DPoints).points;
+  const points = interpolated3DPoints.points;
   const interpolatedAnnotation = createPolylineToolData(points, handlePoints, oldToolData);
   interpolatedAnnotation.annotationUID = oldToolData.annotationUID;
   removeAnnotation(oldToolData.annotationUID);
   addAnnotation(interpolatedAnnotation, viewport.element);
 }
 function _generateInterpolatedOpenContour(c1ir, c2ir, zInterp, c1HasMoreNodes) {
-  const cInterp = {
-    x: [],
-    y: [],
-    z: []
-  };
   const indices = c1HasMoreNodes ? c1ir.I : c2ir.I;
+  const c1 = PointsManager.fromXYZ(c1ir);
+  const c2 = PointsManager.fromXYZ(c2ir);
+  const {
+    length
+  } = c1;
+  const cInterp = PointsManager.create3(length);
+  const vecSubtract = vec3.create();
+  const vecResult = vec3.create();
+  const c1Source = PointsManager.create3(length);
+  c1Source.kIndex = c1ir.kIndex;
+  const c2Source = PointsManager.create3(length);
+  c2Source.kIndex = c2ir.kIndex;
   for (let i = 0; i < c1ir.x.length; i++) {
     if (indices[i]) {
-      cInterp.x.push(c1ir.x[i] + (c2ir.x[i] - c1ir.x[i]) * zInterp);
-      cInterp.y.push(c1ir.y[i] + (c2ir.y[i] - c1ir.y[i]) * zInterp);
-      cInterp.z.push(c1ir.z[i] + (c2ir.z[i] - c1ir.z[i]) * zInterp);
+      const c1point = c1.getPoint(i);
+      const c2point = c2.getPoint(i);
+      c1Source.push(c1point);
+      c2Source.push(c2point);
+      vec3.sub(vecSubtract, c2point, c1point);
+      cInterp.push(vec3.scaleAndAdd(vecResult, c1point, vecSubtract, zInterp));
     }
   }
+  cInterp.sources = [c1Source, c2Source];
   return cInterp;
 }
 function _generateInterpolationContourPair(c1, c2) {
@@ -48621,8 +48974,8 @@ function _generateInterpolationContourPair(c1, c2) {
   const numNodes2 = interpNodes + c1.x.length;
   const perim1Interp = _getInterpolatedPerim(numNodes1, cumPerim1Norm);
   const perim2Interp = _getInterpolatedPerim(numNodes2, cumPerim2Norm);
-  const perim1Ind = _getIndicatorArray(c1, numNodes1);
-  const perim2Ind = _getIndicatorArray(c2, numNodes2);
+  const perim1Ind = _getIndicatorArray(numNodes1 - 2, c1.x.length);
+  const perim2Ind = _getIndicatorArray(numNodes2 - 2, c2.x.length);
   const nodesPerSegment1 = _getNodesPerSegment(perim1Interp, perim1Ind);
   const nodesPerSegment2 = _getNodesPerSegment(perim2Interp, perim2Ind);
   const c1i = _getSuperSampledContour(c1, nodesPerSegment1);
@@ -48741,14 +49094,10 @@ function _getNodesPerSegment(perimInterp, perimInd) {
   }
   return nodesPerSegment;
 }
-function _getIndicatorArray(contour, numNodes) {
-  const perimInd = [];
-  for (let i = 0; i < numNodes - 2; i++) {
-    perimInd.push(false);
-  }
-  for (let i = 0; i < contour.x.length; i++) {
-    perimInd.push(true);
-  }
+function _getIndicatorArray(numFalse, numTrue) {
+  const perimInd = new Array(numFalse + numTrue);
+  perimInd.fill(false, 0, numFalse);
+  perimInd.fill(true, numFalse, numFalse + numTrue);
   return perimInd;
 }
 function _getInterpolatedPerim(numNodes, cumPerimNorm) {
@@ -48855,6 +49204,7 @@ function deleteRelatedAnnotations(viewportData) {
 const {
   uuidv4
 } = utilities;
+const ChangeTypesForInterpolation = [ChangeTypes$1.HandlesUpdated, ChangeTypes$1.InterpolationUpdated];
 class InterpolationManager {
   static {
     this.toolNames = [];
@@ -48868,7 +49218,8 @@ class InterpolationManager {
     const {
       toolNames,
       segmentationId,
-      segmentIndex
+      segmentIndex,
+      sliceIndex
     } = selector;
     for (const toolName of toolNames || InterpolationManager.toolNames) {
       const annotations = getAnnotations(toolName, annotationGroupSelector);
@@ -48878,7 +49229,8 @@ class InterpolationManager {
       for (const annotation of annotations) {
         const {
           data,
-          autoGenerated
+          autoGenerated,
+          metadata
         } = annotation;
         if (!autoGenerated) {
           continue;
@@ -48886,6 +49238,9 @@ class InterpolationManager {
         if (segmentIndex && segmentIndex !== data.segmentation.segmentIndex) {
           continue;
         }
+        if (sliceIndex !== undefined && metadata && sliceIndex !== metadata.referencedSliceIndex) {
+          continue;
+        }
         if (segmentationId && segmentationId !== data.segmentation.segmentationId) {
           continue;
         }
@@ -48958,7 +49313,7 @@ class InterpolationManager {
       const {
         toolName
       } = annotation.metadata;
-      if (!this.toolNames.includes(toolName) || changeType !== ChangeTypes$1.HandlesUpdated) {
+      if (!this.toolNames.includes(toolName) || !ChangeTypesForInterpolation.includes(changeType)) {
         return;
       }
       const viewport = getViewportForAnnotation(annotation);
@@ -48972,7 +49327,8 @@ class InterpolationManager {
         viewport,
         sliceData,
         annotation,
-        interpolationUID: annotation.interpolationUID
+        interpolationUID: annotation.interpolationUID,
+        isInterpolationUpdate: changeType === ChangeTypes$1.InterpolationUpdated
       };
       interpolate(viewportData);
     };
@@ -49070,8 +49426,11 @@ var index = /*#__PURE__*/Object.freeze({
   detectContourHoles: detectContourHoles,
   findHandlePolylineIndex: findHandlePolylineIndex,
   generateContourSetsFromLabelmap: generateContourSetsFromLabelmap$2,
+  getContourHolesDataCanvas: getContourHolesDataCanvas,
+  getContourHolesDataWorld: getContourHolesDataWorld,
   interpolation: index$1,
-  mergePoints: mergePoints
+  mergePoints: mergePoints,
+  updateContourPolyline: updateContourPolyline
 });
 
 const MODES = [ToolModes$1.Active, ToolModes$1.Passive, ToolModes$1.Enabled];
@@ -49159,6 +49518,9 @@ function getAnnotations(toolName, annotationGroupSelector) {
   const groupKey = manager.getGroupKey(annotationGroupSelector);
   return manager.getAnnotations(groupKey, toolName);
 }
+function getParentAnnotation(annotation) {
+  return annotation.parentAnnotationUID ? getAnnotation(annotation.parentAnnotationUID) : undefined;
+}
 function addAnnotation(annotation, annotationGroupSelector) {
   if (!annotation.annotationUID) {
     annotation.annotationUID = uuidv4$1();
@@ -49183,6 +49545,7 @@ function removeAnnotation(annotationUID) {
   if (!annotation) {
     return;
   }
+  annotation.childAnnotationUIDs?.forEach(childAnnotationUID => removeAnnotation(childAnnotationUID));
   manager.removeAnnotation(annotationUID);
   const eventType = Events$1.ANNOTATION_REMOVED;
   const eventDetail = {
@@ -49196,6 +49559,13 @@ function getAnnotation(annotationUID) {
   const annotation = manager.getAnnotation(annotationUID);
   return annotation;
 }
+function invalidateAnnotation(annotation) {
+  let currAnnotation = annotation;
+  while (currAnnotation) {
+    currAnnotation.invalidated = true;
+    currAnnotation = currAnnotation.parentAnnotationUID ? getAnnotation(currAnnotation.parentAnnotationUID) : undefined;
+  }
+}
 
 function getPatientModule(imageId, metadataProvider) {
   var generalSeriesModule = metadataProvider.get("generalSeriesModule", imageId);