@cornerstonejs/tools 2.6.5 → 2.7.1

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, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, 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, VolumeRotateTool } from './tools';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, 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, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool } 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, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, 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, VolumeRotateTool, };
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, 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, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, };

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, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, 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, VolumeRotateTool, } from './tools';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, 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, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, } 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, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, 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, VolumeRotateTool, };
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, 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, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, };

package/dist/esm/stateManagement/segmentation/polySeg/Labelmap/labelmapComputationStrategies.js

@@ -73,7 +73,8 @@ async function computeLabelmapFromSurfaceSegmentation(segmentationId, options =
     let segmentationVolume;
     if (isVolume) {
         const volumeId = viewport.getVolumeId();
-        segmentationVolume = await volumeLoader.createAndCacheDerivedLabelmapVolume(volumeId);
+        segmentationVolume =
+            volumeLoader.createAndCacheDerivedLabelmapVolume(volumeId);
     }
     else {
         const imageIds = options.viewport.getImageIds();

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

@@ -432,9 +432,12 @@ class LengthTool extends AnnotationTool {
             const handles = [index1, index2];
             const { scale, unit } = getCalibratedLengthUnitsAndScale(image, handles);
             const length = this._calculateLength(worldPos1, worldPos2) / scale;
-            this._isInsideVolume(index1, index2, dimensions)
-                ? (this.isHandleOutsideImage = false)
-                : (this.isHandleOutsideImage = true);
+            if (this._isInsideVolume(index1, index2, dimensions)) {
+                this.isHandleOutsideImage = false;
+            }
+            else {
+                this.isHandleOutsideImage = true;
+            }
             cachedStats[targetId] = {
                 length,
                 unit,

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

@@ -0,0 +1,15 @@
+import type { Types } from '@cornerstonejs/core';
+import type { EventTypes, PublicToolProps, ToolProps } from '../../types';
+import GrowCutBaseTool from '../base/GrowCutBaseTool';
+import type { GrowCutToolData } from '../base/GrowCutBaseTool';
+type RegionSegmentPlusToolData = GrowCutToolData & {
+    worldPoint: Types.Point3;
+};
+declare class RegionSegmentPlusTool extends GrowCutBaseTool {
+    static toolName: any;
+    protected growCutData: RegionSegmentPlusToolData | null;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    preMouseDownCallback(evt: EventTypes.MouseDownActivateEventType): Promise<boolean>;
+    protected getGrowCutLabelmap(): Promise<Types.IImageVolume>;
+}
+export default RegionSegmentPlusTool;

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

@@ -0,0 +1,40 @@
+import { getRenderingEngine } from '@cornerstonejs/core';
+import { growCut } from '../../utilities/segmentation';
+import GrowCutBaseTool from '../base/GrowCutBaseTool';
+class RegionSegmentPlusTool extends GrowCutBaseTool {
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            positiveSeedVariance: 0.4,
+            negativeSeedVariance: 0.9,
+            subVolumePaddingPercentage: 0.1,
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+    }
+    async preMouseDownCallback(evt) {
+        const eventData = evt.detail;
+        const { currentPoints } = eventData;
+        const { world: worldPoint } = currentPoints;
+        super.preMouseDownCallback(evt);
+        this.growCutData.worldPoint = worldPoint;
+        this.runGrowCut();
+        return true;
+    }
+    async getGrowCutLabelmap() {
+        const { segmentation: { segmentIndex, referencedVolumeId }, renderingEngineId, viewportId, worldPoint, } = this.growCutData;
+        const renderingEngine = getRenderingEngine(renderingEngineId);
+        const viewport = renderingEngine.getViewport(viewportId);
+        const { positiveSeedVariance, negativeSeedVariance, subVolumePaddingPercentage, } = this.configuration;
+        const options = {
+            positiveSeedValue: segmentIndex,
+            negativeSeedValue: 255,
+            positiveSeedVariance: positiveSeedVariance,
+            negativeSeedVariance: negativeSeedVariance,
+            subVolumePaddingPercentage: subVolumePaddingPercentage,
+        };
+        return await growCut.runOneClickGrowCut(referencedVolumeId, worldPoint, viewport, options);
+    }
+}
+RegionSegmentPlusTool.toolName = 'RegionSegmentPlus';
+export default RegionSegmentPlusTool;

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

@@ -0,0 +1,21 @@
+import type { Types } from '@cornerstonejs/core';
+import type { EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper } from '../../types';
+import type { GrowCutToolData } from '../base/GrowCutBaseTool';
+import GrowCutBaseTool from '../base/GrowCutBaseTool';
+type RegionSegmentToolData = GrowCutToolData & {
+    circleCenterPoint: Types.Point3;
+    circleBorderPoint: Types.Point3;
+};
+declare class RegionSegmentTool extends GrowCutBaseTool {
+    static toolName: any;
+    protected growCutData: RegionSegmentToolData | null;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    preMouseDownCallback(evt: EventTypes.MouseDownActivateEventType): Promise<boolean>;
+    private _dragCallback;
+    private _endCallback;
+    protected getGrowCutLabelmap(): Promise<Types.IImageVolume>;
+    private _activateDraw;
+    private _deactivateDraw;
+    renderAnnotation(enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper): void;
+}
+export default RegionSegmentTool;

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

@@ -0,0 +1,103 @@
+import { vec2, vec3 } from 'gl-matrix';
+import { getEnabledElement, utilities as csUtils, getRenderingEngine, } from '@cornerstonejs/core';
+import { drawCircle as drawCircleSvg } from '../../drawingSvg';
+import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
+import { Events } from '../../enums';
+import triggerAnnotationRenderForViewportUIDs from '../../utilities/triggerAnnotationRenderForViewportIds';
+import { growCut } from '../../utilities/segmentation';
+import GrowCutBaseTool from '../base/GrowCutBaseTool';
+class RegionSegmentTool extends GrowCutBaseTool {
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {},
+    }) {
+        super(toolProps, defaultToolProps);
+        this._dragCallback = (evt) => {
+            const eventData = evt.detail;
+            const { element, currentPoints } = eventData;
+            const { world: currentWorldPoint } = currentPoints;
+            const enabledElement = getEnabledElement(element);
+            const { viewport } = enabledElement;
+            this.growCutData.circleBorderPoint = currentWorldPoint;
+            triggerAnnotationRenderForViewportUIDs([viewport.id]);
+        };
+        this._endCallback = async (evt) => {
+            const eventData = evt.detail;
+            const { element } = eventData;
+            const enabledElement = getEnabledElement(element);
+            const { viewport } = enabledElement;
+            this.runGrowCut();
+            this._deactivateDraw(element);
+            this.growCutData = null;
+            resetElementCursor(element);
+            triggerAnnotationRenderForViewportUIDs([viewport.id]);
+        };
+        this._deactivateDraw = (element) => {
+            element.removeEventListener(Events.MOUSE_UP, this._endCallback);
+            element.removeEventListener(Events.MOUSE_DRAG, this._dragCallback);
+            element.removeEventListener(Events.MOUSE_CLICK, this._endCallback);
+        };
+    }
+    async preMouseDownCallback(evt) {
+        const eventData = evt.detail;
+        const { element, currentPoints } = eventData;
+        const { world: worldPoint } = currentPoints;
+        const enabledElement = getEnabledElement(element);
+        const { viewport, renderingEngine } = enabledElement;
+        super.preMouseDownCallback(evt);
+        Object.assign(this.growCutData, {
+            circleCenterPoint: worldPoint,
+            circleBorderPoint: worldPoint,
+        });
+        this._activateDraw(element);
+        hideElementCursor(element);
+        triggerAnnotationRenderForViewportUIDs([viewport.id]);
+        return true;
+    }
+    async getGrowCutLabelmap() {
+        const { segmentation: { segmentIndex, referencedVolumeId }, renderingEngineId, viewportId, circleCenterPoint, circleBorderPoint, } = this.growCutData;
+        const renderingEngine = getRenderingEngine(renderingEngineId);
+        const viewport = renderingEngine.getViewport(viewportId);
+        const worldCircleRadius = vec3.len(vec3.sub(vec3.create(), circleCenterPoint, circleBorderPoint));
+        const sphereInfo = {
+            center: circleCenterPoint,
+            radius: worldCircleRadius,
+        };
+        const options = {
+            positiveSeedValue: segmentIndex,
+            negativeSeedValue: 255,
+        };
+        return growCut.runGrowCutForSphere(referencedVolumeId, sphereInfo, viewport, options);
+    }
+    _activateDraw(element) {
+        element.addEventListener(Events.MOUSE_UP, this._endCallback);
+        element.addEventListener(Events.MOUSE_DRAG, this._dragCallback);
+        element.addEventListener(Events.MOUSE_CLICK, this._endCallback);
+    }
+    renderAnnotation(enabledElement, svgDrawingHelper) {
+        if (!this.growCutData) {
+            return;
+        }
+        const { viewport } = enabledElement;
+        const { segmentation: segmentationData, circleCenterPoint, circleBorderPoint, } = this.growCutData;
+        const canvasCenterPoint = viewport.worldToCanvas(circleCenterPoint);
+        const canvasBorderPoint = viewport.worldToCanvas(circleBorderPoint);
+        const vecCenterToBorder = vec2.sub(vec2.create(), canvasBorderPoint, canvasCenterPoint);
+        const circleRadius = vec2.len(vecCenterToBorder);
+        if (csUtils.isEqual(circleRadius, 0)) {
+            return;
+        }
+        const annotationUID = 'growcut';
+        const circleUID = '0';
+        const { color } = this.getSegmentStyle({
+            segmentationId: segmentationData.segmentationId,
+            segmentIndex: segmentationData.segmentIndex,
+            viewportId: viewport.id,
+        });
+        drawCircleSvg(svgDrawingHelper, annotationUID, circleUID, canvasCenterPoint, circleRadius, {
+            color,
+        });
+    }
+}
+RegionSegmentTool.toolName = 'RegionSegment';
+export default RegionSegmentTool;

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

@@ -0,0 +1,28 @@
+import type { Types } from '@cornerstonejs/core';
+import type { EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper } from '../../types';
+import type { GrowCutToolData } from '../base/GrowCutBaseTool';
+import GrowCutBaseTool from '../base/GrowCutBaseTool';
+type HorizontalLine = [Types.Point3, Types.Point3];
+type WholeBodySegmentToolData = GrowCutToolData & {
+    horizontalLines: [HorizontalLine, HorizontalLine];
+};
+declare class WholeBodySegmentTool extends GrowCutBaseTool {
+    static toolName: any;
+    protected growCutData: WholeBodySegmentToolData | null;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    preMouseDownCallback(evt: EventTypes.MouseDownActivateEventType): Promise<boolean>;
+    private _dragCallback;
+    private _endCallback;
+    renderAnnotation(enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper): void;
+    protected getGrowCutLabelmap(): Promise<Types.IImageVolume>;
+    private _activateDraw;
+    private _deactivateDraw;
+    private _projectWorldPointAcrossSlices;
+    private _getCuboidIJKEdgePointsFromProjectedWorldPoint;
+    private _getWorldCuboidCornerPoints;
+    private _getWorldBoundingBoxFromProjectedSquare;
+    private _getViewportVolume;
+    private _getHorizontalLineIJKPoints;
+    private _getHorizontalLineWorldPoints;
+}
+export default WholeBodySegmentTool;

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

@@ -0,0 +1,188 @@
+import { vec3 } from 'gl-matrix';
+import { getEnabledElement, utilities as csUtils, cache, getRenderingEngine, BaseVolumeViewport, } from '@cornerstonejs/core';
+import { drawPolyline as drawPolylineSvg } from '../../drawingSvg';
+import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
+import { Events } from '../../enums';
+import triggerAnnotationRenderForViewportUIDs from '../../utilities/triggerAnnotationRenderForViewportIds';
+import { growCut } from '../../utilities/segmentation';
+import GrowCutBaseTool from '../base/GrowCutBaseTool';
+const { transformWorldToIndex, transformIndexToWorld } = csUtils;
+class WholeBodySegmentTool extends GrowCutBaseTool {
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {},
+    }) {
+        super(toolProps, defaultToolProps);
+        this._dragCallback = (evt) => {
+            const eventData = evt.detail;
+            const { element, currentPoints } = eventData;
+            const { world: currentWorldPoint } = currentPoints;
+            const enabledElement = getEnabledElement(element);
+            const { renderingEngine, viewport } = enabledElement;
+            const linePoints = this._getHorizontalLineWorldPoints(enabledElement, currentWorldPoint);
+            this.growCutData.horizontalLines[1] = linePoints;
+            triggerAnnotationRenderForViewportUIDs([viewport.id]);
+        };
+        this._endCallback = (evt) => {
+            const eventData = evt.detail;
+            const { element } = eventData;
+            const enabledElement = getEnabledElement(element);
+            const { renderingEngine, viewport } = enabledElement;
+            this.runGrowCut();
+            this._deactivateDraw(element);
+            this.growCutData = null;
+            resetElementCursor(element);
+            triggerAnnotationRenderForViewportUIDs([viewport.id]);
+        };
+        this._deactivateDraw = (element) => {
+            element.removeEventListener(Events.MOUSE_UP, this._endCallback);
+            element.removeEventListener(Events.MOUSE_DRAG, this._dragCallback);
+            element.removeEventListener(Events.MOUSE_CLICK, this._endCallback);
+        };
+    }
+    async preMouseDownCallback(evt) {
+        const eventData = evt.detail;
+        const { element, currentPoints } = eventData;
+        const { world: worldPoint } = currentPoints;
+        const enabledElement = getEnabledElement(element);
+        const { viewport, renderingEngine } = enabledElement;
+        const linePoints = this._getHorizontalLineWorldPoints(enabledElement, worldPoint);
+        super.preMouseDownCallback(evt);
+        this.growCutData.horizontalLines = [linePoints, linePoints];
+        this._activateDraw(element);
+        hideElementCursor(element);
+        triggerAnnotationRenderForViewportUIDs([viewport.id]);
+        return true;
+    }
+    renderAnnotation(enabledElement, svgDrawingHelper) {
+        if (!this.growCutData) {
+            return;
+        }
+        const { segmentation: segmentationData, horizontalLines } = this.growCutData;
+        if (horizontalLines.length !== 2) {
+            return;
+        }
+        const { viewport } = enabledElement;
+        const { segmentationId, segmentIndex } = segmentationData;
+        const [line1, line2] = horizontalLines;
+        const [worldLine1P1, worldLine1P2] = line1;
+        const [worldLine2P1, worldLine2P2] = line2;
+        const canvasPoints = [
+            worldLine1P1,
+            worldLine1P2,
+            worldLine2P2,
+            worldLine2P1,
+        ].map((worldPoint) => viewport.worldToCanvas(worldPoint));
+        const annotationUID = 'growCutRect';
+        const squareGroupUID = '0';
+        const { color, fillColor, lineWidth, fillOpacity, lineDash } = this.getSegmentStyle({
+            segmentationId,
+            segmentIndex,
+            viewportId: viewport.id,
+        });
+        drawPolylineSvg(svgDrawingHelper, annotationUID, squareGroupUID, canvasPoints, {
+            color,
+            fillColor,
+            fillOpacity,
+            lineWidth,
+            lineDash,
+            closePath: true,
+        });
+    }
+    async getGrowCutLabelmap() {
+        const { segmentation: { segmentIndex, referencedVolumeId }, renderingEngineId, viewportId, horizontalLines, } = this.growCutData;
+        const renderingEngine = getRenderingEngine(renderingEngineId);
+        const viewport = renderingEngine.getViewport(viewportId);
+        const [line1, line2] = horizontalLines;
+        const worldSquarePoints = [line1[0], line1[1], line2[1], line2[0]];
+        const referencedVolume = cache.getVolume(referencedVolumeId);
+        const { topLeft: worldTopLeft, bottomRight: worldBottomRight } = this._getWorldBoundingBoxFromProjectedSquare(viewport, worldSquarePoints);
+        const ijkTopLeft = transformWorldToIndex(referencedVolume.imageData, worldTopLeft);
+        const ijkBottomRight = transformWorldToIndex(referencedVolume.imageData, worldBottomRight);
+        const boundingBoxInfo = {
+            boundingBox: {
+                ijkTopLeft,
+                ijkBottomRight,
+            },
+        };
+        const options = {
+            positiveSeedValue: segmentIndex,
+            negativeSeedValue: 255,
+        };
+        return growCut.runGrowCutForBoundingBox(referencedVolumeId, boundingBoxInfo, options);
+    }
+    _activateDraw(element) {
+        element.addEventListener(Events.MOUSE_UP, this._endCallback);
+        element.addEventListener(Events.MOUSE_DRAG, this._dragCallback);
+        element.addEventListener(Events.MOUSE_CLICK, this._endCallback);
+    }
+    _projectWorldPointAcrossSlices(viewport, worldEdgePoint, vecDirection) {
+        const volume = this._getViewportVolume(viewport);
+        const { dimensions } = volume;
+        const ijkPoint = transformWorldToIndex(volume.imageData, worldEdgePoint);
+        const axis = vecDirection.findIndex((n) => csUtils.isEqual(Math.abs(n), 1));
+        if (axis === -1) {
+            throw new Error('Non-orthogonal direction vector');
+        }
+        const ijkLineP1 = [...ijkPoint];
+        const ijkLineP2 = [...ijkPoint];
+        ijkLineP1[axis] = 0;
+        ijkLineP2[axis] = dimensions[axis] - 1;
+        return [ijkLineP1, ijkLineP2];
+    }
+    _getCuboidIJKEdgePointsFromProjectedWorldPoint(viewport, worldEdgePoint) {
+        const { viewPlaneNormal } = viewport.getCamera();
+        return this._projectWorldPointAcrossSlices(viewport, worldEdgePoint, viewPlaneNormal);
+    }
+    _getWorldCuboidCornerPoints(viewport, worldSquarePoints) {
+        const cuboidPoints = [];
+        const volume = this._getViewportVolume(viewport);
+        worldSquarePoints.forEach((worldSquarePoint) => {
+            const ijkEdgePoints = this._getCuboidIJKEdgePointsFromProjectedWorldPoint(viewport, worldSquarePoint);
+            const worldEdgePoints = ijkEdgePoints.map((ijkPoint) => transformIndexToWorld(volume.imageData, ijkPoint));
+            cuboidPoints.push(...worldEdgePoints);
+        });
+        return cuboidPoints;
+    }
+    _getWorldBoundingBoxFromProjectedSquare(viewport, worldSquarePoints) {
+        const worldCuboidPoints = this._getWorldCuboidCornerPoints(viewport, worldSquarePoints);
+        const topLeft = [...worldCuboidPoints[0]];
+        const bottomRight = [...worldCuboidPoints[0]];
+        worldCuboidPoints.forEach((worldPoint) => {
+            vec3.min(topLeft, topLeft, worldPoint);
+            vec3.max(bottomRight, bottomRight, worldPoint);
+        });
+        return { topLeft, bottomRight };
+    }
+    _getViewportVolume(viewport) {
+        if (!(viewport instanceof BaseVolumeViewport)) {
+            throw new Error('Viewport is not a BaseVolumeViewport');
+        }
+        const volumeId = viewport.getAllVolumeIds()[0];
+        return cache.getVolume(volumeId);
+    }
+    _getHorizontalLineIJKPoints(enabledElement, worldPoint) {
+        const { viewport } = enabledElement;
+        const volume = this._getViewportVolume(viewport);
+        const { dimensions } = volume;
+        const ijkPoint = transformWorldToIndex(volume.imageData, worldPoint);
+        const { viewUp, viewPlaneNormal } = viewport.getCamera();
+        const vecRow = vec3.cross(vec3.create(), viewUp, viewPlaneNormal);
+        const axis = vecRow.findIndex((n) => csUtils.isEqual(Math.abs(n), 1));
+        const ijkLineP1 = [...ijkPoint];
+        const ijkLineP2 = [...ijkPoint];
+        ijkLineP1[axis] = 0;
+        ijkLineP2[axis] = dimensions[axis] - 1;
+        return [ijkLineP1, ijkLineP2];
+    }
+    _getHorizontalLineWorldPoints(enabledElement, worldPoint) {
+        const { viewport } = enabledElement;
+        const volume = this._getViewportVolume(viewport);
+        const [ijkPoint1, ijkPoint2] = this._getHorizontalLineIJKPoints(enabledElement, worldPoint);
+        const worldPoint1 = transformIndexToWorld(volume.imageData, ijkPoint1);
+        const worldPoint2 = transformIndexToWorld(volume.imageData, ijkPoint2);
+        return [worldPoint1, worldPoint2];
+    }
+}
+WholeBodySegmentTool.toolName = 'WholeBodySegmentTool';
+export default WholeBodySegmentTool;

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

@@ -15,6 +15,7 @@ import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getAct
 import { getLockedSegmentIndices } from '../../stateManagement/segmentation/segmentLocking';
 import { segmentationStyle } from '../../stateManagement/segmentation/SegmentationStyle';
 import { internalGetHiddenSegmentIndices } from '../../stateManagement/segmentation/helpers/internalGetHiddenSegmentIndices';
+import { getSVGStyleForSegment } from '../../utilities/segmentation/getSVGStyleForSegment';
 class ContourSegmentationBaseTool extends ContourBaseTool {
     constructor(toolProps, defaultToolProps) {
         super(toolProps, defaultToolProps);
@@ -112,54 +113,12 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
         const { autoGenerated } = annotation;
         const segmentsLocked = getLockedSegmentIndices(segmentationId);
         const annotationLocked = segmentsLocked.includes(segmentIndex);
-        const segmentColor = getSegmentIndexColor(context.styleSpecifier.viewportId, segmentationId, segmentIndex);
-        const segmentationVisible = getSegmentationRepresentationVisibility(viewportId, {
+        const { color, fillColor, lineWidth, fillOpacity, lineDash, visibility } = getSVGStyleForSegment({
             segmentationId,
-            type: SegmentationRepresentations.Contour,
-        });
-        const activeSegmentation = getActiveSegmentation(viewportId);
-        const isActive = activeSegmentation?.segmentationId === segmentationId;
-        const style = segmentationStyle.getStyle({
-            viewportId,
-            segmentationId,
-            type: SegmentationRepresentations.Contour,
             segmentIndex,
+            viewportId,
+            autoGenerated,
         });
-        const mergedConfig = style;
-        let lineWidth = 1;
-        let lineDash = undefined;
-        let lineOpacity = 1;
-        let fillOpacity = 0;
-        if (autoGenerated) {
-            lineWidth = mergedConfig.outlineWidthAutoGenerated ?? lineWidth;
-            lineDash = mergedConfig.outlineDashAutoGenerated ?? lineDash;
-            lineOpacity = mergedConfig.outlineOpacity ?? lineOpacity;
-            fillOpacity = mergedConfig.fillAlphaAutoGenerated ?? fillOpacity;
-        }
-        else if (isActive) {
-            lineWidth = mergedConfig.outlineWidth ?? lineWidth;
-            lineDash = mergedConfig.outlineDash ?? lineDash;
-            lineOpacity = mergedConfig.outlineOpacity ?? lineOpacity;
-            fillOpacity = mergedConfig.fillAlpha ?? fillOpacity;
-        }
-        else {
-            lineWidth = mergedConfig.outlineWidthInactive ?? lineWidth;
-            lineDash = mergedConfig.outlineDashInactive ?? lineDash;
-            lineOpacity = mergedConfig.outlineOpacityInactive ?? lineOpacity;
-            fillOpacity = mergedConfig.fillAlphaInactive ?? fillOpacity;
-        }
-        if (getActiveSegmentIndex(segmentationId) === segmentIndex) {
-            lineWidth += mergedConfig.activeSegmentOutlineWidthDelta;
-        }
-        lineWidth = mergedConfig.renderOutline ? lineWidth : 0;
-        fillOpacity = mergedConfig.renderFill ? fillOpacity : 0;
-        const color = `rgba(${segmentColor[0]}, ${segmentColor[1]}, ${segmentColor[2]}, ${lineOpacity})`;
-        const fillColor = `rgb(${segmentColor[0]}, ${segmentColor[1]}, ${segmentColor[2]})`;
-        const hiddenSegments = internalGetHiddenSegmentIndices(viewportId, {
-            segmentationId,
-            type: SegmentationRepresentations.Contour,
-        });
-        const isVisible = !hiddenSegments.has(segmentIndex);
         return {
             color,
             fillColor,
@@ -169,7 +128,7 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
             textbox: {
                 color,
             },
-            visibility: segmentationVisible && isVisible,
+            visibility,
             locked: annotationLocked,
         };
     }

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

@@ -0,0 +1,49 @@
+import type { Types } from '@cornerstonejs/core';
+import { BaseTool } from '../base';
+import type { EventTypes, PublicToolProps, ToolProps } from '../../types';
+type GrowCutToolData = {
+    metadata: Types.ViewReference & {
+        viewUp?: Types.Point3;
+    };
+    segmentation: {
+        segmentationId: string;
+        segmentIndex: number;
+        labelmapVolumeId: string;
+        referencedVolumeId: string;
+    };
+    viewportId: string;
+    renderingEngineId: string;
+};
+declare class GrowCutBaseTool extends BaseTool {
+    static toolName: any;
+    protected growCutData: GrowCutToolData | null;
+    constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps);
+    preMouseDownCallback(evt: EventTypes.MouseDownActivateEventType): Promise<boolean>;
+    protected getGrowCutLabelmap(): Promise<Types.IImageVolume>;
+    protected runGrowCut(): Promise<void>;
+    protected applyGrowCutLabelmap(segmentationId: string, segmentIndex: number, targetLabelmap: Types.IImageVolume, sourceLabelmap: Types.IImageVolume): void;
+    protected getSegmentStyle({ segmentationId, viewportId, segmentIndex }: {
+        segmentationId: any;
+        viewportId: any;
+        segmentIndex: any;
+    }): {
+        color: string;
+        fillColor: string;
+        lineWidth: number;
+        fillOpacity: number;
+        lineDash: any;
+        textbox: {
+            color: string;
+        };
+        visibility: boolean;
+    };
+    protected getLabelmapSegmentationData(viewport: Types.IViewport): {
+        segmentationId: string;
+        segmentIndex: number;
+        labelmapVolumeId: string;
+        referencedVolumeId: string;
+    };
+    protected _isOrthogonalView(viewport: Types.IViewport, referencedVolumeId: string): boolean;
+}
+export default GrowCutBaseTool;
+export type { GrowCutToolData };