@cornerstonejs/tools 4.12.3 → 4.12.5

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

@@ -568,7 +568,7 @@ class EllipticalROITool extends AnnotationTool {
                     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 { scale, areaUnit } = getCalibratedLengthUnitsAndScale(image, handles);
                     const aspect = getCalibratedAspect(image);
                     const area = Math.abs(Math.PI *
                         (worldWidth / scale / 2) *

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

@@ -35,8 +35,6 @@ declare class LengthTool extends AnnotationTool {
     _activateDraw: (element: HTMLDivElement) => void;
     _deactivateDraw: (element: HTMLDivElement) => void;
     renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
-    _calculateLength(pos1: any, pos2: any): number;
     _calculateCachedStats(annotation: any, renderingEngine: any, enabledElement: any): any;
-    _isInsideVolume(index1: any, index2: any, dimensions: any): boolean;
 }
 export default LengthTool;

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

@@ -1,4 +1,4 @@
-import { Events, ChangeTypes } from '../../enums';
+import { Events, ChangeTypes, MeasurementType } from '../../enums';
 import { getEnabledElement, utilities as csUtils, utilities, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits';
 import { AnnotationTool } from '../base';
@@ -15,7 +15,6 @@ import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import { getStyleProperty } from '../../stateManagement/annotation/config/helpers';
-const { transformWorldToIndex } = csUtils;
 class LengthTool extends AnnotationTool {
     static { this.toolName = 'Length'; }
     constructor(toolProps = {}, defaultToolProps = {
@@ -384,17 +383,9 @@ class LengthTool extends AnnotationTool {
         triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         evt.preventDefault();
     }
-    _calculateLength(pos1, pos2) {
-        const dx = pos1[0] - pos2[0];
-        const dy = pos1[1] - pos2[1];
-        const dz = pos1[2] - pos2[2];
-        return Math.sqrt(dx * dx + dy * dy + dz * dz);
-    }
     _calculateCachedStats(annotation, renderingEngine, enabledElement) {
         const data = annotation.data;
         const { element } = enabledElement.viewport;
-        const worldPos1 = data.handles.points[0];
-        const worldPos2 = data.handles.points[1];
         const { cachedStats } = data;
         const targetIds = Object.keys(cachedStats);
         for (let i = 0; i < targetIds.length; i++) {
@@ -404,20 +395,21 @@ class LengthTool extends AnnotationTool {
                 continue;
             }
             const { imageData, dimensions } = image;
-            const index1 = transformWorldToIndex(imageData, worldPos1);
-            const index2 = transformWorldToIndex(imageData, worldPos2);
-            const handles = [index1, index2];
-            const { scale, unit } = getCalibratedLengthUnitsAndScale(image, handles);
-            const length = this._calculateLength(worldPos1, worldPos2) / scale;
-            if (this._isInsideVolume(index1, index2, dimensions)) {
-                this.isHandleOutsideImage = false;
-            }
-            else {
-                this.isHandleOutsideImage = true;
-            }
+            const handles = data.handles.points.map((point) => imageData.worldToIndex(point));
+            const calibrate = getCalibratedLengthUnitsAndScale(image, handles);
+            const { unit } = calibrate;
+            const length = LengthTool.calculateLengthInIndex(calibrate, handles);
+            this.isHandleOutsideImage = !LengthTool.isInsideVolume(dimensions, handles);
+            const namedLength = {
+                name: 'length',
+                value: length,
+                unit,
+                type: MeasurementType.Linear,
+            };
             cachedStats[targetId] = {
                 length,
                 unit,
+                statsArray: [namedLength],
             };
         }
         const invalidated = annotation.invalidated;
@@ -427,10 +419,6 @@ class LengthTool extends AnnotationTool {
         }
         return cachedStats;
     }
-    _isInsideVolume(index1, index2, dimensions) {
-        return (csUtils.indexWithinDimensions(index1, dimensions) &&
-            csUtils.indexWithinDimensions(index2, dimensions));
-    }
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];

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

@@ -48,12 +48,13 @@ declare class PlanarFreehandROITool extends ContourSegmentationBaseTool {
         deltaInX: any;
         deltaInY: any;
     }): void;
-    protected updateOpenCachedStats({ targetId, metadata, cachedStats, modalityUnit, calibratedScale, points, }: {
+    protected updateOpenCachedStats({ targetId, metadata, cachedStats, modalityUnit, calibratedScale, imageData, points, }: {
         targetId: any;
         metadata: any;
         cachedStats: any;
         modalityUnit: any;
         calibratedScale: any;
+        imageData: any;
         points: any;
     }): void;
     private _renderStats;

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

@@ -19,9 +19,8 @@ import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import { getLineSegmentIntersectionsCoordinates } from '../../utilities/math/polyline';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
 import { BasicStatsCalculator } from '../../utilities/math/basic';
-import calculatePerimeter from '../../utilities/contours/calculatePerimeter';
 import ContourSegmentationBaseTool from '../base/ContourSegmentationBaseTool';
-import { KeyboardBindings, ChangeTypes } from '../../enums';
+import { KeyboardBindings, ChangeTypes, MeasurementType } from '../../enums';
 import { getPixelValueUnits } from '../../utilities/getPixelValueUnits';
 const { pointCanProjectOnLine } = polyline;
 const { EPSILON } = CONSTANTS;
@@ -150,23 +149,22 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
                     isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
                 };
                 const modalityUnit = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
-                const calibratedScale = getCalibratedLengthUnitsAndScale(image, () => {
-                    const polyline = data.contour.polyline;
-                    const numPoints = polyline.length;
-                    const projectedPolyline = new Array(numPoints);
-                    for (let i = 0; i < numPoints; i++) {
-                        projectedPolyline[i] = viewport.worldToCanvas(polyline[i]);
-                    }
-                    const { maxX: canvasMaxX, maxY: canvasMaxY, minX: canvasMinX, minY: canvasMinY, } = math.polyline.getAABB(projectedPolyline);
-                    const topLeftBBWorld = viewport.canvasToWorld([canvasMinX, canvasMinY]);
-                    const topLeftBBIndex = csUtils.transformWorldToIndex(imageData, topLeftBBWorld);
-                    const bottomRightBBWorld = viewport.canvasToWorld([
-                        canvasMaxX,
-                        canvasMaxY,
-                    ]);
-                    const bottomRightBBIndex = csUtils.transformWorldToIndex(imageData, bottomRightBBWorld);
-                    return [topLeftBBIndex, bottomRightBBIndex];
-                });
+                const polyline = data.contour.polyline;
+                const numPoints = polyline.length;
+                const projectedPolyline = new Array(numPoints);
+                for (let i = 0; i < numPoints; i++) {
+                    projectedPolyline[i] = viewport.worldToCanvas(polyline[i]);
+                }
+                const { maxX: canvasMaxX, maxY: canvasMaxY, minX: canvasMinX, minY: canvasMinY, } = math.polyline.getAABB(projectedPolyline);
+                const topLeftBBWorld = viewport.canvasToWorld([canvasMinX, canvasMinY]);
+                const topLeftBBIndex = csUtils.transformWorldToIndex(imageData, topLeftBBWorld);
+                const bottomRightBBWorld = viewport.canvasToWorld([
+                    canvasMaxX,
+                    canvasMaxY,
+                ]);
+                const bottomRightBBIndex = csUtils.transformWorldToIndex(imageData, bottomRightBBWorld);
+                const handles = [topLeftBBIndex, bottomRightBBIndex];
+                const calibratedScale = getCalibratedLengthUnitsAndScale(image, handles);
                 const canvasPoint = canvasCoordinates[0];
                 const originalWorldPoint = viewport.canvasToWorld(canvasPoint);
                 const deltaXPoint = viewport.canvasToWorld([
@@ -179,30 +177,24 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
                 ]);
                 const deltaInX = vec3.distance(originalWorldPoint, deltaXPoint);
                 const deltaInY = vec3.distance(originalWorldPoint, deltaYPoint);
+                const statsArgs = {
+                    targetId,
+                    viewport,
+                    canvasCoordinates,
+                    points,
+                    imageData,
+                    metadata,
+                    cachedStats,
+                    modalityUnit,
+                    calibratedScale,
+                    deltaInX,
+                    deltaInY,
+                };
                 if (closed) {
-                    this.updateClosedCachedStats({
-                        targetId,
-                        viewport,
-                        canvasCoordinates,
-                        points,
-                        imageData,
-                        metadata,
-                        cachedStats,
-                        modalityUnit,
-                        calibratedScale,
-                        deltaInX,
-                        deltaInY,
-                    });
+                    this.updateClosedCachedStats(statsArgs);
                 }
                 else {
-                    this.updateOpenCachedStats({
-                        metadata,
-                        targetId,
-                        cachedStats,
-                        modalityUnit,
-                        calibratedScale,
-                        points,
-                    });
+                    this.updateOpenCachedStats(statsArgs);
                 }
             }
             const invalidated = annotation.invalidated;
@@ -255,12 +247,12 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
         this._throttledCalculateCachedStats = throttle(this._calculateCachedStats, 100, { trailing: true });
     }
     filterInteractableAnnotationsForElement(element, annotations) {
-        if (!annotations || !annotations.length) {
-            return;
+        if (!annotations?.length) {
+            return [];
         }
         const baseFilteredAnnotations = super.filterInteractableAnnotationsForElement(element, annotations);
-        if (!baseFilteredAnnotations || !baseFilteredAnnotations.length) {
-            return;
+        if (!baseFilteredAnnotations?.length) {
+            return [];
         }
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;
@@ -432,21 +424,15 @@ 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();
-        const worldPosIndex = csUtils.transformWorldToIndex(imageData, points[0]);
-        worldPosIndex[0] = Math.floor(worldPosIndex[0]);
-        worldPosIndex[1] = Math.floor(worldPosIndex[1]);
-        worldPosIndex[2] = Math.floor(worldPosIndex[2]);
-        let iMin = worldPosIndex[0];
-        let iMax = worldPosIndex[0];
-        let jMin = worldPosIndex[1];
-        let jMax = worldPosIndex[1];
-        let kMin = worldPosIndex[2];
-        let kMax = worldPosIndex[2];
-        for (let j = 1; j < points.length; j++) {
-            const worldPosIndex = csUtils.transformWorldToIndex(imageData, points[j]);
-            worldPosIndex[0] = Math.floor(worldPosIndex[0]);
-            worldPosIndex[1] = Math.floor(worldPosIndex[1]);
-            worldPosIndex[2] = Math.floor(worldPosIndex[2]);
+        const indexPoints = points.map((point) => imageData.worldToIndex(point));
+        let iMin = Number.MAX_SAFE_INTEGER;
+        let iMax = Number.MIN_SAFE_INTEGER;
+        let jMin = Number.MAX_SAFE_INTEGER;
+        let jMax = Number.MIN_SAFE_INTEGER;
+        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);
             iMin = Math.min(iMin, worldPosIndex[0]);
             iMax = Math.max(iMax, worldPosIndex[0]);
             jMin = Math.min(jMin, worldPosIndex[1]);
@@ -454,13 +440,9 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
             kMin = Math.min(kMin, worldPosIndex[2]);
             kMax = Math.max(kMax, worldPosIndex[2]);
         }
-        const worldPosIndex2 = csUtils.transformWorldToIndex(imageData, points[1]);
-        worldPosIndex2[0] = Math.floor(worldPosIndex2[0]);
-        worldPosIndex2[1] = Math.floor(worldPosIndex2[1]);
-        worldPosIndex2[2] = Math.floor(worldPosIndex2[2]);
         let area = polyline.getArea(canvasCoordinates) / scale / scale;
         area *= deltaInX * deltaInY;
-        const perimeter = calculatePerimeter(points, closed) / scale;
+        const perimeter = PlanarFreehandROITool.calculateLengthInIndex(calibratedScale, indexPoints, closed);
         const iDelta = 0.01 * (iMax - iMin);
         const jDelta = 0.01 * (jMax - jMin);
         const kDelta = 0.01 * (kMax - kMin);
@@ -515,6 +497,18 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
             });
         }
         const stats = this.configuration.statsCalculator.getStatistics();
+        const namedArea = {
+            name: 'area',
+            value: area,
+            unit: areaUnit,
+            type: MeasurementType.Area,
+        };
+        const namedPerimeter = {
+            name: 'perimeter',
+            value: perimeter,
+            unit,
+            type: MeasurementType.Linear,
+        };
         cachedStats[targetId] = {
             Modality: metadata.Modality,
             area,
@@ -523,21 +517,29 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
             max: stats.max?.value,
             min: stats.min?.value,
             stdDev: stats.stdDev?.value,
-            statsArray: stats.array,
+            statsArray: [namedArea, namedPerimeter, ...stats.array],
             pointsInShape: pointsInShape,
             areaUnit,
             modalityUnit,
             unit,
         };
     }
-    updateOpenCachedStats({ targetId, metadata, cachedStats, modalityUnit, calibratedScale, points, }) {
-        const { scale, unit } = calibratedScale;
-        const length = calculatePerimeter(points, closed) / scale;
+    updateOpenCachedStats({ targetId, metadata, cachedStats, modalityUnit, calibratedScale, imageData, points, }) {
+        const { unit } = calibratedScale;
+        const indexPoints = points.map((point) => imageData.worldToIndex(point));
+        const length = PlanarFreehandROITool.calculateLengthInIndex(calibratedScale, indexPoints);
+        const namedLength = {
+            name: 'length',
+            value: length,
+            unit,
+            type: MeasurementType.Linear,
+        };
         cachedStats[targetId] = {
             Modality: metadata.Modality,
             length,
             modalityUnit,
             unit,
+            statArray: [namedLength],
         };
     }
 }

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

@@ -1,4 +1,4 @@
-import { utilities } from '@cornerstonejs/core';
+import { utilities as csUtils } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 import ToolModes from '../../enums/ToolModes';
 import type StrategyCallbacks from '../../enums/StrategyCallbacks';
@@ -9,7 +9,7 @@ declare abstract class BaseTool {
     configuration: Record<string, any>;
     toolGroupId: string;
     mode: ToolModes;
-    protected memo: utilities.HistoryMemo.Memo;
+    protected memo: csUtils.HistoryMemo.Memo;
     static defaults: {
         configuration: {
             strategies: {};
@@ -36,5 +36,7 @@ declare abstract class BaseTool {
     doneEditMemo(): void;
     static startGroupRecording(): void;
     static endGroupRecording(): void;
+    static calculateLengthInIndex(calibrate: any, indexPoints: any, closed?: boolean): number;
+    static isInsideVolume(dimensions: any, indexPoints: any): boolean;
 }
 export default BaseTool;

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

@@ -1,6 +1,6 @@
-import { utilities } from '@cornerstonejs/core';
+import { utilities as csUtils } from '@cornerstonejs/core';
 import ToolModes from '../../enums/ToolModes';
-const { DefaultHistoryMemo } = utilities.HistoryMemo;
+const { DefaultHistoryMemo } = csUtils.HistoryMemo;
 class BaseTool {
     static { this.defaults = {
         configuration: {
@@ -12,7 +12,7 @@ class BaseTool {
     }; }
     constructor(toolProps, defaultToolProps) {
         const mergedDefaults = BaseTool.mergeDefaultProps(BaseTool.defaults, defaultToolProps);
-        const initialProps = utilities.deepMerge(mergedDefaults, toolProps);
+        const initialProps = csUtils.deepMerge(mergedDefaults, toolProps);
         const { configuration = {}, supportedInteractionTypes, toolGroupId, } = initialProps;
         this.toolGroupId = toolGroupId;
         this.supportedInteractionTypes = supportedInteractionTypes || [];
@@ -23,7 +23,7 @@ class BaseTool {
         if (!additionalProps) {
             return defaultProps;
         }
-        return utilities.deepMerge(defaultProps, additionalProps);
+        return csUtils.deepMerge(defaultProps, additionalProps);
     }
     get toolName() {
         return this.getToolName();
@@ -43,7 +43,7 @@ class BaseTool {
         return strategies[activeStrategy][callbackType]?.call(this, enabledElement, operationData, ...extraArgs);
     }
     setConfiguration(newConfiguration) {
-        this.configuration = utilities.deepMerge(this.configuration, newConfiguration);
+        this.configuration = csUtils.deepMerge(this.configuration, newConfiguration);
     }
     setActiveStrategy(strategyName) {
         this.setConfiguration({ activeStrategy: strategyName });
@@ -51,8 +51,8 @@ class BaseTool {
     getTargetImageData(targetId) {
         if (targetId.startsWith('imageId:')) {
             const imageId = targetId.split('imageId:')[1];
-            const imageURI = utilities.imageIdToURI(imageId);
-            let viewports = utilities.getViewportsWithImageURI(imageURI);
+            const imageURI = csUtils.imageIdToURI(imageId);
+            let viewports = csUtils.getViewportsWithImageURI(imageURI);
             if (!viewports || !viewports.length) {
                 return;
             }
@@ -65,16 +65,16 @@ class BaseTool {
             return viewports[0].getImageData();
         }
         else if (targetId.startsWith('volumeId:')) {
-            const volumeId = utilities.getVolumeId(targetId);
-            const viewports = utilities.getViewportsWithVolumeId(volumeId);
+            const volumeId = csUtils.getVolumeId(targetId);
+            const viewports = csUtils.getViewportsWithVolumeId(volumeId);
             if (!viewports || !viewports.length) {
                 return;
             }
             return viewports[0].getImageData();
         }
         else if (targetId.startsWith('videoId:')) {
-            const imageURI = utilities.imageIdToURI(targetId);
-            const viewports = utilities.getViewportsWithImageURI(imageURI);
+            const imageURI = csUtils.imageIdToURI(targetId);
+            const viewports = csUtils.getViewportsWithImageURI(imageURI);
             if (!viewports || !viewports.length) {
                 return;
             }
@@ -129,6 +129,33 @@ class BaseTool {
     static endGroupRecording() {
         DefaultHistoryMemo.endGroupRecording();
     }
+    static calculateLengthInIndex(calibrate, indexPoints, closed = false) {
+        const scale = calibrate?.scale || 1;
+        const scaleY = calibrate?.scaleY || scale;
+        const scaleZ = calibrate?.scaleZ || scale;
+        let length = 0;
+        const count = indexPoints.length;
+        const start = closed ? 0 : 1;
+        let lastPoint = closed ? indexPoints[count - 1] : indexPoints[0];
+        for (let i = start; i < count; i++) {
+            const point = indexPoints[i];
+            const dx = (point[0] - lastPoint[0]) / scale;
+            const dy = (point[1] - lastPoint[1]) / scaleY;
+            const dz = (point[2] - lastPoint[2]) / scaleZ;
+            length += Math.sqrt(dx * dx + dy * dy + dz * dz);
+            lastPoint = point;
+        }
+        return length;
+    }
+    static isInsideVolume(dimensions, indexPoints) {
+        const { length: count } = indexPoints;
+        for (let i = 0; i < count; i++) {
+            if (!csUtils.indexWithinDimensions(indexPoints[i], dimensions)) {
+                return false;
+            }
+        }
+        return true;
+    }
 }
 BaseTool.toolName = 'BaseTool';
 export default BaseTool;

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

@@ -113,6 +113,9 @@ class BrushTool extends LabelmapBaseTool {
             const hoverData = this._hoverData || this.createHoverData(element);
             triggerAnnotationRenderForViewportUIDs(hoverData.viewportIdsToRender);
             const operationData = this.getOperationData(element);
+            if (!operationData) {
+                return false;
+            }
             this.applyActiveStrategyCallback(enabledElement, operationData, StrategyCallbacks.OnInteractionStart);
             return true;
         };
@@ -218,6 +221,9 @@ class BrushTool extends LabelmapBaseTool {
             this._hoverData = this.createHoverData(element, currentCanvas);
             this._calculateCursor(element, currentCanvas);
             const operationData = this.getOperationData(element);
+            if (!operationData) {
+                return;
+            }
             operationData.strokePointsWorld = [
                 vec3.clone(this._lastDragInfo.world),
                 vec3.clone(currentWorld),
@@ -238,6 +244,9 @@ class BrushTool extends LabelmapBaseTool {
             const { element } = eventData;
             const enabledElement = getEnabledElement(element);
             const operationData = this.getOperationData(element);
+            if (!operationData) {
+                return;
+            }
             if (!this._previewData.preview && !this._previewData.isDrag) {
                 this.applyActiveStrategy(enabledElement, operationData);
             }

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

@@ -418,7 +418,10 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
             worldPos2Index[2] = Math.floor(worldPos2Index[2]);
             worldPos2Index[indexOfProjection] =
                 worldProjectionPointIndex[indexOfProjection];
-            if (this._isInsideVolume(worldPos1Index, worldPos2Index, dimensions)) {
+            if (CircleROITool.isInsideVolume(dimensions, [
+                worldPos1Index,
+                worldPos2Index,
+            ])) {
                 const iMin = Math.min(worldPos1Index[0], worldPos2Index[0]);
                 const iMax = Math.max(worldPos1Index[0], worldPos2Index[0]);
                 const jMin = Math.min(worldPos1Index[1], worldPos2Index[1]);

package/dist/esm/types/CalculatorTypes.d.ts

@@ -1,13 +1,15 @@
 import type { Types } from '@cornerstonejs/core';
-type Statistics = {
+import type { MeasurementType } from '../enums/MeasurementType';
+export type Statistics = {
     name: string;
     label?: string;
     value: number | number[];
     unit: null | string;
     pointIJK?: Types.Point3;
     pointLPS?: Types.Point3;
+    type?: MeasurementType;
 };
-type NamedStatistics = {
+export type NamedStatistics = {
     mean: Statistics & {
         name: 'mean';
     };
@@ -60,4 +62,3 @@ type NamedStatistics = {
     }>;
     array: Statistics[];
 };
-export type { Statistics, NamedStatistics };

package/dist/esm/types/ISculptToolShape.d.ts

@@ -1,12 +1,14 @@
 import type { Types } from '@cornerstonejs/core';
 import type { SVGDrawingHelper, EventTypes, ContourAnnotation } from '.';
-import type { PushedHandles } from '../tools/SculptorTool/CircleSculptCursor';
-import type { SculptData } from '../tools/SculptorTool';
 export interface ISculptToolShape {
     renderShape(svgDrawingHelper: SVGDrawingHelper, canvasLocation: Types.Point2, options: any): void;
-    pushHandles(viewport: Types.IViewport, sculptData: SculptData): PushedHandles;
     configureToolSize(evt: EventTypes.InteractionEventType): void;
+    interpolatePoint(viewport: Types.IViewport, angle: number, center: Types.Point2): Types.Point2;
+    getEdge(viewport: Types.IViewport, p1: Types.Point3, p2: Types.Point3, mouseCanvas: Types.Point2): {
+        point: Types.Point3;
+        angle: number;
+        canvasPoint: Types.Point2;
+    };
     updateToolSize(canvasCoords: Types.Point2, viewport: Types.IViewport, activeAnnotation: ContourAnnotation): void;
     getMaxSpacing(minSpacing: number): number;
-    getInsertPosition(previousIndex: number, nextIndex: number, sculptData: SculptData): Types.Point3;
 }

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

@@ -10,6 +10,5 @@ import getContourHolesDataCanvas from './getContourHolesDataCanvas';
 import updateContourPolyline from './updateContourPolyline';
 import acceptAutogeneratedInterpolations from './interpolation/acceptAutogeneratedInterpolations';
 import findHandlePolylineIndex from './findHandlePolylineIndex';
-import calculatePerimeter from './calculatePerimeter';
 import findIslands from './findIslands';
-export { areCoplanarContours, contourFinder, getDeduplicatedVTKPolyDataPoints, detectContourHoles, findContourHoles, generateContourSetsFromLabelmap, AnnotationToPointData, getContourHolesDataWorld, getContourHolesDataCanvas, updateContourPolyline, acceptAutogeneratedInterpolations, findHandlePolylineIndex, calculatePerimeter, findIslands, };
+export { areCoplanarContours, contourFinder, getDeduplicatedVTKPolyDataPoints, detectContourHoles, findContourHoles, generateContourSetsFromLabelmap, AnnotationToPointData, getContourHolesDataWorld, getContourHolesDataCanvas, updateContourPolyline, acceptAutogeneratedInterpolations, findHandlePolylineIndex, findIslands, };

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

@@ -10,6 +10,5 @@ import getContourHolesDataCanvas from './getContourHolesDataCanvas';
 import updateContourPolyline from './updateContourPolyline';
 import acceptAutogeneratedInterpolations from './interpolation/acceptAutogeneratedInterpolations';
 import findHandlePolylineIndex from './findHandlePolylineIndex';
-import calculatePerimeter from './calculatePerimeter';
 import findIslands from './findIslands';
-export { areCoplanarContours, contourFinder, getDeduplicatedVTKPolyDataPoints, detectContourHoles, findContourHoles, generateContourSetsFromLabelmap, AnnotationToPointData, getContourHolesDataWorld, getContourHolesDataCanvas, updateContourPolyline, acceptAutogeneratedInterpolations, findHandlePolylineIndex, calculatePerimeter, findIslands, };
+export { areCoplanarContours, contourFinder, getDeduplicatedVTKPolyDataPoints, detectContourHoles, findContourHoles, generateContourSetsFromLabelmap, AnnotationToPointData, getContourHolesDataWorld, getContourHolesDataCanvas, updateContourPolyline, acceptAutogeneratedInterpolations, findHandlePolylineIndex, findIslands, };

package/dist/esm/utilities/getCalibratedUnits.d.ts

@@ -2,6 +2,8 @@ declare const getCalibratedLengthUnitsAndScale: (image: any, handles: any) => {
     unit: string;
     areaUnit: string;
     scale: number;
+    scaleY: number;
+    scaleZ: number;
     volumeUnit: string;
 };
 declare const getCalibratedProbeUnitsAndValue: (image: any, handles: any) => {