@cornerstonejs/tools 2.6.5 → 2.7.1

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

@@ -0,0 +1,106 @@
+import { getEnabledElement, utilities as csUtils, cache, } 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';
+const { transformWorldToIndex, transformIndexToWorld } = csUtils;
+class GrowCutBaseTool extends BaseTool {
+    constructor(toolProps, defaultToolProps) {
+        super(toolProps, defaultToolProps);
+    }
+    async preMouseDownCallback(evt) {
+        const eventData = evt.detail;
+        const { element, currentPoints } = eventData;
+        const { world: worldPoint } = currentPoints;
+        const enabledElement = getEnabledElement(element);
+        const { viewport, renderingEngine } = enabledElement;
+        const { viewUp } = viewport.getCamera();
+        const { segmentationId, segmentIndex, labelmapVolumeId, referencedVolumeId, } = this.getLabelmapSegmentationData(viewport);
+        if (!this._isOrthogonalView(viewport, referencedVolumeId)) {
+            throw new Error('Oblique view is not supported yet');
+        }
+        this.growCutData = {
+            metadata: {
+                ...viewport.getViewReference({ points: [worldPoint] }),
+                viewUp,
+            },
+            segmentation: {
+                segmentationId,
+                segmentIndex,
+                labelmapVolumeId,
+                referencedVolumeId,
+            },
+            viewportId: viewport.id,
+            renderingEngineId: renderingEngine.id,
+        };
+        evt.preventDefault();
+        return true;
+    }
+    async getGrowCutLabelmap() {
+        throw new Error('Not implemented');
+    }
+    async runGrowCut() {
+        const { segmentation: { segmentationId, segmentIndex, labelmapVolumeId }, } = this.growCutData;
+        const labelmap = cache.getVolume(labelmapVolumeId);
+        const growcutLabelmap = await this.getGrowCutLabelmap();
+        this.applyGrowCutLabelmap(segmentationId, segmentIndex, labelmap, growcutLabelmap);
+    }
+    applyGrowCutLabelmap(segmentationId, segmentIndex, targetLabelmap, sourceLabelmap) {
+        const srcLabelmapData = sourceLabelmap.voxelManager.getCompleteScalarDataArray();
+        const targetLabelmapData = targetLabelmap.voxelManager.getCompleteScalarDataArray();
+        const [srcColumns, srcRows, srcNumSlices] = sourceLabelmap.dimensions;
+        const [tgtColumns, tgtRows] = targetLabelmap.dimensions;
+        const srcPixelsPerSlice = srcColumns * srcRows;
+        const tgtPixelsPerSlice = tgtColumns * tgtRows;
+        for (let srcSlice = 0; srcSlice < srcNumSlices; srcSlice++) {
+            for (let srcRow = 0; srcRow < srcRows; srcRow++) {
+                const srcRowIJK = [0, srcRow, srcSlice];
+                const rowVoxelWorld = transformIndexToWorld(sourceLabelmap.imageData, srcRowIJK);
+                const tgtRowIJK = transformWorldToIndex(targetLabelmap.imageData, rowVoxelWorld);
+                const [tgtColumn, tgtRow, tgtSlice] = tgtRowIJK;
+                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;
+                }
+            }
+        }
+        targetLabelmap.voxelManager.setCompleteScalarDataArray(targetLabelmapData);
+        triggerSegmentationDataModified(segmentationId);
+    }
+    getSegmentStyle({ segmentationId, viewportId, segmentIndex }) {
+        return getSVGStyleForSegment({
+            segmentationId,
+            segmentIndex,
+            viewportId,
+        });
+    }
+    getLabelmapSegmentationData(viewport) {
+        const { segmentationId } = activeSegmentation.getActiveSegmentation(viewport.id);
+        const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
+        const { representationData } = segmentationState.getSegmentation(segmentationId);
+        const labelmapData = representationData[SegmentationRepresentations.Labelmap];
+        const { volumeId: labelmapVolumeId, referencedVolumeId } = labelmapData;
+        return {
+            segmentationId,
+            segmentIndex,
+            labelmapVolumeId,
+            referencedVolumeId,
+        };
+    }
+    _isOrthogonalView(viewport, referencedVolumeId) {
+        const volume = cache.getVolume(referencedVolumeId);
+        const volumeImageData = volume.imageData;
+        const camera = viewport.getCamera();
+        const { ijkVecColDir, ijkVecSliceDir } = csUtils.getVolumeDirectionVectors(volumeImageData, camera);
+        return [ijkVecColDir, ijkVecSliceDir].every((vec) => csUtils.isEqual(Math.abs(vec[0]), 1) ||
+            csUtils.isEqual(Math.abs(vec[1]), 1) ||
+            csUtils.isEqual(Math.abs(vec[2]), 1));
+    }
+}
+GrowCutBaseTool.toolName = 'GrowCutBaseTool';
+export default GrowCutBaseTool;

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

@@ -38,6 +38,9 @@ import CobbAngleTool from './annotation/CobbAngleTool';
 import UltrasoundDirectionalTool from './annotation/UltrasoundDirectionalTool';
 import KeyImageTool from './annotation/KeyImageTool';
 import AnnotationEraserTool from './AnnotationEraserTool';
+import RegionSegmentTool from './annotation/RegionSegmentTool';
+import RegionSegmentPlusTool from './annotation/RegionSegmentPlusTool';
+import WholeBodySegmentTool from './annotation/WholeBodySegmentTool';
 import RectangleScissorsTool from './segmentation/RectangleScissorsTool';
 import CircleScissorsTool from './segmentation/CircleScissorsTool';
 import SphereScissorsTool from './segmentation/SphereScissorsTool';
@@ -48,4 +51,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, 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, };
+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, };

package/dist/esm/tools/index.js

@@ -38,6 +38,9 @@ import CobbAngleTool from './annotation/CobbAngleTool';
 import UltrasoundDirectionalTool from './annotation/UltrasoundDirectionalTool';
 import KeyImageTool from './annotation/KeyImageTool';
 import AnnotationEraserTool from './AnnotationEraserTool';
+import RegionSegmentTool from './annotation/RegionSegmentTool';
+import RegionSegmentPlusTool from './annotation/RegionSegmentPlusTool';
+import WholeBodySegmentTool from './annotation/WholeBodySegmentTool';
 import RectangleScissorsTool from './segmentation/RectangleScissorsTool';
 import CircleScissorsTool from './segmentation/CircleScissorsTool';
 import SphereScissorsTool from './segmentation/SphereScissorsTool';
@@ -48,4 +51,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, 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, };
+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, };

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

@@ -5,7 +5,7 @@ import compositions from './compositions';
 import StrategyCallbacks from '../../../enums/StrategyCallbacks';
 import { createEllipseInPoint } from './fillCircle';
 const { transformWorldToIndex } = csUtils;
-import { getSphereBoundsInfo } from '../../../utilities/getSphereBoundsInfo';
+import { getSphereBoundsInfoFromViewport } from '../../../utilities/getSphereBoundsInfo';
 const sphereComposition = {
     [StrategyCallbacks.Initialize]: (operationData) => {
         const { points, viewport, segmentationImageData } = operationData;
@@ -19,7 +19,7 @@ const sphereComposition = {
         vec3.scale(center, center, 1 / points.length);
         operationData.centerWorld = center;
         operationData.centerIJK = transformWorldToIndex(segmentationImageData, center);
-        const { boundsIJK: newBoundsIJK, topLeftWorld, bottomRightWorld, } = getSphereBoundsInfo(points.slice(0, 2), segmentationImageData, viewport);
+        const { boundsIJK: newBoundsIJK, topLeftWorld, bottomRightWorld, } = getSphereBoundsInfoFromViewport(points.slice(0, 2), segmentationImageData, viewport);
         operationData.isInObjectBoundsIJK = newBoundsIJK;
         operationData.isInObject = createEllipseInPoint({
             topLeftWorld,

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

@@ -1,11 +1,14 @@
 import type { Types } from '@cornerstonejs/core';
 import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
 import type { BoundsIJK } from '../types';
-declare function getSphereBoundsInfo(circlePoints: [Types.Point3, Types.Point3], imageData: vtkImageData, viewport: any): {
+type SphereBoundsInfo = {
     boundsIJK: BoundsIJK;
     centerWorld: Types.Point3;
     radiusWorld: number;
     topLeftWorld: Types.Point3;
     bottomRightWorld: Types.Point3;
 };
-export { getSphereBoundsInfo };
+declare function getSphereBoundsInfo(circlePoints: [Types.Point3, Types.Point3], imageData: vtkImageData): SphereBoundsInfo;
+declare function getSphereBoundsInfoFromViewport(circlePoints: [Types.Point3, Types.Point3], imageData: vtkImageData, viewport: any): SphereBoundsInfo;
+export { getSphereBoundsInfo, getSphereBoundsInfoFromViewport };
+export type { SphereBoundsInfo };

package/dist/esm/utilities/getSphereBoundsInfo.js

@@ -2,14 +2,11 @@ import { utilities as csUtils } from '@cornerstonejs/core';
 import { vec3 } from 'gl-matrix';
 import { getBoundingBoxAroundShapeIJK } from './boundingBox';
 const { transformWorldToIndex } = csUtils;
-function getSphereBoundsInfo(circlePoints, imageData, viewport) {
+function _getSphereBoundsInfo(circlePoints, imageData, directionVectors) {
     const [bottom, top] = circlePoints;
     const centerWorld = vec3.fromValues((bottom[0] + top[0]) / 2, (bottom[1] + top[1]) / 2, (bottom[2] + top[2]) / 2);
     const radiusWorld = vec3.distance(bottom, top) / 2;
-    if (!viewport) {
-        throw new Error('viewport is required in order to calculate the sphere bounds');
-    }
-    const { boundsIJK, topLeftWorld, bottomRightWorld } = _computeBoundsIJKWithCamera(imageData, viewport, circlePoints, centerWorld, radiusWorld);
+    const { boundsIJK, topLeftWorld, bottomRightWorld } = _computeBoundsIJK(imageData, directionVectors, circlePoints, centerWorld, radiusWorld);
     return {
         boundsIJK,
         centerWorld: centerWorld,
@@ -18,24 +15,50 @@ function getSphereBoundsInfo(circlePoints, imageData, viewport) {
         bottomRightWorld: bottomRightWorld,
     };
 }
-function _computeBoundsIJKWithCamera(imageData, viewport, circlePoints, centerWorld, radiusWorld) {
-    const [bottom, top] = circlePoints;
-    const dimensions = imageData.getDimensions();
+function getSphereBoundsInfo(circlePoints, imageData) {
+    const direction = imageData.getDirection();
+    const rowCosine = vec3.fromValues(direction[0], direction[1], direction[2]);
+    const columnCosine = vec3.fromValues(direction[3], direction[4], direction[5]);
+    const scanAxis = vec3.fromValues(direction[6], direction[7], direction[8]);
+    const viewPlaneNormal = vec3.negate(vec3.create(), scanAxis);
+    const directionVectors = {
+        row: rowCosine,
+        column: columnCosine,
+        normal: viewPlaneNormal,
+    };
+    return _getSphereBoundsInfo(circlePoints, imageData, directionVectors);
+}
+function getSphereBoundsInfoFromViewport(circlePoints, imageData, viewport) {
+    if (!viewport) {
+        throw new Error('viewport is required in order to calculate the sphere bounds');
+    }
     const camera = viewport.getCamera();
     const viewUp = vec3.fromValues(camera.viewUp[0], camera.viewUp[1], camera.viewUp[2]);
     const viewPlaneNormal = vec3.fromValues(camera.viewPlaneNormal[0], camera.viewPlaneNormal[1], camera.viewPlaneNormal[2]);
     const viewRight = vec3.create();
     vec3.cross(viewRight, viewUp, viewPlaneNormal);
+    const directionVectors = {
+        row: viewRight,
+        normal: viewPlaneNormal,
+        column: vec3.negate(vec3.create(), viewUp),
+    };
+    return _getSphereBoundsInfo(circlePoints, imageData, directionVectors);
+}
+function _computeBoundsIJK(imageData, directionVectors, circlePoints, centerWorld, radiusWorld) {
+    const dimensions = imageData.getDimensions();
+    const { row: rowCosine, column: columnCosine, normal: vecNormal, } = directionVectors;
     const topLeftWorld = vec3.create();
     const bottomRightWorld = vec3.create();
-    vec3.scaleAndAdd(topLeftWorld, top, viewPlaneNormal, radiusWorld);
-    vec3.scaleAndAdd(bottomRightWorld, bottom, viewPlaneNormal, -radiusWorld);
-    vec3.scaleAndAdd(topLeftWorld, topLeftWorld, viewRight, -radiusWorld);
-    vec3.scaleAndAdd(bottomRightWorld, bottomRightWorld, viewRight, radiusWorld);
+    vec3.scaleAndAdd(topLeftWorld, centerWorld, vecNormal, radiusWorld);
+    vec3.scaleAndAdd(bottomRightWorld, centerWorld, vecNormal, -radiusWorld);
+    vec3.scaleAndAdd(topLeftWorld, topLeftWorld, columnCosine, -radiusWorld);
+    vec3.scaleAndAdd(bottomRightWorld, bottomRightWorld, columnCosine, radiusWorld);
+    vec3.scaleAndAdd(topLeftWorld, topLeftWorld, rowCosine, -radiusWorld);
+    vec3.scaleAndAdd(bottomRightWorld, bottomRightWorld, rowCosine, radiusWorld);
     const topLeftIJK = transformWorldToIndex(imageData, topLeftWorld);
     const bottomRightIJK = transformWorldToIndex(imageData, bottomRightWorld);
     const pointsIJK = circlePoints.map((p) => transformWorldToIndex(imageData, p));
     const boundsIJK = getBoundingBoxAroundShapeIJK([topLeftIJK, bottomRightIJK, ...pointsIJK], dimensions);
     return { boundsIJK, topLeftWorld, bottomRightWorld };
 }
-export { getSphereBoundsInfo };
+export { getSphereBoundsInfo, getSphereBoundsInfoFromViewport };

package/dist/esm/utilities/segmentation/createLabelmapVolumeForViewport.js

@@ -20,7 +20,7 @@ export default async function createLabelmapVolumeForViewport(input) {
     }
     else {
         const volumeId = viewport.getVolumeId();
-        await volumeLoader.createAndCacheDerivedLabelmapVolume(volumeId, {
+        volumeLoader.createAndCacheDerivedLabelmapVolume(volumeId, {
             volumeId: segmentationId,
         });
     }

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

@@ -0,0 +1,17 @@
+export interface SVGStyleForSegmentParams {
+    segmentationId: string;
+    segmentIndex: number;
+    viewportId: string;
+    autoGenerated?: boolean;
+}
+export declare function getSVGStyleForSegment({ segmentationId, segmentIndex, viewportId, autoGenerated, }: SVGStyleForSegmentParams): {
+    color: string;
+    fillColor: string;
+    lineWidth: number;
+    fillOpacity: number;
+    lineDash: any;
+    textbox: {
+        color: string;
+    };
+    visibility: boolean;
+};

package/dist/esm/utilities/segmentation/getSVGStyleForSegment.js

@@ -0,0 +1,68 @@
+import { SegmentationRepresentations } from '../../enums';
+import { getSegmentIndexColor } from '../../stateManagement/segmentation/config/segmentationColor';
+import { getActiveSegmentation } from '../../stateManagement/segmentation/getActiveSegmentation';
+import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
+import { getSegmentationRepresentationVisibility } from '../../stateManagement/segmentation/getSegmentationRepresentationVisibility';
+import { internalGetHiddenSegmentIndices } from '../../stateManagement/segmentation/helpers/internalGetHiddenSegmentIndices';
+import { segmentationStyle } from '../../stateManagement/segmentation/SegmentationStyle';
+export function getSVGStyleForSegment({ segmentationId, segmentIndex, viewportId, autoGenerated = false, }) {
+    const segmentColor = getSegmentIndexColor(viewportId, segmentationId, segmentIndex);
+    const segmentationVisible = getSegmentationRepresentationVisibility(viewportId, {
+        segmentationId,
+        type: SegmentationRepresentations.Contour,
+    });
+    const activeSegmentation = getActiveSegmentation(viewportId);
+    const isActive = activeSegmentation?.segmentationId === segmentationId;
+    const style = segmentationStyle.getStyle({
+        viewportId,
+        segmentationId,
+        type: SegmentationRepresentations.Contour,
+        segmentIndex,
+    });
+    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,
+        lineWidth,
+        fillOpacity,
+        lineDash,
+        textbox: {
+            color,
+        },
+        visibility: segmentationVisible && isVisible,
+    };
+}

package/dist/esm/utilities/segmentation/growCut/growCutShader.d.ts

@@ -0,0 +1,2 @@
+declare const shader = "\nconst MAX_STRENGTH = 65535f;\n\n// Workgroup soze - X*Y*Z must be multiple of 32 for better performance\n// otherwise warps are sub allocated and some threads will not process anything\noverride workGroupSizeX = 1u;\noverride workGroupSizeY = 1u;\noverride workGroupSizeZ = 1u;\n\n// Compare the current voxel to neighbors using a 9x9x9 window\noverride windowSize = 9i;\n\nstruct Params {\n  size: vec3u,\n  iteration: u32,\n}\n\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage> volumePixelData: array<f32>;\n@group(0) @binding(2) var<storage, read_write> labelmap: array<u32>;\n@group(0) @binding(3) var<storage, read_write> strengthData: array<f32>;\n@group(0) @binding(4) var<storage> prevLabelmap: array<u32>;\n@group(0) @binding(5) var<storage> prevStrengthData: array<f32>;\n@group(0) @binding(6) var<storage, read_write> updatedVoxelsCounter: array<atomic<u32>>;\n\nfn getPixelIndex(ijkPos: vec3u) -> u32 {\n  let numPixelsPerSlice = params.size.x * params.size.y;\n  return ijkPos.x + ijkPos.y * params.size.x + ijkPos.z * numPixelsPerSlice;\n}\n\n@compute @workgroup_size(workGroupSizeX, workGroupSizeY, workGroupSizeZ)\nfn main(\n  @builtin(global_invocation_id) globalId: vec3u,\n) {\n  // Make sure it will not get out of bounds for volume with sizes that\n  // are not multiple of workGroupSize\n  if (\n    globalId.x >= params.size.x ||\n    globalId.y >= params.size.y ||\n    globalId.z >= params.size.z\n  ) {\n    return;\n  }\n\n  let currentCoord = vec3i(globalId);\n  let currentPixelIndex = getPixelIndex(globalId);\n\n  let numPixels = arrayLength(&volumePixelData);\n  let currentPixelValue = volumePixelData[currentPixelIndex];\n\n  if (params.iteration == 0) {\n    // All non-zero initial labels are given maximum strength\n    strengthData[currentPixelIndex] = select(MAX_STRENGTH, 0., labelmap[currentPixelIndex] == 0);\n    return;\n  }\n\n  // It should at least copy the values from previous state\n  var newLabel = prevLabelmap[currentPixelIndex];\n  var newStrength = prevStrengthData[currentPixelIndex];\n\n  let window = i32(ceil(f32(windowSize - 1) * .5));\n  let minWindow = -1i * window;\n  let maxWindow = 1i * window;\n\n  for (var k = minWindow; k <= maxWindow; k++) {\n    for (var j = minWindow; j <= maxWindow; j++) {\n      for (var i = minWindow; i <= maxWindow; i++) {\n        // Skip current voxel\n        if (i == 0 && j == 0 && k == 0) {\n          continue;\n        }\n\n        let neighborCoord = currentCoord + vec3i(i, j, k);\n\n        //  Boundary conditions. Do not grow outside of the volume\n        if (\n          neighborCoord.x < 0i || neighborCoord.x >= i32(params.size.x) ||\n          neighborCoord.y < 0i || neighborCoord.y >= i32(params.size.y) ||\n          neighborCoord.z < 0i || neighborCoord.z >= i32(params.size.z)\n        ) {\n          continue;\n        }\n\n        let neighborIndex = getPixelIndex(vec3u(neighborCoord));\n        let neighborPixelValue = volumePixelData[neighborIndex];\n        let prevNeighborStrength = prevStrengthData[neighborIndex];\n        let strengthCost = abs(neighborPixelValue - currentPixelValue);\n        let takeoverStrength = prevNeighborStrength - strengthCost;\n\n        if (takeoverStrength > newStrength) {\n          newLabel = prevLabelmap[neighborIndex];\n          newStrength = takeoverStrength;\n        }\n      }\n    }\n  }\n\n  if (labelmap[currentPixelIndex] != newLabel) {\n    atomicAdd(&updatedVoxelsCounter[params.iteration], 1u);\n  }\n\n  labelmap[currentPixelIndex] = newLabel;\n  strengthData[currentPixelIndex] = newStrength;\n}\n";
+export default shader;

package/dist/esm/utilities/segmentation/growCut/growCutShader.js

@@ -0,0 +1,106 @@
+const shader = `
+const MAX_STRENGTH = 65535f;
+
+// Workgroup soze - X*Y*Z must be multiple of 32 for better performance
+// otherwise warps are sub allocated and some threads will not process anything
+override workGroupSizeX = 1u;
+override workGroupSizeY = 1u;
+override workGroupSizeZ = 1u;
+
+// Compare the current voxel to neighbors using a 9x9x9 window
+override windowSize = 9i;
+
+struct Params {
+  size: vec3u,
+  iteration: u32,
+}
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var<storage> volumePixelData: array<f32>;
+@group(0) @binding(2) var<storage, read_write> labelmap: array<u32>;
+@group(0) @binding(3) var<storage, read_write> strengthData: array<f32>;
+@group(0) @binding(4) var<storage> prevLabelmap: array<u32>;
+@group(0) @binding(5) var<storage> prevStrengthData: array<f32>;
+@group(0) @binding(6) var<storage, read_write> updatedVoxelsCounter: array<atomic<u32>>;
+
+fn getPixelIndex(ijkPos: vec3u) -> u32 {
+  let numPixelsPerSlice = params.size.x * params.size.y;
+  return ijkPos.x + ijkPos.y * params.size.x + ijkPos.z * numPixelsPerSlice;
+}
+
+@compute @workgroup_size(workGroupSizeX, workGroupSizeY, workGroupSizeZ)
+fn main(
+  @builtin(global_invocation_id) globalId: vec3u,
+) {
+  // Make sure it will not get out of bounds for volume with sizes that
+  // are not multiple of workGroupSize
+  if (
+    globalId.x >= params.size.x ||
+    globalId.y >= params.size.y ||
+    globalId.z >= params.size.z
+  ) {
+    return;
+  }
+
+  let currentCoord = vec3i(globalId);
+  let currentPixelIndex = getPixelIndex(globalId);
+
+  let numPixels = arrayLength(&volumePixelData);
+  let currentPixelValue = volumePixelData[currentPixelIndex];
+
+  if (params.iteration == 0) {
+    // All non-zero initial labels are given maximum strength
+    strengthData[currentPixelIndex] = select(MAX_STRENGTH, 0., labelmap[currentPixelIndex] == 0);
+    return;
+  }
+
+  // It should at least copy the values from previous state
+  var newLabel = prevLabelmap[currentPixelIndex];
+  var newStrength = prevStrengthData[currentPixelIndex];
+
+  let window = i32(ceil(f32(windowSize - 1) * .5));
+  let minWindow = -1i * window;
+  let maxWindow = 1i * window;
+
+  for (var k = minWindow; k <= maxWindow; k++) {
+    for (var j = minWindow; j <= maxWindow; j++) {
+      for (var i = minWindow; i <= maxWindow; i++) {
+        // Skip current voxel
+        if (i == 0 && j == 0 && k == 0) {
+          continue;
+        }
+
+        let neighborCoord = currentCoord + vec3i(i, j, k);
+
+        //  Boundary conditions. Do not grow outside of the volume
+        if (
+          neighborCoord.x < 0i || neighborCoord.x >= i32(params.size.x) ||
+          neighborCoord.y < 0i || neighborCoord.y >= i32(params.size.y) ||
+          neighborCoord.z < 0i || neighborCoord.z >= i32(params.size.z)
+        ) {
+          continue;
+        }
+
+        let neighborIndex = getPixelIndex(vec3u(neighborCoord));
+        let neighborPixelValue = volumePixelData[neighborIndex];
+        let prevNeighborStrength = prevStrengthData[neighborIndex];
+        let strengthCost = abs(neighborPixelValue - currentPixelValue);
+        let takeoverStrength = prevNeighborStrength - strengthCost;
+
+        if (takeoverStrength > newStrength) {
+          newLabel = prevLabelmap[neighborIndex];
+          newStrength = takeoverStrength;
+        }
+      }
+    }
+  }
+
+  if (labelmap[currentPixelIndex] != newLabel) {
+    atomicAdd(&updatedVoxelsCounter[params.iteration], 1u);
+  }
+
+  labelmap[currentPixelIndex] = newLabel;
+  strengthData[currentPixelIndex] = newStrength;
+}
+`;
+export default shader;

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

@@ -0,0 +1,7 @@
+export { run } from './runGrowCut';
+export { runGrowCutForSphere } from './runGrowCutForSphere';
+export { runGrowCutForBoundingBox } from './runGrowCutForBoundingBox';
+export { runOneClickGrowCut } from './runOneClickGrowCut';
+export type { SphereInfo, GrowCutSphereOptions } from './runGrowCutForSphere';
+export type { GrowCutBoundingBoxOptions } from './runGrowCutForBoundingBox';
+export type { GrowCutOneClickOptions } from './runOneClickGrowCut';

package/dist/esm/utilities/segmentation/growCut/index.js

@@ -0,0 +1,4 @@
+export { run } from './runGrowCut';
+export { runGrowCutForSphere } from './runGrowCutForSphere';
+export { runGrowCutForBoundingBox } from './runGrowCutForBoundingBox';
+export { runOneClickGrowCut } from './runOneClickGrowCut';

package/dist/esm/utilities/segmentation/growCut/runGrowCut.d.ts

@@ -0,0 +1,16 @@
+type GrowCutOptions = {
+    maxProcessingTime?: number;
+    windowSize?: number;
+    positiveSeedValue?: number;
+    negativeSeedValue?: number;
+    positiveSeedVariance?: number;
+    negativeSeedVariance?: number;
+    inspection?: {
+        numCyclesInterval?: number;
+        numCyclesBelowThreashold?: number;
+        threshold?: number;
+    };
+};
+declare function runGrowCut(referenceVolumeId: string, labelmapVolumeId: string, options?: GrowCutOptions): Promise<void>;
+export { runGrowCut as default, runGrowCut as run };
+export type { GrowCutOptions };