@cornerstonejs/tools 3.0.2 → 3.0.3

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

@@ -0,0 +1,76 @@
+import { BaseVolumeViewport, cache, utilities } from '@cornerstonejs/core';
+import { getSegmentation, getCurrentLabelmapImageIdForViewport, } from '../../stateManagement/segmentation/segmentationState';
+import { getLabelmapActorEntry } from '../../stateManagement/segmentation/helpers';
+export function getSegmentIndexAtLabelmapBorder(segmentationId, worldPoint, { viewport, searchRadius }) {
+    const segmentation = getSegmentation(segmentationId);
+    const labelmapData = segmentation.representationData.Labelmap;
+    if (viewport instanceof BaseVolumeViewport) {
+        const { volumeId } = labelmapData;
+        const segmentationVolume = cache.getVolume(volumeId);
+        if (!segmentationVolume) {
+            return;
+        }
+        const voxelManager = segmentationVolume.voxelManager;
+        const imageData = segmentationVolume.imageData;
+        const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
+        const segmentIndex = voxelManager.getAtIJK(indexIJK[0], indexIJK[1], indexIJK[2]);
+        const canvasPoint = viewport.worldToCanvas(worldPoint);
+        const onEdge = isSegmentOnEdgeCanvas(canvasPoint, segmentIndex, viewport, imageData, searchRadius);
+        return onEdge ? segmentIndex : undefined;
+    }
+    const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
+    const image = cache.getImage(segmentationImageId);
+    if (!image) {
+        return;
+    }
+    const segmentationActorEntry = getLabelmapActorEntry(viewport.id, segmentationId);
+    const imageData = segmentationActorEntry?.actor.getMapper().getInputData();
+    const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
+    const dimensions = imageData.getDimensions();
+    const voxelManager = (imageData.voxelManager ||
+        utilities.VoxelManager.createScalarVolumeVoxelManager({
+            dimensions,
+            scalarData: imageData.getPointData().getScalars().getData(),
+        }));
+    const segmentIndex = voxelManager.getAtIJKPoint(indexIJK);
+    const onEdge = isSegmentOnEdgeIJK(indexIJK, dimensions, voxelManager, segmentIndex);
+    return onEdge ? segmentIndex : undefined;
+}
+function isSegmentOnEdge(getNeighborIndex, segmentIndex, searchRadius = 1) {
+    const neighborRange = Array.from({ length: 2 * searchRadius + 1 }, (_, i) => i - searchRadius);
+    for (const deltaI of neighborRange) {
+        for (const deltaJ of neighborRange) {
+            for (const deltaK of neighborRange) {
+                if (deltaI === 0 && deltaJ === 0 && deltaK === 0) {
+                    continue;
+                }
+                const neighborIndex = getNeighborIndex(deltaI, deltaJ, deltaK);
+                if (neighborIndex !== undefined && segmentIndex !== neighborIndex) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+function isSegmentOnEdgeIJK(indexIJK, dimensions, voxelManager, segmentIndex, searchRadius) {
+    const getNeighborIndex = (deltaI, deltaJ, deltaK) => {
+        const neighborIJK = [
+            indexIJK[0] + deltaI,
+            indexIJK[1] + deltaJ,
+            indexIJK[2] + deltaK,
+        ];
+        return voxelManager.getAtIJK(neighborIJK[0], neighborIJK[1], neighborIJK[2]);
+    };
+    return isSegmentOnEdge(getNeighborIndex, segmentIndex, searchRadius);
+}
+function isSegmentOnEdgeCanvas(canvasPoint, segmentIndex, viewport, imageData, searchRadius) {
+    const getNeighborIndex = (deltaI, deltaJ) => {
+        const neighborCanvas = [canvasPoint[0] + deltaI, canvasPoint[1] + deltaJ];
+        const worldPoint = viewport.canvasToWorld(neighborCanvas);
+        const voxelManager = imageData.get('voxelManager').voxelManager;
+        const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
+        return voxelManager.getAtIJK(indexIJK[0], indexIJK[1], indexIJK[2]);
+    };
+    return isSegmentOnEdge(getNeighborIndex, segmentIndex, searchRadius);
+}

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

@@ -0,0 +1,11 @@
+import type { Types } from '@cornerstonejs/core';
+import { SegmentationRepresentations } from '../../enums';
+import type { Segmentation } from '../../types';
+type Options = {
+    representationType?: SegmentationRepresentations;
+    viewport?: Types.IViewport;
+};
+export declare function getSegmentIndexAtWorldPoint(segmentationId: string, worldPoint: Types.Point3, options?: Options): number;
+export declare function getSegmentIndexAtWorldForLabelmap(segmentation: Segmentation, worldPoint: Types.Point3, { viewport }: Options): number | undefined;
+export declare function getSegmentIndexAtWorldForContour(segmentation: Segmentation, worldPoint: Types.Point3, { viewport }: Options): number;
+export {};

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

@@ -0,0 +1,74 @@
+import { BaseVolumeViewport, cache, utilities } from '@cornerstonejs/core';
+import { SegmentationRepresentations } from '../../enums';
+import { getSegmentation, getCurrentLabelmapImageIdForViewport, } from '../../stateManagement/segmentation/segmentationState';
+import { getAnnotation } from '../../stateManagement';
+import { isPointInsidePolyline3D } from '../math/polyline';
+import { getLabelmapActorEntry } from '../../stateManagement/segmentation/helpers/getSegmentationActor';
+export function getSegmentIndexAtWorldPoint(segmentationId, worldPoint, options = {}) {
+    const segmentation = getSegmentation(segmentationId);
+    const representationData = segmentation.representationData;
+    const desiredRepresentation = options?.representationType ?? Object.keys(representationData)[0];
+    if (!desiredRepresentation) {
+        throw new Error(`Segmentation ${segmentationId} does not have any representations`);
+    }
+    switch (desiredRepresentation) {
+        case SegmentationRepresentations.Labelmap:
+            return getSegmentIndexAtWorldForLabelmap(segmentation, worldPoint, options);
+        case SegmentationRepresentations.Contour:
+            return getSegmentIndexAtWorldForContour(segmentation, worldPoint, options);
+        default:
+            return;
+    }
+}
+export function getSegmentIndexAtWorldForLabelmap(segmentation, worldPoint, { viewport }) {
+    const labelmapData = segmentation.representationData.Labelmap;
+    if (viewport instanceof BaseVolumeViewport) {
+        const { volumeId } = labelmapData;
+        const segmentationVolume = cache.getVolume(volumeId);
+        if (!segmentationVolume) {
+            return;
+        }
+        const segmentIndex = segmentationVolume.imageData.getScalarValueFromWorld(worldPoint);
+        return segmentIndex;
+    }
+    const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentation.segmentationId);
+    const image = cache.getImage(segmentationImageId);
+    if (!image) {
+        return;
+    }
+    const segmentationActorEntry = getLabelmapActorEntry(viewport.id, segmentation.segmentationId);
+    const imageData = segmentationActorEntry?.actor.getMapper().getInputData();
+    const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
+    const dimensions = imageData.getDimensions();
+    const voxelManager = (imageData.voxelManager ||
+        utilities.VoxelManager.createScalarVolumeVoxelManager({
+            dimensions,
+            scalarData: imageData.getPointData().getScalars().getData(),
+        }));
+    const segmentIndex = voxelManager.getAtIJKPoint(indexIJK);
+    return segmentIndex;
+}
+export function getSegmentIndexAtWorldForContour(segmentation, worldPoint, { viewport }) {
+    const contourData = segmentation.representationData.Contour;
+    const segmentIndices = Array.from(contourData.annotationUIDsMap.keys());
+    const { viewPlaneNormal } = viewport.getCamera();
+    for (const segmentIndex of segmentIndices) {
+        const annotationsSet = contourData.annotationUIDsMap.get(segmentIndex);
+        if (!annotationsSet) {
+            continue;
+        }
+        for (const annotationUID of annotationsSet) {
+            const annotation = getAnnotation(annotationUID);
+            if (!annotation) {
+                continue;
+            }
+            const { polyline } = annotation.data.contour;
+            if (!utilities.isEqual(viewPlaneNormal, annotation.metadata.viewPlaneNormal)) {
+                continue;
+            }
+            if (isPointInsidePolyline3D(worldPoint, polyline)) {
+                return Number(segmentIndex);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,5 @@
+declare function getStatistics({ segmentationId, segmentIndices, }: {
+    segmentationId: string;
+    segmentIndices: number[] | number;
+}): Promise<any>;
+export default getStatistics;

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

@@ -0,0 +1,210 @@
+import { cache, utilities, getWebWorkerManager, eventTarget, Enums, triggerEvent, metaData, } from '@cornerstonejs/core';
+import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
+import VolumetricCalculator from './VolumetricCalculator';
+import { getStrategyData } from '../../tools/segmentation/strategies/utils/getStrategyData';
+import { getPixelValueUnitsImageId } from '../getPixelValueUnits';
+import ensureSegmentationVolume from '../../tools/segmentation/strategies/compositions/ensureSegmentationVolume';
+import ensureImageVolume from '../../tools/segmentation/strategies/compositions/ensureImageVolume';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
+import { registerComputeWorker } from '../registerComputeWorker';
+import { WorkerTypes } from '../../enums';
+const radiusForVol1 = Math.pow((3 * 1000) / (4 * Math.PI), 1 / 3);
+const workerManager = getWebWorkerManager();
+const triggerWorkerProgress = (eventTarget, progress) => {
+    triggerEvent(eventTarget, Enums.Events.WEB_WORKER_PROGRESS, {
+        progress,
+        type: WorkerTypes.COMPUTE_STATISTICS,
+    });
+};
+async function getStatistics({ segmentationId, segmentIndices, }) {
+    registerComputeWorker();
+    triggerWorkerProgress(eventTarget, 0);
+    const segmentation = getSegmentation(segmentationId);
+    const { representationData } = segmentation;
+    const { Labelmap } = representationData;
+    if (!Labelmap) {
+        console.debug('No labelmap found for segmentation', segmentationId);
+        return;
+    }
+    const segVolumeId = Labelmap.volumeId;
+    const segImageIds = Labelmap.imageIds;
+    const operationData = {
+        segmentationId,
+        volumeId: segVolumeId,
+        imageIds: segImageIds,
+    };
+    let reconstructableVolume = false;
+    if (segImageIds) {
+        const refImageIds = segImageIds.map((imageId) => {
+            const image = cache.getImage(imageId);
+            return image.referencedImageId;
+        });
+        reconstructableVolume = utilities.isValidVolume(refImageIds);
+    }
+    let indices = segmentIndices;
+    if (!indices) {
+        indices = [getActiveSegmentIndex(segmentationId)];
+    }
+    else if (!Array.isArray(indices)) {
+        indices = [indices, 255];
+    }
+    const { refImageId, modalityUnitOptions } = getImageReferenceInfo(segVolumeId, segImageIds);
+    const unit = getPixelValueUnitsImageId(refImageId, modalityUnitOptions);
+    const stats = reconstructableVolume
+        ? await calculateVolumeStatistics(operationData, indices, unit)
+        : await calculateStackStatistics(segImageIds, indices, unit);
+    return stats;
+}
+async function calculateVolumeStatistics(operationData, indices, unit) {
+    const strategyData = getStrategyData({
+        operationData,
+        strategy: {
+            ensureSegmentationVolumeFor3DManipulation: ensureSegmentationVolume.ensureSegmentationVolumeFor3DManipulation,
+            ensureImageVolumeFor3DManipulation: ensureImageVolume.ensureImageVolumeFor3DManipulation,
+        },
+    });
+    const { segmentationVoxelManager, imageVoxelManager, segmentationImageData, imageData, } = strategyData;
+    const spacing = segmentationImageData.getSpacing();
+    const { boundsIJK: boundsOrig } = segmentationVoxelManager;
+    if (!boundsOrig) {
+        return VolumetricCalculator.getStatistics({ spacing });
+    }
+    const segmentationScalarData = segmentationVoxelManager.getCompleteScalarDataArray();
+    const imageScalarData = imageVoxelManager.getCompleteScalarDataArray();
+    const segmentationInfo = {
+        scalarData: segmentationScalarData,
+        dimensions: segmentationImageData.getDimensions(),
+        spacing: segmentationImageData.getSpacing(),
+        origin: segmentationImageData.getOrigin(),
+    };
+    const imageInfo = {
+        scalarData: imageScalarData,
+        dimensions: imageData.getDimensions(),
+        spacing: imageData.getSpacing(),
+        origin: imageData.getOrigin(),
+    };
+    const stats = await workerManager.executeTask('compute', 'calculateSegmentsStatisticsVolume', {
+        segmentationInfo,
+        imageInfo,
+        indices,
+    });
+    triggerWorkerProgress(eventTarget, 100);
+    stats.mean.unit = unit;
+    stats.max.unit = unit;
+    stats.min.unit = unit;
+    if (unit !== 'SUV') {
+        return stats;
+    }
+    const radiusIJK = spacing.map((s) => Math.max(1, Math.round((1.1 * radiusForVol1) / s)));
+    for (const testMax of stats.maxIJKs) {
+        const testStats = getSphereStats(testMax, radiusIJK, segmentationImageData, imageVoxelManager, spacing);
+        if (!testStats) {
+            continue;
+        }
+        const { mean } = testStats;
+        if (!stats.peakValue || stats.peakValue.value <= mean.value) {
+            stats.peakValue = {
+                name: 'peakValue',
+                label: 'Peak Value',
+                value: mean.value,
+                unit,
+            };
+        }
+    }
+    return stats;
+}
+async function calculateStackStatistics(segImageIds, indices, unit) {
+    triggerWorkerProgress(eventTarget, 0);
+    const segmentationInfo = [];
+    const imageInfo = [];
+    for (const segImageId of segImageIds) {
+        const segImage = cache.getImage(segImageId);
+        const segPixelData = segImage.getPixelData();
+        const segVoxelManager = segImage.voxelManager;
+        const segSpacing = [segImage.rowPixelSpacing, segImage.columnPixelSpacing];
+        const refImageId = segImage.referencedImageId;
+        const refImage = cache.getImage(refImageId);
+        const refPixelData = refImage.getPixelData();
+        const refVoxelManager = refImage.voxelManager;
+        const refSpacing = [refImage.rowPixelSpacing, refImage.columnPixelSpacing];
+        segmentationInfo.push({
+            scalarData: segPixelData,
+            dimensions: segVoxelManager.dimensions,
+            spacing: segSpacing,
+        });
+        imageInfo.push({
+            scalarData: refPixelData,
+            dimensions: refVoxelManager.dimensions,
+            spacing: refSpacing,
+        });
+    }
+    const stats = await workerManager.executeTask('compute', 'calculateSegmentsStatisticsStack', {
+        segmentationInfo,
+        imageInfo,
+        indices,
+    });
+    triggerWorkerProgress(eventTarget, 100);
+    stats.mean.unit = unit;
+    stats.max.unit = unit;
+    stats.min.unit = unit;
+    return stats;
+}
+function getSphereStats(testMax, radiusIJK, segData, imageVoxels, spacing) {
+    const { pointIJK: centerIJK } = testMax;
+    if (!centerIJK) {
+        return;
+    }
+    const boundsIJK = centerIJK.map((ijk, idx) => [
+        ijk - radiusIJK[idx],
+        ijk + radiusIJK[idx],
+    ]);
+    const testFunction = (_pointLPS, pointIJK) => {
+        const i = (pointIJK[0] - centerIJK[0]) / radiusIJK[0];
+        const j = (pointIJK[1] - centerIJK[1]) / radiusIJK[1];
+        const k = (pointIJK[2] - centerIJK[2]) / radiusIJK[2];
+        const radius = i * i + j * j + k * k;
+        return radius <= 1;
+    };
+    const statsFunction = ({ pointIJK, pointLPS }) => {
+        const value = imageVoxels.getAtIJKPoint(pointIJK);
+        if (value === undefined) {
+            return;
+        }
+        VolumetricCalculator.statsCallback({ value, pointLPS, pointIJK });
+    };
+    VolumetricCalculator.statsInit({ storePointData: false });
+    utilities.pointInShapeCallback(segData, {
+        pointInShapeFn: testFunction,
+        callback: statsFunction,
+        boundsIJK,
+    });
+    return VolumetricCalculator.getStatistics({ spacing });
+}
+function getImageReferenceInfo(segVolumeId, segImageIds) {
+    let refImageId;
+    let modalityUnitOptions;
+    if (segVolumeId) {
+        const segmentationVolume = cache.getVolume(segVolumeId);
+        const referencedVolumeId = segmentationVolume.referencedVolumeId;
+        const volume = cache.getVolume(referencedVolumeId);
+        if (volume?.imageIds?.length > 0) {
+            refImageId = volume.imageIds[0];
+        }
+        modalityUnitOptions = {
+            isPreScaled: Object.keys(volume.scaling || {}).length > 0,
+            isSuvScaled: Boolean(volume.scaling?.PT),
+        };
+    }
+    else if (segImageIds?.length) {
+        const segImage = cache.getImage(segImageIds[0]);
+        refImageId = segImage.referencedImageId;
+        const refImage = cache.getImage(refImageId);
+        const scalingModule = metaData.get('scalingModule', refImageId);
+        modalityUnitOptions = {
+            isPreScaled: Boolean(refImage.preScale?.scaled),
+            isSuvScaled: typeof scalingModule?.preScale?.scaled === 'number',
+        };
+    }
+    return { refImageId, modalityUnitOptions };
+}
+export default getStatistics;

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

@@ -0,0 +1,2 @@
+declare function getUniqueSegmentIndices(segmentationId: any): any;
+export { getUniqueSegmentIndices };

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

@@ -0,0 +1,80 @@
+import { cache } from '@cornerstonejs/core';
+import { SegmentationRepresentations } from '../../enums';
+import { getCachedSegmentIndices, setCachedSegmentIndices } from './utilities';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
+function getUniqueSegmentIndices(segmentationId) {
+    const cachedResult = getCachedSegmentIndices(segmentationId);
+    if (cachedResult) {
+        return cachedResult;
+    }
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation) {
+        throw new Error(`No segmentation found for segmentationId ${segmentationId}`);
+    }
+    let indices;
+    if (segmentation.representationData.Labelmap) {
+        indices = handleLabelmapSegmentation(segmentation, segmentationId);
+    }
+    else if (segmentation.representationData.Contour) {
+        indices = handleContourSegmentation(segmentation);
+    }
+    else if (segmentation.representationData.Surface) {
+        indices = handleSurfaceSegmentation(segmentation);
+    }
+    else {
+        throw new Error(`Unsupported segmentation type: ${segmentation.representationData}`);
+    }
+    setCachedSegmentIndices(segmentationId, indices);
+    return indices;
+}
+function handleLabelmapSegmentation(segmentation, segmentationId) {
+    const labelmapData = segmentation.representationData[SegmentationRepresentations.Labelmap];
+    const keySet = new Set();
+    if (labelmapData.imageIds) {
+        addImageSegmentIndices(keySet, labelmapData.imageIds);
+    }
+    else {
+        addVolumeSegmentIndices(keySet, segmentationId);
+    }
+    return Array.from(keySet)
+        .map(Number)
+        .sort((a, b) => a - b);
+}
+function addVolumeSegmentIndices(keySet, segmentationId) {
+    const volume = cache.getVolume(segmentationId);
+    volume.voxelManager.forEach(({ value }) => {
+        if (value !== 0) {
+            keySet.add(value);
+        }
+    });
+}
+function addImageSegmentIndices(keySet, imageIds) {
+    imageIds.forEach((segmentationImageId) => {
+        const image = cache.getImage(segmentationImageId);
+        const scalarData = image.voxelManager.getScalarData();
+        scalarData.forEach((segmentIndex) => {
+            if (segmentIndex !== 0) {
+                keySet.add(segmentIndex);
+            }
+        });
+    });
+}
+function handleContourSegmentation(segmentation) {
+    const { annotationUIDsMap, geometryIds } = segmentation.representationData.Contour || {};
+    if (!geometryIds) {
+        throw new Error(`No geometryIds found for segmentationId ${segmentation.segmentationId}`);
+    }
+    const indices = new Set([...annotationUIDsMap.keys()]);
+    geometryIds.forEach((geometryId) => {
+        const geometry = cache.getGeometry(geometryId);
+        indices.add(geometry.data.segmentIndex);
+    });
+    return Array.from(indices).sort((a, b) => a - b);
+}
+function handleSurfaceSegmentation(segmentation) {
+    const geometryIds = segmentation.representationData.Surface?.geometryIds ?? [];
+    return Array.from(geometryIds.keys())
+        .map(Number)
+        .sort((a, b) => a - b);
+}
+export { getUniqueSegmentIndices };

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

@@ -0,0 +1,2 @@
+declare const shader = "\nconst MAX_STRENGTH = 65535f;\n\n// Workgroup soze - X*Y*Z must be multiple of 32 for better performance\n// otherwise warps are sub allocated and some threads will not process anything\noverride workGroupSizeX = 1u;\noverride workGroupSizeY = 1u;\noverride workGroupSizeZ = 1u;\n\n// Compare the current voxel to neighbors using a 9x9x9 window\noverride windowSize = 9i;\n\nstruct Params {\n  size: vec3u,\n  iteration: u32,\n}\n\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage> volumePixelData: array<f32>;\n@group(0) @binding(2) var<storage, read_write> labelmap: array<u32>;\n@group(0) @binding(3) var<storage, read_write> strengthData: array<f32>;\n@group(0) @binding(4) var<storage> prevLabelmap: array<u32>;\n@group(0) @binding(5) var<storage> prevStrengthData: array<f32>;\n@group(0) @binding(6) var<storage, read_write> updatedVoxelsCounter: array<atomic<u32>>;\n\nfn getPixelIndex(ijkPos: vec3u) -> u32 {\n  let numPixelsPerSlice = params.size.x * params.size.y;\n  return ijkPos.x + ijkPos.y * params.size.x + ijkPos.z * numPixelsPerSlice;\n}\n\n@compute @workgroup_size(workGroupSizeX, workGroupSizeY, workGroupSizeZ)\nfn main(\n  @builtin(global_invocation_id) globalId: vec3u,\n) {\n  // Make sure it will not get out of bounds for volume with sizes that\n  // are not multiple of workGroupSize\n  if (\n    globalId.x >= params.size.x ||\n    globalId.y >= params.size.y ||\n    globalId.z >= params.size.z\n  ) {\n    return;\n  }\n\n  let currentCoord = vec3i(globalId);\n  let currentPixelIndex = getPixelIndex(globalId);\n\n  let numPixels = arrayLength(&volumePixelData);\n  let currentPixelValue = volumePixelData[currentPixelIndex];\n\n  if (params.iteration == 0) {\n    // All non-zero initial labels are given maximum strength\n    strengthData[currentPixelIndex] = select(MAX_STRENGTH, 0., labelmap[currentPixelIndex] == 0);\n    return;\n  }\n\n  // It should at least copy the values from previous state\n  var newLabel = prevLabelmap[currentPixelIndex];\n  var newStrength = prevStrengthData[currentPixelIndex];\n\n  let window = i32(ceil(f32(windowSize - 1) * .5));\n  let minWindow = -1i * window;\n  let maxWindow = 1i * window;\n\n  for (var k = minWindow; k <= maxWindow; k++) {\n    for (var j = minWindow; j <= maxWindow; j++) {\n      for (var i = minWindow; i <= maxWindow; i++) {\n        // Skip current voxel\n        if (i == 0 && j == 0 && k == 0) {\n          continue;\n        }\n\n        let neighborCoord = currentCoord + vec3i(i, j, k);\n\n        //  Boundary conditions. Do not grow outside of the volume\n        if (\n          neighborCoord.x < 0i || neighborCoord.x >= i32(params.size.x) ||\n          neighborCoord.y < 0i || neighborCoord.y >= i32(params.size.y) ||\n          neighborCoord.z < 0i || neighborCoord.z >= i32(params.size.z)\n        ) {\n          continue;\n        }\n\n        let neighborIndex = getPixelIndex(vec3u(neighborCoord));\n        let neighborPixelValue = volumePixelData[neighborIndex];\n        let prevNeighborStrength = prevStrengthData[neighborIndex];\n        let strengthCost = abs(neighborPixelValue - currentPixelValue);\n        let takeoverStrength = prevNeighborStrength - strengthCost;\n\n        if (takeoverStrength > newStrength) {\n          newLabel = prevLabelmap[neighborIndex];\n          newStrength = takeoverStrength;\n        }\n      }\n    }\n  }\n\n  if (labelmap[currentPixelIndex] != newLabel) {\n    atomicAdd(&updatedVoxelsCounter[params.iteration], 1u);\n  }\n\n  labelmap[currentPixelIndex] = newLabel;\n  strengthData[currentPixelIndex] = newStrength;\n}\n";
+export default shader;

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

@@ -0,0 +1,106 @@
+const shader = `
+const MAX_STRENGTH = 65535f;
+
+// Workgroup soze - X*Y*Z must be multiple of 32 for better performance
+// otherwise warps are sub allocated and some threads will not process anything
+override workGroupSizeX = 1u;
+override workGroupSizeY = 1u;
+override workGroupSizeZ = 1u;
+
+// Compare the current voxel to neighbors using a 9x9x9 window
+override windowSize = 9i;
+
+struct Params {
+  size: vec3u,
+  iteration: u32,
+}
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var<storage> volumePixelData: array<f32>;
+@group(0) @binding(2) var<storage, read_write> labelmap: array<u32>;
+@group(0) @binding(3) var<storage, read_write> strengthData: array<f32>;
+@group(0) @binding(4) var<storage> prevLabelmap: array<u32>;
+@group(0) @binding(5) var<storage> prevStrengthData: array<f32>;
+@group(0) @binding(6) var<storage, read_write> updatedVoxelsCounter: array<atomic<u32>>;
+
+fn getPixelIndex(ijkPos: vec3u) -> u32 {
+  let numPixelsPerSlice = params.size.x * params.size.y;
+  return ijkPos.x + ijkPos.y * params.size.x + ijkPos.z * numPixelsPerSlice;
+}
+
+@compute @workgroup_size(workGroupSizeX, workGroupSizeY, workGroupSizeZ)
+fn main(
+  @builtin(global_invocation_id) globalId: vec3u,
+) {
+  // Make sure it will not get out of bounds for volume with sizes that
+  // are not multiple of workGroupSize
+  if (
+    globalId.x >= params.size.x ||
+    globalId.y >= params.size.y ||
+    globalId.z >= params.size.z
+  ) {
+    return;
+  }
+
+  let currentCoord = vec3i(globalId);
+  let currentPixelIndex = getPixelIndex(globalId);
+
+  let numPixels = arrayLength(&volumePixelData);
+  let currentPixelValue = volumePixelData[currentPixelIndex];
+
+  if (params.iteration == 0) {
+    // All non-zero initial labels are given maximum strength
+    strengthData[currentPixelIndex] = select(MAX_STRENGTH, 0., labelmap[currentPixelIndex] == 0);
+    return;
+  }
+
+  // It should at least copy the values from previous state
+  var newLabel = prevLabelmap[currentPixelIndex];
+  var newStrength = prevStrengthData[currentPixelIndex];
+
+  let window = i32(ceil(f32(windowSize - 1) * .5));
+  let minWindow = -1i * window;
+  let maxWindow = 1i * window;
+
+  for (var k = minWindow; k <= maxWindow; k++) {
+    for (var j = minWindow; j <= maxWindow; j++) {
+      for (var i = minWindow; i <= maxWindow; i++) {
+        // Skip current voxel
+        if (i == 0 && j == 0 && k == 0) {
+          continue;
+        }
+
+        let neighborCoord = currentCoord + vec3i(i, j, k);
+
+        //  Boundary conditions. Do not grow outside of the volume
+        if (
+          neighborCoord.x < 0i || neighborCoord.x >= i32(params.size.x) ||
+          neighborCoord.y < 0i || neighborCoord.y >= i32(params.size.y) ||
+          neighborCoord.z < 0i || neighborCoord.z >= i32(params.size.z)
+        ) {
+          continue;
+        }
+
+        let neighborIndex = getPixelIndex(vec3u(neighborCoord));
+        let neighborPixelValue = volumePixelData[neighborIndex];
+        let prevNeighborStrength = prevStrengthData[neighborIndex];
+        let strengthCost = abs(neighborPixelValue - currentPixelValue);
+        let takeoverStrength = prevNeighborStrength - strengthCost;
+
+        if (takeoverStrength > newStrength) {
+          newLabel = prevLabelmap[neighborIndex];
+          newStrength = takeoverStrength;
+        }
+      }
+    }
+  }
+
+  if (labelmap[currentPixelIndex] != newLabel) {
+    atomicAdd(&updatedVoxelsCounter[params.iteration], 1u);
+  }
+
+  labelmap[currentPixelIndex] = newLabel;
+  strengthData[currentPixelIndex] = newStrength;
+}
+`;
+export default shader;

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

@@ -0,0 +1,7 @@
+export { run } from './runGrowCut';
+export { runGrowCutForSphere } from './runGrowCutForSphere';
+export { runGrowCutForBoundingBox } from './runGrowCutForBoundingBox';
+export { runOneClickGrowCut } from './runOneClickGrowCut';
+export type { SphereInfo, GrowCutSphereOptions } from './runGrowCutForSphere';
+export type { GrowCutBoundingBoxOptions } from './runGrowCutForBoundingBox';
+export type { GrowCutOneClickOptions } from './runOneClickGrowCut';

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

@@ -0,0 +1,4 @@
+export { run } from './runGrowCut';
+export { runGrowCutForSphere } from './runGrowCutForSphere';
+export { runGrowCutForBoundingBox } from './runGrowCutForBoundingBox';
+export { runOneClickGrowCut } from './runOneClickGrowCut';

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

@@ -0,0 +1,16 @@
+type GrowCutOptions = {
+    maxProcessingTime?: number;
+    windowSize?: number;
+    positiveSeedValue?: number;
+    negativeSeedValue?: number;
+    positiveSeedVariance?: number;
+    negativeSeedVariance?: number;
+    inspection?: {
+        numCyclesInterval?: number;
+        numCyclesBelowThreashold?: number;
+        threshold?: number;
+    };
+};
+declare function runGrowCut(referenceVolumeId: string, labelmapVolumeId: string, options?: GrowCutOptions): Promise<void>;
+export { runGrowCut as default, runGrowCut as run };
+export type { GrowCutOptions };