@cornerstonejs/tools 4.12.3 → 4.12.4

package/dist/esm/tools/SculptorTool/CircleSculptCursor.d.ts

@@ -1,6 +1,5 @@
 import type { Types } from '@cornerstonejs/core';
 import type { ISculptToolShape } from '../../types/ISculptToolShape';
-import type { SculptData } from '../SculptorTool';
 import type { SVGDrawingHelper, EventTypes, ContourAnnotationData } from '../../types';
 export type PushedHandles = {
     first?: number;
@@ -8,19 +7,18 @@ export type PushedHandles = {
 };
 declare class CircleSculptCursor implements ISculptToolShape {
     static shapeName: string;
-    static readonly CHAIN_MAINTENANCE_ITERATIONS = 3;
-    static readonly CHAIN_PULL_STRENGTH_FACTOR = 0.3;
-    static readonly MAX_INTER_DISTANCE_FACTOR = 1.2;
     private toolInfo;
     renderShape(svgDrawingHelper: SVGDrawingHelper, canvasLocation: Types.Point2, options: unknown): void;
-    pushHandles(viewport: Types.IViewport, sculptData: SculptData): PushedHandles;
     configureToolSize(evt: EventTypes.InteractionEventType): void;
     updateToolSize(canvasCoords: Types.Point2, viewport: Types.IViewport, activeAnnotation: ContourAnnotationData): void;
     getMaxSpacing(minSpacing: number): number;
-    getInsertPosition(previousIndex: number, nextIndex: number, sculptData: SculptData): Types.Point3;
-    private pushOneHandle;
-    private directionalVector;
-    private calculateMeanConsecutiveDistance;
-    private maintainChainStructure;
+    computeWorldRadius(viewport: any, clearExisting?: boolean): any;
+    getEdge(viewport: any, p1: Types.Point3, p2: Types.Point3, mouseCanvas: Types.Point2): {
+        point: any;
+        angle: number;
+        canvasPoint: any;
+    };
+    interpolatePoint(viewport: any, angle: any, center: any): any;
+    isInCursor(point: any, mousePoint: any): boolean;
 }
 export default CircleSculptCursor;

package/dist/esm/tools/SculptorTool/CircleSculptCursor.js

@@ -1,4 +1,4 @@
-import { vec3 } from 'gl-matrix';
+import { vec2, vec3 } from 'gl-matrix';
 import { getEnabledElement } from '@cornerstonejs/core';
 import { distancePointToContour } from '../distancePointToContour';
 import { drawCircle as drawCircleSvg } from '../../drawingSvg';
@@ -7,46 +7,15 @@ class CircleSculptCursor {
     constructor() {
         this.toolInfo = {
             toolSize: null,
+            radius: null,
             maxToolSize: null,
         };
     }
     static { this.shapeName = 'Circle'; }
-    static { this.CHAIN_MAINTENANCE_ITERATIONS = 3; }
-    static { this.CHAIN_PULL_STRENGTH_FACTOR = 0.3; }
-    static { this.MAX_INTER_DISTANCE_FACTOR = 1.2; }
     renderShape(svgDrawingHelper, canvasLocation, options) {
         const circleUID = '0';
         drawCircleSvg(svgDrawingHelper, 'SculptorTool', circleUID, canvasLocation, this.toolInfo.toolSize, options);
     }
-    pushHandles(viewport, sculptData) {
-        const { points, mouseCanvasPoint } = sculptData;
-        const pushedHandles = { first: undefined, last: undefined };
-        const worldRadius = point.distanceToPoint(viewport.canvasToWorld(mouseCanvasPoint), viewport.canvasToWorld([
-            mouseCanvasPoint[0] + this.toolInfo.toolSize,
-            mouseCanvasPoint[1],
-        ]));
-        for (let i = 0; i < points.length; i++) {
-            const handleCanvasPoint = viewport.worldToCanvas(points[i]);
-            const distanceToHandle = point.distanceToPoint(handleCanvasPoint, mouseCanvasPoint);
-            if (distanceToHandle > this.toolInfo.toolSize) {
-                continue;
-            }
-            this.pushOneHandle(i, worldRadius, sculptData);
-            if (pushedHandles.first === undefined) {
-                pushedHandles.first = i;
-                pushedHandles.last = i;
-            }
-            else {
-                pushedHandles.last = i;
-            }
-        }
-        if (pushedHandles.first !== undefined && pushedHandles.last !== undefined) {
-            for (let i = 0; i < CircleSculptCursor.CHAIN_MAINTENANCE_ITERATIONS; i++) {
-                this.maintainChainStructure(sculptData, pushedHandles);
-            }
-        }
-        return pushedHandles;
-    }
     configureToolSize(evt) {
         const toolInfo = this.toolInfo;
         if (toolInfo.toolSize && toolInfo.maxToolSize) {
@@ -55,8 +24,9 @@ class CircleSculptCursor {
         const eventData = evt.detail;
         const element = eventData.element;
         const minDim = Math.min(element.clientWidth, element.clientHeight);
-        const maxRadius = minDim / 12;
+        const maxRadius = minDim / 24;
         toolInfo.toolSize = maxRadius;
+        toolInfo.radius = null;
         toolInfo.maxToolSize = maxRadius;
     }
     updateToolSize(canvasCoords, viewport, activeAnnotation) {
@@ -64,114 +34,44 @@ class CircleSculptCursor {
         const radius = distancePointToContour(viewport, activeAnnotation, canvasCoords);
         if (radius > 0) {
             toolInfo.toolSize = Math.min(toolInfo.maxToolSize, radius);
+            this.computeWorldRadius(viewport, true);
         }
     }
     getMaxSpacing(minSpacing) {
         return Math.max(this.toolInfo.toolSize / 4, minSpacing);
     }
-    getInsertPosition(previousIndex, nextIndex, sculptData) {
-        let insertPosition;
-        const { points, element, mouseCanvasPoint } = sculptData;
-        const toolSize = this.toolInfo.toolSize;
-        const enabledElement = getEnabledElement(element);
-        const { viewport } = enabledElement;
-        const previousCanvasPoint = viewport.worldToCanvas(points[previousIndex]);
-        const nextCanvasPoint = viewport.worldToCanvas(points[nextIndex]);
-        const midPoint = [
-            (previousCanvasPoint[0] + nextCanvasPoint[0]) / 2.0,
-            (previousCanvasPoint[1] + nextCanvasPoint[1]) / 2.0,
-        ];
-        const distanceToMidPoint = point.distanceToPoint(mouseCanvasPoint, midPoint);
-        if (distanceToMidPoint < toolSize) {
-            const directionUnitVector = {
-                x: (midPoint[0] - mouseCanvasPoint[0]) / distanceToMidPoint,
-                y: (midPoint[1] - mouseCanvasPoint[1]) / distanceToMidPoint,
-            };
-            insertPosition = [
-                mouseCanvasPoint[0] + toolSize * directionUnitVector.x,
-                mouseCanvasPoint[1] + toolSize * directionUnitVector.y,
-            ];
+    computeWorldRadius(viewport, clearExisting = false) {
+        if (!this.toolInfo.radius || clearExisting) {
+            const p0 = viewport.canvasToWorld([0, 0]);
+            const p1 = viewport.canvasToWorld([this.toolInfo.toolSize, 0]);
+            this.toolInfo.radius = vec3.length(vec3.sub(vec3.create(), p0, p1));
         }
-        else {
-            insertPosition = midPoint;
-        }
-        const worldPosition = viewport.canvasToWorld(insertPosition);
-        return worldPosition;
+        return this.toolInfo.radius;
     }
-    pushOneHandle(i, worldRadius, sculptData) {
-        const { points, mousePoint } = sculptData;
-        const handle = points[i];
-        const directionUnitVector = this.directionalVector(mousePoint, handle);
-        const position = vec3.scaleAndAdd(vec3.create(), mousePoint, directionUnitVector, worldRadius);
-        handle[0] = position[0];
-        handle[1] = position[1];
-        handle[2] = position[2];
+    getEdge(viewport, p1, p2, mouseCanvas) {
+        const midPoint = vec3.add(vec3.create(), p1, p2 || p1);
+        vec3.scale(midPoint, midPoint, 0.5);
+        const canvasMidPoint = viewport.worldToCanvas(midPoint);
+        const canvasDelta = vec2.sub(vec2.create(), canvasMidPoint, mouseCanvas);
+        const angle = Math.atan2(canvasDelta[1], canvasDelta[0]);
+        const point = this.interpolatePoint(viewport, angle, mouseCanvas);
+        const canvasPoint = viewport.worldToCanvas(point);
+        return {
+            point,
+            angle,
+            canvasPoint,
+        };
     }
-    directionalVector(p1, p2) {
-        return vec3.normalize(vec3.create(), [
-            p2[0] - p1[0],
-            p2[1] - p1[1],
-            p2[2] - p1[2],
-        ]);
+    interpolatePoint(viewport, angle, center) {
+        const [cx, cy] = center;
+        const r = this.toolInfo.toolSize;
+        const dx = Math.cos(angle) * r;
+        const dy = Math.sin(angle) * r;
+        const newPoint2 = [cx + dx, cy + dy];
+        return viewport.canvasToWorld(newPoint2);
     }
-    calculateMeanConsecutiveDistance(points) {
-        if (points.length < 2) {
-            return 0;
-        }
-        let totalDistance = 0;
-        const numPoints = points.length;
-        for (let i = 0; i < numPoints; i++) {
-            const nextIndex = (i + 1) % numPoints;
-            const distance = point.distanceToPoint(points[i], points[nextIndex]);
-            totalDistance += distance;
-        }
-        return totalDistance / numPoints;
-    }
-    maintainChainStructure(sculptData, pushedHandles) {
-        const { points } = sculptData;
-        const first = pushedHandles.first;
-        const last = pushedHandles.last;
-        const mean = Math.round((first + last) / 2);
-        const numPoints = points.length;
-        if (!sculptData.meanDistance) {
-            sculptData.meanDistance = this.calculateMeanConsecutiveDistance(points);
-        }
-        const maxInterDistance = sculptData.meanDistance * CircleSculptCursor.MAX_INTER_DISTANCE_FACTOR;
-        for (let i = mean; i >= 0; i--) {
-            if (i >= numPoints - 1 || i < 0) {
-                continue;
-            }
-            const nextIndex = i + 1;
-            const distanceToNext = point.distanceToPoint(points[i], points[nextIndex]);
-            if (distanceToNext > maxInterDistance) {
-                const pullDirection = this.directionalVector(points[i], points[nextIndex]);
-                const pullStrength = (distanceToNext - sculptData.meanDistance) / sculptData.meanDistance;
-                const adjustmentMagnitude = pullStrength *
-                    sculptData.meanDistance *
-                    CircleSculptCursor.CHAIN_PULL_STRENGTH_FACTOR;
-                points[i][0] += pullDirection[0] * adjustmentMagnitude;
-                points[i][1] += pullDirection[1] * adjustmentMagnitude;
-                points[i][2] += pullDirection[2] * adjustmentMagnitude;
-            }
-        }
-        for (let i = mean + 1; i < numPoints; i++) {
-            if (i >= numPoints || i <= 0) {
-                continue;
-            }
-            const previousIndex = i - 1;
-            const distanceToPrevious = point.distanceToPoint(points[i], points[previousIndex]);
-            if (distanceToPrevious > maxInterDistance) {
-                const pullDirection = this.directionalVector(points[i], points[previousIndex]);
-                const pullStrength = (distanceToPrevious - sculptData.meanDistance) /
-                    sculptData.meanDistance;
-                const adjustmentMagnitude = pullStrength *
-                    sculptData.meanDistance *
-                    CircleSculptCursor.CHAIN_PULL_STRENGTH_FACTOR;
-                points[i][0] += pullDirection[0] * adjustmentMagnitude;
-                points[i][1] += pullDirection[1] * adjustmentMagnitude;
-                points[i][2] += pullDirection[2] * adjustmentMagnitude;
-            }
-        }
+    isInCursor(point, mousePoint) {
+        return vec3.distance(point, mousePoint) < this.toolInfo.radius;
     }
 }
 export default CircleSculptCursor;

package/dist/esm/tools/SculptorTool.d.ts

@@ -2,15 +2,27 @@ import type { Types } from '@cornerstonejs/core';
 import { BaseTool } from './base';
 import type { EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
 import type { ISculptToolShape } from '../types/ISculptToolShape';
+export type Contour = {
+    annotationUID: string;
+    points: Array<Types.Point3>;
+};
 export type SculptData = {
     mousePoint: Types.Point3;
-    deltaWorld: Types.Point3;
     mouseCanvasPoint: Types.Point2;
     points: Array<Types.Point3>;
     maxSpacing: number;
-    meanDistance?: number;
     element: HTMLDivElement;
+    contours: Contour[];
+};
+export type SculptIntersect = {
+    annotationUID: string;
+    isEnter: boolean;
+    index: number;
+    relIndex?: number;
+    point: Types.Point3;
+    angle: number;
 };
+export type ContourSelection = Array<SculptIntersect>;
 declare class SculptorTool extends BaseTool {
     static toolName: string;
     registeredShapes: Map<any, any>;
@@ -23,13 +35,16 @@ declare class SculptorTool extends BaseTool {
     preMouseDownCallback: (evt: EventTypes.InteractionEventType) => boolean;
     mouseMoveCallback: (evt: EventTypes.InteractionEventType) => void;
     protected sculpt(eventData: any, points: Array<Types.Point3>): void;
+    intersect(viewport: Types.IViewport, cursorShape: any): SculptIntersect[];
+    interpolatePoints(viewport: any, enter: any, exit: any, existing: any, newPoints: any): void;
+    getContourSelections(intersections: any, pointLength: any): ContourSelection[];
+    findMergeable(contours: any, testIntersection: any, currentIndex: any): any;
+    findNext(intersections: any, lastAngle: any, isEnter?: boolean): any;
     protected interpolatePointsWithinMaxSpacing(i: number, points: Array<Types.Point3>, indicesToInsertAfter: Array<number>, maxSpacing: number): void;
     private updateCursor;
+    protected getToolInstance(element: HTMLDivElement): any;
     private filterSculptableAnnotationsForElement;
     private configureToolSize;
-    private insertNewHandles;
-    private findNewHandleIndices;
-    private insertHandleRadially;
     private selectFreehandTool;
     private getClosestFreehandToolOnElement;
     private endCallback;

package/dist/esm/tools/SculptorTool.js

@@ -1,6 +1,7 @@
-import { getEnabledElement } from '@cornerstonejs/core';
+import { getEnabledElement, utilities } from '@cornerstonejs/core';
+import { vec3 } from 'gl-matrix';
 import { BaseTool } from './base';
-import { getAnnotations } from '../stateManagement';
+import { getAnnotations, getAnnotation } from '../stateManagement';
 import { point } from '../utilities/math';
 import { Events, ToolModes, AnnotationStyleStates, ChangeTypes, } from '../enums';
 import { triggerAnnotationRenderForViewportIds } from '../utilities/triggerAnnotationRenderForViewportIds';
@@ -10,6 +11,8 @@ import { triggerAnnotationModified } from '../stateManagement/annotation/helpers
 import CircleSculptCursor from './SculptorTool/CircleSculptCursor';
 import { distancePointToContour } from './distancePointToContour';
 import { getToolGroupForViewport } from '../store/ToolGroupManager';
+import { getSignedArea, containsPoint } from '../utilities/math/polyline';
+const { isEqual } = utilities;
 class SculptorTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -21,7 +24,6 @@ class SculptorTool extends BaseTool {
             ],
             toolShape: 'circle',
             referencedToolName: 'PlanarFreehandROI',
-            updateCursorSize: 'dynamic',
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -32,10 +34,12 @@ class SculptorTool extends BaseTool {
             viewportIdsToRender: [],
             isEditingOpenContour: false,
             canvasLocation: undefined,
+            external: true,
+            closed: false,
         };
         this.preMouseDownCallback = (evt) => {
             const eventData = evt.detail;
-            const element = eventData.element;
+            const { element } = eventData;
             this.configureToolSize(evt);
             this.selectFreehandTool(eventData);
             if (this.commonData.activeAnnotationUID === null) {
@@ -58,14 +62,11 @@ class SculptorTool extends BaseTool {
         this.endCallback = (evt) => {
             const eventData = evt.detail;
             const { element } = eventData;
-            const config = this.configuration;
-            const enabledElement = getEnabledElement(element);
             this.isActive = false;
             this.deactivateModify(element);
             resetElementCursor(element);
-            const { renderingEngineId, viewportId } = enabledElement;
-            const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
-            const toolInstance = toolGroup.getToolInstance(config.referencedToolName);
+            const toolInstance = this.getToolInstance(element);
+            toolInstance.doneEditMemo?.();
             const annotations = this.filterSculptableAnnotationsForElement(element);
             const activeAnnotation = annotations.find((annotation) => annotation.annotationUID === this.commonData.activeAnnotationUID);
             if (toolInstance.configuration.calculateStats) {
@@ -101,15 +102,209 @@ class SculptorTool extends BaseTool {
         this.sculptData = {
             mousePoint: eventData.currentPoints.world,
             mouseCanvasPoint: eventData.currentPoints.canvas,
-            deltaWorld: eventData.deltaPoints.world,
             points,
             maxSpacing: cursorShape.getMaxSpacing(config.minSpacing),
             element: element,
+            contours: [
+                {
+                    annotationUID: this.commonData.activeAnnotationUID,
+                    points,
+                },
+            ],
         };
-        const pushedHandles = cursorShape.pushHandles(viewport, this.sculptData);
-        if (pushedHandles.first !== undefined) {
-            this.insertNewHandles(pushedHandles);
+        const intersections = this.intersect(viewport, cursorShape);
+        if (!intersections.length) {
+            return;
+        }
+        const contourSelections = this.getContourSelections(intersections, points.length);
+        const { closed } = this.commonData;
+        for (const contour of contourSelections) {
+            const newPoints = new Array();
+            const lastExit = contour[contour.length - 1];
+            let lastIndex = closed ? lastExit.relIndex : 0;
+            let lastEnter;
+            for (const intersection of contour) {
+                if (intersection.isEnter) {
+                    pushArr(newPoints, points, lastIndex, intersection.index);
+                    lastEnter = intersection;
+                }
+                else {
+                    this.interpolatePoints(viewport, lastEnter, intersection, points, newPoints);
+                }
+                lastIndex = intersection.index;
+            }
+            if (contourSelections.length > 1) {
+                const signedArea = getSignedArea(newPoints.map(viewport.worldToCanvas));
+                if (signedArea < 0) {
+                    console.warn('Skipping internal area');
+                    continue;
+                }
+            }
+            if (!closed && lastIndex < points.length - 1) {
+                pushArr(newPoints, points, lastIndex);
+            }
+            points.splice(0, points.length);
+            pushArr(points, newPoints);
+            return;
+        }
+    }
+    intersect(viewport, cursorShape) {
+        const { contours, mousePoint, mouseCanvasPoint } = this.sculptData;
+        const { closed } = this.commonData;
+        cursorShape.computeWorldRadius(viewport);
+        const result = new Array();
+        for (const contour of contours) {
+            const { annotationUID, points } = contour;
+            let lastIn = false;
+            let anyIn = false;
+            let anyOut = false;
+            const { length } = points;
+            for (let i = 0; i <= length; i++) {
+                const index = i % length;
+                const point = points[index];
+                const inCursor = cursorShape.isInCursor(point, mousePoint);
+                anyIn ||= inCursor;
+                anyOut ||= !inCursor;
+                if (i === 0) {
+                    lastIn = inCursor;
+                    if (!closed && inCursor) {
+                        const edge = cursorShape.getEdge(viewport, point, null, mouseCanvasPoint);
+                        result.push({
+                            annotationUID,
+                            isEnter: inCursor,
+                            index: i,
+                            point: edge.point,
+                            angle: edge.angle,
+                        });
+                    }
+                    continue;
+                }
+                if (index === 0 && !closed) {
+                    if (lastIn) {
+                        const edge = cursorShape.getEdge(viewport, points[length - 1], null, mouseCanvasPoint);
+                        result.push({
+                            annotationUID,
+                            isEnter: false,
+                            index: length - 1,
+                            point: edge.point,
+                            angle: edge.angle,
+                        });
+                    }
+                    continue;
+                }
+                if (lastIn === inCursor) {
+                    continue;
+                }
+                lastIn = inCursor;
+                const edge = cursorShape.getEdge(viewport, point, points[i - 1], mouseCanvasPoint);
+                result.push({
+                    annotationUID,
+                    isEnter: inCursor,
+                    index: i,
+                    point: edge.point,
+                    angle: edge.angle,
+                });
+            }
+        }
+        return result;
+    }
+    interpolatePoints(viewport, enter, exit, existing, newPoints) {
+        const { external, closed } = this.commonData;
+        const p0 = existing[enter.index % existing.length];
+        const p1 = existing[exit.index % existing.length];
+        const v = vec3.sub(vec3.create(), p1, p0);
+        if (isEqual(vec3.length(v), 0)) {
+            return;
+        }
+        const cursorShape = this.registeredShapes.get(this.selectedShape);
+        const a0 = (enter.angle + 2 * Math.PI) % (Math.PI * 2);
+        const a1 = (exit.angle + 2 * Math.PI) % (Math.PI * 2);
+        let ae = a1 < a0 ? a1 + 2 * Math.PI : a1;
+        const aeAlt = a1 > a0 ? a1 - 2 * Math.PI : a1;
+        if ((external && !closed && Math.abs(aeAlt - a0) < Math.abs(ae - a0)) ||
+            (external && closed)) {
+            ae = aeAlt;
+        }
+        const count = Math.ceil(Math.abs(a0 - ae) / 0.25);
+        for (let i = 0; i <= count; i++) {
+            const a = (a0 * (count - i) + i * ae) / count;
+            newPoints.push(cursorShape.interpolatePoint(viewport, a, this.sculptData.mouseCanvasPoint));
+        }
+    }
+    getContourSelections(intersections, pointLength) {
+        const result = new Array();
+        const enterLength = intersections.length / 2;
+        if (!enterLength || intersections.length % 2) {
+            return result;
+        }
+        let lastAngle = Number.NEGATIVE_INFINITY;
+        for (let enterCount = 0; enterCount < enterLength; enterCount++) {
+            const enter = this.findNext(intersections, lastAngle);
+            if (!enter) {
+                console.error("Couldnt' find an entry");
+                continue;
+            }
+            const exit = this.findNext(intersections, enter.angle, false);
+            if (!exit) {
+                console.error("Couldn't find an exit for", enter);
+                continue;
+            }
+            exit.relIndex ||=
+                exit.index < enter.index ? exit.index + pointLength : exit.index;
+            result.push([enter, exit]);
+        }
+        result.sort((a, b) => a[0].index - b[0].index);
+        for (let i = 0; i < result.length - 1;) {
+            const testIntersection = result[i];
+            const mergeableResult = this.findMergeable(result, testIntersection, i);
+            if (mergeableResult) {
+                testIntersection.push(...mergeableResult);
+            }
+            else {
+                i++;
+            }
+        }
+        if (result.length > 1) {
+            console.warn('************* More than 1 result', result);
         }
+        return result;
+    }
+    findMergeable(contours, testIntersection, currentIndex) {
+        const end = testIntersection[testIntersection.length - 1];
+        for (let i = currentIndex + 1; i < contours.length; i++) {
+            const [enter] = contours[i];
+            if (enter.index >= end.relIndex) {
+                const contour = contours[i];
+                contours.splice(i, 1);
+                return contour;
+            }
+        }
+    }
+    findNext(intersections, lastAngle, isEnter = true) {
+        if (intersections.length === 1) {
+            const [intersection] = intersections;
+            intersections.splice(0, 1);
+            return intersection;
+        }
+        let foundItem;
+        let testAngle;
+        for (let i = 0; i < intersections.length; i++) {
+            const intersection = intersections[i];
+            if (intersection.isEnter == isEnter) {
+                const relativeAngle = (intersection.angle - lastAngle + 2 * Math.PI) % (2 * Math.PI);
+                if (!foundItem || relativeAngle < testAngle) {
+                    foundItem = { i, intersection };
+                    testAngle = relativeAngle;
+                }
+            }
+        }
+        if (!foundItem) {
+            console.warn("Couldn't find an exit point for entry", JSON.stringify(intersections));
+            return;
+        }
+        intersections.splice(foundItem.i, 1);
+        const { intersection } = foundItem;
+        return intersection;
     }
     interpolatePointsWithinMaxSpacing(i, points, indicesToInsertAfter, maxSpacing) {
         const { element } = this.sculptData;
@@ -127,7 +322,7 @@ class SculptorTool extends BaseTool {
         const eventData = evt.detail;
         const element = eventData.element;
         const enabledElement = getEnabledElement(element);
-        const { renderingEngine, viewport } = enabledElement;
+        const { viewport } = enabledElement;
         this.commonData.viewportIdsToRender = [viewport.id];
         const annotations = this.filterSculptableAnnotationsForElement(element);
         if (!annotations?.length) {
@@ -141,20 +336,22 @@ class SculptorTool extends BaseTool {
         else {
             const cursorShape = this.registeredShapes.get(this.selectedShape);
             const canvasCoords = eventData.currentPoints.canvas;
-            if (this.configuration.updateCursorSize === 'dynamic') {
-                cursorShape.updateToolSize(canvasCoords, viewport, activeAnnotation);
-            }
+            cursorShape.updateToolSize(canvasCoords, viewport, activeAnnotation);
         }
         triggerAnnotationRenderForViewportIds(this.commonData.viewportIdsToRender);
     }
-    filterSculptableAnnotationsForElement(element) {
-        const config = this.configuration;
+    getToolInstance(element) {
         const enabledElement = getEnabledElement(element);
         const { renderingEngineId, viewportId } = enabledElement;
-        const sculptableAnnotations = [];
         const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
-        const toolInstance = toolGroup.getToolInstance(config.referencedToolName);
-        config.referencedToolNames.forEach((referencedToolName) => {
+        const toolInstance = toolGroup.getToolInstance(this.configuration.referencedToolName);
+        return toolInstance;
+    }
+    filterSculptableAnnotationsForElement(element) {
+        const { configuration } = this;
+        const sculptableAnnotations = [];
+        const toolInstance = this.getToolInstance(element);
+        configuration.referencedToolNames.forEach((referencedToolName) => {
             const annotations = getAnnotations(referencedToolName, element);
             if (annotations) {
                 sculptableAnnotations.push(...annotations);
@@ -166,42 +363,25 @@ class SculptorTool extends BaseTool {
         const cursorShape = this.registeredShapes.get(this.selectedShape);
         cursorShape.configureToolSize(evt);
     }
-    insertNewHandles(pushedHandles) {
-        const indicesToInsertAfter = this.findNewHandleIndices(pushedHandles);
-        let newIndexModifier = 0;
-        for (let i = 0; i < indicesToInsertAfter?.length; i++) {
-            const insertIndex = indicesToInsertAfter[i] + 1 + newIndexModifier;
-            this.insertHandleRadially(insertIndex);
-            newIndexModifier++;
-        }
-    }
-    findNewHandleIndices(pushedHandles) {
-        const { points, maxSpacing } = this.sculptData;
-        const indicesToInsertAfter = [];
-        for (let i = pushedHandles.first; i <= pushedHandles.last; i++) {
-            this.interpolatePointsWithinMaxSpacing(i, points, indicesToInsertAfter, maxSpacing);
-        }
-        return indicesToInsertAfter;
-    }
-    insertHandleRadially(insertIndex) {
-        const { points } = this.sculptData;
-        if (insertIndex > points.length - 1 &&
-            this.commonData.isEditingOpenContour) {
-            return;
-        }
-        const cursorShape = this.registeredShapes.get(this.selectedShape);
-        const previousIndex = insertIndex - 1;
-        const nextIndex = contourIndex(insertIndex, points.length);
-        const insertPosition = cursorShape.getInsertPosition(previousIndex, nextIndex, this.sculptData);
-        const handleData = insertPosition;
-        points.splice(insertIndex, 0, handleData);
-    }
     selectFreehandTool(eventData) {
         const closestAnnotationUID = this.getClosestFreehandToolOnElement(eventData);
         if (closestAnnotationUID === undefined) {
             return;
         }
+        const annotation = getAnnotation(closestAnnotationUID);
         this.commonData.activeAnnotationUID = closestAnnotationUID;
+        this.commonData.closed = annotation.data.contour.closed;
+        this.commonData.external = true;
+        if (this.commonData.closed) {
+            const { element } = eventData;
+            const enabledElement = getEnabledElement(element);
+            const { viewport } = enabledElement;
+            const polyline = annotation.data.contour.polyline.map((p) => viewport.worldToCanvas(p));
+            const canvasPoint = eventData.currentPoints.canvas;
+            this.commonData.external = !containsPoint(polyline, canvasPoint, {
+                closed: true,
+            });
+        }
     }
     getClosestFreehandToolOnElement(eventData) {
         const { element } = eventData;
@@ -239,6 +419,9 @@ class SculptorTool extends BaseTool {
         return closest.annotationUID;
     }
     activateModify(element) {
+        const annotation = getAnnotation(this.commonData.activeAnnotationUID);
+        const instance = this.getToolInstance(element);
+        instance.createMemo?.(element, annotation);
         element.addEventListener(Events.MOUSE_UP, this.endCallback);
         element.addEventListener(Events.MOUSE_CLICK, this.endCallback);
         element.addEventListener(Events.MOUSE_DRAG, this.dragCallback);
@@ -286,6 +469,14 @@ class SculptorTool extends BaseTool {
         });
     }
 }
+function pushArr(dest, src, start = 0, end = src.length) {
+    if (end < start) {
+        end = end + src.length;
+    }
+    for (let i = start; i < end; i++) {
+        dest.push(src[i % src.length]);
+    }
+}
 export const contourIndex = (i, length) => {
     return (i + length) % length;
 };

package/dist/esm/tools/annotation/PlanarFreehandROITool.js

@@ -255,12 +255,12 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
         this._throttledCalculateCachedStats = throttle(this._calculateCachedStats, 100, { trailing: true });
     }
     filterInteractableAnnotationsForElement(element, annotations) {
-        if (!annotations || !annotations.length) {
-            return;
+        if (!annotations?.length) {
+            return [];
         }
         const baseFilteredAnnotations = super.filterInteractableAnnotationsForElement(element, annotations);
-        if (!baseFilteredAnnotations || !baseFilteredAnnotations.length) {
-            return;
+        if (!baseFilteredAnnotations?.length) {
+            return [];
         }
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;

package/dist/esm/tools/segmentation/BrushTool.js

@@ -113,6 +113,9 @@ class BrushTool extends LabelmapBaseTool {
             const hoverData = this._hoverData || this.createHoverData(element);
             triggerAnnotationRenderForViewportUIDs(hoverData.viewportIdsToRender);
             const operationData = this.getOperationData(element);
+            if (!operationData) {
+                return false;
+            }
             this.applyActiveStrategyCallback(enabledElement, operationData, StrategyCallbacks.OnInteractionStart);
             return true;
         };
@@ -218,6 +221,9 @@ class BrushTool extends LabelmapBaseTool {
             this._hoverData = this.createHoverData(element, currentCanvas);
             this._calculateCursor(element, currentCanvas);
             const operationData = this.getOperationData(element);
+            if (!operationData) {
+                return;
+            }
             operationData.strokePointsWorld = [
                 vec3.clone(this._lastDragInfo.world),
                 vec3.clone(currentWorld),
@@ -238,6 +244,9 @@ class BrushTool extends LabelmapBaseTool {
             const { element } = eventData;
             const enabledElement = getEnabledElement(element);
             const operationData = this.getOperationData(element);
+            if (!operationData) {
+                return;
+            }
             if (!this._previewData.preview && !this._previewData.isDrag) {
                 this.applyActiveStrategy(enabledElement, operationData);
             }

package/dist/esm/types/ISculptToolShape.d.ts

@@ -1,12 +1,14 @@
 import type { Types } from '@cornerstonejs/core';
 import type { SVGDrawingHelper, EventTypes, ContourAnnotation } from '.';
-import type { PushedHandles } from '../tools/SculptorTool/CircleSculptCursor';
-import type { SculptData } from '../tools/SculptorTool';
 export interface ISculptToolShape {
     renderShape(svgDrawingHelper: SVGDrawingHelper, canvasLocation: Types.Point2, options: any): void;
-    pushHandles(viewport: Types.IViewport, sculptData: SculptData): PushedHandles;
     configureToolSize(evt: EventTypes.InteractionEventType): void;
+    interpolatePoint(viewport: Types.IViewport, angle: number, center: Types.Point2): Types.Point2;
+    getEdge(viewport: Types.IViewport, p1: Types.Point3, p2: Types.Point3, mouseCanvas: Types.Point2): {
+        point: Types.Point3;
+        angle: number;
+        canvasPoint: Types.Point2;
+    };
     updateToolSize(canvasCoords: Types.Point2, viewport: Types.IViewport, activeAnnotation: ContourAnnotation): void;
     getMaxSpacing(minSpacing: number): number;
-    getInsertPosition(previousIndex: number, nextIndex: number, sculptData: SculptData): Types.Point3;
 }

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.12.3";
+export declare const version = "4.12.4";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '4.12.3';
+export const version = '4.12.4';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "4.12.3",
+  "version": "4.12.4",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -108,7 +108,7 @@
     "canvas": "3.2.0"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "4.12.3",
+    "@cornerstonejs/core": "4.12.4",
     "@kitware/vtk.js": "34.15.1",
     "@types/d3-array": "3.2.1",
     "@types/d3-interpolate": "3.0.4",
@@ -127,5 +127,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "ea79a24d2099225dd33ac53e06e106f15322007f"
+  "gitHead": "709d5a61b1acccf6a2dd8f9193907f98b5ed6c4c"
 }