@cornerstonejs/tools 4.12.3 → 4.12.5

package/dist/esm/enums/MeasurementType.d.ts

@@ -0,0 +1,6 @@
+export declare enum MeasurementType {
+    Linear = "Linear",
+    Area = "Area",
+    Volume = "Volume",
+    Pixel = "Pixel"
+}

package/dist/esm/enums/MeasurementType.js

@@ -0,0 +1,7 @@
+export var MeasurementType;
+(function (MeasurementType) {
+    MeasurementType["Linear"] = "Linear";
+    MeasurementType["Area"] = "Area";
+    MeasurementType["Volume"] = "Volume";
+    MeasurementType["Pixel"] = "Pixel";
+})(MeasurementType || (MeasurementType = {}));

package/dist/esm/enums/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./MeasurementType";
 import { MouseBindings } from './ToolBindings';
 import { KeyboardBindings } from './ToolBindings';
 import ToolModes from './ToolModes';

package/dist/esm/enums/index.js

@@ -7,4 +7,5 @@ import { Swipe } from './Touch';
 import StrategyCallbacks from './StrategyCallbacks';
 import ChangeTypes from './ChangeTypes';
 import WorkerTypes from './WorkerTypes';
+export * from './MeasurementType';
 export { MouseBindings, KeyboardBindings, ToolModes, AnnotationStyleStates, Events, SegmentationRepresentations, Swipe, StrategyCallbacks, ChangeTypes, WorkerTypes, };

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;