@cornerstonejs/tools 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/esm/tools/annotation/planarFreehandROITool/drawLoop.js

@@ -1,14 +1,17 @@
-import { getEnabledElement } from '@cornerstonejs/core';
+import { getEnabledElement, utilities } from '@cornerstonejs/core';
 import { resetElementCursor, hideElementCursor, } from '../../../cursors/elementCursor';
 import { Events } from '../../../enums';
 import { state } from '../../../store';
 import { vec3 } from 'gl-matrix';
-import { shouldInterpolate, getInterpolatedPoints, } from '../../../utilities/planarFreehandROITool/interpolatePoints';
+import { shouldSmooth, getInterpolatedPoints, } from '../../../utilities/planarFreehandROITool/smoothPoints';
+import getMouseModifierKey from '../../../eventDispatchers/shared/getMouseModifier';
 import triggerAnnotationRenderForViewportIds from '../../../utilities/triggerAnnotationRenderForViewportIds';
+import { triggerContourAnnotationCompleted } from '../../../stateManagement/annotation/helpers/state';
 import findOpenUShapedContourVectorToPeak from './findOpenUShapedContourVectorToPeak';
 import { polyline } from '../../../utilities/math';
 import { removeAnnotation } from '../../../stateManagement/annotation/annotationState';
-const { addCanvasPointsToArray, pointsAreWithinCloseContourProximity, getFirstIntersectionWithPolyline, getSubPixelSpacingAndXYDirections, } = polyline;
+import { ContourWindingDirection } from '../../../types/ContourAnnotation';
+const { addCanvasPointsToArray, pointsAreWithinCloseContourProximity, getFirstLineSegmentIntersectionIndexes, getSubPixelSpacingAndXYDirections, } = polyline;
 function activateDraw(evt, annotation, viewportIdsToRender) {
     this.isDrawing = true;
     const eventDetail = evt.detail;
@@ -16,10 +19,13 @@ function activateDraw(evt, annotation, viewportIdsToRender) {
     const canvasPos = currentPoints.canvas;
     const enabledElement = getEnabledElement(element);
     const { viewport } = enabledElement;
+    const contourHoleProcessingEnabled = getMouseModifierKey(evt.detail.event) ===
+        this.configuration.contourHoleAdditionModifierKey;
     const { spacing, xDir, yDir } = getSubPixelSpacingAndXYDirections(viewport, this.configuration.subPixelResolution);
     this.drawData = {
         canvasPoints: [canvasPos],
         polylineIndex: 0,
+        contourHoleProcessingEnabled,
     };
     this.commonData = {
         annotation,
@@ -87,26 +93,30 @@ function mouseDragDrawCallback(evt) {
             this.drawData.polylineIndex = polylineIndex + numPointsAdded;
         }
     }
-    triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+    triggerAnnotationRenderForViewportIds(viewportIdsToRender);
 }
 function mouseUpDrawCallback(evt) {
     const { allowOpenContours } = this.configuration;
-    const { canvasPoints } = this.drawData;
+    const { canvasPoints, contourHoleProcessingEnabled } = this.drawData;
     const firstPoint = canvasPoints[0];
     const lastPoint = canvasPoints[canvasPoints.length - 1];
     const eventDetail = evt.detail;
     const { element } = eventDetail;
     if (allowOpenContours &&
         !pointsAreWithinCloseContourProximity(firstPoint, lastPoint, this.configuration.closeContourProximity)) {
-        this.completeDrawOpenContour(element);
+        this.completeDrawOpenContour(element, { contourHoleProcessingEnabled });
     }
     else {
-        this.completeDrawClosedContour(element);
+        this.completeDrawClosedContour(element, { contourHoleProcessingEnabled });
     }
 }
-function completeDrawClosedContour(element) {
+function completeDrawClosedContour(element, options) {
     this.removeCrossedLinesOnCompleteDraw();
     const { canvasPoints } = this.drawData;
+    const { contourHoleProcessingEnabled, minPointsToSave } = options ?? {};
+    if (minPointsToSave && canvasPoints.length < minPointsToSave) {
+        return false;
+    }
     if (this.haltDrawing(element, canvasPoints)) {
         return false;
     }
@@ -115,20 +125,22 @@ function completeDrawClosedContour(element) {
     const { viewport, renderingEngine } = enabledElement;
     addCanvasPointsToArray(element, canvasPoints, canvasPoints[0], this.commonData);
     canvasPoints.pop();
-    const updatedPoints = shouldInterpolate(this.configuration)
+    const updatedPoints = shouldSmooth(this.configuration, annotation)
         ? getInterpolatedPoints(this.configuration, canvasPoints)
         : canvasPoints;
-    const worldPoints = updatedPoints.map((canvasPoint) => viewport.canvasToWorld(canvasPoint));
-    annotation.data.polyline = worldPoints;
-    annotation.data.isOpenContour = false;
+    this.updateContourPolyline(annotation, {
+        points: updatedPoints,
+        closed: true,
+        targetWindingDirection: ContourWindingDirection.Clockwise,
+    }, viewport);
     const { textBox } = annotation.data.handles;
-    if (!textBox.hasMoved) {
-        this.triggerAnnotationCompleted(annotation);
+    if (!textBox?.hasMoved) {
+        triggerContourAnnotationCompleted(annotation, contourHoleProcessingEnabled);
     }
     this.isDrawing = false;
     this.drawData = undefined;
     this.commonData = undefined;
-    triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+    triggerAnnotationRenderForViewportIds(viewportIdsToRender);
     this.deactivateDraw(element);
     return true;
 }
@@ -137,27 +149,35 @@ function removeCrossedLinesOnCompleteDraw() {
     const numPoints = canvasPoints.length;
     const endToStart = [canvasPoints[0], canvasPoints[numPoints - 1]];
     const canvasPointsMinusEnds = canvasPoints.slice(0, -1).slice(1);
-    const lineSegment = getFirstIntersectionWithPolyline(canvasPointsMinusEnds, endToStart[0], endToStart[1], false);
+    const lineSegment = getFirstLineSegmentIntersectionIndexes(canvasPointsMinusEnds, endToStart[0], endToStart[1], false);
     if (lineSegment) {
         const indexToRemoveUpTo = lineSegment[1];
-        this.drawData.canvasPoints = canvasPoints.splice(0, indexToRemoveUpTo);
+        if (indexToRemoveUpTo === 1) {
+            this.drawData.canvasPoints = canvasPoints.splice(1);
+        }
+        else {
+            this.drawData.canvasPoints = canvasPoints.splice(0, indexToRemoveUpTo);
+        }
     }
 }
-function completeDrawOpenContour(element) {
+function completeDrawOpenContour(element, options) {
     const { canvasPoints } = this.drawData;
+    const { contourHoleProcessingEnabled } = options ?? {};
     if (this.haltDrawing(element, canvasPoints)) {
         return false;
     }
     const { annotation, viewportIdsToRender } = this.commonData;
     const enabledElement = getEnabledElement(element);
     const { viewport, renderingEngine } = enabledElement;
-    const updatedPoints = shouldInterpolate(this.configuration)
+    const updatedPoints = shouldSmooth(this.configuration, annotation)
         ? getInterpolatedPoints(this.configuration, canvasPoints)
         : canvasPoints;
-    const worldPoints = updatedPoints.map((canvasPoint) => viewport.canvasToWorld(canvasPoint));
-    annotation.data.polyline = worldPoints;
-    annotation.data.isOpenContour = true;
+    this.updateContourPolyline(annotation, {
+        points: updatedPoints,
+        closed: false,
+    }, viewport);
     const { textBox } = annotation.data.handles;
+    const worldPoints = annotation.data.contour.polyline;
     annotation.data.handles.points = [
         worldPoints[0],
         worldPoints[worldPoints.length - 1],
@@ -167,12 +187,12 @@ function completeDrawOpenContour(element) {
             findOpenUShapedContourVectorToPeak(canvasPoints, viewport);
     }
     if (!textBox.hasMoved) {
-        this.triggerAnnotationCompleted(annotation);
+        triggerContourAnnotationCompleted(annotation, contourHoleProcessingEnabled);
     }
     this.isDrawing = false;
     this.drawData = undefined;
     this.commonData = undefined;
-    triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+    triggerAnnotationRenderForViewportIds(viewportIdsToRender);
     this.deactivateDraw(element);
     return true;
 }
@@ -183,7 +203,7 @@ function findCrossingIndexDuringCreate(evt) {
     const lastCanvasPoint = lastPoints.canvas;
     const { canvasPoints } = this.drawData;
     const pointsLessLastOne = canvasPoints.slice(0, -1);
-    const lineSegment = getFirstIntersectionWithPolyline(pointsLessLastOne, canvasPos, lastCanvasPoint, false);
+    const lineSegment = getFirstLineSegmentIntersectionIndexes(pointsLessLastOne, canvasPos, lastCanvasPoint, false);
     if (lineSegment === undefined) {
         return;
     }
@@ -193,28 +213,33 @@ function findCrossingIndexDuringCreate(evt) {
 function applyCreateOnCross(evt, crossingIndex) {
     const eventDetail = evt.detail;
     const { element } = eventDetail;
-    const { canvasPoints } = this.drawData;
+    const { canvasPoints, contourHoleProcessingEnabled } = this.drawData;
     const { annotation, viewportIdsToRender } = this.commonData;
     addCanvasPointsToArray(element, canvasPoints, canvasPoints[crossingIndex], this.commonData);
     canvasPoints.pop();
-    for (let i = 0; i < crossingIndex; i++) {
-        canvasPoints.shift();
+    const remainingPoints = canvasPoints.slice(crossingIndex);
+    const newArea = polyline.getArea(remainingPoints);
+    if (utilities.isEqual(newArea, 0)) {
+        canvasPoints.splice(crossingIndex + 1);
+        return;
     }
-    if (this.completeDrawClosedContour(element)) {
+    canvasPoints.splice(0, crossingIndex);
+    const options = { contourHoleProcessingEnabled, minPointsToSave: 3 };
+    if (this.completeDrawClosedContour(element, options)) {
         this.activateClosedContourEdit(evt, annotation, viewportIdsToRender);
     }
 }
 function cancelDrawing(element) {
     const { allowOpenContours } = this.configuration;
-    const { canvasPoints } = this.drawData;
+    const { canvasPoints, contourHoleProcessingEnabled } = this.drawData;
     const firstPoint = canvasPoints[0];
     const lastPoint = canvasPoints[canvasPoints.length - 1];
     if (allowOpenContours &&
         !pointsAreWithinCloseContourProximity(firstPoint, lastPoint, this.configuration.closeContourProximity)) {
-        this.completeDrawOpenContour(element);
+        this.completeDrawOpenContour(element, { contourHoleProcessingEnabled });
     }
     else {
-        this.completeDrawClosedContour(element);
+        this.completeDrawClosedContour(element, { contourHoleProcessingEnabled });
     }
 }
 function shouldHaltDrawing(canvasPoints, subPixelResolution) {
@@ -231,7 +256,7 @@ function haltDrawing(element, canvasPoints) {
         this.isDrawing = false;
         this.drawData = undefined;
         this.commonData = undefined;
-        triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+        triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         this.deactivateDraw(element);
         return true;
     }
@@ -255,4 +280,3 @@ function registerDrawLoop(toolInstance) {
     toolInstance.haltDrawing = haltDrawing.bind(toolInstance);
 }
 export default registerDrawLoop;
-//# sourceMappingURL=drawLoop.js.map

package/dist/esm/tools/annotation/planarFreehandROITool/editLoopCommon.js

@@ -1,13 +1,13 @@
 import { vec2 } from 'gl-matrix';
 import { polyline } from '../../../utilities/math';
-const { addCanvasPointsToArray, getFirstIntersectionWithPolyline } = polyline;
+const { addCanvasPointsToArray, getFirstLineSegmentIntersectionIndexes } = polyline;
 function checkForFirstCrossing(evt, isClosedContour) {
     const eventDetail = evt.detail;
     const { element, currentPoints, lastPoints } = eventDetail;
     const canvasPos = currentPoints.canvas;
     const lastCanvasPoint = lastPoints.canvas;
     const { editCanvasPoints, prevCanvasPoints } = this.editData;
-    const crossedLineSegment = getFirstIntersectionWithPolyline(prevCanvasPoints, canvasPos, lastCanvasPoint, isClosedContour);
+    const crossedLineSegment = getFirstLineSegmentIntersectionIndexes(prevCanvasPoints, canvasPos, lastCanvasPoint, isClosedContour);
     if (crossedLineSegment) {
         this.editData.startCrossingIndex = crossedLineSegment[0];
         this.removePointsUpUntilFirstCrossing(isClosedContour);
@@ -39,7 +39,7 @@ function checkForFirstCrossing(evt, isClosedContour) {
                 editCanvasPoints[0][0] - dir[0] * proximity,
                 editCanvasPoints[0][1] - dir[1] * proximity,
             ];
-            const crossedLineSegmentFromExtendedPoint = getFirstIntersectionWithPolyline(prevCanvasPoints, extendedPoint, editCanvasPoints[0], isClosedContour);
+            const crossedLineSegmentFromExtendedPoint = getFirstLineSegmentIntersectionIndexes(prevCanvasPoints, extendedPoint, editCanvasPoints[0], isClosedContour);
             if (crossedLineSegmentFromExtendedPoint) {
                 const pointsToPrepend = [extendedPoint];
                 addCanvasPointsToArray(element, pointsToPrepend, editCanvasPoints[0], this.commonData);
@@ -57,7 +57,7 @@ function removePointsUpUntilFirstCrossing(isClosedContour) {
     let numPointsToRemove = 0;
     for (let i = 0; i < editCanvasPoints.length - 1; i++) {
         const firstLine = [editCanvasPoints[i], editCanvasPoints[i + 1]];
-        const didCrossLine = !!getFirstIntersectionWithPolyline(prevCanvasPoints, firstLine[0], firstLine[1], isClosedContour);
+        const didCrossLine = !!getFirstLineSegmentIntersectionIndexes(prevCanvasPoints, firstLine[0], firstLine[1], isClosedContour);
         numPointsToRemove++;
         if (didCrossLine) {
             break;
@@ -72,7 +72,7 @@ function checkForSecondCrossing(evt, isClosedContour) {
     const canvasPos = currentPoints.canvas;
     const lastCanvasPoint = lastPoints.canvas;
     const { prevCanvasPoints } = this.editData;
-    const crossedLineSegment = getFirstIntersectionWithPolyline(prevCanvasPoints, canvasPos, lastCanvasPoint, isClosedContour);
+    const crossedLineSegment = getFirstLineSegmentIntersectionIndexes(prevCanvasPoints, canvasPos, lastCanvasPoint, isClosedContour);
     if (!crossedLineSegment) {
         return false;
     }
@@ -82,7 +82,7 @@ function removePointsAfterSecondCrossing(isClosedContour) {
     const { prevCanvasPoints, editCanvasPoints } = this.editData;
     for (let i = editCanvasPoints.length - 1; i > 0; i--) {
         const lastLine = [editCanvasPoints[i], editCanvasPoints[i - 1]];
-        const didCrossLine = !!getFirstIntersectionWithPolyline(prevCanvasPoints, lastLine[0], lastLine[1], isClosedContour);
+        const didCrossLine = !!getFirstLineSegmentIntersectionIndexes(prevCanvasPoints, lastLine[0], lastLine[1], isClosedContour);
         editCanvasPoints.pop();
         if (didCrossLine) {
             break;
@@ -107,7 +107,7 @@ function findSnapIndex() {
         const { index } = distanceIndexPairs[i];
         const snapCanvasPosition = prevCanvasPoints[index];
         const lastEditCanvasPoint = editCanvasPoints[editCanvasPoints.length - 1];
-        const crossedLineSegment = getFirstIntersectionWithPolyline(editCanvasPointsLessLastOne, snapCanvasPosition, lastEditCanvasPoint, false);
+        const crossedLineSegment = getFirstLineSegmentIntersectionIndexes(editCanvasPointsLessLastOne, snapCanvasPosition, lastEditCanvasPoint, false);
         if (!crossedLineSegment) {
             return index;
         }
@@ -121,7 +121,7 @@ function checkAndRemoveCrossesOnEditLine(evt) {
     const lastCanvasPoint = lastPoints.canvas;
     const { editCanvasPoints } = this.editData;
     const editCanvasPointsLessLastOne = editCanvasPoints.slice(0, -2);
-    const crossedLineSegment = getFirstIntersectionWithPolyline(editCanvasPointsLessLastOne, canvasPos, lastCanvasPoint, false);
+    const crossedLineSegment = getFirstLineSegmentIntersectionIndexes(editCanvasPointsLessLastOne, canvasPos, lastCanvasPoint, false);
     if (!crossedLineSegment) {
         return;
     }
@@ -144,4 +144,3 @@ function registerEditLoopCommon(toolInstance) {
         checkAndRemoveCrossesOnEditLine.bind(toolInstance);
 }
 export default registerEditLoopCommon;
-//# sourceMappingURL=editLoopCommon.js.map

package/dist/esm/tools/annotation/planarFreehandROITool/findOpenUShapedContourVectorToPeak.d.ts

@@ -1,4 +1,4 @@
 import type { Types } from '@cornerstonejs/core';
-import { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
+import type { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
 export default function findOpenUShapedContourVectorToPeak(canvasPoints: Types.Point2[], viewport: Types.IStackViewport | Types.IVolumeViewport): Types.Point3[];
 export declare function findOpenUShapedContourVectorToPeakOnRender(enabledElement: Types.IEnabledElement, annotation: PlanarFreehandROIAnnotation): Types.Point3[];

package/dist/esm/tools/annotation/planarFreehandROITool/findOpenUShapedContourVectorToPeak.js

@@ -34,7 +34,6 @@ export default function findOpenUShapedContourVectorToPeak(canvasPoints, viewpor
 }
 export function findOpenUShapedContourVectorToPeakOnRender(enabledElement, annotation) {
     const { viewport } = enabledElement;
-    const canvasPoints = annotation.data.polyline.map(viewport.worldToCanvas);
+    const canvasPoints = annotation.data.contour.polyline.map(viewport.worldToCanvas);
     return findOpenUShapedContourVectorToPeak(canvasPoints, viewport);
 }
-//# sourceMappingURL=findOpenUShapedContourVectorToPeak.js.map

package/dist/esm/tools/annotation/planarFreehandROITool/openContourEditLoop.js

@@ -1,12 +1,14 @@
+import { vec3, vec2 } from 'gl-matrix';
 import { getEnabledElement } from '@cornerstonejs/core';
 import { state } from '../../../store';
 import { Events } from '../../../enums';
 import { resetElementCursor, hideElementCursor, } from '../../../cursors/elementCursor';
-import { vec3, vec2 } from 'gl-matrix';
 import { polyline } from '../../../utilities/math';
-import { shouldInterpolate, getInterpolatedPoints, } from '../../../utilities/planarFreehandROITool/interpolatePoints';
+import { shouldSmooth, getInterpolatedPoints, } from '../../../utilities/planarFreehandROITool/smoothPoints';
 import triggerAnnotationRenderForViewportIds from '../../../utilities/triggerAnnotationRenderForViewportIds';
+import { updateContourPolyline } from '../../../utilities/contours';
 import findOpenUShapedContourVectorToPeak from './findOpenUShapedContourVectorToPeak';
+import { triggerAnnotationModified } from '../../../stateManagement/annotation/helpers/state';
 const { addCanvasPointsToArray, getSubPixelSpacingAndXYDirections } = polyline;
 function activateOpenContourEdit(evt, annotation, viewportIdsToRender) {
     this.isEditingOpen = true;
@@ -15,7 +17,7 @@ function activateOpenContourEdit(evt, annotation, viewportIdsToRender) {
     const canvasPos = currentPoints.canvas;
     const enabledElement = getEnabledElement(element);
     const { viewport } = enabledElement;
-    const prevCanvasPoints = annotation.data.polyline.map(viewport.worldToCanvas);
+    const prevCanvasPoints = annotation.data.contour.polyline.map(viewport.worldToCanvas);
     const { spacing, xDir, yDir } = getSubPixelSpacingAndXYDirections(viewport, this.configuration.subPixelResolution);
     this.editData = {
         prevCanvasPoints,
@@ -87,7 +89,7 @@ function mouseDragOpenContourEditCallback(evt) {
     else if (this.checkIfShouldOverwriteAnEnd(evt)) {
         this.openContourEditOverwriteEnd(evt);
     }
-    triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+    triggerAnnotationRenderForViewportIds(viewportIdsToRender);
 }
 function openContourEditOverwriteEnd(evt) {
     const eventDetail = evt.detail;
@@ -96,15 +98,17 @@ function openContourEditOverwriteEnd(evt) {
     const { viewport } = enabledElement;
     const { annotation, viewportIdsToRender } = this.commonData;
     const fusedCanvasPoints = this.fuseEditPointsForOpenContourEndEdit();
-    const worldPoints = fusedCanvasPoints.map((canvasPoint) => viewport.canvasToWorld(canvasPoint));
-    annotation.data.polyline = worldPoints;
-    annotation.data.isOpenContour = true;
+    updateContourPolyline(annotation, {
+        points: fusedCanvasPoints,
+        closed: false,
+    }, viewport);
+    const worldPoints = annotation.data.contour.polyline;
     annotation.data.handles.points = [
         worldPoints[0],
         worldPoints[worldPoints.length - 1],
     ];
     annotation.data.handles.activeHandleIndex = 1;
-    this.triggerAnnotationModified(annotation, enabledElement);
+    triggerAnnotationModified(annotation, element);
     this.isEditingOpen = false;
     this.editData = undefined;
     this.commonData = undefined;
@@ -232,14 +236,16 @@ function finishEditOpenOnSecondCrossing(evt) {
     const { viewport, renderingEngine } = enabledElement;
     const { annotation, viewportIdsToRender } = this.commonData;
     const { fusedCanvasPoints, editCanvasPoints } = this.editData;
-    const worldPoints = fusedCanvasPoints.map((canvasPoint) => viewport.canvasToWorld(canvasPoint));
-    annotation.data.polyline = worldPoints;
-    annotation.data.isOpenContour = true;
+    updateContourPolyline(annotation, {
+        points: fusedCanvasPoints,
+        closed: false,
+    }, viewport);
+    const worldPoints = annotation.data.contour.polyline;
     annotation.data.handles.points = [
         worldPoints[0],
         worldPoints[worldPoints.length - 1],
     ];
-    this.triggerAnnotationModified(annotation, enabledElement);
+    triggerAnnotationModified(annotation, element);
     const lastEditCanvasPoint = editCanvasPoints.pop();
     this.editData = {
         prevCanvasPoints: fusedCanvasPoints,
@@ -247,7 +253,7 @@ function finishEditOpenOnSecondCrossing(evt) {
         startCrossingIndex: undefined,
         editIndex: 0,
     };
-    triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+    triggerAnnotationRenderForViewportIds(viewportIdsToRender);
 }
 function mouseUpOpenContourEditCallback(evt) {
     const eventDetail = evt.detail;
@@ -260,12 +266,20 @@ function completeOpenContourEdit(element) {
     const { annotation, viewportIdsToRender } = this.commonData;
     const { fusedCanvasPoints, prevCanvasPoints } = this.editData;
     if (fusedCanvasPoints) {
-        const updatedPoints = shouldInterpolate(this.configuration)
+        const updatedPoints = shouldSmooth(this.configuration)
             ? getInterpolatedPoints(this.configuration, fusedCanvasPoints, prevCanvasPoints)
             : fusedCanvasPoints;
-        const worldPoints = updatedPoints.map((canvasPoint) => viewport.canvasToWorld(canvasPoint));
-        annotation.data.polyline = worldPoints;
-        annotation.data.isOpenContour = true;
+        const decimateConfig = this.configuration?.decimate || {};
+        updateContourPolyline(annotation, {
+            points: updatedPoints,
+            closed: false,
+        }, viewport, {
+            decimate: {
+                enabled: !!decimateConfig.enabled,
+                epsilon: decimateConfig.epsilon,
+            },
+        });
+        const worldPoints = annotation.data.contour.polyline;
         annotation.data.handles.points = [
             worldPoints[0],
             worldPoints[worldPoints.length - 1],
@@ -274,13 +288,12 @@ function completeOpenContourEdit(element) {
             annotation.data.openUShapeContourVectorToPeak =
                 findOpenUShapedContourVectorToPeak(fusedCanvasPoints, viewport);
         }
-        annotation.invalidated = true;
-        this.triggerAnnotationModified(annotation, enabledElement);
+        triggerAnnotationModified(annotation, element);
     }
     this.isEditingOpen = false;
     this.editData = undefined;
     this.commonData = undefined;
-    triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+    triggerAnnotationRenderForViewportIds(viewportIdsToRender);
     this.deactivateOpenContourEdit(element);
 }
 function cancelOpenContourEdit(element) {
@@ -310,4 +323,3 @@ function registerOpenContourEditLoop(toolInstance) {
         completeOpenContourEdit.bind(toolInstance);
 }
 export default registerOpenContourEditLoop;
-//# sourceMappingURL=openContourEditLoop.js.map

package/dist/esm/tools/annotation/planarFreehandROITool/openContourEndEditLoop.js

@@ -11,13 +11,13 @@ function activateOpenContourEndEdit(evt, annotation, viewportIdsToRender, handle
     const enabledElement = getEnabledElement(element);
     const { viewport } = enabledElement;
     const { spacing, xDir, yDir } = getSubPixelSpacingAndXYDirections(viewport, this.configuration.subPixelResolution);
-    const canvasPoints = annotation.data.polyline.map(viewport.worldToCanvas);
+    const canvasPoints = annotation.data.contour.polyline.map(viewport.worldToCanvas);
     const handleIndexGrabbed = annotation.data.handles.activeHandleIndex;
     if (handleIndexGrabbed === 0) {
         canvasPoints.reverse();
     }
     let movingTextBox = false;
-    if (handle.worldPosition) {
+    if (handle?.worldPosition) {
         movingTextBox = true;
     }
     this.drawData = {
@@ -46,4 +46,3 @@ function registerOpenContourEndEditLoop(toolInstance) {
         activateOpenContourEndEdit.bind(toolInstance);
 }
 export default registerOpenContourEndEditLoop;
-//# sourceMappingURL=openContourEndEditLoop.js.map

package/dist/esm/tools/annotation/planarFreehandROITool/renderMethods.js

@@ -1,6 +1,7 @@
-import { drawHandles as drawHandlesSvg, drawPolyline as drawPolylineSvg, } from '../../../drawingSvg';
+import { drawHandles as drawHandlesSvg, drawPolyline as drawPolylineSvg, drawPath as drawPathSvg, } from '../../../drawingSvg';
 import { polyline } from '../../../utilities/math';
 import { findOpenUShapedContourVectorToPeakOnRender } from './findOpenUShapedContourVectorToPeak';
+import { getContourHolesDataCanvas } from '../../../utilities/contours';
 const { pointsAreWithinCloseContourProximity } = polyline;
 function _getRenderingOptions(enabledElement, annotation) {
     const styleSpecifier = {
@@ -9,15 +10,18 @@ function _getRenderingOptions(enabledElement, annotation) {
         viewportId: enabledElement.viewport.id,
         annotationUID: annotation.annotationUID,
     };
-    const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
-    const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
-    const color = this.getStyle('color', styleSpecifier, annotation);
-    const isOpenContour = annotation.data.isOpenContour;
+    const { lineWidth, lineDash, color, fillColor, fillOpacity } = this.getAnnotationStyle({
+        annotation,
+        styleSpecifier,
+    });
+    const { closed: isClosedContour } = annotation.data.contour;
     const options = {
-        color: color === undefined ? undefined : color,
-        width: lineWidth === undefined ? undefined : lineWidth,
-        lineDash: lineDash === undefined ? undefined : lineDash,
-        connectLastToFirst: !isOpenContour,
+        color,
+        width: lineWidth,
+        lineDash,
+        fillColor,
+        fillOpacity,
+        closePath: isClosedContour,
     };
     return options;
 }
@@ -25,7 +29,10 @@ function renderContour(enabledElement, svgDrawingHelper, annotation) {
     if (!enabledElement?.viewport?.getImageData()) {
         return;
     }
-    if (annotation.data.isOpenContour) {
+    if (annotation.data.contour.closed) {
+        this.renderClosedContour(enabledElement, svgDrawingHelper, annotation);
+    }
+    else {
         if (annotation.data.isOpenUShapeContour) {
             calculateUShapeContourVectorToPeakIfNotPresent(enabledElement, annotation);
             this.renderOpenUShapedContour(enabledElement, svgDrawingHelper, annotation);
@@ -34,9 +41,6 @@ function renderContour(enabledElement, svgDrawingHelper, annotation) {
             this.renderOpenContour(enabledElement, svgDrawingHelper, annotation);
         }
     }
-    else {
-        this.renderClosedContour(enabledElement, svgDrawingHelper, annotation);
-    }
 }
 function calculateUShapeContourVectorToPeakIfNotPresent(enabledElement, annotation) {
     if (!annotation.data.openUShapeContourVectorToPeak) {
@@ -45,16 +49,21 @@ function calculateUShapeContourVectorToPeakIfNotPresent(enabledElement, annotati
     }
 }
 function renderClosedContour(enabledElement, svgDrawingHelper, annotation) {
+    if (annotation.parentAnnotationUID) {
+        return;
+    }
     const { viewport } = enabledElement;
     const options = this._getRenderingOptions(enabledElement, annotation);
-    const canvasPoints = annotation.data.polyline.map((worldPos) => viewport.worldToCanvas(worldPos));
+    const canvasPolyline = annotation.data.contour.polyline.map((worldPos) => viewport.worldToCanvas(worldPos));
+    const childContours = getContourHolesDataCanvas(annotation, viewport);
+    const allContours = [canvasPolyline, ...childContours];
     const polylineUID = '1';
-    drawPolylineSvg(svgDrawingHelper, annotation.annotationUID, polylineUID, canvasPoints, options);
+    drawPathSvg(svgDrawingHelper, annotation.annotationUID, polylineUID, allContours, options);
 }
 function renderOpenContour(enabledElement, svgDrawingHelper, annotation) {
     const { viewport } = enabledElement;
     const options = this._getRenderingOptions(enabledElement, annotation);
-    const canvasPoints = annotation.data.polyline.map((worldPos) => viewport.worldToCanvas(worldPos));
+    const canvasPoints = annotation.data.contour.polyline.map((worldPos) => viewport.worldToCanvas(worldPos));
     const polylineUID = '1';
     drawPolylineSvg(svgDrawingHelper, annotation.annotationUID, polylineUID, canvasPoints, options);
     const activeHandleIndex = annotation.data.handles.activeHandleIndex;
@@ -85,7 +94,8 @@ function renderOpenContour(enabledElement, svgDrawingHelper, annotation) {
 }
 function renderOpenUShapedContour(enabledElement, svgDrawingHelper, annotation) {
     const { viewport } = enabledElement;
-    const { polyline, openUShapeContourVectorToPeak } = annotation.data;
+    const { openUShapeContourVectorToPeak } = annotation.data;
+    const { polyline } = annotation.data.contour;
     this.renderOpenContour(enabledElement, svgDrawingHelper, annotation);
     if (!openUShapeContourVectorToPeak) {
         return;
@@ -100,7 +110,7 @@ function renderOpenUShapedContour(enabledElement, svgDrawingHelper, annotation)
     drawPolylineSvg(svgDrawingHelper, annotation.annotationUID, 'first-to-last', [firstCanvasPoint, lastCanvasPoint], {
         color: options.color,
         width: options.width,
-        connectLastToFirst: false,
+        closePath: false,
         lineDash: '2,2',
     });
     drawPolylineSvg(svgDrawingHelper, annotation.annotationUID, 'midpoint-to-open-contour', [
@@ -109,7 +119,7 @@ function renderOpenUShapedContour(enabledElement, svgDrawingHelper, annotation)
     ], {
         color: options.color,
         width: options.width,
-        connectLastToFirst: false,
+        closePath: false,
         lineDash: '2,2',
     });
 }
@@ -117,7 +127,7 @@ function renderContourBeingDrawn(enabledElement, svgDrawingHelper, annotation) {
     const options = this._getRenderingOptions(enabledElement, annotation);
     const { allowOpenContours } = this.configuration;
     const { canvasPoints } = this.drawData;
-    options.connectLastToFirst = false;
+    options.closePath = false;
     drawPolylineSvg(svgDrawingHelper, annotation.annotationUID, '1', canvasPoints, options);
     if (allowOpenContours) {
         const firstPoint = canvasPoints[0];
@@ -132,14 +142,20 @@ function renderContourBeingDrawn(enabledElement, svgDrawingHelper, annotation) {
     }
 }
 function renderClosedContourBeingEdited(enabledElement, svgDrawingHelper, annotation) {
+    const { viewport } = enabledElement;
     const { fusedCanvasPoints } = this.editData;
     if (fusedCanvasPoints === undefined) {
         this.renderClosedContour(enabledElement, svgDrawingHelper, annotation);
         return;
     }
+    const childContours = getContourHolesDataCanvas(annotation, viewport);
+    const allContours = [fusedCanvasPoints, ...childContours];
     const options = this._getRenderingOptions(enabledElement, annotation);
     const polylineUIDToRender = 'preview-1';
-    drawPolylineSvg(svgDrawingHelper, annotation.annotationUID, polylineUIDToRender, fusedCanvasPoints, options);
+    if (annotation.parentAnnotationUID && options.fillOpacity) {
+        options.fillOpacity = 0;
+    }
+    drawPathSvg(svgDrawingHelper, annotation.annotationUID, polylineUIDToRender, allContours, options);
 }
 function renderOpenContourBeingEdited(enabledElement, svgDrawingHelper, annotation) {
     const { fusedCanvasPoints } = this.editData;
@@ -151,10 +167,42 @@ function renderOpenContourBeingEdited(enabledElement, svgDrawingHelper, annotati
     const polylineUIDToRender = 'preview-1';
     drawPolylineSvg(svgDrawingHelper, annotation.annotationUID, polylineUIDToRender, fusedCanvasPoints, options);
 }
+function renderPointContourWithMarker(enabledElement, svgDrawingHelper, annotation) {
+    if (annotation.parentAnnotationUID) {
+        return;
+    }
+    const { viewport } = enabledElement;
+    const options = this._getRenderingOptions(enabledElement, annotation);
+    const canvasPolyline = annotation.data.contour.polyline.map((worldPos) => viewport.worldToCanvas(worldPos));
+    const childContours = getContourHolesDataCanvas(annotation, viewport);
+    const polylineUID = '1';
+    const center = canvasPolyline[0];
+    const radius = 6;
+    const numberOfPoints = 100;
+    const circlePoints = [];
+    for (let i = 0; i < numberOfPoints; i++) {
+        const angle = (i / numberOfPoints) * 2 * Math.PI;
+        const x = center[0] + radius * Math.cos(angle);
+        const y = center[1] + radius * Math.sin(angle);
+        circlePoints.push([x, y]);
+    }
+    const crosshair = [
+        [center[0] - radius * 2, center[1]],
+        [center[0] + radius * 2, center[1]],
+        [center[0], center[1] - radius * 2],
+        [center[0], center[1] + radius * 2],
+    ];
+    drawPathSvg(svgDrawingHelper, annotation.annotationUID, polylineUID + '-crosshair_v', [crosshair[0], crosshair[1]], options);
+    drawPathSvg(svgDrawingHelper, annotation.annotationUID, polylineUID + '-crosshair_h', [crosshair[2], crosshair[3]], options);
+    const allContours = [circlePoints, ...childContours];
+    drawPathSvg(svgDrawingHelper, annotation.annotationUID, polylineUID, allContours, options);
+}
 function registerRenderMethods(toolInstance) {
     toolInstance.renderContour = renderContour.bind(toolInstance);
     toolInstance.renderClosedContour = renderClosedContour.bind(toolInstance);
     toolInstance.renderOpenContour = renderOpenContour.bind(toolInstance);
+    toolInstance.renderPointContourWithMarker =
+        renderPointContourWithMarker.bind(toolInstance);
     toolInstance.renderOpenUShapedContour =
         renderOpenUShapedContour.bind(toolInstance);
     toolInstance.renderContourBeingDrawn =
@@ -166,4 +214,3 @@ function registerRenderMethods(toolInstance) {
     toolInstance._getRenderingOptions = _getRenderingOptions.bind(toolInstance);
 }
 export default registerRenderMethods;
-//# sourceMappingURL=renderMethods.js.map

package/dist/esm/tools/annotation/splines/BSpline.d.ts

@@ -0,0 +1,5 @@
+import { CubicSpline } from './CubicSpline';
+declare class BSpline extends CubicSpline {
+    protected getTransformMatrix(): number[];
+}
+export { BSpline as default, BSpline };