@cornerstonejs/tools 2.0.0-beta.3 → 2.0.0-beta.30

package/dist/esm/tools/segmentation/strategies/BrushStrategy.js

@@ -0,0 +1,142 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
+import compositions from './compositions';
+import { getStrategyData } from './utils/getStrategyData';
+import { StrategyCallbacks } from '../../../enums';
+const { VoxelManager } = csUtils;
+export default class BrushStrategy {
+    static { this.COMPOSITIONS = compositions; }
+    static { this.childFunctions = {
+        [StrategyCallbacks.OnInteractionStart]: addListMethod(StrategyCallbacks.OnInteractionStart, StrategyCallbacks.Initialize),
+        [StrategyCallbacks.OnInteractionEnd]: addListMethod(StrategyCallbacks.OnInteractionEnd, StrategyCallbacks.Initialize),
+        [StrategyCallbacks.Fill]: addListMethod(StrategyCallbacks.Fill),
+        [StrategyCallbacks.Initialize]: addListMethod(StrategyCallbacks.Initialize),
+        [StrategyCallbacks.CreateIsInThreshold]: addSingletonMethod(StrategyCallbacks.CreateIsInThreshold),
+        [StrategyCallbacks.AcceptPreview]: addListMethod(StrategyCallbacks.AcceptPreview, StrategyCallbacks.Initialize),
+        [StrategyCallbacks.RejectPreview]: addListMethod(StrategyCallbacks.RejectPreview, StrategyCallbacks.Initialize),
+        [StrategyCallbacks.INTERNAL_setValue]: addSingletonMethod(StrategyCallbacks.INTERNAL_setValue),
+        [StrategyCallbacks.Preview]: addSingletonMethod(StrategyCallbacks.Preview, false),
+        [StrategyCallbacks.ComputeInnerCircleRadius]: addListMethod(StrategyCallbacks.ComputeInnerCircleRadius),
+        compositions: null,
+    }; }
+    constructor(name, ...initializers) {
+        this._initialize = [];
+        this._fill = [];
+        this._onInteractionStart = [];
+        this.fill = (enabledElement, operationData) => {
+            const initializedData = this.initialize(enabledElement, operationData, StrategyCallbacks.Fill);
+            if (!initializedData) {
+                return;
+            }
+            const { strategySpecificConfiguration = {}, centerIJK } = initializedData;
+            if (csUtils.isEqual(centerIJK, strategySpecificConfiguration.centerIJK)) {
+                return operationData.preview;
+            }
+            else {
+                strategySpecificConfiguration.centerIJK = centerIJK;
+            }
+            this._fill.forEach((func) => func(initializedData));
+            const { segmentationVoxelManager, previewVoxelManager, previewSegmentIndex, } = initializedData;
+            triggerSegmentationDataModified(initializedData.segmentationId, segmentationVoxelManager.getArrayOfModifiedSlices());
+            if (!previewSegmentIndex || !previewVoxelManager.modifiedSlices.size) {
+                segmentationVoxelManager.resetModifiedSlices();
+                return null;
+            }
+            return initializedData.preview || initializedData;
+        };
+        this.onInteractionStart = (enabledElement, operationData) => {
+            const { preview } = operationData;
+            if (preview?.isPreviewFromHover) {
+                preview.isPreviewFromHover = false;
+                return;
+            }
+            const initializedData = this.initialize(enabledElement, operationData);
+            if (!initializedData) {
+                return;
+            }
+            this._onInteractionStart.forEach((func) => func.call(this, initializedData));
+        };
+        this.configurationName = name;
+        this.compositions = initializers;
+        initializers.forEach((initializer) => {
+            const result = typeof initializer === 'function' ? initializer() : initializer;
+            if (!result) {
+                return;
+            }
+            for (const key in result) {
+                if (!BrushStrategy.childFunctions[key]) {
+                    throw new Error(`Didn't find ${key} as a brush strategy`);
+                }
+                BrushStrategy.childFunctions[key](this, result[key]);
+            }
+        });
+        this.strategyFunction = (enabledElement, operationData) => {
+            return this.fill(enabledElement, operationData);
+        };
+        for (const key of Object.keys(BrushStrategy.childFunctions)) {
+            this.strategyFunction[key] = this[key];
+        }
+    }
+    initialize(enabledElement, operationData, operationName) {
+        const { viewport } = enabledElement;
+        const data = getStrategyData({ operationData, viewport });
+        if (!data) {
+            console.warn('No data found for BrushStrategy');
+            return operationData.preview;
+        }
+        const { imageVoxelManager, segmentationVoxelManager, segmentationImageData, } = data;
+        const segmentationVoxelManagerToUse = operationData.override?.voxelManager || segmentationVoxelManager;
+        const segmentationImageDataToUse = operationData.override?.imageData || segmentationImageData;
+        const previewVoxelManager = operationData.preview?.previewVoxelManager ||
+            VoxelManager.createHistoryVoxelManager({
+                sourceVoxelManager: segmentationVoxelManagerToUse,
+            });
+        const previewEnabled = !!operationData.previewColors;
+        const previewSegmentIndex = previewEnabled ? 255 : undefined;
+        const initializedData = {
+            operationName,
+            previewSegmentIndex,
+            ...operationData,
+            enabledElement,
+            imageVoxelManager,
+            segmentationVoxelManager: segmentationVoxelManagerToUse,
+            segmentationImageData: segmentationImageDataToUse,
+            previewVoxelManager,
+            viewport,
+            centerWorld: null,
+            isInObject: null,
+            isInObjectBoundsIJK: null,
+            brushStrategy: this,
+        };
+        this._initialize.forEach((func) => func(initializedData));
+        return initializedData;
+    }
+}
+function addListMethod(name, createInitialized) {
+    const listName = `_${name}`;
+    return (brushStrategy, func) => {
+        brushStrategy[listName] ||= [];
+        brushStrategy[listName].push(func);
+        brushStrategy[name] ||= createInitialized
+            ? (enabledElement, operationData) => {
+                const initializedData = brushStrategy[createInitialized](enabledElement, operationData, name);
+                brushStrategy[listName].forEach((func) => func.call(brushStrategy, initializedData));
+            }
+            : (operationData) => {
+                brushStrategy[listName].forEach((func) => func.call(brushStrategy, operationData));
+            };
+    };
+}
+function addSingletonMethod(name, isInitialized = true) {
+    return (brushStrategy, func) => {
+        if (brushStrategy[name]) {
+            throw new Error(`The singleton method ${name} already exists`);
+        }
+        brushStrategy[name] = isInitialized
+            ? func
+            : (enabledElement, operationData) => {
+                operationData.enabledElement = enabledElement;
+                return func.call(brushStrategy, operationData);
+            };
+    };
+}

package/dist/esm/tools/segmentation/strategies/compositions/determineSegmentIndex.d.ts

@@ -0,0 +1,6 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+declare const _default: {
+    initialize: (operationData: InitializedOperationData) => void;
+    onInteractionStart: (operationData: InitializedOperationData) => void;
+};
+export default _default;

package/dist/esm/tools/segmentation/strategies/compositions/determineSegmentIndex.js

@@ -0,0 +1,49 @@
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+export default {
+    [StrategyCallbacks.Initialize]: (operationData) => {
+        const { strategySpecificConfiguration } = operationData;
+        if (!strategySpecificConfiguration) {
+            return;
+        }
+        const { centerSegmentIndex } = strategySpecificConfiguration;
+        if (centerSegmentIndex) {
+            operationData.segmentIndex = centerSegmentIndex.segmentIndex;
+        }
+    },
+    [StrategyCallbacks.OnInteractionStart]: (operationData) => {
+        const { segmentIndex, previewSegmentIndex, segmentationVoxelManager, centerIJK, strategySpecificConfiguration, imageVoxelManager, segmentationImageData, preview, } = operationData;
+        if (!strategySpecificConfiguration?.useCenterSegmentIndex) {
+            return;
+        }
+        delete strategySpecificConfiguration.centerSegmentIndex;
+        let hasSegmentIndex = false;
+        let hasPreviewIndex = false;
+        const callback = ({ value }) => {
+            hasSegmentIndex ||= value === segmentIndex;
+            hasPreviewIndex ||= value === previewSegmentIndex;
+        };
+        imageVoxelManager.forEach(callback, {
+            imageData: segmentationImageData,
+            isInObject: operationData.isInObject,
+        });
+        if (!hasSegmentIndex && !hasPreviewIndex) {
+            return;
+        }
+        let existingValue = segmentationVoxelManager.getAtIJKPoint(centerIJK);
+        if (existingValue === previewSegmentIndex) {
+            if (preview) {
+                existingValue = preview.segmentIndex;
+            }
+            else {
+                return;
+            }
+        }
+        else if (hasPreviewIndex) {
+            existingValue = null;
+        }
+        operationData.segmentIndex = existingValue;
+        strategySpecificConfiguration.centerSegmentIndex = {
+            segmentIndex: existingValue,
+        };
+    },
+};

package/dist/esm/tools/segmentation/strategies/compositions/dynamicThreshold.d.ts

@@ -0,0 +1,7 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+declare const _default: {
+    initialize: (operationData: InitializedOperationData) => void;
+    onInteractionStart: (operationData: InitializedOperationData) => void;
+    computeInnerCircleRadius: (operationData: InitializedOperationData) => void;
+};
+export default _default;

package/dist/esm/tools/segmentation/strategies/compositions/dynamicThreshold.js

@@ -0,0 +1,67 @@
+import { vec3 } from 'gl-matrix';
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+export default {
+    [StrategyCallbacks.Initialize]: (operationData) => {
+        const { operationName, centerIJK, strategySpecificConfiguration, segmentationVoxelManager, imageVoxelManager, segmentIndex, } = operationData;
+        const { THRESHOLD } = strategySpecificConfiguration;
+        if (!THRESHOLD?.isDynamic || !centerIJK || !segmentIndex) {
+            return;
+        }
+        if (operationName === StrategyCallbacks.RejectPreview ||
+            operationName === StrategyCallbacks.OnInteractionEnd) {
+            return;
+        }
+        const boundsIJK = segmentationVoxelManager.getBoundsIJK();
+        const { threshold: oldThreshold, dynamicRadius = 0 } = THRESHOLD;
+        const useDelta = oldThreshold ? 0 : dynamicRadius;
+        const nestedBounds = boundsIJK.map((ijk, idx) => {
+            const [min, max] = ijk;
+            return [
+                Math.max(min, centerIJK[idx] - useDelta),
+                Math.min(max, centerIJK[idx] + useDelta),
+            ];
+        });
+        const threshold = oldThreshold || [Infinity, -Infinity];
+        const callback = ({ value }) => {
+            const gray = Array.isArray(value) ? vec3.len(value) : value;
+            threshold[0] = Math.min(gray, threshold[0]);
+            threshold[1] = Math.max(gray, threshold[1]);
+        };
+        imageVoxelManager.forEach(callback, { boundsIJK: nestedBounds });
+        operationData.strategySpecificConfiguration.THRESHOLD.threshold = threshold;
+    },
+    [StrategyCallbacks.OnInteractionStart]: (operationData) => {
+        const { strategySpecificConfiguration, preview } = operationData;
+        if (!strategySpecificConfiguration?.THRESHOLD?.isDynamic && !preview) {
+            return;
+        }
+        strategySpecificConfiguration.THRESHOLD.threshold = null;
+    },
+    [StrategyCallbacks.ComputeInnerCircleRadius]: (operationData) => {
+        const { configuration, viewport } = operationData;
+        const { THRESHOLD: { dynamicRadius = 0 } = {} } = configuration.strategySpecificConfiguration || {};
+        if (dynamicRadius === 0) {
+            return;
+        }
+        const imageData = viewport.getImageData();
+        if (!imageData) {
+            return;
+        }
+        const { spacing } = imageData;
+        const centerCanvas = [
+            viewport.element.clientWidth / 2,
+            viewport.element.clientHeight / 2,
+        ];
+        const radiusInWorld = dynamicRadius * spacing[0];
+        const centerCursorInWorld = viewport.canvasToWorld(centerCanvas);
+        const offSetCenterInWorld = centerCursorInWorld.map((coord) => coord + radiusInWorld);
+        const offSetCenterCanvas = viewport.worldToCanvas(offSetCenterInWorld);
+        const dynamicRadiusInCanvas = Math.abs(centerCanvas[0] - offSetCenterCanvas[0]);
+        const { strategySpecificConfiguration, activeStrategy } = configuration;
+        if (!strategySpecificConfiguration[activeStrategy]) {
+            strategySpecificConfiguration[activeStrategy] = {};
+        }
+        strategySpecificConfiguration[activeStrategy].dynamicRadiusInCanvas =
+            dynamicRadiusInCanvas;
+    },
+};

package/dist/esm/tools/segmentation/strategies/compositions/erase.d.ts

@@ -0,0 +1,5 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+declare const _default: {
+    initialize: (operationData: InitializedOperationData) => void;
+};
+export default _default;

package/dist/esm/tools/segmentation/strategies/compositions/erase.js

@@ -0,0 +1,6 @@
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+export default {
+    [StrategyCallbacks.Initialize]: (operationData) => {
+        operationData.segmentIndex = 0;
+    },
+};

package/dist/esm/tools/segmentation/strategies/compositions/index.d.ts

@@ -0,0 +1,36 @@
+declare const _default: {
+    determineSegmentIndex: {
+        initialize: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
+        onInteractionStart: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
+    };
+    dynamicThreshold: {
+        initialize: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
+        onInteractionStart: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
+        computeInnerCircleRadius: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
+    };
+    erase: {
+        initialize: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
+    };
+    islandRemoval: {
+        onInteractionEnd: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
+    };
+    preview: {
+        preview: (operationData: import("../BrushStrategy").InitializedOperationData) => any;
+        initialize: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
+        acceptPreview: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
+        rejectPreview: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
+    };
+    regionFill: {
+        fill: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
+    };
+    setValue: {
+        setValue: (operationData: import("../BrushStrategy").InitializedOperationData, { value, index }: {
+            value: any;
+            index: any;
+        }) => void;
+    };
+    threshold: {
+        createIsInThreshold: (operationData: import("../BrushStrategy").InitializedOperationData) => (index: any) => boolean;
+    };
+};
+export default _default;

package/dist/esm/tools/segmentation/strategies/compositions/index.js

@@ -0,0 +1,18 @@
+import determineSegmentIndex from './determineSegmentIndex';
+import dynamicThreshold from './dynamicThreshold';
+import erase from './erase';
+import islandRemoval from './islandRemoval';
+import preview from './preview';
+import regionFill from './regionFill';
+import setValue from './setValue';
+import threshold from './threshold';
+export default {
+    determineSegmentIndex,
+    dynamicThreshold,
+    erase,
+    islandRemoval,
+    preview,
+    regionFill,
+    setValue,
+    threshold,
+};

package/dist/esm/tools/segmentation/strategies/compositions/islandRemoval.d.ts

@@ -0,0 +1,5 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+declare const _default: {
+    onInteractionEnd: (operationData: InitializedOperationData) => void;
+};
+export default _default;

package/dist/esm/tools/segmentation/strategies/compositions/islandRemoval.js

@@ -0,0 +1,123 @@
+import floodFill from '../../../../utilities/segmentation/floodFill';
+import { triggerSegmentationDataModified } from '../../../../stateManagement/segmentation/triggerSegmentationEvents';
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+export default {
+    [StrategyCallbacks.OnInteractionEnd]: (operationData) => {
+        const { previewVoxelManager: previewVoxelManager, segmentationVoxelManager, strategySpecificConfiguration, previewSegmentIndex, segmentIndex, } = operationData;
+        if (!strategySpecificConfiguration.THRESHOLD || segmentIndex === null) {
+            return;
+        }
+        const clickedPoints = previewVoxelManager.getPoints();
+        if (!clickedPoints?.length) {
+            return;
+        }
+        if (previewSegmentIndex === undefined) {
+            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] > 65535)) {
+            return;
+        }
+        const floodedSet = new Set();
+        const getter = (i, j, k) => {
+            if (i < boundsIJK[0][0] ||
+                i > boundsIJK[0][1] ||
+                j < boundsIJK[1][0] ||
+                j > boundsIJK[1][1] ||
+                k < boundsIJK[2][0] ||
+                k > boundsIJK[2][1]) {
+                return -1;
+            }
+            const index = segmentationVoxelManager.toIndex([i, j, k]);
+            if (floodedSet.has(index)) {
+                return -2;
+            }
+            const oldVal = segmentationVoxelManager.getAtIndex(index);
+            const isIn = oldVal === previewSegmentIndex || oldVal === segmentIndex ? 1 : 0;
+            if (!isIn) {
+                segmentationVoxelManager.addPoint(index);
+            }
+            return isIn;
+        };
+        let floodedCount = 0;
+        const onFlood = (i, j, k) => {
+            const index = segmentationVoxelManager.toIndex([i, j, k]);
+            if (floodedSet.has(index)) {
+                return;
+            }
+            previewVoxelManager.setAtIJK(i, j, k, previewSegmentIndex);
+            floodedSet.add(index);
+            floodedCount++;
+        };
+        clickedPoints.forEach((clickedPoint) => {
+            if (getter(...clickedPoint) === 1) {
+                floodFill(getter, clickedPoint, {
+                    onFlood,
+                    diagonals: true,
+                });
+            }
+        });
+        let clearedCount = 0;
+        let previewCount = 0;
+        const callback = ({ index, pointIJK, value: trackValue }) => {
+            const value = segmentationVoxelManager.getAtIndex(index);
+            if (floodedSet.has(index)) {
+                previewCount++;
+                const newValue = trackValue === segmentIndex ? segmentIndex : previewSegmentIndex;
+                previewVoxelManager.setAtIJKPoint(pointIJK, newValue);
+            }
+            else if (value === previewSegmentIndex) {
+                clearedCount++;
+                const newValue = trackValue ?? 0;
+                previewVoxelManager.setAtIJKPoint(pointIJK, newValue);
+            }
+        };
+        previewVoxelManager.forEach(callback, {});
+        if (floodedCount - previewCount !== 0) {
+            console.warn('There were flooded=', floodedCount, 'cleared=', clearedCount, 'preview count=', previewCount, 'not handled', floodedCount - previewCount);
+        }
+        const islandMap = new Set(segmentationVoxelManager.points || []);
+        floodedSet.clear();
+        for (const index of islandMap.keys()) {
+            if (floodedSet.has(index)) {
+                continue;
+            }
+            let isInternal = true;
+            const internalSet = new Set();
+            const onFloodInternal = (i, j, k) => {
+                const floodIndex = previewVoxelManager.toIndex([i, j, k]);
+                floodedSet.add(floodIndex);
+                if ((boundsIJK[0][0] !== boundsIJK[0][1] &&
+                    (i === boundsIJK[0][0] || i === boundsIJK[0][1])) ||
+                    (boundsIJK[1][0] !== boundsIJK[1][1] &&
+                        (j === boundsIJK[1][0] || j === boundsIJK[1][1])) ||
+                    (boundsIJK[2][0] !== boundsIJK[2][1] &&
+                        (k === boundsIJK[2][0] || k === boundsIJK[2][1]))) {
+                    isInternal = false;
+                }
+                if (isInternal) {
+                    internalSet.add(floodIndex);
+                }
+            };
+            const pointIJK = previewVoxelManager.toIJK(index);
+            if (getter(...pointIJK) !== 0) {
+                continue;
+            }
+            floodFill(getter, pointIJK, {
+                onFlood: onFloodInternal,
+                diagonals: false,
+            });
+            if (isInternal) {
+                for (const index of internalSet) {
+                    previewVoxelManager.setAtIndex(index, previewSegmentIndex);
+                }
+            }
+        }
+        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices());
+    },
+};

package/dist/esm/tools/segmentation/strategies/compositions/preview.d.ts

@@ -0,0 +1,8 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+declare const _default: {
+    preview: (operationData: InitializedOperationData) => any;
+    initialize: (operationData: InitializedOperationData) => void;
+    acceptPreview: (operationData: InitializedOperationData) => void;
+    rejectPreview: (operationData: InitializedOperationData) => void;
+};
+export default _default;

package/dist/esm/tools/segmentation/strategies/compositions/preview.js

@@ -0,0 +1,84 @@
+import { triggerSegmentationDataModified } from '../../../../stateManagement/segmentation/events/triggerSegmentationDataModified';
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+import { getSegmentIndexColor, setSegmentIndexColor, } from '../../../../stateManagement/segmentation/config/segmentationColor';
+function lightenColor(r, g, b, a, factor = 0.4) {
+    return [
+        Math.round(r + (255 - r) * factor),
+        Math.round(g + (255 - g) * factor),
+        Math.round(b + (255 - b) * factor),
+        a,
+    ];
+}
+export default {
+    [StrategyCallbacks.Preview]: function (operationData) {
+        const { previewColors, strategySpecificConfiguration, enabledElement } = operationData;
+        if (!previewColors || !strategySpecificConfiguration) {
+            return;
+        }
+        if (operationData.preview) {
+            delete operationData.preview;
+        }
+        delete strategySpecificConfiguration.centerSegmentIndex;
+        this.onInteractionStart?.(enabledElement, operationData);
+        const preview = this.fill(enabledElement, operationData);
+        if (preview) {
+            preview.isPreviewFromHover = true;
+            operationData.preview = preview;
+            this.onInteractionEnd?.(enabledElement, operationData);
+        }
+        return preview;
+    },
+    [StrategyCallbacks.Initialize]: (operationData) => {
+        const { segmentIndex, previewSegmentIndex, previewColors, preview } = operationData;
+        if (previewColors === undefined) {
+            return;
+        }
+        if (preview) {
+            preview.previewVoxelManager.sourceVoxelManager =
+                operationData.segmentationVoxelManager;
+            operationData.previewVoxelManager = preview.previewVoxelManager;
+        }
+        if (segmentIndex === null || !previewSegmentIndex) {
+            return;
+        }
+        const configColor = previewColors?.[segmentIndex];
+        const segmentColor = getSegmentIndexColor(operationData.viewport.id, operationData.segmentationId, segmentIndex);
+        if (!configColor && !segmentColor) {
+            return;
+        }
+        const previewColor = configColor || lightenColor(...segmentColor);
+        setSegmentIndexColor(operationData.viewport.id, operationData.segmentationId, previewSegmentIndex, previewColor);
+    },
+    [StrategyCallbacks.AcceptPreview]: (operationData) => {
+        const { segmentationVoxelManager, previewVoxelManager: previewVoxelManager, previewSegmentIndex, preview, } = operationData || {};
+        if (previewSegmentIndex === undefined) {
+            return;
+        }
+        const segmentIndex = preview?.segmentIndex ?? operationData.segmentIndex;
+        const tracking = previewVoxelManager;
+        if (!tracking || tracking.modifiedSlices.size === 0) {
+            return;
+        }
+        const callback = ({ index }) => {
+            const oldValue = segmentationVoxelManager.getAtIndex(index);
+            if (oldValue === previewSegmentIndex) {
+                segmentationVoxelManager.setAtIndex(index, segmentIndex);
+            }
+        };
+        tracking.forEach(callback, {});
+        triggerSegmentationDataModified(operationData.segmentationId, tracking.getArrayOfModifiedSlices());
+        tracking.clear();
+    },
+    [StrategyCallbacks.RejectPreview]: (operationData) => {
+        const { previewVoxelManager: previewVoxelManager, segmentationVoxelManager, } = operationData;
+        if (previewVoxelManager.modifiedSlices.size === 0) {
+            return;
+        }
+        const callback = ({ index, value }) => {
+            segmentationVoxelManager.setAtIndex(index, value);
+        };
+        previewVoxelManager.forEach(callback);
+        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices());
+        previewVoxelManager.clear();
+    },
+};

package/dist/esm/tools/segmentation/strategies/compositions/regionFill.d.ts

@@ -0,0 +1,5 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+declare const _default: {
+    fill: (operationData: InitializedOperationData) => void;
+};
+export default _default;

package/dist/esm/tools/segmentation/strategies/compositions/regionFill.js

@@ -0,0 +1,23 @@
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+export default {
+    [StrategyCallbacks.Fill]: (operationData) => {
+        const { segmentsLocked, segmentationImageData, segmentationVoxelManager, previewVoxelManager: previewVoxelManager, brushStrategy, centerIJK, } = operationData;
+        const isWithinThreshold = brushStrategy.createIsInThreshold?.(operationData);
+        const { setValue } = brushStrategy;
+        const callback = isWithinThreshold
+            ? (data) => {
+                const { value, index } = data;
+                if (segmentsLocked.includes(value) || !isWithinThreshold(index)) {
+                    return;
+                }
+                setValue(operationData, data);
+            }
+            : (data) => setValue(operationData, data);
+        segmentationVoxelManager.forEach(callback, {
+            imageData: segmentationImageData,
+            isInObject: operationData.isInObject,
+            boundsIJK: operationData.isInObjectBoundsIJK,
+        });
+        previewVoxelManager.addPoint(centerIJK);
+    },
+};

package/dist/esm/tools/segmentation/strategies/compositions/setValue.d.ts

@@ -0,0 +1,8 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+declare const _default: {
+    setValue: (operationData: InitializedOperationData, { value, index }: {
+        value: any;
+        index: any;
+    }) => void;
+};
+export default _default;

package/dist/esm/tools/segmentation/strategies/compositions/setValue.js

@@ -0,0 +1,29 @@
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+import { triggerEvent, eventTarget } from '@cornerstonejs/core';
+export default {
+    [StrategyCallbacks.INTERNAL_setValue]: (operationData, { value, index }) => {
+        const { segmentsLocked, segmentIndex, previewVoxelManager, previewSegmentIndex, segmentationVoxelManager, } = operationData;
+        const existingValue = segmentationVoxelManager.getAtIndex(index);
+        let changed = false;
+        if (segmentIndex === null) {
+            const oldValue = previewVoxelManager.getAtIndex(index);
+            if (oldValue !== undefined) {
+                changed = previewVoxelManager.setAtIndex(index, oldValue);
+            }
+            return;
+        }
+        if (existingValue === segmentIndex || segmentsLocked.includes(value)) {
+            return;
+        }
+        if (existingValue === previewSegmentIndex) {
+            if (previewVoxelManager.getAtIndex(index) === undefined) {
+                changed = segmentationVoxelManager.setAtIndex(index, segmentIndex);
+            }
+            else {
+                return;
+            }
+        }
+        const useSegmentIndex = previewSegmentIndex ?? segmentIndex;
+        changed = previewVoxelManager.setAtIndex(index, useSegmentIndex);
+    },
+};

package/dist/esm/tools/segmentation/strategies/compositions/threshold.d.ts

@@ -0,0 +1,5 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+declare const _default: {
+    createIsInThreshold: (operationData: InitializedOperationData) => (index: any) => boolean;
+};
+export default _default;