@cornerstonejs/tools 3.8.0 → 3.8.2

package/dist/esm/store/addTool.js

@@ -1,13 +1,14 @@
 import { state } from './state';
 export function addTool(ToolClass) {
     const toolName = ToolClass.toolName;
-    const toolAlreadyAdded = state.tools[toolName] !== undefined;
     if (!toolName) {
         throw new Error(`No Tool Found for the ToolClass ${ToolClass.name}`);
     }
-    state.tools[toolName] = {
-        toolClass: ToolClass,
-    };
+    if (!state.tools[toolName]) {
+        state.tools[toolName] = {
+            toolClass: ToolClass,
+        };
+    }
 }
 export function hasTool(ToolClass) {
     const toolName = ToolClass.toolName;

package/dist/esm/tools/annotation/RegionSegmentPlusTool.d.ts

@@ -8,7 +8,11 @@ type RegionSegmentPlusToolData = GrowCutToolData & {
 declare class RegionSegmentPlusTool extends GrowCutBaseTool {
     static toolName: string;
     protected growCutData: RegionSegmentPlusToolData | null;
+    private mouseTimer;
+    private allowedToProceed;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    mouseMoveCallback(evt: EventTypes.MouseMoveEventType): void;
+    onMouseStable(evt: EventTypes.MouseMoveEventType, worldPoint: Types.Point3, element: HTMLDivElement): Promise<void>;
     preMouseDownCallback(evt: EventTypes.MouseDownActivateEventType): Promise<boolean>;
     protected getRemoveIslandData(growCutData: RegionSegmentPlusToolData): RemoveIslandData;
     protected getGrowCutLabelmap(growCutData: any): Promise<Types.IImageVolume>;

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

@@ -1,6 +1,7 @@
-import { getRenderingEngine, utilities as csUtils } from '@cornerstonejs/core';
+import { cache, utilities as csUtils, getEnabledElement, } from '@cornerstonejs/core';
 import { growCut } from '../../utilities/segmentation';
 import GrowCutBaseTool from '../base/GrowCutBaseTool';
+import { calculateGrowCutSeeds } from '../../utilities/segmentation/growCut/runOneClickGrowCut';
 class RegionSegmentPlusTool extends GrowCutBaseTool {
     static { this.toolName = 'RegionSegmentPlus'; }
     constructor(toolProps = {}, defaultToolProps = {
@@ -16,10 +17,68 @@ class RegionSegmentPlusTool extends GrowCutBaseTool {
         },
     }) {
         super(toolProps, defaultToolProps);
+        this.mouseTimer = null;
+        this.allowedToProceed = false;
+    }
+    mouseMoveCallback(evt) {
+        const eventData = evt.detail;
+        const { currentPoints, element } = eventData;
+        const { world: worldPoint } = currentPoints;
+        element.style.cursor = 'default';
+        if (this.mouseTimer !== null) {
+            window.clearTimeout(this.mouseTimer);
+            this.mouseTimer = null;
+        }
+        this.mouseTimer = window.setTimeout(() => {
+            this.onMouseStable(evt, worldPoint, element);
+        }, this.configuration.mouseStabilityDelay || 500);
+    }
+    async onMouseStable(evt, worldPoint, element) {
+        await super.preMouseDownCallback(evt);
+        const refVolume = cache.getVolume(this.growCutData.segmentation.referencedVolumeId);
+        const seeds = calculateGrowCutSeeds(refVolume, worldPoint, {});
+        const { positiveSeedIndices, negativeSeedIndices } = seeds;
+        let cursor;
+        if (positiveSeedIndices.size / negativeSeedIndices.size > 20 ||
+            negativeSeedIndices.size < 30) {
+            cursor = 'not-allowed';
+            this.allowedToProceed = false;
+        }
+        else {
+            cursor = 'copy';
+            this.allowedToProceed = true;
+        }
+        const enabledElement = getEnabledElement(element);
+        if (element) {
+            element.style.cursor = cursor;
+            requestAnimationFrame(() => {
+                if (element.style.cursor !== cursor) {
+                    element.style.cursor = cursor;
+                }
+            });
+        }
+        if (this.allowedToProceed) {
+            this.seeds = seeds;
+        }
+        if (enabledElement && enabledElement.viewport) {
+            enabledElement.viewport.render();
+        }
     }
     async preMouseDownCallback(evt) {
+        if (!this.allowedToProceed) {
+            return false;
+        }
         const eventData = evt.detail;
-        const { currentPoints } = eventData;
+        const { currentPoints, element } = eventData;
+        const enabledElement = getEnabledElement(element);
+        if (enabledElement) {
+            element.style.cursor = 'wait';
+            requestAnimationFrame(() => {
+                if (element.style.cursor !== 'wait') {
+                    element.style.cursor = 'wait';
+                }
+            });
+        }
         const { world: worldPoint } = currentPoints;
         await super.preMouseDownCallback(evt);
         this.growCutData = csUtils.deepMerge(this.growCutData, {
@@ -32,7 +91,10 @@ class RegionSegmentPlusTool extends GrowCutBaseTool {
         this.growCutData.islandRemoval = {
             worldIslandPoints: [worldPoint],
         };
-        this.runGrowCut();
+        await this.runGrowCut();
+        if (element) {
+            element.style.cursor = 'default';
+        }
         return true;
     }
     getRemoveIslandData(growCutData) {
@@ -42,13 +104,12 @@ class RegionSegmentPlusTool extends GrowCutBaseTool {
         };
     }
     async getGrowCutLabelmap(growCutData) {
-        const { segmentation: { referencedVolumeId, labelmapVolumeId }, renderingEngineId, viewportId, worldPoint, options, } = growCutData;
-        const renderingEngine = getRenderingEngine(renderingEngineId);
-        const viewport = renderingEngine.getViewport(viewportId);
+        const { segmentation: { referencedVolumeId }, worldPoint, options, } = growCutData;
         const { subVolumePaddingPercentage } = this.configuration;
         const mergedOptions = {
             ...options,
             subVolumePaddingPercentage,
+            seeds: this.seeds,
         };
         return growCut.runOneClickGrowCut({
             referencedVolumeId,

package/dist/esm/tools/base/GrowCutBaseTool.d.ts

@@ -1,6 +1,7 @@
 import { type Types } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import type { EventTypes, PublicToolProps, ToolProps } from '../../types';
+import type { GrowCutOneClickOptions } from '../../utilities/segmentation/growCut/runOneClickGrowCut';
 type GrowCutToolData = {
     metadata: Types.ViewReference & {
         viewUp?: Types.Point3;
@@ -16,6 +17,7 @@ type GrowCutToolData = {
     };
     viewportId: string;
     renderingEngineId: string;
+    options?: Partial<GrowCutOneClickOptions>;
 };
 type RemoveIslandData = {
     worldIslandPoints?: Types.Point3[];
@@ -26,6 +28,10 @@ declare class GrowCutBaseTool extends BaseTool {
     static toolName: any;
     protected growCutData: GrowCutToolData | null;
     private static lastGrowCutCommand;
+    protected seeds: {
+        positiveSeedIndices: Set<number>;
+        negativeSeedIndices: Set<number>;
+    } | null;
     constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps);
     preMouseDownCallback(evt: EventTypes.MouseDownActivateEventType): Promise<boolean>;
     shrink(): void;

package/dist/esm/tools/base/GrowCutBaseTool.js

@@ -3,6 +3,7 @@ import { BaseTool } from '../base';
 import { SegmentationRepresentations } from '../../enums';
 import { segmentIndex as segmentIndexController, state as segmentationState, activeSegmentation, } from '../../stateManagement/segmentation';
 import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
+import { DEFAULT_POSITIVE_STD_DEV_MULTIPLIER, DEFAULT_NEGATIVE_SEED_MARGIN, } from '../../utilities/segmentation/growCut/constants';
 import { getSVGStyleForSegment } from '../../utilities/segmentation/getSVGStyleForSegment';
 import IslandRemoval from '../../utilities/segmentation/islandRemoval';
 import { getOrCreateSegmentationVolume } from '../../utilities/segmentation';
@@ -13,9 +14,8 @@ class GrowCutBaseTool extends BaseTool {
     constructor(toolProps, defaultToolProps) {
         const baseToolProps = csUtils.deepMerge({
             configuration: {
-                positiveSeedVariance: 0.1,
-                negativeSeedVariance: 0.9,
-                shrinkExpandIncrement: 0.05,
+                positiveStdDevMultiplier: DEFAULT_POSITIVE_STD_DEV_MULTIPLIER,
+                shrinkExpandIncrement: 0.1,
                 islandRemoval: {
                     enabled: false,
                 },
@@ -70,39 +70,38 @@ class GrowCutBaseTool extends BaseTool {
     async runGrowCut() {
         const { growCutData, configuration: config } = this;
         const { segmentation: { segmentationId, segmentIndex, labelmapVolumeId }, } = growCutData;
-        const hasSeedVarianceData = config.positiveSeedVariance !== undefined &&
-            config.negativeSeedVariance !== undefined;
         const labelmap = cache.getVolume(labelmapVolumeId);
-        let shrinkExpandValue = 0;
+        let shrinkExpandAccumulator = 0;
         const growCutCommand = async ({ shrinkExpandAmount = 0 } = {}) => {
-            const { positiveSeedVariance, negativeSeedVariance } = config;
-            let newPositiveSeedVariance = undefined;
-            let newNegativeSeedVariance = undefined;
-            shrinkExpandValue += shrinkExpandAmount;
-            if (hasSeedVarianceData) {
-                newPositiveSeedVariance = positiveSeedVariance + shrinkExpandValue;
-                newNegativeSeedVariance = negativeSeedVariance + shrinkExpandValue;
+            if (shrinkExpandAmount !== 0) {
+                this.seeds = null;
             }
-            const updatedGrowCutData = Object.assign({}, growCutData, {
+            shrinkExpandAccumulator += shrinkExpandAmount;
+            const newPositiveStdDevMultiplier = Math.max(0.1, config.positiveStdDevMultiplier + shrinkExpandAccumulator);
+            const negativeSeedMargin = shrinkExpandAmount < 0
+                ? Math.max(1, DEFAULT_NEGATIVE_SEED_MARGIN -
+                    Math.abs(shrinkExpandAccumulator) * 3)
+                : DEFAULT_NEGATIVE_SEED_MARGIN + shrinkExpandAccumulator * 3;
+            const updatedGrowCutData = {
+                ...growCutData,
                 options: {
+                    ...(growCutData.options || {}),
                     positiveSeedValue: segmentIndex,
                     negativeSeedValue: 255,
-                    positiveSeedVariance: newPositiveSeedVariance,
-                    negativeSeedVariance: newNegativeSeedVariance,
+                    positiveStdDevMultiplier: newPositiveStdDevMultiplier,
+                    negativeSeedMargin,
                 },
-            });
+            };
             const growcutLabelmap = await this.getGrowCutLabelmap(updatedGrowCutData);
             const { isPartialVolume } = config;
             const fn = isPartialVolume
                 ? this.applyPartialGrowCutLabelmap
                 : this.applyGrowCutLabelmap;
             fn(segmentationId, segmentIndex, labelmap, growcutLabelmap);
-            this._removeIslands(growCutData);
+            this._removeIslands(updatedGrowCutData);
         };
         await growCutCommand();
-        if (hasSeedVarianceData) {
-            GrowCutBaseTool.lastGrowCutCommand = growCutCommand;
-        }
+        GrowCutBaseTool.lastGrowCutCommand = growCutCommand;
         this.growCutData = null;
     }
     applyPartialGrowCutLabelmap(segmentationId, segmentIndex, targetLabelmap, sourceLabelmap) {

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

@@ -0,0 +1,8 @@
+export declare const POSITIVE_SEED_LABEL = 254;
+export declare const NEGATIVE_SEED_LABEL = 255;
+export declare const DEFAULT_NEIGHBORHOOD_RADIUS = 1;
+export declare const DEFAULT_POSITIVE_STD_DEV_MULTIPLIER = 1.8;
+export declare const DEFAULT_NEGATIVE_STD_DEV_MULTIPLIER = 3.2;
+export declare const DEFAULT_NEGATIVE_SEED_MARGIN = 30;
+export declare const DEFAULT_NEGATIVE_SEEDS_COUNT = 70;
+export declare const MAX_NEGATIVE_SEED_ATTEMPTS_MULTIPLIER = 50;

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

@@ -0,0 +1,8 @@
+export const POSITIVE_SEED_LABEL = 254;
+export const NEGATIVE_SEED_LABEL = 255;
+export const DEFAULT_NEIGHBORHOOD_RADIUS = 1;
+export const DEFAULT_POSITIVE_STD_DEV_MULTIPLIER = 1.8;
+export const DEFAULT_NEGATIVE_STD_DEV_MULTIPLIER = 3.2;
+export const DEFAULT_NEGATIVE_SEED_MARGIN = 30;
+export const DEFAULT_NEGATIVE_SEEDS_COUNT = 70;
+export const MAX_NEGATIVE_SEED_ATTEMPTS_MULTIPLIER = 50;

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

@@ -1,15 +1,26 @@
 import type { Types } from '@cornerstonejs/core';
 import type { GrowCutOptions } from './runGrowCut';
 type GrowCutOneClickOptions = GrowCutOptions & {
-    subVolumePaddingPercentage?: number | [number, number, number];
-    subVolumeMinPadding?: number | [number, number, number];
+    initialNeighborhoodRadius?: number;
+    positiveStdDevMultiplier?: number;
+    negativeStdDevMultiplier?: number;
     negativeSeedMargin?: number;
-    negativeSeedsCount?: number;
+    negativeSeedsTargetPatches?: number;
+    positiveSeedValue?: number;
+    negativeSeedValue?: number;
+    seeds?: {
+        positiveSeedIndices: Set<number>;
+        negativeSeedIndices: Set<number>;
+    };
 };
+declare function calculateGrowCutSeeds(referencedVolume: Types.IImageVolume, worldPosition: Types.Point3, options?: GrowCutOneClickOptions): {
+    positiveSeedIndices: Set<number>;
+    negativeSeedIndices: Set<number>;
+} | null;
 declare function runOneClickGrowCut({ referencedVolumeId, worldPosition, options, }: {
     referencedVolumeId: string;
     worldPosition: Types.Point3;
     options?: GrowCutOneClickOptions;
-}): Promise<Types.IImageVolume>;
-export { runOneClickGrowCut as default, runOneClickGrowCut };
+}): Promise<Types.IImageVolume | null>;
+export { runOneClickGrowCut as default, runOneClickGrowCut, calculateGrowCutSeeds, };
 export type { GrowCutOneClickOptions };

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

@@ -1,29 +1,37 @@
 import { utilities as csUtils, cache, volumeLoader } from '@cornerstonejs/core';
 import { run } from './runGrowCut';
-const { transformWorldToIndex, transformIndexToWorld } = csUtils;
-const POSITIVE_SEED_VALUE = 254;
-const NEGATIVE_SEED_VALUE = 255;
-const POSITIVE_SEED_VARIANCE = 0.1;
-const NEGATIVE_SEED_VARIANCE = 0.8;
-function _generateSeeds(referencedVolume, labelmap, worldPosition, options) {
-    const [width, height, numSlices] = referencedVolume.dimensions;
-    const subVolPixelData = referencedVolume.voxelManager.getCompleteScalarDataArray();
+import { POSITIVE_SEED_LABEL, NEGATIVE_SEED_LABEL, DEFAULT_NEIGHBORHOOD_RADIUS, DEFAULT_POSITIVE_STD_DEV_MULTIPLIER, DEFAULT_NEGATIVE_STD_DEV_MULTIPLIER, DEFAULT_NEGATIVE_SEED_MARGIN, DEFAULT_NEGATIVE_SEEDS_COUNT, MAX_NEGATIVE_SEED_ATTEMPTS_MULTIPLIER, } from './constants';
+const { transformWorldToIndex } = csUtils;
+const MAX_POSITIVE_SEEDS = 100000;
+function calculateGrowCutSeeds(referencedVolume, worldPosition, options) {
+    const { dimensions, imageData: refImageData } = referencedVolume;
+    const [width, height, numSlices] = dimensions;
+    const referenceVolumeVoxelManager = referencedVolume.voxelManager;
+    const scalarData = referenceVolumeVoxelManager.getCompleteScalarDataArray();
     const numPixelsPerSlice = width * height;
-    const ijkStartPosition = transformWorldToIndex(referencedVolume.imageData, worldPosition);
-    const startIndex = ijkStartPosition[2] * numPixelsPerSlice +
-        ijkStartPosition[1] * width +
-        ijkStartPosition[0];
-    const referencePixelValue = subVolPixelData[startIndex];
-    const positiveSeedVariance = options.positiveSeedVariance ?? POSITIVE_SEED_VARIANCE;
-    const positiveSeedVarianceValue = Math.abs(referencePixelValue * positiveSeedVariance);
-    const minPositivePixelValue = referencePixelValue - positiveSeedVarianceValue;
-    const maxPositivePixelValue = referencePixelValue + positiveSeedVarianceValue;
-    const negativeSeedVariance = options.negativeSeedVariance ?? NEGATIVE_SEED_VARIANCE;
-    const negativeSeedVarianceValue = Math.abs(referencePixelValue * negativeSeedVariance);
-    const minNegativePixelValue = referencePixelValue - negativeSeedVarianceValue;
-    const maxNegativePixelValue = referencePixelValue + negativeSeedVarianceValue;
-    const positiveSeedValue = options.positiveSeedValue ?? POSITIVE_SEED_VALUE;
-    const negativeSeedValue = options.negativeSeedValue ?? NEGATIVE_SEED_VALUE;
+    const neighborhoodRadius = options?.initialNeighborhoodRadius ?? DEFAULT_NEIGHBORHOOD_RADIUS;
+    const positiveK = options?.positiveStdDevMultiplier ?? DEFAULT_POSITIVE_STD_DEV_MULTIPLIER;
+    const negativeK = options?.negativeStdDevMultiplier ?? DEFAULT_NEGATIVE_STD_DEV_MULTIPLIER;
+    const negativeSeedMargin = options?.negativeSeedMargin ?? DEFAULT_NEGATIVE_SEED_MARGIN;
+    const negativeSeedsTargetPatches = options?.negativeSeedsTargetPatches ?? DEFAULT_NEGATIVE_SEEDS_COUNT;
+    const ijkStart = transformWorldToIndex(refImageData, worldPosition).map(Math.round);
+    const startIndex = referenceVolumeVoxelManager.toIndex(ijkStart);
+    if (ijkStart[0] < 0 ||
+        ijkStart[0] >= width ||
+        ijkStart[1] < 0 ||
+        ijkStart[1] >= height ||
+        ijkStart[2] < 0 ||
+        ijkStart[2] >= numSlices) {
+        console.warn('Click position is outside volume bounds.');
+        return null;
+    }
+    const initialStats = csUtils.calculateNeighborhoodStats(scalarData, dimensions, ijkStart, neighborhoodRadius);
+    if (initialStats.count === 0) {
+        initialStats.mean = scalarData[startIndex];
+        initialStats.stdDev = 0;
+    }
+    const positiveIntensityMin = initialStats.mean - positiveK * initialStats.stdDev;
+    const positiveIntensityMax = initialStats.mean + positiveK * initialStats.stdDev;
     const neighborsCoordDelta = [
         [-1, 0, 0],
         [1, 0, 0],
@@ -32,18 +40,33 @@ function _generateSeeds(referencedVolume, labelmap, worldPosition, options) {
         [0, 0, -1],
         [0, 0, 1],
     ];
-    let minX = Infinity, minY = Infinity, minZ = Infinity, maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
-    const voxelIndexesSet = new Set([startIndex]);
-    labelmap.voxelManager.setAtIndex(startIndex, positiveSeedValue);
-    const queue = [ijkStartPosition];
-    while (queue.length) {
-        const [x, y, z] = queue.shift();
-        minX = x < minX ? x : minX;
-        minY = y < minY ? y : minY;
-        minZ = z < minZ ? z : minZ;
-        maxX = x > maxX ? x : maxX;
-        maxY = y > maxY ? y : maxY;
-        maxZ = z > maxZ ? z : maxZ;
+    let minX = Infinity, minY = Infinity, minZ = Infinity;
+    let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+    const positiveSeedIndices = new Set();
+    const queue = [];
+    const startValue = scalarData[startIndex];
+    if (startValue >= positiveIntensityMin &&
+        startValue <= positiveIntensityMax) {
+        positiveSeedIndices.add(startIndex);
+        queue.push(ijkStart);
+        minX = maxX = ijkStart[0];
+        minY = maxY = ijkStart[1];
+        minZ = maxZ = ijkStart[2];
+    }
+    else {
+        console.warn('Clicked voxel intensity is outside the calculated positive range. No positive seeds generated.');
+        return { positiveSeedIndices: new Set(), negativeSeedIndices: new Set() };
+    }
+    let currentQueueIndex = 0;
+    while (currentQueueIndex < queue.length &&
+        positiveSeedIndices.size < MAX_POSITIVE_SEEDS) {
+        const [x, y, z] = queue[currentQueueIndex++];
+        minX = Math.min(x, minX);
+        minY = Math.min(y, minY);
+        minZ = Math.min(z, minZ);
+        maxX = Math.max(x, maxX);
+        maxY = Math.max(y, maxY);
+        maxZ = Math.max(z, maxZ);
         for (let i = 0; i < neighborsCoordDelta.length; i++) {
             const [dx, dy, dz] = neighborsCoordDelta[i];
             const nx = x + dx;
@@ -57,52 +80,122 @@ function _generateSeeds(referencedVolume, labelmap, worldPosition, options) {
                 nz >= numSlices) {
                 continue;
             }
-            const neighborVoxelIndex = nz * numPixelsPerSlice + ny * width + nx;
-            if (voxelIndexesSet.has(neighborVoxelIndex)) {
+            const neighborIndex = nz * numPixelsPerSlice + ny * width + nx;
+            if (positiveSeedIndices.has(neighborIndex)) {
                 continue;
             }
-            const neighborPixelValue = subVolPixelData[neighborVoxelIndex];
-            if (neighborPixelValue >= minPositivePixelValue &&
-                neighborPixelValue <= maxPositivePixelValue) {
-                labelmap.voxelManager.setAtIndex(neighborVoxelIndex, positiveSeedValue);
-                voxelIndexesSet.add(neighborVoxelIndex);
-                queue.push([nx, ny, nz]);
+            const neighborValue = scalarData[neighborIndex];
+            if (neighborValue >= positiveIntensityMin &&
+                neighborValue <= positiveIntensityMax) {
+                positiveSeedIndices.add(neighborIndex);
+                if (positiveSeedIndices.size < MAX_POSITIVE_SEEDS) {
+                    queue.push([nx, ny, nz]);
+                }
             }
         }
     }
-    const margin = options.negativeSeedMargin ?? 30;
-    const minXwMargin = Math.max(0, minX - margin);
-    const minYwMargin = Math.max(0, minY - margin);
-    const minZwMargin = Math.max(0, minZ - margin);
-    const maxXwMargin = Math.min(width - 1, maxX + margin);
-    const maxYwMargin = Math.min(height - 1, maxY + margin);
-    const maxZwMargin = Math.min(numSlices - 1, maxZ + margin);
-    const negativeSeedsCount = options.negativeSeedsCount ?? 70;
-    const negativeIndexesSet = new Set();
+    if (positiveSeedIndices.size >= MAX_POSITIVE_SEEDS) {
+        console.debug(`Reached maximum number of positive seeds (${MAX_POSITIVE_SEEDS}). Stopping BFS.`);
+    }
+    if (positiveSeedIndices.size === 0) {
+        console.warn('No positive seeds found after BFS.');
+        return { positiveSeedIndices: new Set(), negativeSeedIndices: new Set() };
+    }
+    let positiveSum = 0;
+    let positiveSumSq = 0;
+    positiveSeedIndices.forEach((index) => {
+        const value = scalarData[index];
+        positiveSum += value;
+        positiveSumSq += value * value;
+    });
+    const positiveCount = positiveSeedIndices.size;
+    const positiveMean = positiveSum / positiveCount;
+    const positiveVariance = positiveSumSq / positiveCount - positiveMean * positiveMean;
+    const positiveStdDev = Math.sqrt(Math.max(0, positiveVariance));
+    const negativeDiffThreshold = negativeK * positiveStdDev;
+    const minXm = Math.max(0, minX - negativeSeedMargin);
+    const minYm = Math.max(0, minY - negativeSeedMargin);
+    const minZm = Math.max(0, minZ - negativeSeedMargin);
+    const maxXm = Math.min(width - 1, maxX + negativeSeedMargin);
+    const maxYm = Math.min(height - 1, maxY + negativeSeedMargin);
+    const maxZm = Math.min(numSlices - 1, maxZ + negativeSeedMargin);
+    const negativeSeedIndices = new Set();
     let attempts = 0;
-    while (negativeIndexesSet.size < negativeSeedsCount &&
-        attempts < negativeSeedsCount * 50) {
+    let patchesAdded = 0;
+    const maxAttempts = negativeSeedsTargetPatches * MAX_NEGATIVE_SEED_ATTEMPTS_MULTIPLIER;
+    while (patchesAdded < negativeSeedsTargetPatches && attempts < maxAttempts) {
         attempts++;
-        const rx = Math.floor(Math.random() * (maxXwMargin - minXwMargin + 1) + minXwMargin);
-        const ry = Math.floor(Math.random() * (maxYwMargin - minYwMargin + 1) + minYwMargin);
-        const rz = Math.floor(Math.random() * (maxZwMargin - minZwMargin + 1) + minZwMargin);
-        const randomIndex = rz * numPixelsPerSlice + ry * width + rx;
-        if (voxelIndexesSet.has(randomIndex)) {
+        const rx = Math.floor(Math.random() * (maxXm - minXm + 1) + minXm);
+        const ry = Math.floor(Math.random() * (maxYm - minYm + 1) + minYm);
+        const rz = Math.floor(Math.random() * (maxZm - minZm + 1) + minZm);
+        const centerIndex = rz * numPixelsPerSlice + ry * width + rx;
+        if (positiveSeedIndices.has(centerIndex) ||
+            negativeSeedIndices.has(centerIndex)) {
             continue;
         }
-        const randomVal = subVolPixelData[randomIndex];
-        if (randomVal >= minNegativePixelValue &&
-            randomVal <= maxNegativePixelValue) {
-            labelmap.voxelManager.setAtIndex(randomIndex, negativeSeedValue);
-            negativeIndexesSet.add(randomIndex);
+        const centerValue = scalarData[centerIndex];
+        if (Math.abs(centerValue - positiveMean) > negativeDiffThreshold) {
+            let patchContributed = false;
+            for (let dy = -1; dy <= 1; dy++) {
+                const ny = ry + dy;
+                if (ny < 0 || ny >= height) {
+                    continue;
+                }
+                for (let dx = -1; dx <= 1; dx++) {
+                    const nx = rx + dx;
+                    if (nx < 0 || nx >= width) {
+                        continue;
+                    }
+                    const neighborIndex = rz * numPixelsPerSlice + ny * width + nx;
+                    if (positiveSeedIndices.has(neighborIndex) ||
+                        negativeSeedIndices.has(neighborIndex)) {
+                        continue;
+                    }
+                    negativeSeedIndices.add(neighborIndex);
+                    patchContributed = true;
+                }
+            }
+            if (patchContributed) {
+                patchesAdded++;
+            }
         }
     }
+    if (negativeSeedIndices.size === 0) {
+        console.warn('Could not find any negative seeds. GrowCut might fail or produce poor results.');
+    }
+    console.debug('positiveSeedIndices', positiveSeedIndices.size);
+    console.debug('negativeSeedIndices', negativeSeedIndices.size);
+    return { positiveSeedIndices, negativeSeedIndices };
 }
 async function runOneClickGrowCut({ referencedVolumeId, worldPosition, options, }) {
     const referencedVolume = cache.getVolume(referencedVolumeId);
     const labelmap = volumeLoader.createAndCacheDerivedLabelmapVolume(referencedVolumeId);
-    _generateSeeds(referencedVolume, labelmap, worldPosition, options);
-    await run(referencedVolumeId, labelmap.volumeId);
+    labelmap.voxelManager.forEach(({ index, value }) => {
+        if (value !== 0) {
+            labelmap.voxelManager.setAtIndex(index, 0);
+        }
+    });
+    const seeds = options.seeds ??
+        calculateGrowCutSeeds(referencedVolume, worldPosition, options);
+    const positiveSeedLabel = options?.positiveSeedValue ?? POSITIVE_SEED_LABEL;
+    const negativeSeedLabel = options?.negativeSeedValue ?? NEGATIVE_SEED_LABEL;
+    if (!seeds) {
+        return null;
+    }
+    const { positiveSeedIndices, negativeSeedIndices } = seeds;
+    if (positiveSeedIndices.size < 10 ||
+        positiveSeedIndices.size > MAX_POSITIVE_SEEDS ||
+        negativeSeedIndices.size < 10) {
+        console.warn('Not enough seeds found. GrowCut might fail or produce poor results.');
+        return labelmap;
+    }
+    positiveSeedIndices.forEach((index) => {
+        labelmap.voxelManager.setAtIndex(index, positiveSeedLabel);
+    });
+    negativeSeedIndices.forEach((index) => {
+        labelmap.voxelManager.setAtIndex(index, negativeSeedLabel);
+    });
+    await run(referencedVolumeId, labelmap.volumeId, options);
     return labelmap;
 }
-export { runOneClickGrowCut as default, runOneClickGrowCut };
+export { runOneClickGrowCut as default, runOneClickGrowCut, calculateGrowCutSeeds, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "3.8.0",
+  "version": "3.8.2",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -103,7 +103,7 @@
     "canvas": "^3.1.0"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^3.8.0",
+    "@cornerstonejs/core": "^3.8.2",
     "@kitware/vtk.js": "32.12.1",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
@@ -122,5 +122,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "bc351a2bae5a5b2f93691a384222b71b26d5c263"
+  "gitHead": "d14852bdc9402b62ca685c559663438c19079e07"
 }