@cornerstonejs/tools 2.0.0-beta.22 → 2.0.0-beta.23

package/dist/esm/index.d.ts

@@ -9,7 +9,7 @@ import * as cursors from './cursors';
 import * as Types from './types';
 import * as annotation from './stateManagement/annotation';
 import * as segmentation from './stateManagement/segmentation';
-import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ReferenceLines, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool } from './tools';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool } from './tools';
 import VideoRedactionTool from './tools/annotation/VideoRedactionTool';
 import * as Enums from './enums';
-export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ReferenceLines, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, };
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, };

package/dist/esm/index.js

@@ -9,7 +9,7 @@ import * as cursors from './cursors';
 import * as Types from './types';
 import * as annotation from './stateManagement/annotation';
 import * as segmentation from './stateManagement/segmentation';
-import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ReferenceLines, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, } from './tools';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, } from './tools';
 import VideoRedactionTool from './tools/annotation/VideoRedactionTool';
 import * as Enums from './enums';
-export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ReferenceLines, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, };
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, };

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

@@ -15,4 +15,6 @@ import { setAnnotationManager } from './annotation/annotationState';
 import { getAnnotationManager } from './annotation/annotationState';
 import { resetAnnotationManager } from './annotation/annotationState';
 import { invalidateAnnotation } from './annotation/annotationState';
+import addSegmentationRepresentations from './segmentation/addSegmentationRepresentations';
+import removeSegmentationRepresentations from './segmentation/removeSegmentationRepresentations';
 export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, addSegmentationRepresentations, removeSegmentationRepresentations };

package/dist/esm/stateManagement/index.js

@@ -2,6 +2,6 @@ import FrameOfReferenceSpecificAnnotationManager, { defaultFrameOfReferenceSpeci
 import * as annotationLocking from './annotation/annotationLocking';
 import * as annotationSelection from './annotation/annotationSelection';
 import { getAnnotations, addAnnotation, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, } from './annotation/annotationState';
-import { addSegmentationRepresentations } from './segmentation/addSegmentationRepresentations';
-import { removeSegmentationRepresentations } from './segmentation/removeSegmentationRepresentations';
+import addSegmentationRepresentations from './segmentation/addSegmentationRepresentations';
+import removeSegmentationRepresentations from './segmentation/removeSegmentationRepresentations';
 export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, addSegmentationRepresentations, removeSegmentationRepresentations, };

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

@@ -608,13 +608,13 @@ class BidirectionalTool extends AnnotationTool {
                 const index4 = transformWorldToIndex(imageData, worldPos4);
                 const handles1 = [index1, index2];
                 const handles2 = [index3, index4];
-                const { scale: scale1, lengthUnits: units1 } = getCalibratedLengthUnitsAndScale(image, handles1);
-                const { scale: scale2, lengthUnits: units2 } = getCalibratedLengthUnitsAndScale(image, handles2);
+                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 length = dist1 > dist2 ? dist1 : dist2;
                 const width = dist1 > dist2 ? dist2 : dist1;
-                const lengthUnits = dist1 > dist2 ? units1 : units2;
+                const unit = dist1 > dist2 ? units1 : units2;
                 const widthUnit = dist1 > dist2 ? units2 : units1;
                 this._isInsideVolume(index1, index2, index3, index4, dimensions)
                     ? (this.isHandleOutsideImage = false)
@@ -622,7 +622,7 @@ class BidirectionalTool extends AnnotationTool {
                 cachedStats[targetId] = {
                     length,
                     width,
-                    lengthUnits,
+                    unit,
                     widthUnit,
                 };
             }
@@ -712,7 +712,7 @@ class BidirectionalTool extends AnnotationTool {
 }
 function defaultGetTextLines(data, targetId) {
     const { cachedStats, label } = data;
-    const { length, width, unit, lengthUnits, widthUnit } = cachedStats[targetId];
+    const { length, width, unit } = cachedStats[targetId];
     const textLines = [];
     if (label) {
         textLines.push(label);
@@ -720,7 +720,7 @@ function defaultGetTextLines(data, targetId) {
     if (length === undefined) {
         return textLines;
     }
-    textLines.push(`L: ${csUtils.roundNumber(length)} ${lengthUnits || unit}`, `W: ${csUtils.roundNumber(width)} ${widthUnit || unit}`);
+    textLines.push(`L: ${csUtils.roundNumber(length)} ${unit || unit}`, `W: ${csUtils.roundNumber(width)} ${unit}`);
     return textLines;
 }
 BidirectionalTool.toolName = 'Bidirectional';

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

@@ -346,14 +346,14 @@ class CircleROITool extends AnnotationTool {
                 const canvasCorners = getCanvasCircleCorners(canvasCoordinates);
                 const { centerPointRadius } = this.configuration;
                 if (!data.cachedStats[targetId] ||
-                    data.cachedStats[targetId].areaUnits == null) {
+                    data.cachedStats[targetId].areaUnit == null) {
                     data.cachedStats[targetId] = {
                         Modality: null,
                         area: null,
                         max: null,
                         mean: null,
                         stdDev: null,
-                        areaUnits: null,
+                        areaUnit: null,
                         radius: null,
                         radiusUnit: null,
                         perimeter: null,
@@ -507,7 +507,7 @@ class CircleROITool extends AnnotationTool {
                     const { worldWidth, worldHeight } = getWorldWidthAndHeightFromTwoPoints(viewPlaneNormal, viewUp, worldPos1, worldPos2);
                     const isEmptyArea = worldWidth === 0 && worldHeight === 0;
                     const handles = [pos1Index, pos2Index];
-                    const { scale, lengthUnits, areaUnits } = getCalibratedLengthUnitsAndScale(image, handles);
+                    const { scale, unit, areaUnit } = getCalibratedLengthUnitsAndScale(image, handles);
                     const aspect = getCalibratedAspect(image);
                     const area = Math.abs(Math.PI *
                         (worldWidth / scale / 2) *
@@ -516,7 +516,7 @@ class CircleROITool extends AnnotationTool {
                         isPreScaled: isViewportPreScaled(viewport, targetId),
                         isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
                     };
-                    const pixelValueUnits = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
+                    const modalityUnit = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
                     const pointsInShape = voxelManager.forEach(this.configuration.statsCalculator.statsCallback, {
                         isInObject: (pointLPS) => pointInEllipse(ellipseObj, pointLPS, { fast: true }),
                         boundsIJK,
@@ -533,11 +533,11 @@ class CircleROITool extends AnnotationTool {
                         statsArray: stats.array,
                         pointsInShape: pointsInShape,
                         isEmptyArea,
-                        areaUnits,
+                        areaUnit,
                         radius: worldWidth / 2 / scale,
-                        radiusUnit: lengthUnits,
+                        radiusUnit: unit,
                         perimeter: (2 * Math.PI * (worldWidth / 2)) / scale,
-                        pixelValueUnits,
+                        modalityUnit,
                     };
                 }
                 else {
@@ -560,7 +560,7 @@ class CircleROITool extends AnnotationTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { radius, radiusUnit, area, mean, stdDev, max, isEmptyArea, areaUnits, pixelValueUnits, } = cachedVolumeStats;
+    const { radius, radiusUnit, area, mean, stdDev, max, isEmptyArea, areaUnit, modalityUnit, } = cachedVolumeStats;
     const textLines = [];
     if (radius) {
         const radiusLine = isEmptyArea
@@ -571,17 +571,17 @@ function defaultGetTextLines(data, targetId) {
     if (area) {
         const areaLine = isEmptyArea
             ? `Area: Oblique not supported`
-            : `Area: ${csUtils.roundNumber(area)} ${areaUnits}`;
+            : `Area: ${csUtils.roundNumber(area)} ${areaUnit}`;
         textLines.push(areaLine);
     }
     if (mean) {
-        textLines.push(`Mean: ${csUtils.roundNumber(mean)} ${pixelValueUnits}`);
+        textLines.push(`Mean: ${csUtils.roundNumber(mean)} ${modalityUnit}`);
     }
     if (max) {
-        textLines.push(`Max: ${csUtils.roundNumber(max)} ${pixelValueUnits}`);
+        textLines.push(`Max: ${csUtils.roundNumber(max)} ${modalityUnit}`);
     }
     if (stdDev) {
-        textLines.push(`Std Dev: ${csUtils.roundNumber(stdDev)} ${pixelValueUnits}`);
+        textLines.push(`Std Dev: ${csUtils.roundNumber(stdDev)} ${modalityUnit}`);
     }
     return textLines;
 }

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

@@ -117,13 +117,13 @@ class DragProbeTool extends ProbeTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { index, value, pixelValueUnits } = cachedVolumeStats;
+    const { index, value, modalityUnit } = cachedVolumeStats;
     if (value === undefined) {
         return;
     }
     const textLines = [];
     textLines.push(`(${index[0]}, ${index[1]}, ${index[2]})`);
-    textLines.push(`${value.toFixed(2)} ${pixelValueUnits}`);
+    textLines.push(`${value.toFixed(2)} ${modalityUnit}`);
     return textLines;
 }
 DragProbeTool.toolName = 'DragProbe';

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

@@ -427,14 +427,14 @@ class EllipticalROITool extends AnnotationTool {
                 const canvasCorners = (getCanvasEllipseCorners(canvasCoordinates));
                 const { centerPointRadius } = this.configuration;
                 if (!data.cachedStats[targetId] ||
-                    data.cachedStats[targetId].areaUnits == null) {
+                    data.cachedStats[targetId].areaUnit == null) {
                     data.cachedStats[targetId] = {
                         Modality: null,
                         area: null,
                         max: null,
                         mean: null,
                         stdDev: null,
-                        areaUnits: null,
+                        areaUnit: null,
                     };
                     this._calculateCachedStats(annotation, viewport, renderingEngine);
                 }
@@ -587,7 +587,7 @@ class EllipticalROITool extends AnnotationTool {
                 const { worldWidth, worldHeight } = getWorldWidthAndHeightFromTwoPoints(viewPlaneNormal, viewUp, worldPos1, worldPos2);
                 const isEmptyArea = worldWidth === 0 && worldHeight === 0;
                 const handles = [pos1Index, post2Index];
-                const { scale, areaUnits } = getCalibratedLengthUnitsAndScale(image, handles);
+                const { scale, areaUnit } = getCalibratedLengthUnitsAndScale(image, handles);
                 const area = Math.abs(Math.PI * (worldWidth / 2) * (worldHeight / 2)) /
                     scale /
                     scale;
@@ -595,7 +595,7 @@ class EllipticalROITool extends AnnotationTool {
                     isPreScaled: isViewportPreScaled(viewport, targetId),
                     isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
                 };
-                const pixelValueUnits = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
+                const modalityUnit = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
                 const pointsInShape = voxelManager.forEach(this.configuration.statsCalculator.statsCallback, {
                     boundsIJK,
                     imageData,
@@ -612,8 +612,8 @@ class EllipticalROITool extends AnnotationTool {
                     statsArray: stats.array,
                     pointsInShape,
                     isEmptyArea,
-                    areaUnits,
-                    pixelValueUnits,
+                    areaUnit,
+                    modalityUnit,
                 };
             }
             annotation.invalidated = false;
@@ -651,22 +651,22 @@ class EllipticalROITool extends AnnotationTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { area, mean, stdDev, max, isEmptyArea, areaUnits, pixelValueUnits } = cachedVolumeStats;
+    const { area, mean, stdDev, max, isEmptyArea, areaUnit, modalityUnit } = cachedVolumeStats;
     const textLines = [];
     if (area) {
         const areaLine = isEmptyArea
             ? `Area: Oblique not supported`
-            : `Area: ${csUtils.roundNumber(area)} ${areaUnits}`;
+            : `Area: ${csUtils.roundNumber(area)} ${areaUnit}`;
         textLines.push(areaLine);
     }
     if (mean) {
-        textLines.push(`Mean: ${csUtils.roundNumber(mean)} ${pixelValueUnits}`);
+        textLines.push(`Mean: ${csUtils.roundNumber(mean)} ${modalityUnit}`);
     }
     if (max) {
-        textLines.push(`Max: ${csUtils.roundNumber(max)} ${pixelValueUnits}`);
+        textLines.push(`Max: ${csUtils.roundNumber(max)} ${modalityUnit}`);
     }
     if (stdDev) {
-        textLines.push(`Std Dev: ${csUtils.roundNumber(stdDev)} ${pixelValueUnits}`);
+        textLines.push(`Std Dev: ${csUtils.roundNumber(stdDev)} ${modalityUnit}`);
     }
     return textLines;
 }

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

@@ -403,13 +403,13 @@ class HeightTool extends AnnotationTool {
             const index1 = transformWorldToIndex(imageData, worldPos1);
             const index2 = transformWorldToIndex(imageData, worldPos2);
             const handles = [index1, index2];
-            const { scale, lengthUnits } = getCalibratedLengthUnitsAndScale(image, handles);
+            const { scale, unit } = getCalibratedLengthUnitsAndScale(image, handles);
             const height = this._calculateHeight(worldPos1, worldPos2) / scale;
             const outside = this._isInsideVolume(index1, index2, dimensions);
             this.isHandleOutsideImage = outside;
             cachedStats[targetId] = {
                 height,
-                lengthUnits,
+                unit,
             };
         }
         annotation.invalidated = false;
@@ -423,11 +423,11 @@ class HeightTool extends AnnotationTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { height, lengthUnits } = cachedVolumeStats;
+    const { height, unit } = cachedVolumeStats;
     if (height === undefined || height === null || isNaN(height)) {
         return;
     }
-    const textLines = [`${csUtils.roundNumber(height)} ${lengthUnits}`];
+    const textLines = [`${csUtils.roundNumber(height)} ${unit}`];
     return textLines;
 }
 HeightTool.toolName = 'Height';

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

@@ -394,14 +394,14 @@ class LengthTool extends AnnotationTool {
             const index1 = transformWorldToIndex(imageData, worldPos1);
             const index2 = transformWorldToIndex(imageData, worldPos2);
             const handles = [index1, index2];
-            const { scale, lengthUnits } = getCalibratedLengthUnitsAndScale(image, handles);
+            const { scale, unit } = getCalibratedLengthUnitsAndScale(image, handles);
             const length = this._calculateLength(worldPos1, worldPos2) / scale;
             this._isInsideVolume(index1, index2, dimensions)
                 ? (this.isHandleOutsideImage = false)
                 : (this.isHandleOutsideImage = true);
             cachedStats[targetId] = {
                 length,
-                lengthUnits,
+                unit,
             };
         }
         annotation.invalidated = false;
@@ -415,11 +415,11 @@ class LengthTool extends AnnotationTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { length, lengthUnits } = cachedVolumeStats;
+    const { length, unit } = cachedVolumeStats;
     if (length === undefined || length === null || isNaN(length)) {
         return;
     }
-    const textLines = [`${csUtils.roundNumber(length)} ${lengthUnits}`];
+    const textLines = [`${csUtils.roundNumber(length)} ${unit}`];
     return textLines;
 }
 LengthTool.toolName = 'Length';

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

@@ -35,23 +35,23 @@ 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, pixelValueUnits, canvasCoordinates, calibratedScale, }: {
+    protected updateClosedCachedStats({ viewport, points, imageData, metadata, cachedStats, targetId, modalityUnit, canvasCoordinates, calibratedScale, }: {
         viewport: any;
         points: any;
         imageData: any;
         metadata: any;
         cachedStats: any;
         targetId: any;
-        pixelValueUnits: any;
+        modalityUnit: any;
         canvasCoordinates: any;
         calibratedScale: any;
     }): void;
-    protected updateOpenCachedStats({ targetId, metadata, canvasCoordinates, cachedStats, pixelValueUnits, calibratedScale, }: {
+    protected updateOpenCachedStats({ targetId, metadata, canvasCoordinates, cachedStats, modalityUnit, calibratedScale, }: {
         targetId: any;
         metadata: any;
         canvasCoordinates: any;
         cachedStats: any;
-        pixelValueUnits: any;
+        modalityUnit: any;
         calibratedScale: any;
     }): void;
     private _renderStats;

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

@@ -148,7 +148,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
                     isPreScaled: isViewportPreScaled(viewport, targetId),
                     isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
                 };
-                const pixelValueUnits = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
+                const modalityUnit = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
                 const calibratedScale = getCalibratedLengthUnitsAndScale(image, () => {
                     const polyline = data.contour.polyline;
                     const numPoints = polyline.length;
@@ -175,7 +175,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
                         imageData,
                         metadata,
                         cachedStats,
-                        pixelValueUnits,
+                        modalityUnit,
                         calibratedScale,
                     });
                 }
@@ -185,7 +185,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
                         canvasCoordinates,
                         targetId,
                         cachedStats,
-                        pixelValueUnits,
+                        modalityUnit,
                         calibratedScale,
                     });
                 }
@@ -365,14 +365,14 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
         if (!this.commonData?.movingTextBox) {
             const { data } = annotation;
             if (!data.cachedStats[targetId] ||
-                data.cachedStats[targetId].areaUnits == null) {
+                data.cachedStats[targetId].areaUnit == null) {
                 data.cachedStats[targetId] = {
                     Modality: null,
                     area: null,
                     max: null,
                     mean: null,
                     stdDev: null,
-                    areaUnits: null,
+                    areaUnit: null,
                 };
                 this._calculateCachedStats(annotation, viewport, renderingEngine, enabledElement);
             }
@@ -381,8 +381,8 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
             }
         }
     }
-    updateClosedCachedStats({ viewport, points, imageData, metadata, cachedStats, targetId, pixelValueUnits, canvasCoordinates, calibratedScale, }) {
-        const { scale, areaUnits, units } = calibratedScale;
+    updateClosedCachedStats({ viewport, points, imageData, metadata, cachedStats, targetId, modalityUnit, canvasCoordinates, calibratedScale, }) {
+        const { scale, areaUnit, units } = calibratedScale;
         const { voxelManager } = viewport.getImageData();
         const canvasPoint = canvasCoordinates[0];
         const originalWorldPoint = viewport.canvasToWorld(canvasPoint);
@@ -484,45 +484,45 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
             stdDev: stats.stdDev?.value,
             statsArray: stats.array,
             pointsInShape: pointsInShape,
-            areaUnits,
-            pixelValueUnits,
-            lengthUnits: units,
+            areaUnit,
+            modalityUnit,
+            unit: units,
         };
     }
-    updateOpenCachedStats({ targetId, metadata, canvasCoordinates, cachedStats, pixelValueUnits, calibratedScale, }) {
+    updateOpenCachedStats({ targetId, metadata, canvasCoordinates, cachedStats, modalityUnit, calibratedScale, }) {
         const { scale, units } = calibratedScale;
         cachedStats[targetId] = {
             Modality: metadata.Modality,
             length: calculatePerimeter(canvasCoordinates, false) / scale,
-            pixelValueUnits,
+            modalityUnit,
             getPixelValueUnitunit: units,
         };
     }
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { area, mean, stdDev, length, perimeter, max, isEmptyArea, lengthUnits, areaUnits, pixelValueUnits, } = cachedVolumeStats || {};
+    const { area, mean, stdDev, length, perimeter, max, isEmptyArea, unit, areaUnit, modalityUnit, } = cachedVolumeStats || {};
     const textLines = [];
     if (area) {
         const areaLine = isEmptyArea
             ? `Area: Oblique not supported`
-            : `Area: ${csUtils.roundNumber(area)} ${areaUnits}`;
+            : `Area: ${csUtils.roundNumber(area)} ${areaUnit}`;
         textLines.push(areaLine);
     }
     if (mean) {
-        textLines.push(`Mean: ${csUtils.roundNumber(mean)} ${pixelValueUnits}`);
+        textLines.push(`Mean: ${csUtils.roundNumber(mean)} ${modalityUnit}`);
     }
     if (Number.isFinite(max)) {
-        textLines.push(`Max: ${csUtils.roundNumber(max)} ${pixelValueUnits}`);
+        textLines.push(`Max: ${csUtils.roundNumber(max)} ${modalityUnit}`);
     }
     if (stdDev) {
-        textLines.push(`Std Dev: ${csUtils.roundNumber(stdDev)} ${pixelValueUnits}`);
+        textLines.push(`Std Dev: ${csUtils.roundNumber(stdDev)} ${modalityUnit}`);
     }
     if (perimeter) {
-        textLines.push(`Perimeter: ${csUtils.roundNumber(perimeter)} ${lengthUnits}`);
+        textLines.push(`Perimeter: ${csUtils.roundNumber(perimeter)} ${unit}`);
     }
     if (length) {
-        textLines.push(`${csUtils.roundNumber(length)} ${lengthUnits}`);
+        textLines.push(`${csUtils.roundNumber(length)} ${unit}`);
     }
     return textLines;
 }

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

@@ -278,25 +278,25 @@ class ProbeTool extends AnnotationTool {
                     const viewport = viewports[0];
                     ijk[2] = viewport.getCurrentImageIdIndex();
                 }
-                let pixelValueUnits;
+                let modalityUnit;
                 if (modality === 'US') {
                     const calibratedResults = getCalibratedProbeUnitsAndValue(image, [
                         ijk,
                     ]);
                     const hasEnhancedRegionValues = calibratedResults.values.every((value) => value !== null);
                     value = (hasEnhancedRegionValues ? calibratedResults.values : value);
-                    pixelValueUnits = hasEnhancedRegionValues
+                    modalityUnit = hasEnhancedRegionValues
                         ? calibratedResults.units
                         : 'raw';
                 }
                 else {
-                    pixelValueUnits = getPixelValueUnits(modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
+                    modalityUnit = getPixelValueUnits(modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
                 }
                 cachedStats[targetId] = {
                     index: ijk,
                     value,
                     Modality: modality,
-                    pixelValueUnits,
+                    modalityUnit,
                 };
             }
             else {
@@ -314,19 +314,19 @@ class ProbeTool extends AnnotationTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { index, value, pixelValueUnits } = cachedVolumeStats;
+    const { index, value, modalityUnit } = cachedVolumeStats;
     if (value === undefined) {
         return;
     }
     const textLines = [];
     textLines.push(`(${index[0]}, ${index[1]}, ${index[2]})`);
-    if (value instanceof Array && pixelValueUnits instanceof Array) {
+    if (value instanceof Array && modalityUnit instanceof Array) {
         for (let i = 0; i < value.length; i++) {
-            textLines.push(`${csUtils.roundNumber(value[i])} ${pixelValueUnits[i]}`);
+            textLines.push(`${csUtils.roundNumber(value[i])} ${modalityUnit[i]}`);
         }
     }
     else {
-        textLines.push(`${csUtils.roundNumber(value)} ${pixelValueUnits}`);
+        textLines.push(`${csUtils.roundNumber(value)} ${modalityUnit}`);
     }
     return textLines;
 }

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

@@ -346,14 +346,14 @@ class RectangleROITool extends AnnotationTool {
                 });
                 const { viewPlaneNormal, viewUp } = viewport.getCamera();
                 if (!data.cachedStats[targetId] ||
-                    data.cachedStats[targetId].areaUnits == null) {
+                    data.cachedStats[targetId].areaUnit == null) {
                     data.cachedStats[targetId] = {
                         Modality: null,
                         area: null,
                         max: null,
                         mean: null,
                         stdDev: null,
-                        areaUnits: null,
+                        areaUnit: null,
                     };
                     this._calculateCachedStats(annotation, viewPlaneNormal, viewUp, renderingEngine, enabledElement);
                 }
@@ -487,13 +487,13 @@ class RectangleROITool extends AnnotationTool {
                     ];
                     const { worldWidth, worldHeight } = getWorldWidthAndHeightFromCorners(viewPlaneNormal, viewUp, worldPos1, worldPos2);
                     const handles = [pos1Index, pos2Index];
-                    const { scale, areaUnits } = getCalibratedLengthUnitsAndScale(image, handles);
+                    const { scale, areaUnit } = getCalibratedLengthUnitsAndScale(image, handles);
                     const area = Math.abs(worldWidth * worldHeight) / (scale * scale);
                     const pixelUnitsOptions = {
                         isPreScaled: isViewportPreScaled(viewport, targetId),
                         isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
                     };
-                    const pixelValueUnits = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
+                    const modalityUnit = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
                     const pointsInShape = voxelManager.forEach(this.configuration.statsCalculator.statsCallback, {
                         boundsIJK,
                         imageData,
@@ -508,8 +508,8 @@ class RectangleROITool extends AnnotationTool {
                         max: stats.max?.value,
                         statsArray: stats.array,
                         pointsInShape: pointsInShape,
-                        areaUnits,
-                        pixelValueUnits,
+                        areaUnit,
+                        modalityUnit,
                     };
                 }
                 else {
@@ -532,15 +532,15 @@ class RectangleROITool extends AnnotationTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { area, mean, max, stdDev, areaUnits, pixelValueUnits } = cachedVolumeStats;
+    const { area, mean, max, stdDev, areaUnit, modalityUnit } = cachedVolumeStats;
     if (mean === undefined) {
         return;
     }
     const textLines = [];
-    textLines.push(`Area: ${csUtils.roundNumber(area)} ${areaUnits}`);
-    textLines.push(`Mean: ${csUtils.roundNumber(mean)} ${pixelValueUnits}`);
-    textLines.push(`Max: ${csUtils.roundNumber(max)} ${pixelValueUnits}`);
-    textLines.push(`Std Dev: ${csUtils.roundNumber(stdDev)} ${pixelValueUnits}`);
+    textLines.push(`Area: ${csUtils.roundNumber(area)} ${areaUnit}`);
+    textLines.push(`Mean: ${csUtils.roundNumber(mean)} ${modalityUnit}`);
+    textLines.push(`Max: ${csUtils.roundNumber(max)} ${modalityUnit}`);
+    textLines.push(`Std Dev: ${csUtils.roundNumber(stdDev)} ${modalityUnit}`);
     return textLines;
 }
 RectangleROITool.toolName = 'RectangleROI';