@cornerstonejs/tools 5.4.11 → 5.4.13

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

@@ -0,0 +1,524 @@
+import { utilities as csUtils, cache } from '@cornerstonejs/core';
+import IslandRemoval from '../floodFillIslandRemoval.js';
+import { commitSliceMasksToLabelmapVolume } from '../commitSliceMasksToLabelmap.js';
+import { createEnsureSliceLoadedForVolume } from '../createEnsureSliceLoadedForVolume.js';
+import { floodFill3dSliceLazy } from '../floodFillSliceLazy.js';
+import { DEFAULT_NEIGHBORHOOD_RADIUS, DEFAULT_POSITIVE_STD_DEV_MULTIPLIER, } from './constants.js';
+import { calculateNeighborhoodStatsVM } from './neighborhoodStats.js';
+import { getViewportVoiMappingForVolume } from './getViewportVoiMappingForVolume.js';
+const { transformWorldToIndex, mapScalarToViewportVoiIntensity, mapMappedBandToRawRange, } = csUtils;
+const { growCutLog: log } = csUtils.logger;
+const ENABLE_VERBOSE_FLOOD_FILL_LOGS = false;
+const timeStart = (label) => {
+    if (ENABLE_VERBOSE_FLOOD_FILL_LOGS) {
+        console.time(label);
+    }
+};
+const timeEnd = (label) => {
+    if (ENABLE_VERBOSE_FLOOD_FILL_LOGS) {
+        console.timeEnd(label);
+    }
+};
+const FLOOD_FILL_PREP_TIMING_LABEL = 'cornerstone.tools: floodFill: prep';
+const FLOOD_FILL_PREP_REF_META = 'cornerstone.tools: floodFill: prep: ref_volume_meta';
+const FLOOD_FILL_RANGE_TIMING_LABEL = 'cornerstone.tools: floodFill: intensityRange';
+const FLOOD_FILL_RUN_TIMING_LABEL = 'cornerstone.tools: floodFill: fillAndIslandRemoval';
+const FLOOD_FILL_ISLAND_EXTERNAL_TIMING_LABEL = 'cornerstone.tools: floodFill: islandRemoval:external';
+const FLOOD_FILL_ISLAND_INTERNAL_TIMING_LABEL = 'cornerstone.tools: floodFill: islandRemoval:internal';
+function getDisplayVoiSnapshot(viewport, referencedVolumeId) {
+    const getProps = viewport.getProperties;
+    if (typeof getProps !== 'function') {
+        return null;
+    }
+    const props = referencedVolumeId
+        ? getProps.call(viewport, referencedVolumeId)
+        : getProps.call(viewport);
+    const voiRange = props?.voiRange;
+    if (!voiRange ||
+        typeof voiRange.lower !== 'number' ||
+        typeof voiRange.upper !== 'number') {
+        return null;
+    }
+    const { lower, upper } = voiRange;
+    return {
+        lower,
+        upper,
+        windowWidth: upper - lower,
+        windowCenter: (lower + upper) / 2,
+    };
+}
+function getPositiveIntensityRangeRaw(referencedVolume, worldPosition, options) {
+    const { dimensions, imageData: refImageData } = referencedVolume;
+    const [width, height, numSlices] = dimensions;
+    const referenceVolumeVoxelManager = referencedVolume.voxelManager;
+    const neighborhoodRadius = options?.initialNeighborhoodRadius ?? DEFAULT_NEIGHBORHOOD_RADIUS;
+    const positiveK = options?.positiveStdDevMultiplier ?? DEFAULT_POSITIVE_STD_DEV_MULTIPLIER;
+    const ijkStart = transformWorldToIndex(refImageData, worldPosition).map(Math.round);
+    if (ijkStart[0] < 0 ||
+        ijkStart[0] >= width ||
+        ijkStart[1] < 0 ||
+        ijkStart[1] >= height ||
+        ijkStart[2] < 0 ||
+        ijkStart[2] >= numSlices) {
+        log.warn('intensity range: click outside volume', {
+            ijkStart,
+            dimensions: [width, height, numSlices],
+        });
+        return null;
+    }
+    const initialStats = calculateNeighborhoodStatsVM(referenceVolumeVoxelManager, dimensions, ijkStart, neighborhoodRadius);
+    if (initialStats.count === 0) {
+        const seedScalar = Number(referenceVolumeVoxelManager.getAtIJKPoint(ijkStart));
+        initialStats.mean = seedScalar;
+        initialStats.stdDev = 0;
+    }
+    const min = initialStats.mean - positiveK * initialStats.stdDev;
+    const max = initialStats.mean + positiveK * initialStats.stdDev;
+    const startValue = referenceVolumeVoxelManager.getAtIJKPoint(ijkStart);
+    if (startValue < min || startValue > max) {
+        log.warn('intensity range: clicked voxel intensity is outside the calculated positive range');
+        return null;
+    }
+    return {
+        min,
+        max,
+        ijkStart,
+        diagnostics: {
+            neighborhoodMean: initialStats.mean,
+            neighborhoodStdDev: initialStats.stdDev,
+            clickedVoxelValue: startValue,
+            positiveStdDevMultiplier: positiveK,
+            neighborhoodRadius,
+            strategy: 'meanStdRaw',
+        },
+    };
+}
+function getPositiveIntensityRangeVoiMapped(referencedVolume, worldPosition, voiMapping, options) {
+    const { dimensions, imageData: refImageData } = referencedVolume;
+    const [width, height, numSlices] = dimensions;
+    const referenceVolumeVoxelManager = referencedVolume.voxelManager;
+    const neighborhoodRadius = options?.initialNeighborhoodRadius ?? DEFAULT_NEIGHBORHOOD_RADIUS;
+    const positiveK = options?.positiveStdDevMultiplier ?? DEFAULT_POSITIVE_STD_DEV_MULTIPLIER;
+    const ijkStart = transformWorldToIndex(refImageData, worldPosition).map(Math.round);
+    if (ijkStart[0] < 0 ||
+        ijkStart[0] >= width ||
+        ijkStart[1] < 0 ||
+        ijkStart[1] >= height ||
+        ijkStart[2] < 0 ||
+        ijkStart[2] >= numSlices) {
+        log.info('intensity range (VOI-mapped): click outside volume', {
+            ijkStart,
+            dimensions: [width, height, numSlices],
+        });
+        return null;
+    }
+    const mapFn = (v) => mapScalarToViewportVoiIntensity(v, voiMapping);
+    const initialStats = calculateNeighborhoodStatsVM(referenceVolumeVoxelManager, dimensions, ijkStart, neighborhoodRadius, mapFn);
+    if (initialStats.count === 0) {
+        const seedScalar = Number(referenceVolumeVoxelManager.getAtIJKPoint(ijkStart));
+        initialStats.mean = mapFn(seedScalar);
+        initialStats.stdDev = 0;
+    }
+    let yMin = initialStats.mean - positiveK * initialStats.stdDev;
+    let yMax = initialStats.mean + positiveK * initialStats.stdDev;
+    yMin = Math.max(0, Math.min(1, yMin));
+    yMax = Math.max(0, Math.min(1, yMax));
+    if (yMin > yMax) {
+        const t = yMin;
+        yMin = yMax;
+        yMax = t;
+    }
+    const { rawMin, rawMax } = mapMappedBandToRawRange(yMin, yMax, voiMapping);
+    const startValue = Number(referenceVolumeVoxelManager.getAtIJKPoint(ijkStart));
+    const bandLo = Math.min(rawMin, rawMax);
+    const bandHi = Math.max(rawMin, rawMax);
+    const min = Math.min(bandLo, startValue);
+    const max = Math.max(bandHi, startValue);
+    return {
+        min,
+        max,
+        ijkStart,
+        diagnostics: {
+            neighborhoodMean: initialStats.mean,
+            neighborhoodStdDev: initialStats.stdDev,
+            clickedVoxelValue: startValue,
+            positiveStdDevMultiplier: positiveK,
+            neighborhoodRadius,
+            strategy: 'meanStdVoiMapped',
+            mappedBand: { min: yMin, max: yMax },
+        },
+    };
+}
+function getPositiveIntensityRange(referencedVolume, worldPosition, options) {
+    if (options?.voiMapping) {
+        return getPositiveIntensityRangeVoiMapped(referencedVolume, worldPosition, options.voiMapping, options);
+    }
+    return getPositiveIntensityRangeRaw(referencedVolume, worldPosition, options);
+}
+function resolveIntensityRange(referencedVolume, worldPosition, viewport, referencedVolumeId, options, rangeContext) {
+    if (options.getIntensityRange) {
+        const fromGetter = options.getIntensityRange(referencedVolume, worldPosition, rangeContext);
+        if (!fromGetter) {
+            log.warn('flood fill intensity range: strategy/custom getIntensityRange returned null (e.g. missing canvasPoint/VOI for canvas-disk, click outside volume, or fixed-% rejection)', { referencedVolumeId, worldPosition });
+        }
+        return fromGetter;
+    }
+    const voiFromViewport = getViewportVoiMappingForVolume(viewport, referencedVolumeId);
+    const merged = {
+        ...rangeContext,
+        voiMapping: voiFromViewport ?? undefined,
+    };
+    let result = getPositiveIntensityRange(referencedVolume, worldPosition, merged);
+    if (!result && merged.voiMapping) {
+        log.info('flood fill intensity range: VOI-mapped mean±σ failed; falling back to raw mean±σ', { referencedVolumeId });
+        result = getPositiveIntensityRange(referencedVolume, worldPosition, {
+            ...merged,
+            voiMapping: undefined,
+        });
+    }
+    if (!result) {
+        log.warn('flood fill intensity range: default mean±σ (VOI + raw fallback) could not resolve a band', { referencedVolumeId, worldPosition });
+    }
+    return result;
+}
+function assertFloodFillLabelmapMatchesRef(referencedVolume, labelmapVolume) {
+    const [rw, rh, rd] = referencedVolume.dimensions;
+    const [lw, lh, ld] = labelmapVolume.dimensions;
+    if (rw !== lw || rh !== lh || rd !== ld) {
+        throw new Error(`runFloodFillSegmentation: labelmap dimensions [${lw},${lh},${ld}] must match referenced volume [${rw},${rh},${rd}]`);
+    }
+}
+function resolveFloodPaintIndices(segmentIndex, explicitPreview) {
+    if (explicitPreview !== undefined) {
+        return {
+            paintIndex: explicitPreview,
+            usePreview: explicitPreview !== segmentIndex,
+        };
+    }
+    if (segmentIndex === 255) {
+        return { paintIndex: 255, usePreview: false };
+    }
+    return { paintIndex: 255, usePreview: true };
+}
+function promotePreviewSegmentToFinal(readVoxelManager, writeVoxelManager, preview, final, points, numPixelsPerSlice, width) {
+    for (let i = 0; i < points.length; i++) {
+        const [x, y, z] = points[i];
+        const index = z * numPixelsPerSlice + y * width + x;
+        if (readVoxelManager.getAtIndex(index) === preview) {
+            writeVoxelManager.setAtIndex(index, final);
+        }
+    }
+}
+async function runFloodFillSegmentation({ referencedVolumeId, worldPosition, viewport, labelmapVolume, options = {}, }) {
+    timeStart(FLOOD_FILL_PREP_TIMING_LABEL);
+    const referencedVolume = cache.getVolume(referencedVolumeId);
+    assertFloodFillLabelmapMatchesRef(referencedVolume, labelmapVolume);
+    const labelmap = labelmapVolume;
+    const segmentIndex = options.segmentIndex ?? 1;
+    const { paintIndex, usePreview } = resolveFloodPaintIndices(segmentIndex, options.floodPreviewSegmentIndex);
+    timeStart(FLOOD_FILL_PREP_REF_META);
+    const [volMin, volMax] = referencedVolume.voxelManager.getRange();
+    const displayVoi = getDisplayVoiSnapshot(viewport, referencedVolumeId);
+    log.info('segmentation path: flood fill (floodfill_full)', {
+        referencedVolumeId,
+        volumeScalarRange: { min: volMin, max: volMax },
+        displayVoi,
+        floodPreview: usePreview ? paintIndex : null,
+        segmentIndex,
+    });
+    timeEnd(FLOOD_FILL_PREP_REF_META);
+    timeEnd(FLOOD_FILL_PREP_TIMING_LABEL);
+    const voiMapping = getViewportVoiMappingForVolume(viewport, referencedVolumeId);
+    const rangeContext = {
+        positiveStdDevMultiplier: options.positiveStdDevMultiplier,
+        initialNeighborhoodRadius: options.initialNeighborhoodRadius,
+        viewport,
+        element: options.element,
+        referencedVolumeId,
+        canvasPoint: options.canvasPoint,
+        canvasDiskRadiusPx: options.intensitySamplingDiskRadiusCanvasPx,
+        voiMapping: voiMapping ?? undefined,
+    };
+    timeStart(FLOOD_FILL_RANGE_TIMING_LABEL);
+    const rangeResult = resolveIntensityRange(referencedVolume, worldPosition, viewport, referencedVolumeId, options, rangeContext);
+    timeEnd(FLOOD_FILL_RANGE_TIMING_LABEL);
+    if (!rangeResult) {
+        log.warn('flood fill: aborted before fill (no intensity range)', {
+            referencedVolumeId,
+            worldPosition,
+        });
+        return null;
+    }
+    const { min: rangeMin, max: rangeMax, ijkStart, diagnostics } = rangeResult;
+    let clampedRangeMin = rangeMin;
+    let clampedRangeMax = rangeMax;
+    const MAX_WL_BAND_FRACTION = 0.2;
+    if (voiMapping && diagnostics?.mappedBand) {
+        const mapped = diagnostics.mappedBand;
+        const mappedLo = Math.max(0, Math.min(1, Math.min(mapped.min, mapped.max)));
+        const mappedHi = Math.max(0, Math.min(1, Math.max(mapped.min, mapped.max)));
+        const mappedWidth = mappedHi - mappedLo;
+        if (mappedWidth > MAX_WL_BAND_FRACTION) {
+            const seedScalarPreClamp = Number(referencedVolume.voxelManager.getAtIJKPoint(ijkStart));
+            const seedMapped = Math.max(0, Math.min(1, mapScalarToViewportVoiIntensity(seedScalarPreClamp, voiMapping)));
+            const half = MAX_WL_BAND_FRACTION / 2;
+            const clippedMappedLo = Math.max(0, seedMapped - half);
+            const clippedMappedHi = Math.min(1, seedMapped + half);
+            const { rawMin: clipRawMin, rawMax: clipRawMax } = mapMappedBandToRawRange(clippedMappedLo, clippedMappedHi, voiMapping);
+            clampedRangeMin = Math.min(clipRawMin, clipRawMax, seedScalarPreClamp);
+            clampedRangeMax = Math.max(clipRawMin, clipRawMax, seedScalarPreClamp);
+            log.info('flood fill: clipped wide WL band around seed', {
+                maxWlBandFraction: MAX_WL_BAND_FRACTION,
+                originalMappedBand: {
+                    min: mappedLo,
+                    max: mappedHi,
+                    width: mappedWidth,
+                },
+                clippedMappedBand: {
+                    min: clippedMappedLo,
+                    max: clippedMappedHi,
+                    width: clippedMappedHi - clippedMappedLo,
+                },
+            });
+        }
+    }
+    log.info('intensity tolerance band', {
+        toleranceMin: clampedRangeMin,
+        toleranceMax: clampedRangeMax,
+        width: clampedRangeMax - clampedRangeMin,
+        ...diagnostics,
+    });
+    if (ENABLE_VERBOSE_FLOOD_FILL_LOGS) {
+        console.info('[cornerstone-tools] flood fill intensity range', {
+            rawMin: clampedRangeMin,
+            rawMax: clampedRangeMax,
+            strategy: diagnostics.strategy,
+            mappedBand: diagnostics.mappedBand,
+            neighborhoodRadius: diagnostics.neighborhoodRadius,
+        });
+    }
+    timeStart(FLOOD_FILL_RUN_TIMING_LABEL);
+    try {
+        const { dimensions } = referencedVolume;
+        const [width, height, numSlices] = dimensions;
+        const refVoxelManager = referencedVolume.voxelManager;
+        const numPixelsPerSlice = width * height;
+        const labelmapReadVm = labelmap.voxelManager;
+        const labelmapWriteVm = (options.historyVoxelManager ??
+            labelmap.voxelManager);
+        let positiveMin = clampedRangeMin;
+        let positiveMax = clampedRangeMax;
+        const seedScalar = Number(refVoxelManager.getAtIJKPoint(ijkStart));
+        if (Number.isFinite(seedScalar)) {
+            if (seedScalar < positiveMin) {
+                log.info('flood fill: expanded tolerance min to include seed voxel', {
+                    seedScalar,
+                    previousMin: positiveMin,
+                });
+                positiveMin = seedScalar;
+            }
+            if (seedScalar > positiveMax) {
+                log.info('flood fill: expanded tolerance max to include seed voxel', {
+                    seedScalar,
+                    previousMax: positiveMax,
+                });
+                positiveMax = seedScalar;
+            }
+        }
+        if (ENABLE_VERBOSE_FLOOD_FILL_LOGS) {
+            console.info('[cornerstone-tools] flood fill seed + effective tolerance', {
+                seedScalar,
+                effectiveMin: positiveMin,
+                effectiveMax: positiveMax,
+            });
+        }
+        const intensityGetter = (x, y, z) => {
+            if (x < 0 ||
+                x >= width ||
+                y < 0 ||
+                y >= height ||
+                z < 0 ||
+                z >= numSlices) {
+                return undefined;
+            }
+            const idx = z * numPixelsPerSlice + y * width + x;
+            return refVoxelManager.getAtIndex(idx);
+        };
+        const inRange = (val) => val >= positiveMin && val <= positiveMax;
+        const ensureSliceLoaded = options.ensureSliceLoaded ??
+            createEnsureSliceLoadedForVolume(referencedVolume);
+        const planar = options.planar === true;
+        if (planar) {
+            log.info('flood fill: planar mode (fixed slice index k)', { ijkStart });
+        }
+        const { sliceMasks, voxelCount: filledVoxelCount, truncated, bbox, } = await floodFill3dSliceLazy(intensityGetter, ijkStart, {
+            width,
+            height,
+            depth: numSlices,
+            equals: (val, _startVal) => val !== undefined && typeof val === 'number' && inRange(val),
+            ensureSliceLoaded,
+            yieldEvery: options.yieldEvery ?? 500,
+            planar,
+            maxDeltaK: options.maxDeltaK,
+            maxDeltaIJ: options.maxDeltaIJ,
+            isCancelled: options.isCancelled,
+            maxVoxels: options.maxVoxels,
+            shouldContinue: options.shouldContinueRegion,
+        });
+        const finalShapeRejected = !truncated &&
+            bbox &&
+            options.shouldContinueRegion &&
+            !options.shouldContinueRegion({ voxelCount: filledVoxelCount, bbox });
+        if (truncated || finalShapeRejected) {
+            log.warn('flood fill: rejected — region stopped by budget or shape gate; nothing committed', {
+                maxVoxels: options.maxVoxels,
+                voxelCountAtStop: filledVoxelCount,
+                bbox,
+                ijkStart,
+            });
+            options.onRejected?.({ voxelCount: filledVoxelCount, bbox });
+            return null;
+        }
+        if (filledVoxelCount === 0) {
+            log.info('flood fill: zero voxels (range may be too tight or seed isolated)', {
+                ijkStart,
+                toleranceMin: positiveMin,
+                toleranceMax: positiveMax,
+            });
+            return labelmap;
+        }
+        if (options.isCancelled?.() === true) {
+            log.info('flood fill: cancellation requested; nothing committed', {
+                ijkStart,
+                voxelCountAtCancel: filledVoxelCount,
+            });
+            return null;
+        }
+        const { floodedPoints, voxelCount: committedVoxels } = commitSliceMasksToLabelmapVolume({
+            labelmapVolume: labelmap,
+            sliceMasks,
+            width,
+            height,
+            paintIndex,
+            historyVoxelManager: options.historyVoxelManager,
+        });
+        if (committedVoxels === 0 || floodedPoints.length === 0) {
+            log.warn('flood fill: commit produced no labelmap voxels', {
+                filledVoxelCount,
+                committedVoxels,
+                ijkStart,
+            });
+            return labelmap;
+        }
+        let committedPoints = floodedPoints;
+        log.info('flood fill: complete', {
+            voxelCount: floodedPoints.length,
+            ijkStart,
+            paintIndex,
+            usePreview,
+        });
+        const applyExternal = options.applyExternalIslandRemoval !== false;
+        const applyInternal = options.applyInternalIslandRemoval !== false && applyExternal;
+        if (!applyExternal && !applyInternal) {
+            if (usePreview) {
+                promotePreviewSegmentToFinal(labelmapReadVm, labelmapWriteVm, paintIndex, segmentIndex, floodedPoints, numPixelsPerSlice, width);
+            }
+            options.onCommitted?.(committedPoints);
+            return labelmap;
+        }
+        const islandVerbose = options.islandRemovalVerboseLogging === true;
+        const islandRemoval = new IslandRemoval({
+            maxInternalRemove: options.maxInternalRemove ?? 128,
+            fillInternalEdge: false,
+            verboseLogging: islandVerbose,
+        });
+        const ijkPoints = [ijkStart];
+        const initialized = islandRemoval.initialize(viewport, options.historyVoxelManager ?? labelmap.voxelManager, {
+            points: ijkPoints,
+            segmentIndex,
+            previewSegmentIndex: usePreview ? paintIndex : segmentIndex,
+        });
+        if (!initialized) {
+            log.warn('island removal: initialize failed', { segmentIndex, ijkStart });
+            if (usePreview) {
+                promotePreviewSegmentToFinal(labelmapReadVm, labelmapWriteVm, paintIndex, segmentIndex, floodedPoints, numPixelsPerSlice, width);
+            }
+            options.onCommitted?.(committedPoints);
+            return labelmap;
+        }
+        let islandFloodVoxels = 0;
+        let externalClearedVoxels = 0;
+        let internalSliceCount;
+        if (applyExternal) {
+            timeStart(FLOOD_FILL_ISLAND_EXTERNAL_TIMING_LABEL);
+            islandFloodVoxels = islandRemoval.floodFillSegmentIsland();
+            externalClearedVoxels = islandRemoval.removeExternalIslands();
+            timeEnd(FLOOD_FILL_ISLAND_EXTERNAL_TIMING_LABEL);
+            if (applyInternal) {
+                timeStart(FLOOD_FILL_ISLAND_INTERNAL_TIMING_LABEL);
+                const modifiedSlices = islandRemoval.removeInternalIslands();
+                internalSliceCount = modifiedSlices?.length;
+                timeEnd(FLOOD_FILL_ISLAND_INTERNAL_TIMING_LABEL);
+            }
+        }
+        log.info('island removal: complete', {
+            segmentIndex,
+            applyExternalIslandRemoval: applyExternal,
+            applyInternalIslandRemoval: applyInternal,
+            floodedPointsBeforeIsland: floodedPoints.length,
+            islandFloodVoxelsFromSegmentSet: islandFloodVoxels,
+            externalIslandClearVoxels: externalClearedVoxels,
+            internalRemovalModifiedSlices: internalSliceCount,
+            islandRemovalVerboseLogging: islandVerbose,
+        });
+        const internalFilledPoints = applyInternal
+            ? islandRemoval.getInternalFilledPoints()
+            : [];
+        committedPoints =
+            internalFilledPoints.length > 0
+                ? floodedPoints.concat(internalFilledPoints)
+                : floodedPoints;
+        if (usePreview) {
+            promotePreviewSegmentToFinal(labelmapReadVm, labelmapWriteVm, paintIndex, segmentIndex, committedPoints, numPixelsPerSlice, width);
+        }
+        options.onCommitted?.(committedPoints);
+        if (ENABLE_VERBOSE_FLOOD_FILL_LOGS && floodedPoints.length > 0) {
+            let finalSegmentCount = 0;
+            let previewCount = 0;
+            let zeroCount = 0;
+            let otherCount = 0;
+            for (let i = 0; i < floodedPoints.length; i++) {
+                const [x, y, z] = floodedPoints[i];
+                const index = z * numPixelsPerSlice + y * width + x;
+                const value = Number(labelmap.voxelManager.getAtIndex(index) ?? 0);
+                if (value === segmentIndex) {
+                    finalSegmentCount += 1;
+                }
+                else if (value === paintIndex) {
+                    previewCount += 1;
+                }
+                else if (value === 0) {
+                    zeroCount += 1;
+                }
+                else {
+                    otherCount += 1;
+                }
+            }
+            console.info('[cornerstone-tools] flood fill final voxel check', {
+                floodedPoints: floodedPoints.length,
+                segmentIndex,
+                paintIndex,
+                usePreview,
+                finalSegmentCount,
+                previewCount,
+                zeroCount,
+                otherCount,
+            });
+        }
+        return labelmap;
+    }
+    finally {
+        timeEnd(FLOOD_FILL_RUN_TIMING_LABEL);
+    }
+}
+export { runFloodFillSegmentation as default, runFloodFillSegmentation, getPositiveIntensityRange, getPositiveIntensityRangeRaw, getPositiveIntensityRangeVoiMapped, getDisplayVoiSnapshot, };

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

@@ -14,8 +14,8 @@ export default class IslandRemoval {
     previewVoxelManager: Types.VoxelManager<number>;
     previewSegmentIndex: number;
     selectedPoints: Types.Point3[];
-    private fillInternalEdge;
-    private maxInternalRemove;
+    protected fillInternalEdge: boolean;
+    protected maxInternalRemove: number;
     constructor(options?: {
         maxInternalRemove?: number;
         fillInternalEdge?: boolean;
@@ -24,5 +24,6 @@ export default class IslandRemoval {
     floodFillSegmentIsland(): number;
     removeExternalIslands(): void;
     removeInternalIslands(): number[];
+    protected onInternalPointFilled(_point: Types.Point3): void;
     static covers(rle: any, row: any): boolean;
 }

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

@@ -158,10 +158,13 @@ export default class IslandRemoval {
             for (let iPrime = rle.start; iPrime < rle.end; iPrime++) {
                 const clearPoint = toIJK(segmentSet.toIJK(baseIndex + iPrime));
                 previewVoxelManager.setAtIJKPoint(clearPoint, previewSegmentIndex);
+                this.onInternalPointFilled(clearPoint);
             }
         });
         return previewVoxelManager.getArrayOfModifiedSlices();
     }
+    onInternalPointFilled(_point) {
+    }
     static covers(rle, row) {
         if (!row) {
             return false;

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.4.11";
+export declare const version = "5.4.13";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '5.4.11';
+export const version = '5.4.13';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "5.4.11",
+  "version": "5.4.13",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -113,7 +113,7 @@
     "build": "pnpm run build:esm",
     "clean": "rm -rf node_modules/.cache/storybook && shx rm -rf dist",
     "clean:deep": "pnpm run clean && shx rm -rf node_modules",
-    "dev": "tsc --project ./tsconfig.json --watch",
+    "dev": "tsc --project ./tsconfig.json --watch --sourceMap --inlineSources",
     "lint": "oxlint .",
     "api-check": "api-extractor --debug run ",
     "prepublishOnly": "pnpm run build",
@@ -126,11 +126,11 @@
     "lodash.get": "4.4.2"
   },
   "devDependencies": {
-    "@cornerstonejs/core": "5.4.11",
+    "@cornerstonejs/core": "5.4.13",
     "canvas": "3.2.0"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "5.4.11",
+    "@cornerstonejs/core": "5.4.13",
     "@kitware/vtk.js": "35.5.3",
     "@types/d3-array": "3.2.1",
     "@types/d3-interpolate": "3.0.4",
@@ -149,5 +149,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "b6139a8e5a81a2f5a1bf5e1d1e238605d85c6d65"
+  "gitHead": "9f0b0f4813368e68bc0c04f02132e06f15b6a0f8"
 }