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

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';

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

@@ -452,7 +452,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
                 const deltaInX = vec3.distance(originalWorldPoint, deltaXPoint);
                 const deltaInY = vec3.distance(originalWorldPoint, deltaYPoint);
                 const { imageData } = image;
-                const { scale, areaUnits } = getCalibratedLengthUnitsAndScale(image, () => {
+                const { scale, areaUnit } = getCalibratedLengthUnitsAndScale(image, () => {
                     const { maxX: canvasMaxX, maxY: canvasMaxY, minX: canvasMinX, minY: canvasMinY, } = math.polyline.getAABB(canvasCoordinates);
                     const topLeftBBWorld = viewport.canvasToWorld([
                         canvasMinX,
@@ -471,7 +471,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
                 cachedStats[targetId] = {
                     Modality: metadata.Modality,
                     area,
-                    areaUnits,
+                    areaUnit,
                 };
             }
             this.triggerAnnotationModified(annotation, enabledElement, ChangeTypes.StatsUpdated);
@@ -560,11 +560,11 @@ class SplineROITool extends ContourSegmentationBaseTool {
         });
         super.renderAnnotationInstance(renderContext);
         if (!data.cachedStats[targetId] ||
-            data.cachedStats[targetId].areaUnits == null) {
+            data.cachedStats[targetId].areaUnit == null) {
             data.cachedStats[targetId] = {
                 Modality: null,
                 area: null,
-                areaUnits: null,
+                areaUnit: null,
             };
             this._calculateCachedStats(annotation, element);
         }
@@ -715,12 +715,12 @@ class SplineROITool extends ContourSegmentationBaseTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { area, isEmptyArea, areaUnits } = cachedVolumeStats;
+    const { area, isEmptyArea, areaUnit } = cachedVolumeStats;
     const textLines = [];
     if (area) {
         const areaLine = isEmptyArea
             ? `Area: Oblique not supported`
-            : `Area: ${utilities.roundNumber(area)} ${areaUnits}`;
+            : `Area: ${utilities.roundNumber(area)} ${areaUnit}`;
         textLines.push(areaLine);
     }
     return textLines;

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

@@ -5,7 +5,6 @@ import WindowLevelTool from './WindowLevelTool';
 import WindowLevelRegionTool from './WindowLevelRegionTool';
 import StackScrollTool from './StackScrollTool';
 import PlanarRotateTool from './PlanarRotateTool';
-import StackScrollMouseWheelTool from './StackScrollToolMouseWheelTool';
 import ZoomTool from './ZoomTool';
 import VolumeRotateMouseWheelTool from './VolumeRotateMouseWheelTool';
 import MIPJumpToClickTool from './MIPJumpToClickTool';
@@ -16,7 +15,6 @@ import ReferenceLinesTool from './ReferenceLinesTool';
 import OverlayGridTool from './OverlayGridTool';
 import SegmentationIntersectionTool from './SegmentationIntersectionTool';
 import ReferenceCursors from './ReferenceCursors';
-import ReferenceLines from './ReferenceLinesTool';
 import ScaleOverlayTool from './ScaleOverlayTool';
 import SculptorTool from './SculptorTool';
 import BidirectionalTool from './annotation/BidirectionalTool';
@@ -49,4 +47,4 @@ import BrushTool from './segmentation/BrushTool';
 import PaintFillTool from './segmentation/PaintFillTool';
 import OrientationMarkerTool from './OrientationMarkerTool';
 import SegmentSelectTool from './segmentation/SegmentSelectTool';
-export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, ZoomTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, ReferenceLines, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, };
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, };

package/dist/esm/tools/index.js

@@ -5,7 +5,6 @@ import WindowLevelTool from './WindowLevelTool';
 import WindowLevelRegionTool from './WindowLevelRegionTool';
 import StackScrollTool from './StackScrollTool';
 import PlanarRotateTool from './PlanarRotateTool';
-import StackScrollMouseWheelTool from './StackScrollToolMouseWheelTool';
 import ZoomTool from './ZoomTool';
 import VolumeRotateMouseWheelTool from './VolumeRotateMouseWheelTool';
 import MIPJumpToClickTool from './MIPJumpToClickTool';
@@ -16,7 +15,6 @@ import ReferenceLinesTool from './ReferenceLinesTool';
 import OverlayGridTool from './OverlayGridTool';
 import SegmentationIntersectionTool from './SegmentationIntersectionTool';
 import ReferenceCursors from './ReferenceCursors';
-import ReferenceLines from './ReferenceLinesTool';
 import ScaleOverlayTool from './ScaleOverlayTool';
 import SculptorTool from './SculptorTool';
 import BidirectionalTool from './annotation/BidirectionalTool';
@@ -49,4 +47,4 @@ import BrushTool from './segmentation/BrushTool';
 import PaintFillTool from './segmentation/PaintFillTool';
 import OrientationMarkerTool from './OrientationMarkerTool';
 import SegmentSelectTool from './segmentation/SegmentSelectTool';
-export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, ZoomTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, ReferenceLines, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, };
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, };

package/dist/esm/tools/segmentation/BrushTool.d.ts

@@ -1,6 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
 import type { PublicToolProps, ToolProps, EventTypes, SVGDrawingHelper } from '../../types';
 import { BaseTool } from '../base';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 export type PreviewData = {
     preview: unknown;
     timer?: number;
@@ -24,11 +25,22 @@ declare class BrushTool extends BaseTool {
         referencedVolumeId: any;
         segmentsLocked: number[] | [];
         imageId?: undefined;
+        override?: undefined;
     } | {
         imageId: string;
         segmentsLocked: number[] | [];
         volumeId?: undefined;
         referencedVolumeId?: undefined;
+        override?: undefined;
+    } | {
+        imageId: string;
+        segmentsLocked: number[] | [];
+        override: {
+            voxelManager: Types.IVoxelManager<number> | Types.IVoxelManager<Types.RGB>;
+            imageData: vtkImageData;
+        };
+        volumeId?: undefined;
+        referencedVolumeId?: undefined;
     };
     preMouseDownCallback: (evt: EventTypes.MouseDownActivateEventType) => boolean;
     mouseMoveCallback: (evt: EventTypes.InteractionEventType) => void;
@@ -48,8 +60,13 @@ declare class BrushTool extends BaseTool {
         viewUp: any;
         strategySpecificConfiguration: any;
         preview: unknown;
+        override: {
+            voxelManager: Types.IVoxelManager<number>;
+            imageData: vtkImageData;
+        };
         segmentsLocked: number[];
         imageId?: string;
+        imageIds?: string[];
         volumeId?: string;
         referencedVolumeId?: string;
     } | {
@@ -67,6 +84,23 @@ declare class BrushTool extends BaseTool {
         referencedVolumeId: any;
         segmentsLocked: number[] | [];
         imageId?: undefined;
+        override?: undefined;
+    } | {
+        points: any;
+        segmentIndex: number;
+        previewColors: any;
+        viewPlaneNormal: any;
+        toolGroupId: string;
+        segmentationId: string;
+        segmentationRepresentationUID: string;
+        viewUp: any;
+        strategySpecificConfiguration: any;
+        preview: unknown;
+        imageId: string;
+        segmentsLocked: number[] | [];
+        volumeId?: undefined;
+        referencedVolumeId?: undefined;
+        override?: undefined;
     } | {
         points: any;
         segmentIndex: number;
@@ -80,6 +114,10 @@ declare class BrushTool extends BaseTool {
         preview: unknown;
         imageId: string;
         segmentsLocked: number[] | [];
+        override: {
+            voxelManager: Types.IVoxelManager<number> | Types.IVoxelManager<Types.RGB>;
+            imageData: vtkImageData;
+        };
         volumeId?: undefined;
         referencedVolumeId?: undefined;
     };

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

@@ -10,10 +10,11 @@ import { drawCircle as drawCircleSvg } from '../../drawingSvg';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportUIDs from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
-import { getActiveSegmentationRepresentation, getCurrentLabelmapImageIdForViewport, getSegmentation, } from '../../stateManagement/segmentation/segmentationState';
+import { getActiveSegmentationRepresentation, getCurrentLabelmapImageIdForViewport, getSegmentation, getStackSegmentationImageIdsForViewport, } from '../../stateManagement/segmentation/segmentationState';
 import { getLockedSegmentIndices } from '../../stateManagement/segmentation/segmentLocking';
 import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
 import { getSegmentIndexColor } from '../../stateManagement/segmentation/config/segmentationColor';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 class BrushTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -141,7 +142,6 @@ class BrushTool extends BaseTool {
             const eventData = evt.detail;
             const { element, currentPoints } = eventData;
             const enabledElement = getEnabledElement(element);
-            const { renderingEngine } = enabledElement;
             this.updateCursor(evt);
             const { viewportIdsToRender } = this._hoverData;
             triggerAnnotationRenderForViewportUIDs(viewportIdsToRender);
@@ -235,12 +235,45 @@ class BrushTool extends BaseTool {
                 return;
             }
             if (this.configuration.activeStrategy.includes('SPHERE')) {
-                throw new Error('Sphere manipulation is not supported for stacks of image segmentations yet');
+                const referencedImageIds = viewport.getImageIds();
+                const isValidVolumeForSphere = csUtils.isValidVolume(referencedImageIds);
+                if (!isValidVolumeForSphere) {
+                    throw new Error('Volume is not reconstructable for sphere manipulation');
+                }
+                const labelmapImageIds = getStackSegmentationImageIdsForViewport(viewport.id, segmentationId);
+                if (!labelmapImageIds || labelmapImageIds.length === 1) {
+                    return {
+                        imageId: segmentationImageId,
+                        segmentsLocked,
+                    };
+                }
+                const tempVolumeId = 'tempVolumeId';
+                const { dimensions, direction, origin, spacing, numberOfComponents, imageIds: sortedLabelmapImageIds, } = csUtils.generateVolumePropsFromImageIds(labelmapImageIds, tempVolumeId);
+                const newVoxelManager = csUtils.VoxelManager.createImageVolumeVoxelManager({
+                    dimensions,
+                    imageIds: sortedLabelmapImageIds,
+                    numberOfComponents,
+                });
+                const newImageData = vtkImageData.newInstance();
+                newImageData.setDimensions(dimensions);
+                newImageData.setSpacing(spacing);
+                newImageData.setDirection(direction);
+                newImageData.setOrigin(origin);
+                return {
+                    imageId: segmentationImageId,
+                    segmentsLocked,
+                    override: {
+                        voxelManager: newVoxelManager,
+                        imageData: newImageData,
+                    },
+                };
+            }
+            else {
+                return {
+                    imageId: segmentationImageId,
+                    segmentsLocked,
+                };
             }
-            return {
-                imageId: segmentationImageId,
-                segmentsLocked,
-            };
         }
     }
     createHoverData(element, centerCanvas) {

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

@@ -345,7 +345,7 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
             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);
         for (let i = 0; i < projectionPoints.length; i++) {
             if (!imageVolume) {
                 continue;
@@ -409,8 +409,8 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
             stdDev: stats.stdDev?.value,
             max: stats.max?.value,
             statsArray: stats.array,
-            areaUnits: measureInfo.areaUnits,
-            pixelValueUnits,
+            areaUnit: measureInfo.areaUnit,
+            modalityUnit,
         };
     }
     _calculateCachedStatsTool(annotation, enabledElement) {
@@ -456,15 +456,15 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
 }
 function defaultGetTextLines(data) {
     const cachedVolumeStats = data.cachedStats.statistics;
-    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;
 }
 CircleROIStartEndThresholdTool.toolName = 'CircleROIStartEndThreshold';

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

@@ -316,7 +316,7 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
             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);
         for (let i = 0; i < projectionPoints.length; i++) {
             if (!imageVolume) {
                 continue;
@@ -367,8 +367,8 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
             stdDev: stats.stdDev?.value,
             max: stats.max?.value,
             statsArray: stats.array,
-            areaUnits: measureInfo.areaUnits,
-            pixelValueUnits,
+            areaUnit: measureInfo.areaUnit,
+            modalityUnit,
         };
     }
     _calculateCachedStatsTool(annotation, enabledElement) {
@@ -410,15 +410,15 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
 }
 function defaultGetTextLines(data) {
     const cachedVolumeStats = data.cachedStats.statistics;
-    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;
 }
 RectangleROIStartEndThresholdTool.toolName = 'RectangleROIStartEndThreshold';

package/dist/esm/tools/segmentation/strategies/BrushStrategy.js

@@ -37,7 +37,8 @@ export default class BrushStrategy {
             }
             this._fill.forEach((func) => func(initializedData));
             const { segmentationVoxelManager, previewVoxelManager, previewSegmentIndex, } = initializedData;
-            triggerSegmentationDataModified(initializedData.segmentationId, segmentationVoxelManager.getArrayOfSlices());
+            triggerSegmentationDataModified(initializedData.segmentationId, segmentationVoxelManager.getArrayOfModifiedSlices());
+            segmentationVoxelManager.resetModifiedSlices();
             if (!previewSegmentIndex || !previewVoxelManager.modifiedSlices.size) {
                 return null;
             }
@@ -69,7 +70,9 @@ export default class BrushStrategy {
                 BrushStrategy.childFunctions[key](this, result[key]);
             }
         });
-        this.strategyFunction = (enabledElement, operationData) => this.fill(enabledElement, operationData);
+        this.strategyFunction = (enabledElement, operationData) => {
+            return this.fill(enabledElement, operationData);
+        };
         for (const key of Object.keys(BrushStrategy.childFunctions)) {
             this.strategyFunction[key] = this[key];
         }
@@ -82,9 +85,11 @@ export default class BrushStrategy {
             return operationData.preview;
         }
         const { imageVoxelManager, segmentationVoxelManager, segmentationImageData, } = data;
+        const segmentationVoxelManagerToUse = operationData.override?.voxelManager || segmentationVoxelManager;
+        const segmentationImageDataToUse = operationData.override?.imageData || segmentationImageData;
         const previewVoxelManager = operationData.preview?.previewVoxelManager ||
             VoxelManager.createHistoryVoxelManager({
-                sourceVoxelManager: segmentationVoxelManager,
+                sourceVoxelManager: segmentationVoxelManagerToUse,
             });
         const previewEnabled = !!operationData.previewColors;
         const previewSegmentIndex = previewEnabled ? 255 : undefined;
@@ -94,8 +99,8 @@ export default class BrushStrategy {
             ...operationData,
             enabledElement,
             imageVoxelManager,
-            segmentationVoxelManager,
-            segmentationImageData,
+            segmentationVoxelManager: segmentationVoxelManagerToUse,
+            segmentationImageData: segmentationImageDataToUse,
             previewVoxelManager,
             viewport,
             centerWorld: null,

package/dist/esm/tools/segmentation/strategies/compositions/islandRemoval.js

@@ -118,6 +118,6 @@ export default {
                 }
             }
         }
-        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfSlices());
+        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices());
     },
 };

package/dist/esm/tools/segmentation/strategies/compositions/preview.js

@@ -66,7 +66,7 @@ export default {
             }
         };
         tracking.forEach(callback, {});
-        triggerSegmentationDataModified(operationData.segmentationId, tracking.getArrayOfSlices());
+        triggerSegmentationDataModified(operationData.segmentationId, tracking.getArrayOfModifiedSlices());
         tracking.clear();
     },
     [StrategyCallbacks.RejectPreview]: (operationData) => {
@@ -78,7 +78,7 @@ export default {
             segmentationVoxelManager.setAtIndex(index, value);
         };
         previewVoxelManager.forEach(callback);
-        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfSlices());
+        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices());
         previewVoxelManager.clear();
     },
 };