@cornerstonejs/tools 3.0.2 → 3.0.3

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

@@ -0,0 +1,125 @@
+import type { Types } from '@cornerstonejs/core';
+import { StrategyCallbacks } from '../../../enums';
+import type { LabelmapToolOperationDataAny } from '../../../types/LabelmapToolOperationData';
+import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import type { LabelmapMemo } from '../../../utilities/segmentation/createLabelmapMemo';
+export type InitializedOperationData = LabelmapToolOperationDataAny & {
+    operationName?: string;
+    enabledElement: Types.IEnabledElement;
+    centerIJK?: Types.Point3;
+    centerWorld: Types.Point3;
+    isInObject: (point: Types.Point3) => boolean;
+    isInObjectBoundsIJK: Types.BoundsIJK;
+    viewport: Types.IViewport;
+    imageVoxelManager: Types.IVoxelManager<number> | Types.IVoxelManager<Types.RGB>;
+    segmentationVoxelManager: Types.IVoxelManager<number>;
+    segmentationImageData: vtkImageData;
+    previewVoxelManager: Types.IVoxelManager<number>;
+    previewSegmentIndex?: number;
+    brushStrategy: BrushStrategy;
+    activeStrategy: string;
+    configuration?: {
+        [key: string]: unknown;
+        centerSegmentIndex?: {
+            segmentIndex: number;
+        };
+        threshold?: {
+            range?: number[];
+            isDynamic: boolean;
+            dynamicRadius: number;
+            dynamicRadiusInCanvas?: number;
+        };
+    };
+    memo?: LabelmapMemo;
+};
+export type StrategyFunction = (operationData: InitializedOperationData, ...args: any[]) => unknown;
+export type CompositionInstance = {
+    [callback in StrategyCallbacks]?: StrategyFunction;
+};
+export type CompositionFunction = () => CompositionInstance;
+export type Composition = CompositionFunction | CompositionInstance;
+export default class BrushStrategy {
+    static COMPOSITIONS: {
+        determineSegmentIndex: {
+            initialize: (operationData: InitializedOperationData) => void;
+            onInteractionStart: (operationData: InitializedOperationData) => void;
+        };
+        dynamicThreshold: {
+            initialize: (operationData: InitializedOperationData) => void;
+            onInteractionStart: (operationData: InitializedOperationData) => void;
+            computeInnerCircleRadius: (operationData: InitializedOperationData) => void;
+        };
+        erase: {
+            initialize: (operationData: InitializedOperationData) => void;
+        };
+        islandRemoval: {
+            onInteractionEnd: (operationData: InitializedOperationData) => void;
+        };
+        preview: {
+            preview: (operationData: InitializedOperationData) => any;
+            initialize: (operationData: InitializedOperationData) => void;
+            acceptPreview: (operationData: InitializedOperationData) => void;
+            rejectPreview: (operationData: InitializedOperationData) => void;
+        };
+        regionFill: {
+            fill: (operationData: InitializedOperationData) => void;
+        };
+        setValue: {
+            setValue: (operationData: InitializedOperationData, { value, index }: {
+                value: any;
+                index: any;
+            }) => void;
+        };
+        threshold: {
+            createIsInThreshold: (operationData: InitializedOperationData) => (index: any) => boolean;
+        };
+        labelmapStatistics: {
+            getStatistics: (enabledElement: any, operationData: InitializedOperationData, options?: {
+                indices?: number | number[];
+            }) => void;
+        };
+        ensureSegmentationVolumeFor3DManipulation: {
+            ensureSegmentationVolumeFor3DManipulation: (data: any) => void;
+        };
+        ensureImageVolumeFor3DManipulation: {
+            ensureImageVolumeFor3DManipulation: (data: any) => void;
+        };
+    };
+    protected static childFunctions: {
+        onInteractionStart: (brushStrategy: any, func: any) => void;
+        onInteractionEnd: (brushStrategy: any, func: any) => void;
+        fill: (brushStrategy: any, func: any) => void;
+        initialize: (brushStrategy: any, func: any) => void;
+        createIsInThreshold: (brushStrategy: any, func: any) => void;
+        interpolate: (brushStrategy: any, func: any) => void;
+        acceptPreview: (brushStrategy: any, func: any) => void;
+        rejectPreview: (brushStrategy: any, func: any) => void;
+        setValue: (brushStrategy: any, func: any) => void;
+        preview: (brushStrategy: any, func: any) => void;
+        computeInnerCircleRadius: (brushStrategy: any, func: any) => void;
+        ensureSegmentationVolumeFor3DManipulation: (brushStrategy: any, func: any) => void;
+        ensureImageVolumeFor3DManipulation: (brushStrategy: any, func: any) => void;
+        addPreview: (brushStrategy: any, func: any) => void;
+        getStatistics: (brushStrategy: any, func: any) => void;
+        compositions: any;
+    };
+    compositions: Composition[];
+    strategyFunction: (enabledElement: any, operationData: any) => unknown;
+    protected configurationName: string;
+    protected _initialize: any[];
+    protected _fill: any[];
+    protected _acceptPreview: [];
+    protected _onInteractionStart: any[];
+    constructor(name: any, ...initializers: Composition[]);
+    fill: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => any;
+    protected initialize(enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny, operationName?: string): InitializedOperationData;
+    onInteractionStart: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => void;
+    onInteractionEnd: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => void;
+    rejectPreview: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => void;
+    addPreview: (enabledElement: any, operationData: LabelmapToolOperationDataAny) => any;
+    acceptPreview: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => void;
+    preview: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => unknown;
+    interpolate: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => unknown;
+    setValue: (operationData: InitializedOperationData, data: any) => void;
+    createIsInThreshold: (operationData: InitializedOperationData) => any;
+}

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

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

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

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

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

@@ -0,0 +1,59 @@
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+export default {
+    [StrategyCallbacks.Initialize]: (operationData) => {
+        const { centerSegmentIndex } = operationData.configuration || {};
+        if (!centerSegmentIndex) {
+            return;
+        }
+        operationData.segmentIndex = centerSegmentIndex.segmentIndex;
+    },
+    [StrategyCallbacks.OnInteractionStart]: (operationData) => {
+        const { segmentIndex, previewSegmentIndex, segmentationVoxelManager, centerIJK, viewPlaneNormal, segmentationImageData, preview, configuration, } = operationData;
+        if (!configuration?.useCenterSegmentIndex) {
+            return;
+        }
+        delete configuration.centerSegmentIndex;
+        let hasSegmentIndex = false;
+        let hasPreviewIndex = false;
+        const nestedBounds = [
+            ...segmentationVoxelManager.getBoundsIJK(),
+        ];
+        if (Math.abs(viewPlaneNormal[0]) > 0.8) {
+            nestedBounds[0] = [centerIJK[0], centerIJK[0]];
+        }
+        else if (Math.abs(viewPlaneNormal[1]) > 0.8) {
+            nestedBounds[1] = [centerIJK[1], centerIJK[1]];
+        }
+        else if (Math.abs(viewPlaneNormal[2]) > 0.8) {
+            nestedBounds[2] = [centerIJK[2], centerIJK[2]];
+        }
+        const callback = ({ value }) => {
+            hasSegmentIndex ||= value === segmentIndex;
+            hasPreviewIndex ||= value === previewSegmentIndex;
+        };
+        segmentationVoxelManager.forEach(callback, {
+            imageData: segmentationImageData,
+            isInObject: operationData.isInObject,
+            boundsIJK: nestedBounds,
+        });
+        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;
+        configuration.centerSegmentIndex = {
+            segmentIndex: existingValue,
+        };
+    },
+};

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

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

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

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

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

@@ -0,0 +1,4 @@
+declare const _default: {
+    ensureImageVolumeFor3DManipulation: (data: any) => void;
+};
+export default _default;

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

@@ -0,0 +1,35 @@
+import { cache, utilities as csUtils, volumeLoader } from '@cornerstonejs/core';
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+import { getSegmentation } from '../../../../stateManagement/segmentation/getSegmentation';
+export default {
+    [StrategyCallbacks.EnsureImageVolumeFor3DManipulation]: (data) => {
+        const { operationData, viewport } = data;
+        let referencedImageIds;
+        if (viewport) {
+            referencedImageIds = viewport.getImageIds();
+            const isValidVolumeForSphere = csUtils.isValidVolume(referencedImageIds);
+            if (!isValidVolumeForSphere) {
+                throw new Error('Volume is not reconstructable for sphere manipulation');
+            }
+        }
+        else {
+            const segmentation = getSegmentation(operationData.segmentationId);
+            const imageIds = segmentation.representationData
+                .Labelmap.imageIds;
+            referencedImageIds = imageIds.map((imageId) => {
+                const image = cache.getImage(imageId);
+                return image.referencedImageId;
+            });
+        }
+        const volumeId = cache.generateVolumeId(referencedImageIds);
+        let imageVolume = cache.getVolume(volumeId);
+        if (imageVolume) {
+            operationData.imageVoxelManager = imageVolume.voxelManager;
+            operationData.imageData = imageVolume.imageData;
+            return;
+        }
+        imageVolume = volumeLoader.createAndCacheVolumeFromImagesSync(volumeId, referencedImageIds);
+        operationData.imageVoxelManager = imageVolume.voxelManager;
+        operationData.imageData = imageVolume.imageData;
+    },
+};

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

@@ -0,0 +1,4 @@
+declare const _default: {
+    ensureSegmentationVolumeFor3DManipulation: (data: any) => void;
+};
+export default _default;

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

@@ -0,0 +1,20 @@
+import { utilities, cache } from '@cornerstonejs/core';
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+import getOrCreateSegmentationVolume from '../../../../utilities/segmentation/getOrCreateSegmentationVolume';
+export default {
+    [StrategyCallbacks.EnsureSegmentationVolumeFor3DManipulation]: (data) => {
+        const { operationData, viewport } = data;
+        const { segmentationId, imageIds: segImageIds } = operationData;
+        const referencedImageIds = viewport
+            ? viewport.getImageIds()
+            : segImageIds.map((imageId) => cache.getImage(imageId).referencedImageId);
+        const isValidVolumeForSphere = utilities.isValidVolume(referencedImageIds);
+        if (!isValidVolumeForSphere) {
+            throw new Error('Volume is not reconstructable for sphere manipulation');
+        }
+        const segVolume = getOrCreateSegmentationVolume(segmentationId);
+        operationData.segmentationVoxelManager = segVolume.voxelManager;
+        operationData.segmentationImageData = segVolume.imageData;
+        return;
+    },
+};

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

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

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

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

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

@@ -0,0 +1,47 @@
+declare const _default: {
+    determineSegmentIndex: {
+        initialize: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
+        onInteractionStart: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
+    };
+    dynamicThreshold: {
+        initialize: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
+        onInteractionStart: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
+        computeInnerCircleRadius: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
+    };
+    erase: {
+        initialize: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
+    };
+    islandRemoval: {
+        onInteractionEnd: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
+    };
+    preview: {
+        preview: (operationData: import("../BrushStrategy").InitializedOperationData) => any;
+        initialize: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
+        acceptPreview: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
+        rejectPreview: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
+    };
+    regionFill: {
+        fill: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
+    };
+    setValue: {
+        setValue: (operationData: import("../BrushStrategy").InitializedOperationData, { value, index }: {
+            value: any;
+            index: any;
+        }) => void;
+    };
+    threshold: {
+        createIsInThreshold: (operationData: import("../BrushStrategy").InitializedOperationData) => (index: any) => boolean;
+    };
+    labelmapStatistics: {
+        getStatistics: (enabledElement: any, operationData: import("../BrushStrategy").InitializedOperationData, options?: {
+            indices?: number | number[];
+        }) => void;
+    };
+    ensureSegmentationVolumeFor3DManipulation: {
+        ensureSegmentationVolumeFor3DManipulation: (data: any) => void;
+    };
+    ensureImageVolumeFor3DManipulation: {
+        ensureImageVolumeFor3DManipulation: (data: any) => void;
+    };
+};
+export default _default;

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

@@ -0,0 +1,24 @@
+import determineSegmentIndex from './determineSegmentIndex';
+import dynamicThreshold from './dynamicThreshold';
+import erase from './erase';
+import islandRemoval from './islandRemovalComposition';
+import preview from './preview';
+import regionFill from './regionFill';
+import setValue from './setValue';
+import threshold from './threshold';
+import labelmapStatistics from './labelmapStatistics';
+import ensureSegmentationVolumeFor3DManipulation from './ensureSegmentationVolume';
+import ensureImageVolumeFor3DManipulation from './ensureImageVolume';
+export default {
+    determineSegmentIndex,
+    dynamicThreshold,
+    erase,
+    islandRemoval,
+    preview,
+    regionFill,
+    setValue,
+    threshold,
+    labelmapStatistics,
+    ensureSegmentationVolumeFor3DManipulation,
+    ensureImageVolumeFor3DManipulation,
+};

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

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

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

@@ -0,0 +1,28 @@
+import { triggerSegmentationDataModified } from '../../../../stateManagement/segmentation/triggerSegmentationEvents';
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+import IslandRemoval from '../../../../utilities/segmentation/islandRemoval';
+export default {
+    [StrategyCallbacks.OnInteractionEnd]: (operationData) => {
+        const { previewSegmentIndex, segmentIndex, viewport, previewVoxelManager, segmentationVoxelManager, activeStrategy, } = operationData;
+        if (activeStrategy !== 'THRESHOLD_INSIDE_SPHERE_WITH_ISLAND_REMOVAL' ||
+            segmentIndex === null) {
+            return;
+        }
+        const islandRemoval = new IslandRemoval();
+        const voxelManager = previewVoxelManager ?? segmentationVoxelManager;
+        if (!islandRemoval.initialize(viewport, voxelManager, {
+            previewSegmentIndex,
+            segmentIndex,
+        })) {
+            return;
+        }
+        islandRemoval.floodFillSegmentIsland();
+        islandRemoval.removeExternalIslands();
+        islandRemoval.removeInternalIslands();
+        const arrayOfSlices = voxelManager.getArrayOfModifiedSlices();
+        if (!arrayOfSlices) {
+            return;
+        }
+        triggerSegmentationDataModified(operationData.segmentationId, arrayOfSlices, previewSegmentIndex);
+    },
+};

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

@@ -0,0 +1,7 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+declare const _default: {
+    getStatistics: (enabledElement: any, operationData: InitializedOperationData, options?: {
+        indices?: number | number[];
+    }) => void;
+};
+export default _default;

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

@@ -0,0 +1,12 @@
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+import getStatistics from '../../../../utilities/segmentation/getStatistics';
+export default {
+    [StrategyCallbacks.GetStatistics]: function (enabledElement, operationData, options) {
+        const { indices } = options;
+        const { segmentationId, viewport } = operationData;
+        getStatistics({
+            segmentationId,
+            segmentIndices: indices,
+        });
+    },
+};