@ohif/app 3.8.0-beta.28 → 3.8.0-beta.29

package/dist/{26.bundle.c92012465cee00a2a708.js → 566.bundle.4840518afd323372c70f.js}

@@ -1,6 +1,6 @@
-(self["webpackChunk"] = self["webpackChunk"] || []).push([[26],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[566],{
 
-/***/ 1026:
+/***/ 74566:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -82,6 +82,7 @@ __webpack_require__.d(enums_namespaceObject, {
   KeyboardBindings: () => (KeyboardBindings),
   MouseBindings: () => (MouseBindings),
   SegmentationRepresentations: () => (enums_SegmentationRepresentations),
+  StrategyCallbacks: () => (enums_StrategyCallbacks),
   Swipe: () => (Swipe),
   ToolModes: () => (enums_ToolModes)
 });
@@ -294,7 +295,8 @@ var ellipse_namespaceObject = {};
 __webpack_require__.r(ellipse_namespaceObject);
 __webpack_require__.d(ellipse_namespaceObject, {
   getCanvasEllipseCorners: () => (getCanvasEllipseCorners),
-  pointInEllipse: () => (pointInEllipse)
+  pointInEllipse: () => (pointInEllipse),
+  precalculatePointInEllipse: () => (precalculatePointInEllipse)
 });
 
 // NAMESPACE OBJECT: ../../../node_modules/@cornerstonejs/tools/dist/esm/cursors/index.js
@@ -646,8 +648,8 @@ __webpack_require__.d(synchronizers_namespaceObject, {
 var types_namespaceObject = {};
 __webpack_require__.r(types_namespaceObject);
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 363 modules
-var esm = __webpack_require__(56959);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 364 modules
+var esm = __webpack_require__(27968);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/enums/ToolBindings.js
 var MouseBindings;
 (function (MouseBindings) {
@@ -754,6 +756,22 @@ var Swipe;
 })(Swipe || (Swipe = {}));
 
 
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/enums/StrategyCallbacks.js
+var StrategyCallbacks;
+(function (StrategyCallbacks) {
+    StrategyCallbacks["OnInteractionStart"] = "onInteractionStart";
+    StrategyCallbacks["OnInteractionEnd"] = "onInteractionEnd";
+    StrategyCallbacks["Preview"] = "preview";
+    StrategyCallbacks["RejectPreview"] = "rejectPreview";
+    StrategyCallbacks["AcceptPreview"] = "acceptPreview";
+    StrategyCallbacks["Fill"] = "fill";
+    StrategyCallbacks["StrategyFunction"] = "strategyFunction";
+    StrategyCallbacks["CreateIsInThreshold"] = "createIsInThreshold";
+    StrategyCallbacks["Initialize"] = "initialize";
+    StrategyCallbacks["INTERNAL_setValue"] = "setValue";
+})(StrategyCallbacks || (StrategyCallbacks = {}));
+/* harmony default export */ const enums_StrategyCallbacks = (StrategyCallbacks);
+
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/enums/index.js
 
 
@@ -763,6 +781,7 @@ var Swipe;
 
 
 
+
 // EXTERNAL MODULE: ../../../node_modules/lodash.clonedeep/index.js
 var lodash_clonedeep = __webpack_require__(11677);
 var lodash_clonedeep_default = /*#__PURE__*/__webpack_require__.n(lodash_clonedeep);
@@ -4264,7 +4283,14 @@ function getColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, seg
     }
     const { colorLUTIndex } = segmentationRepresentation;
     const colorLUT = getColorLUT(colorLUTIndex);
-    return colorLUT[segmentIndex];
+    let colorValue = colorLUT[segmentIndex];
+    if (!colorValue) {
+        if (typeof segmentIndex !== 'number') {
+            throw new Error(`Can't create colour for LUT index ${segmentIndex}`);
+        }
+        colorValue = colorLUT[segmentIndex] = [0, 0, 0, 0];
+    }
+    return colorValue;
 }
 function setColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, segmentIndex, color) {
     const colorReference = getColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, segmentIndex);
@@ -4421,7 +4447,11 @@ class BaseTool {
     }
     applyActiveStrategy(enabledElement, operationData) {
         const { strategies, activeStrategy } = this.configuration;
-        return strategies[activeStrategy].call(this, enabledElement, operationData);
+        return strategies[activeStrategy]?.call(this, enabledElement, operationData);
+    }
+    applyActiveStrategyCallback(enabledElement, operationData, callbackType) {
+        const { strategies, activeStrategy } = this.configuration;
+        return strategies[activeStrategy][callbackType]?.call(this, enabledElement, operationData);
     }
     setConfiguration(newConfiguration) {
         this.configuration = esm.utilities.deepMerge(this.configuration, newConfiguration);
@@ -4648,7 +4678,6 @@ function drawCircle(svgDrawingHelper, annotationUID, circleUID, center, radius,
 /* harmony default export */ const drawingSvg_drawCircle = (drawCircle);
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/drawingSvg/drawEllipseByCoordinates.js
-2;
 
 
 
@@ -4666,7 +4695,7 @@ function drawEllipseByCoordinates(svgDrawingHelper, annotationUID, ellipseUID, c
     const [bottom, top, left, right] = canvasCoordinates;
     const w = Math.hypot(left[0] - right[0], left[1] - right[1]);
     const h = Math.hypot(top[0] - bottom[0], top[1] - bottom[1]);
-    const angle = Math.atan2(left[1] - right[1], left[0] - right[0]) * 180 / Math.PI;
+    const angle = (Math.atan2(left[1] - right[1], left[0] - right[0]) * 180) / Math.PI;
     const center = [(left[0] + right[0]) / 2, (top[1] + bottom[1]) / 2];
     const radiusX = w / 2;
     const radiusY = h / 2;
@@ -4677,7 +4706,7 @@ function drawEllipseByCoordinates(svgDrawingHelper, annotationUID, ellipseUID, c
         ry: `${radiusY}`,
         stroke: color,
         fill: 'transparent',
-        'transform': `rotate(${angle} ${center[0]} ${center[1]})`,
+        transform: `rotate(${angle} ${center[0]} ${center[1]})`,
         'stroke-width': strokeWidth,
         'stroke-dasharray': lineDash,
     };
@@ -4703,7 +4732,7 @@ function drawEllipse(svgDrawingHelper, annotationUID, ellipseUID, corner1, corne
     const bottom = [(corner1[0] + corner2[0]) / 2, corner2[1]];
     const left = [corner1[0], (corner1[1] + corner2[1]) / 2];
     const right = [corner2[0], (corner1[1] + corner2[1]) / 2];
-    drawingSvg_drawEllipseByCoordinates(svgDrawingHelper, annotationUID, ellipseUID, [bottom, top, left, right], options = {}, dataId = '');
+    drawingSvg_drawEllipseByCoordinates(svgDrawingHelper, annotationUID, ellipseUID, [bottom, top, left, right], (options = {}), (dataId = ''));
 }
 /* harmony default export */ const drawingSvg_drawEllipse = (drawEllipse);
 
@@ -11706,10 +11735,11 @@ function pointInShapeCallback(imageData, pointInShapeFn, callback, boundsIJK) {
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/sphere/pointInSphere.js
 function pointInSphere(sphere, pointLPS) {
     const { center, radius } = sphere;
+    const radius2 = sphere.radius2 || radius * radius;
     return ((pointLPS[0] - center[0]) * (pointLPS[0] - center[0]) +
         (pointLPS[1] - center[1]) * (pointLPS[1] - center[1]) +
         (pointLPS[2] - center[2]) * (pointLPS[2] - center[2]) <=
-        radius ** 2);
+        radius2);
 }
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/sphere/index.js
@@ -11866,20 +11896,581 @@ function roundNumber(value, precision = 2) {
 }
 /* harmony default export */ const utilities_roundNumber = (roundNumber);
 
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/utils/isWithinThreshold.js
-function isWithinThreshold(index, imageScalarData, strategySpecificConfiguration) {
-    const { THRESHOLD_INSIDE_CIRCLE } = strategySpecificConfiguration;
-    const voxelValue = imageScalarData[index];
-    const { threshold } = THRESHOLD_INSIDE_CIRCLE;
-    return threshold[0] <= voxelValue && voxelValue <= threshold[1];
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/ellipse/pointInEllipse.js
+function pointInEllipse(ellipse, pointLPS, inverts = {}) {
+    if (!inverts.precalculated) {
+        precalculatePointInEllipse(ellipse, inverts);
+    }
+    return inverts.precalculated(pointLPS);
 }
-/* harmony default export */ const utils_isWithinThreshold = (isWithinThreshold);
+const precalculatePointInEllipse = (ellipse, inverts = {}) => {
+    const { xRadius, yRadius, zRadius } = ellipse;
+    if (inverts.invXRadiusSq === undefined ||
+        inverts.invYRadiusSq === undefined ||
+        inverts.invZRadiusSq === undefined) {
+        inverts.invXRadiusSq = xRadius !== 0 ? 1 / xRadius ** 2 : 0;
+        inverts.invYRadiusSq = yRadius !== 0 ? 1 / yRadius ** 2 : 0;
+        inverts.invZRadiusSq = zRadius !== 0 ? 1 / zRadius ** 2 : 0;
+    }
+    const { invXRadiusSq, invYRadiusSq, invZRadiusSq } = inverts;
+    const { center } = ellipse;
+    const [centerL, centerP, centerS] = center;
+    inverts.precalculated = (pointLPS) => {
+        const dx = pointLPS[0] - centerL;
+        let inside = dx * dx * invXRadiusSq;
+        if (inside > 1) {
+            return false;
+        }
+        const dy = pointLPS[1] - centerP;
+        inside += dy * dy * invYRadiusSq;
+        if (inside > 1) {
+            return false;
+        }
+        const dz = pointLPS[2] - centerS;
+        inside += dz * dz * invZRadiusSq;
+        return inside <= 1;
+    };
+    return inverts;
+};
+
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/ellipse/getCanvasEllipseCorners.js
+function getCanvasEllipseCorners(ellipseCanvasPoints) {
+    const [bottom, top, left, right] = ellipseCanvasPoints;
+    const topLeft = [left[0], top[1]];
+    const bottomRight = [right[0], bottom[1]];
+    return [topLeft, bottomRight];
+}
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/ellipse/index.js
+
+
+
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/compositions/determineSegmentIndex.js
+
+
+/* harmony default export */ const determineSegmentIndex = ({
+    [enums_StrategyCallbacks.Initialize]: (operationData) => {
+        const { strategySpecificConfiguration } = operationData;
+        if (!strategySpecificConfiguration) {
+            return;
+        }
+        const { centerSegmentIndex } = strategySpecificConfiguration;
+        if (centerSegmentIndex) {
+            operationData.segmentIndex = centerSegmentIndex.segmentIndex;
+        }
+    },
+    [enums_StrategyCallbacks.OnInteractionStart]: (operationData) => {
+        const { segmentIndex, previewSegmentIndex, segmentationVoxelManager: segmentationVoxelManager, centerIJK, strategySpecificConfiguration, imageVoxelManager: 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;
+        };
+        pointInShapeCallback(segmentationImageData, imageVoxelManager.isInObject, callback, segmentationVoxelManager.boundsIJK);
+        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,
+        };
+    },
+});
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/compositions/dynamicThreshold.js
+
+/* harmony default export */ const dynamicThreshold = ({
+    [enums_StrategyCallbacks.Initialize]: (operationData) => {
+        const { centerIJK, strategySpecificConfiguration, segmentationVoxelManager: segmentationVoxelManager, imageVoxelManager: imageVoxelManager, segmentIndex, } = operationData;
+        const { THRESHOLD } = strategySpecificConfiguration;
+        if (!THRESHOLD?.isDynamic || !centerIJK || !segmentIndex) {
+            return;
+        }
+        const { boundsIJK } = segmentationVoxelManager;
+        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 }) => {
+            threshold[0] = Math.min(value, threshold[0]);
+            threshold[1] = Math.max(value, threshold[1]);
+        };
+        imageVoxelManager.forEach(callback, { boundsIJK: nestedBounds });
+        operationData.strategySpecificConfiguration.THRESHOLD.threshold = threshold;
+    },
+    [enums_StrategyCallbacks.OnInteractionStart]: (operationData) => {
+        const { strategySpecificConfiguration, preview } = operationData;
+        if (!strategySpecificConfiguration?.THRESHOLD?.isDynamic && !preview) {
+            return;
+        }
+        strategySpecificConfiguration.THRESHOLD.threshold = null;
+    },
+});
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/compositions/erase.js
+
+/* harmony default export */ const erase = ({
+    [enums_StrategyCallbacks.Initialize]: (operationData) => {
+        operationData.segmentIndex = 0;
+    },
+});
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/floodFill.js
+function floodFill(getter, seed, options = {}) {
+    const onFlood = options.onFlood;
+    const onBoundary = options.onBoundary;
+    const equals = options.equals || defaultEquals;
+    const diagonals = options.diagonals || false;
+    const startNode = get(seed);
+    const permutations = prunedPermutations();
+    const stack = [];
+    const flooded = [];
+    const visits = {};
+    const bounds = {};
+    stack.push({ currentArgs: seed });
+    while (stack.length > 0) {
+        flood(stack.pop());
+    }
+    return {
+        flooded,
+        boundaries: boundaries(),
+    };
+    function flood(job) {
+        const getArgs = job.currentArgs;
+        const prevArgs = job.previousArgs;
+        if (visited(getArgs)) {
+            return;
+        }
+        markAsVisited(getArgs);
+        if (member(getArgs)) {
+            markAsFlooded(getArgs);
+            pushAdjacent(getArgs);
+        }
+        else {
+            markAsBoundary(prevArgs);
+        }
+    }
+    function visited(key) {
+        return visits[key] === true;
+    }
+    function markAsVisited(key) {
+        visits[key] = true;
+    }
+    function member(getArgs) {
+        const node = safely(get, [getArgs]);
+        return safely(equals, [node, startNode]);
+    }
+    function markAsFlooded(getArgs) {
+        flooded.push(getArgs);
+        if (onFlood) {
+            onFlood(...getArgs);
+        }
+    }
+    function markAsBoundary(prevArgs) {
+        bounds[prevArgs] = prevArgs;
+        if (onBoundary) {
+            onBoundary(...prevArgs);
+        }
+    }
+    function pushAdjacent(getArgs) {
+        for (let i = 0; i < permutations.length; i += 1) {
+            const perm = permutations[i];
+            const nextArgs = getArgs.slice(0);
+            for (let j = 0; j < getArgs.length; j += 1) {
+                nextArgs[j] += perm[j];
+            }
+            stack.push({
+                currentArgs: nextArgs,
+                previousArgs: getArgs,
+            });
+        }
+    }
+    function get(getArgs) {
+        return getter(...getArgs);
+    }
+    function safely(f, args) {
+        try {
+            return f(...args);
+        }
+        catch (error) {
+            return;
+        }
+    }
+    function prunedPermutations() {
+        const permutations = permute(seed.length);
+        return permutations.filter(function (perm) {
+            const count = countNonZeroes(perm);
+            return count !== 0 && (count === 1 || diagonals);
+        });
+    }
+    function permute(length) {
+        const perms = [];
+        const permutation = function (string) {
+            return string.split('').map(function (c) {
+                return parseInt(c, 10) - 1;
+            });
+        };
+        for (let i = 0; i < Math.pow(3, length); i += 1) {
+            const string = lpad(i.toString(3), '0', length);
+            perms.push(permutation(string));
+        }
+        return perms;
+    }
+    function boundaries() {
+        const array = [];
+        for (const key in bounds) {
+            if (bounds[key] !== undefined) {
+                array.unshift(bounds[key]);
+            }
+        }
+        return array;
+    }
+}
+function defaultEquals(a, b) {
+    return a === b;
+}
+function countNonZeroes(array) {
+    let count = 0;
+    for (let i = 0; i < array.length; i += 1) {
+        if (array[i] !== 0) {
+            count += 1;
+        }
+    }
+    return count;
+}
+function lpad(string, character, length) {
+    const array = new Array(length + 1);
+    const pad = array.join(character);
+    return (pad + string).slice(-length);
+}
+/* harmony default export */ const segmentation_floodFill = (floodFill);
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/compositions/islandRemoval.js
+
+
+
+/* harmony default export */ const islandRemoval = ({
+    [enums_StrategyCallbacks.OnInteractionEnd]: (operationData) => {
+        const { previewVoxelManager: previewVoxelManager, segmentationVoxelManager: 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, index) => {
+            if (getter(...clickedPoint) === 1) {
+                segmentation_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;
+            }
+            segmentation_floodFill(getter, pointIJK, {
+                onFlood: onFloodInternal,
+                diagonals: false,
+            });
+            if (isInternal) {
+                for (const index of internalSet) {
+                    previewVoxelManager.setAtIndex(index, previewSegmentIndex);
+                }
+            }
+        }
+        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfSlices());
+    },
+});
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/compositions/preview.js
+
+
+
+/* harmony default export */ const preview = ({
+    [enums_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;
+    },
+    [enums_StrategyCallbacks.Initialize]: (operationData) => {
+        const { toolGroupId, segmentIndex, segmentationRepresentationUID, 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 = getColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, segmentIndex);
+        if (!configColor && !segmentColor) {
+            return;
+        }
+        const previewColor = configColor || segmentColor.map((it) => it * 0.9);
+        setColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, previewSegmentIndex, previewColor);
+    },
+    [enums_StrategyCallbacks.AcceptPreview]: (operationData) => {
+        const { segmentationVoxelManager: 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.getArrayOfSlices());
+        tracking.clear();
+    },
+    [enums_StrategyCallbacks.RejectPreview]: (operationData) => {
+        const { previewVoxelManager: previewVoxelManager, segmentationVoxelManager: segmentationVoxelManager, } = operationData;
+        if (previewVoxelManager.modifiedSlices.size === 0) {
+            return;
+        }
+        const callback = ({ index, value }) => {
+            segmentationVoxelManager.setAtIndex(index, value);
+        };
+        previewVoxelManager.forEach(callback);
+        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfSlices());
+        previewVoxelManager.clear();
+    },
+});
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/compositions/regionFill.js
+
+
+/* harmony default export */ const regionFill = ({
+    [enums_StrategyCallbacks.Fill]: (operationData) => {
+        const { segmentsLocked, segmentationImageData, segmentationVoxelManager: segmentationVoxelManager, previewVoxelManager: previewVoxelManager, imageVoxelManager: imageVoxelManager, 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);
+        pointInShapeCallback(segmentationImageData, imageVoxelManager.isInObject, callback, segmentationVoxelManager.boundsIJK);
+        previewVoxelManager.addPoint(centerIJK);
+    },
+});
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/compositions/setValue.js
+
+/* harmony default export */ const setValue = ({
+    [enums_StrategyCallbacks.INTERNAL_setValue]: (operationData, { value, index }) => {
+        const { segmentsLocked, segmentIndex, previewVoxelManager: previewVoxelManager, previewSegmentIndex, segmentationVoxelManager: segmentationVoxelManager, } = operationData;
+        const existingValue = segmentationVoxelManager.getAtIndex(index);
+        if (segmentIndex === null) {
+            const oldValue = previewVoxelManager.getAtIndex(index);
+            if (oldValue !== undefined) {
+                previewVoxelManager.setAtIndex(index, oldValue);
+            }
+            return;
+        }
+        if (existingValue === segmentIndex || segmentsLocked.includes(value)) {
+            return;
+        }
+        if (existingValue === previewSegmentIndex) {
+            if (previewVoxelManager.getAtIndex(index) === undefined) {
+                segmentationVoxelManager.setAtIndex(index, segmentIndex);
+            }
+            else {
+                return;
+            }
+        }
+        const useSegmentIndex = previewSegmentIndex ?? segmentIndex;
+        previewVoxelManager.setAtIndex(index, useSegmentIndex);
+    },
+});
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/compositions/threshold.js
+
+/* harmony default export */ const threshold = ({
+    [enums_StrategyCallbacks.CreateIsInThreshold]: (operationData) => {
+        const { imageVoxelManager: imageVoxelManager, strategySpecificConfiguration, segmentIndex, } = operationData;
+        if (!strategySpecificConfiguration || !segmentIndex) {
+            return;
+        }
+        return (index) => {
+            const { THRESHOLD, THRESHOLD_INSIDE_CIRCLE } = strategySpecificConfiguration;
+            const voxelValue = imageVoxelManager.getAtIndex(index);
+            const { threshold } = THRESHOLD || THRESHOLD_INSIDE_CIRCLE || {};
+            if (!threshold?.length) {
+                return true;
+            }
+            return threshold[0] <= voxelValue && voxelValue <= threshold[1];
+        };
+    },
+});
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/compositions/index.js
+
+
+
+
+
+
+
+
+/* harmony default export */ const compositions = ({
+    determineSegmentIndex: determineSegmentIndex,
+    dynamicThreshold: dynamicThreshold,
+    erase: erase,
+    islandRemoval: islandRemoval,
+    preview: preview,
+    regionFill: regionFill,
+    setValue: setValue,
+    threshold: threshold,
+});
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/utils/getStrategyData.js
 
 
+const { VoxelManager } = esm.utilities;
 function getStrategyData({ operationData, viewport }) {
     let segmentationImageData, segmentationScalarData, imageScalarData;
+    let dimensions;
     if (isVolumeSegmentation(operationData)) {
         const { volumeId, referencedVolumeId } = operationData;
         const segmentationVolume = esm.cache.getVolume(volumeId);
@@ -11890,6 +12481,7 @@ function getStrategyData({ operationData, viewport }) {
         ({ imageData: segmentationImageData } = segmentationVolume);
         segmentationScalarData = segmentationVolume.getScalarData();
         imageScalarData = imageVolume.getScalarData();
+        dimensions = imageVolume.dimensions;
     }
     else {
         const { imageIdReferenceMap, segmentationRepresentationUID } = operationData;
@@ -11907,134 +12499,232 @@ function getStrategyData({ operationData, viewport }) {
         segmentationScalarData = segmentationImage.getPixelData();
         const image = esm.cache.getImage(currentImageId);
         imageScalarData = image.getPixelData();
+        dimensions = [image.columns, image.rows, 1];
     }
     return {
         segmentationImageData,
         segmentationScalarData,
+        segmentationVoxelManager: VoxelManager.createVolumeVoxelManager(dimensions, segmentationScalarData),
         imageScalarData,
+        imageVoxelManager: VoxelManager.createVolumeVoxelManager(dimensions, imageScalarData),
     };
 }
 
 
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/fillSphere.js
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/BrushStrategy.js
 
 
 
 
 
 
-function fillSphere(enabledElement, operationData, _inside = true, threshold = false) {
-    const { viewport } = enabledElement;
-    const { segmentsLocked, segmentIndex, strategySpecificConfiguration, points, } = operationData;
-    const strategyData = getStrategyData({ operationData, viewport });
-    if (!strategyData) {
-        console.warn('No data found for fillSphere');
-        return;
-    }
-    const { imageScalarData, segmentationImageData, segmentationScalarData } = strategyData;
-    const scalarIndex = [];
-    let callback;
-    if (threshold) {
-        callback = ({ value, index }) => {
-            if (segmentsLocked.includes(value)) {
-                return;
+const { VoxelManager: BrushStrategy_VoxelManager } = esm.utilities;
+class BrushStrategy {
+    constructor(name, ...initializers) {
+        this._initialize = [];
+        this._fill = [];
+        this._onInteractionStart = [];
+        this.fill = (enabledElement, operationData) => {
+            const initializedData = this.initialize(enabledElement, operationData);
+            const { strategySpecificConfiguration = {}, centerIJK } = initializedData;
+            if (esm.utilities.isEqual(centerIJK, strategySpecificConfiguration.centerIJK)) {
+                return operationData.preview;
+            }
+            else {
+                strategySpecificConfiguration.centerIJK = centerIJK;
             }
-            if (utils_isWithinThreshold(index, imageScalarData, strategySpecificConfiguration)) {
-                segmentationScalarData[index] = segmentIndex;
-                scalarIndex.push(index);
+            this._fill.forEach((func) => func(initializedData));
+            const { segmentationVoxelManager, previewVoxelManager, previewSegmentIndex, } = initializedData;
+            triggerSegmentationDataModified(initializedData.segmentationId, segmentationVoxelManager.getArrayOfSlices());
+            if (!previewSegmentIndex || !previewVoxelManager.modifiedSlices.size) {
+                return null;
             }
+            return initializedData.preview || initializedData;
         };
-    }
-    else {
-        callback = ({ index, value }) => {
-            if (segmentsLocked.includes(value)) {
+        this.onInteractionStart = (enabledElement, operationData) => {
+            const { preview } = operationData;
+            if (preview?.isPreviewFromHover) {
+                preview.isPreviewFromHover = false;
                 return;
             }
-            segmentationScalarData[index] = segmentIndex;
-            scalarIndex.push(index);
+            const initializedData = this.initialize(enabledElement, operationData);
+            this._onInteractionStart.forEach((func) => func.call(this, initializedData));
         };
-    }
-    pointInSurroundingSphereCallback(segmentationImageData, [points[0], points[1]], callback, viewport);
-    const dimensions = segmentationImageData.getDimensions();
-    let sliceArray;
-    if (isVolumeSegmentation(operationData)) {
-        const zMultiple = dimensions[0] * dimensions[1];
-        const minSlice = Math.floor(scalarIndex[0] / zMultiple);
-        const maxSlice = Math.floor(scalarIndex[scalarIndex.length - 1] / zMultiple);
-        sliceArray = Array.from({ length: maxSlice - minSlice + 1 }, (v, k) => k + minSlice);
-        triggerSegmentationDataModified(operationData.volumeId, sliceArray);
+        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) => this.fill(enabledElement, operationData);
+        for (const key of Object.keys(BrushStrategy.childFunctions)) {
+            this.strategyFunction[key] = this[key];
+        }
+    }
+    static { this.COMPOSITIONS = compositions; }
+    static { this.childFunctions = {
+        [enums_StrategyCallbacks.OnInteractionStart]: addListMethod(enums_StrategyCallbacks.OnInteractionStart, enums_StrategyCallbacks.Initialize),
+        [enums_StrategyCallbacks.OnInteractionEnd]: addListMethod(enums_StrategyCallbacks.OnInteractionEnd, enums_StrategyCallbacks.Initialize),
+        [enums_StrategyCallbacks.Fill]: addListMethod(enums_StrategyCallbacks.Fill),
+        [enums_StrategyCallbacks.Initialize]: addListMethod(enums_StrategyCallbacks.Initialize),
+        [enums_StrategyCallbacks.CreateIsInThreshold]: addSingletonMethod(enums_StrategyCallbacks.CreateIsInThreshold),
+        [enums_StrategyCallbacks.AcceptPreview]: addListMethod(enums_StrategyCallbacks.AcceptPreview, enums_StrategyCallbacks.Initialize),
+        [enums_StrategyCallbacks.RejectPreview]: addListMethod(enums_StrategyCallbacks.RejectPreview, enums_StrategyCallbacks.Initialize),
+        [enums_StrategyCallbacks.INTERNAL_setValue]: addSingletonMethod(enums_StrategyCallbacks.INTERNAL_setValue),
+        [enums_StrategyCallbacks.Preview]: addSingletonMethod(enums_StrategyCallbacks.Preview, false),
+        compositions: null,
+    }; }
+    initialize(enabledElement, operationData) {
+        const { viewport } = enabledElement;
+        const data = getStrategyData({ operationData, viewport });
+        if (!data) {
+            console.warn('No data found for BrushStrategy');
+            return operationData.preview;
+        }
+        if (isVolumeSegmentation(operationData)) {
+            const { referencedVolumeId, volumeId } = operationData;
+            const imageVolume = esm.cache.getVolume(referencedVolumeId);
+            const segmentation = esm.cache.getVolume(volumeId);
+            if (!esm.utilities.isEqual(segmentation.dimensions, imageVolume.dimensions) ||
+                !esm.utilities.isEqual(segmentation.direction, imageVolume.direction)) {
+                throw new Error('Only source data the same dimensions/size/orientation as the segmentation currently supported.');
+            }
+        }
+        const { imageVoxelManager, segmentationVoxelManager, segmentationImageData, } = data;
+        const previewVoxelManager = operationData.preview?.previewVoxelManager ||
+            BrushStrategy_VoxelManager.createHistoryVoxelManager(segmentationVoxelManager);
+        const previewEnabled = !!operationData.previewColors;
+        const previewSegmentIndex = previewEnabled ? 255 : undefined;
+        const initializedData = {
+            previewSegmentIndex,
+            ...operationData,
+            enabledElement,
+            imageVoxelManager,
+            segmentationVoxelManager,
+            segmentationImageData,
+            previewVoxelManager,
+            viewport,
+            centerWorld: null,
+            brushStrategy: this,
+        };
+        this._initialize.forEach((func) => func(initializedData));
+        return initializedData;
     }
 }
-function fillInsideSphere(enabledElement, operationData) {
-    fillSphere(enabledElement, operationData, true);
+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);
+                brushStrategy[listName].forEach((func) => func.call(brushStrategy, initializedData));
+            }
+            : (operationData) => {
+                brushStrategy[listName].forEach((func) => func.call(brushStrategy, operationData));
+            };
+    };
 }
-function thresholdInsideSphere(enabledElement, operationData) {
-    if (isVolumeSegmentation(operationData)) {
-        const { referencedVolumeId, volumeId } = operationData;
-        const imageVolume = esm.cache.getVolume(referencedVolumeId);
-        const segmentation = esm.cache.getVolume(volumeId);
-        if (!esm.utilities.isEqual(segmentation.dimensions, imageVolume.dimensions) ||
-            !esm.utilities.isEqual(segmentation.direction, imageVolume.direction)) {
-            throw new Error('Only source data the same dimensions/size/orientation as the segmentation currently supported.');
+function addSingletonMethod(name, isInitialized = true) {
+    return (brushStrategy, func) => {
+        if (brushStrategy[name]) {
+            throw new Error(`The singleton method ${name} already exists`);
         }
-    }
-    fillSphere(enabledElement, operationData, true, true);
-}
-function fillOutsideSphere(enabledElement, operationData) {
-    fillSphere(enabledElement, operationData, false);
+        brushStrategy[name] = isInitialized
+            ? func
+            : (enabledElement, operationData) => {
+                operationData.enabledElement = enabledElement;
+                return func.call(brushStrategy, operationData);
+            };
+    };
 }
 
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/eraseSphere.js
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/fillCircle.js
 
-function eraseInsideSphere(enabledElement, operationData) {
-    const eraseOperationData = Object.assign({}, operationData, {
-        segmentIndex: 0,
-    });
-    fillInsideSphere(enabledElement, eraseOperationData);
-}
 
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/ellipse/pointInEllipse.js
-function pointInEllipse(ellipse, pointLPS, inverts = {}) {
-    const { center, xRadius, yRadius, zRadius } = ellipse;
-    if (inverts.invXRadiusSq === undefined ||
-        inverts.invYRadiusSq === undefined ||
-        inverts.invZRadiusSq === undefined) {
-        inverts.invXRadiusSq = xRadius !== 0 ? 1 / xRadius ** 2 : 0;
-        inverts.invYRadiusSq = yRadius !== 0 ? 1 / yRadius ** 2 : 0;
-        inverts.invZRadiusSq = zRadius !== 0 ? 1 / zRadius ** 2 : 0;
-    }
-    let inside = 0;
-    const dx = pointLPS[0] - center[0];
-    inside += dx * dx * inverts.invXRadiusSq;
-    if (inside > 1) {
-        return false;
-    }
-    const dy = pointLPS[1] - center[1];
-    inside += dy * dy * inverts.invYRadiusSq;
-    if (inside > 1) {
-        return false;
-    }
-    const dz = pointLPS[2] - center[2];
-    inside += dz * dz * inverts.invZRadiusSq;
-    return inside <= 1;
-}
 
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/ellipse/getCanvasEllipseCorners.js
-function getCanvasEllipseCorners(ellipseCanvasPoints) {
-    const [bottom, top, left, right] = ellipseCanvasPoints;
-    const topLeft = [left[0], top[1]];
-    const bottomRight = [right[0], bottom[1]];
-    return [topLeft, bottomRight];
-}
 
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/ellipse/index.js
 
 
 
 
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/fillCircle.js
+const { transformWorldToIndex: fillCircle_transformWorldToIndex } = esm.utilities;
+const fillCircle_EPSILON = 1e-4;
+const nearOrZero = (testValue, nearValue) => Math.abs(testValue) < fillCircle_EPSILON || Math.abs(testValue - nearValue) < fillCircle_EPSILON;
+const initializeCircle = {
+    [enums_StrategyCallbacks.Initialize]: (operationData) => {
+        const { points, imageVoxelManager: imageVoxelManager, viewport, segmentationImageData, segmentationVoxelManager: segmentationVoxelManager, } = operationData;
+        if (!points) {
+            return;
+        }
+        const center = gl_matrix_esm/* vec3.fromValues */.R3.fromValues(0, 0, 0);
+        points.forEach((point) => {
+            gl_matrix_esm/* vec3.add */.R3.add(center, center, point);
+        });
+        gl_matrix_esm/* vec3.scale */.R3.scale(center, center, 1 / points.length);
+        operationData.centerWorld = center;
+        operationData.centerIJK = fillCircle_transformWorldToIndex(segmentationImageData, center);
+        const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
+        const [topLeftCanvas, bottomRightCanvas] = getCanvasEllipseCorners(canvasCoordinates);
+        const topLeftWorld = viewport.canvasToWorld(topLeftCanvas);
+        const bottomRightWorld = viewport.canvasToWorld(bottomRightCanvas);
+        const ellipsoidCornersIJK = [
+            fillCircle_transformWorldToIndex(segmentationImageData, topLeftWorld),
+            (fillCircle_transformWorldToIndex(segmentationImageData, bottomRightWorld)),
+        ];
+        segmentationVoxelManager.boundsIJK = boundingBox_getBoundingBoxAroundShape(ellipsoidCornersIJK, segmentationVoxelManager.dimensions);
+        imageVoxelManager.isInObject = createPointInEllipse({
+            topLeftWorld,
+            bottomRightWorld,
+            center,
+        });
+    },
+};
+function createPointInEllipse(worldInfo) {
+    const { topLeftWorld, bottomRightWorld, center } = worldInfo;
+    const xRadius = Math.abs(topLeftWorld[0] - bottomRightWorld[0]) / 2;
+    const yRadius = Math.abs(topLeftWorld[1] - bottomRightWorld[1]) / 2;
+    const zRadius = Math.abs(topLeftWorld[2] - bottomRightWorld[2]) / 2;
+    const radius = Math.max(xRadius, yRadius, zRadius);
+    if (nearOrZero(xRadius, radius) &&
+        nearOrZero(yRadius, radius) &&
+        nearOrZero(zRadius, radius)) {
+        const sphereObj = {
+            center,
+            radius,
+            radius2: radius * radius,
+        };
+        return (pointLPS) => pointInSphere(sphereObj, pointLPS);
+    }
+    const ellipseObj = {
+        center: center,
+        xRadius,
+        yRadius,
+        zRadius,
+    };
+    const inverts = precalculatePointInEllipse(ellipseObj);
+    const { precalculated } = inverts;
+    return precalculated;
+}
+const CIRCLE_STRATEGY = new BrushStrategy('Circle', compositions.regionFill, compositions.setValue, initializeCircle, compositions.determineSegmentIndex, compositions.preview);
+const CIRCLE_THRESHOLD_STRATEGY = new BrushStrategy('CircleThreshold', compositions.regionFill, compositions.setValue, initializeCircle, compositions.determineSegmentIndex, compositions.dynamicThreshold, compositions.threshold, compositions.preview, compositions.islandRemoval);
+const fillInsideCircle = CIRCLE_STRATEGY.strategyFunction;
+const thresholdInsideCircle = CIRCLE_THRESHOLD_STRATEGY.strategyFunction;
+function fillOutsideCircle() {
+    throw new Error('Not yet implemented');
+}
 
 
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/fillSphere.js
 
 
 
@@ -12043,104 +12733,69 @@ function getCanvasEllipseCorners(ellipseCanvasPoints) {
 
 
 
-const { transformWorldToIndex: fillCircle_transformWorldToIndex } = esm.utilities;
-function fillCircle(enabledElement, operationData, threshold = false) {
-    const { points, segmentsLocked, segmentIndex, segmentationId, strategySpecificConfiguration, } = operationData;
-    const { viewport } = enabledElement;
-    const data = getStrategyData({ operationData, viewport });
-    if (!data) {
-        console.warn('No data found for fillCircle');
-        return;
-    }
-    const { imageScalarData, segmentationImageData, segmentationScalarData } = data;
-    const { ellipseObj, boundsIJK } = getEllipse(viewport, segmentationImageData, points);
-    const modifiedSlicesToUse = new Set();
-    let callback;
-    if (threshold) {
-        callback = ({ value, index, pointIJK }) => {
-            if (segmentsLocked.includes(value)) {
-                return;
-            }
-            if (utils_isWithinThreshold(index, imageScalarData, strategySpecificConfiguration)) {
-                segmentationScalarData[index] = segmentIndex;
-                modifiedSlicesToUse.add(pointIJK[2]);
-            }
-        };
-    }
-    else {
-        callback = ({ value, index, pointIJK }) => {
-            if (segmentsLocked.includes(value)) {
-                return;
-            }
-            segmentationScalarData[index] = segmentIndex;
-            modifiedSlicesToUse.add(pointIJK[2]);
-        };
-    }
-    pointInShapeCallback(segmentationImageData, (pointLPS) => pointInEllipse(ellipseObj, pointLPS, {
-        fast: true,
-    }), callback, boundsIJK);
-    const arrayOfSlices = Array.from(modifiedSlicesToUse);
-    triggerSegmentationDataModified(segmentationId, arrayOfSlices);
-}
-function fillInsideCircle(enabledElement, operationData) {
-    fillCircle(enabledElement, operationData, false);
-}
-function thresholdInsideCircle(enabledElement, operationData) {
-    if (isVolumeSegmentation(operationData)) {
-        const { referencedVolumeId, volumeId } = operationData;
-        const imageVolume = esm.cache.getVolume(referencedVolumeId);
-        const segmentation = esm.cache.getVolume(volumeId);
-        if (!esm.utilities.isEqual(segmentation.dimensions, imageVolume.dimensions) ||
-            !esm.utilities.isEqual(segmentation.direction, imageVolume.direction)) {
-            throw new Error('Only source data the same dimensions/size/orientation as the segmentation currently supported.');
+const { transformWorldToIndex: fillSphere_transformWorldToIndex } = esm.utilities;
+const sphereComposition = {
+    [enums_StrategyCallbacks.Initialize]: (operationData) => {
+        const { points, imageVoxelManager: imageVoxelManager, viewport, segmentationImageData, segmentationVoxelManager: segmentationVoxelManager, } = operationData;
+        if (!points) {
+            return;
         }
-    }
-    fillCircle(enabledElement, operationData, true);
-}
-function fillOutsideCircle(enabledElement, operationData) {
-    throw new Error('Not yet implemented');
-}
-function getCenter(points) {
-    const center = gl_matrix_esm/* vec3.fromValues */.R3.fromValues(0, 0, 0);
-    points.forEach((point) => {
-        gl_matrix_esm/* vec3.add */.R3.add(center, center, point);
-    });
-    gl_matrix_esm/* vec3.scale */.R3.scale(center, center, 1 / points.length);
-    return center;
-}
-function getEllipse(viewport, imageData, points) {
-    const center = getCenter(points);
-    const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
-    const dimensions = imageData.getDimensions();
-    const [topLeftCanvas, bottomRightCanvas] = getCanvasEllipseCorners(canvasCoordinates);
-    const topLeftWorld = viewport.canvasToWorld(topLeftCanvas);
-    const bottomRightWorld = viewport.canvasToWorld(bottomRightCanvas);
-    const ellipsoidCornersIJK = [
-        fillCircle_transformWorldToIndex(imageData, topLeftWorld),
-        fillCircle_transformWorldToIndex(imageData, bottomRightWorld),
-    ];
-    const boundsIJK = boundingBox_getBoundingBoxAroundShape(ellipsoidCornersIJK, dimensions);
-    if (boundsIJK.every(([min, max]) => min !== max)) {
-        throw new Error('Oblique segmentation tools are not supported yet');
-    }
-    const ellipseObj = {
-        center: center,
-        xRadius: Math.abs(topLeftWorld[0] - bottomRightWorld[0]) / 2,
-        yRadius: Math.abs(topLeftWorld[1] - bottomRightWorld[1]) / 2,
-        zRadius: Math.abs(topLeftWorld[2] - bottomRightWorld[2]) / 2,
-    };
-    return { ellipseObj, boundsIJK };
+        const center = gl_matrix_esm/* vec3.fromValues */.R3.fromValues(0, 0, 0);
+        points.forEach((point) => {
+            gl_matrix_esm/* vec3.add */.R3.add(center, center, point);
+        });
+        gl_matrix_esm/* vec3.scale */.R3.scale(center, center, 1 / points.length);
+        operationData.centerWorld = center;
+        operationData.centerIJK = fillSphere_transformWorldToIndex(segmentationImageData, center);
+        const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
+        const [topLeftCanvas, bottomRightCanvas] = getCanvasEllipseCorners(canvasCoordinates);
+        const topLeftWorld = viewport.canvasToWorld(topLeftCanvas);
+        const bottomRightWorld = viewport.canvasToWorld(bottomRightCanvas);
+        const diameters = topLeftWorld.map((left, index) => Math.abs(bottomRightWorld[index] - left));
+        const radius = Math.max(...diameters) / 2;
+        topLeftWorld.forEach((left, index) => {
+            const right = bottomRightWorld[index];
+            if (left === right) {
+                topLeftWorld[index] = left - radius;
+                bottomRightWorld[index] = left + radius;
+            }
+        });
+        const ellipsoidCornersIJK = [
+            fillSphere_transformWorldToIndex(segmentationImageData, topLeftWorld),
+            (fillSphere_transformWorldToIndex(segmentationImageData, bottomRightWorld)),
+        ];
+        segmentationVoxelManager.boundsIJK = boundingBox_getBoundingBoxAroundShape(ellipsoidCornersIJK, segmentationVoxelManager.dimensions);
+        imageVoxelManager.isInObject = createPointInEllipse({
+            topLeftWorld,
+            bottomRightWorld,
+            center,
+        });
+    },
+};
+const SPHERE_STRATEGY = new BrushStrategy('Sphere', compositions.regionFill, compositions.setValue, sphereComposition, compositions.determineSegmentIndex, compositions.preview);
+const fillInsideSphere = SPHERE_STRATEGY.strategyFunction;
+const SPHERE_THRESHOLD_STRATEGY = new BrushStrategy('SphereThreshold', ...SPHERE_STRATEGY.compositions, compositions.dynamicThreshold, compositions.threshold, compositions.islandRemoval);
+const thresholdInsideSphere = SPHERE_THRESHOLD_STRATEGY.strategyFunction;
+function fillOutsideSphere() {
+    throw new Error('fill outside sphere not implemented');
 }
 
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/eraseSphere.js
+
+
+
+const ERASE_SPHERE_STRATEGY = new BrushStrategy('EraseSphere', compositions.erase, ...SPHERE_STRATEGY.compositions);
+const eraseInsideSphere = ERASE_SPHERE_STRATEGY.strategyFunction;
+
+
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/eraseCircle.js
 
-function eraseInsideCircle(enabledElement, operationData) {
-    const eraseOperationData = {
-        ...operationData,
-        segmentIndex: 0,
-    };
-    fillInsideCircle(enabledElement, eraseOperationData);
-}
+
+
+const ERASE_CIRCLE_STRATEGY = new BrushStrategy('EraseCircle', compositions.erase, ...CIRCLE_STRATEGY.compositions);
+const eraseInsideCircle = ERASE_CIRCLE_STRATEGY.strategyFunction;
+
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/cursors/MouseCursor.js
 const DEFINED_CURSORS = Symbol('DefinedCursors');
@@ -12819,127 +13474,153 @@ class BrushTool extends base_BaseTool {
                 THRESHOLD_INSIDE_SPHERE: thresholdInsideSphere,
             },
             strategySpecificConfiguration: {
-                THRESHOLD_INSIDE_CIRCLE: {
+                THRESHOLD: {
                     threshold: [-150, -70],
                 },
             },
             defaultStrategy: 'FILL_INSIDE_CIRCLE',
             activeStrategy: 'FILL_INSIDE_CIRCLE',
             brushSize: 25,
+            preview: {
+                enabled: false,
+                previewColors: {},
+                previewTimeMs: 250,
+                previewMoveDistance: 8,
+                dragMoveDistance: 4,
+                dragTimeMs: 500,
+            },
+            centerRadius: 2,
+            actions: {
+                [enums_StrategyCallbacks.AcceptPreview]: {
+                    method: enums_StrategyCallbacks.AcceptPreview,
+                    bindings: [
+                        {
+                            key: 'Enter',
+                        },
+                    ],
+                },
+                [enums_StrategyCallbacks.RejectPreview]: {
+                    method: enums_StrategyCallbacks.RejectPreview,
+                    bindings: [
+                        {
+                            key: 'Escape',
+                        },
+                    ],
+                },
+            },
         },
     }) {
         super(toolProps, defaultToolProps);
-        this.onSetToolPassive = () => {
+        this._previewData = {
+            preview: null,
+            element: null,
+            timerStart: 0,
+            timer: null,
+            startPoint: [NaN, NaN],
+            isDrag: false,
+        };
+        this.onSetToolPassive = (evt) => {
             this.disableCursor();
         };
         this.onSetToolEnabled = () => {
             this.disableCursor();
         };
-        this.onSetToolDisabled = () => {
+        this.onSetToolDisabled = (evt) => {
             this.disableCursor();
         };
         this.preMouseDownCallback = (evt) => {
             const eventData = evt.detail;
             const { element } = eventData;
             const enabledElement = (0,esm.getEnabledElement)(element);
-            const { viewport, renderingEngine } = enabledElement;
-            const toolGroupId = this.toolGroupId;
-            const activeSegmentationRepresentation = getActiveSegmentationRepresentation(toolGroupId);
-            if (!activeSegmentationRepresentation) {
-                throw new Error('No active segmentation detected, create one before using the brush tool');
-            }
-            const { segmentationId, type, segmentationRepresentationUID } = activeSegmentationRepresentation;
-            if (type === enums_SegmentationRepresentations.Contour) {
-                throw new Error('Not implemented yet');
-            }
-            const segmentsLocked = getLockedSegments(segmentationId);
-            const { representationData } = getSegmentation(segmentationId);
-            const labelmapData = representationData[enums_SegmentationRepresentations.Labelmap];
-            const viewportIdsToRender = [viewport.id];
-            if (isVolumeSegmentation(labelmapData)) {
-                const { volumeId } = representationData[type];
-                const actors = viewport.getActors();
-                const firstVolumeActorUID = actors[0].uid;
-                this._editData = {
-                    volumeId,
-                    referencedVolumeId: firstVolumeActorUID,
-                    segmentsLocked,
-                    segmentationRepresentationUID,
-                };
-            }
-            else {
-                const { imageIdReferenceMap } = labelmapData;
-                const currentImageId = viewport.getCurrentImageId();
-                if (!imageIdReferenceMap.get(currentImageId)) {
-                    return;
-                }
-                if (this.configuration.activeStrategy.includes('SPHERE')) {
-                    console.warn('Sphere manipulation is not supported for this stack of images yet');
-                    return;
-                }
-                this._editData = {
-                    imageIdReferenceMap,
-                    segmentsLocked,
-                    segmentationRepresentationUID,
-                };
-            }
+            const { renderingEngine } = enabledElement;
+            this._editData = this.createEditData(element);
             this._activateDraw(element);
             hideElementCursor(element);
             evt.preventDefault();
-            utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            this._previewData.isDrag = false;
+            this._previewData.timerStart = Date.now();
+            utilities_triggerAnnotationRenderForViewportIds(renderingEngine, this._hoverData.viewportIdsToRender);
+            this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), enums_StrategyCallbacks.OnInteractionStart);
             return true;
         };
         this.mouseMoveCallback = (evt) => {
             if (this.mode === enums_ToolModes.Active) {
                 this.updateCursor(evt);
+                if (!this.configuration.preview.enabled) {
+                    return;
+                }
+                const { previewTimeMs, previewMoveDistance, dragMoveDistance } = this.configuration.preview;
+                const { currentPoints, element } = evt.detail;
+                const { canvas } = currentPoints;
+                const { preview, startPoint, timer, timerStart, isDrag } = this._previewData;
+                const delta = gl_matrix_esm/* vec2.distance */.K4.distance(canvas, startPoint);
+                const time = Date.now() - timerStart;
+                if (delta > previewMoveDistance ||
+                    (time > previewTimeMs && delta > dragMoveDistance)) {
+                    if (timer) {
+                        window.clearTimeout(timer);
+                        this._previewData.timer = null;
+                    }
+                    if (preview && !isDrag) {
+                        this.rejectPreview(element);
+                    }
+                }
+                if (!this._previewData.timer) {
+                    const timer = window.setTimeout(this.previewCallback, 250);
+                    Object.assign(this._previewData, {
+                        timerStart: Date.now(),
+                        timer,
+                        startPoint: canvas,
+                        element,
+                    });
+                }
             }
         };
+        this.previewCallback = () => {
+            if (this._previewData.preview) {
+                return;
+            }
+            this._previewData.timer = null;
+            this._previewData.preview = this.applyActiveStrategyCallback((0,esm.getEnabledElement)(this._previewData.element), this.getOperationData(this._previewData.element), enums_StrategyCallbacks.Preview);
+        };
         this._dragCallback = (evt) => {
             const eventData = evt.detail;
-            const { element } = eventData;
+            const { element, currentPoints } = eventData;
             const enabledElement = (0,esm.getEnabledElement)(element);
             const { renderingEngine } = enabledElement;
             this.updateCursor(evt);
-            const { segmentIndex, segmentationId, segmentationRepresentationUID, brushCursor, viewportIdsToRender, } = this._hoverData;
-            const { data } = brushCursor;
-            const { viewPlaneNormal, viewUp } = brushCursor.metadata;
+            const { viewportIdsToRender } = this._hoverData;
             utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
-            const operationData = {
-                ...this._editData,
-                points: data.handles.points,
-                segmentIndex,
-                viewPlaneNormal,
-                toolGroupId: this.toolGroupId,
-                segmentationId,
-                segmentationRepresentationUID,
-                viewUp,
-                strategySpecificConfiguration: this.configuration.strategySpecificConfiguration,
-            };
-            this.applyActiveStrategy(enabledElement, operationData);
+            const delta = gl_matrix_esm/* vec2.distance */.K4.distance(currentPoints.canvas, this._previewData.startPoint);
+            const { dragTimeMs, dragMoveDistance } = this.configuration.preview;
+            if (!this._previewData.isDrag &&
+                this._previewData.preview &&
+                Date.now() - this._previewData.timerStart < dragTimeMs &&
+                delta < dragMoveDistance) {
+                return;
+            }
+            this._previewData.preview = this.applyActiveStrategy(enabledElement, this.getOperationData());
+            this._previewData.element = element;
+            this._previewData.timerStart = Date.now() + dragTimeMs;
+            this._previewData.isDrag = true;
+            this._previewData.startPoint = currentPoints.canvas;
         };
         this._endCallback = (evt) => {
             const eventData = evt.detail;
             const { element } = eventData;
-            const { segmentIndex, segmentationId, segmentationRepresentationUID, brushCursor, } = this._hoverData;
-            const { data } = brushCursor;
-            const { viewPlaneNormal, viewUp } = brushCursor.metadata;
+            const enabledElement = (0,esm.getEnabledElement)(element);
+            const operationData = this.getOperationData(element);
+            if (!this._previewData.preview && !this._previewData.isDrag) {
+                this.applyActiveStrategy(enabledElement, operationData);
+            }
             this._deactivateDraw(element);
             resetElementCursor(element);
-            const enabledElement = (0,esm.getEnabledElement)(element);
             this.updateCursor(evt);
-            const operationData = {
-                points: data.handles.points,
-                ...this._editData,
-                segmentIndex,
-                viewPlaneNormal,
-                toolGroupId: this.toolGroupId,
-                segmentationId,
-                segmentationRepresentationUID,
-                viewUp,
-                strategySpecificConfiguration: this.configuration.strategySpecificConfiguration,
-            };
             this._editData = null;
-            this.applyActiveStrategy(enabledElement, operationData);
+            this.applyActiveStrategyCallback(enabledElement, operationData, enums_StrategyCallbacks.OnInteractionEnd);
+            if (!this._previewData.isDrag) {
+                this.acceptPreview(element);
+            }
         };
         this._activateDraw = (element) => {
             element.addEventListener(enums_Events.MOUSE_UP, this._endCallback);
@@ -12954,14 +13635,55 @@ class BrushTool extends base_BaseTool {
     }
     disableCursor() {
         this._hoverData = undefined;
+        this.rejectPreview();
     }
-    updateCursor(evt) {
-        const eventData = evt.detail;
-        const { element } = eventData;
-        const { currentPoints } = eventData;
-        const centerCanvas = currentPoints.canvas;
+    createEditData(element) {
         const enabledElement = (0,esm.getEnabledElement)(element);
-        const { renderingEngine, viewport } = enabledElement;
+        const { viewport, renderingEngine } = enabledElement;
+        const toolGroupId = this.toolGroupId;
+        const activeSegmentationRepresentation = getActiveSegmentationRepresentation(toolGroupId);
+        if (!activeSegmentationRepresentation) {
+            throw new Error('No active segmentation detected, create one before using the brush tool');
+        }
+        const { segmentationId, type, segmentationRepresentationUID } = activeSegmentationRepresentation;
+        if (type === enums_SegmentationRepresentations.Contour) {
+            throw new Error('Not implemented yet');
+        }
+        const segmentsLocked = getLockedSegments(segmentationId);
+        const { representationData } = getSegmentation(segmentationId);
+        const labelmapData = representationData[enums_SegmentationRepresentations.Labelmap];
+        const viewportIdsToRender = [viewport.id];
+        if (isVolumeSegmentation(labelmapData)) {
+            const { volumeId } = representationData[type];
+            const actors = viewport.getActors();
+            const firstVolumeActorUID = actors[0].uid;
+            return {
+                volumeId,
+                referencedVolumeId: firstVolumeActorUID,
+                segmentsLocked,
+                segmentationRepresentationUID,
+            };
+        }
+        else {
+            const { imageIdReferenceMap } = labelmapData;
+            const currentImageId = viewport.getCurrentImageId();
+            if (!imageIdReferenceMap.get(currentImageId)) {
+                return;
+            }
+            if (this.configuration.activeStrategy.includes('SPHERE')) {
+                console.warn('Sphere manipulation is not supported for this stack of images yet');
+                return;
+            }
+            return {
+                imageIdReferenceMap,
+                segmentsLocked,
+                segmentationRepresentationUID,
+            };
+        }
+    }
+    createHoverData(element, centerCanvas) {
+        const enabledElement = (0,esm.getEnabledElement)(element);
+        const { viewport } = enabledElement;
         const camera = viewport.getCamera();
         const { viewPlaneNormal, viewUp } = camera;
         const toolGroupId = this.toolGroupId;
@@ -12985,7 +13707,7 @@ class BrushTool extends base_BaseTool {
             },
             data: {},
         };
-        this._hoverData = {
+        return {
             brushCursor,
             centerCanvas,
             segmentIndex,
@@ -12994,8 +13716,37 @@ class BrushTool extends base_BaseTool {
             segmentColor,
             viewportIdsToRender,
         };
+    }
+    updateCursor(evt) {
+        const eventData = evt.detail;
+        const { element } = eventData;
+        const { currentPoints } = eventData;
+        const centerCanvas = currentPoints.canvas;
+        this._hoverData = this.createHoverData(element, centerCanvas);
         this._calculateCursor(element, centerCanvas);
-        utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+        utilities_triggerAnnotationRenderForViewportIds((0,esm.getEnabledElement)(element).renderingEngine, this._hoverData.viewportIdsToRender);
+    }
+    getOperationData(element) {
+        const editData = this._editData || this.createEditData(element);
+        const { segmentIndex, segmentationId, segmentationRepresentationUID, brushCursor, } = this._hoverData || this.createHoverData(element);
+        const { data, metadata = {} } = brushCursor || {};
+        const { viewPlaneNormal, viewUp } = metadata;
+        const operationData = {
+            ...editData,
+            points: data?.handles?.points,
+            segmentIndex,
+            previewColors: this.configuration.preview.enabled
+                ? this.configuration.preview.previewColors
+                : null,
+            viewPlaneNormal,
+            toolGroupId: this.toolGroupId,
+            segmentationId,
+            segmentationRepresentationUID,
+            viewUp,
+            strategySpecificConfiguration: this.configuration.strategySpecificConfiguration,
+            preview: this._previewData?.preview,
+        };
+        return operationData;
     }
     _calculateCursor(element, centerCanvas) {
         const enabledElement = (0,esm.getEnabledElement)(element);
@@ -13034,6 +13785,24 @@ class BrushTool extends base_BaseTool {
         ];
         data.invalidated = false;
     }
+    rejectPreview(element = this._previewData.element) {
+        if (!element || !this._previewData.preview) {
+            return;
+        }
+        const enabledElement = (0,esm.getEnabledElement)(element);
+        this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), enums_StrategyCallbacks.RejectPreview);
+        this._previewData.preview = null;
+        this._previewData.isDrag = false;
+    }
+    acceptPreview(element = this._previewData.element) {
+        if (!element) {
+            return;
+        }
+        const enabledElement = (0,esm.getEnabledElement)(element);
+        this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), enums_StrategyCallbacks.AcceptPreview);
+        this._previewData.isDrag = false;
+        this._previewData.preview = null;
+    }
     invalidateBrushCursor() {
         if (this._hoverData !== undefined) {
             const { data } = this._hoverData.brushCursor;
@@ -13076,6 +13845,13 @@ class BrushTool extends base_BaseTool {
         drawingSvg_drawCircle(svgDrawingHelper, annotationUID, circleUID, center, radius, {
             color,
         });
+        const { centerRadius } = this.configuration;
+        if (centerRadius >= 0) {
+            const circleUID1 = '1';
+            drawingSvg_drawCircle(svgDrawingHelper, annotationUID, circleUID1, center, 2, {
+                color,
+            });
+        }
     }
 }
 BrushTool.toolName = 'Brush';
@@ -21536,8 +22312,7 @@ class EllipticalROITool extends base_AnnotationTool {
                 const color = this.getStyle('color', styleSpecifier, annotation);
                 const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
                 const rotation = Math.abs(viewport.getRotation() - (data.initialRotation || 0));
-                let canvasCorners;
-                canvasCorners = (getCanvasEllipseCorners(canvasCoordinates));
+                const canvasCorners = (getCanvasEllipseCorners(canvasCoordinates));
                 const { centerPointRadius } = this.configuration;
                 if (!data.cachedStats[targetId] ||
                     data.cachedStats[targetId].areaUnit == null) {
@@ -27406,7 +28181,7 @@ KeyImageTool.toolName = 'KeyImage';
 
 const { transformWorldToIndex: fillRectangle_transformWorldToIndex } = esm.utilities;
 function fillRectangle(enabledElement, operationData, inside = true) {
-    const { points, segmentsLocked, segmentIndex, segmentationId, constraintFn } = operationData;
+    const { points, segmentsLocked, segmentIndex, segmentationId } = operationData;
     const strategyData = getStrategyData({
         operationData,
         viewport: enabledElement.viewport,
@@ -27426,17 +28201,11 @@ function fillRectangle(enabledElement, operationData, inside = true) {
     });
     const boundsIJK = boundingBox_getBoundingBoxAroundShape(rectangleCornersIJK, segmentationImageData.getDimensions());
     const pointInRectangle = () => true;
-    const callback = ({ value, index, pointIJK }) => {
+    const callback = ({ value, index }) => {
         if (segmentsLocked.includes(value)) {
             return;
         }
-        if (!constraintFn) {
-            segmentationScalarData[index] = segmentIndex;
-            return;
-        }
-        if (constraintFn(pointIJK)) {
-            segmentationScalarData[index] = segmentIndex;
-        }
+        segmentationScalarData[index] = segmentIndex;
     };
     pointInShapeCallback(segmentationImageData, pointInRectangle, callback, boundsIJK);
     triggerSegmentationDataModified(segmentationId);
@@ -27696,12 +28465,14 @@ RectangleScissorsTool.toolName = 'RectangleScissor';
 
 
 
+
 class CircleScissorsTool extends base_BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
             strategies: {
                 FILL_INSIDE: fillInsideCircle,
+                ERASE_INSIDE: eraseInsideCircle,
             },
             defaultStrategy: 'FILL_INSIDE',
             activeStrategy: 'FILL_INSIDE',
@@ -27844,6 +28615,7 @@ class CircleScissorsTool extends base_BaseTool {
                 points: data.handles.points,
                 viewPlaneNormal,
                 viewUp,
+                strategySpecificConfiguration: {},
             };
             this.editData = null;
             this.isDrawing = false;
@@ -27916,12 +28688,14 @@ CircleScissorsTool.toolName = 'CircleScissor';
 
 
 
+
 class SphereScissorsTool extends base_BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
             strategies: {
                 FILL_INSIDE: fillInsideSphere,
+                ERASE_INSIDE: eraseInsideSphere,
             },
             defaultStrategy: 'FILL_INSIDE',
             activeStrategy: 'FILL_INSIDE',
@@ -27973,6 +28747,7 @@ class SphereScissorsTool extends base_BaseTool {
                 centerCanvas: canvasPos,
                 segmentationRepresentationUID,
                 segmentIndex,
+                segmentationId,
                 segmentsLocked,
                 segmentColor,
                 toolGroupId,
@@ -28522,136 +29297,6 @@ class RectangleROIStartEndThresholdTool extends annotation_RectangleROITool {
 RectangleROIStartEndThresholdTool.toolName = 'RectangleROIStartEndThreshold';
 /* harmony default export */ const segmentation_RectangleROIStartEndThresholdTool = (RectangleROIStartEndThresholdTool);
 
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/floodFill.js
-function floodFill(getter, seed, options = {}) {
-    const onFlood = options.onFlood;
-    const onBoundary = options.onBoundary;
-    const equals = options.equals || defaultEquals;
-    const diagonals = options.diagonals || false;
-    const startNode = get(seed);
-    const permutations = prunedPermutations();
-    const stack = [];
-    const flooded = [];
-    const visits = {};
-    const bounds = {};
-    stack.push({ currentArgs: seed });
-    while (stack.length > 0) {
-        flood(stack.pop());
-    }
-    return {
-        flooded,
-        boundaries: boundaries(),
-    };
-    function flood(job) {
-        const getArgs = job.currentArgs;
-        const prevArgs = job.previousArgs;
-        if (visited(getArgs)) {
-            return;
-        }
-        markAsVisited(getArgs);
-        if (member(getArgs)) {
-            markAsFlooded(getArgs);
-            pushAdjacent(getArgs);
-        }
-        else {
-            markAsBoundary(prevArgs);
-        }
-    }
-    function visited(key) {
-        return visits[key] === true;
-    }
-    function markAsVisited(key) {
-        visits[key] = true;
-    }
-    function member(getArgs) {
-        const node = safely(get, [getArgs]);
-        return safely(equals, [node, startNode]);
-    }
-    function markAsFlooded(getArgs) {
-        flooded.push(getArgs);
-        if (onFlood) {
-            onFlood(...getArgs);
-        }
-    }
-    function markAsBoundary(prevArgs) {
-        bounds[prevArgs] = prevArgs;
-        if (onBoundary) {
-            onBoundary(...prevArgs);
-        }
-    }
-    function pushAdjacent(getArgs) {
-        for (let i = 0; i < permutations.length; i += 1) {
-            const perm = permutations[i];
-            const nextArgs = getArgs.slice(0);
-            for (let j = 0; j < getArgs.length; j += 1) {
-                nextArgs[j] += perm[j];
-            }
-            stack.push({
-                currentArgs: nextArgs,
-                previousArgs: getArgs,
-            });
-        }
-    }
-    function get(getArgs) {
-        return getter(...getArgs);
-    }
-    function safely(f, args) {
-        try {
-            return f(...args);
-        }
-        catch (error) {
-            return;
-        }
-    }
-    function prunedPermutations() {
-        const permutations = permute(seed.length);
-        return permutations.filter(function (perm) {
-            const count = countNonZeroes(perm);
-            return count !== 0 && (count === 1 || diagonals);
-        });
-    }
-    function permute(length) {
-        const perms = [];
-        const permutation = function (string) {
-            return string.split('').map(function (c) {
-                return parseInt(c, 10) - 1;
-            });
-        };
-        for (let i = 0; i < Math.pow(3, length); i += 1) {
-            const string = lpad(i.toString(3), '0', length);
-            perms.push(permutation(string));
-        }
-        return perms;
-    }
-    function boundaries() {
-        const array = [];
-        for (const key in bounds) {
-            if (bounds[key] !== undefined) {
-                array.unshift(bounds[key]);
-            }
-        }
-        return array;
-    }
-}
-function defaultEquals(a, b) {
-    return a === b;
-}
-function countNonZeroes(array) {
-    let count = 0;
-    for (let i = 0; i < array.length; i += 1) {
-        if (array[i] !== 0) {
-            count += 1;
-        }
-    }
-    return count;
-}
-function lpad(string, character, length) {
-    const array = new Array(length + 1);
-    const pad = array.join(character);
-    return (pad + string).slice(-length);
-}
-/* harmony default export */ const segmentation_floodFill = (floodFill);
-
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/PaintFillTool.js
 
 
@@ -34380,15 +35025,21 @@ function getBrushSizeForToolGroup(toolGroupId, toolName) {
 
 
 
-function setBrushThresholdForToolGroup(toolGroupId, threshold) {
+function setBrushThresholdForToolGroup(toolGroupId, threshold, otherArgs = { isDynamic: false }) {
     const toolGroup = ToolGroupManager_getToolGroup(toolGroupId);
     if (toolGroup === undefined) {
         return;
     }
     const brushBasedToolInstances = getBrushToolInstances(toolGroupId);
+    const configuration = {
+        ...otherArgs,
+        ...(threshold !== undefined && { threshold }),
+    };
     brushBasedToolInstances.forEach((tool) => {
-        tool.configuration.strategySpecificConfiguration.THRESHOLD_INSIDE_CIRCLE.threshold =
-            threshold;
+        tool.configuration.strategySpecificConfiguration.THRESHOLD = {
+            ...tool.configuration.strategySpecificConfiguration.THRESHOLD,
+            ...configuration,
+        };
     });
     const viewportsInfo = toolGroup.getViewportsInfo();
     if (!viewportsInfo.length) {
@@ -34413,8 +35064,8 @@ function getBrushThresholdForToolGroup(toolGroupId) {
     if (!brushToolInstance) {
         return;
     }
-    return brushToolInstance.configuration.strategySpecificConfiguration
-        .THRESHOLD_INSIDE_CIRCLE.threshold;
+    return brushToolInstance.configuration.strategySpecificConfiguration.THRESHOLD
+        .threshold;
 }
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/thresholdSegmentationByRange.js
@@ -37187,28 +37838,71 @@ function getActiveToolForKeyboardEvent(evt) {
     for (let j = 0; j < toolGroupToolNames.length; j++) {
         const toolName = toolGroupToolNames[j];
         const toolOptions = toolGroup.toolOptions[toolName];
+        if (toolOptions.mode !== getActiveToolForKeyboardEvent_Active) {
+            continue;
+        }
         const correctBinding = toolOptions.bindings.length &&
             toolOptions.bindings.some((binding) => binding.mouseButton === (mouseButton ?? defaultMousePrimary) &&
                 binding.modifierKey === modifierKey);
-        if (toolOptions.mode === getActiveToolForKeyboardEvent_Active && correctBinding) {
+        if (correctBinding) {
             return toolGroup.getToolInstance(toolName);
         }
     }
 }
 
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/eventDispatchers/shared/getToolsWithActionsForKeyboardEvents.js
+
+function getToolsWithModesForKeyboardEvent(evt, toolModes) {
+    const toolsWithActions = new Map();
+    const { renderingEngineId, viewportId } = evt.detail;
+    const toolGroup = ToolGroupManager_getToolGroupForViewport(viewportId, renderingEngineId);
+    if (!toolGroup) {
+        return toolsWithActions;
+    }
+    const toolGroupToolNames = Object.keys(toolGroup.toolOptions);
+    const key = evt.detail.key;
+    for (let j = 0; j < toolGroupToolNames.length; j++) {
+        const toolName = toolGroupToolNames[j];
+        const tool = toolGroup.getToolInstance(toolName);
+        const actionsConfig = tool.configuration?.actions;
+        if (!actionsConfig) {
+            continue;
+        }
+        const actions = Object.values(actionsConfig);
+        if (!actions?.length || !toolModes.includes(tool.mode)) {
+            continue;
+        }
+        const action = actions.find((action) => action.bindings.some((binding) => binding.key === key));
+        if (action) {
+            toolsWithActions.set(tool, action);
+        }
+    }
+    return toolsWithActions;
+}
+
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/eventDispatchers/keyboardEventHandlers/keyDown.js
 
 
+
+
 function keyDown(evt) {
     const activeTool = getActiveToolForKeyboardEvent(evt);
-    if (!activeTool) {
-        return;
+    if (activeTool) {
+        const { renderingEngineId, viewportId } = evt.detail;
+        const toolGroup = ToolGroupManager_getToolGroupForViewport(viewportId, renderingEngineId);
+        const toolName = activeTool.getToolName();
+        if (Object.keys(toolGroup.toolOptions).includes(toolName)) {
+            toolGroup.setViewportsCursorByToolName(toolName);
+        }
     }
-    const { renderingEngineId, viewportId } = evt.detail;
-    const toolGroup = ToolGroupManager_getToolGroupForViewport(viewportId, renderingEngineId);
-    const toolName = activeTool.getToolName();
-    if (Object.keys(toolGroup.toolOptions).includes(toolName)) {
-        toolGroup.setViewportsCursorByToolName(toolName);
+    const activeToolsWithEventBinding = getToolsWithModesForKeyboardEvent(evt, [
+        enums_ToolModes.Active,
+    ]);
+    if (activeToolsWithEventBinding?.size) {
+        const { element } = evt.detail;
+        for (const [key, value] of [...activeToolsWithEventBinding.entries()]) {
+            key[value.method](element);
+        }
     }
 }