@cornerstonejs/tools 4.4.1 → 4.4.2

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

@@ -1,6 +1,6 @@
 import { AnnotationTool } from '../base';
-import { getEnabledElement, VolumeViewport, utilities as csUtils, getEnabledElementByViewportId, } from '@cornerstonejs/core';
-import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits';
+import { getEnabledElement, VolumeViewport, utilities as csUtils, getEnabledElementByViewportId, EPSILON, } from '@cornerstonejs/core';
+import { getCalibratedAspect, getCalibratedLengthUnitsAndScale, } from '../../utilities/getCalibratedUnits';
 import throttle from '../../utilities/throttle';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
@@ -535,68 +535,79 @@ class EllipticalROITool extends AnnotationTool {
                 pos1Index[0] = Math.floor(pos1Index[0]);
                 pos1Index[1] = Math.floor(pos1Index[1]);
                 pos1Index[2] = Math.floor(pos1Index[2]);
-                const post2Index = transformWorldToIndex(imageData, worldPos2);
-                post2Index[0] = Math.floor(post2Index[0]);
-                post2Index[1] = Math.floor(post2Index[1]);
-                post2Index[2] = Math.floor(post2Index[2]);
-                this.isHandleOutsideImage = !this._isInsideVolume(pos1Index, post2Index, dimensions);
-                const iMin = Math.min(pos1Index[0], post2Index[0]);
-                const iMax = Math.max(pos1Index[0], post2Index[0]);
-                const jMin = Math.min(pos1Index[1], post2Index[1]);
-                const jMax = Math.max(pos1Index[1], post2Index[1]);
-                const kMin = Math.min(pos1Index[2], post2Index[2]);
-                const kMax = Math.max(pos1Index[2], post2Index[2]);
-                const boundsIJK = [
-                    [iMin, iMax],
-                    [jMin, jMax],
-                    [kMin, kMax],
-                ];
-                const center = [
-                    (topLeftWorld[0] + bottomRightWorld[0]) / 2,
-                    (topLeftWorld[1] + bottomRightWorld[1]) / 2,
-                    (topLeftWorld[2] + bottomRightWorld[2]) / 2,
-                ];
-                const ellipseObj = {
-                    center,
-                    xRadius: Math.abs(topLeftWorld[0] - bottomRightWorld[0]) / 2,
-                    yRadius: Math.abs(topLeftWorld[1] - bottomRightWorld[1]) / 2,
-                    zRadius: Math.abs(topLeftWorld[2] - bottomRightWorld[2]) / 2,
-                };
-                const { worldWidth, worldHeight } = getWorldWidthAndHeightFromTwoPoints(viewPlaneNormal, viewUp, worldPos1, worldPos2);
-                const isEmptyArea = worldWidth === 0 && worldHeight === 0;
-                const handles = [pos1Index, post2Index];
-                const { scale, areaUnit } = getCalibratedLengthUnitsAndScale(image, handles);
-                const area = Math.abs(Math.PI * (worldWidth / 2) * (worldHeight / 2)) /
-                    scale /
-                    scale;
-                const pixelUnitsOptions = {
-                    isPreScaled: isViewportPreScaled(viewport, targetId),
-                    isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
-                };
-                const modalityUnit = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
-                let pointsInShape;
-                if (voxelManager) {
-                    const pointsInShape = voxelManager.forEach(this.configuration.statsCalculator.statsCallback, {
-                        boundsIJK,
-                        imageData,
-                        isInObject: (pointLPS) => pointInEllipse(ellipseObj, pointLPS, { fast: true }),
-                        returnPoints: this.configuration.storePointData,
-                    });
+                const pos2Index = transformWorldToIndex(imageData, worldPos2);
+                pos2Index[0] = Math.floor(pos2Index[0]);
+                pos2Index[1] = Math.floor(pos2Index[1]);
+                pos2Index[2] = Math.floor(pos2Index[2]);
+                if (this._isInsideVolume(pos1Index, pos2Index, dimensions)) {
+                    const iMin = Math.min(pos1Index[0], pos2Index[0]);
+                    const iMax = Math.max(pos1Index[0], pos2Index[0]);
+                    const jMin = Math.min(pos1Index[1], pos2Index[1]);
+                    const jMax = Math.max(pos1Index[1], pos2Index[1]);
+                    const kMin = Math.min(pos1Index[2], pos2Index[2]);
+                    const kMax = Math.max(pos1Index[2], pos2Index[2]);
+                    const boundsIJK = [
+                        [iMin, iMax],
+                        [jMin, jMax],
+                        [kMin, kMax],
+                    ];
+                    const center = [
+                        (topLeftWorld[0] + bottomRightWorld[0]) / 2,
+                        (topLeftWorld[1] + bottomRightWorld[1]) / 2,
+                        (topLeftWorld[2] + bottomRightWorld[2]) / 2,
+                    ];
+                    const xRadius = Math.abs(topLeftWorld[0] - bottomRightWorld[0]) / 2;
+                    const yRadius = Math.abs(topLeftWorld[1] - bottomRightWorld[1]) / 2;
+                    const zRadius = Math.abs(topLeftWorld[2] - bottomRightWorld[2]) / 2;
+                    const ellipseObj = {
+                        center,
+                        xRadius: xRadius < EPSILON / 2 ? 0 : xRadius,
+                        yRadius: yRadius < EPSILON / 2 ? 0 : yRadius,
+                        zRadius: zRadius < EPSILON / 2 ? 0 : zRadius,
+                    };
+                    const { worldWidth, worldHeight } = getWorldWidthAndHeightFromTwoPoints(viewPlaneNormal, viewUp, worldPos1, worldPos2);
+                    const isEmptyArea = worldWidth === 0 && worldHeight === 0;
+                    const handles = [pos1Index, pos2Index];
+                    const { scale, unit, areaUnit } = getCalibratedLengthUnitsAndScale(image, handles);
+                    const aspect = getCalibratedAspect(image);
+                    const area = Math.abs(Math.PI *
+                        (worldWidth / scale / 2) *
+                        (worldHeight / aspect / scale / 2));
+                    const pixelUnitsOptions = {
+                        isPreScaled: isViewportPreScaled(viewport, targetId),
+                        isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
+                    };
+                    const modalityUnit = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
+                    let pointsInShape;
+                    if (voxelManager) {
+                        pointsInShape = voxelManager.forEach(this.configuration.statsCalculator.statsCallback, {
+                            isInObject: (pointLPS) => pointInEllipse(ellipseObj, pointLPS, { fast: true }),
+                            boundsIJK,
+                            imageData,
+                            returnPoints: this.configuration.storePointData,
+                        });
+                    }
+                    const stats = this.configuration.statsCalculator.getStatistics();
+                    cachedStats[targetId] = {
+                        Modality: metadata.Modality,
+                        area,
+                        mean: stats.mean?.value,
+                        max: stats.max?.value,
+                        min: stats.min?.value,
+                        stdDev: stats.stdDev?.value,
+                        statsArray: stats.array,
+                        pointsInShape,
+                        isEmptyArea,
+                        areaUnit,
+                        modalityUnit,
+                    };
+                }
+                else {
+                    this.isHandleOutsideImage = true;
+                    cachedStats[targetId] = {
+                        Modality: metadata.Modality,
+                    };
                 }
-                const stats = this.configuration.statsCalculator.getStatistics();
-                cachedStats[targetId] = {
-                    Modality: metadata.Modality,
-                    area,
-                    mean: stats.mean?.value,
-                    max: stats.max?.value,
-                    min: stats.min?.value,
-                    stdDev: stats.stdDev?.value,
-                    statsArray: stats.array,
-                    pointsInShape,
-                    isEmptyArea,
-                    areaUnit,
-                    modalityUnit,
-                };
             }
             const invalidated = annotation.invalidated;
             annotation.invalidated = false;

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.4.1";
+export declare const version = "4.4.2";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '4.4.1';
+export const version = '4.4.2';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "4.4.1",
+  "version": "4.4.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": "4.4.1",
+    "@cornerstonejs/core": "4.4.2",
     "@kitware/vtk.js": "32.12.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": "a3125cde6a15894c53f1c4e8e7bcd31530b78aaf"
+  "gitHead": "e9db49c820e93f4b404ff0aa918ccb013191bebe"
 }