@cornerstonejs/tools 5.0.0-beta.1 → 5.0.1

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

@@ -17,7 +17,6 @@ import ContourSegmentationBaseTool from '../base/ContourSegmentationBaseTool';
 import { getCalibratedLengthUnitsAndScale, throttle } from '../../utilities';
 const CLICK_CLOSE_CURVE_SQR_DIST = 10 ** 2;
 class LivewireContourTool extends ContourSegmentationBaseTool {
-    static { this.toolName = 'LivewireContour'; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -335,12 +334,9 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
                 const deltaInX = vec3.distance(originalWorldPoint, deltaXPoint);
                 const deltaInY = vec3.distance(originalWorldPoint, deltaYPoint);
                 const { imageData } = image;
-                const { scale, areaUnit } = getCalibratedLengthUnitsAndScale(image, () => {
+                const { areaUnit } = getCalibratedLengthUnitsAndScale(image, () => {
                     const { maxX: canvasMaxX, maxY: canvasMaxY, minX: canvasMinX, minY: canvasMinY, } = math.polyline.getAABB(canvasCoordinates);
-                    const topLeftBBWorld = viewport.canvasToWorld([
-                        canvasMinX,
-                        canvasMinY,
-                    ]);
+                    const topLeftBBWorld = viewport.canvasToWorld([canvasMinX, canvasMinY]);
                     const topLeftBBIndex = utilities.transformWorldToIndex(imageData, topLeftBBWorld);
                     const bottomRightBBWorld = viewport.canvasToWorld([
                         canvasMaxX,
@@ -349,8 +345,7 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
                     const bottomRightBBIndex = utilities.transformWorldToIndex(imageData, bottomRightBBWorld);
                     return [topLeftBBIndex, bottomRightBBIndex];
                 });
-                let area = math.polyline.getArea(canvasCoordinates) / scale / scale;
-                area *= deltaInX * deltaInY;
+                const area = math.polyline.getArea(canvasCoordinates) * deltaInX * deltaInY;
                 cachedStats[targetId] = {
                     Modality: metadata.Modality,
                     area,
@@ -641,6 +636,7 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
         });
     }
 }
+LivewireContourTool.toolName = 'LivewireContour';
 export default LivewireContourTool;
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];

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

@@ -1,9 +1,9 @@
+var _a;
 import { utilities } from '@cornerstonejs/core';
 import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
 import PlanarFreehandROITool from './PlanarFreehandROITool';
 import AnnotationToPointData from '../../utilities/contours/AnnotationToPointData';
 export class PlanarFreehandContourSegmentationTool extends PlanarFreehandROITool {
-    static { this.toolName = 'PlanarFreehandContourSegmentationTool'; }
     constructor(toolProps) {
         const initialProps = utilities.deepMerge({
             configuration: {
@@ -13,9 +13,6 @@ export class PlanarFreehandContourSegmentationTool extends PlanarFreehandROITool
         }, toolProps);
         super(initialProps);
     }
-    static {
-        AnnotationToPointData.register(this);
-    }
     isContourSegmentationTool() {
         return true;
     }
@@ -30,4 +27,9 @@ export class PlanarFreehandContourSegmentationTool extends PlanarFreehandROITool
         return renderResult;
     }
 }
+_a = PlanarFreehandContourSegmentationTool;
+PlanarFreehandContourSegmentationTool.toolName = 'PlanarFreehandContourSegmentationTool';
+(() => {
+    AnnotationToPointData.register(_a);
+})();
 export default PlanarFreehandContourSegmentationTool;

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

@@ -35,11 +35,12 @@ 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, deltaInX, deltaInY, }: {
+    protected updateClosedCachedStats({ viewport, points, imageData, metadata, voxelManager, cachedStats, targetId, modalityUnit, canvasCoordinates, calibratedScale, deltaInX, deltaInY, }: {
         viewport: any;
         points: any;
         imageData: any;
         metadata: any;
+        voxelManager: any;
         cachedStats: any;
         targetId: any;
         modalityUnit: any;

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

@@ -20,11 +20,11 @@ import { BasicStatsCalculator } from '../../utilities/math/basic';
 import ContourSegmentationBaseTool from '../base/ContourSegmentationBaseTool';
 import { KeyboardBindings, ChangeTypes, MeasurementType } from '../../enums';
 import { getPixelValueUnits } from '../../utilities/getPixelValueUnits';
+import snapIndexBounds from '../../utilities/boundingBox/snapIndexBounds';
 const { pointCanProjectOnLine } = polyline;
 const { EPSILON } = CONSTANTS;
 const PARALLEL_THRESHOLD = 1 - EPSILON;
 class PlanarFreehandROITool extends ContourSegmentationBaseTool {
-    static { this.toolName = 'PlanarFreehandROI'; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -140,7 +140,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
                 if (!image) {
                     continue;
                 }
-                const { imageData, metadata } = image;
+                const { imageData, metadata, voxelManager } = image;
                 const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
                 const modalityUnitOptions = {
                     isPreScaled: isViewportPreScaled(viewport, targetId),
@@ -182,6 +182,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
                     points,
                     imageData,
                     metadata,
+                    voxelManager,
                     cachedStats,
                     modalityUnit,
                     calibratedScale,
@@ -408,9 +409,8 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
             }
         }
     }
-    updateClosedCachedStats({ viewport, points, imageData, metadata, cachedStats, targetId, modalityUnit, canvasCoordinates, calibratedScale, deltaInX, deltaInY, }) {
-        const { scale, areaUnit, unit } = calibratedScale;
-        const { voxelManager } = viewport.getImageData();
+    updateClosedCachedStats({ viewport, points, imageData, metadata, voxelManager, cachedStats, targetId, modalityUnit, canvasCoordinates, calibratedScale, deltaInX, deltaInY, }) {
+        const { areaUnit, unit } = calibratedScale;
         const indexPoints = points.map((point) => imageData.worldToIndex(point));
         let iMin = Number.MAX_SAFE_INTEGER;
         let iMax = Number.MIN_SAFE_INTEGER;
@@ -419,7 +419,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
         let kMin = Number.MAX_SAFE_INTEGER;
         let kMax = Number.MIN_SAFE_INTEGER;
         for (let j = 0; j < points.length; j++) {
-            const worldPosIndex = indexPoints[j].map(Math.floor);
+            const worldPosIndex = indexPoints[j];
             iMin = Math.min(iMin, worldPosIndex[0]);
             iMax = Math.max(iMax, worldPosIndex[0]);
             jMin = Math.min(jMin, worldPosIndex[1]);
@@ -427,8 +427,10 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
             kMin = Math.min(kMin, worldPosIndex[2]);
             kMax = Math.max(kMax, worldPosIndex[2]);
         }
-        let area = polyline.getArea(canvasCoordinates) / scale / scale;
-        area *= deltaInX * deltaInY;
+        [iMin, iMax] = snapIndexBounds(iMin, iMax);
+        [jMin, jMax] = snapIndexBounds(jMin, jMax);
+        [kMin, kMax] = snapIndexBounds(kMin, kMax);
+        const area = polyline.getArea(canvasCoordinates) * deltaInX * deltaInY;
         const perimeter = PlanarFreehandROITool.calculateLengthInIndex(calibratedScale, indexPoints, closed);
         const iDelta = 0.01 * (iMax - iMin);
         const jDelta = 0.01 * (jMax - jMin);
@@ -530,6 +532,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
         };
     }
 }
+PlanarFreehandROITool.toolName = 'PlanarFreehandROI';
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
     const { area, mean, stdDev, length, perimeter, max, min, isEmptyArea, unit, areaUnit, modalityUnit, } = cachedVolumeStats || {};

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

@@ -1,3 +1,4 @@
+var _a;
 import { vec2, vec3 } from 'gl-matrix';
 import { getEnabledElement, VolumeViewport, utilities as csUtils, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { AnnotationTool } from '../base';
@@ -13,25 +14,12 @@ import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCur
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { getPixelValueUnits } from '../../utilities/getPixelValueUnits';
+import { viewportSupportsImageSlices } from '../../utilities/viewportCapabilities';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
 const { transformWorldToIndex } = csUtils;
 class ProbeTool extends AnnotationTool {
-    static { this.toolName = 'Probe'; }
-    static { this.probeDefaults = {
-        supportedInteractionTypes: ['Mouse', 'Touch'],
-        configuration: {
-            shadow: true,
-            preventHandleOutsideImage: false,
-            getTextLines: defaultGetTextLines,
-            handleRadius: '6',
-            textCanvasOffset: {
-                x: 6,
-                y: -6,
-            },
-        },
-    }; }
     constructor(toolProps = {}, defaultToolProps) {
-        super(toolProps, AnnotationTool.mergeDefaultProps(ProbeTool.probeDefaults, defaultToolProps));
+        super(toolProps, AnnotationTool.mergeDefaultProps(_a.probeDefaults, defaultToolProps));
         this.addNewAnnotation = (evt) => {
             const eventDetail = evt.detail;
             const { currentPoints, element } = eventDetail;
@@ -176,17 +164,24 @@ class ProbeTool extends AnnotationTool {
                     this._calculateCachedStats(annotation, renderingEngine, enabledElement);
                     if (viewport instanceof VolumeViewport) {
                         const { referencedImageId } = annotation.metadata;
-                        for (const targetId in data.cachedStats) {
-                            if (targetId.startsWith('imageId')) {
-                                const viewports = renderingEngine.getStackViewports();
-                                const invalidatedStack = viewports.find((vp) => {
-                                    const referencedImageURI = csUtils.imageIdToURI(referencedImageId);
-                                    const hasImageURI = vp.hasImageURI(referencedImageURI);
-                                    const currentImageURI = csUtils.imageIdToURI(vp.getCurrentImageId());
-                                    return hasImageURI && currentImageURI !== referencedImageURI;
-                                });
-                                if (invalidatedStack) {
-                                    delete data.cachedStats[targetId];
+                        if (referencedImageId) {
+                            for (const targetId in data.cachedStats) {
+                                if (targetId.startsWith('imageId')) {
+                                    const viewports = renderingEngine
+                                        .getViewports()
+                                        .filter(viewportSupportsImageSlices);
+                                    const invalidatedStack = viewports.find((vp) => {
+                                        const currentImageId = vp.getCurrentImageId();
+                                        if (!currentImageId)
+                                            return false;
+                                        const referencedImageURI = csUtils.imageIdToURI(referencedImageId);
+                                        const hasImageURI = vp.hasImageURI(referencedImageURI);
+                                        const currentImageURI = csUtils.imageIdToURI(currentImageId);
+                                        return hasImageURI && currentImageURI !== referencedImageURI;
+                                    });
+                                    if (invalidatedStack) {
+                                        delete data.cachedStats[targetId];
+                                    }
                                 }
                             }
                         }
@@ -225,36 +220,6 @@ class ProbeTool extends AnnotationTool {
         return vec2.distance(canvasCoords, annotationCanvasCoordinate) < proximity;
     }
     toolSelectedCallback() { }
-    static { this.hydrate = (viewportId, points, options) => {
-        const enabledElement = getEnabledElementByViewportId(viewportId);
-        if (!enabledElement) {
-            return;
-        }
-        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, viewUp, instance, viewport, } = this.hydrateBase(ProbeTool, enabledElement, points, options);
-        const { toolInstance, ...serializableOptions } = options || {};
-        const annotation = {
-            annotationUID: options?.annotationUID || csUtils.uuidv4(),
-            data: {
-                handles: {
-                    points,
-                },
-            },
-            highlighted: false,
-            autoGenerated: false,
-            invalidated: false,
-            isLocked: false,
-            isVisible: true,
-            metadata: {
-                toolName: instance.getToolName(),
-                viewPlaneNormal,
-                FrameOfReferenceUID,
-                referencedImageId,
-                ...serializableOptions,
-            },
-        };
-        addAnnotation(annotation, viewport.element);
-        triggerAnnotationRenderForViewportIds([viewport.id]);
-    }; }
     getHandleNearImagePoint(element, annotation, canvasCoords, proximity) {
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;
@@ -358,6 +323,51 @@ class ProbeTool extends AnnotationTool {
         return cachedStats;
     }
 }
+_a = ProbeTool;
+ProbeTool.toolName = 'Probe';
+ProbeTool.probeDefaults = {
+    supportedInteractionTypes: ['Mouse', 'Touch'],
+    configuration: {
+        shadow: true,
+        preventHandleOutsideImage: false,
+        getTextLines: defaultGetTextLines,
+        handleRadius: '6',
+        textCanvasOffset: {
+            x: 6,
+            y: -6,
+        },
+    },
+};
+ProbeTool.hydrate = (viewportId, points, options) => {
+    const enabledElement = getEnabledElementByViewportId(viewportId);
+    if (!enabledElement) {
+        return;
+    }
+    const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, viewUp, instance, viewport, } = _a.hydrateBase(_a, enabledElement, points, options);
+    const { toolInstance, ...serializableOptions } = options || {};
+    const annotation = {
+        annotationUID: options?.annotationUID || csUtils.uuidv4(),
+        data: {
+            handles: {
+                points,
+            },
+        },
+        highlighted: false,
+        autoGenerated: false,
+        invalidated: false,
+        isLocked: false,
+        isVisible: true,
+        metadata: {
+            toolName: instance.getToolName(),
+            viewPlaneNormal,
+            FrameOfReferenceUID,
+            referencedImageId,
+            ...serializableOptions,
+        },
+    };
+    addAnnotation(annotation, viewport.element);
+    triggerAnnotationRenderForViewportIds([viewport.id]);
+};
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
     const { index, value, modalityUnit } = cachedVolumeStats;

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

@@ -1,3 +1,4 @@
+var _a;
 import { AnnotationTool } from '../base';
 import { getEnabledElement, VolumeViewport, utilities as csUtils, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { vec3 } from 'gl-matrix';
@@ -15,12 +16,12 @@ import * as rectangle from '../../utilities/math/rectangle';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { getPixelValueUnits } from '../../utilities/getPixelValueUnits';
+import { viewportSupportsImageSlices } from '../../utilities/viewportCapabilities';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
 import { BasicStatsCalculator } from '../../utilities/math/basic';
 import { getStyleProperty } from '../../stateManagement/annotation/config/helpers';
 const { transformWorldToIndex } = csUtils;
 class RectangleROITool extends AnnotationTool {
-    static { this.toolName = 'RectangleROI'; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -352,7 +353,9 @@ class RectangleROITool extends AnnotationTool {
                         const { referencedImageId } = annotation.metadata;
                         for (const targetId in data.cachedStats) {
                             if (targetId.startsWith('imageId')) {
-                                const viewports = renderingEngine.getStackViewports();
+                                const viewports = renderingEngine
+                                    .getViewports()
+                                    .filter(viewportSupportsImageSlices);
                                 const invalidatedStack = viewports.find((vp) => {
                                     const referencedImageURI = csUtils.imageIdToURI(referencedImageId);
                                     const hasImageURI = vp.hasImageURI(referencedImageURI);
@@ -456,8 +459,14 @@ class RectangleROITool extends AnnotationTool {
                     ];
                     const handles = [pos1Index, pos2Index];
                     const calibrate = getCalibratedLengthUnitsAndScale(image, handles);
-                    const width = RectangleROITool.calculateLengthInIndex(calibrate, indexHandles.slice(0, 2));
-                    const height = RectangleROITool.calculateLengthInIndex(calibrate, indexHandles.slice(2, 4));
+                    const width = _a.calculateLengthInIndex(calibrate, [
+                        indexHandles[0],
+                        indexHandles[1],
+                    ]);
+                    const height = _a.calculateLengthInIndex(calibrate, [
+                        indexHandles[0],
+                        indexHandles[2],
+                    ]);
                     const area = Math.abs(width * height);
                     const { areaUnit } = calibrate;
                     const pixelUnitsOptions = {
@@ -507,40 +516,42 @@ class RectangleROITool extends AnnotationTool {
         };
         this._throttledCalculateCachedStats = throttle(this._calculateCachedStats, 100, { trailing: true });
     }
-    static { this.hydrate = (viewportId, points, options) => {
-        const enabledElement = getEnabledElementByViewportId(viewportId);
-        if (!enabledElement) {
-            return;
-        }
-        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = this.hydrateBase(RectangleROITool, enabledElement, points, options);
-        const { toolInstance, ...serializableOptions } = options || {};
-        const annotation = {
-            annotationUID: options?.annotationUID || csUtils.uuidv4(),
-            data: {
-                handles: {
-                    points,
-                    activeHandleIndex: null,
-                },
-                label: '',
-                cachedStats: {},
-            },
-            highlighted: false,
-            autoGenerated: false,
-            invalidated: false,
-            isLocked: false,
-            isVisible: true,
-            metadata: {
-                toolName: instance.getToolName(),
-                viewPlaneNormal,
-                FrameOfReferenceUID,
-                referencedImageId,
-                ...serializableOptions,
-            },
-        };
-        addAnnotation(annotation, viewport.element);
-        triggerAnnotationRenderForViewportIds([viewport.id]);
-    }; }
 }
+_a = RectangleROITool;
+RectangleROITool.toolName = 'RectangleROI';
+RectangleROITool.hydrate = (viewportId, points, options) => {
+    const enabledElement = getEnabledElementByViewportId(viewportId);
+    if (!enabledElement) {
+        return;
+    }
+    const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = _a.hydrateBase(_a, enabledElement, points, options);
+    const { toolInstance, ...serializableOptions } = options || {};
+    const annotation = {
+        annotationUID: options?.annotationUID || csUtils.uuidv4(),
+        data: {
+            handles: {
+                points,
+                activeHandleIndex: null,
+            },
+            label: '',
+            cachedStats: {},
+        },
+        highlighted: false,
+        autoGenerated: false,
+        invalidated: false,
+        isLocked: false,
+        isVisible: true,
+        metadata: {
+            toolName: instance.getToolName(),
+            viewPlaneNormal,
+            FrameOfReferenceUID,
+            referencedImageId,
+            ...serializableOptions,
+        },
+    };
+    addAnnotation(annotation, viewport.element);
+    triggerAnnotationRenderForViewportIds([viewport.id]);
+};
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
     const { area, mean, max, stdDev, areaUnit, modalityUnit, min } = cachedVolumeStats;

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

@@ -4,7 +4,6 @@ import GrowCutBaseTool from '../base/GrowCutBaseTool';
 import { calculateGrowCutSeeds } from '../../utilities/segmentation/growCut/runOneClickGrowCut';
 import { ToolModes } from '../../enums';
 class RegionSegmentPlusTool extends GrowCutBaseTool {
-    static { this.toolName = 'RegionSegmentPlus'; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -125,4 +124,5 @@ class RegionSegmentPlusTool extends GrowCutBaseTool {
         });
     }
 }
+RegionSegmentPlusTool.toolName = 'RegionSegmentPlus';
 export default RegionSegmentPlusTool;

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

@@ -7,7 +7,6 @@ import triggerAnnotationRenderForViewportUIDs from '../../utilities/triggerAnnot
 import { growCut } from '../../utilities/segmentation';
 import GrowCutBaseTool from '../base/GrowCutBaseTool';
 class RegionSegmentTool extends GrowCutBaseTool {
-    static { this.toolName = 'RegionSegment'; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -111,4 +110,5 @@ class RegionSegmentTool extends GrowCutBaseTool {
         });
     }
 }
+RegionSegmentTool.toolName = 'RegionSegment';
 export default RegionSegmentTool;

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

@@ -3,7 +3,6 @@ import SplineROITool from './SplineROITool';
 import { Events } from '../../enums';
 import { convertContourSegmentationAnnotation } from '../../utilities/contourSegmentation';
 class SplineContourSegmentationTool extends SplineROITool {
-    static { this.toolName = 'SplineContourSegmentationTool'; }
     constructor(toolProps) {
         const initialProps = utilities.deepMerge({
             configuration: {
@@ -33,4 +32,5 @@ class SplineContourSegmentationTool extends SplineROITool {
         convertContourSegmentationAnnotation(annotation);
     }
 }
+SplineContourSegmentationTool.toolName = 'SplineContourSegmentationTool';
 export default SplineContourSegmentationTool;

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

@@ -1,3 +1,4 @@
+var _a;
 import { getEnabledElement, eventTarget, triggerEvent, utilities, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { vec3 } from 'gl-matrix';
 import { addAnnotation, getChildAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
@@ -46,9 +47,6 @@ const splineToolNames = [
     'CardinalSplineROI',
 ];
 class SplineROITool extends ContourSegmentationBaseTool {
-    static { this.toolName = 'SplineROI'; }
-    static { this.SplineTypes = SplineTypesEnum; }
-    static { this.Actions = SplineToolActions; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -118,6 +116,9 @@ class SplineROITool extends ContourSegmentationBaseTool {
         this.fireChangeOnUpdate = null;
         this.isPointNearTool = (element, annotation, canvasCoords, proximity) => {
             const { instance: spline } = annotation.data.spline;
+            if (!spline) {
+                return false;
+            }
             return spline.isPointNearCurve(canvasCoords, proximity);
         };
         this.toolSelectedCallback = (evt, annotation) => {
@@ -470,12 +471,9 @@ class SplineROITool extends ContourSegmentationBaseTool {
                 const deltaInX = vec3.distance(originalWorldPoint, deltaXPoint);
                 const deltaInY = vec3.distance(originalWorldPoint, deltaYPoint);
                 const { imageData } = image;
-                const { scale, areaUnit } = getCalibratedLengthUnitsAndScale(image, () => {
+                const { areaUnit } = getCalibratedLengthUnitsAndScale(image, () => {
                     const { maxX: canvasMaxX, maxY: canvasMaxY, minX: canvasMinX, minY: canvasMinY, } = math.polyline.getAABB(canvasCoordinates);
-                    const topLeftBBWorld = viewport.canvasToWorld([
-                        canvasMinX,
-                        canvasMinY,
-                    ]);
+                    const topLeftBBWorld = viewport.canvasToWorld([canvasMinX, canvasMinY]);
                     const topLeftBBIndex = utilities.transformWorldToIndex(imageData, topLeftBBWorld);
                     const bottomRightBBWorld = viewport.canvasToWorld([
                         canvasMaxX,
@@ -484,8 +482,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
                     const bottomRightBBIndex = utilities.transformWorldToIndex(imageData, bottomRightBBWorld);
                     return [topLeftBBIndex, bottomRightBBIndex];
                 });
-                let area = math.polyline.getArea(canvasCoordinates) / scale / scale;
-                area *= deltaInX * deltaInY;
+                const area = math.polyline.getArea(canvasCoordinates) * deltaInX * deltaInY;
                 cachedStats[targetId] = {
                     Modality: metadata.Modality,
                     area,
@@ -584,6 +581,9 @@ class SplineROITool extends ContourSegmentationBaseTool {
         const { lineWidth, lineDash, color, locked: annotationLocked, } = annotationStyle;
         const canvasCoordinates = controlPoints.map((p) => worldToCanvas(p));
         const { drawPreviewEnabled } = this.configuration.spline;
+        if (annotation.data.spline && !annotation.data.spline.instance) {
+            annotation.data.spline.instance = new (this._getSplineConfig(annotation.data.spline.type).Class)();
+        }
         const splineType = annotation.data.spline.type;
         const splineConfig = this._getSplineConfig(splineType);
         const spline = annotation.data.spline.instance;
@@ -780,54 +780,58 @@ class SplineROITool extends ContourSegmentationBaseTool {
         }
         return spline;
     }
-    static { this.hydrate = (viewportId, points, options) => {
-        const enabledElement = getEnabledElementByViewportId(viewportId);
-        if (!enabledElement) {
-            return;
-        }
-        if (points.length < SPLINE_MIN_POINTS) {
-            console.warn('Spline requires at least 3 control points');
-            return;
-        }
-        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 { toolInstance, ...serializableOptions } = options || {};
-        const annotation = {
-            annotationUID: options?.annotationUID || utilities.uuidv4(),
-            data: {
-                handles: {
-                    points,
-                },
-                label: '',
-                cachedStats: {},
-                spline: {
-                    type: splineType,
-                    instance: splineInstance,
-                },
-                contour: {
-                    closed: true,
-                },
+}
+_a = SplineROITool;
+SplineROITool.toolName = 'SplineROI';
+SplineROITool.SplineTypes = SplineTypesEnum;
+SplineROITool.Actions = SplineToolActions;
+SplineROITool.hydrate = (viewportId, points, options) => {
+    const enabledElement = getEnabledElementByViewportId(viewportId);
+    if (!enabledElement) {
+        return;
+    }
+    if (points.length < SPLINE_MIN_POINTS) {
+        console.warn('Spline requires at least 3 control points');
+        return;
+    }
+    const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, viewUp, instance, viewport, } = _a.hydrateBase(_a, enabledElement, points, options);
+    const splineType = options?.splineType || SplineTypesEnum.CatmullRom;
+    const splineConfig = instance._getSplineConfig(splineType);
+    const SplineClass = splineConfig.Class;
+    const splineInstance = new SplineClass();
+    const { toolInstance, ...serializableOptions } = options || {};
+    const annotation = {
+        annotationUID: options?.annotationUID || utilities.uuidv4(),
+        data: {
+            handles: {
+                points,
             },
-            highlighted: false,
-            autoGenerated: false,
-            invalidated: true,
-            isLocked: false,
-            isVisible: true,
-            metadata: {
-                toolName: instance.getToolName(),
-                viewPlaneNormal,
-                FrameOfReferenceUID,
-                referencedImageId,
-                ...serializableOptions,
+            label: '',
+            cachedStats: {},
+            spline: {
+                type: splineType,
+                instance: splineInstance,
             },
-        };
-        addAnnotation(annotation, viewport.element);
-        triggerAnnotationRenderForViewportIds([viewport.id]);
-    }; }
-}
+            contour: {
+                closed: true,
+            },
+        },
+        highlighted: false,
+        autoGenerated: false,
+        invalidated: true,
+        isLocked: false,
+        isVisible: true,
+        metadata: {
+            toolName: instance.getToolName(),
+            viewPlaneNormal,
+            FrameOfReferenceUID,
+            referencedImageId,
+            ...serializableOptions,
+        },
+    };
+    addAnnotation(annotation, viewport.element);
+    triggerAnnotationRenderForViewportIds([viewport.id]);
+};
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
     const { area, isEmptyArea, areaUnit } = cachedVolumeStats;

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

@@ -14,7 +14,6 @@ import { getCalibratedProbeUnitsAndValue } from '../../utilities/getCalibratedUn
 import { lineSegment } from '../../utilities/math';
 const { transformWorldToIndex } = csUtils;
 class UltrasoundDirectionalTool extends AnnotationTool {
-    static { this.toolName = 'UltrasoundDirectionalTool'; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -417,6 +416,7 @@ class UltrasoundDirectionalTool extends AnnotationTool {
         return cachedStats;
     }
 }
+UltrasoundDirectionalTool.toolName = 'UltrasoundDirectionalTool';
 function defaultGetTextLines(data, targetId, configuration) {
     const cachedStats = data.cachedStats[targetId];
     const { xValues, yValues, units, isUnitless, isHorizontal } = cachedStats;