@cornerstonejs/tools 2.8.5 → 2.9.0

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

@@ -1,13 +1,25 @@
-import { getEnabledElement, utilities as csUtils, cache, } from '@cornerstonejs/core';
+import { getEnabledElement, utilities as csUtils, cache, getRenderingEngine, StackViewport, } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import { SegmentationRepresentations } from '../../enums';
 import { segmentIndex as segmentIndexController, state as segmentationState, activeSegmentation, } from '../../stateManagement/segmentation';
 import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
 import { getSVGStyleForSegment } from '../../utilities/segmentation/getSVGStyleForSegment';
+import IslandRemoval from '../../utilities/segmentation/islandRemoval';
 const { transformWorldToIndex, transformIndexToWorld } = csUtils;
 class GrowCutBaseTool extends BaseTool {
+    static { this.lastGrowCutCommand = null; }
     constructor(toolProps, defaultToolProps) {
-        super(toolProps, defaultToolProps);
+        const baseToolProps = csUtils.deepMerge({
+            configuration: {
+                positiveSeedVariance: 0.1,
+                negativeSeedVariance: 0.9,
+                shrinkExpandIncrement: 0.05,
+                islandRemoval: {
+                    enabled: false,
+                },
+            },
+        }, defaultToolProps);
+        super(toolProps, baseToolProps);
     }
     async preMouseDownCallback(evt) {
         const eventData = evt.detail;
@@ -16,7 +28,7 @@ class GrowCutBaseTool extends BaseTool {
         const enabledElement = getEnabledElement(element);
         const { viewport, renderingEngine } = enabledElement;
         const { viewUp } = viewport.getCamera();
-        const { segmentationId, segmentIndex, labelmapVolumeId, referencedVolumeId, } = this.getLabelmapSegmentationData(viewport);
+        const { segmentationId, segmentIndex, labelmapVolumeId, referencedVolumeId, } = await this.getLabelmapSegmentationData(viewport);
         if (!this._isOrthogonalView(viewport, referencedVolumeId)) {
             throw new Error('Oblique view is not supported yet');
         }
@@ -37,18 +49,59 @@ class GrowCutBaseTool extends BaseTool {
         evt.preventDefault();
         return true;
     }
-    async getGrowCutLabelmap() {
+    shrink() {
+        this._runLastCommand({
+            shrinkExpandAmount: -this.configuration.shrinkExpandIncrement,
+        });
+    }
+    expand() {
+        this._runLastCommand({
+            shrinkExpandAmount: this.configuration.shrinkExpandIncrement,
+        });
+    }
+    refresh() {
+        this._runLastCommand();
+    }
+    async getGrowCutLabelmap(_growCutData) {
         throw new Error('Not implemented');
     }
     async runGrowCut() {
-        const { segmentation: { segmentationId, segmentIndex, labelmapVolumeId }, } = this.growCutData;
+        const { growCutData, configuration: config } = this;
+        const { segmentation: { segmentationId, segmentIndex, labelmapVolumeId }, } = growCutData;
+        const hasSeedVarianceData = config.positiveSeedVariance !== undefined &&
+            config.negativeSeedVariance !== undefined;
         const labelmap = cache.getVolume(labelmapVolumeId);
-        const growcutLabelmap = await this.getGrowCutLabelmap();
-        this.applyGrowCutLabelmap(segmentationId, segmentIndex, labelmap, growcutLabelmap);
+        let shrinkExpandValue = 0;
+        const growCutCommand = async ({ shrinkExpandAmount = 0 } = {}) => {
+            const { positiveSeedVariance, negativeSeedVariance } = config;
+            let newPositiveSeedVariance = undefined;
+            let newNegativeSeedVariance = undefined;
+            shrinkExpandValue += shrinkExpandAmount;
+            if (hasSeedVarianceData) {
+                newPositiveSeedVariance = positiveSeedVariance + shrinkExpandValue;
+                newNegativeSeedVariance = negativeSeedVariance + shrinkExpandValue;
+            }
+            const updatedGrowCutData = Object.assign({}, growCutData, {
+                options: {
+                    positiveSeedValue: segmentIndex,
+                    negativeSeedValue: 255,
+                    positiveSeedVariance: newPositiveSeedVariance,
+                    negativeSeedVariance: newNegativeSeedVariance,
+                },
+            });
+            const growcutLabelmap = await this.getGrowCutLabelmap(updatedGrowCutData);
+            this.applyGrowCutLabelmap(segmentationId, segmentIndex, labelmap, growcutLabelmap);
+            this._removeIslands(growCutData);
+        };
+        await growCutCommand();
+        if (hasSeedVarianceData) {
+            GrowCutBaseTool.lastGrowCutCommand = growCutCommand;
+        }
+        this.growCutData = null;
     }
     applyGrowCutLabelmap(segmentationId, segmentIndex, targetLabelmap, sourceLabelmap) {
         const srcLabelmapData = sourceLabelmap.voxelManager.getCompleteScalarDataArray();
-        const targetLabelmapData = targetLabelmap.voxelManager.getCompleteScalarDataArray();
+        const tgtVoxelManager = targetLabelmap.voxelManager;
         const [srcColumns, srcRows, srcNumSlices] = sourceLabelmap.dimensions;
         const [tgtColumns, tgtRows] = targetLabelmap.dimensions;
         const srcPixelsPerSlice = srcColumns * srcRows;
@@ -62,29 +115,34 @@ class GrowCutBaseTool extends BaseTool {
                 const srcOffset = srcRow * srcColumns + srcSlice * srcPixelsPerSlice;
                 const tgtOffset = tgtColumn + tgtRow * tgtColumns + tgtSlice * tgtPixelsPerSlice;
                 for (let column = 0; column < srcColumns; column++) {
-                    targetLabelmapData[tgtOffset + column] =
-                        srcLabelmapData[srcOffset + column] === segmentIndex
-                            ? segmentIndex
-                            : 0;
+                    const labelmapValue = srcLabelmapData[srcOffset + column] === segmentIndex
+                        ? segmentIndex
+                        : 0;
+                    tgtVoxelManager.setAtIndex(tgtOffset + column, labelmapValue);
                 }
             }
         }
-        targetLabelmap.voxelManager.setCompleteScalarDataArray(targetLabelmapData);
         triggerSegmentationDataModified(segmentationId);
     }
-    getSegmentStyle({ segmentationId, viewportId, segmentIndex }) {
-        return getSVGStyleForSegment({
-            segmentationId,
-            segmentIndex,
-            viewportId,
-        });
+    _runLastCommand({ shrinkExpandAmount = 0 } = {}) {
+        const cmd = GrowCutBaseTool.lastGrowCutCommand;
+        if (cmd) {
+            cmd({ shrinkExpandAmount });
+        }
     }
-    getLabelmapSegmentationData(viewport) {
-        const { segmentationId } = activeSegmentation.getActiveSegmentation(viewport.id);
+    async getLabelmapSegmentationData(viewport) {
+        const activeSeg = activeSegmentation.getActiveSegmentation(viewport.id);
+        if (!activeSeg) {
+            throw new Error('No active segmentation found');
+        }
+        const { segmentationId } = activeSeg;
         const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
         const { representationData } = segmentationState.getSegmentation(segmentationId);
         const labelmapData = representationData[SegmentationRepresentations.Labelmap];
         const { volumeId: labelmapVolumeId, referencedVolumeId } = labelmapData;
+        if (!labelmapVolumeId) {
+            throw new Error('Labelmap volume id not found - not implemented');
+        }
         return {
             segmentationId,
             segmentIndex,
@@ -101,6 +159,51 @@ class GrowCutBaseTool extends BaseTool {
             csUtils.isEqual(Math.abs(vec[1]), 1) ||
             csUtils.isEqual(Math.abs(vec[2]), 1));
     }
+    getRemoveIslandData(_growCutData) {
+        return;
+    }
+    _removeIslands(growCutData) {
+        const { islandRemoval: config } = this.configuration;
+        if (!config.enabled) {
+            return;
+        }
+        const { segmentation: { segmentIndex, labelmapVolumeId }, renderingEngineId, viewportId, } = growCutData;
+        const labelmap = cache.getVolume(labelmapVolumeId);
+        const removeIslandData = this.getRemoveIslandData(growCutData);
+        if (!removeIslandData) {
+            return;
+        }
+        const [width, height] = labelmap.dimensions;
+        const numPixelsPerSlice = width * height;
+        const { worldIslandPoints = [], islandPointIndexes = [] } = removeIslandData;
+        let ijkIslandPoints = [...(removeIslandData?.ijkIslandPoints ?? [])];
+        const renderingEngine = getRenderingEngine(renderingEngineId);
+        const viewport = renderingEngine.getViewport(viewportId);
+        const { voxelManager } = labelmap;
+        const islandRemoval = new IslandRemoval();
+        ijkIslandPoints = ijkIslandPoints.concat(worldIslandPoints.map((worldPoint) => transformWorldToIndex(labelmap.imageData, worldPoint)));
+        ijkIslandPoints = ijkIslandPoints.concat(islandPointIndexes.map((pointIndex) => {
+            const x = pointIndex % width;
+            const y = Math.floor(pointIndex / width) % height;
+            const z = Math.floor(pointIndex / numPixelsPerSlice);
+            return [x, y, z];
+        }));
+        islandRemoval.initialize(viewport, voxelManager, {
+            points: ijkIslandPoints,
+            previewSegmentIndex: segmentIndex,
+            segmentIndex,
+        });
+        islandRemoval.floodFillSegmentIsland();
+        islandRemoval.removeExternalIslands();
+        islandRemoval.removeInternalIslands();
+    }
+    getSegmentStyle({ segmentationId, viewportId, segmentIndex }) {
+        return getSVGStyleForSegment({
+            segmentationId,
+            segmentIndex,
+            viewportId,
+        });
+    }
 }
 GrowCutBaseTool.toolName = 'GrowCutBaseTool';
 export default GrowCutBaseTool;

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

@@ -41,6 +41,7 @@ import AnnotationEraserTool from './AnnotationEraserTool';
 import RegionSegmentTool from './annotation/RegionSegmentTool';
 import RegionSegmentPlusTool from './annotation/RegionSegmentPlusTool';
 import WholeBodySegmentTool from './annotation/WholeBodySegmentTool';
+import LabelmapBaseTool from './segmentation/LabelmapBaseTool';
 import RectangleScissorsTool from './segmentation/RectangleScissorsTool';
 import CircleScissorsTool from './segmentation/CircleScissorsTool';
 import SphereScissorsTool from './segmentation/SphereScissorsTool';
@@ -51,4 +52,5 @@ 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, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, 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, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, };
+import * as strategies from './segmentation/strategies';
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, 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, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, LabelmapBaseTool, strategies, };

package/dist/esm/tools/index.js

@@ -41,6 +41,7 @@ import AnnotationEraserTool from './AnnotationEraserTool';
 import RegionSegmentTool from './annotation/RegionSegmentTool';
 import RegionSegmentPlusTool from './annotation/RegionSegmentPlusTool';
 import WholeBodySegmentTool from './annotation/WholeBodySegmentTool';
+import LabelmapBaseTool from './segmentation/LabelmapBaseTool';
 import RectangleScissorsTool from './segmentation/RectangleScissorsTool';
 import CircleScissorsTool from './segmentation/CircleScissorsTool';
 import SphereScissorsTool from './segmentation/SphereScissorsTool';
@@ -51,4 +52,5 @@ 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, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, 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, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, };
+import * as strategies from './segmentation/strategies';
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, 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, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, LabelmapBaseTool, strategies, };

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

@@ -3,7 +3,6 @@ import type { PublicToolProps, ToolProps, EventTypes, SVGDrawingHelper } from '.
 import LabelmapBaseTool from './LabelmapBaseTool';
 declare class BrushTool extends LabelmapBaseTool {
     static toolName: any;
-    prg: any;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     onSetToolPassive: (evt: any) => void;
     onSetToolEnabled: () => void;

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

@@ -31,8 +31,9 @@ export default class LabelmapBaseTool extends BaseTool {
         centerCanvas?: Array<number>;
         viewport: Types.IViewport;
     };
-    protected _previewData?: PreviewData;
+    static previewData?: PreviewData;
     constructor(toolProps: any, defaultToolProps: any);
+    protected get _previewData(): PreviewData;
     createMemo(segmentId: string, segmentationVoxelManager: any, preview: any): LabelmapMemo.LabelmapMemo;
     createEditData(element: any): {
         volumeId: string;
@@ -157,4 +158,7 @@ export default class LabelmapBaseTool extends BaseTool {
     }): unknown;
     rejectPreview(element?: HTMLDivElement): void;
     acceptPreview(element?: HTMLDivElement): void;
+    static viewportContoursToLabelmap(viewport: Types.IViewport, options?: {
+        removeContours: boolean;
+    }): void;
 }

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

@@ -11,17 +11,25 @@ import { getSegmentIndexColor } from '../../stateManagement/segmentation/config/
 import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
 import { StrategyCallbacks } from '../../enums';
 import * as LabelmapMemo from '../../utilities/segmentation/createLabelmapMemo';
+import { getAllAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
+import { filterAnnotationsForDisplay } from '../../utilities/planar';
+import { isPointInsidePolyline3D } from '../../utilities/math/polyline';
+import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
+import { fillInsideCircle } from './strategies';
 export default class LabelmapBaseTool extends BaseTool {
+    static { this.previewData = {
+        preview: null,
+        element: null,
+        timerStart: 0,
+        timer: null,
+        startPoint: [NaN, NaN],
+        isDrag: false,
+    }; }
     constructor(toolProps, defaultToolProps) {
         super(toolProps, defaultToolProps);
-        this._previewData = {
-            preview: null,
-            element: null,
-            timerStart: 0,
-            timer: null,
-            startPoint: [NaN, NaN],
-            isDrag: false,
-        };
+    }
+    get _previewData() {
+        return LabelmapBaseTool.previewData;
     }
     createMemo(segmentId, segmentationVoxelManager, preview) {
         this.memo ||= LabelmapMemo.createLabelmapMemo(segmentId, segmentationVoxelManager, preview);
@@ -175,7 +183,7 @@ export default class LabelmapBaseTool extends BaseTool {
             points: data?.handles?.points,
             segmentIndex,
             previewColors: this.configuration.preview?.enabled || this._previewData.preview
-                ? this.configuration.preview.previewColors
+                ? this.configuration.preview?.previewColors
                 : null,
             viewPlaneNormal,
             toolGroupId: this.toolGroupId,
@@ -188,6 +196,7 @@ export default class LabelmapBaseTool extends BaseTool {
         return operationData;
     }
     addPreview(element = this._previewData.element, options) {
+        const { _previewData } = this;
         const acceptReject = options?.acceptReject;
         if (acceptReject === true) {
             this.acceptPreview(element);
@@ -196,9 +205,9 @@ export default class LabelmapBaseTool extends BaseTool {
             this.rejectPreview(element);
         }
         const enabledElement = getEnabledElement(element);
-        this._previewData.preview = this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.AddPreview);
-        this._previewData.isDrag = true;
-        return this._previewData.preview;
+        _previewData.preview = this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.AddPreview);
+        _previewData.isDrag = true;
+        return _previewData.preview;
     }
     rejectPreview(element = this._previewData.element) {
         if (!element || !this._previewData.preview) {
@@ -220,4 +229,90 @@ export default class LabelmapBaseTool extends BaseTool {
         this._previewData.preview = null;
         this.doneEditMemo();
     }
+    static viewportContoursToLabelmap(viewport, options) {
+        const removeContours = options?.removeContours ?? true;
+        const annotations = getAllAnnotations();
+        const viewAnnotations = filterAnnotationsForDisplay(viewport, annotations);
+        if (!viewAnnotations?.length) {
+            return;
+        }
+        const contourAnnotations = viewAnnotations.filter((annotation) => annotation.data.contour?.polyline?.length);
+        if (!contourAnnotations.length) {
+            return;
+        }
+        const brushInstance = new LabelmapBaseTool({}, {
+            configuration: {
+                strategies: {
+                    FILL_INSIDE_CIRCLE: fillInsideCircle,
+                },
+                activeStrategy: 'FILL_INSIDE_CIRCLE',
+            },
+        });
+        const preview = brushInstance.addPreview(viewport.element);
+        const { memo, segmentationId } = preview;
+        const previewVoxels = memo?.voxelManager || preview.previewVoxelManager;
+        const segmentationVoxels = previewVoxels.sourceVoxelManager || previewVoxels;
+        const { dimensions } = previewVoxels;
+        const imageData = viewport
+            .getDefaultActor()
+            .actor.getMapper()
+            .getInputData();
+        for (const annotation of contourAnnotations) {
+            const boundsIJK = [
+                [Infinity, -Infinity],
+                [Infinity, -Infinity],
+                [Infinity, -Infinity],
+            ];
+            const { polyline } = annotation.data.contour;
+            for (const point of polyline) {
+                const indexPoint = imageData.worldToIndex(point);
+                indexPoint.forEach((v, idx) => {
+                    boundsIJK[idx][0] = Math.min(boundsIJK[idx][0], v);
+                    boundsIJK[idx][1] = Math.max(boundsIJK[idx][1], v);
+                });
+            }
+            boundsIJK.forEach((bound, idx) => {
+                bound[0] = Math.round(Math.max(0, bound[0]));
+                bound[1] = Math.round(Math.min(dimensions[idx] - 1, bound[1]));
+            });
+            const activeIndex = getActiveSegmentIndex(segmentationId);
+            const startPoint = annotation.data.handles?.[0] || polyline[0];
+            const startIndex = imageData.worldToIndex(startPoint).map(Math.round);
+            const startValue = segmentationVoxels.getAtIJKPoint(startIndex) || 0;
+            let hasZeroIndex = false;
+            let hasPositiveIndex = false;
+            for (const polyPoint of polyline) {
+                const polyIndex = imageData.worldToIndex(polyPoint).map(Math.round);
+                const polyValue = segmentationVoxels.getAtIJKPoint(polyIndex);
+                if (polyValue === startValue) {
+                    hasZeroIndex = true;
+                }
+                else if (polyValue >= 0) {
+                    hasPositiveIndex = true;
+                }
+            }
+            const hasBoth = hasZeroIndex && hasPositiveIndex;
+            const segmentIndex = hasBoth
+                ? startValue
+                : startValue === 0
+                    ? activeIndex
+                    : 0;
+            for (let i = boundsIJK[0][0]; i <= boundsIJK[0][1]; i++) {
+                for (let j = boundsIJK[1][0]; j <= boundsIJK[1][1]; j++) {
+                    for (let k = boundsIJK[2][0]; k <= boundsIJK[2][1]; k++) {
+                        const worldPoint = imageData.indexToWorld([i, j, k]);
+                        const isContained = isPointInsidePolyline3D(worldPoint, polyline);
+                        if (isContained) {
+                            previewVoxels.setAtIJK(i, j, k, segmentIndex);
+                        }
+                    }
+                }
+            }
+            if (removeContours) {
+                removeAnnotation(annotation.annotationUID);
+            }
+        }
+        const slices = previewVoxels.getArrayOfModifiedSlices();
+        triggerSegmentationDataModified(segmentationId, slices);
+    }
 }

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

@@ -1,7 +1,7 @@
 import determineSegmentIndex from './determineSegmentIndex';
 import dynamicThreshold from './dynamicThreshold';
 import erase from './erase';
-import islandRemoval from './islandRemoval';
+import islandRemoval from './islandRemovalComposition';
 import preview from './preview';
 import regionFill from './regionFill';
 import setValue from './setValue';

package/dist/esm/tools/segmentation/strategies/compositions/islandRemovalComposition.d.ts

@@ -0,0 +1,5 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+declare const _default: {
+    onInteractionEnd: (operationData: InitializedOperationData) => void;
+};
+export default _default;

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

@@ -0,0 +1,27 @@
+import { triggerSegmentationDataModified } from '../../../../stateManagement/segmentation/triggerSegmentationEvents';
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+import IslandRemoval from '../../../../utilities/segmentation/islandRemoval';
+export default {
+    [StrategyCallbacks.OnInteractionEnd]: (operationData) => {
+        const { strategySpecificConfiguration, previewSegmentIndex, segmentIndex, viewport, previewVoxelManager, segmentationVoxelManager, } = operationData;
+        if (!strategySpecificConfiguration.THRESHOLD || segmentIndex === null) {
+            return;
+        }
+        const islandRemoval = new IslandRemoval();
+        const voxelManager = previewVoxelManager ?? segmentationVoxelManager;
+        if (!islandRemoval.initialize(viewport, voxelManager, {
+            previewSegmentIndex,
+            segmentIndex,
+        })) {
+            return;
+        }
+        islandRemoval.floodFillSegmentIsland();
+        islandRemoval.removeExternalIslands();
+        islandRemoval.removeInternalIslands();
+        const arrayOfSlices = voxelManager.getArrayOfModifiedSlices();
+        if (!arrayOfSlices) {
+            return;
+        }
+        triggerSegmentationDataModified(operationData.segmentationId, arrayOfSlices, previewSegmentIndex);
+    },
+};

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

@@ -2,6 +2,11 @@ import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 import VolumetricCalculator from '../../../../utilities/segmentation/VolumetricCalculator';
 import { getActiveSegmentIndex } from '../../../../stateManagement/segmentation/getActiveSegmentIndex';
 import { getStrategyData } from '../utils/getStrategyData';
+import { utilities } from '@cornerstonejs/core';
+import { getPixelValueUnits } from '../../../../utilities/getPixelValueUnits';
+import { AnnotationTool } from '../../../base';
+import { isViewportPreScaled } from '../../../../utilities/viewport/isViewportPreScaled';
+const radiusForVol1 = Math.pow((3 * 1000) / (4 * Math.PI), 1 / 3);
 export default {
     [StrategyCallbacks.GetStatistics]: function (enabledElement, operationData, options) {
         const { viewport } = enabledElement;
@@ -29,8 +34,70 @@ export default {
                 return;
             }
             const imageValue = imageVoxelManager.getAtIJKPoint(pointIJK);
-            VolumetricCalculator.statsCallback({ value: imageValue });
+            VolumetricCalculator.statsCallback({ value: imageValue, pointIJK });
         });
-        return VolumetricCalculator.getStatistics({ spacing });
+        const targetId = viewport.getReferenceId();
+        const modalityUnitOptions = {
+            isPreScaled: isViewportPreScaled(viewport, targetId),
+            isSuvScaled: AnnotationTool.isSuvScaled(viewport, targetId, viewport.getCurrentImageId()),
+        };
+        const imageData = viewport.getImageData();
+        const unit = getPixelValueUnits(imageData.metadata.Modality, viewport.getCurrentImageId(), modalityUnitOptions);
+        const stats = VolumetricCalculator.getStatistics({ spacing, unit });
+        const { maxIJKs } = stats;
+        if (!maxIJKs?.length) {
+            return stats;
+        }
+        stats.mean.unit = unit;
+        stats.max.unit = unit;
+        stats.min.unit = unit;
+        if (unit !== 'SUV') {
+            return;
+        }
+        const radiusIJK = spacing.map((s) => Math.max(1, Math.round((1.1 * radiusForVol1) / s)));
+        for (const testMax of maxIJKs) {
+            const testStats = getSphereStats(testMax, radiusIJK, segmentationImageData, imageVoxelManager, spacing);
+            if (!testStats) {
+                continue;
+            }
+            const { mean } = testStats;
+            if (!stats.peakValue || stats.peakValue.value <= mean.value) {
+                stats.peakValue = {
+                    name: 'peakValue',
+                    label: 'Peak Value',
+                    value: mean.value,
+                    unit,
+                };
+            }
+        }
+        return stats;
     },
 };
+function getSphereStats(testMax, radiusIJK, segData, imageVoxels, spacing) {
+    const { pointIJK: centerIJK } = testMax;
+    const boundsIJK = centerIJK.map((ijk, idx) => [
+        ijk - radiusIJK[idx],
+        ijk + radiusIJK[idx],
+    ]);
+    const testFunction = (_pointLPS, pointIJK) => {
+        const i = (pointIJK[0] - centerIJK[0]) / radiusIJK[0];
+        const j = (pointIJK[1] - centerIJK[1]) / radiusIJK[1];
+        const k = (pointIJK[2] - centerIJK[2]) / radiusIJK[2];
+        const radius = i * i + j * j + k * k;
+        return radius <= 1;
+    };
+    const statsFunction = ({ pointIJK, pointLPS }) => {
+        const value = imageVoxels.getAtIJKPoint(pointIJK);
+        if (value === undefined) {
+            return;
+        }
+        VolumetricCalculator.statsCallback({ value, pointLPS, pointIJK });
+    };
+    VolumetricCalculator.statsInit({ storePointData: false });
+    utilities.pointInShapeCallback(segData, {
+        pointInShapeFn: testFunction,
+        callback: statsFunction,
+        boundsIJK,
+    });
+    return VolumetricCalculator.getStatistics({ spacing });
+}

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

@@ -31,6 +31,10 @@ type NamedStatistics = {
         name: 'circumference';
     };
     pointsInShape?: Types.IPointsManager<Types.Point3>;
+    maxIJKs?: Array<{
+        value: number;
+        pointIJK: Types.Point3;
+    }>;
     array: Statistics[];
 };
 export type { Statistics, NamedStatistics };

package/dist/esm/utilities/contourSegmentation/addContourSegmentationAnnotation.js

@@ -11,8 +11,11 @@ export function addContourSegmentationAnnotation(annotation) {
     if (!segmentation.representationData.Contour) {
         segmentation.representationData.Contour = { annotationUIDsMap: new Map() };
     }
-    const { annotationUIDsMap } = segmentation.representationData.Contour;
-    let annotationsUIDsSet = annotationUIDsMap.get(segmentIndex);
+    let { annotationUIDsMap } = segmentation.representationData.Contour;
+    if (!annotationUIDsMap) {
+        annotationUIDsMap = new Map();
+    }
+    let annotationsUIDsSet = annotationUIDsMap?.get(segmentIndex);
     if (!annotationsUIDsSet) {
         annotationsUIDsSet = new Set();
         annotationUIDsMap.set(segmentIndex, annotationsUIDsSet);

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

@@ -33,4 +33,6 @@ import * as voi from './voi';
 import * as contourSegmentation from './contourSegmentation';
 import { pointInSurroundingSphereCallback } from './pointInSurroundingSphereCallback';
 declare const roundNumber: typeof utilities.roundNumber;
-export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, annotationFrameRange, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, };
+import normalizeViewportPlane from './normalizeViewportPlane';
+import IslandRemoval from './segmentation/islandRemoval';
+export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, annotationFrameRange, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, };

package/dist/esm/utilities/index.js

@@ -33,4 +33,6 @@ import * as voi from './voi';
 import * as contourSegmentation from './contourSegmentation';
 import { pointInSurroundingSphereCallback } from './pointInSurroundingSphereCallback';
 const roundNumber = utilities.roundNumber;
-export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, annotationFrameRange, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, };
+import normalizeViewportPlane from './normalizeViewportPlane';
+import IslandRemoval from './segmentation/islandRemoval';
+export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, annotationFrameRange, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, };

package/dist/esm/utilities/planar/filterAnnotationsWithinSlice.js

@@ -27,14 +27,14 @@ export default function filterAnnotationsWithinSlice(annotations, camera, spacin
     const annotationsWithinSlice = [];
     for (const annotation of annotationsWithParallelNormals) {
         const data = annotation.data;
-        const point = data.handles.points[0];
+        const point = data.handles.points[0] || data.contour?.polyline[0];
         if (!annotation.isVisible) {
             continue;
         }
         const dir = vec3.create();
         if (!point) {
             annotationsWithinSlice.push(annotation);
-            return;
+            continue;
         }
         vec3.sub(dir, focalPoint, point);
         const dot = vec3.dot(dir, viewPlaneNormal);

package/dist/esm/utilities/segmentation/VolumetricCalculator.d.ts

@@ -1,8 +1,15 @@
+import type { Types } from '@cornerstonejs/core';
 import type { NamedStatistics } from '../../types';
 import { BasicStatsCalculator } from '../math/basic';
 export default class VolumetricCalculator extends BasicStatsCalculator {
+    private static maxIJKs;
     static getStatistics(options: {
         spacing?: number;
         unit?: string;
     }): NamedStatistics;
+    static statsCallback(data: {
+        value: number | Types.RGB;
+        pointLPS?: Types.Point3;
+        pointIJK?: Types.Point3;
+    }): void;
 }