@cornerstonejs/tools 5.4.12 → 5.4.14

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

@@ -0,0 +1,748 @@
+import { cache, Enums as CoreEnums, eventTarget, utilities as csUtils, getEnabledElement, getRenderingEngine, } from '@cornerstonejs/core';
+import GrowCutBaseTool from '../base/GrowCutBaseTool.js';
+import { runFloodFillSegmentation } from '../../utilities/segmentation/growCut/runFloodFillSegmentation.js';
+import { floodFill3dSliceLazy } from '../../utilities/segmentation/floodFillSliceLazy.js';
+import { probeAdaptiveRegion, resolveAdaptiveBandAtTolerance, } from '../../utilities/segmentation/growCut/intensityRange/adaptiveRegionIntensityRange.js';
+import { getViewportVoiMappingForVolume } from '../../utilities/segmentation/growCut/getViewportVoiMappingForVolume.js';
+import { activeSegmentation } from '../../stateManagement/segmentation/index.js';
+import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents.js';
+import * as LabelmapMemo from '../../utilities/segmentation/createLabelmapMemo.js';
+import { PLUS_CURSOR, BLOCKED_CURSOR, PENDING_CURSOR, } from './regionSegmentHoverCursors.js';
+import { ToolModes } from '../../enums/index.js';
+const { growCutLog } = csUtils.logger;
+const HOVER_PROBE_THROTTLE_MS = 100;
+const PROBE_REUSE_DISTANCE_PX = 6;
+const PROBE_FRESH_MS = 1500;
+const EXPAND_STEP_FACTOR = 1.15;
+const SHRINK_STEP_FACTOR = 0.85;
+const MIN_COMPACTNESS = 0.08;
+const COMPACTNESS_CHECK_MIN_VOLUME_MM3 = 2000;
+const COMPUTE_BUDGET_MM3 = 2_000_000;
+const NOT_LESION_MESSAGE = 'The region here does not form a self-contained, lesion-like shape; nothing was segmented.';
+const DRY_RUN_YIELD_EVERY = 10_000;
+const CONSENSUS_MIN_NEIGHBOR_VOTES = 2;
+const VERDICT_CACHE_TTL_MS = 2500;
+const MAX_REJECTED_REGIONS = 8;
+class ClickSegmentTool extends GrowCutBaseTool {
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            maxDeltaK: 25,
+            maxDeltaIJ: 512,
+            actions: {
+                cancelInProgress: {
+                    method: 'cancelInProgress',
+                    bindings: [
+                        {
+                            key: 'Escape',
+                        },
+                    ],
+                },
+            },
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this.segmentationInProgress = false;
+        this.hoverThrottleTimer = null;
+        this.pendingHoverEvent = null;
+        this.lastHoverElement = null;
+        this.lastProbe = null;
+        this.lastClick = null;
+        this.clickAbortController = null;
+        this.dryRunToken = null;
+        this.confirmedRegion = null;
+        this.rejectedRegions = [];
+    }
+    notifySegmentationError(message) {
+        const event = new CustomEvent(CoreEnums.Events.ERROR_EVENT, {
+            detail: {
+                type: 'Segmentation',
+                message,
+            },
+            cancelable: true,
+        });
+        eventTarget.dispatchEvent(event);
+    }
+    cancelInProgress() {
+        return this.cancelActiveOperation();
+    }
+    cancelActiveOperation() {
+        if (!this.clickAbortController ||
+            this.clickAbortController.signal.aborted) {
+            return false;
+        }
+        this.clickAbortController.abort();
+        return true;
+    }
+    clearHoverState() {
+        if (this.hoverThrottleTimer !== null) {
+            window.clearTimeout(this.hoverThrottleTimer);
+            this.hoverThrottleTimer = null;
+        }
+        this.pendingHoverEvent = null;
+        this.lastProbe = null;
+        this.confirmedRegion = null;
+        this.rejectedRegions = [];
+        if (this.dryRunToken) {
+            this.dryRunToken.cancelled = true;
+            this.dryRunToken = null;
+        }
+        if (this.lastHoverElement) {
+            this.lastHoverElement.style.cursor = '';
+            this.lastHoverElement = null;
+        }
+    }
+    pointerOnConfirmedRegion(refVolume, viewport, world) {
+        const region = this.confirmedRegion;
+        if (!region ||
+            region.viewportId !== viewport.id ||
+            Date.now() > region.expiresAt) {
+            return false;
+        }
+        const ijk = csUtils
+            .transformWorldToIndex(refVolume.imageData, world)
+            .map(Math.round);
+        for (let axis = 0; axis < 3; axis++) {
+            if (ijk[axis] < region.bbox.min[axis] ||
+                ijk[axis] > region.bbox.max[axis]) {
+                return false;
+            }
+        }
+        const [width, height] = refVolume.dimensions;
+        const scalar = Number(refVolume.voxelManager.getAtIndex(ijk[2] * width * height + ijk[1] * width + ijk[0]));
+        if (!Number.isFinite(scalar) ||
+            scalar < region.bandMin ||
+            scalar > region.bandMax) {
+            return false;
+        }
+        region.expiresAt = Date.now() + VERDICT_CACHE_TTL_MS;
+        return true;
+    }
+    static bandsAreSimilar(aMin, aMax, bMin, bMax) {
+        const edgeMatches = (a, b) => {
+            if (!Number.isFinite(a) || !Number.isFinite(b)) {
+                return a === b;
+            }
+            const scale = Math.max(Math.abs(a), Math.abs(b), 1e-6);
+            return Math.abs(a - b) <= 0.25 * scale;
+        };
+        return edgeMatches(aMin, bMin) && edgeMatches(aMax, bMax);
+    }
+    matchesRejectedRegion(viewportId, range) {
+        const now = Date.now();
+        this.rejectedRegions = this.rejectedRegions.filter((entry) => entry.expiresAt > now);
+        const seed = range.ijkStart;
+        const match = this.rejectedRegions.find((entry) => {
+            if (entry.viewportId !== viewportId) {
+                return false;
+            }
+            for (let axis = 0; axis < 3; axis++) {
+                if (seed[axis] < entry.bbox.min[axis] ||
+                    seed[axis] > entry.bbox.max[axis]) {
+                    return false;
+                }
+            }
+            return ClickSegmentTool.bandsAreSimilar(range.min, range.max, entry.bandMin, entry.bandMax);
+        });
+        if (match) {
+            match.expiresAt = now + VERDICT_CACHE_TTL_MS;
+            return true;
+        }
+        return false;
+    }
+    rememberRejectedRegion(viewportId, bbox, bandMin, bandMax) {
+        if (!bbox) {
+            return;
+        }
+        this.rejectedRegions.push({
+            viewportId,
+            bbox: {
+                min: [...bbox.min],
+                max: [...bbox.max],
+            },
+            bandMin,
+            bandMax,
+            expiresAt: Date.now() + VERDICT_CACHE_TTL_MS,
+        });
+        if (this.rejectedRegions.length > MAX_REJECTED_REGIONS) {
+            this.rejectedRegions.splice(0, this.rejectedRegions.length - MAX_REJECTED_REGIONS);
+        }
+    }
+    safeSpacing(volume) {
+        const spacing = volume.spacing ?? [1, 1, 1];
+        return [0, 1, 2].map((axis) => Number.isFinite(spacing[axis]) && spacing[axis] > 0 ? spacing[axis] : 1);
+    }
+    computeVoxelBudget(volume) {
+        const [sx, sy, sz] = this.safeSpacing(volume);
+        return Math.max(1000, Math.ceil(COMPUTE_BUDGET_MM3 / (sx * sy * sz)));
+    }
+    makeRegionShapeGate(volume) {
+        const spacing = this.safeSpacing(volume);
+        const voxelVolumeMm3 = spacing[0] * spacing[1] * spacing[2];
+        const maxDeltaK = this.configuration.maxDeltaK;
+        return ({ voxelCount, bbox }) => {
+            if (typeof maxDeltaK === 'number' && maxDeltaK >= 0) {
+                const kExtent = bbox.max[2] - bbox.min[2] + 1;
+                if (kExtent >= 2 * maxDeltaK + 1) {
+                    return false;
+                }
+            }
+            const volumeMm3 = voxelCount * voxelVolumeMm3;
+            if (volumeMm3 < COMPACTNESS_CHECK_MIN_VOLUME_MM3) {
+                return true;
+            }
+            let bboxMm3 = 1;
+            for (let axis = 0; axis < 3; axis++) {
+                bboxMm3 *= (bbox.max[axis] - bbox.min[axis] + 1) * spacing[axis];
+            }
+            return volumeMm3 / bboxMm3 >= MIN_COMPACTNESS;
+        };
+    }
+    onSetToolPassive() {
+        this.clearHoverState();
+    }
+    onSetToolDisabled() {
+        this.clearHoverState();
+    }
+    buildProbeOptions(viewport, element, referencedVolumeId) {
+        return {
+            viewport,
+            element,
+            referencedVolumeId,
+            voiMapping: getViewportVoiMappingForVolume(viewport, referencedVolumeId) ??
+                undefined,
+        };
+    }
+    mouseMoveCallback(evt) {
+        if (this.mode !== ToolModes.Active) {
+            return;
+        }
+        const { element } = evt.detail;
+        this.lastHoverElement = element;
+        if (this.segmentationInProgress) {
+            element.style.cursor = 'wait';
+            return;
+        }
+        this.queueHoverProbe(evt);
+    }
+    queueHoverProbe(evt) {
+        this.pendingHoverEvent = evt;
+        if (this.hoverThrottleTimer !== null) {
+            return;
+        }
+        this.flushHoverProbe();
+    }
+    flushHoverProbe() {
+        const evt = this.pendingHoverEvent;
+        this.pendingHoverEvent = null;
+        if (!evt) {
+            return;
+        }
+        void this.runHoverProbe(evt);
+        this.hoverThrottleTimer = window.setTimeout(() => {
+            this.hoverThrottleTimer = null;
+            if (this.pendingHoverEvent) {
+                this.flushHoverProbe();
+            }
+        }, HOVER_PROBE_THROTTLE_MS);
+    }
+    getViewportSliceIndex(viewport) {
+        const getSliceIndex = viewport.getSliceIndex;
+        if (typeof getSliceIndex !== 'function') {
+            return null;
+        }
+        try {
+            const sliceIndex = getSliceIndex.call(viewport);
+            return Number.isFinite(sliceIndex) ? sliceIndex : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async runHoverProbe(evt) {
+        if (this.mode !== ToolModes.Active || this.segmentationInProgress) {
+            return;
+        }
+        const { element, currentPoints } = evt.detail;
+        const enabledElement = getEnabledElement(element);
+        const viewport = enabledElement?.viewport;
+        if (!viewport) {
+            return;
+        }
+        if (this.dryRunToken) {
+            this.dryRunToken.cancelled = true;
+            this.dryRunToken = null;
+        }
+        let state = 'unknown';
+        let dryRunInput = null;
+        try {
+            if (activeSegmentation.getActiveSegmentation(viewport.id)) {
+                const labelmapData = await this.getLabelmapSegmentationData(viewport);
+                if (labelmapData) {
+                    const { referencedVolumeId } = labelmapData;
+                    if (!this._isOrthogonalView(viewport, referencedVolumeId)) {
+                        state = 'blocked';
+                    }
+                    else {
+                        const refVolume = cache.getVolume(referencedVolumeId);
+                        if (refVolume) {
+                            if (this.pointerOnConfirmedRegion(refVolume, viewport, currentPoints.world)) {
+                                state = 'plus';
+                            }
+                            else {
+                                const options = this.buildProbeOptions(viewport, element, referencedVolumeId);
+                                const probe = probeAdaptiveRegion(refVolume, currentPoints.world, options);
+                                if (!probe.viable || !probe.range) {
+                                    state = 'blocked';
+                                }
+                                else if (this.matchesRejectedRegion(viewport.id, probe.range)) {
+                                    state = 'blocked';
+                                }
+                                else if (!this.neighborsAgree(probe)) {
+                                    state = 'blocked';
+                                }
+                                else {
+                                    state = 'pending';
+                                    dryRunInput = { refVolume, range: probe.range };
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            growCutLog.debug('hover probe: could not evaluate', {
+                message: err instanceof Error ? err.message : String(err),
+            });
+            state = 'unknown';
+        }
+        const verdict = state === 'unknown'
+            ? null
+            : {
+                viewportId: viewport.id,
+                canvas: [...currentPoints.canvas],
+                sliceIndex: this.getViewportSliceIndex(viewport),
+                ok: state !== 'blocked',
+                at: Date.now(),
+            };
+        this.lastProbe = verdict;
+        element.style.cursor =
+            state === 'plus'
+                ? PLUS_CURSOR
+                : state === 'blocked'
+                    ? BLOCKED_CURSOR
+                    : PENDING_CURSOR;
+        if (state === 'pending' && dryRunInput && verdict) {
+            const token = { cancelled: false };
+            this.dryRunToken = token;
+            void this.runConfinementDryRun(dryRunInput.refVolume, dryRunInput.range, token, verdict, element);
+        }
+    }
+    neighborsAgree(probe) {
+        const joinLevels = probe.clickNeighborJoinLevels;
+        const tolerance = probe.toleranceBytes;
+        if (!joinLevels || typeof tolerance !== 'number') {
+            return true;
+        }
+        let votes = 0;
+        let evaluated = 0;
+        for (const joinLevel of joinLevels) {
+            if (joinLevel === null) {
+                continue;
+            }
+            evaluated++;
+            if (joinLevel >= 0 && joinLevel <= tolerance) {
+                votes++;
+            }
+        }
+        return evaluated < CONSENSUS_MIN_NEIGHBOR_VOTES
+            ? votes === evaluated
+            : votes >= CONSENSUS_MIN_NEIGHBOR_VOTES;
+    }
+    async runConfinementDryRun(refVolume, range, token, verdict, element) {
+        const { dimensions } = refVolume;
+        const [width, height, depth] = dimensions;
+        const pixelsPerSlice = width * height;
+        const voxelManager = refVolume.voxelManager;
+        const { min, max } = range;
+        const shapeGate = this.makeRegionShapeGate(refVolume);
+        try {
+            const { truncated, voxelCount, bbox } = await floodFill3dSliceLazy((x, y, z) => Number(voxelManager.getAtIndex(z * pixelsPerSlice + y * width + x)), [...range.ijkStart], {
+                width,
+                height,
+                depth,
+                equals: (val) => typeof val === 'number' &&
+                    Number.isFinite(val) &&
+                    val >= min &&
+                    val <= max,
+                yieldEvery: DRY_RUN_YIELD_EVERY,
+                maxDeltaK: this.configuration.maxDeltaK,
+                maxDeltaIJ: this.configuration.maxDeltaIJ,
+                isCancelled: () => token.cancelled,
+                maxVoxels: this.computeVoxelBudget(refVolume),
+                shouldContinue: shapeGate,
+            });
+            if (token.cancelled) {
+                return;
+            }
+            const lesionLike = !truncated && bbox && shapeGate({ voxelCount, bbox });
+            if (lesionLike) {
+                this.confirmedRegion = {
+                    viewportId: verdict.viewportId,
+                    bbox,
+                    bandMin: min,
+                    bandMax: max,
+                    expiresAt: Date.now() + VERDICT_CACHE_TTL_MS,
+                };
+                if (this.lastProbe === verdict) {
+                    verdict.ok = true;
+                    element.style.cursor = PLUS_CURSOR;
+                }
+            }
+            else {
+                this.rememberRejectedRegion(verdict.viewportId, bbox, min, max);
+                if (this.lastProbe === verdict) {
+                    verdict.ok = false;
+                    element.style.cursor = BLOCKED_CURSOR;
+                }
+            }
+        }
+        catch (err) {
+            growCutLog.debug('hover dry-run: could not evaluate', {
+                message: err instanceof Error ? err.message : String(err),
+            });
+        }
+        finally {
+            if (this.dryRunToken === token) {
+                this.dryRunToken = null;
+            }
+        }
+    }
+    probeAppliesToClick(viewport, canvas) {
+        const probe = this.lastProbe;
+        if (!probe || probe.viewportId !== viewport.id) {
+            return false;
+        }
+        if (Date.now() - probe.at > PROBE_FRESH_MS) {
+            return false;
+        }
+        if (probe.sliceIndex !== this.getViewportSliceIndex(viewport)) {
+            return false;
+        }
+        const dx = canvas[0] - probe.canvas[0];
+        const dy = canvas[1] - probe.canvas[1];
+        return Math.sqrt(dx * dx + dy * dy) <= PROBE_REUSE_DISTANCE_PX;
+    }
+    async preMouseDownCallback(evt) {
+        if (this.segmentationInProgress) {
+            return false;
+        }
+        const { currentPoints, element } = evt.detail;
+        const { world: worldPoint, canvas: canvasPoint } = currentPoints;
+        const enabledElement = element ? getEnabledElement(element) : undefined;
+        if (enabledElement?.viewport &&
+            this.probeAppliesToClick(enabledElement.viewport, canvasPoint) &&
+            this.lastProbe?.ok === false) {
+            growCutLog.info('click ignored: hover probe reported no proper region', {
+                canvasPoint,
+            });
+            return false;
+        }
+        let setupOk = false;
+        try {
+            setupOk = await super.preMouseDownCallback(evt);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Click segmentation failed.';
+            growCutLog.info('ClickSegment: click setup rejected', { message });
+            this.notifySegmentationError(message);
+            return false;
+        }
+        if (!setupOk || !this.growCutData) {
+            return false;
+        }
+        const clickData = this.growCutData;
+        this.growCutData = null;
+        void this.runClick(clickData, worldPoint, element).catch((err) => {
+            const message = err instanceof Error ? err.message : 'Click segmentation failed.';
+            this.notifySegmentationError(message);
+            growCutLog.error('ClickSegment: segmentation failed', { message });
+        });
+        return true;
+    }
+    async runClick(clickData, worldPoint, element) {
+        const { segmentation, viewportId, renderingEngineId } = clickData;
+        const { referencedVolumeId, labelmapVolumeId, segmentIndex } = segmentation;
+        const renderingEngine = getRenderingEngine(renderingEngineId);
+        const viewport = renderingEngine?.getViewport(viewportId);
+        if (!viewport) {
+            throw new Error('ClickSegment: viewport not found for click.');
+        }
+        const refVolume = cache.getVolume(referencedVolumeId);
+        const labelmapVolume = cache.getVolume(labelmapVolumeId);
+        if (!refVolume || !labelmapVolume) {
+            throw new Error('ClickSegment: referenced or labelmap volume not in cache.');
+        }
+        const probe = probeAdaptiveRegion(refVolume, worldPoint, this.buildProbeOptions(viewport, viewport.element, referencedVolumeId));
+        if (!probe.viable || !probe.range || !probe.expandContext) {
+            growCutLog.info('ClickSegment: click found no meaningful region', {
+                reason: probe.reason,
+                regionAreaMm2: probe.regionAreaMm2,
+            });
+            this.notifySegmentationError('No meaningful region at the clicked location. Move the pointer until the plus cursor appears.');
+            return;
+        }
+        growCutLog.info('ClickSegment: click', {
+            worldPoint,
+            toleranceBytes: probe.toleranceBytes,
+            regionAreaMm2: probe.regionAreaMm2,
+            band: { min: probe.range.min, max: probe.range.max },
+        });
+        const memo = this.beginLabelmapMemo(segmentation, labelmapVolume);
+        let filledPoints;
+        try {
+            filledPoints = await this.fillWithRange(probe.range, {
+                segmentation,
+                viewportId,
+                renderingEngineId,
+            }, viewport, labelmapVolume, element, memo);
+        }
+        finally {
+            this.doneEditMemo();
+        }
+        this.lastClick = {
+            expandContext: probe.expandContext,
+            toleranceBytes: probe.expandContext.chosenToleranceBytes,
+            worldPoint: [...worldPoint],
+            filledPoints,
+            segmentation,
+            viewportId,
+            renderingEngineId,
+        };
+        growCutLog.info('ClickSegment: click complete', {
+            filledVoxels: filledPoints.length,
+            segmentIndex,
+        });
+    }
+    async fillWithRange(range, target, viewport, labelmapVolume, element, memo) {
+        const { segmentation } = target;
+        const { referencedVolumeId, segmentIndex, segmentationId } = segmentation;
+        this.segmentationInProgress = true;
+        if (element) {
+            element.style.cursor = 'wait';
+        }
+        const abortController = new AbortController();
+        this.clickAbortController = abortController;
+        let filledPoints = [];
+        let notLesionLike = false;
+        try {
+            const referencedVolume = cache.getVolume(referencedVolumeId);
+            if (!referencedVolume) {
+                throw new Error('ClickSegment: referenced volume is no longer cached; cannot fill.');
+            }
+            const result = await runFloodFillSegmentation({
+                referencedVolumeId,
+                worldPosition: this.indexToWorld(referencedVolume, range.ijkStart),
+                viewport,
+                labelmapVolume,
+                options: {
+                    segmentIndex,
+                    getIntensityRange: () => range,
+                    element: viewport.element,
+                    applyExternalIslandRemoval: true,
+                    applyInternalIslandRemoval: true,
+                    maxDeltaK: this.configuration.maxDeltaK,
+                    maxDeltaIJ: this.configuration.maxDeltaIJ,
+                    isCancelled: () => abortController.signal.aborted,
+                    maxVoxels: this.computeVoxelBudget(referencedVolume),
+                    shouldContinueRegion: this.makeRegionShapeGate(referencedVolume),
+                    historyVoxelManager: memo?.voxelManager,
+                    onRejected: ({ voxelCount, bbox }) => {
+                        notLesionLike = true;
+                        growCutLog.info('ClickSegment: fill rejected by shape gate', {
+                            voxelCount,
+                            bbox,
+                        });
+                    },
+                    onCommitted: (points) => {
+                        filledPoints = points;
+                    },
+                },
+            });
+            if (!result) {
+                if (abortController.signal.aborted) {
+                    throw new Error('ClickSegment: fill cancelled.');
+                }
+                throw new Error(notLesionLike
+                    ? NOT_LESION_MESSAGE
+                    : 'ClickSegment: fill produced no result (band rejected).');
+            }
+            triggerSegmentationDataModified(segmentationId);
+            return filledPoints;
+        }
+        finally {
+            if (this.clickAbortController === abortController) {
+                this.clickAbortController = null;
+            }
+            this.segmentationInProgress = false;
+            if (element) {
+                element.style.cursor = PENDING_CURSOR;
+            }
+        }
+    }
+    indexToWorld(volume, ijk) {
+        return csUtils.transformIndexToWorld(volume.imageData, ijk);
+    }
+    beginLabelmapMemo(segmentation, labelmapVolume) {
+        const memo = LabelmapMemo.createLabelmapMemo(segmentation.segmentationId, labelmapVolume.voxelManager);
+        this.memo = memo;
+        return memo;
+    }
+    curveSizeAt(context, toleranceBytes) {
+        let size = 0;
+        for (const [level, levelSize] of context.growthCurve) {
+            if (level > toleranceBytes) {
+                break;
+            }
+            size = levelSize;
+        }
+        return size;
+    }
+    pickNextTolerance(direction) {
+        const lastClick = this.lastClick;
+        if (!lastClick) {
+            return null;
+        }
+        const { expandContext, toleranceBytes } = lastClick;
+        const currentSize = this.curveSizeAt(expandContext, toleranceBytes);
+        if (direction > 0) {
+            for (const [level, size] of expandContext.growthCurve) {
+                if (level <= toleranceBytes) {
+                    continue;
+                }
+                if (size >= Math.max(currentSize + 1, currentSize * EXPAND_STEP_FACTOR)) {
+                    return level;
+                }
+            }
+            return null;
+        }
+        for (let index = expandContext.growthCurve.length - 1; index >= 0; index--) {
+            const [level, size] = expandContext.growthCurve[index];
+            if (level >= toleranceBytes) {
+                continue;
+            }
+            if (size <= Math.min(currentSize - 1, currentSize * SHRINK_STEP_FACTOR)) {
+                return level;
+            }
+        }
+        return null;
+    }
+    expand() {
+        this.stepTolerance(1);
+    }
+    shrink() {
+        this.stepTolerance(-1);
+    }
+    refresh() {
+        const lastClick = this.lastClick;
+        if (!lastClick || this.segmentationInProgress) {
+            return;
+        }
+        void this.refillAtTolerance(lastClick.toleranceBytes).catch((err) => {
+            growCutLog.error('ClickSegment: refresh failed', {
+                message: err instanceof Error ? err.message : String(err),
+            });
+        });
+    }
+    stepTolerance(direction) {
+        if (this.segmentationInProgress) {
+            return;
+        }
+        const lastClick = this.lastClick;
+        if (!lastClick) {
+            growCutLog.info('ClickSegment: no click to expand/shrink yet');
+            return;
+        }
+        const next = this.pickNextTolerance(direction);
+        if (next === null) {
+            growCutLog.info('ClickSegment: no further step available', {
+                direction: direction > 0 ? 'expand' : 'shrink',
+                toleranceBytes: lastClick.toleranceBytes,
+            });
+            return;
+        }
+        growCutLog.info('ClickSegment: stepping tolerance', {
+            direction: direction > 0 ? 'expand' : 'shrink',
+            fromToleranceBytes: lastClick.toleranceBytes,
+            toToleranceBytes: next,
+            predictedRegionPx: this.curveSizeAt(lastClick.expandContext, next),
+        });
+        const previousTolerance = lastClick.toleranceBytes;
+        void this.refillAtTolerance(next).catch((err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            if (message === NOT_LESION_MESSAGE && direction > 0) {
+                growCutLog.info('ClickSegment: expand blocked by the lesion shape gate; previous result kept', { previousTolerance });
+                this.notifySegmentationError('Expanding further would leak beyond a lesion-like shape; kept the previous result.');
+                return;
+            }
+            growCutLog.error('ClickSegment: expand/shrink failed', { message });
+        });
+    }
+    async refillAtTolerance(toleranceBytes) {
+        const lastClick = this.lastClick;
+        if (!lastClick) {
+            return;
+        }
+        const { segmentation, viewportId, renderingEngineId } = lastClick;
+        const labelmapVolume = cache.getVolume(segmentation.labelmapVolumeId);
+        const renderingEngine = getRenderingEngine(renderingEngineId);
+        const viewport = renderingEngine?.getViewport(viewportId);
+        if (!labelmapVolume || !viewport) {
+            growCutLog.warn('ClickSegment: labelmap or viewport gone; cannot expand/shrink');
+            return;
+        }
+        const memo = this.beginLabelmapMemo(segmentation, labelmapVolume);
+        try {
+            const { voxelManager } = labelmapVolume;
+            const historyVm = memo.voxelManager;
+            const [width, height] = labelmapVolume.dimensions;
+            const pixelsPerSlice = width * height;
+            const { segmentIndex } = segmentation;
+            const clearedIndices = [];
+            for (const [x, y, z] of lastClick.filledPoints) {
+                const index = z * pixelsPerSlice + y * width + x;
+                if (voxelManager.getAtIndex(index) === segmentIndex) {
+                    historyVm.setAtIndex(index, 0);
+                    clearedIndices.push(index);
+                }
+            }
+            const range = resolveAdaptiveBandAtTolerance(lastClick.expandContext, toleranceBytes);
+            try {
+                const filledPoints = await this.fillWithRange(range, {
+                    segmentation,
+                    viewportId,
+                    renderingEngineId,
+                }, viewport, labelmapVolume, this.lastHoverElement ?? undefined, memo);
+                lastClick.toleranceBytes = toleranceBytes;
+                lastClick.filledPoints = filledPoints;
+                growCutLog.info('ClickSegment: refill complete', {
+                    toleranceBytes,
+                    filledVoxels: filledPoints.length,
+                });
+            }
+            catch (err) {
+                for (const index of clearedIndices) {
+                    historyVm.setAtIndex(index, segmentIndex);
+                }
+                triggerSegmentationDataModified(segmentation.segmentationId);
+                throw err;
+            }
+        }
+        finally {
+            this.doneEditMemo();
+        }
+    }
+}
+ClickSegmentTool.toolName = 'ClickSegment';
+export default ClickSegmentTool;