@ohif/app 3.13.0-beta.119 → 3.13.0-beta.120

package/dist/{3215.bundle.1fca83719c1b786b.js → 3330.bundle.b1297ef8c94e5440.js}

@@ -1,5 +1,5 @@
 "use strict";
-(globalThis["rspackChunk"] = globalThis["rspackChunk"] || []).push([[3215], {
+(globalThis["rspackChunk"] = globalThis["rspackChunk"] || []).push([[3330], {
 28910(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
@@ -6310,6 +6310,9 @@ __webpack_require__.d(__webpack_exports__, {
   loadImageToCanvas: () => (/* reexport */ loadImageToCanvas/* ["default"] */.A),
   logger: () => (/* reexport */ logger),
   makeVolumeMetadata: () => (/* reexport */ makeVolumeMetadata/* ["default"] */.A),
+  mapMappedBandToRawRange: () => (/* reexport */ viewportVoiIntensityMapping/* .mapMappedBandToRawRange */.j_),
+  mapScalarToViewportVoiIntensity: () => (/* reexport */ viewportVoiIntensityMapping/* .mapScalarToViewportVoiIntensity */.fT),
+  mapViewportVoiIntensityToScalar: () => (/* reexport */ viewportVoiIntensityMapping/* .mapViewportVoiIntensityToScalar */.l2),
   planar: () => (/* reexport */ planar),
   pointInShapeCallback: () => (/* reexport */ pointInShapeCallback/* .pointInShapeCallback */.ii),
   renderToCanvasCPU: () => (/* reexport */ renderToCanvasCPU/* ["default"] */.A),
@@ -6576,6 +6579,8 @@ var calculateSpacingBetweenImageIds = __webpack_require__(66831);
 var logger = __webpack_require__(80977);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/calculateNeighborhoodStats.js
 var calculateNeighborhoodStats = __webpack_require__(5830);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/viewportVoiIntensityMapping.js
+var viewportVoiIntensityMapping = __webpack_require__(28656);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/getPixelSpacingInformation.js
 var getPixelSpacingInformation = __webpack_require__(41840);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/getPlaneCubeIntersectionDimensions.js
@@ -6706,6 +6711,7 @@ var isEqual = __webpack_require__(77981);
 
 
 
+
 
 
 const utilities_getViewportModality = (viewport, volumeId) => (0,getViewportModality/* ._getViewportModality */.p)(viewport, volumeId, cache/* ["default"].getVolume */.Ay.getVolume);
@@ -6714,6 +6720,29 @@ const utilities_getScalingDescriptor = (viewport, targetId) => (0,getScalingDesc
 
 
 
+},
+80977(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  aiLog: () => (aiLog),
+  coreLog: () => (coreLog),
+  cs3dLog: () => (cs3dLog),
+  dicomConsistencyLog: () => (dicomConsistencyLog),
+  examplesLog: () => (examplesLog),
+  getLogger: () => (getLogger),
+  getRootLogger: () => (getRootLogger),
+  growCutLog: () => (growCutLog),
+  imageConsistencyLog: () => (imageConsistencyLog),
+  loaderLog: () => (loaderLog),
+  toolsLog: () => (toolsLog),
+  workerLog: () => (workerLog)
+});
+/* import */ var _cornerstonejs_utils__rspack_import_0 = __webpack_require__(53103);
+
+const { /* getRootLogger */pp: getRootLogger, /* getLogger */tZ: getLogger, /* cs3dLog */gE: cs3dLog, /* workerLog */bM: workerLog, /* coreLog */uu: coreLog, /* toolsLog */UA: toolsLog, /* loaderLog */_E: loaderLog, /* aiLog */RZ: aiLog, /* examplesLog */UX: examplesLog, /* dicomConsistencyLog */HL: dicomConsistencyLog, /* imageConsistencyLog */U5: imageConsistencyLog, } = _cornerstonejs_utils__rspack_import_0/* .logging */.m9;
+const growCutLog = toolsLog.getLogger('growCut');
+
+
 },
 25481(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 __webpack_require__.r(__webpack_exports__);
@@ -6778,7 +6807,7 @@ function isPointOnPlane(point, plane, tolerance = _constants_index_js__rspack_im
 
 
 },
-48260(__unused_rspack___webpack_module__, __unused_rspack___webpack_exports__, __webpack_require__) {
+63215(__unused_rspack___webpack_module__, __unused_rspack___webpack_exports__, __webpack_require__) {
 // NAMESPACE OBJECT: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/polyData/utils.js
 var utils_namespaceObject = {};
 __webpack_require__.r(utils_namespaceObject);
@@ -10188,7 +10217,7 @@ var COLOR_LUT = __webpack_require__(69501);
 
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/version.js
-const version = '5.4.12';
+const version = '5.4.13';
 
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/viewportPresentation.js
 var viewportPresentation = __webpack_require__(88299);
@@ -31010,6 +31039,769 @@ class RegionSegmentPlusTool extends GrowCutBaseTool/* ["default"] */.A {
 RegionSegmentPlusTool.toolName = 'RegionSegmentPlus';
 /* export default */ const annotation_RegionSegmentPlusTool = ((/* unused pure expression or super */ null && (RegionSegmentPlusTool)));
 
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/growCut/runFloodFillSegmentation.js + 4 modules
+var runFloodFillSegmentation = __webpack_require__(55600);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/floodFillSliceLazy.js
+var floodFillSliceLazy = __webpack_require__(10621);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/growCut/intensityRange/adaptiveRegionIntensityRange.js
+var adaptiveRegionIntensityRange = __webpack_require__(81537);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/growCut/getViewportVoiMappingForVolume.js
+var getViewportVoiMappingForVolume = __webpack_require__(1967);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/triggerSegmentationEvents.js + 4 modules
+var triggerSegmentationEvents = __webpack_require__(49256);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/createLabelmapMemo.js
+var createLabelmapMemo = __webpack_require__(1732);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/annotation/regionSegmentHoverCursors.js
+var regionSegmentHoverCursors = __webpack_require__(58690);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/annotation/ClickSegmentTool.js
+
+
+
+
+
+
+
+
+
+
+
+const { growCutLog } = esm.utilities.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/* ["default"] */.A {
+    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(esm.Enums.Events.ERROR_EVENT, {
+            detail: {
+                type: 'Segmentation',
+                message,
+            },
+            cancelable: true,
+        });
+        esm.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 = esm.utilities.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: (0,getViewportVoiMappingForVolume/* .getViewportVoiMappingForVolume */.K)(viewport, referencedVolumeId) ??
+                undefined,
+        };
+    }
+    mouseMoveCallback(evt) {
+        if (this.mode !== enums.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 !== enums.ToolModes.Active || this.segmentationInProgress) {
+            return;
+        }
+        const { element, currentPoints } = evt.detail;
+        const enabledElement = (0,esm.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 (stateManagement_segmentation.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 = esm.cache.getVolume(referencedVolumeId);
+                        if (refVolume) {
+                            if (this.pointerOnConfirmedRegion(refVolume, viewport, currentPoints.world)) {
+                                state = 'plus';
+                            }
+                            else {
+                                const options = this.buildProbeOptions(viewport, element, referencedVolumeId);
+                                const probe = (0,adaptiveRegionIntensityRange/* .probeAdaptiveRegion */.Ti)(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'
+                ? regionSegmentHoverCursors/* .PLUS_CURSOR */.ys
+                : state === 'blocked'
+                    ? regionSegmentHoverCursors/* .BLOCKED_CURSOR */.kC
+                    : regionSegmentHoverCursors/* .PENDING_CURSOR */.t5;
+        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 (0,floodFillSliceLazy/* .floodFill3dSliceLazy */.x)((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 = regionSegmentHoverCursors/* .PLUS_CURSOR */.ys;
+                }
+            }
+            else {
+                this.rememberRejectedRegion(verdict.viewportId, bbox, min, max);
+                if (this.lastProbe === verdict) {
+                    verdict.ok = false;
+                    element.style.cursor = regionSegmentHoverCursors/* .BLOCKED_CURSOR */.kC;
+                }
+            }
+        }
+        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 ? (0,esm.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 = (0,esm.getRenderingEngine)(renderingEngineId);
+        const viewport = renderingEngine?.getViewport(viewportId);
+        if (!viewport) {
+            throw new Error('ClickSegment: viewport not found for click.');
+        }
+        const refVolume = esm.cache.getVolume(referencedVolumeId);
+        const labelmapVolume = esm.cache.getVolume(labelmapVolumeId);
+        if (!refVolume || !labelmapVolume) {
+            throw new Error('ClickSegment: referenced or labelmap volume not in cache.');
+        }
+        const probe = (0,adaptiveRegionIntensityRange/* .probeAdaptiveRegion */.Ti)(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 = esm.cache.getVolume(referencedVolumeId);
+            if (!referencedVolume) {
+                throw new Error('ClickSegment: referenced volume is no longer cached; cannot fill.');
+            }
+            const result = await (0,runFloodFillSegmentation/* .runFloodFillSegmentation */.ZC)({
+                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).');
+            }
+            (0,triggerSegmentationEvents.triggerSegmentationDataModified)(segmentationId);
+            return filledPoints;
+        }
+        finally {
+            if (this.clickAbortController === abortController) {
+                this.clickAbortController = null;
+            }
+            this.segmentationInProgress = false;
+            if (element) {
+                element.style.cursor = regionSegmentHoverCursors/* .PENDING_CURSOR */.t5;
+            }
+        }
+    }
+    indexToWorld(volume, ijk) {
+        return esm.utilities.transformIndexToWorld(volume.imageData, ijk);
+    }
+    beginLabelmapMemo(segmentation, labelmapVolume) {
+        const memo = createLabelmapMemo.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 = esm.cache.getVolume(segmentation.labelmapVolumeId);
+        const renderingEngine = (0,esm.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 = (0,adaptiveRegionIntensityRange/* .resolveAdaptiveBandAtTolerance */.CN)(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);
+                }
+                (0,triggerSegmentationEvents.triggerSegmentationDataModified)(segmentation.segmentationId);
+                throw err;
+            }
+        }
+        finally {
+            this.doneEditMemo();
+        }
+    }
+}
+ClickSegmentTool.toolName = 'ClickSegment';
+/* export default */ const annotation_ClickSegmentTool = ((/* unused pure expression or super */ null && (ClickSegmentTool)));
+
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/annotation/WholeBodySegmentTool.js
 
 
@@ -32433,8 +33225,6 @@ CircleROIStartEndThresholdTool.toolName = 'CircleROIStartEndThreshold';
 
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/BrushTool.js
 var BrushTool = __webpack_require__(70947);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/triggerSegmentationEvents.js + 4 modules
-var triggerSegmentationEvents = __webpack_require__(49256);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/floodFill.js
 var floodFill = __webpack_require__(97637);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/PaintFillTool.js
@@ -34126,6 +34916,7 @@ LabelMapEditWithContourTool.viewportIdsChecked = [];
 
 
 
+
 
 
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/rectangle/index.js
@@ -36855,181 +37646,6 @@ __webpack_require__.d(__webpack_exports__, {
 
 
 
-},
-88392(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
-__webpack_require__.d(__webpack_exports__, {
-  AD: () => (registerLabelmap),
-  BS: () => (getLabelmapForVolumeId),
-  Hs: () => (getLabelmap),
-  M4: () => (getLabelmapForImageId),
-  kL: () => (getOrCreateLabelmapVolume),
-  m: () => (getLabelmaps)
-});
-/* import */ var _cornerstonejs_core__rspack_import_0 = __webpack_require__(88479);
-/* import */ var _normalizeLabelmapSegmentationData_js__rspack_import_1 = __webpack_require__(209);
-/* import */ var _labelmapImageIdMapping_js__rspack_import_2 = __webpack_require__(26372);
-
-
-
-function getLabelmap(segmentation, labelmapId) {
-    return (0,_normalizeLabelmapSegmentationData_js__rspack_import_1/* .ensureLabelmapState */.uk)(segmentation)?.labelmaps?.[labelmapId];
-}
-function getLabelmaps(segmentation) {
-    const labelmapState = (0,_normalizeLabelmapSegmentationData_js__rspack_import_1/* .ensureLabelmapState */.uk)(segmentation);
-    if (!labelmapState) {
-        return [];
-    }
-    return Object.values(labelmapState.labelmaps);
-}
-function registerLabelmap(segmentation, layer) {
-    const labelmapState = (0,_normalizeLabelmapSegmentationData_js__rspack_import_1/* .ensureLabelmapState */.uk)(segmentation);
-    if (!labelmapState) {
-        return;
-    }
-    labelmapState.labelmaps[layer.labelmapId] = layer;
-}
-function removeLabelmap(segmentation, labelmapId) {
-    const labelmapState = ensureLabelmapState(segmentation);
-    if (!labelmapState) {
-        return;
-    }
-    const layer = labelmapState.labelmaps[labelmapId];
-    if (layer?.geometryVolumeId && cache.getVolume(layer.geometryVolumeId)) {
-        cache.removeVolumeLoadObject(layer.geometryVolumeId);
-    }
-    delete labelmapState.labelmaps[labelmapId];
-}
-function getOrCreateLabelmapVolume(layer) {
-    const mergedVolume = getOrCreateMergedStackLabelmapVolume(layer);
-    if (mergedVolume) {
-        return mergedVolume;
-    }
-    const existingVolumeId = layer.volumeId ?? layer.geometryVolumeId;
-    if (existingVolumeId) {
-        const cachedVolume = _cornerstonejs_core__rspack_import_0.cache.getVolume(existingVolumeId);
-        if (cachedVolume) {
-            return cachedVolume;
-        }
-    }
-    const imageIds = layer.imageIds ?? [];
-    if (!imageIds.length) {
-        return;
-    }
-    const volumeId = layer.volumeId ?? layer.geometryVolumeId ?? `${layer.labelmapId}-geometry`;
-    if (!layer.volumeId) {
-        layer.geometryVolumeId = volumeId;
-    }
-    const cachedVolume = _cornerstonejs_core__rspack_import_0.cache.getVolume(volumeId);
-    if (cachedVolume) {
-        return cachedVolume;
-    }
-    return _cornerstonejs_core__rspack_import_0.volumeLoader.createAndCacheVolumeFromImagesSync(volumeId, imageIds);
-}
-function getOrCreateMergedStackLabelmapVolume(layer) {
-    if (layer.volumeId || !hasDuplicateReferencedImageIds(layer)) {
-        return;
-    }
-    const volumeId = layer.geometryVolumeId ?? `${layer.labelmapId}-geometry`;
-    const cachedVolume = _cornerstonejs_core__rspack_import_0.cache.getVolume(volumeId);
-    if (cachedVolume) {
-        return cachedVolume;
-    }
-    const imageIdsByReferencedImageId = new Map();
-    (0,_labelmapImageIdMapping_js__rspack_import_2/* .forEachLabelmapImageReference */.Zd)(layer, (referencedImageId, imageId) => {
-        const imageIdsForReference = imageIdsByReferencedImageId.get(referencedImageId) ?? [];
-        imageIdsForReference.push(imageId);
-        imageIdsByReferencedImageId.set(referencedImageId, imageIdsForReference);
-    });
-    const mergedReferencedImageIds = Array.from(imageIdsByReferencedImageId.keys());
-    if (!mergedReferencedImageIds.length) {
-        return;
-    }
-    let mergedImageIndex = 0;
-    const mergedImages = _cornerstonejs_core__rspack_import_0.imageLoader.createAndCacheDerivedImages(mergedReferencedImageIds, {
-        getDerivedImageId: () => `${volumeId}-image-${mergedImageIndex++}`,
-        targetBuffer: { type: 'Uint8Array' },
-    });
-    mergedImages.forEach((mergedImage) => {
-        const sourceImageIds = imageIdsByReferencedImageId.get(mergedImage.referencedImageId);
-        if (!sourceImageIds?.length) {
-            return;
-        }
-        const targetVoxelManager = mergedImage.voxelManager;
-        const scalarDataLength = targetVoxelManager.getScalarDataLength();
-        sourceImageIds.forEach((sourceImageId) => {
-            const sourceImage = _cornerstonejs_core__rspack_import_0.cache.getImage(sourceImageId);
-            const sourceVoxelManager = sourceImage?.voxelManager;
-            if (!sourceVoxelManager) {
-                return;
-            }
-            const sourceScalarDataLength = sourceVoxelManager.getScalarDataLength();
-            const length = Math.min(scalarDataLength, sourceScalarDataLength);
-            for (let index = 0; index < length; index++) {
-                const value = Number(sourceVoxelManager.getAtIndex(index));
-                if (value !== 0) {
-                    targetVoxelManager.setAtIndex(index, value);
-                }
-            }
-        });
-    });
-    layer.geometryVolumeId = volumeId;
-    return _cornerstonejs_core__rspack_import_0.volumeLoader.createAndCacheVolumeFromImagesSync(volumeId, mergedImages.map((image) => image.imageId));
-}
-function hasDuplicateReferencedImageIds(layer) {
-    return (0,_labelmapImageIdMapping_js__rspack_import_2/* .hasMultipleLabelmapImagesPerReferencedImageId */.dm)(layer);
-}
-function getLabelmapIds(segmentation) {
-    return getLabelmaps(segmentation).map((layer) => layer.labelmapId);
-}
-function getLabelmapDataById(segmentation, labelmapId) {
-    const labelmapState = ensureLabelmapState(segmentation);
-    const layer = labelmapState?.labelmaps?.[labelmapId];
-    if (!labelmapState || !layer) {
-        return;
-    }
-    return {
-        volumeId: layer.volumeId,
-        referencedVolumeId: layer.referencedVolumeId,
-        imageIds: layer.imageIds,
-        referencedImageIds: layer.referencedImageIds,
-        sourceRepresentationName: labelmapState.sourceRepresentationName,
-        primaryLabelmapId: labelmapId,
-        labelmaps: {
-            [labelmapId]: layer,
-        },
-        segmentBindings: Object.fromEntries(Object.entries(labelmapState.segmentBindings).filter(([, binding]) => binding.labelmapId === labelmapId)),
-    };
-}
-function getScalarArrayLengthFromLabelmap(layer) {
-    if (layer.volumeId) {
-        return cache.getVolume(layer.volumeId)?.voxelManager?.getScalarDataLength();
-    }
-    const firstImageId = layer.imageIds?.[0];
-    const firstImage = firstImageId ? cache.getImage(firstImageId) : null;
-    if (!firstImage || !layer.imageIds?.length) {
-        return 0;
-    }
-    return firstImage.voxelManager.getScalarDataLength() * layer.imageIds.length;
-}
-function getConstructorNameForLabelmap(layer) {
-    if (layer.volumeId) {
-        return cache.getVolume(layer.volumeId)?.voxelManager?.getConstructor()
-            ?.name;
-    }
-    const imageId = layer.imageIds?.[0];
-    return imageId
-        ? cache.getImage(imageId)?.voxelManager?.getConstructor()?.name
-        : undefined;
-}
-function getLabelmapForImageId(segmentation, imageId) {
-    return getLabelmaps(segmentation).find((layer) => layer.imageIds?.includes(imageId));
-}
-function getLabelmapForVolumeId(segmentation, volumeId) {
-    return getLabelmaps(segmentation).find((layer) => layer.volumeId === volumeId || layer.geometryVolumeId === volumeId);
-}
-
-
-
 },
 85335(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {