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

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

@@ -0,0 +1,31 @@
+import type { Types } from '@cornerstonejs/core';
+import { PublicToolProps, ToolProps, SVGDrawingHelper, Annotation } from '../types';
+import AnnotationDisplayTool from './base/AnnotationDisplayTool';
+export interface OverlayGridAnnotation extends Annotation {
+    data: {
+        viewportData: Map<string, object>;
+        pointSets: Array<object>;
+    };
+}
+declare class OverlayGridTool extends AnnotationDisplayTool {
+    static toolName: any;
+    touchDragCallback: any;
+    mouseDragCallback: any;
+    _throttledCalculateCachedStats: any;
+    isDrawing: boolean;
+    isHandleOutsideImage: boolean;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    onSetToolEnabled: () => void;
+    onSetToolActive: () => void;
+    _init: () => void;
+    calculateImageIdPointSets: (imageId: string) => {
+        pointSet1: Types.Point3[];
+        pointSet2: Types.Point3[];
+    };
+    renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
+    private initializeViewportData;
+    private isPerpendicular;
+    private isParallel;
+    private getImageIdNormal;
+}
+export default OverlayGridTool;

package/dist/esm/tools/OverlayGridTool.js

@@ -0,0 +1,164 @@
+import { vec3 } from 'gl-matrix';
+import { metaData, CONSTANTS, utilities as csUtils, } from '@cornerstonejs/core';
+import { addAnnotation, getAnnotations, } from '../stateManagement/annotation/annotationState';
+import { getToolGroup } from '../store/ToolGroupManager';
+import { drawLine as drawLineSvg } from '../drawingSvg';
+import triggerAnnotationRenderForViewportIds from '../utilities/triggerAnnotationRenderForViewportIds';
+import AnnotationDisplayTool from './base/AnnotationDisplayTool';
+const { EPSILON } = CONSTANTS;
+class OverlayGridTool extends AnnotationDisplayTool {
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            sourceImageIds: [],
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this.onSetToolEnabled = () => {
+            this._init();
+        };
+        this.onSetToolActive = () => {
+            this._init();
+        };
+        this._init = () => {
+            const sourceImageIds = this.configuration.sourceImageIds;
+            if (!sourceImageIds?.length) {
+                console.warn('OverlayGridTool: No sourceImageIds provided in configuration');
+                return;
+            }
+            const imagePlaneModule = metaData.get('imagePlaneModule', sourceImageIds[0]);
+            if (!imagePlaneModule) {
+                console.warn('OverlayGridTool: No imagePlaneModule found for sourceImageIds');
+                return;
+            }
+            const { frameOfReferenceUID } = imagePlaneModule;
+            const viewportsInfo = getToolGroup(this.toolGroupId).viewportsInfo;
+            if (!viewportsInfo?.length) {
+                console.warn('OverlayGridTool: No viewports found');
+                return;
+            }
+            const annotations = getAnnotations(this.getToolName(), frameOfReferenceUID);
+            if (!annotations?.length) {
+                const pointSets = sourceImageIds.map((id) => {
+                    return this.calculateImageIdPointSets(id);
+                });
+                const newAnnotation = {
+                    highlighted: true,
+                    invalidated: true,
+                    metadata: {
+                        toolName: this.getToolName(),
+                        FrameOfReferenceUID: frameOfReferenceUID,
+                        referencedImageId: null,
+                    },
+                    data: {
+                        viewportData: new Map(),
+                        pointSets,
+                    },
+                };
+                addAnnotation(newAnnotation, frameOfReferenceUID);
+            }
+            triggerAnnotationRenderForViewportIds(viewportsInfo.map(({ viewportId }) => viewportId));
+        };
+        this.calculateImageIdPointSets = (imageId) => {
+            const { imagePositionPatient, rows, columns, rowCosines, columnCosines, rowPixelSpacing, columnPixelSpacing, } = metaData.get('imagePlaneModule', imageId);
+            const topLeft = [...imagePositionPatient];
+            const topRight = [...imagePositionPatient];
+            const bottomLeft = [...imagePositionPatient];
+            const bottomRight = [...imagePositionPatient];
+            vec3.scaleAndAdd(topRight, imagePositionPatient, columnCosines, columns * columnPixelSpacing);
+            vec3.scaleAndAdd(bottomLeft, imagePositionPatient, rowCosines, rows * rowPixelSpacing);
+            vec3.scaleAndAdd(bottomRight, bottomLeft, columnCosines, columns * columnPixelSpacing);
+            const pointSet1 = [topLeft, bottomLeft, topRight, bottomRight];
+            const pointSet2 = [topLeft, topRight, bottomLeft, bottomRight];
+            return { pointSet1, pointSet2 };
+        };
+        this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
+            const sourceImageIds = this.configuration.sourceImageIds;
+            let renderStatus = false;
+            if (!sourceImageIds?.length) {
+                return renderStatus;
+            }
+            const { viewport: targetViewport, FrameOfReferenceUID } = enabledElement;
+            const targetImageIds = targetViewport.getImageIds();
+            if (targetImageIds.length < 2) {
+                return renderStatus;
+            }
+            const annotations = getAnnotations(this.getToolName(), FrameOfReferenceUID);
+            if (!annotations?.length) {
+                return renderStatus;
+            }
+            const annotation = annotations[0];
+            const { annotationUID } = annotation;
+            const { focalPoint, viewPlaneNormal } = targetViewport.getCamera();
+            const styleSpecifier = {
+                toolGroupId: this.toolGroupId,
+                toolName: this.getToolName(),
+                viewportId: enabledElement.viewport.id,
+            };
+            const imageIdNormal = (this.getImageIdNormal(sourceImageIds[0]));
+            if (this.isParallel(viewPlaneNormal, imageIdNormal)) {
+                return renderStatus;
+            }
+            const targetViewportPlane = csUtils.planar.planeEquation(viewPlaneNormal, focalPoint);
+            const pointSets = annotation.data.pointSets;
+            const viewportData = annotation.data.viewportData;
+            for (let i = 0; i < sourceImageIds.length; i++) {
+                const { pointSet1, pointSet2 } = pointSets[i];
+                const targetData = viewportData.get(targetViewport.id) ||
+                    this.initializeViewportData(viewportData, targetViewport.id);
+                if (!targetData.pointSetsToUse[i]) {
+                    let pointSetToUse = pointSet1;
+                    let topBottomVec = vec3.subtract(vec3.create(), pointSet1[0], pointSet1[1]);
+                    topBottomVec = vec3.normalize(vec3.create(), topBottomVec);
+                    if (this.isPerpendicular(topBottomVec, viewPlaneNormal)) {
+                        pointSetToUse = pointSet2;
+                    }
+                    targetData.pointSetsToUse[i] = pointSetToUse;
+                    targetData.lineStartsWorld[i] = csUtils.planar.linePlaneIntersection(pointSetToUse[0], pointSetToUse[1], targetViewportPlane);
+                    targetData.lineEndsWorld[i] = csUtils.planar.linePlaneIntersection(pointSetToUse[2], pointSetToUse[3], targetViewportPlane);
+                }
+                const lineStartWorld = targetData.lineStartsWorld[i];
+                const lineEndWorld = targetData.lineEndsWorld[i];
+                styleSpecifier.annotationUID = annotationUID;
+                const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
+                const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
+                const color = this.getStyle('color', styleSpecifier, annotation);
+                const shadow = this.getStyle('shadow', styleSpecifier, annotation);
+                const canvasCoordinates = [lineStartWorld, lineEndWorld].map((world) => targetViewport.worldToCanvas(world));
+                const dataId = `${annotationUID}-line`;
+                const lineUID = `${i}`;
+                drawLineSvg(svgDrawingHelper, annotationUID, lineUID, canvasCoordinates[0], canvasCoordinates[1], {
+                    color,
+                    width: lineWidth,
+                    lineDash,
+                    shadow,
+                }, dataId);
+            }
+            renderStatus = true;
+            return renderStatus;
+        };
+        this.initializeViewportData = (viewportData, id) => {
+            viewportData.set(id, {
+                pointSetsToUse: [],
+                lineStartsWorld: [],
+                lineEndsWorld: [],
+            });
+            return viewportData.get(id);
+        };
+        this.isPerpendicular = (vec1, vec2) => {
+            const dot = vec3.dot(vec1, vec2);
+            return Math.abs(dot) < EPSILON;
+        };
+    }
+    isParallel(vec1, vec2) {
+        return Math.abs(vec3.dot(vec1, vec2)) > 1 - EPSILON;
+    }
+    getImageIdNormal(imageId) {
+        const { imageOrientationPatient } = metaData.get('imagePlaneModule', imageId);
+        const rowCosineVec = vec3.fromValues(imageOrientationPatient[0], imageOrientationPatient[1], imageOrientationPatient[2]);
+        const colCosineVec = vec3.fromValues(imageOrientationPatient[3], imageOrientationPatient[4], imageOrientationPatient[5]);
+        return vec3.cross(vec3.create(), rowCosineVec, colCosineVec);
+    }
+}
+OverlayGridTool.toolName = 'OverlayGrid';
+export default OverlayGridTool;

package/dist/esm/tools/PanTool.js

@@ -37,4 +37,3 @@ class PanTool extends BaseTool {
 }
 PanTool.toolName = 'Pan';
 export default PanTool;
-//# sourceMappingURL=PanTool.js.map

package/dist/esm/tools/PlanarRotateTool.js

@@ -40,12 +40,11 @@ class PlanarRotateTool extends BaseTool {
             viewport.setCamera({ viewUp: rotatedViewUp });
         }
         else {
-            const { rotation } = viewport.getProperties();
-            viewport.setProperties({ rotation: rotation + angle });
+            const { rotation } = viewport.getViewPresentation();
+            viewport.setViewPresentation({ rotation: rotation + angle });
         }
         viewport.render();
     }
 }
 PlanarRotateTool.toolName = 'PlanarRotate';
 export default PlanarRotateTool;
-//# sourceMappingURL=PlanarRotateTool.js.map

package/dist/esm/tools/ReferenceCursors.js

@@ -92,7 +92,7 @@ class ReferenceCursors extends AnnotationDisplayTool {
                 return;
             }
             const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName(), false);
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         };
         this.onCameraModified = (evt) => {
             const eventDetail = evt.detail;
@@ -241,8 +241,7 @@ class ReferenceCursors extends AnnotationDisplayTool {
         if (!enabledElement) {
             return;
         }
-        const { renderingEngine } = enabledElement;
-        triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+        triggerAnnotationRenderForViewportIds(viewportIdsToRender);
     }
     filterInteractableAnnotationsForElement(element, annotations) {
         if (!(annotations instanceof Array) || annotations.length === 0) {
@@ -307,4 +306,3 @@ class ReferenceCursors extends AnnotationDisplayTool {
 }
 ReferenceCursors.toolName = 'ReferenceCursors';
 export default ReferenceCursors;
-//# sourceMappingURL=ReferenceCursors.js.map

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

@@ -1,4 +1,4 @@
-import type { Types } from '@cornerstonejs/core';
+import { type Types } from '@cornerstonejs/core';
 import { PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
 import { ReferenceLineAnnotation } from '../types/ToolSpecificAnnotationTypes';
 import AnnotationDisplayTool from './base/AnnotationDisplayTool';
@@ -9,7 +9,7 @@ declare class ReferenceLines extends AnnotationDisplayTool {
     _throttledCalculateCachedStats: any;
     editData: {
         renderingEngine: any;
-        sourceViewport: any;
+        sourceViewportId: string;
         annotation: ReferenceLineAnnotation;
     } | null;
     isDrawing: boolean;
@@ -17,9 +17,13 @@ declare class ReferenceLines extends AnnotationDisplayTool {
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     _init: () => void;
     onSetToolEnabled: () => void;
+    onSetToolConfiguration: () => void;
     onCameraModified: (evt: Types.EventTypes.CameraModifiedEvent) => void;
     renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
     isPerpendicular: (vec1: Types.Point3, vec2: Types.Point3) => boolean;
+    private handleFullDimension;
+    intersectInfiniteLines(line1Start: Types.Point2, line1End: Types.Point2, line2Start: Types.Point2, line2End: Types.Point2): number[];
     isParallel(vec1: Types.Point3, vec2: Types.Point3): boolean;
+    isInBound(point: number[], dimensions: Types.Point3): boolean;
 }
 export default ReferenceLines;

package/dist/esm/tools/ReferenceLinesTool.js

@@ -1,5 +1,6 @@
 import { vec3 } from 'gl-matrix';
 import { getRenderingEngines, CONSTANTS, utilities as csUtils, } from '@cornerstonejs/core';
+import { getEnabledElementByViewportId } from '@cornerstonejs/core';
 import { addAnnotation } from '../stateManagement/annotation/annotationState';
 import { drawLine as drawLineSvg } from '../drawingSvg';
 import { filterViewportsWithToolEnabled } from '../utilities/viewportFilters';
@@ -11,6 +12,7 @@ class ReferenceLines extends AnnotationDisplayTool {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
             sourceViewportId: '',
+            showFullDimension: false,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -24,7 +26,7 @@ class ReferenceLines extends AnnotationDisplayTool {
             let viewports = renderingEngine.getViewports();
             viewports = filterViewportsWithToolEnabled(viewports, this.getToolName());
             const sourceViewport = renderingEngine.getViewport(this.configuration.sourceViewportId);
-            if (!sourceViewport || !sourceViewport.getImageData()) {
+            if (!sourceViewport?.getImageData()) {
                 return;
             }
             const { element } = sourceViewport;
@@ -57,24 +59,28 @@ class ReferenceLines extends AnnotationDisplayTool {
                     sourceViewportCanvasCornersInWorld;
             }
             this.editData = {
-                sourceViewport,
+                sourceViewportId: sourceViewport.id,
                 renderingEngine,
                 annotation,
             };
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewports
+            triggerAnnotationRenderForViewportIds(viewports
                 .filter((viewport) => viewport.id !== sourceViewport.id)
                 .map((viewport) => viewport.id));
         };
         this.onSetToolEnabled = () => {
             this._init();
         };
+        this.onSetToolConfiguration = () => {
+            this._init();
+        };
         this.onCameraModified = (evt) => {
             this._init();
         };
         this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
             const { viewport: targetViewport } = enabledElement;
-            const { annotation, sourceViewport } = this.editData;
+            const { annotation, sourceViewportId } = this.editData;
             let renderStatus = false;
+            const { viewport: sourceViewport } = getEnabledElementByViewportId(sourceViewportId) || {};
             if (!sourceViewport) {
                 return renderStatus;
             }
@@ -93,7 +99,7 @@ class ReferenceLines extends AnnotationDisplayTool {
             const topRight = annotation.data.handles.points[1];
             const bottomLeft = annotation.data.handles.points[2];
             const bottomRight = annotation.data.handles.points[3];
-            const { focalPoint, viewPlaneNormal } = targetViewport.getCamera();
+            const { focalPoint, viewPlaneNormal, viewUp } = targetViewport.getCamera();
             const { viewPlaneNormal: sourceViewPlaneNormal } = sourceViewport.getCamera();
             if (this.isParallel(viewPlaneNormal, sourceViewPlaneNormal)) {
                 return renderStatus;
@@ -121,7 +127,13 @@ class ReferenceLines extends AnnotationDisplayTool {
             const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
             const color = this.getStyle('color', styleSpecifier, annotation);
             const shadow = this.getStyle('shadow', styleSpecifier, annotation);
-            const canvasCoordinates = [lineStartWorld, lineEndWorld].map((world) => targetViewport.worldToCanvas(world));
+            let canvasCoordinates = [lineStartWorld, lineEndWorld].map((world) => targetViewport.worldToCanvas(world));
+            if (this.configuration.showFullDimension) {
+                canvasCoordinates = this.handleFullDimension(targetViewport, lineStartWorld, viewPlaneNormal, viewUp, lineEndWorld, canvasCoordinates);
+            }
+            if (canvasCoordinates.length < 2) {
+                return renderStatus;
+            }
             const dataId = `${annotationUID}-line`;
             const lineUID = '1';
             drawLineSvg(svgDrawingHelper, annotationUID, lineUID, canvasCoordinates[0], canvasCoordinates[1], {
@@ -138,10 +150,74 @@ class ReferenceLines extends AnnotationDisplayTool {
             return Math.abs(dot) < EPSILON;
         };
     }
+    handleFullDimension(targetViewport, lineStartWorld, viewPlaneNormal, viewUp, lineEndWorld, canvasCoordinates) {
+        const renderingEngine = targetViewport.getRenderingEngine();
+        const targetId = this.getTargetId(targetViewport);
+        const targetImage = this.getTargetIdImage(targetId, renderingEngine);
+        const referencedImageId = this.getReferencedImageId(targetViewport, lineStartWorld, viewPlaneNormal, viewUp);
+        if (referencedImageId && targetImage) {
+            try {
+                const { imageData, dimensions } = targetImage;
+                const [topLeftImageCoord, topRightImageCoord, bottomRightImageCoord, bottomLeftImageCoord,] = [
+                    imageData.indexToWorld([0, 0, 0]),
+                    imageData.indexToWorld([dimensions[0] - 1, 0, 0]),
+                    imageData.indexToWorld([
+                        dimensions[0] - 1,
+                        dimensions[1] - 1,
+                        0,
+                    ]),
+                    imageData.indexToWorld([0, dimensions[1] - 1, 0]),
+                ].map((world) => csUtils.worldToImageCoords(referencedImageId, world));
+                const [lineStartImageCoord, lineEndImageCoord] = [
+                    lineStartWorld,
+                    lineEndWorld,
+                ].map((world) => csUtils.worldToImageCoords(referencedImageId, world));
+                canvasCoordinates = [
+                    [topLeftImageCoord, topRightImageCoord],
+                    [topRightImageCoord, bottomRightImageCoord],
+                    [bottomLeftImageCoord, bottomRightImageCoord],
+                    [topLeftImageCoord, bottomLeftImageCoord],
+                ]
+                    .map(([start, end]) => this.intersectInfiniteLines(start, end, lineStartImageCoord, lineEndImageCoord))
+                    .filter((point) => point && this.isInBound(point, dimensions))
+                    .map((point) => {
+                    const world = csUtils.imageToWorldCoords(referencedImageId, point);
+                    return targetViewport.worldToCanvas(world);
+                });
+            }
+            catch (err) {
+                console.log(err);
+            }
+        }
+        return canvasCoordinates;
+    }
+    intersectInfiniteLines(line1Start, line1End, line2Start, line2End) {
+        const [x1, y1] = line1Start;
+        const [x2, y2] = line1End;
+        const [x3, y3] = line2Start;
+        const [x4, y4] = line2End;
+        const a1 = y2 - y1;
+        const b1 = x1 - x2;
+        const c1 = x2 * y1 - x1 * y2;
+        const a2 = y4 - y3;
+        const b2 = x3 - x4;
+        const c2 = x4 * y3 - x3 * y4;
+        if (Math.abs(a1 * b2 - a2 * b1) < EPSILON) {
+            return;
+        }
+        const x = (b1 * c2 - b2 * c1) / (a1 * b2 - a2 * b1);
+        const y = (a2 * c1 - a1 * c2) / (a1 * b2 - a2 * b1);
+        return [x, y];
+    }
     isParallel(vec1, vec2) {
         return Math.abs(vec3.dot(vec1, vec2)) > 1 - EPSILON;
     }
+    isInBound(point, dimensions) {
+        return (point[0] >= 0 &&
+            point[0] <= dimensions[0] &&
+            point[1] >= 0 &&
+            point[1] <= dimensions[1]);
+    }
 }
 ReferenceLines.toolName = 'ReferenceLines';
 export default ReferenceLines;
-//# sourceMappingURL=ReferenceLinesTool.js.map

package/dist/esm/tools/ScaleOverlayTool.js

@@ -65,7 +65,8 @@ class ScaleOverlayTool extends AnnotationDisplayTool {
                 addAnnotation(newAnnotation, viewport.element);
                 annotation = newAnnotation;
             }
-            else if (this.editData.annotation.data.viewportId == viewport.id) {
+            else if (this.editData.annotation &&
+                this.editData.annotation.data.viewportId == viewport.id) {
                 this.editData.annotation.data.handles.points =
                     viewportCanvasCornersInWorld;
                 this.editData.annotation.data.viewportId = viewport.id;
@@ -298,8 +299,8 @@ class ScaleOverlayTool extends AnnotationDisplayTool {
             viewportId: enabledElement.viewport.id,
         };
         const canvasSize = {
-            width: canvas.width,
-            height: canvas.height,
+            width: canvas.width / window.devicePixelRatio || 1,
+            height: canvas.height / window.devicePixelRatio || 1,
         };
         const topLeft = annotation.data.handles.points[0];
         const topRight = annotation.data.handles.points[1];
@@ -392,4 +393,3 @@ class ScaleOverlayTool extends AnnotationDisplayTool {
 }
 ScaleOverlayTool.toolName = 'ScaleOverlay';
 export default ScaleOverlayTool;
-//# sourceMappingURL=ScaleOverlayTool.js.map

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

@@ -0,0 +1,20 @@
+import type { Types } from '@cornerstonejs/core';
+import { ISculptToolShape } from '../../types/ISculptToolShape';
+import { SculptData } from '../SculptorTool';
+import { SVGDrawingHelper, EventTypes, ContourAnnotationData } from '../../types';
+export type PushedHandles = {
+    first?: number;
+    last?: number;
+};
+declare class CircleSculptCursor implements ISculptToolShape {
+    static shapeName: string;
+    private toolInfo;
+    renderShape(svgDrawingHelper: SVGDrawingHelper, canvasLocation: Types.Point2, options: any): 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;
+}
+export default CircleSculptCursor;

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

@@ -0,0 +1,107 @@
+import { getEnabledElement } from '@cornerstonejs/core';
+import { distancePointToContour } from '../distancePointToContour';
+import { drawCircle as drawCircleSvg } from '../../drawingSvg';
+import { point } from '../../utilities/math';
+class CircleSculptCursor {
+    constructor() {
+        this.toolInfo = {
+            toolSize: null,
+            maxToolSize: null,
+        };
+    }
+    static { this.shapeName = 'Circle'; }
+    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 };
+        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, distanceToHandle, sculptData);
+            if (pushedHandles.first === undefined) {
+                pushedHandles.first = i;
+                pushedHandles.last = i;
+            }
+            else {
+                pushedHandles.last = i;
+            }
+        }
+        return pushedHandles;
+    }
+    configureToolSize(evt) {
+        const toolInfo = this.toolInfo;
+        if (toolInfo.toolSize && toolInfo.maxToolSize) {
+            return;
+        }
+        const eventData = evt.detail;
+        const element = eventData.element;
+        const minDim = Math.min(element.clientWidth, element.clientHeight);
+        const maxRadius = minDim / 12;
+        toolInfo.toolSize = maxRadius;
+        toolInfo.maxToolSize = maxRadius;
+    }
+    updateToolSize(canvasCoords, viewport, activeAnnotation) {
+        const toolInfo = this.toolInfo;
+        const radius = distancePointToContour(viewport, activeAnnotation, canvasCoords);
+        if (radius > 0) {
+            toolInfo.toolSize = Math.min(toolInfo.maxToolSize, radius);
+        }
+    }
+    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,
+            ];
+        }
+        else {
+            insertPosition = midPoint;
+        }
+        const worldPosition = viewport.canvasToWorld(insertPosition);
+        return worldPosition;
+    }
+    pushOneHandle(i, distanceToHandle, sculptData) {
+        const { points, mousePoint } = sculptData;
+        const toolSize = this.toolInfo.toolSize;
+        const handle = points[i];
+        const directionUnitVector = {
+            x: (handle[0] - mousePoint[0]) / distanceToHandle,
+            y: (handle[1] - mousePoint[1]) / distanceToHandle,
+            z: (handle[2] - mousePoint[2]) / distanceToHandle,
+        };
+        const position = {
+            x: mousePoint[0] + toolSize * directionUnitVector.x,
+            y: mousePoint[1] + toolSize * directionUnitVector.y,
+            z: mousePoint[2] + toolSize * directionUnitVector.z,
+        };
+        handle[0] = position.x;
+        handle[1] = position.y;
+        handle[2] = position.z;
+    }
+}
+export default CircleSculptCursor;

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

@@ -0,0 +1,41 @@
+import type { Types } from '@cornerstonejs/core';
+import { BaseTool } from './base';
+import { EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
+import type { ISculptToolShape } from '../types/ISculptToolShape';
+export type SculptData = {
+    mousePoint: Types.Point3;
+    mouseCanvasPoint: Types.Point2;
+    points: Array<Types.Point3>;
+    maxSpacing: number;
+    element: HTMLDivElement;
+};
+declare class SculptorTool extends BaseTool {
+    static toolName: string;
+    registeredShapes: Map<any, any>;
+    private isActive;
+    private selectedShape;
+    private commonData;
+    private sculptData?;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    registerShapes<T extends ISculptToolShape>(shapeName: string, shapeClass: new () => T): void;
+    preMouseDownCallback: (evt: EventTypes.InteractionEventType) => boolean;
+    mouseMoveCallback: (evt: EventTypes.InteractionEventType) => void;
+    protected sculpt(eventData: any, points: Array<Types.Point3>): void;
+    protected interpolatePointsWithinMaxSpacing(i: number, points: Array<Types.Point3>, indicesToInsertAfter: Array<number>, maxSpacing: number): void;
+    private updateCursor;
+    private filterSculptableAnnotationsForElement;
+    private configureToolSize;
+    private insertNewHandles;
+    private findNewHandleIndices;
+    private insertHandleRadially;
+    private selectFreehandTool;
+    private getClosestFreehandToolOnElement;
+    private endCallback;
+    private dragCallback;
+    protected activateModify(element: HTMLDivElement): void;
+    protected deactivateModify(element: HTMLDivElement): void;
+    setToolShape(toolShape: string): void;
+    renderAnnotation(enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper): void;
+}
+export declare const contourIndex: (i: number, length: number) => number;
+export default SculptorTool;