@cornerstonejs/tools 3.0.2 → 3.0.4

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

@@ -0,0 +1,289 @@
+import { getEnabledElement, utilities } from '@cornerstonejs/core';
+import { resetElementCursor, hideElementCursor, } from '../../../cursors/elementCursor';
+import { Events } from '../../../enums';
+import { state } from '../../../store/state';
+import { vec3 } from 'gl-matrix';
+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';
+import { ContourWindingDirection } from '../../../types/ContourAnnotation';
+const { addCanvasPointsToArray, pointsAreWithinCloseContourProximity, getFirstLineSegmentIntersectionIndexes, getSubPixelSpacingAndXYDirections, } = polyline;
+function activateDraw(evt, annotation, viewportIdsToRender) {
+    this.isDrawing = true;
+    const eventDetail = evt.detail;
+    const { currentPoints, element } = eventDetail;
+    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) || {};
+    if (!spacing || !xDir || !yDir) {
+        return;
+    }
+    this.drawData = {
+        canvasPoints: [canvasPos],
+        polylineIndex: 0,
+        contourHoleProcessingEnabled,
+        newAnnotation: true,
+    };
+    this.commonData = {
+        annotation,
+        viewportIdsToRender,
+        spacing,
+        xDir,
+        yDir,
+        movingTextBox: false,
+    };
+    state.isInteractingWithTool = true;
+    element.addEventListener(Events.MOUSE_UP, this.mouseUpDrawCallback);
+    element.addEventListener(Events.MOUSE_DRAG, this.mouseDragDrawCallback);
+    element.addEventListener(Events.MOUSE_CLICK, this.mouseUpDrawCallback);
+    element.addEventListener(Events.TOUCH_END, this.mouseUpDrawCallback);
+    element.addEventListener(Events.TOUCH_DRAG, this.mouseDragDrawCallback);
+    element.addEventListener(Events.TOUCH_TAP, this.mouseUpDrawCallback);
+    hideElementCursor(element);
+}
+function deactivateDraw(element) {
+    state.isInteractingWithTool = false;
+    element.removeEventListener(Events.MOUSE_UP, this.mouseUpDrawCallback);
+    element.removeEventListener(Events.MOUSE_DRAG, this.mouseDragDrawCallback);
+    element.removeEventListener(Events.MOUSE_CLICK, this.mouseUpDrawCallback);
+    element.removeEventListener(Events.TOUCH_END, this.mouseUpDrawCallback);
+    element.removeEventListener(Events.TOUCH_DRAG, this.mouseDragDrawCallback);
+    element.removeEventListener(Events.TOUCH_TAP, this.mouseUpDrawCallback);
+    resetElementCursor(element);
+}
+function mouseDragDrawCallback(evt) {
+    const eventDetail = evt.detail;
+    const { currentPoints, element } = eventDetail;
+    const worldPos = currentPoints.world;
+    const canvasPos = currentPoints.canvas;
+    const enabledElement = getEnabledElement(element);
+    const { viewport } = enabledElement;
+    const { annotation, viewportIdsToRender, xDir, yDir, spacing, movingTextBox, } = this.commonData;
+    const { polylineIndex, canvasPoints, newAnnotation } = this.drawData;
+    this.createMemo(element, annotation, { newAnnotation });
+    const lastCanvasPoint = canvasPoints[canvasPoints.length - 1];
+    const lastWorldPoint = viewport.canvasToWorld(lastCanvasPoint);
+    const worldPosDiff = vec3.create();
+    vec3.subtract(worldPosDiff, worldPos, lastWorldPoint);
+    const xDist = Math.abs(vec3.dot(worldPosDiff, xDir));
+    const yDist = Math.abs(vec3.dot(worldPosDiff, yDir));
+    if (xDist <= spacing[0] && yDist <= spacing[1]) {
+        return;
+    }
+    if (movingTextBox) {
+        this.isDrawing = false;
+        const { deltaPoints } = eventDetail;
+        const worldPosDelta = deltaPoints.world;
+        const { textBox } = annotation.data.handles;
+        const { worldPosition } = textBox;
+        worldPosition[0] += worldPosDelta[0];
+        worldPosition[1] += worldPosDelta[1];
+        worldPosition[2] += worldPosDelta[2];
+        textBox.hasMoved = true;
+    }
+    else {
+        const crossingIndex = this.findCrossingIndexDuringCreate(evt);
+        if (crossingIndex !== undefined) {
+            this.applyCreateOnCross(evt, crossingIndex);
+        }
+        else {
+            const numPointsAdded = addCanvasPointsToArray(element, canvasPoints, canvasPos, this.commonData);
+            this.drawData.polylineIndex = polylineIndex + numPointsAdded;
+        }
+    }
+    triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+}
+function mouseUpDrawCallback(evt) {
+    const { allowOpenContours } = this.configuration;
+    const { canvasPoints, contourHoleProcessingEnabled } = this.drawData;
+    const firstPoint = canvasPoints[0];
+    const lastPoint = canvasPoints[canvasPoints.length - 1];
+    const eventDetail = evt.detail;
+    const { element } = eventDetail;
+    this.doneEditMemo();
+    this.drawData.newAnnotation = false;
+    if (allowOpenContours &&
+        !pointsAreWithinCloseContourProximity(firstPoint, lastPoint, this.configuration.closeContourProximity)) {
+        this.completeDrawOpenContour(element, { contourHoleProcessingEnabled });
+    }
+    else {
+        this.completeDrawClosedContour(element, { contourHoleProcessingEnabled });
+    }
+}
+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;
+    }
+    const { annotation, viewportIdsToRender } = this.commonData;
+    const enabledElement = getEnabledElement(element);
+    const { viewport, renderingEngine } = enabledElement;
+    addCanvasPointsToArray(element, canvasPoints, canvasPoints[0], this.commonData);
+    canvasPoints.pop();
+    const updatedPoints = shouldSmooth(this.configuration, annotation)
+        ? getInterpolatedPoints(this.configuration, canvasPoints)
+        : canvasPoints;
+    this.updateContourPolyline(annotation, {
+        points: updatedPoints,
+        closed: true,
+        targetWindingDirection: ContourWindingDirection.Clockwise,
+    }, viewport);
+    const { textBox } = annotation.data.handles;
+    if (!textBox?.hasMoved) {
+        triggerContourAnnotationCompleted(annotation, contourHoleProcessingEnabled);
+    }
+    this.isDrawing = false;
+    this.drawData = undefined;
+    this.commonData = undefined;
+    triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+    this.deactivateDraw(element);
+    return true;
+}
+function removeCrossedLinesOnCompleteDraw() {
+    const { canvasPoints } = this.drawData;
+    const numPoints = canvasPoints.length;
+    const endToStart = [canvasPoints[0], canvasPoints[numPoints - 1]];
+    const canvasPointsMinusEnds = canvasPoints.slice(0, -1).slice(1);
+    const lineSegment = getFirstLineSegmentIntersectionIndexes(canvasPointsMinusEnds, endToStart[0], endToStart[1], false);
+    if (lineSegment) {
+        const indexToRemoveUpTo = lineSegment[1];
+        if (indexToRemoveUpTo === 1) {
+            this.drawData.canvasPoints = canvasPoints.splice(1);
+        }
+        else {
+            this.drawData.canvasPoints = canvasPoints.splice(0, indexToRemoveUpTo);
+        }
+    }
+}
+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 = shouldSmooth(this.configuration, annotation)
+        ? getInterpolatedPoints(this.configuration, canvasPoints)
+        : canvasPoints;
+    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],
+    ];
+    if (annotation.data.isOpenUShapeContour) {
+        annotation.data.openUShapeContourVectorToPeak =
+            findOpenUShapedContourVectorToPeak(canvasPoints, viewport);
+    }
+    if (!textBox.hasMoved) {
+        triggerContourAnnotationCompleted(annotation, contourHoleProcessingEnabled);
+    }
+    this.isDrawing = false;
+    this.drawData = undefined;
+    this.commonData = undefined;
+    triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+    this.deactivateDraw(element);
+    return true;
+}
+function findCrossingIndexDuringCreate(evt) {
+    const eventDetail = evt.detail;
+    const { currentPoints, lastPoints } = eventDetail;
+    const canvasPos = currentPoints.canvas;
+    const lastCanvasPoint = lastPoints.canvas;
+    const { canvasPoints } = this.drawData;
+    const pointsLessLastOne = canvasPoints.slice(0, -1);
+    const lineSegment = getFirstLineSegmentIntersectionIndexes(pointsLessLastOne, canvasPos, lastCanvasPoint, false);
+    if (lineSegment === undefined) {
+        return;
+    }
+    const crossingIndex = lineSegment[0];
+    return crossingIndex;
+}
+function applyCreateOnCross(evt, crossingIndex) {
+    const eventDetail = evt.detail;
+    const { element } = eventDetail;
+    const { canvasPoints, contourHoleProcessingEnabled } = this.drawData;
+    const { annotation, viewportIdsToRender } = this.commonData;
+    addCanvasPointsToArray(element, canvasPoints, canvasPoints[crossingIndex], this.commonData);
+    canvasPoints.pop();
+    const remainingPoints = canvasPoints.slice(crossingIndex);
+    const newArea = polyline.getArea(remainingPoints);
+    if (utilities.isEqual(newArea, 0)) {
+        canvasPoints.splice(crossingIndex + 1);
+        return;
+    }
+    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, contourHoleProcessingEnabled } = this.drawData;
+    const firstPoint = canvasPoints[0];
+    const lastPoint = canvasPoints[canvasPoints.length - 1];
+    if (allowOpenContours &&
+        !pointsAreWithinCloseContourProximity(firstPoint, lastPoint, this.configuration.closeContourProximity)) {
+        this.completeDrawOpenContour(element, { contourHoleProcessingEnabled });
+    }
+    else {
+        this.completeDrawClosedContour(element, { contourHoleProcessingEnabled });
+    }
+}
+function shouldHaltDrawing(canvasPoints, subPixelResolution) {
+    const minPoints = Math.max(subPixelResolution * 3, 3);
+    return canvasPoints.length < minPoints;
+}
+function haltDrawing(element, canvasPoints) {
+    const { subPixelResolution } = this.configuration;
+    if (shouldHaltDrawing(canvasPoints, subPixelResolution)) {
+        const { annotation, viewportIdsToRender } = this.commonData;
+        const enabledElement = getEnabledElement(element);
+        const { renderingEngine } = enabledElement;
+        removeAnnotation(annotation.annotationUID);
+        this.isDrawing = false;
+        this.drawData = undefined;
+        this.commonData = undefined;
+        triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+        this.deactivateDraw(element);
+        return true;
+    }
+    return false;
+}
+function registerDrawLoop(toolInstance) {
+    toolInstance.activateDraw = activateDraw.bind(toolInstance);
+    toolInstance.deactivateDraw = deactivateDraw.bind(toolInstance);
+    toolInstance.applyCreateOnCross = applyCreateOnCross.bind(toolInstance);
+    toolInstance.findCrossingIndexDuringCreate =
+        findCrossingIndexDuringCreate.bind(toolInstance);
+    toolInstance.completeDrawOpenContour =
+        completeDrawOpenContour.bind(toolInstance);
+    toolInstance.removeCrossedLinesOnCompleteDraw =
+        removeCrossedLinesOnCompleteDraw.bind(toolInstance);
+    toolInstance.mouseDragDrawCallback = mouseDragDrawCallback.bind(toolInstance);
+    toolInstance.mouseUpDrawCallback = mouseUpDrawCallback.bind(toolInstance);
+    toolInstance.completeDrawClosedContour =
+        completeDrawClosedContour.bind(toolInstance);
+    toolInstance.cancelDrawing = cancelDrawing.bind(toolInstance);
+    toolInstance.haltDrawing = haltDrawing.bind(toolInstance);
+}
+export default registerDrawLoop;

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

@@ -0,0 +1,2 @@
+declare function registerEditLoopCommon(toolInstance: any): void;
+export default registerEditLoopCommon;

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

@@ -0,0 +1,146 @@
+import { vec2 } from 'gl-matrix';
+import { polyline } from '../../../utilities/math';
+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 = getFirstLineSegmentIntersectionIndexes(prevCanvasPoints, canvasPos, lastCanvasPoint, isClosedContour);
+    if (crossedLineSegment) {
+        this.editData.startCrossingIndex = crossedLineSegment[0];
+        this.removePointsUpUntilFirstCrossing(isClosedContour);
+    }
+    else if (prevCanvasPoints.length >= 2) {
+        if (editCanvasPoints.length >
+            this.configuration.checkCanvasEditFallbackProximity) {
+            const firstEditCanvasPoint = editCanvasPoints[0];
+            const distanceIndexPairs = [];
+            for (let i = 0; i < prevCanvasPoints.length; i++) {
+                const prevCanvasPoint = prevCanvasPoints[i];
+                const distance = vec2.distance(prevCanvasPoint, firstEditCanvasPoint);
+                distanceIndexPairs.push({ distance, index: i });
+            }
+            distanceIndexPairs.sort((a, b) => a.distance - b.distance);
+            const twoClosestDistanceIndexPairs = [
+                distanceIndexPairs[0],
+                distanceIndexPairs[1],
+            ];
+            const lowestIndex = Math.min(twoClosestDistanceIndexPairs[0].index, twoClosestDistanceIndexPairs[1].index);
+            this.editData.startCrossingIndex = lowestIndex;
+        }
+        else {
+            const dir = vec2.create();
+            vec2.subtract(dir, editCanvasPoints[1], editCanvasPoints[0]);
+            vec2.normalize(dir, dir);
+            const proximity = 6;
+            const extendedPoint = [
+                editCanvasPoints[0][0] - dir[0] * proximity,
+                editCanvasPoints[0][1] - dir[1] * proximity,
+            ];
+            const crossedLineSegmentFromExtendedPoint = getFirstLineSegmentIntersectionIndexes(prevCanvasPoints, extendedPoint, editCanvasPoints[0], isClosedContour);
+            if (crossedLineSegmentFromExtendedPoint) {
+                const pointsToPrepend = [extendedPoint];
+                addCanvasPointsToArray(element, pointsToPrepend, editCanvasPoints[0], this.commonData);
+                editCanvasPoints.unshift(...pointsToPrepend);
+                this.removePointsUpUntilFirstCrossing(isClosedContour);
+                this.editData.editIndex = editCanvasPoints.length - 1;
+                this.editData.startCrossingIndex =
+                    crossedLineSegmentFromExtendedPoint[0];
+            }
+        }
+    }
+}
+function removePointsUpUntilFirstCrossing(isClosedContour) {
+    const { editCanvasPoints, prevCanvasPoints } = this.editData;
+    let numPointsToRemove = 0;
+    for (let i = 0; i < editCanvasPoints.length - 1; i++) {
+        const firstLine = [editCanvasPoints[i], editCanvasPoints[i + 1]];
+        const didCrossLine = !!getFirstLineSegmentIntersectionIndexes(prevCanvasPoints, firstLine[0], firstLine[1], isClosedContour);
+        numPointsToRemove++;
+        if (didCrossLine) {
+            break;
+        }
+    }
+    editCanvasPoints.splice(0, numPointsToRemove);
+    this.editData.editIndex = editCanvasPoints.length - 1;
+}
+function checkForSecondCrossing(evt, isClosedContour) {
+    const eventDetail = evt.detail;
+    const { currentPoints, lastPoints } = eventDetail;
+    const canvasPos = currentPoints.canvas;
+    const lastCanvasPoint = lastPoints.canvas;
+    const { prevCanvasPoints } = this.editData;
+    const crossedLineSegment = getFirstLineSegmentIntersectionIndexes(prevCanvasPoints, canvasPos, lastCanvasPoint, isClosedContour);
+    if (!crossedLineSegment) {
+        return false;
+    }
+    return true;
+}
+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 = !!getFirstLineSegmentIntersectionIndexes(prevCanvasPoints, lastLine[0], lastLine[1], isClosedContour);
+        editCanvasPoints.pop();
+        if (didCrossLine) {
+            break;
+        }
+    }
+}
+function findSnapIndex() {
+    const { editCanvasPoints, prevCanvasPoints, startCrossingIndex } = this.editData;
+    if (startCrossingIndex === undefined) {
+        return;
+    }
+    const lastEditCanvasPoint = editCanvasPoints[editCanvasPoints.length - 1];
+    const distanceIndexPairs = [];
+    for (let i = 0; i < prevCanvasPoints.length; i++) {
+        const prevCanvasPoint = prevCanvasPoints[i];
+        const distance = vec2.distance(prevCanvasPoint, lastEditCanvasPoint);
+        distanceIndexPairs.push({ distance, index: i });
+    }
+    distanceIndexPairs.sort((a, b) => a.distance - b.distance);
+    const editCanvasPointsLessLastOne = editCanvasPoints.slice(0, -1);
+    for (let i = 0; i < distanceIndexPairs.length; i++) {
+        const { index } = distanceIndexPairs[i];
+        const snapCanvasPosition = prevCanvasPoints[index];
+        const lastEditCanvasPoint = editCanvasPoints[editCanvasPoints.length - 1];
+        const crossedLineSegment = getFirstLineSegmentIntersectionIndexes(editCanvasPointsLessLastOne, snapCanvasPosition, lastEditCanvasPoint, false);
+        if (!crossedLineSegment) {
+            return index;
+        }
+    }
+    return -1;
+}
+function checkAndRemoveCrossesOnEditLine(evt) {
+    const eventDetail = evt.detail;
+    const { currentPoints, lastPoints } = eventDetail;
+    const canvasPos = currentPoints.canvas;
+    const lastCanvasPoint = lastPoints.canvas;
+    const { editCanvasPoints } = this.editData;
+    const editCanvasPointsLessLastOne = editCanvasPoints.slice(0, -2);
+    const crossedLineSegment = getFirstLineSegmentIntersectionIndexes(editCanvasPointsLessLastOne, canvasPos, lastCanvasPoint, false);
+    if (!crossedLineSegment) {
+        return;
+    }
+    const editIndexCrossed = crossedLineSegment[0];
+    const numPointsToRemove = editCanvasPoints.length - editIndexCrossed;
+    for (let i = 0; i < numPointsToRemove; i++) {
+        editCanvasPoints.pop();
+    }
+}
+function registerEditLoopCommon(toolInstance) {
+    toolInstance.checkForFirstCrossing = checkForFirstCrossing.bind(toolInstance);
+    toolInstance.removePointsUpUntilFirstCrossing =
+        removePointsUpUntilFirstCrossing.bind(toolInstance);
+    toolInstance.checkForSecondCrossing =
+        checkForSecondCrossing.bind(toolInstance);
+    toolInstance.findSnapIndex = findSnapIndex.bind(toolInstance);
+    toolInstance.removePointsAfterSecondCrossing =
+        removePointsAfterSecondCrossing.bind(toolInstance);
+    toolInstance.checkAndRemoveCrossesOnEditLine =
+        checkAndRemoveCrossesOnEditLine.bind(toolInstance);
+}
+export default registerEditLoopCommon;

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

@@ -0,0 +1,4 @@
+import type { Types } from '@cornerstonejs/core';
+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

@@ -0,0 +1,39 @@
+import { vec2 } from 'gl-matrix';
+export default function findOpenUShapedContourVectorToPeak(canvasPoints, viewport) {
+    const first = canvasPoints[0];
+    const last = canvasPoints[canvasPoints.length - 1];
+    const firstToLastUnitVector = vec2.create();
+    vec2.set(firstToLastUnitVector, last[0] - first[0], last[1] - first[1]);
+    vec2.normalize(firstToLastUnitVector, firstToLastUnitVector);
+    const normalVector1 = vec2.create();
+    const normalVector2 = vec2.create();
+    vec2.set(normalVector1, -firstToLastUnitVector[1], firstToLastUnitVector[0]);
+    vec2.set(normalVector2, firstToLastUnitVector[1], -firstToLastUnitVector[0]);
+    const centerOfFirstToLast = [
+        (first[0] + last[0]) / 2,
+        (first[1] + last[1]) / 2,
+    ];
+    const furthest = {
+        dist: 0,
+        index: null,
+    };
+    for (let i = 0; i < canvasPoints.length; i++) {
+        const canvasPoint = canvasPoints[i];
+        const distance = vec2.dist(canvasPoint, centerOfFirstToLast);
+        if (distance > furthest.dist) {
+            furthest.dist = distance;
+            furthest.index = i;
+        }
+    }
+    const toFurthest = [
+        canvasPoints[furthest.index],
+        centerOfFirstToLast,
+    ];
+    const toFurthestWorld = toFurthest.map(viewport.canvasToWorld);
+    return toFurthestWorld;
+}
+export function findOpenUShapedContourVectorToPeakOnRender(enabledElement, annotation) {
+    const { viewport } = enabledElement;
+    const canvasPoints = annotation.data.contour.polyline.map(viewport.worldToCanvas);
+    return findOpenUShapedContourVectorToPeak(canvasPoints, viewport);
+}

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

@@ -0,0 +1,2 @@
+declare function registerOpenContourEditLoop(toolInstance: any): void;
+export default registerOpenContourEditLoop;