@cornerstonejs/tools 5.4.11 → 5.4.13

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

@@ -0,0 +1,167 @@
+export const FLOOD_SLICE_FLAG_VISITED = 1;
+export async function floodFill3dSliceLazy(getter, seed, options) {
+    const { width: w, height: h, depth: d, equals, ensureSliceLoaded, yieldEvery = 500, planar = false, maxDeltaK, maxDeltaIJ, isCancelled, maxVoxels, shouldContinue, validateEvery = 2048, } = options;
+    const [sx, sy, sz] = seed;
+    if (sx < 0 || sx >= w || sy < 0 || sy >= h || sz < 0 || sz >= d) {
+        return {
+            sliceMasks: new Map(),
+            voxelCount: 0,
+            truncated: false,
+            bbox: null,
+        };
+    }
+    if (ensureSliceLoaded) {
+        await ensureSliceLoaded(sz);
+    }
+    const startNode = getter(sx, sy, sz);
+    if (!equals(startNode, startNode)) {
+        return {
+            sliceMasks: new Map(),
+            voxelCount: 0,
+            truncated: false,
+            bbox: null,
+        };
+    }
+    const frameSize = w * h;
+    const sliceMasks = new Map();
+    function sliceFlags(z) {
+        let a = sliceMasks.get(z);
+        if (!a) {
+            a = new Uint8Array(frameSize);
+            sliceMasks.set(z, a);
+        }
+        return a;
+    }
+    function isVisited(z, x, y) {
+        const a = sliceMasks.get(z);
+        if (!a) {
+            return false;
+        }
+        return (a[y * w + x] & FLOOD_SLICE_FLAG_VISITED) !== 0;
+    }
+    function setVisited(z, x, y) {
+        sliceFlags(z)[y * w + x] |= FLOOD_SLICE_FLAG_VISITED;
+    }
+    function pack(x, y, z) {
+        return z * frameSize + y * w + x;
+    }
+    function unpack(p) {
+        const x = p % w;
+        const t1 = Math.floor(p / w);
+        const y = t1 % h;
+        const z = Math.floor(t1 / h);
+        return [x, y, z];
+    }
+    const dirs = planar
+        ? [
+            [1, 0, 0],
+            [-1, 0, 0],
+            [0, 1, 0],
+            [0, -1, 0],
+        ]
+        : [
+            [1, 0, 0],
+            [-1, 0, 0],
+            [0, 1, 0],
+            [0, -1, 0],
+            [0, 0, 1],
+            [0, 0, -1],
+        ];
+    const queue = [];
+    let qh = 0;
+    queue.push(pack(sx, sy, sz));
+    setVisited(sz, sx, sy);
+    let minX = sx;
+    let maxX = sx;
+    let minY = sy;
+    let maxY = sy;
+    let minZ = sz;
+    let maxZ = sz;
+    const currentBBox = () => ({
+        min: [minX, minY, minZ],
+        max: [maxX, maxY, maxZ],
+    });
+    let steps = 0;
+    let truncated = false;
+    let nextValidateAt = validateEvery;
+    while (qh < queue.length) {
+        if (isCancelled?.()) {
+            break;
+        }
+        if (maxVoxels !== undefined && queue.length > maxVoxels) {
+            truncated = true;
+            break;
+        }
+        if (shouldContinue && queue.length >= nextValidateAt) {
+            nextValidateAt += validateEvery;
+            if (!shouldContinue({ voxelCount: queue.length, bbox: currentBBox() })) {
+                truncated = true;
+                break;
+            }
+        }
+        steps++;
+        if (yieldEvery > 0 && steps % yieldEvery === 0) {
+            await new Promise((r) => setTimeout(r, 0));
+        }
+        const p = queue[qh++];
+        const [x, y, z] = unpack(p);
+        for (let di = 0; di < dirs.length; di++) {
+            const nx = x + dirs[di][0];
+            const ny = y + dirs[di][1];
+            const nz = z + dirs[di][2];
+            if (nx < 0 || nx >= w || ny < 0 || ny >= h || nz < 0 || nz >= d) {
+                continue;
+            }
+            if (maxDeltaK >= 0 && Math.abs(nz - sz) > maxDeltaK) {
+                continue;
+            }
+            if (maxDeltaIJ >= 0 &&
+                (Math.abs(nx - sx) > maxDeltaIJ || Math.abs(ny - sy) > maxDeltaIJ)) {
+                continue;
+            }
+            if (planar && nz !== sz) {
+                continue;
+            }
+            if (isVisited(nz, nx, ny)) {
+                continue;
+            }
+            if (ensureSliceLoaded) {
+                await ensureSliceLoaded(nz);
+                if (isCancelled?.()) {
+                    break;
+                }
+            }
+            const nv = getter(nx, ny, nz);
+            if (!equals(nv, startNode)) {
+                continue;
+            }
+            setVisited(nz, nx, ny);
+            queue.push(pack(nx, ny, nz));
+            if (nx < minX) {
+                minX = nx;
+            }
+            else if (nx > maxX) {
+                maxX = nx;
+            }
+            if (ny < minY) {
+                minY = ny;
+            }
+            else if (ny > maxY) {
+                maxY = ny;
+            }
+            if (nz < minZ) {
+                minZ = nz;
+            }
+            else if (nz > maxZ) {
+                maxZ = nz;
+            }
+        }
+    }
+    const voxelCount = queue.length;
+    return {
+        sliceMasks,
+        voxelCount,
+        truncated,
+        bbox: voxelCount > 0 ? currentBBox() : null,
+    };
+}

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

@@ -0,0 +1,51 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ViewportVoiMappingForTool } from './getViewportVoiMappingForVolume.js';
+export type FloodFillIntensityRangeDiagnostics = {
+    neighborhoodMean: number;
+    neighborhoodStdDev: number;
+    clickedVoxelValue: number;
+    positiveStdDevMultiplier: number;
+    neighborhoodRadius: number;
+    strategy?: string;
+    strategyMode?: 'triClass' | 'exactRange';
+    mappedBand?: {
+        min: number;
+        max: number;
+    };
+    canvasSampleCount?: number;
+    canvasDiskBandCenteredOnSeed?: boolean;
+    canvasDiskLetterboxTrimmed?: boolean;
+    adaptive?: {
+        toleranceBytes: number;
+        regionSizePx: number;
+        regionAreaMm2?: number;
+        backgroundByte: number;
+        seedByte: number;
+        polarity?: number;
+        seedSnapped: boolean;
+        windowSize: [number, number];
+        growthCurve?: Array<[number, number]>;
+        explosionLevel?: number;
+        borderTouchLevel?: number;
+    };
+};
+export type FloodFillIntensityRangeResult = {
+    min: number;
+    max: number;
+    ijkStart: Types.Point3;
+    diagnostics: FloodFillIntensityRangeDiagnostics;
+};
+export type FloodFillIntensityRangeOptions = {
+    positiveStdDevMultiplier?: number;
+    initialNeighborhoodRadius?: number;
+    voiMapping?: ViewportVoiMappingForTool | null;
+    viewport?: Types.IViewport;
+    element?: HTMLDivElement;
+    referencedVolumeId?: string;
+    canvasPoint?: {
+        x: number;
+        y: number;
+    };
+    canvasDiskRadiusPx?: number;
+};
+export type GetFloodFillIntensityRange = (referencedVolume: Types.IImageVolume, worldPosition: Types.Point3, options?: FloodFillIntensityRangeOptions) => FloodFillIntensityRangeResult | null;

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

@@ -0,0 +1,10 @@
+import type { Types } from '@cornerstonejs/core';
+export type ViewportVoiMappingForTool = {
+    voiRange: {
+        lower: number;
+        upper: number;
+    };
+    VOILUTFunction?: string;
+    invert?: boolean;
+};
+export declare function getViewportVoiMappingForVolume(viewport: Types.IViewport, volumeId?: string): ViewportVoiMappingForTool | null;

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

@@ -0,0 +1,21 @@
+export function getViewportVoiMappingForVolume(viewport, volumeId) {
+    const getProps = viewport.getProperties;
+    if (typeof getProps !== 'function') {
+        return null;
+    }
+    const props = volumeId
+        ? getProps.call(viewport, volumeId)
+        : getProps.call(viewport);
+    if (!props?.voiRange) {
+        return null;
+    }
+    const { lower, upper } = props.voiRange;
+    if (typeof lower !== 'number' || typeof upper !== 'number') {
+        return null;
+    }
+    return {
+        voiRange: { lower, upper },
+        VOILUTFunction: props.VOILUTFunction,
+        invert: props.invert === true,
+    };
+}

package/dist/esm/utilities/segmentation/growCut/intensityRange/adaptiveRegionIntensityRange.d.ts

@@ -0,0 +1,57 @@
+import type { Types } from '@cornerstonejs/core';
+import type { FloodFillIntensityRangeOptions, FloodFillIntensityRangeResult } from '../floodFillIntensityRangeTypes.js';
+import type { GetFloodFillIntensityRange } from '../floodFillIntensityRangeTypes.js';
+import type { ViewportVoiMappingForTool } from '../getViewportVoiMappingForVolume.js';
+export type AdaptiveRegionProbeReason = 'ok' | 'outside-volume' | 'flat-region' | 'too-small' | 'unbounded' | 'off-target';
+export type AdaptiveRegionExpandContext = {
+    seedByte: number;
+    polarity: 1 | -1;
+    voiMapping: ViewportVoiMappingForTool | null;
+    rawWindow: {
+        min: number;
+        span: number;
+    };
+    seedIjk: Types.Point3;
+    seedScalar: number;
+    growthCurve: Array<[number, number]>;
+    chosenToleranceBytes: number;
+    growthEndLevel: number;
+    pxAreaMm2: number;
+};
+export type AdaptiveRegionProbeResult = {
+    viable: boolean;
+    reason: AdaptiveRegionProbeReason;
+    range: FloodFillIntensityRangeResult | null;
+    regionSizePx?: number;
+    regionAreaMm2?: number;
+    toleranceBytes?: number;
+    clickNeighborJoinLevels?: Array<number | null>;
+    expandContext?: AdaptiveRegionExpandContext;
+    debug?: {
+        growthCurve: Array<[number, number]>;
+        quietRuns: Array<[number, number, number]>;
+        seedByte: number;
+        backgroundByte: number;
+        polarity: number;
+        borderTouchLevel: number;
+        explosionLevel: number;
+        clickJoinLevel: number;
+        minRegionPx: number;
+        maxRegionPx: number;
+        pxAreaMm2: number;
+    };
+};
+export type AdaptiveRegionCoreInput = {
+    dimensions: Types.Point3;
+    getScalar: (i: number, j: number, k: number) => number;
+    ijkClick: Types.Point3;
+    inPlaneAxes?: [number, number];
+    inPlaneSpacing?: [number, number];
+    voiMapping?: ViewportVoiMappingForTool | null;
+    toleranceScale?: number;
+};
+export declare function resolveAdaptiveBandAtTolerance(context: AdaptiveRegionExpandContext, toleranceBytes: number): FloodFillIntensityRangeResult;
+export declare function probeAdaptiveRegionCore(input: AdaptiveRegionCoreInput): AdaptiveRegionProbeResult;
+export declare function resolveInPlaneAxes(referencedVolume: Types.IImageVolume, viewport: Types.IViewport | undefined): [number, number];
+export declare function probeAdaptiveRegion(referencedVolume: Types.IImageVolume, worldPosition: Types.Point3, options?: FloodFillIntensityRangeOptions): AdaptiveRegionProbeResult;
+export declare const getAdaptiveRegionIntensityRange: GetFloodFillIntensityRange;