@cornerstonejs/tools 2.6.5 → 2.7.0

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

@@ -0,0 +1,269 @@
+import { cache } from '@cornerstonejs/core';
+import shaderCode from './growCutShader';
+const GB = 1024 * 1024 * 1024;
+const WEBGPU_MEMORY_LIMIT = 2 * GB;
+const DEFAULT_GROWCUT_OPTIONS = {
+    windowSize: 3,
+    maxProcessingTime: 30000,
+    inspection: {
+        numCyclesInterval: 5,
+        numCyclesBelowThreshold: 3,
+        threshold: 1e-4,
+    },
+};
+async function runGrowCut(referenceVolumeId, labelmapVolumeId, options = DEFAULT_GROWCUT_OPTIONS) {
+    const workGroupSize = [8, 8, 4];
+    const { windowSize, maxProcessingTime } = Object.assign({}, DEFAULT_GROWCUT_OPTIONS, options);
+    const inspection = Object.assign({}, DEFAULT_GROWCUT_OPTIONS.inspection, options.inspection);
+    const volume = cache.getVolume(referenceVolumeId);
+    const labelmap = cache.getVolume(labelmapVolumeId);
+    const [columns, rows, numSlices] = volume.dimensions;
+    if (labelmap.dimensions[0] !== columns ||
+        labelmap.dimensions[1] !== rows ||
+        labelmap.dimensions[2] !== numSlices) {
+        throw new Error('Volume and labelmap must have the same size');
+    }
+    const numIterations = Math.floor(Math.sqrt(rows ** 2 + columns ** 2 + numSlices ** 2) / 2);
+    const labelmapData = labelmap.voxelManager.getCompleteScalarDataArray();
+    let volumePixelData = volume.voxelManager.getCompleteScalarDataArray();
+    if (!(volumePixelData instanceof Float32Array)) {
+        volumePixelData = new Float32Array(volumePixelData);
+    }
+    const requiredLimits = {
+        maxStorageBufferBindingSize: WEBGPU_MEMORY_LIMIT,
+        maxBufferSize: WEBGPU_MEMORY_LIMIT,
+    };
+    const adapter = await navigator.gpu.requestAdapter();
+    const device = await adapter.requestDevice({ requiredLimits });
+    const BUFFER_SIZE = volumePixelData.byteLength;
+    const UPDATED_VOXELS_COUNTER_BUFFER_SIZE = numIterations * Uint32Array.BYTES_PER_ELEMENT;
+    const shaderModule = device.createShaderModule({
+        code: shaderCode,
+    });
+    const numIterationIndex = 3;
+    const paramsArrayValues = new Uint32Array([
+        columns,
+        rows,
+        numSlices,
+        0,
+    ]);
+    const gpuParamsBuffer = device.createBuffer({
+        size: paramsArrayValues.byteLength,
+        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+    });
+    const gpuVolumePixelDataBuffer = device.createBuffer({
+        size: BUFFER_SIZE,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+    });
+    device.queue.writeBuffer(gpuVolumePixelDataBuffer, 0, volumePixelData);
+    const gpuLabelmapBuffers = [0, 1].map(() => device.createBuffer({
+        size: BUFFER_SIZE,
+        usage: GPUBufferUsage.STORAGE |
+            GPUBufferUsage.COPY_SRC |
+            GPUBufferUsage.COPY_DST,
+    }));
+    device.queue.writeBuffer(gpuLabelmapBuffers[0], 0, new Uint32Array(labelmapData));
+    const gpuStrengthBuffers = [0, 1].map(() => {
+        const strengthBuffer = device.createBuffer({
+            size: BUFFER_SIZE,
+            usage: GPUBufferUsage.STORAGE |
+                GPUBufferUsage.COPY_SRC |
+                GPUBufferUsage.COPY_DST,
+        });
+        return strengthBuffer;
+    });
+    const gpuCounterBuffer = device.createBuffer({
+        size: UPDATED_VOXELS_COUNTER_BUFFER_SIZE,
+        usage: GPUBufferUsage.STORAGE |
+            GPUBufferUsage.COPY_SRC |
+            GPUBufferUsage.COPY_DST,
+    });
+    const bindGroupLayout = device.createBindGroupLayout({
+        entries: [
+            {
+                binding: 0,
+                visibility: GPUShaderStage.COMPUTE,
+                buffer: {
+                    type: 'uniform',
+                },
+            },
+            {
+                binding: 1,
+                visibility: GPUShaderStage.COMPUTE,
+                buffer: {
+                    type: 'read-only-storage',
+                },
+            },
+            {
+                binding: 2,
+                visibility: GPUShaderStage.COMPUTE,
+                buffer: {
+                    type: 'storage',
+                },
+            },
+            {
+                binding: 3,
+                visibility: GPUShaderStage.COMPUTE,
+                buffer: {
+                    type: 'storage',
+                },
+            },
+            {
+                binding: 4,
+                visibility: GPUShaderStage.COMPUTE,
+                buffer: {
+                    type: 'read-only-storage',
+                },
+            },
+            {
+                binding: 5,
+                visibility: GPUShaderStage.COMPUTE,
+                buffer: {
+                    type: 'read-only-storage',
+                },
+            },
+            {
+                binding: 6,
+                visibility: GPUShaderStage.COMPUTE,
+                buffer: {
+                    type: 'storage',
+                },
+            },
+        ],
+    });
+    const bindGroups = [0, 1].map((i) => {
+        const outputLabelmapBuffer = gpuLabelmapBuffers[i];
+        const outputStrengthBuffer = gpuStrengthBuffers[i];
+        const previouLabelmapBuffer = gpuLabelmapBuffers[(i + 1) % 2];
+        const previousStrengthBuffer = gpuStrengthBuffers[(i + 1) % 2];
+        return device.createBindGroup({
+            layout: bindGroupLayout,
+            entries: [
+                {
+                    binding: 0,
+                    resource: {
+                        buffer: gpuParamsBuffer,
+                    },
+                },
+                {
+                    binding: 1,
+                    resource: {
+                        buffer: gpuVolumePixelDataBuffer,
+                    },
+                },
+                {
+                    binding: 2,
+                    resource: {
+                        buffer: outputLabelmapBuffer,
+                    },
+                },
+                {
+                    binding: 3,
+                    resource: {
+                        buffer: outputStrengthBuffer,
+                    },
+                },
+                {
+                    binding: 4,
+                    resource: {
+                        buffer: previouLabelmapBuffer,
+                    },
+                },
+                {
+                    binding: 5,
+                    resource: {
+                        buffer: previousStrengthBuffer,
+                    },
+                },
+                {
+                    binding: 6,
+                    resource: {
+                        buffer: gpuCounterBuffer,
+                    },
+                },
+            ],
+        });
+    });
+    const pipeline = device.createComputePipeline({
+        layout: device.createPipelineLayout({
+            bindGroupLayouts: [bindGroupLayout],
+        }),
+        compute: {
+            module: shaderModule,
+            entryPoint: 'main',
+            constants: {
+                workGroupSizeX: workGroupSize[0],
+                workGroupSizeY: workGroupSize[1],
+                workGroupSizeZ: workGroupSize[2],
+                windowSize,
+            },
+        },
+    });
+    const numWorkGroups = [
+        Math.ceil(columns / workGroupSize[0]),
+        Math.ceil(rows / workGroupSize[1]),
+        Math.ceil(numSlices / workGroupSize[2]),
+    ];
+    const gpuUpdatedVoxelsCounterStagingBuffer = device.createBuffer({
+        size: UPDATED_VOXELS_COUNTER_BUFFER_SIZE,
+        usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
+    });
+    const labelmapStagingBufferTemp = device.createBuffer({
+        size: BUFFER_SIZE,
+        usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
+    });
+    const limitProcessingTime = maxProcessingTime
+        ? performance.now() + maxProcessingTime
+        : 0;
+    let currentInspectionNumCyclesInterval = inspection.numCyclesInterval;
+    let belowThresholdCounter = 0;
+    for (let i = 0; i < numIterations; i++) {
+        paramsArrayValues[numIterationIndex] = i;
+        device.queue.writeBuffer(gpuParamsBuffer, 0, paramsArrayValues);
+        const commandEncoder = device.createCommandEncoder();
+        const passEncoder = commandEncoder.beginComputePass();
+        passEncoder.setPipeline(pipeline);
+        passEncoder.setBindGroup(0, bindGroups[i % 2]);
+        passEncoder.dispatchWorkgroups(numWorkGroups[0], numWorkGroups[1], numWorkGroups[2]);
+        passEncoder.end();
+        commandEncoder.copyBufferToBuffer(gpuCounterBuffer, i * Uint32Array.BYTES_PER_ELEMENT, gpuUpdatedVoxelsCounterStagingBuffer, i * Uint32Array.BYTES_PER_ELEMENT, Uint32Array.BYTES_PER_ELEMENT);
+        device.queue.submit([commandEncoder.finish()]);
+        const inspect = i > 0 && !(i % currentInspectionNumCyclesInterval);
+        if (inspect) {
+            await gpuUpdatedVoxelsCounterStagingBuffer.mapAsync(GPUMapMode.READ, 0, UPDATED_VOXELS_COUNTER_BUFFER_SIZE);
+            const updatedVoxelsCounterResultBuffer = gpuUpdatedVoxelsCounterStagingBuffer.getMappedRange(0, UPDATED_VOXELS_COUNTER_BUFFER_SIZE);
+            const updatedVoxelsCounterBufferData = new Uint32Array(updatedVoxelsCounterResultBuffer.slice(0));
+            const updatedVoxelsRatio = updatedVoxelsCounterBufferData[i] / volumePixelData.length;
+            gpuUpdatedVoxelsCounterStagingBuffer.unmap();
+            if (i >= 1 && updatedVoxelsRatio < inspection.threshold) {
+                currentInspectionNumCyclesInterval = 1;
+                belowThresholdCounter++;
+                if (belowThresholdCounter === inspection.numCyclesBelowThreshold) {
+                    break;
+                }
+            }
+            else {
+                currentInspectionNumCyclesInterval = inspection.numCyclesInterval;
+            }
+        }
+        if (limitProcessingTime && performance.now() > limitProcessingTime) {
+            console.warn(`Exceeded processing time limit (${maxProcessingTime})ms`);
+            break;
+        }
+    }
+    const commandEncoder = device.createCommandEncoder();
+    const outputLabelmapBufferIndex = (numIterations + 1) % 2;
+    const labelmapStagingBuffer = device.createBuffer({
+        size: BUFFER_SIZE,
+        usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
+    });
+    commandEncoder.copyBufferToBuffer(gpuLabelmapBuffers[outputLabelmapBufferIndex], 0, labelmapStagingBuffer, 0, BUFFER_SIZE);
+    device.queue.submit([commandEncoder.finish()]);
+    await labelmapStagingBuffer.mapAsync(GPUMapMode.READ, 0, BUFFER_SIZE);
+    const labelmapResultBuffer = labelmapStagingBuffer.getMappedRange(0, BUFFER_SIZE);
+    const labelmapResult = new Uint32Array(labelmapResultBuffer);
+    labelmapData.set(labelmapResult);
+    labelmapStagingBuffer.unmap();
+    labelmap.voxelManager.setCompleteScalarDataArray(labelmapData);
+}
+export { runGrowCut as default, runGrowCut as run };

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

@@ -0,0 +1,17 @@
+import type { Types } from '@cornerstonejs/core';
+import type { GrowCutOptions } from './runGrowCut';
+type BoundingBoxInfo = {
+    boundingBox: {
+        ijkTopLeft: Types.Point3;
+        ijkBottomRight: Types.Point3;
+    };
+};
+type GrowCutBoundingBoxOptions = GrowCutOptions & {
+    positiveSeedValue?: number;
+    negativeSeedValue?: number;
+    negativePixelRange: [number, number];
+    positivePixelRange: [number, number];
+};
+declare function runGrowCutForBoundingBox(referencedVolumeId: string, boundingBoxInfo: BoundingBoxInfo, options?: GrowCutBoundingBoxOptions): Promise<Types.IImageVolume>;
+export { runGrowCutForBoundingBox as default, runGrowCutForBoundingBox };
+export type { BoundingBoxInfo, GrowCutBoundingBoxOptions };

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

@@ -0,0 +1,111 @@
+import { volumeLoader, utilities as csUtils } from '@cornerstonejs/core';
+import { run } from './runGrowCut';
+const POSITIVE_SEED_VALUE = 254;
+const NEGATIVE_SEED_VALUE = 255;
+const NEGATIVE_PIXEL_RANGE = [-Infinity, -995];
+const POSITIVE_PIXEL_RANGE = [0, 1900];
+function _setNegativeSeedValues(subVolume, labelmap, options) {
+    const { negativeSeedValue = NEGATIVE_SEED_VALUE, negativePixelRange = NEGATIVE_PIXEL_RANGE, } = options;
+    const subVolPixelData = subVolume.voxelManager.getCompleteScalarDataArray();
+    const labelmapData = labelmap.voxelManager.getCompleteScalarDataArray();
+    const [width, height, numSlices] = labelmap.dimensions;
+    const middleSliceIndex = Math.floor(numSlices / 2);
+    const visited = new Array(width * height).fill(false);
+    const sliceOffset = middleSliceIndex * width * height;
+    const bfs = (startX, startY) => {
+        const queue = [[startX, startY]];
+        while (queue.length) {
+            const [x, y] = queue.shift();
+            const slicePixelIndex = y * width + x;
+            if (x < 0 ||
+                x >= width ||
+                y < 0 ||
+                y >= height ||
+                visited[slicePixelIndex]) {
+                continue;
+            }
+            visited[slicePixelIndex] = true;
+            const volumeVoxelIndex = sliceOffset + slicePixelIndex;
+            const volumeVoxelValue = subVolPixelData[volumeVoxelIndex];
+            if (volumeVoxelValue < negativePixelRange[0] ||
+                volumeVoxelValue > negativePixelRange[1]) {
+                continue;
+            }
+            labelmap.voxelManager.setAtIndex(volumeVoxelIndex, negativeSeedValue);
+            queue.push([x - 1, y]);
+            queue.push([x + 1, y]);
+            queue.push([x, y - 1]);
+            queue.push([x, y + 1]);
+        }
+    };
+    const scanLine = (startX, limitX, incX, y) => {
+        for (let x = startX; x !== limitX; x += incX) {
+            const slicePixelIndex = y * width + x;
+            const volumeVoxelIndex = sliceOffset + slicePixelIndex;
+            const volumeVoxelValue = subVolPixelData[volumeVoxelIndex];
+            if (volumeVoxelValue < negativePixelRange[0] ||
+                volumeVoxelValue > negativePixelRange[1]) {
+                break;
+            }
+            if (!visited[slicePixelIndex]) {
+                bfs(x, y);
+            }
+        }
+    };
+    for (let y = 0; y < height; y++) {
+        scanLine(0, width - 1, 1, y);
+        scanLine(width - 1, 0, -1, y);
+    }
+}
+function _setPositiveSeedValues(subVolume, labelmap, options) {
+    const { positiveSeedValue = POSITIVE_SEED_VALUE, positivePixelRange = POSITIVE_PIXEL_RANGE, } = options;
+    const subVolPixelData = subVolume.voxelManager.getCompleteScalarDataArray();
+    const labelmapData = labelmap.voxelManager.getCompleteScalarDataArray();
+    const [width, height, numSlices] = labelmap.dimensions;
+    const middleSliceIndex = Math.floor(numSlices / 2);
+    const startSliceIndex = Math.max(middleSliceIndex - 3, 0);
+    const stopSliceIndex = Math.max(startSliceIndex + 5, numSlices);
+    const pixelsPerSlice = width * height;
+    for (let z = startSliceIndex; z < stopSliceIndex; z++) {
+        const zOffset = z * pixelsPerSlice;
+        for (let y = 0; y < height; y++) {
+            const yOffset = y * width;
+            for (let x = 0; x < width; x++) {
+                const index = zOffset + yOffset + x;
+                const pixelValue = subVolPixelData[index];
+                const isPositiveValue = pixelValue >= positivePixelRange[0] &&
+                    pixelValue <= positivePixelRange[1];
+                if (isPositiveValue) {
+                    labelmap.voxelManager.setAtIndex(index, positiveSeedValue);
+                }
+            }
+        }
+    }
+}
+async function _createAndCacheSegmentationSubVolumeForBoundingBox(subVolume, options) {
+    const labelmap = volumeLoader.createAndCacheDerivedLabelmapVolume(subVolume.volumeId);
+    _setPositiveSeedValues(subVolume, labelmap, options);
+    _setNegativeSeedValues(subVolume, labelmap, options);
+    return labelmap;
+}
+async function runGrowCutForBoundingBox(referencedVolumeId, boundingBoxInfo, options) {
+    const { boundingBox } = boundingBoxInfo;
+    const { ijkTopLeft, ijkBottomRight } = boundingBox;
+    const subVolumeBoundsIJK = {
+        minX: ijkTopLeft[0],
+        maxX: ijkBottomRight[0],
+        minY: ijkTopLeft[1],
+        maxY: ijkBottomRight[1],
+        minZ: ijkTopLeft[2],
+        maxZ: ijkBottomRight[2],
+    };
+    const subVolume = csUtils.createSubVolume(referencedVolumeId, subVolumeBoundsIJK, {
+        targetBuffer: {
+            type: 'Float32Array',
+        },
+    });
+    const labelmap = await _createAndCacheSegmentationSubVolumeForBoundingBox(subVolume, options);
+    await run(subVolume.volumeId, labelmap.volumeId);
+    return labelmap;
+}
+export { runGrowCutForBoundingBox as default, runGrowCutForBoundingBox };

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

@@ -0,0 +1,9 @@
+import type { Types } from '@cornerstonejs/core';
+import { type GrowCutOptions } from './runGrowCut';
+type SphereInfo = {
+    center: Types.Point3;
+    radius: number;
+};
+declare function runGrowCutForSphere(referencedVolumeId: string, sphereInfo: SphereInfo, viewport: Types.IViewport, options?: GrowCutOptions): Promise<Types.IImageVolume>;
+export { runGrowCutForSphere as default, runGrowCutForSphere };
+export type { SphereInfo, GrowCutOptions as GrowCutSphereOptions };

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

@@ -0,0 +1,164 @@
+import { quat, vec3 } from 'gl-matrix';
+import { utilities as csUtils, cache, volumeLoader } from '@cornerstonejs/core';
+import { run } from './runGrowCut';
+import { getSphereBoundsInfo } from '../../getSphereBoundsInfo';
+const { transformWorldToIndex } = csUtils;
+const POSITIVE_SEED_VALUE = 254;
+const NEGATIVE_SEED_VALUE = 255;
+const POSITIVE_SEED_VARIANCE = 0.1;
+const NEGATIVE_SEED_VARIANCE = 0.8;
+function _getGrowCutSphereBoundsInfo(referencedVolume, sphereBoundsInfo) {
+    const { topLeftWorld, bottomRightWorld } = sphereBoundsInfo;
+    const topLeftIJK = transformWorldToIndex(referencedVolume.imageData, topLeftWorld);
+    const bottomRightIJK = transformWorldToIndex(referencedVolume.imageData, bottomRightWorld);
+    return {
+        ...sphereBoundsInfo,
+        topLeftIJK,
+        bottomRightIJK,
+    };
+}
+function _getSphereBoundsInfo(referencedVolume, sphereInfo) {
+    const direction = referencedVolume.imageData.getDirection();
+    const vecColumn = vec3.fromValues(direction[3], direction[4], direction[5]);
+    const { center: sphereCenterPoint, radius: sphereRadius } = sphereInfo;
+    const refVolImageData = referencedVolume.imageData;
+    const topCirclePoint = vec3.scaleAndAdd(vec3.create(), sphereCenterPoint, vecColumn, -sphereRadius);
+    const bottomCirclePoint = vec3.scaleAndAdd(vec3.create(), sphereCenterPoint, vecColumn, sphereRadius);
+    const sphereBoundsInfo = getSphereBoundsInfo([bottomCirclePoint, topCirclePoint], refVolImageData);
+    return _getGrowCutSphereBoundsInfo(referencedVolume, sphereBoundsInfo);
+}
+function _createSubVolumeFromSphere(referencedVolume, sphereInfo, viewport) {
+    const refVolImageData = referencedVolume.imageData;
+    const camera = viewport.getCamera();
+    const { ijkVecRowDir, ijkVecColDir } = csUtils.getVolumeDirectionVectors(refVolImageData, camera);
+    const obliqueView = [ijkVecRowDir, ijkVecColDir].some((vec) => !csUtils.isEqual(Math.abs(vec[0]), 1) &&
+        !csUtils.isEqual(Math.abs(vec[1]), 1) &&
+        !csUtils.isEqual(Math.abs(vec[2]), 1));
+    if (obliqueView) {
+        console.warn('Oblique view is not supported!');
+        return;
+    }
+    const { boundsIJK: sphereBoundsIJK } = _getSphereBoundsInfo(referencedVolume, sphereInfo);
+    const subVolumeBoundsIJK = {
+        minX: sphereBoundsIJK[0][0],
+        maxX: sphereBoundsIJK[0][1] + 1,
+        minY: sphereBoundsIJK[1][0],
+        maxY: sphereBoundsIJK[1][1] + 1,
+        minZ: sphereBoundsIJK[2][0],
+        maxZ: sphereBoundsIJK[2][1] + 1,
+    };
+    return csUtils.createSubVolume(referencedVolume.volumeId, subVolumeBoundsIJK, {
+        targetBuffer: {
+            type: 'Float32Array',
+        },
+    });
+}
+function _setPositiveSeedValues(referencedVolume, labelmap, sphereInfo, options) {
+    const refVolumePixelData = referencedVolume.voxelManager.getCompleteScalarDataArray();
+    const worldStartPos = sphereInfo.center;
+    const [width, height, numSlices] = referencedVolume.dimensions;
+    const numPixelsPerSlice = width * height;
+    const ijkStartPosition = transformWorldToIndex(referencedVolume.imageData, worldStartPos);
+    const referencePixelValue = refVolumePixelData[ijkStartPosition[2] * numPixelsPerSlice +
+        ijkStartPosition[1] * width +
+        ijkStartPosition[0]];
+    const positiveSeedValue = options.positiveSeedValue ?? POSITIVE_SEED_VALUE;
+    const positiveSeedVariance = options.positiveSeedVariance ?? POSITIVE_SEED_VARIANCE;
+    const positiveSeedVarianceValue = Math.abs(referencePixelValue * positiveSeedVariance);
+    const minPositivePixelValue = referencePixelValue - positiveSeedVarianceValue;
+    const maxPositivePixelValue = referencePixelValue + positiveSeedVarianceValue;
+    const neighborsCoordDelta = [
+        [-1, 0, 0],
+        [1, 0, 0],
+        [0, -1, 0],
+        [0, 1, 0],
+        [0, 0, -1],
+        [0, 0, 1],
+    ];
+    const startVoxelIndex = ijkStartPosition[2] * numPixelsPerSlice +
+        ijkStartPosition[1] * width +
+        ijkStartPosition[0];
+    labelmap.voxelManager.setAtIndex(startVoxelIndex, positiveSeedValue);
+    const queue = [ijkStartPosition];
+    while (queue.length) {
+        const ijkVoxel = queue.shift();
+        const [x, y, z] = ijkVoxel;
+        for (let i = 0, len = neighborsCoordDelta.length; i < len; i++) {
+            const neighborCoordDelta = neighborsCoordDelta[i];
+            const nx = x + neighborCoordDelta[0];
+            const ny = y + neighborCoordDelta[1];
+            const nz = z + neighborCoordDelta[2];
+            if (nx < 0 ||
+                nx >= width ||
+                ny < 0 ||
+                ny >= height ||
+                nz < 0 ||
+                nz >= numSlices) {
+                continue;
+            }
+            const neighborVoxelIndex = nz * numPixelsPerSlice + ny * width + nx;
+            const neighborPixelValue = refVolumePixelData[neighborVoxelIndex];
+            const neighborLabelmapValue = labelmap.voxelManager.getAtIndex(neighborVoxelIndex);
+            if (neighborLabelmapValue === positiveSeedValue ||
+                neighborPixelValue < minPositivePixelValue ||
+                neighborPixelValue > maxPositivePixelValue) {
+                continue;
+            }
+            labelmap.voxelManager.setAtIndex(neighborVoxelIndex, positiveSeedValue);
+            queue.push([nx, ny, nz]);
+        }
+    }
+}
+function _setNegativeSeedValues(subVolume, labelmap, sphereInfo, viewport, options) {
+    const subVolPixelData = subVolume.voxelManager.getCompleteScalarDataArray();
+    const [columns, rows, numSlices] = labelmap.dimensions;
+    const numPixelsPerSlice = columns * rows;
+    const { worldVecRowDir, worldVecSliceDir } = csUtils.getVolumeDirectionVectors(labelmap.imageData, viewport.getCamera());
+    const ijkSphereCenter = transformWorldToIndex(subVolume.imageData, sphereInfo.center);
+    const referencePixelValue = subVolPixelData[ijkSphereCenter[2] * columns * rows +
+        ijkSphereCenter[1] * columns +
+        ijkSphereCenter[0]];
+    const negativeSeedVariance = options.negativeSeedVariance ?? NEGATIVE_SEED_VARIANCE;
+    const negativeSeedValue = options?.negativeSeedValue ?? NEGATIVE_SEED_VALUE;
+    const negativeSeedVarianceValue = Math.abs(referencePixelValue * negativeSeedVariance);
+    const minNegativePixelValue = referencePixelValue - negativeSeedVarianceValue;
+    const maxNegativePixelValue = referencePixelValue + negativeSeedVarianceValue;
+    const numCirclePoints = 360;
+    const rotationAngle = (2 * Math.PI) / numCirclePoints;
+    const worldQuat = quat.setAxisAngle(quat.create(), worldVecSliceDir, rotationAngle);
+    const vecRotation = vec3.clone(worldVecRowDir);
+    for (let i = 0; i < numCirclePoints; i++) {
+        const worldCircleBorderPoint = vec3.scaleAndAdd(vec3.create(), sphereInfo.center, vecRotation, sphereInfo.radius);
+        const ijkCircleBorderPoint = transformWorldToIndex(labelmap.imageData, worldCircleBorderPoint);
+        const [x, y, z] = ijkCircleBorderPoint;
+        vec3.transformQuat(vecRotation, vecRotation, worldQuat);
+        if (x < 0 ||
+            x >= columns ||
+            y < 0 ||
+            y >= rows ||
+            z < 0 ||
+            z >= numSlices) {
+            continue;
+        }
+        const offset = x + y * columns + z * numPixelsPerSlice;
+        const pixelValue = subVolPixelData[offset];
+        if (pixelValue < minNegativePixelValue ||
+            pixelValue > maxNegativePixelValue) {
+            labelmap.voxelManager.setAtIndex(offset, negativeSeedValue);
+        }
+    }
+}
+async function _createAndCacheSegmentationSubVolumeForSphere(subVolume, sphereInfo, viewport, options) {
+    const labelmap = await volumeLoader.createAndCacheDerivedLabelmapVolume(subVolume.volumeId);
+    _setPositiveSeedValues(subVolume, labelmap, sphereInfo, options);
+    _setNegativeSeedValues(subVolume, labelmap, sphereInfo, viewport, options);
+    return labelmap;
+}
+async function runGrowCutForSphere(referencedVolumeId, sphereInfo, viewport, options) {
+    const referencedVolume = cache.getVolume(referencedVolumeId);
+    const subVolume = _createSubVolumeFromSphere(referencedVolume, sphereInfo, viewport);
+    const labelmap = await _createAndCacheSegmentationSubVolumeForSphere(subVolume, sphereInfo, viewport, options);
+    await run(subVolume.volumeId, labelmap.volumeId);
+    return labelmap;
+}
+export { runGrowCutForSphere as default, runGrowCutForSphere };

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

@@ -0,0 +1,13 @@
+import type { Types } from '@cornerstonejs/core';
+import type { GrowCutOptions } from './runGrowCut';
+type GrowCutOneClickOptions = GrowCutOptions & {
+    positiveSeedValue?: number;
+    negativeSeedValue?: number;
+    positiveSeedVariance?: number;
+    negativeSeedVariance?: number;
+    subVolumePaddingPercentage?: number | [number, number, number];
+    subVolumeMinPadding?: number | [number, number, number];
+};
+declare function runOneClickGrowCut(referencedVolumeId: string, worldPosition: Types.Point3, viewport: Types.IViewport, options?: GrowCutOneClickOptions): Promise<Types.IImageVolume>;
+export { runOneClickGrowCut as default, runOneClickGrowCut };
+export type { GrowCutOneClickOptions };