@cornerstonejs/tools 3.0.2 → 3.0.4

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

@@ -0,0 +1,176 @@
+import { vec3 } from 'gl-matrix';
+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;
+const SUBVOLUME_PADDING_PERCENTAGE = 0.2;
+const SUBVOLUME_MIN_PADDING = 5;
+function _createSubVolume(referencedVolume, positiveRegionData, options) {
+    const { dimensions } = referencedVolume;
+    const positiveRegionSize = vec3.sub(vec3.create(), positiveRegionData.boundingBox.bottomRight, positiveRegionData.boundingBox.topLeft);
+    let subVolumePaddingPercentage = options?.subVolumePaddingPercentage ?? SUBVOLUME_PADDING_PERCENTAGE;
+    let subVolumeMinPadding = options?.subVolumeMinPadding ?? SUBVOLUME_MIN_PADDING;
+    if (typeof subVolumePaddingPercentage === 'number') {
+        subVolumePaddingPercentage = [
+            subVolumePaddingPercentage,
+            subVolumePaddingPercentage,
+            subVolumePaddingPercentage,
+        ];
+    }
+    if (typeof subVolumeMinPadding === 'number') {
+        subVolumeMinPadding = [
+            subVolumeMinPadding,
+            subVolumeMinPadding,
+            subVolumeMinPadding,
+        ];
+    }
+    const padding = vec3.mul(vec3.create(), positiveRegionSize, subVolumePaddingPercentage);
+    vec3.round(padding, padding);
+    vec3.max(padding, padding, subVolumeMinPadding);
+    const subVolumeSize = vec3.scaleAndAdd(vec3.create(), positiveRegionSize, padding, 2);
+    const ijkTopLeft = vec3.sub(vec3.create(), positiveRegionData.boundingBox.topLeft, padding);
+    const ijkBottomRight = vec3.add(vec3.create(), ijkTopLeft, subVolumeSize);
+    vec3.max(ijkTopLeft, ijkTopLeft, [0, 0, 0]);
+    vec3.min(ijkTopLeft, ijkTopLeft, dimensions);
+    vec3.max(ijkBottomRight, ijkBottomRight, [0, 0, 0]);
+    vec3.min(ijkBottomRight, ijkBottomRight, dimensions);
+    const subVolumeBoundsIJK = {
+        minX: ijkTopLeft[0],
+        maxX: ijkBottomRight[0],
+        minY: ijkTopLeft[1],
+        maxY: ijkBottomRight[1],
+        minZ: ijkTopLeft[2],
+        maxZ: ijkBottomRight[2],
+    };
+    return csUtils.createSubVolume(referencedVolume.volumeId, subVolumeBoundsIJK, {
+        targetBuffer: {
+            type: 'Float32Array',
+        },
+    });
+}
+function _getPositiveRegionData(referencedVolume, worldPosition, options) {
+    const [width, height, numSlices] = referencedVolume.dimensions;
+    const subVolPixelData = referencedVolume.voxelManager.getCompleteScalarDataArray();
+    const numPixelsPerSlice = width * height;
+    const ijkStartPosition = transformWorldToIndex(referencedVolume.imageData, worldPosition);
+    const referencePixelValue = subVolPixelData[ijkStartPosition[2] * numPixelsPerSlice +
+        ijkStartPosition[1] * width +
+        ijkStartPosition[0]];
+    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],
+    ];
+    let minX = Infinity;
+    let minY = Infinity;
+    let minZ = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    let maxZ = -Infinity;
+    const startVoxelIndex = ijkStartPosition[2] * numPixelsPerSlice +
+        ijkStartPosition[1] * width +
+        ijkStartPosition[0];
+    const voxelIndexesSet = new Set([startVoxelIndex]);
+    const worldVoxelSet = new Set([worldPosition]);
+    const queue = [ijkStartPosition];
+    while (queue.length) {
+        const ijkVoxel = queue.shift();
+        const [x, y, z] = ijkVoxel;
+        minX = ijkVoxel[0] < minX ? ijkVoxel[0] : minX;
+        minY = ijkVoxel[1] < minY ? ijkVoxel[1] : minY;
+        minZ = ijkVoxel[2] < minZ ? ijkVoxel[2] : minZ;
+        maxX = ijkVoxel[0] > maxX ? ijkVoxel[0] : maxX;
+        maxY = ijkVoxel[1] > maxY ? ijkVoxel[1] : maxY;
+        maxZ = ijkVoxel[2] > maxZ ? ijkVoxel[2] : maxZ;
+        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 = subVolPixelData[neighborVoxelIndex];
+            if (voxelIndexesSet.has(neighborVoxelIndex) ||
+                neighborPixelValue < minPositivePixelValue ||
+                neighborPixelValue > maxPositivePixelValue) {
+                continue;
+            }
+            const ijkVoxel = [nx, ny, nz];
+            const worldVoxel = transformIndexToWorld(referencedVolume.imageData, ijkVoxel);
+            voxelIndexesSet.add(neighborVoxelIndex);
+            worldVoxelSet.add(worldVoxel);
+            queue.push(ijkVoxel);
+        }
+    }
+    return {
+        worldVoxels: Array.from(worldVoxelSet),
+        boundingBox: {
+            topLeft: [minX, minY, minZ],
+            bottomRight: [maxX, maxY, maxZ],
+        },
+    };
+}
+function _setPositiveSeedValues(labelmap, positiveRegionData, options) {
+    const { dimensions } = labelmap;
+    const [width, height] = dimensions;
+    const numPixelsPerSlice = width * height;
+    const positiveSeedValue = options.positiveSeedValue ?? POSITIVE_SEED_VALUE;
+    const { worldVoxels } = positiveRegionData;
+    for (let i = 0, len = worldVoxels.length; i < len; i++) {
+        const worldVoxel = worldVoxels[i];
+        const ijkVoxel = transformWorldToIndex(labelmap.imageData, worldVoxel);
+        const voxelIndex = ijkVoxel[2] * numPixelsPerSlice + ijkVoxel[1] * width + ijkVoxel[0];
+        labelmap.voxelManager.setAtIndex(voxelIndex, positiveSeedValue);
+    }
+}
+function _setNegativeSeedValues(subVolume, labelmap, worldPosition, options) {
+    const [width, height] = subVolume.dimensions;
+    const subVolPixelData = subVolume.voxelManager.getCompleteScalarDataArray();
+    const labelmapData = labelmap.voxelManager.getCompleteScalarDataArray();
+    const ijkPosition = transformWorldToIndex(subVolume.imageData, worldPosition);
+    const referencePixelValue = subVolPixelData[ijkPosition[2] * width * height + ijkPosition[1] * width + ijkPosition[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;
+    for (let i = 0, len = subVolPixelData.length; i < len; i++) {
+        const pixelValue = subVolPixelData[i];
+        if (!labelmapData[i] &&
+            (pixelValue < minNegativePixelValue || pixelValue > maxNegativePixelValue)) {
+            labelmap.voxelManager.setAtIndex(i, negativeSeedValue);
+        }
+    }
+}
+async function _createAndCacheSegmentation(subVolume, positiveRegionData, worldPosition, options) {
+    const labelmap = volumeLoader.createAndCacheDerivedLabelmapVolume(subVolume.volumeId);
+    _setPositiveSeedValues(labelmap, positiveRegionData, options);
+    _setNegativeSeedValues(subVolume, labelmap, worldPosition, options);
+    return labelmap;
+}
+async function runOneClickGrowCut(referencedVolumeId, worldPosition, viewport, options) {
+    const referencedVolume = cache.getVolume(referencedVolumeId);
+    const positiveRegionData = _getPositiveRegionData(referencedVolume, worldPosition, options);
+    const subVolume = _createSubVolume(referencedVolume, positiveRegionData, options);
+    const labelmap = await _createAndCacheSegmentation(subVolume, positiveRegionData, worldPosition, options);
+    await run(subVolume.volumeId, labelmap.volumeId);
+    return labelmap;
+}
+export { runOneClickGrowCut as default, runOneClickGrowCut };

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

@@ -0,0 +1,28 @@
+import thresholdVolumeByRange from './thresholdVolumeByRange';
+import rectangleROIThresholdVolumeByRange from './rectangleROIThresholdVolumeByRange';
+import createMergedLabelmapForIndex from './createMergedLabelmapForIndex';
+import createLabelmapVolumeForViewport from './createLabelmapVolumeForViewport';
+import { triggerSegmentationRender, triggerSegmentationRenderBySegmentationId } from '../../stateManagement/segmentation/SegmentationRenderingEngine';
+import floodFill from './floodFill';
+import { getBrushSizeForToolGroup, setBrushSizeForToolGroup } from './brushSizeForToolGroup';
+import { getBrushThresholdForToolGroup, setBrushThresholdForToolGroup } from './brushThresholdForToolGroup';
+import VolumetricCalculator from './VolumetricCalculator';
+import thresholdSegmentationByRange from './thresholdSegmentationByRange';
+import contourAndFindLargestBidirectional from './contourAndFindLargestBidirectional';
+import createBidirectionalToolData from './createBidirectionalToolData';
+import segmentContourAction from './segmentContourAction';
+import { invalidateBrushCursor } from './invalidateBrushCursor';
+import { getUniqueSegmentIndices } from './getUniqueSegmentIndices';
+import { getSegmentIndexAtWorldPoint } from './getSegmentIndexAtWorldPoint';
+import { getSegmentIndexAtLabelmapBorder } from './getSegmentIndexAtLabelmapBorder';
+import { getHoveredContourSegmentationAnnotation } from './getHoveredContourSegmentationAnnotation';
+import { getBrushToolInstances } from './getBrushToolInstances';
+import * as growCut from './growCut';
+import * as LabelmapMemo from './createLabelmapMemo';
+import IslandRemoval from './islandRemoval';
+import getOrCreateSegmentationVolume from './getOrCreateSegmentationVolume';
+import getStatistics from './getStatistics';
+import * as validateLabelmap from './validateLabelmap';
+import { computeStackLabelmapFromVolume } from '../../stateManagement/segmentation/helpers/computeStackLabelmapFromVolume';
+import { computeVolumeLabelmapFromStack } from '../../stateManagement/segmentation/helpers/computeVolumeLabelmapFromStack';
+export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, VolumetricCalculator, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, growCut, LabelmapMemo, IslandRemoval, getOrCreateSegmentationVolume, getStatistics, validateLabelmap, computeStackLabelmapFromVolume, computeVolumeLabelmapFromStack, };

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

@@ -0,0 +1,28 @@
+import thresholdVolumeByRange from './thresholdVolumeByRange';
+import rectangleROIThresholdVolumeByRange from './rectangleROIThresholdVolumeByRange';
+import createMergedLabelmapForIndex from './createMergedLabelmapForIndex';
+import createLabelmapVolumeForViewport from './createLabelmapVolumeForViewport';
+import { triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, } from '../../stateManagement/segmentation/SegmentationRenderingEngine';
+import floodFill from './floodFill';
+import { getBrushSizeForToolGroup, setBrushSizeForToolGroup, } from './brushSizeForToolGroup';
+import { getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, } from './brushThresholdForToolGroup';
+import VolumetricCalculator from './VolumetricCalculator';
+import thresholdSegmentationByRange from './thresholdSegmentationByRange';
+import contourAndFindLargestBidirectional from './contourAndFindLargestBidirectional';
+import createBidirectionalToolData from './createBidirectionalToolData';
+import segmentContourAction from './segmentContourAction';
+import { invalidateBrushCursor } from './invalidateBrushCursor';
+import { getUniqueSegmentIndices } from './getUniqueSegmentIndices';
+import { getSegmentIndexAtWorldPoint } from './getSegmentIndexAtWorldPoint';
+import { getSegmentIndexAtLabelmapBorder } from './getSegmentIndexAtLabelmapBorder';
+import { getHoveredContourSegmentationAnnotation } from './getHoveredContourSegmentationAnnotation';
+import { getBrushToolInstances } from './getBrushToolInstances';
+import * as growCut from './growCut';
+import * as LabelmapMemo from './createLabelmapMemo';
+import IslandRemoval from './islandRemoval';
+import getOrCreateSegmentationVolume from './getOrCreateSegmentationVolume';
+import getStatistics from './getStatistics';
+import * as validateLabelmap from './validateLabelmap';
+import { computeStackLabelmapFromVolume } from '../../stateManagement/segmentation/helpers/computeStackLabelmapFromVolume';
+import { computeVolumeLabelmapFromStack } from '../../stateManagement/segmentation/helpers/computeVolumeLabelmapFromStack';
+export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, VolumetricCalculator, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, growCut, LabelmapMemo, IslandRemoval, getOrCreateSegmentationVolume, getStatistics, validateLabelmap, computeStackLabelmapFromVolume, computeVolumeLabelmapFromStack, };

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

@@ -0,0 +1 @@
+export declare function invalidateBrushCursor(toolGroupId: string): void;

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

@@ -0,0 +1,20 @@
+import { getToolGroup } from '../../store/ToolGroupManager';
+import triggerAnnotationRenderForViewportIds from '../triggerAnnotationRenderForViewportIds';
+import { getBrushToolInstances } from './getBrushToolInstances';
+export function invalidateBrushCursor(toolGroupId) {
+    const toolGroup = getToolGroup(toolGroupId);
+    if (toolGroup === undefined) {
+        return;
+    }
+    const brushBasedToolInstances = getBrushToolInstances(toolGroupId);
+    brushBasedToolInstances.forEach((tool) => {
+        tool.invalidateBrushCursor();
+    });
+    const viewportsInfo = toolGroup.getViewportsInfo();
+    const viewportsInfoArray = Object.keys(viewportsInfo).map((key) => viewportsInfo[key]);
+    if (!viewportsInfoArray.length) {
+        return;
+    }
+    const viewportIds = toolGroup.getViewportIds();
+    triggerAnnotationRenderForViewportIds(viewportIds);
+}

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

@@ -0,0 +1,9 @@
+import type { Types } from '@cornerstonejs/core';
+import { vec3 } from 'gl-matrix';
+export default function isLineInSegment(point1: Types.Point3, point2: Types.Point3, isInSegment: any): boolean;
+declare function createIsInSegment(segVolumeId: string, segmentIndex: number, containedSegmentIndices?: Set<number>): {
+    testCenter: (point1: any, point2: any) => boolean;
+    toIJK: (point: any) => vec3;
+    testIJK: (ijk: any) => boolean;
+};
+export { createIsInSegment, isLineInSegment };

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

@@ -0,0 +1,49 @@
+import { cache } from '@cornerstonejs/core';
+import { vec3 } from 'gl-matrix';
+export default function isLineInSegment(point1, point2, isInSegment) {
+    const ijk1 = isInSegment.toIJK(point1);
+    const ijk2 = isInSegment.toIJK(point2);
+    const testPoint = vec3.create();
+    const { testIJK } = isInSegment;
+    const delta = vec3.sub(vec3.create(), ijk1, ijk2);
+    const testSize = Math.round(Math.max(...delta.map(Math.abs)));
+    if (testSize < 2) {
+        return true;
+    }
+    const unitDelta = vec3.scale(vec3.create(), delta, 1 / testSize);
+    for (let i = 1; i < testSize; i++) {
+        vec3.scaleAndAdd(testPoint, ijk2, unitDelta, i);
+        if (!testIJK(testPoint)) {
+            return false;
+        }
+    }
+    return true;
+}
+function createIsInSegment(segVolumeId, segmentIndex, containedSegmentIndices) {
+    const vol = cache.getVolume(segVolumeId);
+    if (!vol) {
+        console.warn(`No volume found for ${segVolumeId}`);
+        return;
+    }
+    const voxelManager = vol.voxelManager;
+    const width = vol.dimensions[0];
+    const pixelsPerSlice = width * vol.dimensions[1];
+    return {
+        testCenter: (point1, point2) => {
+            const point = vec3.add(vec3.create(), point1, point2).map((it) => it / 2);
+            const ijk = vol.imageData.worldToIndex(point).map(Math.round);
+            const [i, j, k] = ijk;
+            const index = i + j * width + k * pixelsPerSlice;
+            const value = voxelManager.getAtIndex(index);
+            return value === segmentIndex || containedSegmentIndices?.has(value);
+        },
+        toIJK: (point) => vol.imageData.worldToIndex(point),
+        testIJK: (ijk) => {
+            const [i, j, k] = ijk;
+            const index = Math.round(i) + Math.round(j) * width + Math.round(k) * pixelsPerSlice;
+            const value = voxelManager.getAtIndex(index);
+            return value === segmentIndex || containedSegmentIndices?.has(value);
+        },
+    };
+}
+export { createIsInSegment, isLineInSegment };

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

@@ -0,0 +1,28 @@
+import type { Types } from '@cornerstonejs/core';
+export declare enum SegmentationEnum {
+    SEGMENT = -1,
+    ISLAND = -2,
+    INTERIOR = -3,
+    EXTERIOR = -4,
+    INTERIOR_SMALL = -5,
+    INTERIOR_TEST = -6
+}
+export default class IslandRemoval {
+    segmentSet: Types.RLEVoxelMap<SegmentationEnum>;
+    segmentIndex: number;
+    fillSegments: (index: number) => boolean;
+    previewVoxelManager: Types.VoxelManager<number>;
+    previewSegmentIndex: number;
+    selectedPoints: Types.Point3[];
+    private fillInternalEdge;
+    private maxInternalRemove;
+    constructor(options?: {
+        maxInternalRemove?: number;
+        fillInternalEdge?: boolean;
+    });
+    initialize(viewport: any, segmentationVoxels: any, options: any): boolean;
+    floodFillSegmentIsland(): number;
+    removeExternalIslands(): void;
+    removeInternalIslands(): number[];
+    static covers(rle: any, row: any): boolean;
+}

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

@@ -0,0 +1,181 @@
+import { utilities } from '@cornerstonejs/core';
+import normalizeViewportPlane from '../normalizeViewportPlane';
+const { RLEVoxelMap, VoxelManager } = utilities;
+const MAX_IMAGE_SIZE = 65535;
+export var SegmentationEnum;
+(function (SegmentationEnum) {
+    SegmentationEnum[SegmentationEnum["SEGMENT"] = -1] = "SEGMENT";
+    SegmentationEnum[SegmentationEnum["ISLAND"] = -2] = "ISLAND";
+    SegmentationEnum[SegmentationEnum["INTERIOR"] = -3] = "INTERIOR";
+    SegmentationEnum[SegmentationEnum["EXTERIOR"] = -4] = "EXTERIOR";
+    SegmentationEnum[SegmentationEnum["INTERIOR_SMALL"] = -5] = "INTERIOR_SMALL";
+    SegmentationEnum[SegmentationEnum["INTERIOR_TEST"] = -6] = "INTERIOR_TEST";
+})(SegmentationEnum || (SegmentationEnum = {}));
+export default class IslandRemoval {
+    constructor(options) {
+        this.fillInternalEdge = false;
+        this.maxInternalRemove = 128;
+        this.maxInternalRemove =
+            options?.maxInternalRemove ?? this.maxInternalRemove;
+        this.fillInternalEdge = options?.fillInternalEdge ?? this.fillInternalEdge;
+    }
+    initialize(viewport, segmentationVoxels, options) {
+        const hasSource = !!segmentationVoxels.sourceVoxelManager;
+        const segmentationVoxelManager = hasSource
+            ? segmentationVoxels.sourceVoxelManager
+            : segmentationVoxels;
+        const previewVoxelManager = hasSource
+            ? segmentationVoxels
+            : VoxelManager.createRLEHistoryVoxelManager(segmentationVoxelManager);
+        const { segmentIndex = 1, previewSegmentIndex = 1 } = options;
+        const clickedPoints = options.points || previewVoxelManager.getPoints();
+        if (!clickedPoints?.length) {
+            return;
+        }
+        const boundsIJK = previewVoxelManager
+            .getBoundsIJK()
+            .map((bound, i) => [
+            Math.min(bound[0], ...clickedPoints.map((point) => point[i])),
+            Math.max(bound[1], ...clickedPoints.map((point) => point[i])),
+        ]);
+        if (boundsIJK.find((it) => it[0] < 0 || it[1] > MAX_IMAGE_SIZE)) {
+            return;
+        }
+        const { toIJK, fromIJK, boundsIJKPrime, error } = normalizeViewportPlane(viewport, boundsIJK);
+        if (error) {
+            console.warn('Not performing island removal for planes not orthogonal to acquisition plane', error);
+            return;
+        }
+        const [width, height, depth] = fromIJK(segmentationVoxelManager.dimensions);
+        const segmentSet = new RLEVoxelMap(width, height, depth);
+        const getter = (i, j, k) => {
+            const index = segmentationVoxelManager.toIndex(toIJK([i, j, k]));
+            const oldVal = segmentationVoxelManager.getAtIndex(index);
+            if (oldVal === previewSegmentIndex || oldVal === segmentIndex) {
+                return SegmentationEnum.SEGMENT;
+            }
+        };
+        segmentSet.fillFrom(getter, boundsIJKPrime);
+        segmentSet.normalizer = { toIJK, fromIJK, boundsIJKPrime };
+        this.segmentSet = segmentSet;
+        this.previewVoxelManager = previewVoxelManager;
+        this.segmentIndex = segmentIndex;
+        this.previewSegmentIndex = previewSegmentIndex ?? segmentIndex;
+        this.selectedPoints = clickedPoints;
+        return true;
+    }
+    floodFillSegmentIsland() {
+        const { selectedPoints: clickedPoints, segmentSet } = this;
+        let floodedCount = 0;
+        const { fromIJK } = segmentSet.normalizer;
+        clickedPoints.forEach((clickedPoint) => {
+            const ijkPrime = fromIJK(clickedPoint);
+            const index = segmentSet.toIndex(ijkPrime);
+            const [iPrime, jPrime, kPrime] = ijkPrime;
+            if (segmentSet.get(index) === SegmentationEnum.SEGMENT) {
+                floodedCount += segmentSet.floodFill(iPrime, jPrime, kPrime, SegmentationEnum.ISLAND);
+            }
+        });
+        return floodedCount;
+    }
+    removeExternalIslands() {
+        const { previewVoxelManager, segmentSet } = this;
+        const { toIJK } = segmentSet.normalizer;
+        const callback = (index, rle) => {
+            const [, jPrime, kPrime] = segmentSet.toIJK(index);
+            if (rle.value !== SegmentationEnum.ISLAND) {
+                for (let iPrime = rle.start; iPrime < rle.end; iPrime++) {
+                    const clearPoint = toIJK([iPrime, jPrime, kPrime]);
+                    const v = previewVoxelManager.getAtIJKPoint(clearPoint);
+                    previewVoxelManager.setAtIJKPoint(clearPoint, v === undefined ? 0 : null);
+                }
+            }
+        };
+        segmentSet.forEach(callback, { rowModified: true });
+    }
+    removeInternalIslands() {
+        const { segmentSet, previewVoxelManager, previewSegmentIndex } = this;
+        const { height, normalizer, width } = segmentSet;
+        const { toIJK } = normalizer;
+        segmentSet.forEachRow((baseIndex, row) => {
+            let lastRle;
+            for (const rle of [...row]) {
+                if (rle.value !== SegmentationEnum.ISLAND) {
+                    continue;
+                }
+                if (!lastRle) {
+                    if (this.fillInternalEdge && rle.start > 0) {
+                        for (let iPrime = 0; iPrime < rle.start; iPrime++) {
+                            segmentSet.set(baseIndex + iPrime, SegmentationEnum.INTERIOR);
+                        }
+                    }
+                    lastRle = rle;
+                    continue;
+                }
+                for (let iPrime = lastRle.end; iPrime < rle.start; iPrime++) {
+                    segmentSet.set(baseIndex + iPrime, SegmentationEnum.INTERIOR);
+                }
+                lastRle = rle;
+            }
+            if (this.fillInternalEdge && lastRle?.end < width) {
+                for (let iPrime = lastRle.end; iPrime < width; iPrime++) {
+                    segmentSet.set(baseIndex + iPrime, SegmentationEnum.INTERIOR);
+                }
+            }
+        });
+        segmentSet.forEach((baseIndex, rle) => {
+            if (rle.value !== SegmentationEnum.INTERIOR) {
+                return;
+            }
+            const [, jPrime, kPrime] = segmentSet.toIJK(baseIndex);
+            const rowPrev = jPrime > 0 ? segmentSet.getRun(jPrime - 1, kPrime) : null;
+            const rowNext = jPrime + 1 < height ? segmentSet.getRun(jPrime + 1, kPrime) : null;
+            const isLast = jPrime === height - 1;
+            const isFirst = jPrime === 0;
+            const prevCovers = IslandRemoval.covers(rle, rowPrev) ||
+                (isFirst && this.fillInternalEdge);
+            const nextCovers = IslandRemoval.covers(rle, rowNext) || (isLast && this.fillInternalEdge);
+            if (rle.end - rle.start > 2 && (!prevCovers || !nextCovers)) {
+                segmentSet.floodFill(rle.start, jPrime, kPrime, SegmentationEnum.EXTERIOR, { singlePlane: true });
+            }
+        });
+        segmentSet.forEach((baseIndex, rle) => {
+            if (rle.value !== SegmentationEnum.INTERIOR) {
+                return;
+            }
+            const [, jPrime, kPrime] = segmentSet.toIJK(baseIndex);
+            const size = segmentSet.floodFill(rle.start, jPrime, kPrime, SegmentationEnum.INTERIOR_TEST);
+            const isBig = size > this.maxInternalRemove;
+            const newType = isBig
+                ? SegmentationEnum.EXTERIOR
+                : SegmentationEnum.INTERIOR_SMALL;
+            segmentSet.floodFill(rle.start, jPrime, kPrime, newType);
+        });
+        segmentSet.forEach((baseIndex, rle) => {
+            if (rle.value !== SegmentationEnum.INTERIOR_SMALL) {
+                return;
+            }
+            for (let iPrime = rle.start; iPrime < rle.end; iPrime++) {
+                const clearPoint = toIJK(segmentSet.toIJK(baseIndex + iPrime));
+                previewVoxelManager.setAtIJKPoint(clearPoint, previewSegmentIndex);
+            }
+        });
+        return previewVoxelManager.getArrayOfModifiedSlices();
+    }
+    static covers(rle, row) {
+        if (!row) {
+            return false;
+        }
+        let { start } = rle;
+        const { end } = rle;
+        for (const rowRle of row) {
+            if (start >= rowRle.start && start < rowRle.end) {
+                start = rowRle.end;
+                if (start >= end) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}

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

@@ -0,0 +1,20 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ThresholdInformation } from './utilities';
+export type ThresholdOptions = {
+    numSlicesToProject?: number;
+    overwrite: boolean;
+    overlapType?: number;
+    segmentIndex?: number;
+};
+export type AnnotationForThresholding = {
+    data: {
+        handles: {
+            points: Types.Point3[];
+        };
+        cachedStats?: {
+            projectionPoints?: Types.Point3[][];
+        };
+    };
+};
+declare function rectangleROIThresholdVolumeByRange(annotationUIDs: string[], segmentationVolume: Types.IImageVolume, thresholdVolumeInformation: ThresholdInformation[], options: ThresholdOptions): Types.IImageVolume;
+export default rectangleROIThresholdVolumeByRange;

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

@@ -0,0 +1,35 @@
+import { state } from '../../stateManagement/annotation';
+import RectangleROIStartEndThresholdTool from '../../tools/segmentation/RectangleROIStartEndThresholdTool';
+import RectangleROIThresholdTool from '../../tools/segmentation/RectangleROIThresholdTool';
+import thresholdVolumeByRange from './thresholdVolumeByRange';
+import getBoundsIJKFromRectangleAnnotations from '../rectangleROITool/getBoundsIJKFromRectangleAnnotations';
+function rectangleROIThresholdVolumeByRange(annotationUIDs, segmentationVolume, thresholdVolumeInformation, options) {
+    const annotations = annotationUIDs.map((annotationUID) => {
+        return state.getAnnotation(annotationUID);
+    });
+    _validateAnnotations(annotations);
+    let boundsIJK;
+    for (let i = 0; i < thresholdVolumeInformation.length; i++) {
+        const volumeSize = thresholdVolumeInformation[i].volume.voxelManager.getScalarDataLength();
+        if (volumeSize === segmentationVolume.voxelManager.getScalarDataLength() ||
+            i === 0) {
+            boundsIJK = getBoundsIJKFromRectangleAnnotations(annotations, thresholdVolumeInformation[i].volume, options);
+        }
+    }
+    const outputSegmentationVolume = thresholdVolumeByRange(segmentationVolume, thresholdVolumeInformation, { ...options, boundsIJK });
+    outputSegmentationVolume.modified();
+    return outputSegmentationVolume;
+}
+function _validateAnnotations(annotations) {
+    const validToolNames = [
+        RectangleROIThresholdTool.toolName,
+        RectangleROIStartEndThresholdTool.toolName,
+    ];
+    for (const annotation of annotations) {
+        const name = annotation.metadata.toolName;
+        if (!validToolNames.includes(name)) {
+            throw new Error('rectangleROIThresholdVolumeByRange only supports RectangleROIThreshold and RectangleROIStartEndThreshold annotations');
+        }
+    }
+}
+export default rectangleROIThresholdVolumeByRange;

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

@@ -0,0 +1,17 @@
+import { type Types } from '@cornerstonejs/core';
+export type Segment = {
+    segmentationId: string;
+    segmentIndex: number;
+    label: string;
+    style?: Record<string, unknown>;
+    containedSegmentIndices?: (number: any) => boolean;
+};
+export type SegmentContourActionConfiguration = {
+    getSegment?: (enabledElement: Types.IEnabledElement, configuration: SegmentContourActionConfiguration) => Segment;
+    segmentationId?: string;
+    segmentIndex?: number;
+    segmentData?: Map<number, Segment>;
+    toolGroupId?: string;
+};
+export default function segmentContourAction(element: HTMLDivElement, configuration: any): any;
+export declare function defaultGetSegment(enabledElement: Types.IEnabledElement, configuration: SegmentContourActionConfiguration): Segment;