@cornerstonejs/tools 3.6.1 → 3.7.1

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

@@ -19,6 +19,10 @@ declare class AngleTool extends AnnotationTool {
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     static hydrate: (viewportId: string, points: Types.Point3[], options?: {
         annotationUID?: string;
+        toolInstance?: AngleTool;
+        referencedImageId?: string;
+        viewplaneNormal?: Types.Point3;
+        viewUp?: Types.Point3;
     }) => AngleAnnotation;
     addNewAnnotation: (evt: EventTypes.InteractionEventType) => AngleAnnotation;
     isPointNearTool: (element: HTMLDivElement, annotation: AngleAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;

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

@@ -390,11 +390,7 @@ class AngleTool extends AnnotationTool {
         if (!enabledElement) {
             return;
         }
-        const { viewport } = enabledElement;
-        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const { viewPlaneNormal, viewUp } = viewport.getCamera();
-        const instance = new this();
-        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = this.hydrateBase(AngleTool, enabledElement, points, options);
         const annotation = {
             annotationUID: options?.annotationUID || csUtils.uuidv4(),
             data: {

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

@@ -18,6 +18,10 @@ declare class ArrowAnnotateTool extends AnnotationTool {
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     static hydrate: (viewportId: string, points: Types.Point3[], text?: string, options?: {
         annotationUID?: string;
+        toolInstance?: ArrowAnnotateTool;
+        referencedImageId?: string;
+        viewplaneNormal?: Types.Point3;
+        viewUp?: Types.Point3;
     }) => ArrowAnnotation;
     addNewAnnotation: (evt: EventTypes.InteractionEventType) => ArrowAnnotation;
     isPointNearTool: (element: HTMLDivElement, annotation: ArrowAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;

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

@@ -392,11 +392,7 @@ class ArrowAnnotateTool extends AnnotationTool {
         if (!enabledElement) {
             return;
         }
-        const { viewport } = enabledElement;
-        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const { viewPlaneNormal, viewUp } = viewport.getCamera();
-        const instance = new this();
-        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = this.hydrateBase(ArrowAnnotateTool, enabledElement, points, options);
         const annotation = {
             annotationUID: options?.annotationUID || csUtils.uuidv4(),
             data: {

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

@@ -20,6 +20,10 @@ declare class BidirectionalTool extends AnnotationTool {
     addNewAnnotation(evt: EventTypes.InteractionEventType): BidirectionalAnnotation;
     static hydrate: (viewportId: string, axis: [[Types.Point3, Types.Point3], [Types.Point3, Types.Point3]], options?: {
         annotationUID?: string;
+        toolInstance?: BidirectionalTool;
+        referencedImageId?: string;
+        viewplaneNormal?: Types.Point3;
+        viewUp?: Types.Point3;
     }) => BidirectionalAnnotation;
     isPointNearTool: (element: HTMLDivElement, annotation: BidirectionalAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;
     toolSelectedCallback: (evt: EventTypes.InteractionEventType, annotation: BidirectionalAnnotation) => void;

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

@@ -714,22 +714,29 @@ class BidirectionalTool extends AnnotationTool {
         if (!enabledElement) {
             return;
         }
-        const { viewport } = enabledElement;
-        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const { viewPlaneNormal, viewUp } = viewport.getCamera();
-        const instance = new this();
+        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = this.hydrateBase(BidirectionalTool, enabledElement, [], options);
         const [majorAxis, minorAxis] = axis;
         const [major0, major1] = majorAxis;
         const [minor0, minor1] = minorAxis;
         const points = [major0, major1, minor0, minor1];
-        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
         const annotation = {
             annotationUID: options?.annotationUID || utilities.uuidv4(),
             data: {
                 handles: {
                     points,
                     activeHandleIndex: null,
+                    textBox: {
+                        hasMoved: false,
+                        worldPosition: [0, 0, 0],
+                        worldBoundingBox: {
+                            topLeft: [0, 0, 0],
+                            topRight: [0, 0, 0],
+                            bottomLeft: [0, 0, 0],
+                            bottomRight: [0, 0, 0],
+                        },
+                    },
                 },
+                cachedStats: {},
             },
             highlighted: false,
             autoGenerated: false,
@@ -746,6 +753,7 @@ class BidirectionalTool extends AnnotationTool {
         };
         addAnnotation(annotation, viewport.element);
         triggerAnnotationRenderForViewportIds([viewport.id]);
+        return annotation;
     }; }
     _calculateLength(pos1, pos2) {
         const dx = pos1[0] - pos2[0];

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

@@ -34,6 +34,10 @@ declare class CircleROITool extends AnnotationTool {
     _isInsideVolume: (index1: any, index2: any, dimensions: any) => boolean;
     static hydrate: (viewportId: string, points: Types.Point3[], options?: {
         annotationUID?: string;
+        toolInstance?: CircleROITool;
+        referencedImageId?: string;
+        viewplaneNormal?: Types.Point3;
+        viewUp?: Types.Point3;
     }) => CircleROIAnnotation;
 }
 export default CircleROITool;

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

@@ -570,11 +570,7 @@ class CircleROITool extends AnnotationTool {
         if (!enabledElement) {
             return;
         }
-        const { viewport } = enabledElement;
-        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const { viewPlaneNormal, viewUp } = viewport.getCamera();
-        const instance = new this();
-        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = this.hydrateBase(CircleROITool, enabledElement, points, options);
         const annotation = {
             annotationUID: options?.annotationUID || csUtils.uuidv4(),
             data: {

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

@@ -22,6 +22,10 @@ declare class EllipticalROITool extends AnnotationTool {
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     static hydrate: (viewportId: string, points: Types.Point3[], options?: {
         annotationUID?: string;
+        toolInstance?: EllipticalROITool;
+        referencedImageId?: string;
+        viewplaneNormal?: Types.Point3;
+        viewUp?: Types.Point3;
     }) => EllipticalROIAnnotation;
     addNewAnnotation: (evt: EventTypes.InteractionEventType) => EllipticalROIAnnotation;
     isPointNearTool: (element: HTMLDivElement, annotation: EllipticalROIAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;

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

@@ -636,11 +636,7 @@ class EllipticalROITool extends AnnotationTool {
         if (!enabledElement) {
             return;
         }
-        const { viewport } = enabledElement;
-        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const { viewPlaneNormal, viewUp } = viewport.getCamera();
-        const instance = new this();
-        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = this.hydrateBase(EllipticalROITool, enabledElement, points, options);
         const annotation = {
             annotationUID: options?.annotationUID || csUtils.uuidv4(),
             data: {

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

@@ -18,6 +18,10 @@ declare class LengthTool extends AnnotationTool {
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     static hydrate: (viewportId: string, points: Types.Point3[], options?: {
         annotationUID?: string;
+        toolInstance?: LengthTool;
+        referencedImageId?: string;
+        viewplaneNormal?: Types.Point3;
+        viewUp?: Types.Point3;
     }) => LengthAnnotation;
     addNewAnnotation: (evt: EventTypes.InteractionEventType) => LengthAnnotation;
     isPointNearTool: (element: HTMLDivElement, annotation: LengthAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;

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

@@ -361,11 +361,7 @@ class LengthTool extends AnnotationTool {
         if (!enabledElement) {
             return;
         }
-        const { viewport } = enabledElement;
-        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const { viewPlaneNormal, viewUp } = viewport.getCamera();
-        const instance = new this();
-        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = this.hydrateBase(LengthTool, enabledElement, points, options);
         const annotation = {
             annotationUID: options?.annotationUID || utilities.uuidv4(),
             data: {

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

@@ -19,6 +19,10 @@ declare class ProbeTool extends AnnotationTool {
     toolSelectedCallback(): void;
     static hydrate: (viewportId: string, points: Types.Point3[], options?: {
         annotationUID?: string;
+        toolInstance?: ProbeTool;
+        referencedImageId?: string;
+        viewplaneNormal?: Types.Point3;
+        viewUp?: Types.Point3;
     }) => ProbeAnnotation;
     addNewAnnotation: (evt: EventTypes.InteractionEventType) => ProbeAnnotation;
     getHandleNearImagePoint(element: HTMLDivElement, annotation: ProbeAnnotation, canvasCoords: Types.Point2, proximity: number): ToolHandle | undefined;

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

@@ -224,11 +224,7 @@ class ProbeTool extends AnnotationTool {
         if (!enabledElement) {
             return;
         }
-        const { viewport } = enabledElement;
-        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const { viewPlaneNormal, viewUp } = viewport.getCamera();
-        const instance = new this();
-        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, viewUp, instance, viewport, } = this.hydrateBase(ProbeTool, enabledElement, points, options);
         const annotation = {
             annotationUID: options?.annotationUID || csUtils.uuidv4(),
             data: {

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

@@ -38,6 +38,10 @@ declare class RectangleROITool extends AnnotationTool {
     _isInsideVolume: (index1: any, index2: any, dimensions: any) => boolean;
     static hydrate: (viewportId: string, points: Types.Point3[], options?: {
         annotationUID?: string;
+        toolInstance?: RectangleROITool;
+        referencedImageId?: string;
+        viewplaneNormal?: Types.Point3;
+        viewUp?: Types.Point3;
     }) => RectangleROIAnnotation;
 }
 export default RectangleROITool;

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

@@ -521,11 +521,7 @@ class RectangleROITool extends AnnotationTool {
         if (!enabledElement) {
             return;
         }
-        const { viewport } = enabledElement;
-        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const { viewPlaneNormal, viewUp } = viewport.getCamera();
-        const instance = new this();
-        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = this.hydrateBase(RectangleROITool, enabledElement, points, options);
         const annotation = {
             annotationUID: options?.annotationUID || csUtils.uuidv4(),
             data: {

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

@@ -68,6 +68,10 @@ declare class SplineROITool extends ContourSegmentationBaseTool {
     static hydrate: (viewportId: string, points: Types.Point3[], options?: {
         annotationUID?: string;
         splineType?: SplineTypesEnum;
+        toolInstance?: SplineROITool;
+        referencedImageId?: string;
+        viewplaneNormal?: Types.Point3;
+        viewUp?: Types.Point3;
     }) => SplineROIAnnotation;
 }
 export default SplineROITool;

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

@@ -726,19 +726,11 @@ class SplineROITool extends ContourSegmentationBaseTool {
             console.warn('Spline requires at least 3 control points');
             return;
         }
-        const { viewport } = enabledElement;
-        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const { viewPlaneNormal, viewUp } = viewport.getCamera();
-        const instance = new this();
-        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, viewUp, instance, viewport, } = this.hydrateBase(SplineROITool, enabledElement, points, options);
         const splineType = options?.splineType || SplineTypesEnum.CatmullRom;
         const splineConfig = instance._getSplineConfig(splineType);
         const SplineClass = splineConfig.Class;
         const splineInstance = new SplineClass();
-        const canvasPoints = points.map((point) => viewport.worldToCanvas(point));
-        splineInstance.setControlPoints(canvasPoints);
-        const splinePolylineCanvas = splineInstance.getPolylinePoints();
-        const splinePolylineWorld = splinePolylineCanvas.map((point) => viewport.canvasToWorld(point));
         const annotation = {
             annotationUID: options?.annotationUID || utilities.uuidv4(),
             data: {
@@ -753,7 +745,6 @@ class SplineROITool extends ContourSegmentationBaseTool {
                 },
                 contour: {
                     closed: true,
-                    polyline: splinePolylineWorld,
                 },
             },
             highlighted: false,

package/dist/esm/tools/base/AnnotationTool.d.ts

@@ -1,3 +1,4 @@
+import { StackViewport } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 import AnnotationDisplayTool from './AnnotationDisplayTool';
 import type { Annotation, Annotations, EventTypes, ToolHandle, InteractionTypes, ToolProps, PublicToolProps } from '../../types';
@@ -54,5 +55,19 @@ declare abstract class AnnotationTool extends AnnotationDisplayTool {
         restoreMemo: () => void;
     };
     protected createMemo(element: any, annotation: any, options?: any): void;
+    protected static hydrateBase<T extends AnnotationTool>(ToolClass: new () => T, enabledElement: Types.IEnabledElement, points: Types.Point3[], options?: {
+        annotationUID?: string;
+        toolInstance?: T;
+        referencedImageId?: string;
+        viewplaneNormal?: Types.Point3;
+        viewUp?: Types.Point3;
+    }): {
+        FrameOfReferenceUID: string;
+        referencedImageId: any;
+        viewPlaneNormal: Types.Point3;
+        viewUp: Types.Point3;
+        instance: T;
+        viewport: StackViewport | import("@cornerstonejs/core").VolumeViewport;
+    };
 }
 export default AnnotationTool;

package/dist/esm/tools/base/AnnotationTool.js

@@ -1,4 +1,4 @@
-import { BaseVolumeViewport, cache, getEnabledElement, metaData, utilities as csUtils, } from '@cornerstonejs/core';
+import { BaseVolumeViewport, cache, getEnabledElement, metaData, utilities as csUtils, StackViewport, } from '@cornerstonejs/core';
 import { vec2 } from 'gl-matrix';
 import AnnotationDisplayTool from './AnnotationDisplayTool';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
@@ -266,6 +266,47 @@ class AnnotationTool extends AnnotationDisplayTool {
     createMemo(element, annotation, options) {
         this.memo ||= AnnotationTool.createAnnotationMemo(element, annotation, options);
     }
+    static hydrateBase(ToolClass, enabledElement, points, options = {}) {
+        if (!enabledElement) {
+            return null;
+        }
+        const { viewport } = enabledElement;
+        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+        const camera = viewport.getCamera();
+        const viewPlaneNormal = options.viewplaneNormal ?? camera.viewPlaneNormal;
+        const viewUp = options.viewUp ?? camera.viewUp;
+        const instance = options.toolInstance || new ToolClass();
+        let referencedImageId;
+        let finalViewPlaneNormal = viewPlaneNormal;
+        let finalViewUp = viewUp;
+        if (options.referencedImageId) {
+            referencedImageId = options.referencedImageId;
+            finalViewPlaneNormal = undefined;
+            finalViewUp = undefined;
+        }
+        else {
+            if (viewport instanceof StackViewport) {
+                const closestImageIndex = csUtils.getClosestStackImageIndexForPoint(points[0], viewport);
+                if (closestImageIndex) {
+                    referencedImageId = viewport.getImageIds()[closestImageIndex];
+                }
+            }
+            else if (viewport instanceof BaseVolumeViewport) {
+                referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+            }
+            else {
+                throw new Error('Unsupported viewport type');
+            }
+        }
+        return {
+            FrameOfReferenceUID,
+            referencedImageId,
+            viewPlaneNormal: finalViewPlaneNormal,
+            viewUp: finalViewUp,
+            instance,
+            viewport,
+        };
+    }
 }
 AnnotationTool.toolName = 'AnnotationTool';
 export default AnnotationTool;

package/dist/esm/tools/segmentation/SegmentBidirectionalTool.d.ts

@@ -21,6 +21,10 @@ declare class SegmentBidirectionalTool extends BidirectionalTool {
         segmentIndex?: number;
         segmentationId?: string;
         annotationUID?: string;
+        toolInstance?: SegmentBidirectionalTool;
+        referencedImageId?: string;
+        viewplaneNormal?: Types.Point3;
+        viewUp?: Types.Point3;
     }) => SegmentBidirectionalAnnotation;
     renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
 }

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

@@ -201,8 +201,6 @@ class SegmentBidirectionalTool extends BidirectionalTool {
             return;
         }
         const { viewport } = enabledElement;
-        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const { viewPlaneNormal, viewUp } = viewport.getCamera();
         const existingAnnotations = getAllAnnotations();
         const toolAnnotations = existingAnnotations.filter((annotation) => annotation.metadata.toolName === 'SegmentBidirectional');
         const existingAnnotation = toolAnnotations.find((annotation) => {
@@ -216,19 +214,29 @@ class SegmentBidirectionalTool extends BidirectionalTool {
         if (existingAnnotation) {
             removeAnnotation(existingAnnotation.annotationUID);
         }
-        const instance = new this();
+        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, } = this.hydrateBase(SegmentBidirectionalTool, enabledElement, axis[0], options);
         const [majorAxis, minorAxis] = axis;
         const [major0, major1] = majorAxis;
         const [minor0, minor1] = minorAxis;
         const points = [major0, major1, minor0, minor1];
-        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
         const annotation = {
             annotationUID: options?.annotationUID || utilities.uuidv4(),
             data: {
                 handles: {
                     points,
                     activeHandleIndex: null,
+                    textBox: {
+                        hasMoved: false,
+                        worldPosition: [0, 0, 0],
+                        worldBoundingBox: {
+                            topLeft: [0, 0, 0],
+                            topRight: [0, 0, 0],
+                            bottomLeft: [0, 0, 0],
+                            bottomRight: [0, 0, 0],
+                        },
+                    },
                 },
+                cachedStats: {},
             },
             highlighted: false,
             autoGenerated: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "3.6.1",
+  "version": "3.7.1",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -103,7 +103,7 @@
     "canvas": "^2.11.2"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^3.6.1",
+    "@cornerstonejs/core": "^3.7.1",
     "@kitware/vtk.js": "32.12.1",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
@@ -122,5 +122,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "a262fd519f1ceabe2e1d1d01a382087920657f65"
+  "gitHead": "a4fe414ad0c938b9f842127dea4b0d12e334ac25"
 }