@cornerstonejs/tools 2.8.6 → 2.10.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/displayTools/Labelmap/addLabelmapToElement.d.ts

@@ -1,3 +1,7 @@
 import type { LabelmapSegmentationData } from '../../../types/LabelmapTypes';
-declare function addLabelmapToElement(element: HTMLDivElement, labelMapData: LabelmapSegmentationData, segmentationId: string): Promise<void>;
+import type { LabelmapRenderingConfig } from '../../../types/SegmentationStateTypes';
+declare function addLabelmapToElement(element: HTMLDivElement, labelMapData: LabelmapSegmentationData, segmentationId: string, config: LabelmapRenderingConfig): Promise<void | {
+    uid: string;
+    actor: any;
+}>;
 export default addLabelmapToElement;

package/dist/esm/tools/displayTools/Labelmap/addLabelmapToElement.js

@@ -3,8 +3,9 @@ import { getCurrentLabelmapImageIdForViewport } from '../../../stateManagement/s
 import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
 import { triggerSegmentationDataModified, triggerSegmentationModified, } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
 import { SegmentationRepresentations } from '../../../enums';
+import { addVolumesAsIndependentComponents } from './addVolumesAsIndependentComponents';
 const { uuidv4 } = utilities;
-async function addLabelmapToElement(element, labelMapData, segmentationId) {
+async function addLabelmapToElement(element, labelMapData, segmentationId, config) {
     const enabledElement = getEnabledElement(element);
     const { renderingEngine, viewport } = enabledElement;
     const { id: viewportId } = viewport;
@@ -17,15 +18,28 @@ async function addLabelmapToElement(element, labelMapData, segmentationId) {
         if (!cache.getVolume(volumeId)) {
             await _handleMissingVolume(labelMapData);
         }
+        const blendMode = config?.blendMode ?? Enums.BlendModes.MAXIMUM_INTENSITY_BLEND;
+        const useIndependentComponents = blendMode === Enums.BlendModes.LABELMAP_EDGE_PROJECTION_BLEND;
         const volumeInputs = [
             {
                 volumeId,
                 visibility,
-                blendMode: Enums.BlendModes.MAXIMUM_INTENSITY_BLEND,
                 representationUID: `${segmentationId}-${SegmentationRepresentations.Labelmap}`,
+                useIndependentComponents,
+                blendMode,
             },
         ];
-        await addVolumesToViewports(renderingEngine, volumeInputs, [viewportId], immediateRender, suppressEvents);
+        if (!volumeInputs[0].useIndependentComponents) {
+            await addVolumesToViewports(renderingEngine, volumeInputs, [viewportId], immediateRender, suppressEvents);
+        }
+        else {
+            const result = await addVolumesAsIndependentComponents({
+                viewport,
+                volumeInputs,
+                segmentationId,
+            });
+            return result;
+        }
     }
     else {
         const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);

package/dist/esm/tools/displayTools/Labelmap/addVolumesAsIndependentComponents.d.ts

@@ -0,0 +1,10 @@
+import { type Types } from '@cornerstonejs/core';
+import type vtkVolume from '@kitware/vtk.js/Rendering/Core/Volume';
+export declare function addVolumesAsIndependentComponents({ viewport, volumeInputs, segmentationId, }: {
+    viewport: Types.IVolumeViewport;
+    volumeInputs: Types.IVolumeInput[];
+    segmentationId: string;
+}): Promise<{
+    uid: string;
+    actor: vtkVolume;
+}>;

package/dist/esm/tools/displayTools/Labelmap/addVolumesAsIndependentComponents.js

@@ -0,0 +1,123 @@
+import { cache, Enums, convertMapperToNotSharedMapper, volumeLoader, eventTarget, createVolumeActor, } from '@cornerstonejs/core';
+import { Events, SegmentationRepresentations } from '../../../enums';
+import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
+const internalCache = new Map();
+const load = ({ cfun, ofun, actor }) => {
+    actor.getProperty().setRGBTransferFunction(1, cfun);
+    actor.getProperty().setScalarOpacity(1, ofun);
+};
+export async function addVolumesAsIndependentComponents({ viewport, volumeInputs, segmentationId, }) {
+    const defaultActor = viewport.getDefaultActor();
+    const { actor } = defaultActor;
+    const { uid, callback } = defaultActor;
+    const referenceVolumeId = viewport.getVolumeId();
+    if (internalCache.get(uid)?.added) {
+        return {
+            uid,
+            actor,
+        };
+    }
+    const volumeInputArray = volumeInputs;
+    const firstImageVolume = cache.getVolume(volumeInputArray[0].volumeId);
+    if (!firstImageVolume) {
+        throw new Error(`imageVolume with id: ${firstImageVolume.volumeId} does not exist`);
+    }
+    const { volumeId } = volumeInputArray[0];
+    const segImageVolume = await volumeLoader.loadVolume(volumeId);
+    if (!segImageVolume) {
+        throw new Error(`segImageVolume with id: ${segImageVolume.volumeId} does not exist`);
+    }
+    const segVoxelManager = segImageVolume.voxelManager;
+    const { imageData: segImageData } = segImageVolume;
+    const baseVolume = cache.getVolume(referenceVolumeId);
+    const baseVoxelManager = baseVolume.voxelManager;
+    const newComp = 2;
+    const cubeData = new Float32Array(newComp * baseVolume.voxelManager.getScalarDataLength());
+    const dims = segImageData.getDimensions();
+    for (let z = 0; z < dims[2]; ++z) {
+        for (let y = 0; y < dims[1]; ++y) {
+            for (let x = 0; x < dims[0]; ++x) {
+                const iTuple = x + dims[0] * (y + dims[1] * z);
+                cubeData[iTuple * newComp + 0] = baseVoxelManager.getAtIndex(iTuple);
+                cubeData[iTuple * newComp + 1] = segVoxelManager.getAtIndex(iTuple);
+            }
+        }
+    }
+    viewport.removeActors([uid]);
+    const oldMapper = actor.getMapper();
+    const mapper = convertMapperToNotSharedMapper(oldMapper);
+    actor.setMapper(mapper);
+    mapper.setBlendMode(Enums.BlendModes.LABELMAP_EDGE_PROJECTION_BLEND);
+    const arrayAgain = mapper.getInputData().getPointData().getArray(0);
+    arrayAgain.setData(cubeData);
+    arrayAgain.setNumberOfComponents(2);
+    actor.getProperty().setColorMixPreset(1);
+    actor.getProperty().setForceNearestInterpolation(1, true);
+    actor.getProperty().setIndependentComponents(true);
+    viewport.addActor({
+        actor,
+        uid,
+        callback,
+        referencedId: referenceVolumeId,
+        representationUID: `${segmentationId}-${SegmentationRepresentations.Labelmap}`,
+    });
+    internalCache.set(uid, {
+        added: true,
+        segmentationRepresentationUID: `${segmentationId}`,
+        originalBlendMode: viewport.getBlendMode(),
+    });
+    actor.set({
+        preLoad: load,
+    });
+    function onSegmentationDataModified(evt) {
+        const { segmentationId, modifiedSlicesToUse } = evt.detail;
+        const { representationData } = getSegmentation(segmentationId);
+        const { volumeId: segVolumeId } = representationData.Labelmap;
+        if (segVolumeId !== segImageVolume.volumeId) {
+            return;
+        }
+        const segmentationVolume = cache.getVolume(segVolumeId);
+        const segVoxelManager = segmentationVolume.voxelManager;
+        const array = mapper.getInputData().getPointData().getArray(0);
+        const baseData = array.getData();
+        const newComp = 2;
+        const dims = segImageData.getDimensions();
+        const slices = modifiedSlicesToUse?.length
+            ? modifiedSlicesToUse
+            : Array.from({ length: dims[2] }, (_, i) => i);
+        for (const z of slices) {
+            for (let y = 0; y < dims[1]; ++y) {
+                for (let x = 0; x < dims[0]; ++x) {
+                    const iTuple = x + dims[0] * (y + dims[1] * z);
+                    baseData[iTuple * newComp + 1] = segVoxelManager.getAtIndex(iTuple);
+                }
+            }
+        }
+        array.setData(baseData);
+    }
+    eventTarget.addEventListener(Events.SEGMENTATION_DATA_MODIFIED, onSegmentationDataModified);
+    eventTarget.addEventListener(Events.SEGMENTATION_REPRESENTATION_REMOVED, async (evt) => {
+        eventTarget.removeEventListener(Events.SEGMENTATION_DATA_MODIFIED, onSegmentationDataModified);
+        const actorEntry = viewport.getActor(uid);
+        const { element, id } = viewport;
+        viewport.removeActors([uid]);
+        const actor = await createVolumeActor({
+            volumeId: uid,
+            blendMode: Enums.BlendModes.MAXIMUM_INTENSITY_BLEND,
+            callback: ({ volumeActor }) => {
+                if (actorEntry.callback) {
+                    actorEntry.callback({
+                        volumeActor,
+                        volumeId,
+                    });
+                }
+            },
+        }, element, id);
+        viewport.addActor({ actor, uid });
+        viewport.render();
+    });
+    return {
+        uid,
+        actor,
+    };
+}

package/dist/esm/tools/displayTools/Labelmap/labelmapDisplay.d.ts

@@ -1,5 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
 import type { LabelmapRepresentation } from '../../../types/SegmentationStateTypes';
+export declare const MAX_NUMBER_COLORS = 255;
 declare function removeRepresentation(viewportId: string, segmentationId: string, renderImmediate?: boolean): void;
 declare function render(viewport: Types.IStackViewport | Types.IVolumeViewport, representation: LabelmapRepresentation): Promise<void>;
 declare const _default: {

package/dist/esm/tools/displayTools/Labelmap/labelmapDisplay.js

@@ -12,7 +12,7 @@ import SegmentationRepresentations from '../../../enums/SegmentationRepresentati
 import { internalGetHiddenSegmentIndices } from '../../../stateManagement/segmentation/helpers/internalGetHiddenSegmentIndices';
 import { getActiveSegmentIndex } from '../../../stateManagement/segmentation/getActiveSegmentIndex';
 import { getLabelmapActorEntry } from '../../../stateManagement/segmentation/helpers/getSegmentationActor';
-const MAX_NUMBER_COLORS = 255;
+export const MAX_NUMBER_COLORS = 255;
 const labelMapConfigCache = new Map();
 let polySegConversionInProgress = false;
 function removeRepresentation(viewportId, segmentationId, renderImmediate = false) {
@@ -33,7 +33,7 @@ function removeRepresentation(viewportId, segmentationId, renderImmediate = fals
     viewport.render();
 }
 async function render(viewport, representation) {
-    const { segmentationId } = representation;
+    const { segmentationId, config } = representation;
     const segmentation = getSegmentation(segmentationId);
     if (!segmentation) {
         console.warn('No segmentation found for segmentationId: ', segmentationId);
@@ -58,7 +58,7 @@ async function render(viewport, representation) {
     }
     if (viewport instanceof VolumeViewport) {
         if (!labelmapActorEntry) {
-            await _addLabelmapToViewport(viewport, labelmapData, segmentationId);
+            await _addLabelmapToViewport(viewport, labelmapData, segmentationId, config);
         }
         labelmapActorEntry = getLabelmapActorEntry(viewport.id, segmentationId);
     }
@@ -68,7 +68,7 @@ async function render(viewport, representation) {
             return;
         }
         if (!labelmapActorEntry) {
-            await _addLabelmapToViewport(viewport, labelmapData, segmentationId);
+            await _addLabelmapToViewport(viewport, labelmapData, segmentationId, config);
         }
         labelmapActorEntry = getLabelmapActorEntry(viewport.id, segmentationId);
     }
@@ -133,11 +133,17 @@ function _setLabelmapColorAndOpacity(viewportId, labelmapActorEntry, segmentatio
             }
         }
     }
-    const labelmapActor = labelmapActorEntry.actor;
-    labelmapActor.getProperty().setRGBTransferFunction(0, cfun);
     ofun.setClamping(false);
-    labelmapActor.getProperty().setScalarOpacity(0, ofun);
-    labelmapActor.getProperty().setInterpolationTypeToNearest();
+    const labelmapActor = labelmapActorEntry.actor;
+    const { preLoad } = labelmapActor.get('preLoad') || { preLoad: null };
+    if (preLoad) {
+        preLoad({ cfun, ofun, actor: labelmapActor });
+    }
+    else {
+        labelmapActor.getProperty().setRGBTransferFunction(0, cfun);
+        labelmapActor.getProperty().setScalarOpacity(0, ofun);
+        labelmapActor.getProperty().setInterpolationTypeToNearest();
+    }
     if (renderOutline) {
         labelmapActor.getProperty().setUseLabelOutline(renderOutline);
         labelmapActor.getProperty().setLabelOutlineOpacity(outlineOpacity);
@@ -241,8 +247,9 @@ function _needsTransferFunctionUpdate(viewportId, segmentationId, segmentIndex,
         forceColorUpdate,
     };
 }
-async function _addLabelmapToViewport(viewport, labelmapData, segmentationId) {
-    await addLabelmapToElement(viewport.element, labelmapData, segmentationId);
+async function _addLabelmapToViewport(viewport, labelmapData, segmentationId, config) {
+    const result = await addLabelmapToElement(viewport.element, labelmapData, segmentationId, config);
+    return result || undefined;
 }
 export default {
     render,

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