@cornerstonejs/tools 4.12.4 → 4.12.6

package/dist/esm/enums/MeasurementType.d.ts

@@ -0,0 +1,6 @@
+export declare enum MeasurementType {
+    Linear = "Linear",
+    Area = "Area",
+    Volume = "Volume",
+    Pixel = "Pixel"
+}

package/dist/esm/enums/MeasurementType.js

@@ -0,0 +1,7 @@
+export var MeasurementType;
+(function (MeasurementType) {
+    MeasurementType["Linear"] = "Linear";
+    MeasurementType["Area"] = "Area";
+    MeasurementType["Volume"] = "Volume";
+    MeasurementType["Pixel"] = "Pixel";
+})(MeasurementType || (MeasurementType = {}));

package/dist/esm/enums/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./MeasurementType";
 import { MouseBindings } from './ToolBindings';
 import { KeyboardBindings } from './ToolBindings';
 import ToolModes from './ToolModes';

package/dist/esm/enums/index.js

@@ -7,4 +7,5 @@ import { Swipe } from './Touch';
 import StrategyCallbacks from './StrategyCallbacks';
 import ChangeTypes from './ChangeTypes';
 import WorkerTypes from './WorkerTypes';
+export * from './MeasurementType';
 export { MouseBindings, KeyboardBindings, ToolModes, AnnotationStyleStates, Events, SegmentationRepresentations, Swipe, StrategyCallbacks, ChangeTypes, WorkerTypes, };

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

@@ -39,9 +39,7 @@ declare class BidirectionalTool extends AnnotationTool {
     _deactivateModify: (element: any) => void;
     renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
     _movingLongAxisWouldPutItThroughShortAxis: (firstLineSegment: any, secondLineSegment: any) => boolean;
-    _calculateLength(pos1: any, pos2: any): number;
     _calculateCachedStats: (annotation: any, renderingEngine: any, enabledElement: any) => any;
-    _isInsideVolume: (index1: any, index2: any, index3: any, index4: any, dimensions: any) => boolean;
     _getSignedAngle: (vector1: any, vector2: any) => number;
 }
 export default BidirectionalTool;

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

@@ -9,7 +9,7 @@ import { isAnnotationVisible } from '../../stateManagement/annotation/annotation
 import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
 import { drawLine as drawLineSvg, drawHandles as drawHandlesSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
 import { state } from '../../store/state';
-import { ChangeTypes, Events } from '../../enums';
+import { ChangeTypes, Events, MeasurementType } from '../../enums';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import * as lineSegment from '../../utilities/math/line';
 import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
@@ -610,28 +610,36 @@ class BidirectionalTool extends AnnotationTool {
                     continue;
                 }
                 const { imageData, dimensions } = image;
-                const index1 = transformWorldToIndex(imageData, worldPos1);
-                const index2 = transformWorldToIndex(imageData, worldPos2);
-                const index3 = transformWorldToIndex(imageData, worldPos3);
-                const index4 = transformWorldToIndex(imageData, worldPos4);
-                const handles1 = [index1, index2];
-                const handles2 = [index3, index4];
-                const { scale: scale1, unit: units1 } = getCalibratedLengthUnitsAndScale(image, handles1);
-                const { scale: scale2, unit: units2 } = getCalibratedLengthUnitsAndScale(image, handles2);
-                const dist1 = this._calculateLength(worldPos1, worldPos2) / scale1;
-                const dist2 = this._calculateLength(worldPos3, worldPos4) / scale2;
+                const handles = data.handles.points.map((point) => imageData.worldToIndex(point));
+                const handles1 = handles.slice(0, 2);
+                const handles2 = handles.slice(2, 4);
+                const calibrate = getCalibratedLengthUnitsAndScale(image, handles);
+                const dist1 = BidirectionalTool.calculateLengthInIndex(calibrate, handles1);
+                const dist2 = BidirectionalTool.calculateLengthInIndex(calibrate, handles2);
+                const { unit } = calibrate;
                 const length = dist1 > dist2 ? dist1 : dist2;
                 const width = dist1 > dist2 ? dist2 : dist1;
-                const unit = dist1 > dist2 ? units1 : units2;
-                const widthUnit = dist1 > dist2 ? units2 : units1;
-                this._isInsideVolume(index1, index2, index3, index4, dimensions)
-                    ? (this.isHandleOutsideImage = false)
-                    : (this.isHandleOutsideImage = true);
+                const widthUnit = unit;
+                this.isHandleOutsideImage = !BidirectionalTool.isInsideVolume(dimensions, handles);
                 cachedStats[targetId] = {
                     length,
                     width,
                     unit,
                     widthUnit,
+                    statsArray: [
+                        {
+                            value: length,
+                            name: 'height',
+                            unit,
+                            type: MeasurementType.Linear,
+                        },
+                        {
+                            value: width,
+                            name: 'width',
+                            unit,
+                            type: MeasurementType.Linear,
+                        },
+                    ],
                 };
             }
             const invalidated = annotation.invalidated;
@@ -641,12 +649,6 @@ class BidirectionalTool extends AnnotationTool {
             }
             return cachedStats;
         };
-        this._isInsideVolume = (index1, index2, index3, index4, dimensions) => {
-            return (csUtils.indexWithinDimensions(index1, dimensions) &&
-                csUtils.indexWithinDimensions(index2, dimensions) &&
-                csUtils.indexWithinDimensions(index3, dimensions) &&
-                csUtils.indexWithinDimensions(index4, dimensions));
-        };
         this._getSignedAngle = (vector1, vector2) => {
             return Math.atan2(vector1[0] * vector2[1] - vector1[1] * vector2[0], vector1[0] * vector2[0] + vector1[1] * vector2[1]);
         };
@@ -726,12 +728,6 @@ class BidirectionalTool extends AnnotationTool {
         triggerAnnotationRenderForViewportIds([viewport.id]);
         return annotation;
     }; }
-    _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);
-    }
 }
 function defaultGetTextLines(data, targetId) {
     const { cachedStats, label } = data;

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

@@ -30,8 +30,7 @@ declare class CircleROITool extends AnnotationTool {
     _activateDraw: (element: any) => void;
     _deactivateDraw: (element: any) => void;
     renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
-    _calculateCachedStats: (annotation: any, viewport: any, renderingEngine: any, enabledElement: any) => any;
-    _isInsideVolume: (index1: any, index2: any, dimensions: any) => boolean;
+    _calculateCachedStats: (annotation: any, viewport: any, _renderingEngine: any, _enabledElement: any) => any;
     static hydrate: (viewportId: string, points: Types.Point3[], options?: {
         annotationUID?: string;
         toolInstance?: CircleROITool;

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

@@ -1,6 +1,7 @@
-import { AnnotationTool } from '../base';
+import { AnnotationTool, BaseTool } from '../base';
+import { vec2, vec3 } from 'gl-matrix';
 import { getEnabledElement, VolumeViewport, utilities as csUtils, getEnabledElementByViewportId, EPSILON, } from '@cornerstonejs/core';
-import { getCalibratedAspect, getCalibratedLengthUnitsAndScale, } from '../../utilities/getCalibratedUnits';
+import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits';
 import throttle from '../../utilities/throttle';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
@@ -8,10 +9,9 @@ import { isAnnotationVisible } from '../../stateManagement/annotation/annotation
 import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
 import { drawCircle as drawCircleSvg, drawHandles as drawHandlesSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
 import { state } from '../../store/state';
-import { ChangeTypes, Events } from '../../enums';
+import { ChangeTypes, Events, MeasurementType } from '../../enums';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
-import getWorldWidthAndHeightFromTwoPoints from '../../utilities/planar/getWorldWidthAndHeightFromTwoPoints';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { getPixelValueUnits } from '../../utilities/getPixelValueUnits';
@@ -19,7 +19,6 @@ import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScale
 import { getCanvasCircleCorners, getCanvasCircleRadius, } from '../../utilities/math/circle';
 import { pointInEllipse } from '../../utilities/math/ellipse';
 import { BasicStatsCalculator } from '../../utilities/math/basic';
-import { vec2, vec3 } from 'gl-matrix';
 import { getStyleProperty } from '../../stateManagement/annotation/config/helpers';
 const { transformWorldToIndex } = csUtils;
 class CircleROITool extends AnnotationTool {
@@ -473,25 +472,22 @@ class CircleROITool extends AnnotationTool {
             }
             return renderStatus;
         };
-        this._calculateCachedStats = (annotation, viewport, renderingEngine, enabledElement) => {
+        this._calculateCachedStats = (annotation, viewport, _renderingEngine, _enabledElement) => {
             if (!this.configuration.calculateStats) {
                 return;
             }
-            const data = annotation.data;
+            const { data } = annotation;
             const { element } = viewport;
             const wasInvalidated = annotation.invalidated;
             const { points } = data.handles;
             const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
             const canvasCenter = canvasCoordinates[0];
             const canvasTop = canvasCoordinates[1];
-            const { viewPlaneNormal, viewUp } = viewport.getCamera();
             const [topLeftCanvas, bottomRightCanvas] = (getCanvasCircleCorners([canvasCenter, canvasTop]));
             const topLeftWorld = viewport.canvasToWorld(topLeftCanvas);
             const bottomRightWorld = viewport.canvasToWorld(bottomRightCanvas);
             const { cachedStats } = data;
             const targetIds = Object.keys(cachedStats);
-            const worldPos1 = topLeftWorld;
-            const worldPos2 = bottomRightWorld;
             for (let i = 0; i < targetIds.length; i++) {
                 const targetId = targetIds[i];
                 const image = this.getTargetImageData(targetId);
@@ -499,15 +495,49 @@ class CircleROITool extends AnnotationTool {
                     continue;
                 }
                 const { dimensions, imageData, metadata, voxelManager } = image;
-                const pos1Index = transformWorldToIndex(imageData, worldPos1);
-                pos1Index[0] = Math.floor(pos1Index[0]);
-                pos1Index[1] = Math.floor(pos1Index[1]);
-                pos1Index[2] = Math.floor(pos1Index[2]);
-                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 handles = points.map((point) => imageData.worldToIndex(point));
+                const calibrate = getCalibratedLengthUnitsAndScale(image, handles);
+                const radius = CircleROITool.calculateLengthInIndex(calibrate, handles);
+                const area = Math.PI * radius * radius;
+                const perimeter = 2 * Math.PI * radius;
+                const isEmptyArea = radius === 0;
+                const { unit, areaUnit } = calibrate;
+                const namedArea = {
+                    name: 'area',
+                    value: area,
+                    unit: areaUnit,
+                    type: MeasurementType.Area,
+                };
+                const namedCircumference = {
+                    name: 'circumference',
+                    value: perimeter,
+                    unit,
+                    type: MeasurementType.Linear,
+                };
+                const namedRadius = {
+                    name: 'radius',
+                    value: radius,
+                    unit,
+                    type: MeasurementType.Linear,
+                };
+                const statsArray = [namedArea, namedRadius, namedCircumference];
+                cachedStats[targetId] = {
+                    Modality: metadata.Modality,
+                    area,
+                    isEmptyArea,
+                    areaUnit,
+                    radius,
+                    radiusUnit: unit,
+                    perimeter,
+                    statsArray,
+                };
+                const pos1Index = transformWorldToIndex(imageData, topLeftWorld);
+                const pos2Index = transformWorldToIndex(imageData, bottomRightWorld);
+                this.isHandleOutsideImage = !BaseTool.isInsideVolume(dimensions, [
+                    pos1Index,
+                    pos2Index,
+                ]);
+                if (!this.isHandleOutsideImage) {
                     const iMin = Math.min(pos1Index[0], pos2Index[0]);
                     const iMax = Math.max(pos1Index[0], pos2Index[0]);
                     const jMin = Math.min(pos1Index[1], pos2Index[1]);
@@ -529,14 +559,6 @@ class CircleROITool extends AnnotationTool {
                         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),
@@ -553,26 +575,15 @@ class CircleROITool extends AnnotationTool {
                     }
                     const stats = this.configuration.statsCalculator.getStatistics();
                     cachedStats[targetId] = {
+                        ...cachedStats[targetId],
                         Modality: metadata.Modality,
-                        area,
                         mean: stats.mean?.value,
                         max: stats.max?.value,
                         min: stats.min?.value,
                         pointsInShape,
                         stdDev: stats.stdDev?.value,
-                        statsArray: stats.array,
-                        isEmptyArea,
-                        areaUnit,
-                        radius: worldWidth / 2 / scale,
-                        radiusUnit: unit,
-                        perimeter: (2 * Math.PI * (worldWidth / 2)) / scale,
                         modalityUnit,
-                    };
-                }
-                else {
-                    this.isHandleOutsideImage = true;
-                    cachedStats[targetId] = {
-                        Modality: metadata.Modality,
+                        statsArray: [...statsArray, ...stats.array],
                     };
                 }
             }
@@ -582,10 +593,6 @@ class CircleROITool extends AnnotationTool {
             }
             return cachedStats;
         };
-        this._isInsideVolume = (index1, index2, dimensions) => {
-            return (csUtils.indexWithinDimensions(index1, dimensions) &&
-                csUtils.indexWithinDimensions(index2, dimensions));
-        };
         this._throttledCalculateCachedStats = throttle(this._calculateCachedStats, 100, { trailing: true });
     }
     static { this.hydrate = (viewportId, points, options) => {

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;
@@ -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/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/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) => {

package/dist/esm/utilities/getCalibratedUnits.js

@@ -1,4 +1,4 @@
-import { Enums, utilities } from '@cornerstonejs/core';
+import { Enums } from '@cornerstonejs/core';
 const { CalibrationTypes } = Enums;
 const PIXEL_UNITS = 'px';
 const VOXEL_UNITS = 'voxels';
@@ -8,10 +8,6 @@ const SUPPORTED_REGION_DATA_TYPES = [
     3,
     4,
 ];
-const SUPPORTED_LENGTH_VARIANT = [
-    '3,3',
-    '4,7',
-];
 const SUPPORTED_PROBE_VARIANT = [
     '4,3',
     '4,7',
@@ -31,94 +27,67 @@ const UNIT_MAPPING = {
 };
 const EPS = 1e-3;
 const SQUARE = '\xb2';
+const types = [
+    CalibrationTypes.ERMF,
+    CalibrationTypes.USER,
+    CalibrationTypes.ERROR,
+    CalibrationTypes.PROJECTION,
+    CalibrationTypes.CALIBRATED,
+    CalibrationTypes.UNKNOWN,
+];
 const getCalibratedLengthUnitsAndScale = (image, handles) => {
-    const { calibration, hasPixelSpacing } = image;
+    const { calibration, hasPixelSpacing, spacing = [1, 1, 1] } = image;
     let unit = hasPixelSpacing ? 'mm' : PIXEL_UNITS;
     const volumeUnit = hasPixelSpacing ? 'mm\xb3' : VOXEL_UNITS;
     let areaUnit = unit + SQUARE;
-    let scale = 1;
+    const baseScale = calibration?.scale || 1;
+    let scale = baseScale / (calibration?.columnPixelSpacing || spacing[0]);
+    let scaleY = baseScale / (calibration?.rowPixelSpacing || spacing[1]);
+    let scaleZ = baseScale / spacing[2];
     let calibrationType = '';
     if (!calibration ||
         (!calibration.type && !calibration.sequenceOfUltrasoundRegions)) {
-        return { unit, areaUnit, scale, volumeUnit };
+        return { unit, areaUnit, scale, scaleY, scaleZ, volumeUnit };
+    }
+    if (types.includes(calibration?.type)) {
+        calibrationType = calibration.type;
     }
     if (calibration.type === CalibrationTypes.UNCALIBRATED) {
         return {
             unit: PIXEL_UNITS,
             areaUnit: PIXEL_UNITS + SQUARE,
             scale,
+            scaleY,
+            scaleZ,
             volumeUnit: VOXEL_UNITS,
         };
     }
     if (calibration.sequenceOfUltrasoundRegions) {
-        let imageIndex1, imageIndex2;
-        if (Array.isArray(handles) && handles.length === 2) {
-            [imageIndex1, imageIndex2] = handles;
-        }
-        else if (typeof handles === 'function') {
-            const points = handles();
-            imageIndex1 = points[0];
-            imageIndex2 = points[1];
-        }
-        let regions = calibration.sequenceOfUltrasoundRegions.filter((region) => imageIndex1[0] >= region.regionLocationMinX0 &&
-            imageIndex1[0] <= region.regionLocationMaxX1 &&
-            imageIndex1[1] >= region.regionLocationMinY0 &&
-            imageIndex1[1] <= region.regionLocationMaxY1 &&
-            imageIndex2[0] >= region.regionLocationMinX0 &&
-            imageIndex2[0] <= region.regionLocationMaxX1 &&
-            imageIndex2[1] >= region.regionLocationMinY0 &&
-            imageIndex2[1] <= region.regionLocationMaxY1);
-        if (!regions?.length) {
-            return { unit, areaUnit, scale, volumeUnit };
-        }
-        regions = regions.filter((region) => SUPPORTED_REGION_DATA_TYPES.includes(region.regionDataType) &&
-            SUPPORTED_LENGTH_VARIANT.includes(`${region.physicalUnitsXDirection},${region.physicalUnitsYDirection}`));
-        if (!regions.length) {
-            return {
-                unit: PIXEL_UNITS,
-                areaUnit: PIXEL_UNITS + SQUARE,
-                scale,
-                volumeUnit: VOXEL_UNITS,
-            };
-        }
-        const region = regions[0];
-        const physicalDeltaX = Math.abs(region.physicalDeltaX);
-        const physicalDeltaY = Math.abs(region.physicalDeltaY);
-        const isSamePhysicalDelta = utilities.isEqual(physicalDeltaX, physicalDeltaY, EPS);
-        if (isSamePhysicalDelta) {
+        const region = calibration.sequenceOfUltrasoundRegions.find((region) => handles.every((handle) => handle[0] >= region.regionLocationMinX0 &&
+            handle[0] <= region.regionLocationMaxX1 &&
+            handle[1] >= region.regionLocationMinY0 &&
+            handle[1] <= region.regionLocationMaxY1) && SUPPORTED_REGION_DATA_TYPES.includes(region.regionDataType));
+        if (region &&
+            region.physicalUnitsXDirection === region.physicalUnitsYDirection) {
+            const physicalDeltaX = Math.abs(region.physicalDeltaX);
+            const physicalDeltaY = Math.abs(region.physicalDeltaY);
             scale = 1 / physicalDeltaX;
+            scaleY = 1 / physicalDeltaY;
             calibrationType = 'US Region';
             unit = UNIT_MAPPING[region.physicalUnitsXDirection] || 'unknown';
             areaUnit = unit + SQUARE;
         }
-        else {
-            return {
-                unit: PIXEL_UNITS,
-                areaUnit: PIXEL_UNITS + SQUARE,
-                scale,
-                volumeUnit: VOXEL_UNITS,
-            };
-        }
     }
     else if (calibration.scale) {
         scale = calibration.scale;
     }
-    const types = [
-        CalibrationTypes.ERMF,
-        CalibrationTypes.USER,
-        CalibrationTypes.ERROR,
-        CalibrationTypes.PROJECTION,
-        CalibrationTypes.CALIBRATED,
-        CalibrationTypes.UNKNOWN,
-    ];
-    if (types.includes(calibration?.type)) {
-        calibrationType = calibration.type;
-    }
     return {
         unit: unit + (calibrationType ? ` ${calibrationType}` : ''),
         areaUnit: areaUnit + (calibrationType ? ` ${calibrationType}` : ''),
-        scale,
         volumeUnit: volumeUnit + (calibrationType ? ` ${calibrationType}` : ''),
+        scale,
+        scaleY,
+        scaleZ,
     };
 };
 const getCalibratedProbeUnitsAndValue = (image, handles) => {

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.12.4";
+export declare const version = "4.12.6";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '4.12.4';
+export const version = '4.12.6';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "4.12.4",
+  "version": "4.12.6",
   "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.12.4",
+    "@cornerstonejs/core": "4.12.6",
     "@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": "709d5a61b1acccf6a2dd8f9193907f98b5ed6c4c"
+  "gitHead": "67da5ec35cb711e4310f0f1971bd8ed090377338"
 }

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

@@ -1,2 +0,0 @@
-export declare function calculatePerimeter(polyline: number[][], closed: boolean): number;
-export default calculatePerimeter;

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

@@ -1,16 +0,0 @@
-import { vec3 } from 'gl-matrix';
-export function calculatePerimeter(polyline, closed) {
-    let perimeter = 0;
-    for (let i = 0; i < polyline.length - 1; i++) {
-        const point1 = polyline[i];
-        const point2 = polyline[i + 1];
-        perimeter += vec3.dist(point1, point2);
-    }
-    if (closed) {
-        const firstPoint = polyline[0];
-        const lastPoint = polyline[polyline.length - 1];
-        perimeter += vec3.dist(firstPoint, lastPoint);
-    }
-    return perimeter;
-}
-export default calculatePerimeter;