@cornerstonejs/tools 3.16.1 → 3.16.2

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

@@ -8,6 +8,9 @@ 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;
@@ -16,5 +19,8 @@ declare class CircleSculptCursor implements ISculptToolShape {
     getMaxSpacing(minSpacing: number): number;
     getInsertPosition(previousIndex: number, nextIndex: number, sculptData: SculptData): Types.Point3;
     private pushOneHandle;
+    private directionalVector;
+    private calculateMeanConsecutiveDistance;
+    private maintainChainStructure;
 }
 export default CircleSculptCursor;

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

@@ -1,3 +1,4 @@
+import { vec3 } from 'gl-matrix';
 import { getEnabledElement } from '@cornerstonejs/core';
 import { distancePointToContour } from '../distancePointToContour';
 import { drawCircle as drawCircleSvg } from '../../drawingSvg';
@@ -10,6 +11,9 @@ class CircleSculptCursor {
         };
     }
     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);
@@ -17,13 +21,17 @@ class CircleSculptCursor {
     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, distanceToHandle, sculptData);
+            this.pushOneHandle(i, worldRadius, sculptData);
             if (pushedHandles.first === undefined) {
                 pushedHandles.first = i;
                 pushedHandles.last = i;
@@ -32,6 +40,11 @@ class CircleSculptCursor {
                 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) {
@@ -85,23 +98,80 @@ class CircleSculptCursor {
         const worldPosition = viewport.canvasToWorld(insertPosition);
         return worldPosition;
     }
-    pushOneHandle(i, distanceToHandle, sculptData) {
+    pushOneHandle(i, worldRadius, 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;
+        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];
+    }
+    directionalVector(p1, p2) {
+        return vec3.normalize(vec3.create(), [
+            p2[0] - p1[0],
+            p2[1] - p1[1],
+            p2[2] - p1[2],
+        ]);
+    }
+    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;
+            }
+        }
     }
 }
 export default CircleSculptCursor;

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

@@ -4,9 +4,11 @@ import type { EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper } from '.
 import type { ISculptToolShape } from '../types/ISculptToolShape';
 export type SculptData = {
     mousePoint: Types.Point3;
+    deltaWorld: Types.Point3;
     mouseCanvasPoint: Types.Point2;
     points: Array<Types.Point3>;
     maxSpacing: number;
+    meanDistance?: number;
     element: HTMLDivElement;
 };
 declare class SculptorTool extends BaseTool {

package/dist/esm/tools/SculptorTool.js

@@ -21,6 +21,7 @@ class SculptorTool extends BaseTool {
             ],
             toolShape: 'circle',
             referencedToolName: 'PlanarFreehandROI',
+            updateCursorSize: 'dynamic',
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -100,6 +101,7 @@ 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,
@@ -139,7 +141,9 @@ class SculptorTool extends BaseTool {
         else {
             const cursorShape = this.registeredShapes.get(this.selectedShape);
             const canvasCoords = eventData.currentPoints.canvas;
-            cursorShape.updateToolSize(canvasCoords, viewport, activeAnnotation);
+            if (this.configuration.updateCursorSize === 'dynamic') {
+                cursorShape.updateToolSize(canvasCoords, viewport, activeAnnotation);
+            }
         }
         triggerAnnotationRenderForViewportIds(this.commonData.viewportIdsToRender);
     }

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "3.16.1";
+export declare const version = "3.16.2";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '3.16.1';
+export const version = '3.16.2';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "3.16.1",
+  "version": "3.16.2",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -108,7 +108,7 @@
     "canvas": "^3.1.0"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^3.16.1",
+    "@cornerstonejs/core": "^3.16.2",
     "@kitware/vtk.js": "32.12.1",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
@@ -127,5 +127,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "50d792050fd2cab62160c80568daf2949c3fa868"
+  "gitHead": "575c73857dd19b22980ad035c014072e0156ddd0"
 }