@cornerstonejs/tools 3.19.4 → 3.20.0

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

@@ -12,6 +12,7 @@ declare enum Events {
     ANNOTATION_LOCK_CHANGE = "CORNERSTONE_TOOLS_ANNOTATION_LOCK_CHANGE",
     ANNOTATION_VISIBILITY_CHANGE = "CORNERSTONE_TOOLS_ANNOTATION_VISIBILITY_CHANGE",
     ANNOTATION_RENDERED = "CORNERSTONE_TOOLS_ANNOTATION_RENDERED",
+    ANNOTATION_CUT_MERGE_PROCESS_COMPLETED = "CORNERSTONE_TOOLS_ANNOTATION_CUT_MERGE_PROCESS_COMPLETED",
     ANNOTATION_INTERPOLATION_PROCESS_COMPLETED = "CORNERSTONE_TOOLS_ANNOTATION_INTERPOLATION_PROCESS_COMPLETED",
     INTERPOLATED_ANNOTATIONS_REMOVED = "CORNERSTONE_TOOLS_INTERPOLATED_ANNOTATIONS_REMOVED",
     SEGMENTATION_MODIFIED = "CORNERSTONE_TOOLS_SEGMENTATION_MODIFIED",

package/dist/esm/enums/Events.js

@@ -13,6 +13,7 @@ var Events;
     Events["ANNOTATION_LOCK_CHANGE"] = "CORNERSTONE_TOOLS_ANNOTATION_LOCK_CHANGE";
     Events["ANNOTATION_VISIBILITY_CHANGE"] = "CORNERSTONE_TOOLS_ANNOTATION_VISIBILITY_CHANGE";
     Events["ANNOTATION_RENDERED"] = "CORNERSTONE_TOOLS_ANNOTATION_RENDERED";
+    Events["ANNOTATION_CUT_MERGE_PROCESS_COMPLETED"] = "CORNERSTONE_TOOLS_ANNOTATION_CUT_MERGE_PROCESS_COMPLETED";
     Events["ANNOTATION_INTERPOLATION_PROCESS_COMPLETED"] = "CORNERSTONE_TOOLS_ANNOTATION_INTERPOLATION_PROCESS_COMPLETED";
     Events["INTERPOLATED_ANNOTATIONS_REMOVED"] = "CORNERSTONE_TOOLS_INTERPOLATED_ANNOTATIONS_REMOVED";
     Events["SEGMENTATION_MODIFIED"] = "CORNERSTONE_TOOLS_SEGMENTATION_MODIFIED";

package/dist/esm/eventListeners/annotations/contourSegmentation/contourSegmentationCompleted.js

@@ -1,3 +1,4 @@
+import { eventTarget, triggerEvent } from '@cornerstonejs/core';
 import getViewportsForAnnotation from '../../../utilities/getViewportsForAnnotation';
 import { getAllAnnotations } from '../../../stateManagement/annotation/annotationState';
 import { areSameSegment, isContourSegmentationAnnotation, } from '../../../utilities/contourSegmentation';
@@ -5,6 +6,7 @@ import { getToolGroupForViewport } from '../../../store/ToolGroupManager';
 import { findAllIntersectingContours } from '../../../utilities/contourSegmentation/getIntersectingAnnotations';
 import { processMultipleIntersections } from '../../../utilities/contourSegmentation/mergeMultipleAnnotations';
 import { convertContourPolylineToCanvasSpace, createPolylineHole, combinePolylines, } from '../../../utilities/contourSegmentation/sharedOperations';
+import { Events } from '../../../enums';
 const DEFAULT_CONTOUR_SEG_TOOL_NAME = 'PlanarFreehandContourSegmentationTool';
 export default async function contourSegmentationCompletedListener(evt) {
     const sourceAnnotation = evt.detail
@@ -15,11 +17,19 @@ export default async function contourSegmentationCompletedListener(evt) {
     const viewport = getViewport(sourceAnnotation);
     const contourSegmentationAnnotations = getValidContourSegmentationAnnotations(viewport, sourceAnnotation);
     if (!contourSegmentationAnnotations.length) {
+        triggerEvent(eventTarget, Events.ANNOTATION_CUT_MERGE_PROCESS_COMPLETED, {
+            element: viewport.element,
+            sourceAnnotation,
+        });
         return;
     }
     const sourcePolyline = convertContourPolylineToCanvasSpace(sourceAnnotation.data.contour.polyline, viewport);
     const intersectingContours = findAllIntersectingContours(viewport, sourcePolyline, contourSegmentationAnnotations);
     if (!intersectingContours.length) {
+        triggerEvent(eventTarget, Events.ANNOTATION_CUT_MERGE_PROCESS_COMPLETED, {
+            element: viewport.element,
+            sourceAnnotation,
+        });
         return;
     }
     if (intersectingContours.length > 1) {

package/dist/esm/tools/annotation/PlanarFreehandROITool.d.ts

@@ -35,7 +35,7 @@ declare class PlanarFreehandROITool extends ContourSegmentationBaseTool {
     protected renderAnnotationInstance(renderContext: AnnotationRenderContext): boolean;
     _calculateStatsIfActive(annotation: PlanarFreehandROIAnnotation, targetId: string, viewport: any, renderingEngine: any, enabledElement: any): void;
     private _calculateCachedStats;
-    protected updateClosedCachedStats({ viewport, points, imageData, metadata, cachedStats, targetId, modalityUnit, canvasCoordinates, calibratedScale, }: {
+    protected updateClosedCachedStats({ viewport, points, imageData, metadata, cachedStats, targetId, modalityUnit, canvasCoordinates, calibratedScale, deltaInX, deltaInY, }: {
         viewport: any;
         points: any;
         imageData: any;
@@ -45,14 +45,18 @@ declare class PlanarFreehandROITool extends ContourSegmentationBaseTool {
         modalityUnit: any;
         canvasCoordinates: any;
         calibratedScale: any;
+        deltaInX: any;
+        deltaInY: any;
     }): void;
-    protected updateOpenCachedStats({ targetId, metadata, canvasCoordinates, cachedStats, modalityUnit, calibratedScale, }: {
+    protected updateOpenCachedStats({ targetId, metadata, canvasCoordinates, cachedStats, modalityUnit, calibratedScale, deltaInX, deltaInY, }: {
         targetId: any;
         metadata: any;
         canvasCoordinates: any;
         cachedStats: any;
         modalityUnit: any;
         calibratedScale: any;
+        deltaInX: any;
+        deltaInY: any;
     }): void;
     private _renderStats;
 }

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

@@ -168,6 +168,18 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
                     const bottomRightBBIndex = csUtils.transformWorldToIndex(imageData, bottomRightBBWorld);
                     return [topLeftBBIndex, bottomRightBBIndex];
                 });
+                const canvasPoint = canvasCoordinates[0];
+                const originalWorldPoint = viewport.canvasToWorld(canvasPoint);
+                const deltaXPoint = viewport.canvasToWorld([
+                    canvasPoint[0] + 1,
+                    canvasPoint[1],
+                ]);
+                const deltaYPoint = viewport.canvasToWorld([
+                    canvasPoint[0],
+                    canvasPoint[1] + 1,
+                ]);
+                const deltaInX = vec3.distance(originalWorldPoint, deltaXPoint);
+                const deltaInY = vec3.distance(originalWorldPoint, deltaYPoint);
                 if (closed) {
                     this.updateClosedCachedStats({
                         targetId,
@@ -179,6 +191,8 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
                         cachedStats,
                         modalityUnit,
                         calibratedScale,
+                        deltaInX,
+                        deltaInY,
                     });
                 }
                 else {
@@ -189,6 +203,8 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
                         cachedStats,
                         modalityUnit,
                         calibratedScale,
+                        deltaInX,
+                        deltaInY,
                     });
                 }
             }
@@ -410,21 +426,9 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
             }
         }
     }
-    updateClosedCachedStats({ viewport, points, imageData, metadata, cachedStats, targetId, modalityUnit, canvasCoordinates, calibratedScale, }) {
+    updateClosedCachedStats({ viewport, points, imageData, metadata, cachedStats, targetId, modalityUnit, canvasCoordinates, calibratedScale, deltaInX, deltaInY, }) {
         const { scale, areaUnit, unit } = calibratedScale;
         const { voxelManager } = viewport.getImageData();
-        const canvasPoint = canvasCoordinates[0];
-        const originalWorldPoint = viewport.canvasToWorld(canvasPoint);
-        const deltaXPoint = viewport.canvasToWorld([
-            canvasPoint[0] + 1,
-            canvasPoint[1],
-        ]);
-        const deltaYPoint = viewport.canvasToWorld([
-            canvasPoint[0],
-            canvasPoint[1] + 1,
-        ]);
-        const deltaInX = vec3.distance(originalWorldPoint, deltaXPoint);
-        const deltaInY = vec3.distance(originalWorldPoint, deltaYPoint);
         const worldPosIndex = csUtils.transformWorldToIndex(imageData, points[0]);
         worldPosIndex[0] = Math.floor(worldPosIndex[0]);
         worldPosIndex[1] = Math.floor(worldPosIndex[1]);
@@ -453,6 +457,8 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
         worldPosIndex2[2] = Math.floor(worldPosIndex2[2]);
         let area = polyline.getArea(canvasCoordinates) / scale / scale;
         area *= deltaInX * deltaInY;
+        let perimeter = calculatePerimeter(canvasCoordinates, closed) / scale;
+        perimeter *= Math.sqrt(Math.pow(deltaInX, 2) + Math.pow(deltaInY, 2));
         const iDelta = 0.01 * (iMax - iMin);
         const jDelta = 0.01 * (jMax - jMin);
         const kDelta = 0.01 * (kMax - kMin);
@@ -510,7 +516,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
         cachedStats[targetId] = {
             Modality: metadata.Modality,
             area,
-            perimeter: calculatePerimeter(canvasCoordinates, closed) / scale,
+            perimeter,
             mean: stats.mean?.value,
             max: stats.max?.value,
             min: stats.min?.value,
@@ -522,11 +528,13 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
             unit,
         };
     }
-    updateOpenCachedStats({ targetId, metadata, canvasCoordinates, cachedStats, modalityUnit, calibratedScale, }) {
+    updateOpenCachedStats({ targetId, metadata, canvasCoordinates, cachedStats, modalityUnit, calibratedScale, deltaInX, deltaInY, }) {
         const { scale, unit } = calibratedScale;
+        let length = calculatePerimeter(canvasCoordinates, closed) / scale;
+        length *= Math.sqrt(Math.pow(deltaInX, 2) + Math.pow(deltaInY, 2));
         cachedStats[targetId] = {
             Modality: metadata.Modality,
-            length: calculatePerimeter(canvasCoordinates, false) / scale,
+            length,
             modalityUnit,
             unit,
         };

package/dist/esm/tools/annotation/SplineContourSegmentationTool.d.ts

@@ -2,7 +2,11 @@ import type { PublicToolProps } from '../../types';
 import SplineROITool from './SplineROITool';
 declare class SplineContourSegmentationTool extends SplineROITool {
     static toolName: string;
+    private annotationCutMergeCompletedBinded;
     constructor(toolProps: PublicToolProps);
     protected isContourSegmentationTool(): boolean;
+    protected initializeListeners(): void;
+    protected removeListeners(): void;
+    protected annotationCutMergeCompleted(evt: any): void;
 }
 export default SplineContourSegmentationTool;

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

@@ -1,5 +1,7 @@
-import { utilities } from '@cornerstonejs/core';
+import { eventTarget, utilities } from '@cornerstonejs/core';
 import SplineROITool from './SplineROITool';
+import { Events } from '../../enums';
+import { convertContourSegmentationAnnotation } from '../../utilities/contourSegmentation';
 class SplineContourSegmentationTool extends SplineROITool {
     static { this.toolName = 'SplineContourSegmentationTool'; }
     constructor(toolProps) {
@@ -9,9 +11,25 @@ class SplineContourSegmentationTool extends SplineROITool {
             },
         }, toolProps);
         super(initialProps);
+        this.annotationCutMergeCompletedBinded =
+            this.annotationCutMergeCompleted.bind(this);
     }
     isContourSegmentationTool() {
         return true;
     }
+    initializeListeners() {
+        eventTarget.addEventListener(Events.ANNOTATION_CUT_MERGE_PROCESS_COMPLETED, this.annotationCutMergeCompletedBinded);
+    }
+    removeListeners() {
+        eventTarget.removeEventListener(Events.ANNOTATION_CUT_MERGE_PROCESS_COMPLETED, this.annotationCutMergeCompletedBinded);
+    }
+    annotationCutMergeCompleted(evt) {
+        const { sourceAnnotation: annotation } = evt.detail;
+        if (!this.splineToolNames.includes(annotation?.metadata?.toolName) ||
+            !this.configuration.simplifiedSpline) {
+            return;
+        }
+        convertContourSegmentationAnnotation(annotation);
+    }
 }
 export default SplineContourSegmentationTool;

package/dist/esm/tools/annotation/SplineROITool.d.ts

@@ -15,8 +15,10 @@ declare enum SplineToolActions {
 }
 declare class SplineROITool extends ContourSegmentationBaseTool {
     static toolName: string;
+    protected splineToolNames: string[];
     static SplineTypes: typeof SplineTypesEnum;
     static Actions: typeof SplineToolActions;
+    private annotationCompletedBinded;
     _throttledCalculateCachedStats: Function;
     editData: {
         annotation: SplineROIAnnotation;
@@ -36,6 +38,12 @@ declare class SplineROITool extends ContourSegmentationBaseTool {
         contourHoleProcessingEnabled: boolean;
     };
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    protected annotationCompleted(evt: any): void;
+    protected initializeListeners(): void;
+    protected removeListeners(): void;
+    onSetToolEnabled(): void;
+    onSetToolActive(): void;
+    onSetToolDisabled(): void;
     addNewAnnotation(evt: EventTypes.InteractionEventType): SplineROIAnnotation;
     isPointNearTool: (element: HTMLDivElement, annotation: SplineROIAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;
     toolSelectedCallback: (evt: EventTypes.InteractionEventType, annotation: SplineROIAnnotation) => void;

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

@@ -18,6 +18,7 @@ import { CatmullRomSpline } from './splines/CatmullRomSpline';
 import { BSpline } from './splines/BSpline';
 import ContourSegmentationBaseTool from '../base/ContourSegmentationBaseTool';
 import { triggerAnnotationRenderForViewportIds } from '../../utilities';
+import { convertContourSegmentationAnnotation } from '../../utilities/contourSegmentation';
 const SPLINE_MIN_POINTS = 3;
 const SPLINE_CLICK_CLOSE_CURVE_DIST = 10;
 const DEFAULT_SPLINE_CONFIG = {
@@ -49,6 +50,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
         configuration: {
             preventHandleOutsideImage: false,
             calculateStats: true,
+            simplifiedSpline: false,
             getTextLines: defaultGetTextLines,
             contourHoleAdditionModifierKey: KeyboardBindings.Shift,
             decimate: {
@@ -101,6 +103,12 @@ class SplineROITool extends ContourSegmentationBaseTool {
         },
     }) {
         super(toolProps, defaultToolProps);
+        this.splineToolNames = [
+            'CatmullRomSplineROI',
+            'LinearSplineROI',
+            'BSplineROI',
+            'CardinalSplineROI',
+        ];
         this.isHandleOutsideImage = false;
         this.fireChangeOnUpdate = null;
         this.isPointNearTool = (element, annotation, canvasCoords, proximity) => {
@@ -487,6 +495,31 @@ class SplineROITool extends ContourSegmentationBaseTool {
             return cachedStats;
         };
         this._throttledCalculateCachedStats = throttle(this._calculateCachedStats, 100, { trailing: true });
+        this.annotationCompletedBinded = this.annotationCompleted.bind(this);
+    }
+    annotationCompleted(evt) {
+        const { sourceAnnotation: annotation } = evt.detail;
+        if (!this.splineToolNames.includes(annotation?.metadata?.toolName) ||
+            !this.configuration.simplifiedSpline ||
+            !this.isContourSegmentationTool()) {
+            return;
+        }
+        convertContourSegmentationAnnotation(annotation);
+    }
+    initializeListeners() {
+        eventTarget.addEventListener(Events.ANNOTATION_COMPLETED, this.annotationCompletedBinded);
+    }
+    removeListeners() {
+        eventTarget.removeEventListener(Events.ANNOTATION_COMPLETED, this.annotationCompletedBinded);
+    }
+    onSetToolEnabled() {
+        this.initializeListeners();
+    }
+    onSetToolActive() {
+        this.initializeListeners();
+    }
+    onSetToolDisabled() {
+        this.removeListeners();
     }
     addNewAnnotation(evt) {
         const eventDetail = evt.detail;

package/dist/esm/utilities/contourSegmentation/convertContourSegmentation.d.ts

@@ -0,0 +1,2 @@
+import type { ContourSegmentationAnnotation } from '../../types';
+export default function convertContourSegmentationAnnotation(annotation: ContourSegmentationAnnotation): ContourSegmentationAnnotation;

package/dist/esm/utilities/contourSegmentation/convertContourSegmentation.js

@@ -0,0 +1,49 @@
+import { utilities } from '@cornerstonejs/core';
+import { addAnnotation, removeAnnotation } from '../../stateManagement';
+import { removeContourSegmentationAnnotation } from './removeContourSegmentationAnnotation';
+import { addContourSegmentationAnnotation } from './addContourSegmentationAnnotation';
+const DEFAULT_CONTOUR_SEG_TOOL_NAME = 'PlanarFreehandContourSegmentationTool';
+export default function convertContourSegmentationAnnotation(annotation) {
+    const { polyline } = annotation.data?.contour || {};
+    if (!polyline || polyline.length < 3) {
+        console.warn('Skipping creation of new annotation due to invalid polyline:', polyline);
+        return;
+    }
+    removeAnnotation(annotation.annotationUID);
+    removeContourSegmentationAnnotation(annotation);
+    const startPointWorld = polyline[0];
+    const endPointWorld = polyline[polyline.length - 1];
+    const newAnnotation = {
+        metadata: {
+            ...annotation.metadata,
+            toolName: DEFAULT_CONTOUR_SEG_TOOL_NAME,
+            originalToolName: annotation.metadata.originalToolName || annotation.metadata.toolName,
+        },
+        data: {
+            cachedStats: {},
+            handles: {
+                points: [startPointWorld, endPointWorld],
+                textBox: annotation.data.handles.textBox
+                    ? { ...annotation.data.handles.textBox }
+                    : undefined,
+            },
+            contour: {
+                ...annotation.data.contour,
+            },
+            spline: annotation.data.spline,
+            segmentation: {
+                ...annotation.data.segmentation,
+            },
+        },
+        annotationUID: utilities.uuidv4(),
+        highlighted: true,
+        invalidated: true,
+        isLocked: false,
+        isVisible: undefined,
+        interpolationUID: annotation.interpolationUID,
+        interpolationCompleted: annotation.interpolationCompleted,
+    };
+    addAnnotation(newAnnotation, annotation.metadata.FrameOfReferenceUID);
+    addContourSegmentationAnnotation(newAnnotation);
+    return newAnnotation;
+}

package/dist/esm/utilities/contourSegmentation/index.d.ts

@@ -1,4 +1,5 @@
 import areSameSegment from './areSameSegment';
+import convertContourSegmentationAnnotation from './convertContourSegmentation';
 import { addition, subtraction } from './logicalOperators';
 export { default as isContourSegmentationAnnotation } from './isContourSegmentationAnnotation';
 export { addContourSegmentationAnnotation } from './addContourSegmentationAnnotation';
@@ -7,5 +8,5 @@ export { findAllIntersectingContours } from './getIntersectingAnnotations';
 export { processMultipleIntersections } from './mergeMultipleAnnotations';
 export { contourSegmentationOperation } from './contourSegmentationOperation';
 export * from './sharedOperations';
-export { addition, subtraction, areSameSegment };
+export { addition, subtraction, areSameSegment, convertContourSegmentationAnnotation, };
 export { unifyPolylineSets, unifyMultiplePolylineSets, unifyAnnotationPolylines, subtractPolylineSets, subtractMultiplePolylineSets, subtractAnnotationPolylines, } from './unifyPolylineSets';

package/dist/esm/utilities/contourSegmentation/index.js

@@ -1,4 +1,5 @@
 import areSameSegment from './areSameSegment';
+import convertContourSegmentationAnnotation from './convertContourSegmentation';
 import { addition, subtraction } from './logicalOperators';
 export { default as isContourSegmentationAnnotation } from './isContourSegmentationAnnotation';
 export { addContourSegmentationAnnotation } from './addContourSegmentationAnnotation';
@@ -7,5 +8,5 @@ export { findAllIntersectingContours } from './getIntersectingAnnotations';
 export { processMultipleIntersections } from './mergeMultipleAnnotations';
 export { contourSegmentationOperation } from './contourSegmentationOperation';
 export * from './sharedOperations';
-export { addition, subtraction, areSameSegment };
+export { addition, subtraction, areSameSegment, convertContourSegmentationAnnotation, };
 export { unifyPolylineSets, unifyMultiplePolylineSets, unifyAnnotationPolylines, subtractPolylineSets, subtractMultiplePolylineSets, subtractAnnotationPolylines, } from './unifyPolylineSets';

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "3.19.4";
+export declare const version = "3.20.0";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '3.19.4';
+export const version = '3.20.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "3.19.4",
+  "version": "3.20.0",
   "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.19.4",
+    "@cornerstonejs/core": "^3.20.0",
     "@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": "dd5d1bd7024e51dcfa9811554f9e7c2d2ae4c90a"
+  "gitHead": "85e1da960eb87095a984c3a4a26a979a4ae5ffd4"
 }