@cornerstonejs/adapters 1.63.5 → 1.64.1

package/dist/adapters.es.js

@@ -36033,7 +36033,7 @@ function loadAndCacheImage(imageId, options = {
   return imageLoadObject.promise;
 }
 
-const VIEWPORT_ELEMENT = 'viewport-element';
+const VIEWPORT_ELEMENT$1 = 'viewport-element';
 const CANVAS_CSS_CLASS = 'cornerstone-canvas';
 function createCanvas(element) {
   const canvas = document.createElement('canvas');
@@ -36049,13 +36049,13 @@ function createViewportElement(element) {
   div.style.position = 'relative';
   div.style.width = '100%';
   div.style.height = '100%';
-  div.classList.add(VIEWPORT_ELEMENT);
+  div.classList.add(VIEWPORT_ELEMENT$1);
   element.appendChild(div);
   return div;
 }
 function getOrCreateCanvas(element) {
   const canvasSelector = `canvas.${CANVAS_CSS_CLASS}`;
-  const viewportElement = `div.${VIEWPORT_ELEMENT}`;
+  const viewportElement = `div.${VIEWPORT_ELEMENT$1}`;
   const internalDiv = element.querySelector(viewportElement) || createViewportElement(element);
   return internalDiv.querySelector(canvasSelector) || createCanvas(internalDiv);
 }
@@ -48803,6 +48803,238 @@ function getSegmentation(segmentationId) {
   return segmentationStateManager.getSegmentation(segmentationId);
 }
 
+const VIEWPORT_ELEMENT = 'viewport-element';
+function getSvgDrawingHelper(element) {
+  const enabledElement = getEnabledElement(element);
+  const {
+    viewportId,
+    renderingEngineId
+  } = enabledElement;
+  const canvasHash = `${viewportId}:${renderingEngineId}`;
+  const svgLayerElement = _getSvgLayer(element);
+  Object.keys(state.svgNodeCache[canvasHash]).forEach(cacheKey => {
+    state.svgNodeCache[canvasHash][cacheKey].touched = false;
+  });
+  return {
+    svgLayerElement: svgLayerElement,
+    svgNodeCacheForCanvas: state.svgNodeCache,
+    getSvgNode: getSvgNode.bind(this, canvasHash),
+    appendNode: appendNode.bind(this, svgLayerElement, canvasHash),
+    setNodeTouched: setNodeTouched.bind(this, canvasHash),
+    clearUntouched: clearUntouched.bind(this, svgLayerElement, canvasHash)
+  };
+}
+function _getSvgLayer(element) {
+  const viewportElement = `.${VIEWPORT_ELEMENT}`;
+  const internalDivElement = element.querySelector(viewportElement);
+  const svgLayer = internalDivElement.querySelector(':scope > .svg-layer');
+  return svgLayer;
+}
+function getSvgNode(canvasHash, cacheKey) {
+  if (!state.svgNodeCache[canvasHash]) {
+    return;
+  }
+  if (state.svgNodeCache[canvasHash][cacheKey]) {
+    return state.svgNodeCache[canvasHash][cacheKey].domRef;
+  }
+}
+function appendNode(svgLayerElement, canvasHash, svgNode, cacheKey) {
+  if (!state.svgNodeCache[canvasHash]) {
+    return null;
+  }
+  state.svgNodeCache[canvasHash][cacheKey] = {
+    touched: true,
+    domRef: svgNode
+  };
+  svgLayerElement.appendChild(svgNode);
+}
+function setNodeTouched(canvasHash, cacheKey) {
+  if (!state.svgNodeCache[canvasHash]) {
+    return;
+  }
+  if (state.svgNodeCache[canvasHash][cacheKey]) {
+    state.svgNodeCache[canvasHash][cacheKey].touched = true;
+  }
+}
+function clearUntouched(svgLayerElement, canvasHash) {
+  if (!state.svgNodeCache[canvasHash]) {
+    return;
+  }
+  Object.keys(state.svgNodeCache[canvasHash]).forEach(cacheKey => {
+    const cacheEntry = state.svgNodeCache[canvasHash][cacheKey];
+    if (!cacheEntry.touched && cacheEntry.domRef) {
+      svgLayerElement.removeChild(cacheEntry.domRef);
+      delete state.svgNodeCache[canvasHash][cacheKey];
+    }
+  });
+}
+
+function draw(element, fn) {
+  const svgDrawingHelper = getSvgDrawingHelper(element);
+  fn(svgDrawingHelper);
+  svgDrawingHelper.clearUntouched();
+}
+
+function getToolsWithModesForElement(element, modesFilter) {
+  const enabledElement = getEnabledElement(element);
+  const {
+    renderingEngineId,
+    viewportId
+  } = enabledElement;
+  const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
+  if (!toolGroup) {
+    return [];
+  }
+  const enabledTools = [];
+  const toolGroupToolNames = Object.keys(toolGroup.toolOptions);
+  for (let j = 0; j < toolGroupToolNames.length; j++) {
+    const toolName = toolGroupToolNames[j];
+    const toolOptions = toolGroup.toolOptions[toolName];
+    if (!toolOptions) {
+      continue;
+    }
+    if (modesFilter.includes(toolOptions.mode)) {
+      const toolInstance = toolGroup.getToolInstance(toolName);
+      enabledTools.push(toolInstance);
+    }
+  }
+  return enabledTools;
+}
+
+const {
+  Active: Active$1,
+  Passive: Passive$1,
+  Enabled: Enabled$1
+} = ToolModes$1;
+class AnnotationRenderingEngine {
+  constructor() {
+    this._needsRender = new Set();
+    this._animationFrameSet = false;
+    this._animationFrameHandle = null;
+    this._renderFlaggedViewports = () => {
+      this._throwIfDestroyed();
+      const elements = Array.from(this._viewportElements.values());
+      for (let i = 0; i < elements.length; i++) {
+        const element = elements[i];
+        if (this._needsRender.has(element)) {
+          this._triggerRender(element);
+          this._needsRender.delete(element);
+          if (this._needsRender.size === 0) {
+            break;
+          }
+        }
+      }
+      this._animationFrameSet = false;
+      this._animationFrameHandle = null;
+      this._render();
+    };
+    this._viewportElements = new Map();
+  }
+  addViewportElement(viewportId, element) {
+    this._viewportElements.set(viewportId, element);
+  }
+  removeViewportElement(viewportId, element) {
+    this._viewportElements.delete(viewportId);
+    this._needsRender.delete(element);
+    this._reset();
+  }
+  renderViewport(element) {
+    this._setViewportsToBeRenderedNextFrame([element]);
+  }
+  _throwIfDestroyed() {
+    if (this.hasBeenDestroyed) {
+      throw new Error('this.destroy() has been manually called to free up memory, can not longer use this instance. Instead make a new one.');
+    }
+  }
+  _setAllViewportsToBeRenderedNextFrame() {
+    const elements = [...this._viewportElements.values()];
+    elements.forEach(element => {
+      this._needsRender.add(element);
+    });
+    this._renderFlaggedViewports();
+  }
+  _setViewportsToBeRenderedNextFrame(elements) {
+    const elementsEnabled = [...this._viewportElements.values()];
+    elements.forEach(element => {
+      if (elementsEnabled.indexOf(element) !== -1) {
+        this._needsRender.add(element);
+      }
+    });
+    this._render();
+  }
+  _render() {
+    if (this._needsRender.size > 0 && this._animationFrameSet === false) {
+      this._animationFrameHandle = window.requestAnimationFrame(this._renderFlaggedViewports);
+      this._animationFrameSet = true;
+    }
+  }
+  _triggerRender(element) {
+    const enabledElement = getEnabledElement(element);
+    if (!enabledElement) {
+      console.warn('Element has been disabled');
+      return;
+    }
+    const renderingEngine = getRenderingEngine(enabledElement.renderingEngineId);
+    if (!renderingEngine) {
+      console.warn('rendering Engine has been destroyed');
+      return;
+    }
+    const enabledTools = getToolsWithModesForElement(element, [Active$1, Passive$1, Enabled$1]);
+    const {
+      renderingEngineId,
+      viewportId
+    } = enabledElement;
+    const eventDetail = {
+      element,
+      renderingEngineId,
+      viewportId
+    };
+    draw(element, svgDrawingHelper => {
+      let anyRendered = false;
+      const handleDrawSvg = tool => {
+        if (tool.renderAnnotation) {
+          const rendered = tool.renderAnnotation(enabledElement, svgDrawingHelper);
+          anyRendered = anyRendered || rendered;
+        }
+      };
+      enabledTools.forEach(handleDrawSvg);
+      if (anyRendered) {
+        triggerEvent(element, Events$1.ANNOTATION_RENDERED, {
+          ...eventDetail
+        });
+      }
+    });
+  }
+  _reset() {
+    window.cancelAnimationFrame(this._animationFrameHandle);
+    this._needsRender.clear();
+    this._animationFrameSet = false;
+    this._animationFrameHandle = null;
+    this._setAllViewportsToBeRenderedNextFrame();
+  }
+}
+const annotationRenderingEngine = new AnnotationRenderingEngine();
+function triggerAnnotationRender(element) {
+  annotationRenderingEngine.renderViewport(element);
+}
+
+function triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender) {
+  if (!viewportIdsToRender.length || !renderingEngine) {
+    return;
+  }
+  viewportIdsToRender.forEach(viewportId => {
+    const viewport = renderingEngine.getViewport(viewportId);
+    if (!viewport) {
+      console.warn(`Viewport not available for ${viewportId}`);
+      return;
+    }
+    const {
+      element
+    } = viewport;
+    triggerAnnotationRender(element);
+  });
+}
+
 const {
   isEqual: isEqual$1
 } = utilities;
@@ -49739,7 +49971,7 @@ function updateContourPolyline(annotation, polylineData, transforms, options) {
   invalidateAnnotation(annotation);
 }
 
-const DEFAULT_CONTOUR_SEG_TOOLNAME = 'PlanarFreehandContourSegmentationTool';
+const DEFAULT_CONTOUR_SEG_TOOLNAME$1 = 'PlanarFreehandContourSegmentationTool';
 function getInterpolationData(viewportData, filterParams = []) {
   const {
     viewport,
@@ -49753,8 +49985,8 @@ function getInterpolationData(viewportData, filterParams = []) {
   } = annotation.metadata;
   const testToolName = originalToolName || toolName;
   const annotations = (getAnnotations(testToolName, viewport.element) || []).filter(annotation => !annotation.metadata.originalToolName || annotation.metadata.originalToolName === testToolName);
-  if (testToolName !== DEFAULT_CONTOUR_SEG_TOOLNAME) {
-    const modifiedAnnotations = getAnnotations(DEFAULT_CONTOUR_SEG_TOOLNAME, viewport.element);
+  if (testToolName !== DEFAULT_CONTOUR_SEG_TOOLNAME$1) {
+    const modifiedAnnotations = getAnnotations(DEFAULT_CONTOUR_SEG_TOOLNAME$1, viewport.element);
     if (modifiedAnnotations?.length) {
       modifiedAnnotations.forEach(annotation => {
         const {
@@ -49816,7 +50048,8 @@ function createPolylineToolData(polyline, handlePoints, referencedToolData) {
     autoGenerated: true,
     annotationUID: undefined,
     cachedStats: {},
-    childAnnotationUIDs: []
+    childAnnotationUIDs: [],
+    parentAnnotationUID: undefined
   });
   Object.assign(annotation.data, {
     handles: {
@@ -49835,8 +50068,8 @@ function createPolylineToolData(polyline, handlePoints, referencedToolData) {
       }
     },
     contour: {
-      polyline,
-      closed: true
+      ...referencedToolData.data.contour,
+      polyline
     }
   });
   return annotation;
@@ -49956,11 +50189,11 @@ function selectHandles(polyline, handleCount = 12) {
     length,
     sources: sourcePoints = []
   } = polyline;
-  const distance = 6;
+  const distance = 5;
   if (length < distance * 3) {
     return polyline.subselect(handleCount);
   }
-  const interval = Math.floor(Math.max(2 * length / handleCount, distance * 5));
+  const interval = Math.floor(Math.max(2 * length / handleCount, distance * 2));
   sourcePoints.forEach(() => destPoints.push(PointsManager$1.create3(handleCount)));
   const dotValues = createDotValues(polyline, distance);
   const minimumRegions = findMinimumRegions(dotValues, handleCount);
@@ -50115,6 +50348,214 @@ function getStats(dotValues) {
   };
 }
 
+function updateChildInterpolationUID(annotation) {
+  const {
+    parentAnnotationUID,
+    annotationUID
+  } = annotation;
+  if (!parentAnnotationUID) {
+    return annotation.interpolationUID;
+  }
+  const parentAnnotation = getAnnotation(parentAnnotationUID);
+  const {
+    interpolationUID
+  } = parentAnnotation;
+  const index = parentAnnotation.childAnnotationUIDs.indexOf(annotationUID);
+  annotation.interpolationUID = `${interpolationUID}-${index}`;
+  return annotation.interpolationUID;
+}
+
+function filterViewportsWithFrameOfReferenceUID(viewports, FrameOfReferenceUID) {
+  const numViewports = viewports.length;
+  const viewportsWithFrameOfReferenceUID = [];
+  for (let vp = 0; vp < numViewports; vp++) {
+    const viewport = viewports[vp];
+    if (viewport.getFrameOfReferenceUID() === FrameOfReferenceUID) {
+      viewportsWithFrameOfReferenceUID.push(viewport);
+    }
+  }
+  return viewportsWithFrameOfReferenceUID;
+}
+
+const {
+  Active,
+  Passive,
+  Enabled
+} = ToolModes$1;
+function filterViewportsWithToolEnabled(viewports, toolName) {
+  const numViewports = viewports.length;
+  const viewportsWithToolEnabled = [];
+  for (let vp = 0; vp < numViewports; vp++) {
+    const viewport = viewports[vp];
+    const toolGroup = getToolGroupForViewport(viewport.id, viewport.renderingEngineId);
+    if (!toolGroup) {
+      continue;
+    }
+    const hasTool = _toolGroupHasActiveEnabledOrPassiveTool(toolGroup, toolName);
+    if (hasTool) {
+      viewportsWithToolEnabled.push(viewport);
+    }
+  }
+  return viewportsWithToolEnabled;
+}
+function _toolGroupHasActiveEnabledOrPassiveTool(toolGroup, toolName) {
+  const {
+    toolOptions
+  } = toolGroup;
+  const tool = toolOptions[toolName];
+  if (!tool) {
+    return false;
+  }
+  const toolMode = tool.mode;
+  return toolMode === Active || toolMode === Passive || toolMode === Enabled;
+}
+
+function filterViewportsWithParallelNormals(viewports, camera, EPS = 0.999) {
+  return viewports.filter(viewport => {
+    const vpCamera = viewport.getCamera();
+    const isParallel = Math.abs(vec3.dot(vpCamera.viewPlaneNormal, camera.viewPlaneNormal)) > EPS;
+    return isParallel;
+  });
+}
+
+function getViewportIdsWithToolToRender(element, toolName, requireParallelNormals = true) {
+  const enabledElement = getEnabledElement(element);
+  const {
+    renderingEngine,
+    FrameOfReferenceUID
+  } = enabledElement;
+  let viewports = renderingEngine.getViewports();
+  viewports = filterViewportsWithFrameOfReferenceUID(viewports, FrameOfReferenceUID);
+  viewports = filterViewportsWithToolEnabled(viewports, toolName);
+  const viewport = renderingEngine.getViewport(enabledElement.viewportId);
+  if (requireParallelNormals) {
+    viewports = filterViewportsWithParallelNormals(viewports, viewport.getCamera());
+  }
+  const viewportIds = viewports.map(vp => vp.id);
+  return viewportIds;
+}
+
+function addContourSegmentationAnnotation(annotation) {
+  if (annotation.parentAnnotationUID) {
+    return;
+  }
+  if (!annotation.data.segmentation) {
+    throw new Error('addContourSegmentationAnnotation: annotation does not have a segmentation data');
+  }
+  const {
+    segmentationId,
+    segmentIndex
+  } = annotation.data.segmentation;
+  const segmentation = getSegmentation(segmentationId);
+  if (!segmentation.representationData.CONTOUR) {
+    segmentation.representationData.CONTOUR = {
+      annotationUIDsMap: new Map()
+    };
+  }
+  const {
+    annotationUIDsMap
+  } = segmentation.representationData.CONTOUR;
+  let annotationsUIDsSet = annotationUIDsMap.get(segmentIndex);
+  if (!annotationsUIDsSet) {
+    annotationsUIDsSet = new Set();
+    annotationUIDsMap.set(segmentIndex, annotationsUIDsSet);
+  }
+  annotationUIDsMap.set(segmentIndex, annotationsUIDsSet.add(annotation.annotationUID));
+}
+
+function removeContourSegmentationAnnotation(annotation) {
+  if (!annotation.data.segmentation) {
+    throw new Error('removeContourSegmentationAnnotation: annotation does not have a segmentation data');
+  }
+  const {
+    segmentationId,
+    segmentIndex
+  } = annotation.data.segmentation;
+  const segmentation = getSegmentation(segmentationId);
+  const {
+    annotationUIDsMap
+  } = segmentation?.representationData.CONTOUR || {};
+  const annotationsUIDsSet = annotationUIDsMap?.get(segmentIndex);
+  if (!annotationsUIDsSet) {
+    return;
+  }
+  annotationsUIDsSet.delete(annotation.annotationUID);
+  if (!annotationsUIDsSet.size) {
+    annotationUIDsMap.delete(segmentIndex);
+  }
+}
+
+var index$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  InterpolationManager: InterpolationManager
+});
+
+const {
+  isEqual
+} = utilities;
+function findHandlePolylineIndex(annotation, handleIndex) {
+  const {
+    polyline
+  } = annotation.data.contour;
+  const {
+    points
+  } = annotation.data.handles;
+  const {
+    length
+  } = points;
+  if (handleIndex === length) {
+    return polyline.length;
+  }
+  if (handleIndex < 0) {
+    handleIndex = (handleIndex + length) % length;
+  }
+  if (handleIndex === 0) {
+    return 0;
+  }
+  const handle = points[handleIndex];
+  const index = polyline.findIndex(point => isEqual(handle, point));
+  if (index !== -1) {
+    return index;
+  }
+  let closestDistance = Infinity;
+  return polyline.reduce((closestIndex, point, testIndex) => {
+    const distance = vec3.squaredDistance(point, handle);
+    if (distance < closestDistance) {
+      closestDistance = distance;
+      return testIndex;
+    }
+    return closestIndex;
+  }, -1);
+}
+
+const DEFAULT_CONTOUR_SEG_TOOLNAME = 'PlanarFreehandContourSegmentationTool';
+function createPolylineHole(viewport, targetAnnotation, holeAnnotation) {
+  const {
+    windingDirection: targetWindingDirection
+  } = targetAnnotation.data.contour;
+  const {
+    windingDirection: holeWindingDirection
+  } = holeAnnotation.data.contour;
+  if (targetWindingDirection === holeWindingDirection) {
+    holeAnnotation.data.contour.polyline.reverse();
+    holeAnnotation.data.contour.windingDirection = targetWindingDirection * -1;
+  }
+  addChildAnnotation(targetAnnotation, holeAnnotation);
+  removeContourSegmentationAnnotation(holeAnnotation);
+  const {
+    element
+  } = viewport;
+  const enabledElement = getEnabledElement(element);
+  const {
+    renderingEngine
+  } = enabledElement;
+  const updatedToolNames = new Set([DEFAULT_CONTOUR_SEG_TOOLNAME, targetAnnotation.metadata.toolName, holeAnnotation.metadata.toolName]);
+  for (const toolName of updatedToolNames.values()) {
+    const viewportIdsToRender = getViewportIdsWithToolToRender(element, toolName);
+    triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+  }
+}
+
 const {
   PointsManager
 } = utilities;
@@ -50142,7 +50583,10 @@ function interpolate(viewportData) {
   });
 }
 function startInterpolation(viewportData) {
-  const toolData = viewportData.annotation;
+  const {
+    annotation: toolData
+  } = viewportData;
+  updateChildInterpolationUID(toolData);
   const {
     interpolationData,
     interpolationList
@@ -50176,8 +50620,10 @@ function startInterpolation(viewportData) {
   }
 }
 function _linearlyInterpolateBetween(indices, annotationPair, interpolationData, eventData) {
-  const c1 = _generateClosedContour(interpolationData.get(annotationPair[0])[0].data.contour.polyline);
-  const c2 = _generateClosedContour(interpolationData.get(annotationPair[1])[0].data.contour.polyline);
+  const annotation0 = interpolationData.get(annotationPair[0])[0];
+  const annotation1 = interpolationData.get(annotationPair[1])[0];
+  const c1 = _generateClosedContour(annotation0.data.contour.polyline);
+  const c2 = _generateClosedContour(annotation1.data.contour.polyline);
   const {
     c1Interp,
     c2Interp
@@ -50191,8 +50637,10 @@ function _linearlyInterpolateBetween(indices, annotationPair, interpolationData,
 function _linearlyInterpolateContour(c1Interp, c2Interp, sliceIndex, annotationPair, interpolationData, c1HasMoreNodes, eventData) {
   const [startIndex, endIndex] = annotationPair;
   const zInterp = (sliceIndex - startIndex) / (endIndex - startIndex);
+  const annotation0 = interpolationData.get(startIndex)[0];
+  const annotation1 = interpolationData.get(endIndex)[0];
   const interpolated3DPoints = _generateInterpolatedOpenContour(c1Interp, c2Interp, zInterp, c1HasMoreNodes);
-  const nearestAnnotation = interpolationData.get(annotationPair[zInterp > 0.5 ? 1 : 0])[0];
+  const nearestAnnotation = zInterp > 0.5 ? annotation1 : annotation0;
   const handlePoints = selectHandles(interpolated3DPoints);
   if (interpolationData.has(sliceIndex)) {
     _editInterpolatedContour(interpolated3DPoints, handlePoints, sliceIndex, nearestAnnotation, eventData);
@@ -50213,30 +50661,35 @@ function _addInterpolatedContour(interpolated3DPoints, handlePoints, sliceIndex,
   interpolatedAnnotation.metadata.sliceIndex = sliceIndex;
   addAnnotation(interpolatedAnnotation, viewport.element);
   referencedToolData.onInterpolationComplete?.(interpolatedAnnotation, referencedToolData);
+  const {
+    parentAnnotationUID
+  } = referencedToolData;
+  if (parentAnnotationUID) {
+    const parentReferenced = getAnnotation(parentAnnotationUID);
+    const parentAnnotation = _findExistingAnnotation(parentReferenced, sliceIndex, eventData);
+    createPolylineHole(viewport, parentAnnotation, interpolatedAnnotation);
+  }
 }
-function _editInterpolatedContour(interpolated3DPoints, handlePoints, sliceIndex, referencedToolData, eventData) {
+function _findExistingAnnotation(referencedToolData, sliceIndex, eventData) {
   const {
     viewport
   } = eventData;
   const annotations = getAnnotations(referencedToolData.metadata.toolName, viewport.element);
-  let toolDataIndex;
   for (let i = 0; i < annotations.length; i++) {
     const annotation = annotations[i];
     if (annotation.interpolationUID === referencedToolData.interpolationUID && annotation.metadata.sliceIndex === sliceIndex) {
-      toolDataIndex = i;
-      break;
+      return annotation;
     }
   }
-  if (toolDataIndex === undefined) {
-    console.warn('Unable to find referenced slice index in the tool data', sliceIndex, annotations);
-    return;
-  }
-  const oldToolData = annotations[toolDataIndex];
+}
+function _editInterpolatedContour(interpolated3DPoints, handlePoints, sliceIndex, referencedToolData, eventData) {
+  const oldAnnotationData = _findExistingAnnotation(referencedToolData, sliceIndex, eventData);
   const points = interpolated3DPoints.points;
-  const interpolatedAnnotation = createPolylineToolData(points, handlePoints, oldToolData);
-  interpolatedAnnotation.annotationUID = oldToolData.annotationUID;
-  removeAnnotation(oldToolData.annotationUID);
-  addAnnotation(interpolatedAnnotation, viewport.element);
+  const interpolatedAnnotation = createPolylineToolData(points, handlePoints, oldAnnotationData);
+  Object.assign(oldAnnotationData, {
+    metadata: interpolatedAnnotation.metadata,
+    data: interpolatedAnnotation.data
+  });
 }
 function _generateInterpolatedOpenContour(c1ir, c2ir, zInterp, c1HasMoreNodes) {
   const indices = c1HasMoreNodes ? c1ir.I : c2ir.I;
@@ -50502,31 +50955,6 @@ function deleteRelatedAnnotations(viewportData) {
   }
 }
 
-function addContourSegmentationAnnotation(annotation) {
-  if (!annotation.data.segmentation) {
-    throw new Error('addContourSegmentationAnnotation: annotation does not have a segmentation data');
-  }
-  const {
-    segmentationId,
-    segmentIndex
-  } = annotation.data.segmentation;
-  const segmentation = getSegmentation(segmentationId);
-  if (!segmentation.representationData.CONTOUR) {
-    segmentation.representationData.CONTOUR = {
-      annotationUIDsMap: new Map()
-    };
-  }
-  const {
-    annotationUIDsMap
-  } = segmentation.representationData.CONTOUR;
-  let annotationsUIDsSet = annotationUIDsMap.get(segmentIndex);
-  if (!annotationsUIDsSet) {
-    annotationsUIDsSet = new Set();
-    annotationUIDsMap.set(segmentIndex, annotationsUIDsSet);
-  }
-  annotationUIDsMap.set(segmentIndex, annotationsUIDsSet.add(annotation.annotationUID));
-}
-
 const {
   uuidv4
 } = utilities;
@@ -50720,49 +51148,6 @@ function acceptAutogeneratedInterpolations(annotationGroupSelector, selector) {
   InterpolationManager.acceptAutoGenerated(annotationGroupSelector, selector);
 }
 
-var index$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  InterpolationManager: InterpolationManager
-});
-
-const {
-  isEqual
-} = utilities;
-function findHandlePolylineIndex(annotation, handleIndex) {
-  const {
-    polyline
-  } = annotation.data.contour;
-  const {
-    points
-  } = annotation.data.handles;
-  const {
-    length
-  } = points;
-  if (handleIndex === length) {
-    return polyline.length;
-  }
-  if (handleIndex < 0) {
-    handleIndex = (handleIndex + length) % length;
-  }
-  if (handleIndex === 0) {
-    return 0;
-  }
-  const handle = points[handleIndex];
-  const index = polyline.findIndex(point => isEqual(handle, point));
-  if (index !== -1) {
-    return index;
-  }
-  let closestDistance = Infinity;
-  return polyline.reduce((closestIndex, point, testIndex) => {
-    const distance = vec3.squaredDistance(point, handle);
-    if (distance < closestDistance) {
-      closestDistance = distance;
-      return testIndex;
-    }
-    return closestIndex;
-  }, -1);
-}
-
 var index = /*#__PURE__*/Object.freeze({
   __proto__: null,
   AnnotationToPointData: AnnotationToPointData$2,
@@ -50779,6 +51164,21 @@ var index = /*#__PURE__*/Object.freeze({
   updateContourPolyline: updateContourPolyline
 });
 
+function getToolGroupForViewport(viewportId, renderingEngineId) {
+  if (!renderingEngineId) {
+    renderingEngineId = getRenderingEngines().find(re => re.getViewports().find(vp => vp.id === viewportId))?.id;
+  }
+  const toolGroupFilteredByIds = state.toolGroups.filter(tg => tg.viewportsInfo.some(vp => vp.renderingEngineId === renderingEngineId && (!vp.viewportId || vp.viewportId === viewportId)));
+  if (!toolGroupFilteredByIds.length) {
+    return;
+  }
+  if (toolGroupFilteredByIds.length > 1) {
+    throw new Error(`Multiple tool groups found for renderingEngineId: ${renderingEngineId} and viewportId: ${viewportId}. You should only
+      have one tool group per viewport in a renderingEngine.`);
+  }
+  return toolGroupFilteredByIds[0];
+}
+
 const MODES = [ToolModes$1.Active, ToolModes$1.Passive, ToolModes$1.Enabled];
 function getToolGroupsWithToolName(toolName) {
   return state.toolGroups.filter(({
@@ -50864,6 +51264,36 @@ function getAnnotations(toolName, annotationGroupSelector) {
   const groupKey = manager.getGroupKey(annotationGroupSelector);
   return manager.getAnnotations(groupKey, toolName);
 }
+function clearParentAnnotation(annotation) {
+  const {
+    annotationUID: childUID,
+    parentAnnotationUID
+  } = annotation;
+  if (!parentAnnotationUID) {
+    return;
+  }
+  const parentAnnotation = getAnnotation(parentAnnotationUID);
+  const childUIDIndex = parentAnnotation.childAnnotationUIDs.indexOf(childUID);
+  parentAnnotation.childAnnotationUIDs.splice(childUIDIndex, 1);
+  annotation.parentAnnotationUID = undefined;
+}
+function addChildAnnotation(parentAnnotation, childAnnotation) {
+  const {
+    annotationUID: parentUID
+  } = parentAnnotation;
+  const {
+    annotationUID: childUID
+  } = childAnnotation;
+  clearParentAnnotation(childAnnotation);
+  if (!parentAnnotation.childAnnotationUIDs) {
+    parentAnnotation.childAnnotationUIDs = [];
+  }
+  if (parentAnnotation.childAnnotationUIDs.includes(childUID)) {
+    return;
+  }
+  parentAnnotation.childAnnotationUIDs.push(childUID);
+  childAnnotation.parentAnnotationUID = parentUID;
+}
 function getParentAnnotation(annotation) {
   return annotation.parentAnnotationUID ? getAnnotation(annotation.parentAnnotationUID) : undefined;
 }