@cornerstonejs/tools 3.0.2 → 3.0.4

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,92 @@
+import { triggerSegmentationDataModified } from '../../../../stateManagement/segmentation/events/triggerSegmentationDataModified';
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+import { getSegmentIndexColor, setSegmentIndexColor, } from '../../../../stateManagement/segmentation/config/segmentationColor';
+import { getViewportIdsWithSegmentation } from '../../../../stateManagement/segmentation/getViewportIdsWithSegmentation';
+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, configuration, enabledElement } = operationData;
+        if (!previewColors || !configuration) {
+            return;
+        }
+        if (operationData.preview) {
+            delete operationData.preview;
+        }
+        delete configuration.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, segmentationId, segmentationVoxelManager, } = operationData;
+        if (previewColors === undefined || !previewSegmentIndex) {
+            operationData.memo = operationData.createMemo(segmentationId, segmentationVoxelManager);
+            return;
+        }
+        if (preview) {
+            preview.previewVoxelManager.sourceVoxelManager =
+                operationData.segmentationVoxelManager;
+            operationData.previewVoxelManager = preview.previewVoxelManager;
+        }
+        if (segmentIndex === null) {
+            return;
+        }
+        const configColor = previewColors?.[segmentIndex];
+        const segmentColor = getSegmentIndexColor(operationData.viewport.id, operationData.segmentationId, segmentIndex);
+        if (!configColor && !segmentColor) {
+            return;
+        }
+        const previewColor = configColor || lightenColor(...segmentColor);
+        const viewportIds = getViewportIdsWithSegmentation(operationData.segmentationId);
+        viewportIds?.forEach((viewportId) => {
+            setSegmentIndexColor(viewportId, operationData.segmentationId, previewSegmentIndex, previewColor);
+        });
+    },
+    [StrategyCallbacks.AcceptPreview]: (operationData) => {
+        const { segmentationVoxelManager, previewVoxelManager: previewVoxelManager, previewSegmentIndex, segmentationId, preview, } = operationData || {};
+        if (previewSegmentIndex === undefined) {
+            return;
+        }
+        const segmentIndex = preview?.segmentIndex ?? operationData.segmentIndex;
+        if (!previewVoxelManager || previewVoxelManager.modifiedSlices.size === 0) {
+            return;
+        }
+        const memo = operationData.createMemo(segmentationId, segmentationVoxelManager);
+        operationData.memo = memo;
+        const { voxelManager } = memo;
+        const callback = ({ index, value }) => {
+            const oldValue = segmentationVoxelManager.getAtIndex(index);
+            if (oldValue === previewSegmentIndex) {
+                segmentationVoxelManager.setAtIndex(index, value);
+                voxelManager.setAtIndex(index, segmentIndex);
+            }
+        };
+        previewVoxelManager.forEach(callback, {});
+        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices(), preview.segmentIndex);
+        previewVoxelManager.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(), 0);
+        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, 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';
+export default {
+    [StrategyCallbacks.INTERNAL_setValue]: (operationData, { value, index }) => {
+        const { segmentsLocked, segmentIndex, previewSegmentIndex, segmentationVoxelManager, memo, } = operationData;
+        const previewVoxelManager = memo?.voxelManager || operationData.previewVoxelManager;
+        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;

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

@@ -0,0 +1,21 @@
+import { vec3 } from 'gl-matrix';
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+export default {
+    [StrategyCallbacks.CreateIsInThreshold]: (operationData) => {
+        const { imageVoxelManager, segmentIndex, configuration } = operationData;
+        if (!configuration || !segmentIndex) {
+            return;
+        }
+        return (index) => {
+            const voxelValue = imageVoxelManager.getAtIndex(index);
+            const gray = Array.isArray(voxelValue)
+                ? vec3.length(voxelValue)
+                : voxelValue;
+            const { threshold } = configuration || {};
+            if (!threshold?.range?.length) {
+                return true;
+            }
+            return threshold.range[0] <= gray && gray <= threshold.range[1];
+        };
+    },
+};

package/dist/esm/tools/segmentation/strategies/eraseCircle.d.ts

@@ -0,0 +1,2 @@
+declare const eraseInsideCircle: (enabledElement: any, operationData: any) => unknown;
+export { eraseInsideCircle };

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

@@ -0,0 +1,6 @@
+import BrushStrategy from './BrushStrategy';
+import { CIRCLE_STRATEGY } from './fillCircle';
+import compositions from './compositions';
+const ERASE_CIRCLE_STRATEGY = new BrushStrategy('EraseCircle', compositions.erase, ...CIRCLE_STRATEGY.compositions);
+const eraseInsideCircle = ERASE_CIRCLE_STRATEGY.strategyFunction;
+export { eraseInsideCircle };

package/dist/esm/tools/segmentation/strategies/eraseRectangle.d.ts

@@ -0,0 +1,8 @@
+import type { Types } from '@cornerstonejs/core';
+import type { LabelmapToolOperationData } from '../../../types';
+type OperationData = LabelmapToolOperationData & {
+    points: [Types.Point3, Types.Point3, Types.Point3, Types.Point3];
+};
+export declare function eraseInsideRectangle(enabledElement: Types.IEnabledElement, operationData: OperationData): void;
+export declare function eraseOutsideRectangle(enabledElement: Types.IEnabledElement, operationData: OperationData): void;
+export {};

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

@@ -0,0 +1,13 @@
+import { fillInsideRectangle } from './fillRectangle';
+function eraseRectangle(enabledElement, operationData, inside = true) {
+    const eraseOperationData = Object.assign({}, operationData, {
+        segmentIndex: 0,
+    });
+    fillInsideRectangle(enabledElement, eraseOperationData);
+}
+export function eraseInsideRectangle(enabledElement, operationData) {
+    eraseRectangle(enabledElement, operationData, true);
+}
+export function eraseOutsideRectangle(enabledElement, operationData) {
+    eraseRectangle(enabledElement, operationData, false);
+}

package/dist/esm/tools/segmentation/strategies/eraseSphere.d.ts

@@ -0,0 +1,2 @@
+declare const eraseInsideSphere: (enabledElement: any, operationData: any) => unknown;
+export { eraseInsideSphere };

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

@@ -0,0 +1,6 @@
+import BrushStrategy from './BrushStrategy';
+import { SPHERE_STRATEGY } from './fillSphere';
+import compositions from './compositions';
+const ERASE_SPHERE_STRATEGY = new BrushStrategy('EraseSphere', compositions.erase, ...SPHERE_STRATEGY.compositions);
+const eraseInsideSphere = ERASE_SPHERE_STRATEGY.strategyFunction;
+export { eraseInsideSphere };

package/dist/esm/tools/segmentation/strategies/fillCircle.d.ts

@@ -0,0 +1,14 @@
+import { vec3 } from 'gl-matrix';
+import type { Types } from '@cornerstonejs/core';
+import BrushStrategy from './BrushStrategy';
+declare function createPointInEllipse(worldInfo: {
+    topLeftWorld: Types.Point3;
+    bottomRightWorld: Types.Point3;
+    center: Types.Point3 | vec3;
+}): (pointLPS: Types.Point3) => boolean;
+declare const CIRCLE_STRATEGY: BrushStrategy;
+declare const CIRCLE_THRESHOLD_STRATEGY: BrushStrategy;
+declare const fillInsideCircle: (enabledElement: any, operationData: any) => unknown;
+declare const thresholdInsideCircle: (enabledElement: any, operationData: any) => unknown;
+export declare function fillOutsideCircle(): void;
+export { CIRCLE_STRATEGY, CIRCLE_THRESHOLD_STRATEGY, fillInsideCircle, thresholdInsideCircle, createPointInEllipse as createEllipseInPoint, };

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

@@ -0,0 +1,71 @@
+import { vec3 } from 'gl-matrix';
+import { utilities as csUtils } from '@cornerstonejs/core';
+import { getCanvasEllipseCorners, precalculatePointInEllipse, } from '../../../utilities/math/ellipse';
+import { getBoundingBoxAroundShapeIJK } from '../../../utilities/boundingBox';
+import BrushStrategy from './BrushStrategy';
+import { StrategyCallbacks } from '../../../enums';
+import compositions from './compositions';
+import { pointInSphere } from '../../../utilities/math/sphere';
+const { transformWorldToIndex, isEqual } = csUtils;
+const initializeCircle = {
+    [StrategyCallbacks.Initialize]: (operationData) => {
+        const { points, viewport, segmentationImageData, } = operationData;
+        if (!points) {
+            return;
+        }
+        const center = vec3.fromValues(0, 0, 0);
+        points.forEach((point) => {
+            vec3.add(center, center, point);
+        });
+        vec3.scale(center, center, 1 / points.length);
+        operationData.centerWorld = center;
+        operationData.centerIJK = 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 circleCornersIJK = points.map((world) => {
+            return transformWorldToIndex(segmentationImageData, world);
+        });
+        const boundsIJK = getBoundingBoxAroundShapeIJK(circleCornersIJK, segmentationImageData.getDimensions());
+        operationData.isInObject = createPointInEllipse({
+            topLeftWorld,
+            bottomRightWorld,
+            center,
+        });
+        operationData.isInObjectBoundsIJK = boundsIJK;
+    },
+};
+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 (isEqual(xRadius, radius) &&
+        isEqual(yRadius, radius) &&
+        isEqual(zRadius, radius)) {
+        const sphereObj = {
+            center,
+            radius,
+            radius2: radius * radius,
+        };
+        return (pointLPS) => pointInSphere(sphereObj, pointLPS);
+    }
+    const ellipseObj = {
+        center: center,
+        xRadius,
+        yRadius,
+        zRadius,
+    };
+    const { precalculated } = precalculatePointInEllipse(ellipseObj, {});
+    return precalculated;
+}
+const CIRCLE_STRATEGY = new BrushStrategy('Circle', compositions.regionFill, compositions.setValue, initializeCircle, compositions.determineSegmentIndex, compositions.preview, compositions.labelmapStatistics);
+const CIRCLE_THRESHOLD_STRATEGY = new BrushStrategy('CircleThreshold', compositions.regionFill, compositions.setValue, initializeCircle, compositions.determineSegmentIndex, compositions.dynamicThreshold, compositions.threshold, compositions.preview, compositions.islandRemoval, compositions.labelmapStatistics);
+const fillInsideCircle = CIRCLE_STRATEGY.strategyFunction;
+const thresholdInsideCircle = CIRCLE_THRESHOLD_STRATEGY.strategyFunction;
+export function fillOutsideCircle() {
+    throw new Error('Not yet implemented');
+}
+export { CIRCLE_STRATEGY, CIRCLE_THRESHOLD_STRATEGY, fillInsideCircle, thresholdInsideCircle, createPointInEllipse as createEllipseInPoint, };

package/dist/esm/tools/segmentation/strategies/fillRectangle.d.ts

@@ -0,0 +1,6 @@
+import BrushStrategy from './BrushStrategy';
+declare const RECTANGLE_STRATEGY: BrushStrategy;
+declare const RECTANGLE_THRESHOLD_STRATEGY: BrushStrategy;
+declare const fillInsideRectangle: (enabledElement: any, operationData: any) => unknown;
+declare const thresholdInsideRectangle: (enabledElement: any, operationData: any) => unknown;
+export { RECTANGLE_STRATEGY, RECTANGLE_THRESHOLD_STRATEGY, fillInsideRectangle, thresholdInsideRectangle, };

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

@@ -0,0 +1,71 @@
+import { vec3 } from 'gl-matrix';
+import { utilities as csUtils, StackViewport } from '@cornerstonejs/core';
+import { getBoundingBoxAroundShapeIJK, getBoundingBoxAroundShapeWorld, } from '../../../utilities/boundingBox';
+import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
+import { getStrategyData } from './utils/getStrategyData';
+import { isAxisAlignedRectangle } from '../../../utilities/rectangleROITool/isAxisAlignedRectangle';
+import BrushStrategy from './BrushStrategy';
+import { StrategyCallbacks } from '../../../enums';
+import compositions from './compositions';
+const { transformWorldToIndex } = csUtils;
+const initializeRectangle = {
+    [StrategyCallbacks.Initialize]: (operationData) => {
+        const { points, imageVoxelManager, viewport, segmentationImageData, segmentationVoxelManager, } = operationData;
+        if (!points) {
+            return;
+        }
+        const center = vec3.fromValues(0, 0, 0);
+        points.forEach((point) => {
+            vec3.add(center, center, point);
+        });
+        vec3.scale(center, center, 1 / points.length);
+        operationData.centerWorld = center;
+        operationData.centerIJK = transformWorldToIndex(segmentationImageData, center);
+        const { boundsIJK, pointInShapeFn } = createPointInRectangle(viewport, points, segmentationImageData);
+        operationData.isInObject = pointInShapeFn;
+        operationData.isInObjectBoundsIJK = boundsIJK;
+    },
+};
+function createPointInRectangle(viewport, points, segmentationImageData) {
+    let rectangleCornersIJK = points.map((world) => {
+        return transformWorldToIndex(segmentationImageData, world);
+    });
+    rectangleCornersIJK = rectangleCornersIJK.map((point) => {
+        return point.map((coord) => {
+            return Math.round(coord);
+        });
+    });
+    const boundsIJK = getBoundingBoxAroundShapeIJK(rectangleCornersIJK, segmentationImageData.getDimensions());
+    const isStackViewport = viewport instanceof StackViewport;
+    const isAligned = isStackViewport || isAxisAlignedRectangle(rectangleCornersIJK);
+    const direction = segmentationImageData.getDirection();
+    const spacing = segmentationImageData.getSpacing();
+    const { viewPlaneNormal } = viewport.getCamera();
+    const EPS = csUtils.getSpacingInNormalDirection({
+        direction,
+        spacing,
+    }, viewPlaneNormal);
+    const pointsBoundsLPS = getBoundingBoxAroundShapeWorld(points);
+    let [[xMin, xMax], [yMin, yMax], [zMin, zMax]] = pointsBoundsLPS;
+    xMin -= EPS;
+    xMax += EPS;
+    yMin -= EPS;
+    yMax += EPS;
+    zMin -= EPS;
+    zMax += EPS;
+    const pointInShapeFn = isAligned
+        ? () => true
+        : (pointLPS) => {
+            const [x, y, z] = pointLPS;
+            const xInside = x >= xMin && x <= xMax;
+            const yInside = y >= yMin && y <= yMax;
+            const zInside = z >= zMin && z <= zMax;
+            return xInside && yInside && zInside;
+        };
+    return { boundsIJK, pointInShapeFn };
+}
+const RECTANGLE_STRATEGY = new BrushStrategy('Rectangle', compositions.regionFill, compositions.setValue, initializeRectangle, compositions.determineSegmentIndex, compositions.preview, compositions.labelmapStatistics);
+const RECTANGLE_THRESHOLD_STRATEGY = new BrushStrategy('RectangleThreshold', compositions.regionFill, compositions.setValue, initializeRectangle, compositions.determineSegmentIndex, compositions.dynamicThreshold, compositions.threshold, compositions.preview, compositions.islandRemoval, compositions.labelmapStatistics);
+const fillInsideRectangle = RECTANGLE_STRATEGY.strategyFunction;
+const thresholdInsideRectangle = RECTANGLE_THRESHOLD_STRATEGY.strategyFunction;
+export { RECTANGLE_STRATEGY, RECTANGLE_THRESHOLD_STRATEGY, fillInsideRectangle, thresholdInsideRectangle, };

package/dist/esm/tools/segmentation/strategies/fillSphere.d.ts

@@ -0,0 +1,7 @@
+import BrushStrategy from './BrushStrategy';
+declare const SPHERE_STRATEGY: BrushStrategy;
+declare const fillInsideSphere: (enabledElement: any, operationData: any) => unknown;
+declare const thresholdInsideSphere: (enabledElement: any, operationData: any) => unknown;
+declare const thresholdInsideSphereIsland: (enabledElement: any, operationData: any) => unknown;
+export declare function fillOutsideSphere(): void;
+export { fillInsideSphere, thresholdInsideSphere, SPHERE_STRATEGY, thresholdInsideSphereIsland, };

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

@@ -0,0 +1,40 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+import { vec3 } from 'gl-matrix';
+import BrushStrategy from './BrushStrategy';
+import compositions from './compositions';
+import StrategyCallbacks from '../../../enums/StrategyCallbacks';
+import { createEllipseInPoint } from './fillCircle';
+const { transformWorldToIndex } = csUtils;
+import { getSphereBoundsInfoFromViewport } from '../../../utilities/getSphereBoundsInfo';
+const sphereComposition = {
+    [StrategyCallbacks.Initialize]: (operationData) => {
+        const { points, viewport, segmentationImageData } = operationData;
+        if (!points) {
+            return;
+        }
+        const center = vec3.fromValues(0, 0, 0);
+        points.forEach((point) => {
+            vec3.add(center, center, point);
+        });
+        vec3.scale(center, center, 1 / points.length);
+        operationData.centerWorld = center;
+        operationData.centerIJK = transformWorldToIndex(segmentationImageData, center);
+        const { boundsIJK: newBoundsIJK, topLeftWorld, bottomRightWorld, } = getSphereBoundsInfoFromViewport(points.slice(0, 2), segmentationImageData, viewport);
+        operationData.isInObjectBoundsIJK = newBoundsIJK;
+        operationData.isInObject = createEllipseInPoint({
+            topLeftWorld,
+            bottomRightWorld,
+            center,
+        });
+    },
+};
+const SPHERE_STRATEGY = new BrushStrategy('Sphere', compositions.regionFill, compositions.setValue, sphereComposition, compositions.determineSegmentIndex, compositions.preview, compositions.labelmapStatistics, compositions.ensureSegmentationVolumeFor3DManipulation);
+const fillInsideSphere = SPHERE_STRATEGY.strategyFunction;
+const SPHERE_THRESHOLD_STRATEGY = new BrushStrategy('SphereThreshold', ...SPHERE_STRATEGY.compositions, compositions.dynamicThreshold, compositions.threshold, compositions.ensureSegmentationVolumeFor3DManipulation, compositions.ensureImageVolumeFor3DManipulation);
+const SPHERE_THRESHOLD_STRATEGY_ISLAND = new BrushStrategy('SphereThreshold', ...SPHERE_STRATEGY.compositions, compositions.dynamicThreshold, compositions.threshold, compositions.islandRemoval, compositions.ensureSegmentationVolumeFor3DManipulation, compositions.ensureImageVolumeFor3DManipulation);
+const thresholdInsideSphere = SPHERE_THRESHOLD_STRATEGY.strategyFunction;
+const thresholdInsideSphereIsland = SPHERE_THRESHOLD_STRATEGY_ISLAND.strategyFunction;
+export function fillOutsideSphere() {
+    throw new Error('fill outside sphere not implemented');
+}
+export { fillInsideSphere, thresholdInsideSphere, SPHERE_STRATEGY, thresholdInsideSphereIsland, };

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

@@ -0,0 +1,3 @@
+import { fillInsideRectangle, thresholdInsideRectangle } from './fillRectangle';
+import { fillInsideCircle, fillOutsideCircle } from './fillCircle';
+export { fillInsideRectangle, thresholdInsideRectangle, fillInsideCircle, fillOutsideCircle, };

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

@@ -0,0 +1,3 @@
+import { fillInsideRectangle, thresholdInsideRectangle } from './fillRectangle';
+import { fillInsideCircle, fillOutsideCircle } from './fillCircle';
+export { fillInsideRectangle, thresholdInsideRectangle, fillInsideCircle, fillOutsideCircle, };

package/dist/esm/tools/segmentation/strategies/utils/getStrategyData.d.ts

@@ -0,0 +1,15 @@
+import { type Types } from '@cornerstonejs/core';
+import type { LabelmapToolOperationDataStack, LabelmapToolOperationDataVolume } from '../../../../types';
+declare function getStrategyData({ operationData, viewport, strategy, }: {
+    operationData: LabelmapToolOperationDataStack | LabelmapToolOperationDataVolume;
+    viewport?: Types.IStackViewport | Types.IVolumeViewport;
+    strategy: unknown;
+}): {
+    segmentationImageData: any;
+    segmentationScalarData: any;
+    imageScalarData: any;
+    segmentationVoxelManager: any;
+    imageVoxelManager: any;
+    imageData: any;
+};
+export { getStrategyData };

package/dist/esm/tools/segmentation/strategies/utils/getStrategyData.js

@@ -0,0 +1,112 @@
+import { BaseVolumeViewport, cache, Enums, eventTarget, } from '@cornerstonejs/core';
+import { getCurrentLabelmapImageIdForViewport } from '../../../../stateManagement/segmentation/segmentationState';
+import { getLabelmapActorEntry } from '../../../../stateManagement/segmentation/helpers';
+function getStrategyDataForVolumeViewport({ operationData }) {
+    const { volumeId } = operationData;
+    if (!volumeId) {
+        const event = new CustomEvent(Enums.Events.ERROR_EVENT, {
+            detail: {
+                type: 'Segmentation',
+                message: 'No volume id found for the segmentation',
+            },
+            cancelable: true,
+        });
+        eventTarget.dispatchEvent(event);
+        return null;
+    }
+    const segmentationVolume = cache.getVolume(volumeId);
+    if (!segmentationVolume) {
+        return null;
+    }
+    const referencedVolumeId = segmentationVolume.referencedVolumeId;
+    const segmentationVoxelManager = segmentationVolume.voxelManager;
+    let imageVoxelManager;
+    let imageData;
+    if (referencedVolumeId) {
+        const imageVolume = cache.getVolume(referencedVolumeId);
+        imageVoxelManager = imageVolume.voxelManager;
+        imageData = imageVolume.imageData;
+    }
+    const { imageData: segmentationImageData } = segmentationVolume;
+    return {
+        segmentationImageData,
+        segmentationVoxelManager,
+        segmentationScalarData: null,
+        imageScalarData: null,
+        imageVoxelManager,
+        imageData,
+    };
+}
+function getStrategyDataForStackViewport({ operationData, viewport, strategy, }) {
+    const { segmentationId } = operationData;
+    let segmentationImageData;
+    let segmentationVoxelManager;
+    let segmentationScalarData;
+    let imageScalarData;
+    let imageVoxelManager;
+    let imageData;
+    if (strategy.ensureSegmentationVolumeFor3DManipulation) {
+        strategy.ensureSegmentationVolumeFor3DManipulation({
+            operationData,
+            viewport,
+        });
+        segmentationVoxelManager = operationData.segmentationVoxelManager;
+        segmentationImageData = operationData.segmentationImageData;
+        segmentationScalarData = null;
+    }
+    else {
+        const labelmapImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
+        if (!labelmapImageId) {
+            return null;
+        }
+        const actorEntry = getLabelmapActorEntry(viewport.id, segmentationId);
+        if (!actorEntry) {
+            return null;
+        }
+        const currentSegImage = cache.getImage(labelmapImageId);
+        segmentationImageData = actorEntry.actor.getMapper().getInputData();
+        segmentationVoxelManager = currentSegImage.voxelManager;
+        const currentSegmentationImageId = operationData.imageId;
+        const segmentationImage = cache.getImage(currentSegmentationImageId);
+        if (!segmentationImage) {
+            return null;
+        }
+        segmentationScalarData = segmentationImage.getPixelData?.();
+    }
+    if (strategy.ensureImageVolumeFor3DManipulation) {
+        strategy.ensureImageVolumeFor3DManipulation({
+            operationData,
+            viewport,
+        });
+        imageVoxelManager = operationData.imageVoxelManager;
+        imageScalarData = operationData.imageScalarData;
+        imageData = operationData.imageData;
+    }
+    else {
+        const currentImageId = viewport.getCurrentImageId();
+        if (!currentImageId) {
+            return null;
+        }
+        const image = cache.getImage(currentImageId);
+        imageData = image ? null : viewport.getImageData();
+        imageScalarData = image?.getPixelData() || imageData.getScalarData();
+        imageVoxelManager = image?.voxelManager;
+    }
+    return {
+        segmentationImageData,
+        segmentationScalarData,
+        imageScalarData,
+        segmentationVoxelManager,
+        imageVoxelManager,
+        imageData,
+    };
+}
+function getStrategyData({ operationData, viewport, strategy, }) {
+    if (('volumeId' in operationData && operationData.volumeId != null) ||
+        ('referencedVolumeId' in operationData &&
+            operationData.referencedVolumeId != null)) {
+        return getStrategyDataForVolumeViewport({ operationData });
+    }
+    return getStrategyDataForStackViewport({ operationData, viewport, strategy });
+}
+export { getStrategyData };

package/dist/esm/tools/segmentation/strategies/utils/isWithinThreshold.d.ts

@@ -0,0 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+declare function isWithinThreshold(index: number, imageScalarData: Types.PixelDataTypedArray, threshold: {
+    range: number[];
+}): boolean;
+export default isWithinThreshold;

package/dist/esm/tools/segmentation/strategies/utils/isWithinThreshold.js

@@ -0,0 +1,8 @@
+function isWithinThreshold(index, imageScalarData, threshold) {
+    if (!threshold) {
+        return true;
+    }
+    const voxelValue = imageScalarData[index];
+    return threshold.range[0] <= voxelValue && voxelValue <= threshold.range[1];
+}
+export default isWithinThreshold;

package/dist/esm/types/AnnotationGroupSelector.d.ts

@@ -0,0 +1,2 @@
+type AnnotationGroupSelector = HTMLDivElement | string;
+export type { AnnotationGroupSelector as default };

package/dist/esm/types/AnnotationRenderContext.d.ts

@@ -0,0 +1,12 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Annotation } from './AnnotationTypes';
+import type SVGDrawingHelper from './SVGDrawingHelper';
+import type { AnnotationStyle } from './AnnotationStyle';
+type AnnotationRenderContext = {
+    enabledElement: Types.IEnabledElement;
+    targetId: string;
+    annotation: Annotation;
+    annotationStyle: AnnotationStyle;
+    svgDrawingHelper: SVGDrawingHelper;
+};
+export type { AnnotationRenderContext as default };