@cornerstonejs/tools 4.13.5 → 4.13.7

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

@@ -68,6 +68,10 @@ declare class AdvancedMagnifyTool extends AnnotationTool {
     renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
     showZoomFactorsList(evt: EventTypes.InteractionEventType, annotation: AdvancedMagnifyAnnotation): void;
     private _getZoomFactorsListDropdown;
+    private _getWorldHandlePoints;
+    private _getCanvasCircleData;
+    private _getWorldDeltaFromCanvasDelta;
+    private _applyWorldDelta;
     private _getCanvasHandlePoints;
 }
 declare class AdvancedMagnifyViewport {

package/dist/esm/tools/AdvancedMagnifyTool.js

@@ -64,7 +64,7 @@ class AdvancedMagnifyTool extends AnnotationTool {
             const canvasPos = currentPoints.canvas;
             const { magnifyingGlass: config } = this.configuration;
             const { radius, zoomFactor, autoPan } = config;
-            const canvasHandlePoints = this._getCanvasHandlePoints(canvasPos, radius);
+            const worldHandlePoints = this._getWorldHandlePoints(viewport, canvasPos, radius);
             const camera = viewport.getCamera();
             const { viewPlaneNormal, viewUp } = camera;
             const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
@@ -86,9 +86,9 @@ class AdvancedMagnifyTool extends AnnotationTool {
                     sourceViewportId: viewport.id,
                     magnifyViewportId,
                     zoomFactor,
-                    isCanvasAnnotation: true,
+                    isCanvasAnnotation: false,
                     handles: {
-                        points: canvasHandlePoints,
+                        points: worldHandlePoints,
                         activeHandleIndex: null,
                     },
                 },
@@ -104,13 +104,14 @@ class AdvancedMagnifyTool extends AnnotationTool {
                     padding: autoPan.padding,
                     callback: (data) => {
                         const annotationPoints = annotation.data.handles.points;
-                        const { canvas: canvasDelta } = data.delta;
+                        const { world: worldDelta } = data.delta;
                         for (let i = 0, len = annotationPoints.length; i < len; i++) {
                             const point = annotationPoints[i];
-                            point[0] += canvasDelta[0];
-                            point[1] += canvasDelta[1];
-                            annotation.invalidated = true;
+                            point[0] += worldDelta[0];
+                            point[1] += worldDelta[1];
+                            point[2] += worldDelta[2];
                         }
+                        annotation.invalidated = true;
                     },
                 },
             });
@@ -130,17 +131,9 @@ class AdvancedMagnifyTool extends AnnotationTool {
             });
         };
         this.isPointNearTool = (element, annotation, canvasCoords, proximity) => {
-            const { data } = annotation;
-            const { points } = data.handles;
-            const canvasCoordinates = points;
-            const canvasTop = canvasCoordinates[0];
-            const canvasBottom = canvasCoordinates[2];
-            const canvasLeft = canvasCoordinates[3];
-            const radius = Math.abs(canvasBottom[1] - canvasTop[1]) * 0.5;
-            const center = [
-                canvasLeft[0] + radius,
-                canvasTop[1] + radius,
-            ];
+            const { viewport } = getEnabledElement(element);
+            const { points } = annotation.data.handles;
+            const { radius, center } = this._getCanvasCircleData(viewport, points);
             const radiusPoint = getCanvasCircleRadius([center, canvasCoords]);
             if (Math.abs(radiusPoint - radius) < proximity * 2) {
                 return true;
@@ -197,14 +190,14 @@ class AdvancedMagnifyTool extends AnnotationTool {
         this._dragDrawCallback = (evt) => {
             this.isDrawing = true;
             const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { viewport } = getEnabledElement(element);
             const { deltaPoints } = eventDetail;
             const canvasDelta = deltaPoints?.canvas ?? [0, 0, 0];
             const { annotation, viewportIdsToRender } = this.editData;
             const { points } = annotation.data.handles;
-            points.forEach((point) => {
-                point[0] += canvasDelta[0];
-                point[1] += canvasDelta[1];
-            });
+            const worldDelta = this._getWorldDeltaFromCanvasDelta(viewport, points, canvasDelta);
+            this._applyWorldDelta(points, worldDelta);
             annotation.invalidated = true;
             this.editData.hasMoved = true;
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
@@ -217,12 +210,10 @@ class AdvancedMagnifyTool extends AnnotationTool {
             const { data } = annotation;
             if (handleIndex === undefined) {
                 const { deltaPoints } = eventDetail;
-                const canvasDelta = deltaPoints.canvas;
+                const canvasDelta = deltaPoints.canvas ?? [0, 0, 0];
                 const points = data.handles.points;
-                points.forEach((point) => {
-                    point[0] += canvasDelta[0];
-                    point[1] += canvasDelta[1];
-                });
+                const worldDelta = this._getWorldDeltaFromCanvasDelta(getEnabledElement(element).viewport, points, canvasDelta);
+                this._applyWorldDelta(points, worldDelta);
                 annotation.invalidated = true;
             }
             else {
@@ -233,18 +224,12 @@ class AdvancedMagnifyTool extends AnnotationTool {
         };
         this._dragHandle = (evt) => {
             const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { viewport } = getEnabledElement(element);
             const { annotation } = this.editData;
             const { data } = annotation;
             const { points } = data.handles;
-            const canvasCoordinates = points;
-            const canvasTop = canvasCoordinates[0];
-            const canvasBottom = canvasCoordinates[2];
-            const canvasLeft = canvasCoordinates[3];
-            const radius = Math.abs(canvasBottom[1] - canvasTop[1]) * 0.5;
-            const canvasCenter = [
-                canvasLeft[0] + radius,
-                canvasTop[1] + radius,
-            ];
+            const { center: canvasCenter } = this._getCanvasCircleData(viewport, points);
             const { currentPoints } = eventDetail;
             const currentCanvasPoints = currentPoints.canvas;
             const newRadius = getCanvasCircleRadius([
@@ -252,10 +237,11 @@ class AdvancedMagnifyTool extends AnnotationTool {
                 currentCanvasPoints,
             ]);
             const newCanvasHandlePoints = this._getCanvasHandlePoints(canvasCenter, newRadius);
-            points[0] = newCanvasHandlePoints[0];
-            points[1] = newCanvasHandlePoints[1];
-            points[2] = newCanvasHandlePoints[2];
-            points[3] = newCanvasHandlePoints[3];
+            const newWorldHandlePoints = newCanvasHandlePoints.map((handle) => viewport.canvasToWorld(handle));
+            points[0] = newWorldHandlePoints[0];
+            points[1] = newWorldHandlePoints[1];
+            points[2] = newWorldHandlePoints[2];
+            points[3] = newWorldHandlePoints[3];
         };
         this.cancel = (element) => {
             if (!this.isDrawing) {
@@ -317,19 +303,11 @@ class AdvancedMagnifyTool extends AnnotationTool {
                 const { annotationUID, data } = annotation;
                 const { magnifyViewportId, zoomFactor, handles } = data;
                 const { points, activeHandleIndex } = handles;
+                const { center, radius, canvasPoints } = this._getCanvasCircleData(viewport, points);
                 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 canvasCoordinates = points;
-                const canvasTop = canvasCoordinates[0];
-                const canvasBottom = canvasCoordinates[2];
-                const canvasLeft = canvasCoordinates[3];
-                const radius = Math.abs(canvasBottom[1] - canvasTop[1]) * 0.5;
-                const center = [
-                    canvasLeft[0] + radius,
-                    canvasTop[1] + radius,
-                ];
                 if (!viewport.getRenderingEngine()) {
                     console.warn('Rendering Engine has been destroyed');
                     return renderStatus;
@@ -341,7 +319,10 @@ class AdvancedMagnifyTool extends AnnotationTool {
                 if (!isAnnotationLocked(annotationUID) &&
                     !this.editData &&
                     activeHandleIndex !== null) {
-                    activeHandleCanvasCoords = [canvasCoordinates[activeHandleIndex]];
+                    const activeHandle = canvasPoints[activeHandleIndex];
+                    activeHandleCanvasCoords = [
+                        [activeHandle[0], activeHandle[1], 0],
+                    ];
                 }
                 if (activeHandleCanvasCoords) {
                     const handleGroupUID = '0';
@@ -364,6 +345,22 @@ class AdvancedMagnifyTool extends AnnotationTool {
             }
             return renderStatus;
         };
+        this._getWorldHandlePoints = (viewport, canvasCenterPos, canvasRadius) => {
+            const canvasHandlePoints = this._getCanvasHandlePoints(canvasCenterPos, canvasRadius);
+            return canvasHandlePoints.map((handlePoint) => viewport.canvasToWorld(handlePoint));
+        };
+        this._getCanvasCircleData = (viewport, points) => {
+            const canvasPoints = points.map((point) => viewport.worldToCanvas(point));
+            const canvasTop = canvasPoints[0];
+            const canvasBottom = canvasPoints[2];
+            const canvasLeft = canvasPoints[3];
+            const radius = Math.abs(canvasBottom[1] - canvasTop[1]) * 0.5;
+            const center = [
+                canvasLeft[0] + radius,
+                canvasTop[1] + radius,
+            ];
+            return { canvasPoints, center, radius };
+        };
         this._getCanvasHandlePoints = (canvasCenterPos, canvasRadius) => {
             return [
                 [canvasCenterPos[0], canvasCenterPos[1] - canvasRadius, 0],
@@ -430,6 +427,33 @@ class AdvancedMagnifyTool extends AnnotationTool {
         });
         return dropdown;
     }
+    _getWorldDeltaFromCanvasDelta(viewport, points, canvasDelta) {
+        if (!canvasDelta) {
+            return [0, 0, 0];
+        }
+        const referencePoint = points[0];
+        const referenceCanvasPoint = viewport.worldToCanvas(referencePoint);
+        const movedWorldPoint = viewport.canvasToWorld([
+            referenceCanvasPoint[0] + canvasDelta[0],
+            referenceCanvasPoint[1] + canvasDelta[1],
+        ]);
+        return [
+            movedWorldPoint[0] - referencePoint[0],
+            movedWorldPoint[1] - referencePoint[1],
+            movedWorldPoint[2] - referencePoint[2],
+        ];
+    }
+    _applyWorldDelta(points, worldDelta) {
+        if (!worldDelta) {
+            return;
+        }
+        for (let i = 0, len = points.length; i < len; i++) {
+            const point = points[i];
+            point[0] += worldDelta[0];
+            point[1] += worldDelta[1];
+            point[2] += worldDelta[2];
+        }
+    }
 }
 class AdvancedMagnifyViewportManager {
     constructor() {

package/dist/esm/tools/ScaleOverlayTool.js

@@ -42,7 +42,7 @@ class ScaleOverlayTool extends AnnotationDisplayTool {
             let annotation = this.editData?.annotation;
             const annotations = getAnnotations(this.getToolName(), viewport.element);
             if (annotations.length) {
-                annotation = annotations.filter((thisAnnotation) => thisAnnotation.data.viewportId == viewport.id)[0];
+                annotation = annotations.filter((thisAnnotation) => thisAnnotation.data?.viewportId == viewport.id)[0];
             }
             enabledElements.forEach((element) => {
                 const { viewport } = element;
@@ -289,10 +289,10 @@ class ScaleOverlayTool extends AnnotationDisplayTool {
         const location = this.configuration.scaleLocation;
         const { viewport } = enabledElement;
         const annotations = getAnnotations(this.getToolName(), viewport.element);
-        const annotation = annotations.filter((thisAnnotation) => thisAnnotation.data.viewportId == viewport.id)[0];
+        const annotation = annotations.filter((thisAnnotation) => thisAnnotation.data?.viewportId == viewport.id)[0];
         const canvas = enabledElement.viewport.canvas;
         const renderStatus = false;
-        if (!viewport) {
+        if (!viewport || !annotation) {
             return renderStatus;
         }
         const styleSpecifier = {

package/dist/esm/utilities/segmentation/getOrCreateImageVolume.js

@@ -1,6 +1,6 @@
 import { cache, volumeLoader, utilities as csUtils, } from '@cornerstonejs/core';
 function getOrCreateImageVolume(referencedImageIds) {
-    if (!referencedImageIds || referencedImageIds.length <= 1) {
+    if (!referencedImageIds?.length) {
         return;
     }
     const isValidVolume = csUtils.isValidVolume(referencedImageIds);

package/dist/esm/utilities/segmentation/getOrCreateSegmentationVolume.d.ts

@@ -1,3 +1,3 @@
 import { type Types } from '@cornerstonejs/core';
-declare function getOrCreateSegmentationVolume(segmentationId: any): Types.IImageVolume | undefined;
+declare function getOrCreateSegmentationVolume(segmentationId: string): Types.IImageVolume | undefined;
 export default getOrCreateSegmentationVolume;

package/dist/esm/utilities/segmentation/getOrCreateSegmentationVolume.js

@@ -1,4 +1,4 @@
-import { cache, volumeLoader, utilities, } from '@cornerstonejs/core';
+import { cache, volumeLoader, utilities, ImageVolume, } from '@cornerstonejs/core';
 import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
 function getOrCreateSegmentationVolume(segmentationId) {
     const { representationData } = getSegmentation(segmentationId);
@@ -12,7 +12,7 @@ function getOrCreateSegmentationVolume(segmentationId) {
     }
     const { imageIds: labelmapImageIds } = representationData.Labelmap;
     volumeId = cache.generateVolumeId(labelmapImageIds);
-    if (!labelmapImageIds || labelmapImageIds.length === 1) {
+    if (!labelmapImageIds || labelmapImageIds.length === 0) {
         return;
     }
     const isValidVolume = utilities.isValidVolume(labelmapImageIds);

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.13.5";
+export declare const version = "4.13.7";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '4.13.5';
+export const version = '4.13.7';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "4.13.5",
+  "version": "4.13.7",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -108,7 +108,7 @@
     "canvas": "3.2.0"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "4.13.5",
+    "@cornerstonejs/core": "4.13.7",
     "@kitware/vtk.js": "34.15.1",
     "@types/d3-array": "3.2.1",
     "@types/d3-interpolate": "3.0.4",
@@ -127,5 +127,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "b2709b422af903a32a518e4fa76c583371f19559"
+  "gitHead": "ee360e7ddba785f4980cc4a6d79c058d7d313361"
 }