@cornerstonejs/tools 5.4.11 → 5.4.13

package/dist/esm/utilities/segmentation/growCut/intensityRange/adaptiveRegionIntensityRange.js

@@ -0,0 +1,559 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+import { getViewportVoiMappingForVolume } from '../getViewportVoiMappingForVolume.js';
+import { DEFAULT_POSITIVE_STD_DEV_MULTIPLIER } from '../constants.js';
+const { transformWorldToIndex, mapScalarToViewportVoiIntensity, mapViewportVoiIntensityToScalar, getVolumeDirectionVectors, } = csUtils;
+const { growCutLog: log } = csUtils.logger;
+const WINDOW_RADIUS_PX = 96;
+const SEED_SNAP_RADIUS_PX = 4;
+const MIN_REGION_PX = 6;
+const MIN_REGION_MM2 = 8;
+const MAX_REGION_WINDOW_FRACTION = 0.6;
+const FLAT_CONTRAST_BYTES = 10;
+const MIN_TOLERANCE_BYTES = 2;
+const MIN_PLATEAU_WIDTH_BYTES = 4;
+const QUIET_GAIN_ABS_PX = 3;
+const QUIET_GAIN_FRACTION = 0.02;
+function medianOf(values) {
+    if (!values.length) {
+        return 0;
+    }
+    const sorted = values.slice().sort((a, b) => a - b);
+    return sorted[Math.floor(sorted.length / 2)];
+}
+function rawBandForTolerance(context, toleranceBytes) {
+    const { seedByte, polarity, voiMapping, rawWindow, seedScalar } = context;
+    const thresholdByte = Math.max(0, Math.min(255, polarity > 0 ? seedByte - toleranceBytes : seedByte + toleranceBytes));
+    const includedExtremeByte = polarity > 0 ? 255 : 0;
+    const rawFromByte = (byte) => voiMapping
+        ? mapViewportVoiIntensityToScalar(byte / 255, voiMapping)
+        : rawWindow.min + (byte / 255) * rawWindow.span;
+    const rawThreshold = rawFromByte(thresholdByte);
+    const rawExtreme = rawFromByte(includedExtremeByte);
+    let min;
+    let max;
+    if (rawExtreme >= rawThreshold) {
+        min = rawThreshold;
+        max = Infinity;
+    }
+    else {
+        min = -Infinity;
+        max = rawThreshold;
+    }
+    if (Number.isFinite(seedScalar)) {
+        min = Math.min(min, seedScalar);
+        max = Math.max(max, seedScalar);
+    }
+    return { min, max };
+}
+export function resolveAdaptiveBandAtTolerance(context, toleranceBytes) {
+    const tolerance = Math.max(0, Math.min(255, Math.round(toleranceBytes)));
+    const { min, max } = rawBandForTolerance(context, tolerance);
+    return {
+        min,
+        max,
+        ijkStart: [...context.seedIjk],
+        diagnostics: {
+            neighborhoodMean: Number.isFinite(context.seedScalar)
+                ? context.seedScalar
+                : 0,
+            neighborhoodStdDev: 0,
+            clickedVoxelValue: Number.isFinite(context.seedScalar)
+                ? context.seedScalar
+                : 0,
+            positiveStdDevMultiplier: 1,
+            neighborhoodRadius: SEED_SNAP_RADIUS_PX,
+            strategy: 'adaptiveRegion:atTolerance',
+            adaptive: {
+                toleranceBytes: tolerance,
+                regionSizePx: -1,
+                backgroundByte: -1,
+                seedByte: context.seedByte,
+                seedSnapped: false,
+                windowSize: [0, 0],
+                polarity: context.polarity,
+            },
+        },
+    };
+}
+export function probeAdaptiveRegionCore(input) {
+    const { dimensions, getScalar, ijkClick, voiMapping } = input;
+    const inPlaneAxes = input.inPlaneAxes ?? [0, 1];
+    const inPlaneSpacing = input.inPlaneSpacing ?? [1, 1];
+    for (let axis = 0; axis < 3; axis++) {
+        if (ijkClick[axis] < 0 || ijkClick[axis] >= dimensions[axis]) {
+            return { viable: false, reason: 'outside-volume', range: null };
+        }
+    }
+    const [axisA, axisB] = inPlaneAxes;
+    const a0 = Math.max(0, ijkClick[axisA] - WINDOW_RADIUS_PX);
+    const a1 = Math.min(dimensions[axisA] - 1, ijkClick[axisA] + WINDOW_RADIUS_PX);
+    const b0 = Math.max(0, ijkClick[axisB] - WINDOW_RADIUS_PX);
+    const b1 = Math.min(dimensions[axisB] - 1, ijkClick[axisB] + WINDOW_RADIUS_PX);
+    const wA = a1 - a0 + 1;
+    const wB = b1 - b0 + 1;
+    const windowArea = wA * wB;
+    const spacingA = Number.isFinite(inPlaneSpacing[0]) && inPlaneSpacing[0] > 0
+        ? inPlaneSpacing[0]
+        : 1;
+    const spacingB = Number.isFinite(inPlaneSpacing[1]) && inPlaneSpacing[1] > 0
+        ? inPlaneSpacing[1]
+        : 1;
+    const pxAreaMm2 = spacingA * spacingB;
+    const minRegionPx = Math.max(MIN_REGION_PX, Math.ceil(MIN_REGION_MM2 / pxAreaMm2));
+    const maxRegionPx = Math.max(minRegionPx + 1, Math.floor(windowArea * MAX_REGION_WINDOW_FRACTION));
+    const scalarAt = (x, y) => {
+        const ijk = [...ijkClick];
+        ijk[axisA] = a0 + x;
+        ijk[axisB] = b0 + y;
+        return Number(getScalar(ijk[0], ijk[1], ijk[2]));
+    };
+    const rawValues = new Float64Array(windowArea);
+    let rawMinInWindow = Infinity;
+    let rawMaxInWindow = -Infinity;
+    for (let y = 0; y < wB; y++) {
+        for (let x = 0; x < wA; x++) {
+            const v = scalarAt(x, y);
+            rawValues[y * wA + x] = v;
+            if (Number.isFinite(v)) {
+                if (v < rawMinInWindow) {
+                    rawMinInWindow = v;
+                }
+                if (v > rawMaxInWindow) {
+                    rawMaxInWindow = v;
+                }
+            }
+        }
+    }
+    if (!Number.isFinite(rawMinInWindow)) {
+        return { viable: false, reason: 'outside-volume', range: null };
+    }
+    const rawSpan = rawMaxInWindow - rawMinInWindow || 1;
+    const bytes = new Int16Array(windowArea);
+    for (let idx = 0; idx < windowArea; idx++) {
+        const v = rawValues[idx];
+        if (!Number.isFinite(v)) {
+            bytes[idx] = -1;
+            continue;
+        }
+        const mapped = voiMapping
+            ? mapScalarToViewportVoiIntensity(v, voiMapping)
+            : (v - rawMinInWindow) / rawSpan;
+        bytes[idx] = Math.max(0, Math.min(255, Math.round(mapped * 255)));
+    }
+    const ringBytes = [];
+    for (let x = 0; x < wA; x++) {
+        if (bytes[x] >= 0) {
+            ringBytes.push(bytes[x]);
+        }
+        const bottom = (wB - 1) * wA + x;
+        if (wB > 1 && bytes[bottom] >= 0) {
+            ringBytes.push(bytes[bottom]);
+        }
+    }
+    for (let y = 1; y < wB - 1; y++) {
+        const left = y * wA;
+        const right = y * wA + (wA - 1);
+        if (bytes[left] >= 0) {
+            ringBytes.push(bytes[left]);
+        }
+        if (wA > 1 && bytes[right] >= 0) {
+            ringBytes.push(bytes[right]);
+        }
+    }
+    const backgroundByte = medianOf(ringBytes);
+    const clickX = ijkClick[axisA] - a0;
+    const clickY = ijkClick[axisB] - b0;
+    let seedX = clickX;
+    let seedY = clickY;
+    let bestContrast = -1;
+    let bestDist = Infinity;
+    const snapR2 = SEED_SNAP_RADIUS_PX * SEED_SNAP_RADIUS_PX;
+    for (let dy = -SEED_SNAP_RADIUS_PX; dy <= SEED_SNAP_RADIUS_PX; dy++) {
+        for (let dx = -SEED_SNAP_RADIUS_PX; dx <= SEED_SNAP_RADIUS_PX; dx++) {
+            if (dx * dx + dy * dy > snapR2) {
+                continue;
+            }
+            const x = clickX + dx;
+            const y = clickY + dy;
+            if (x < 0 || x >= wA || y < 0 || y >= wB) {
+                continue;
+            }
+            const byte = bytes[y * wA + x];
+            if (byte < 0) {
+                continue;
+            }
+            const contrast = Math.abs(byte - backgroundByte);
+            const dist = dx * dx + dy * dy;
+            if (contrast > bestContrast ||
+                (contrast === bestContrast && dist < bestDist)) {
+                bestContrast = contrast;
+                bestDist = dist;
+                seedX = x;
+                seedY = y;
+            }
+        }
+    }
+    if (bestContrast < 0) {
+        return { viable: false, reason: 'outside-volume', range: null };
+    }
+    if (bestContrast < FLAT_CONTRAST_BYTES) {
+        return { viable: false, reason: 'flat-region', range: null };
+    }
+    const seedPixelByte = bytes[seedY * wA + seedX];
+    const polarity = seedPixelByte >= backgroundByte ? 1 : -1;
+    const elevation = (byte) => polarity > 0 ? byte : 255 - byte;
+    const seedNeighborhood = [];
+    for (let dy = -1; dy <= 1; dy++) {
+        for (let dx = -1; dx <= 1; dx++) {
+            const x = seedX + dx;
+            const y = seedY + dy;
+            if (x < 0 || x >= wA || y < 0 || y >= wB) {
+                continue;
+            }
+            const byte = bytes[y * wA + x];
+            if (byte >= 0 &&
+                Math.abs(byte - seedPixelByte) <= Math.abs(byte - backgroundByte)) {
+                seedNeighborhood.push(byte);
+            }
+        }
+    }
+    const v0 = seedNeighborhood.length
+        ? medianOf(seedNeighborhood)
+        : seedPixelByte;
+    const h0 = elevation(v0);
+    const cost = (idx) => {
+        const byte = bytes[idx];
+        if (byte < 0) {
+            return -1;
+        }
+        return Math.max(0, h0 - elevation(byte));
+    };
+    const buckets = new Array(256);
+    const pushToBucket = (level, idx) => {
+        let bucket = buckets[level];
+        if (!bucket) {
+            bucket = [];
+            buckets[level] = bucket;
+        }
+        bucket.push(idx);
+    };
+    const visited = new Uint8Array(windowArea);
+    const seedIdx = seedY * wA + seedX;
+    const seedCost = cost(seedIdx);
+    if (seedCost < 0) {
+        return { viable: false, reason: 'flat-region', range: null };
+    }
+    pushToBucket(seedCost, seedIdx);
+    visited[seedIdx] = 1;
+    const curve = [];
+    const clickIdx = clickY * wA + clickX;
+    let clickJoinLevel = -1;
+    const neighborOffsets = [
+        [-1, 0],
+        [1, 0],
+        [0, -1],
+        [0, 1],
+    ];
+    const clickNeighborJoinLevels = [];
+    const neighborWatch = new Map();
+    neighborOffsets.forEach(([dx, dy], slot) => {
+        const x = clickX + dx;
+        const y = clickY + dy;
+        if (x < 0 || x >= wA || y < 0 || y >= wB) {
+            clickNeighborJoinLevels.push(null);
+            return;
+        }
+        clickNeighborJoinLevels.push(-1);
+        neighborWatch.set(y * wA + x, slot);
+    });
+    let size = 0;
+    let borderTouchLevel = -1;
+    let explosionLevel = -1;
+    outer: for (let level = 0; level < 256; level++) {
+        const bucket = buckets[level];
+        if (bucket?.length) {
+            for (let bi = 0; bi < bucket.length; bi++) {
+                const idx = bucket[bi];
+                if (visited[idx] === 2) {
+                    continue;
+                }
+                visited[idx] = 2;
+                size++;
+                if (idx === clickIdx) {
+                    clickJoinLevel = level;
+                }
+                const watchSlot = neighborWatch.get(idx);
+                if (watchSlot !== undefined) {
+                    clickNeighborJoinLevels[watchSlot] = level;
+                }
+                const x = idx % wA;
+                const y = Math.floor(idx / wA);
+                if (borderTouchLevel < 0 &&
+                    (x === 0 || x === wA - 1 || y === 0 || y === wB - 1)) {
+                    borderTouchLevel = level;
+                }
+                if (size > maxRegionPx) {
+                    explosionLevel = level;
+                    break outer;
+                }
+                const neighbors = [idx - 1, idx + 1, idx - wA, idx + wA];
+                const canLeft = x > 0;
+                const canRight = x < wA - 1;
+                const canUp = y > 0;
+                const canDown = y < wB - 1;
+                const allowed = [canLeft, canRight, canUp, canDown];
+                for (let n = 0; n < 4; n++) {
+                    if (!allowed[n]) {
+                        continue;
+                    }
+                    const nIdx = neighbors[n];
+                    if (visited[nIdx] !== 0) {
+                        continue;
+                    }
+                    const nCost = cost(nIdx);
+                    if (nCost < 0) {
+                        continue;
+                    }
+                    visited[nIdx] = 1;
+                    pushToBucket(Math.max(level, nCost), nIdx);
+                }
+            }
+            bucket.length = 0;
+        }
+        const lastSize = curve.length ? curve[curve.length - 1].size : 0;
+        if (size > lastSize) {
+            curve.push({ level, size });
+        }
+    }
+    const growthEndLevel = explosionLevel >= 0 ? explosionLevel - 1 : 255;
+    const runs = [];
+    {
+        let runStart = -1;
+        let currentSize = 0;
+        let ci = 0;
+        const closeRun = (endLevel, sizeAtEnd) => {
+            if (runStart >= 0 && endLevel >= runStart) {
+                runs.push({
+                    startLevel: runStart,
+                    endLevel,
+                    width: endLevel - runStart,
+                    size: sizeAtEnd,
+                });
+            }
+            runStart = -1;
+        };
+        for (let level = 0; level <= growthEndLevel; level++) {
+            const sizeBefore = currentSize;
+            let gain = 0;
+            if (ci < curve.length && curve[ci].level === level) {
+                gain = curve[ci].size - currentSize;
+                currentSize = curve[ci].size;
+                ci++;
+            }
+            const quietThreshold = Math.max(QUIET_GAIN_ABS_PX, Math.floor(sizeBefore * QUIET_GAIN_FRACTION));
+            if (currentSize > 0 && gain <= quietThreshold) {
+                if (runStart < 0) {
+                    runStart = level;
+                }
+            }
+            else {
+                closeRun(level - 1, sizeBefore);
+            }
+        }
+        closeRun(growthEndLevel, currentSize);
+    }
+    let best = null;
+    for (const run of runs) {
+        const endLevel = borderTouchLevel >= 0
+            ? Math.min(run.endLevel, borderTouchLevel - 1)
+            : run.endLevel;
+        if (endLevel < run.startLevel) {
+            continue;
+        }
+        const clipped = {
+            ...run,
+            endLevel,
+            width: endLevel - run.startLevel,
+        };
+        if (clipped.size < minRegionPx || clipped.size > maxRegionPx) {
+            continue;
+        }
+        if (!best || clipped.width > best.width) {
+            best = clipped;
+        }
+    }
+    const selectionDebug = () => ({
+        growthCurve: curve.map((p) => [p.level, p.size]),
+        quietRuns: runs.map((run) => [
+            run.startLevel,
+            run.endLevel,
+            run.size,
+        ]),
+        seedByte: v0,
+        backgroundByte,
+        polarity,
+        borderTouchLevel,
+        explosionLevel,
+        clickJoinLevel,
+        minRegionPx,
+        maxRegionPx,
+        pxAreaMm2,
+    });
+    if (!best || best.width < MIN_PLATEAU_WIDTH_BYTES) {
+        const stableButSmall = runs.find((run) => run.size < minRegionPx &&
+            run.width >= MIN_PLATEAU_WIDTH_BYTES &&
+            (borderTouchLevel < 0 || run.startLevel < borderTouchLevel));
+        const failSize = best?.size ?? stableButSmall?.size ?? size;
+        return {
+            viable: false,
+            reason: stableButSmall ? 'too-small' : 'unbounded',
+            range: null,
+            regionSizePx: failSize,
+            regionAreaMm2: failSize * pxAreaMm2,
+            debug: selectionDebug(),
+        };
+    }
+    let toleranceBytes = best.startLevel + Math.floor(best.width / 2);
+    toleranceBytes = Math.min(Math.max(toleranceBytes, MIN_TOLERANCE_BYTES), best.endLevel);
+    const toleranceScale = input.toleranceScale && input.toleranceScale > 0 ? input.toleranceScale : 1;
+    toleranceBytes = Math.max(1, Math.min(255, Math.round(toleranceBytes * toleranceScale)));
+    const chosen = best;
+    if (clickJoinLevel < 0 || clickJoinLevel > toleranceBytes) {
+        return {
+            viable: false,
+            reason: 'off-target',
+            range: null,
+            regionSizePx: chosen.size,
+            regionAreaMm2: chosen.size * pxAreaMm2,
+            debug: selectionDebug(),
+        };
+    }
+    const seedIjk = [...ijkClick];
+    seedIjk[axisA] = a0 + seedX;
+    seedIjk[axisB] = b0 + seedY;
+    const seedScalar = rawValues[seedIdx];
+    const clickedScalar = rawValues[clickY * wA + clickX];
+    const expandContext = {
+        seedByte: v0,
+        polarity,
+        voiMapping: voiMapping ?? null,
+        rawWindow: { min: rawMinInWindow, span: rawSpan },
+        seedIjk,
+        seedScalar: Number.isFinite(seedScalar) ? seedScalar : 0,
+        growthCurve: curve.map((p) => [p.level, p.size]),
+        chosenToleranceBytes: toleranceBytes,
+        growthEndLevel,
+        pxAreaMm2,
+    };
+    const { min: rawLo, max: rawHi } = rawBandForTolerance(expandContext, toleranceBytes);
+    return {
+        viable: true,
+        reason: 'ok',
+        regionSizePx: chosen.size,
+        regionAreaMm2: chosen.size * pxAreaMm2,
+        toleranceBytes,
+        clickNeighborJoinLevels,
+        expandContext,
+        range: {
+            min: rawLo,
+            max: rawHi,
+            ijkStart: seedIjk,
+            diagnostics: {
+                neighborhoodMean: Number.isFinite(seedScalar) ? seedScalar : 0,
+                neighborhoodStdDev: 0,
+                clickedVoxelValue: Number.isFinite(clickedScalar) ? clickedScalar : 0,
+                positiveStdDevMultiplier: toleranceScale,
+                neighborhoodRadius: SEED_SNAP_RADIUS_PX,
+                strategy: 'adaptiveRegion',
+                adaptive: {
+                    toleranceBytes,
+                    regionSizePx: chosen.size,
+                    regionAreaMm2: chosen.size * pxAreaMm2,
+                    backgroundByte,
+                    seedByte: v0,
+                    polarity,
+                    seedSnapped: seedX !== clickX || seedY !== clickY,
+                    windowSize: [wA, wB],
+                    growthCurve: curve.map((p) => [p.level, p.size]),
+                    explosionLevel,
+                    borderTouchLevel,
+                },
+            },
+        },
+    };
+}
+export function resolveInPlaneAxes(referencedVolume, viewport) {
+    if (!viewport) {
+        return [0, 1];
+    }
+    try {
+        const camera = viewport.getCamera();
+        const { ijkVecSliceDir } = getVolumeDirectionVectors(referencedVolume.imageData, camera);
+        const abs = ijkVecSliceDir.map(Math.abs);
+        let sliceAxis = 0;
+        if (abs[1] >= abs[0] && abs[1] >= abs[2]) {
+            sliceAxis = 1;
+        }
+        else if (abs[2] >= abs[0] && abs[2] >= abs[1]) {
+            sliceAxis = 2;
+        }
+        const axes = [0, 1, 2].filter((axis) => axis !== sliceAxis);
+        return [axes[0], axes[1]];
+    }
+    catch {
+        return [0, 1];
+    }
+}
+export function probeAdaptiveRegion(referencedVolume, worldPosition, options) {
+    const { dimensions, imageData, spacing } = referencedVolume;
+    const voxelManager = referencedVolume.voxelManager;
+    const [width, height] = dimensions;
+    const pixelsPerSlice = width * height;
+    const ijkClick = transformWorldToIndex(imageData, worldPosition).map(Math.round);
+    const voiMapping = options?.voiMapping ??
+        (options?.viewport && options?.referencedVolumeId
+            ? getViewportVoiMappingForVolume(options.viewport, options.referencedVolumeId)
+            : null);
+    const toleranceScale = options?.positiveStdDevMultiplier
+        ? options.positiveStdDevMultiplier / DEFAULT_POSITIVE_STD_DEV_MULTIPLIER
+        : 1;
+    const inPlaneAxes = resolveInPlaneAxes(referencedVolume, options?.viewport);
+    const inPlaneSpacing = [
+        spacing?.[inPlaneAxes[0]] ?? 1,
+        spacing?.[inPlaneAxes[1]] ?? 1,
+    ];
+    const result = probeAdaptiveRegionCore({
+        dimensions,
+        getScalar: (i, j, k) => Number(voxelManager.getAtIndex(k * pixelsPerSlice + j * width + i)),
+        ijkClick,
+        inPlaneAxes,
+        inPlaneSpacing,
+        voiMapping,
+        toleranceScale,
+    });
+    log.debug('adaptiveRegion probe', {
+        ijkClick,
+        viable: result.viable,
+        reason: result.reason,
+        regionSizePx: result.regionSizePx,
+        regionAreaMm2: result.regionAreaMm2,
+        toleranceBytes: result.toleranceBytes,
+        band: result.range
+            ? { min: result.range.min, max: result.range.max }
+            : null,
+    });
+    return result;
+}
+export const getAdaptiveRegionIntensityRange = (referencedVolume, worldPosition, options) => {
+    const probe = probeAdaptiveRegion(referencedVolume, worldPosition, options);
+    if (!probe.viable) {
+        log.info('adaptiveRegion: no proper region at click', {
+            reason: probe.reason,
+            regionSizePx: probe.regionSizePx,
+            regionAreaMm2: probe.regionAreaMm2,
+            debug: probe.debug,
+        });
+        return null;
+    }
+    return probe.range;
+};

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

@@ -0,0 +1,10 @@
+import type { Types } from '@cornerstonejs/core';
+import type { VoxelManager } from '@cornerstonejs/core/utilities';
+type NumberVoxelManager = VoxelManager<number>;
+type NeighborhoodStats = {
+    mean: number;
+    stdDev: number;
+    count: number;
+};
+export declare function calculateNeighborhoodStatsVM(voxelManager: NumberVoxelManager, dimensions: Types.Point3, centerIjk: Types.Point3, radius: number, mapValue?: (v: number) => number): NeighborhoodStats;
+export {};

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

@@ -0,0 +1,44 @@
+export function calculateNeighborhoodStatsVM(voxelManager, dimensions, centerIjk, radius, mapValue) {
+    const [width, height, numSlices] = dimensions;
+    let sum = 0;
+    let sumSq = 0;
+    let count = 0;
+    const [cx, cy, cz] = centerIjk.map(Math.round);
+    for (let z = cz - radius; z <= cz + radius; z++) {
+        if (z < 0 || z >= numSlices) {
+            continue;
+        }
+        for (let y = cy - radius; y <= cy + radius; y++) {
+            if (y < 0 || y >= height) {
+                continue;
+            }
+            for (let x = cx - radius; x <= cx + radius; x++) {
+                if (x < 0 || x >= width) {
+                    continue;
+                }
+                const raw = Number(voxelManager.getAtIJK(x, y, z));
+                const value = mapValue ? mapValue(raw) : raw;
+                sum += value;
+                sumSq += value * value;
+                count++;
+            }
+        }
+    }
+    if (count === 0) {
+        if (cx >= 0 &&
+            cx < width &&
+            cy >= 0 &&
+            cy < height &&
+            cz >= 0 &&
+            cz < numSlices) {
+            const raw = Number(voxelManager.getAtIJK(cx, cy, cz));
+            const centerValue = mapValue ? mapValue(raw) : raw;
+            return { mean: centerValue, stdDev: 0, count: 1 };
+        }
+        return { mean: 0, stdDev: 0, count: 0 };
+    }
+    const mean = sum / count;
+    const variance = sumSq / count - mean * mean;
+    const stdDev = Math.sqrt(Math.max(0, variance));
+    return { mean, stdDev, count };
+}

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

@@ -0,0 +1,61 @@
+import type { Types } from '@cornerstonejs/core';
+import type { FloodFillIntensityRangeResult, FloodFillIntensityRangeOptions, GetFloodFillIntensityRange } from './floodFillIntensityRangeTypes.js';
+export type { FloodFillIntensityRangeResult, FloodFillIntensityRangeOptions, GetFloodFillIntensityRange, } from './floodFillIntensityRangeTypes.js';
+type FloodFillSegmentationOptions = {
+    isCancelled?: () => boolean;
+    positiveStdDevMultiplier?: number;
+    initialNeighborhoodRadius?: number;
+    segmentIndex?: number;
+    floodPreviewSegmentIndex?: number;
+    maxInternalRemove?: number;
+    applyExternalIslandRemoval?: boolean;
+    applyInternalIslandRemoval?: boolean;
+    islandRemovalVerboseLogging?: boolean;
+    getIntensityRange?: GetFloodFillIntensityRange;
+    element?: HTMLDivElement;
+    canvasPoint?: {
+        x: number;
+        y: number;
+    };
+    intensitySamplingDiskRadiusCanvasPx?: number;
+    ensureSliceLoaded?: (sliceIndex: number) => Promise<void>;
+    yieldEvery?: number;
+    planar?: boolean;
+    maxDeltaK?: number;
+    maxDeltaIJ?: number;
+    onCommitted?: (floodedPoints: Types.Point3[]) => void;
+    maxVoxels?: number;
+    shouldContinueRegion?: (stats: {
+        voxelCount: number;
+        bbox: {
+            min: Types.Point3;
+            max: Types.Point3;
+        };
+    }) => boolean;
+    onRejected?: (info: {
+        voxelCount: number;
+        bbox: {
+            min: Types.Point3;
+            max: Types.Point3;
+        } | null;
+    }) => void;
+    historyVoxelManager?: Types.IVoxelManager<number>;
+};
+declare function getDisplayVoiSnapshot(viewport: Types.IViewport, referencedVolumeId?: string): {
+    lower: number;
+    upper: number;
+    windowWidth: number;
+    windowCenter: number;
+} | null;
+declare function getPositiveIntensityRangeRaw(referencedVolume: Types.IImageVolume, worldPosition: Types.Point3, options?: FloodFillIntensityRangeOptions): FloodFillIntensityRangeResult | null;
+declare function getPositiveIntensityRangeVoiMapped(referencedVolume: Types.IImageVolume, worldPosition: Types.Point3, voiMapping: NonNullable<FloodFillIntensityRangeOptions['voiMapping']>, options?: FloodFillIntensityRangeOptions): FloodFillIntensityRangeResult | null;
+declare function getPositiveIntensityRange(referencedVolume: Types.IImageVolume, worldPosition: Types.Point3, options?: FloodFillIntensityRangeOptions): FloodFillIntensityRangeResult | null;
+declare function runFloodFillSegmentation({ referencedVolumeId, worldPosition, viewport, labelmapVolume, options, }: {
+    referencedVolumeId: string;
+    worldPosition: Types.Point3;
+    viewport: Types.IViewport;
+    labelmapVolume: Types.IImageVolume;
+    options?: FloodFillSegmentationOptions;
+}): Promise<Types.IImageVolume | null>;
+export { runFloodFillSegmentation as default, runFloodFillSegmentation, getPositiveIntensityRange, getPositiveIntensityRangeRaw, getPositiveIntensityRangeVoiMapped, getDisplayVoiSnapshot, };
+export type { FloodFillSegmentationOptions };