@cornerstonejs/tools 3.0.2 → 3.0.3

package/dist/esm/tools/segmentation/CircleScissorsTool.js

@@ -0,0 +1,233 @@
+import { BaseVolumeViewport, cache, getEnabledElement, } from '@cornerstonejs/core';
+import { BaseTool } from '../base';
+import { fillInsideCircle } from './strategies/fillCircle';
+import { eraseInsideCircle } from './strategies/eraseCircle';
+import { Events } from '../../enums';
+import { drawCircle as drawCircleSvg } from '../../drawingSvg';
+import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
+import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
+import { segmentLocking, activeSegmentation, segmentIndex as segmentIndexController, config as segmentationConfig, } from '../../stateManagement/segmentation';
+import { getCurrentLabelmapImageIdForViewport, getSegmentation, } from '../../stateManagement/segmentation/segmentationState';
+import LabelmapBaseTool from './LabelmapBaseTool';
+class CircleScissorsTool extends LabelmapBaseTool {
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            strategies: {
+                FILL_INSIDE: fillInsideCircle,
+                ERASE_INSIDE: eraseInsideCircle,
+            },
+            defaultStrategy: 'FILL_INSIDE',
+            activeStrategy: 'FILL_INSIDE',
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this.preMouseDownCallback = (evt) => {
+            if (this.isDrawing === true) {
+                return;
+            }
+            const eventDetail = evt.detail;
+            const { currentPoints, element } = eventDetail;
+            const worldPos = currentPoints.world;
+            const canvasPos = currentPoints.canvas;
+            const enabledElement = getEnabledElement(element);
+            const { viewport } = enabledElement;
+            this.isDrawing = true;
+            const camera = viewport.getCamera();
+            const { viewPlaneNormal, viewUp } = camera;
+            const activeLabelmapSegmentation = activeSegmentation.getActiveSegmentation(viewport.id);
+            if (!activeLabelmapSegmentation) {
+                throw new Error('No active segmentation detected, create one before using scissors tool');
+            }
+            const { segmentationId } = activeLabelmapSegmentation;
+            const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
+            const segmentsLocked = segmentLocking.getLockedSegmentIndices(segmentationId);
+            const segmentColor = segmentationConfig.color.getSegmentIndexColor(viewport.id, segmentationId, segmentIndex);
+            const { representationData } = getSegmentation(segmentationId);
+            const labelmapData = representationData.Labelmap;
+            if (!labelmapData) {
+                throw new Error('No labelmap data found for the active segmentation, create one before using scissors tool');
+            }
+            const annotation = {
+                invalidated: true,
+                highlighted: true,
+                metadata: {
+                    viewPlaneNormal: [...viewPlaneNormal],
+                    viewUp: [...viewUp],
+                    FrameOfReferenceUID: viewport.getFrameOfReferenceUID(),
+                    referencedImageId: '',
+                    toolName: this.getToolName(),
+                    segmentColor,
+                },
+                data: {
+                    handles: {
+                        points: [
+                            [...worldPos],
+                            [...worldPos],
+                            [...worldPos],
+                            [...worldPos],
+                        ],
+                        activeHandleIndex: null,
+                    },
+                    isDrawing: true,
+                    cachedStats: {},
+                },
+            };
+            const viewportIdsToRender = [viewport.id];
+            this.editData = {
+                annotation,
+                centerCanvas: canvasPos,
+                segmentIndex,
+                segmentationId,
+                segmentsLocked,
+                segmentColor,
+                viewportIdsToRender,
+                handleIndex: 3,
+                movingTextBox: false,
+                newAnnotation: true,
+                hasMoved: false,
+                volumeId: null,
+                referencedVolumeId: null,
+                imageId: null,
+            };
+            if (viewport instanceof BaseVolumeViewport) {
+                const { volumeId } = labelmapData;
+                const segmentation = cache.getVolume(volumeId);
+                this.editData = {
+                    ...this.editData,
+                    volumeId,
+                    referencedVolumeId: segmentation.referencedVolumeId,
+                };
+            }
+            else {
+                const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
+                this.editData = {
+                    ...this.editData,
+                    imageId: segmentationImageId,
+                };
+            }
+            this._activateDraw(element);
+            hideElementCursor(element);
+            evt.preventDefault();
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+            return true;
+        };
+        this._dragCallback = (evt) => {
+            this.isDrawing = true;
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { currentPoints } = eventDetail;
+            const currentCanvasPoints = currentPoints.canvas;
+            const enabledElement = getEnabledElement(element);
+            const { renderingEngine, viewport } = enabledElement;
+            const { canvasToWorld } = viewport;
+            const { annotation, viewportIdsToRender, centerCanvas } = this.editData;
+            const { data } = annotation;
+            const dX = Math.abs(currentCanvasPoints[0] - centerCanvas[0]);
+            const dY = Math.abs(currentCanvasPoints[1] - centerCanvas[1]);
+            const radius = Math.sqrt(dX * dX + dY * dY);
+            const bottomCanvas = [
+                centerCanvas[0],
+                centerCanvas[1] + radius,
+            ];
+            const topCanvas = [centerCanvas[0], centerCanvas[1] - radius];
+            const leftCanvas = [
+                centerCanvas[0] - radius,
+                centerCanvas[1],
+            ];
+            const rightCanvas = [
+                centerCanvas[0] + radius,
+                centerCanvas[1],
+            ];
+            data.handles.points = [
+                canvasToWorld(bottomCanvas),
+                canvasToWorld(topCanvas),
+                canvasToWorld(leftCanvas),
+                canvasToWorld(rightCanvas),
+            ];
+            annotation.invalidated = true;
+            this.editData.hasMoved = true;
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+        };
+        this._endCallback = (evt) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { annotation, newAnnotation, hasMoved } = this.editData;
+            const { data } = annotation;
+            const { viewPlaneNormal, viewUp } = annotation.metadata;
+            if (newAnnotation && !hasMoved) {
+                return;
+            }
+            data.handles.activeHandleIndex = null;
+            this._deactivateDraw(element);
+            resetElementCursor(element);
+            const enabledElement = getEnabledElement(element);
+            const operationData = {
+                ...this.editData,
+                points: data.handles.points,
+                viewPlaneNormal,
+                viewUp,
+                createMemo: this.createMemo.bind(this),
+            };
+            this.editData = null;
+            this.isDrawing = false;
+            this.applyActiveStrategy(enabledElement, operationData);
+            this.doneEditMemo();
+        };
+        this._activateDraw = (element) => {
+            element.addEventListener(Events.MOUSE_UP, this._endCallback);
+            element.addEventListener(Events.MOUSE_DRAG, this._dragCallback);
+            element.addEventListener(Events.MOUSE_CLICK, this._endCallback);
+            element.addEventListener(Events.MOUSE_MOVE, this._dragCallback);
+            element.addEventListener(Events.TOUCH_TAP, this._endCallback);
+            element.addEventListener(Events.TOUCH_DRAG, this._dragCallback);
+            element.addEventListener(Events.TOUCH_END, this._endCallback);
+        };
+        this._deactivateDraw = (element) => {
+            element.removeEventListener(Events.MOUSE_UP, this._endCallback);
+            element.removeEventListener(Events.MOUSE_DRAG, this._dragCallback);
+            element.removeEventListener(Events.MOUSE_CLICK, this._endCallback);
+            element.removeEventListener(Events.MOUSE_MOVE, this._dragCallback);
+            element.removeEventListener(Events.TOUCH_END, this._endCallback);
+            element.removeEventListener(Events.TOUCH_DRAG, this._dragCallback);
+            element.removeEventListener(Events.TOUCH_TAP, this._endCallback);
+        };
+        this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
+            let renderStatus = false;
+            if (!this.editData) {
+                return renderStatus;
+            }
+            const { viewport } = enabledElement;
+            const { viewportIdsToRender } = this.editData;
+            if (!viewportIdsToRender.includes(viewport.id)) {
+                return renderStatus;
+            }
+            const { annotation } = this.editData;
+            const toolMetadata = annotation.metadata;
+            const annotationUID = annotation.annotationUID;
+            const data = annotation.data;
+            const { points } = data.handles;
+            const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
+            const bottom = canvasCoordinates[0];
+            const top = canvasCoordinates[1];
+            const center = [
+                Math.floor((bottom[0] + top[0]) / 2),
+                Math.floor((bottom[1] + top[1]) / 2),
+            ];
+            const radius = Math.abs(bottom[1] - Math.floor((bottom[1] + top[1]) / 2));
+            const color = `rgb(${toolMetadata.segmentColor.slice(0, 3)})`;
+            if (!viewport.getRenderingEngine()) {
+                console.warn('Rendering Engine has been destroyed');
+                return renderStatus;
+            }
+            const circleUID = '0';
+            drawCircleSvg(svgDrawingHelper, annotationUID, circleUID, center, radius, {
+                color,
+            });
+            renderStatus = true;
+            return renderStatus;
+        };
+    }
+}
+CircleScissorsTool.toolName = 'CircleScissor';
+export default CircleScissorsTool;

package/dist/esm/tools/segmentation/LabelmapBaseTool.d.ts

@@ -0,0 +1,99 @@
+import type { Types } from '@cornerstonejs/core';
+import { BaseTool } from '../base';
+import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import * as LabelmapMemo from '../../utilities/segmentation/createLabelmapMemo';
+import type { LabelmapToolOperationData } from '../../types/LabelmapToolOperationData';
+export type PreviewData = {
+    preview: unknown;
+    timer?: number;
+    timerStart: number;
+    startPoint: Types.Point2;
+    element: HTMLDivElement;
+    isDrag: boolean;
+};
+type EditDataReturnType = {
+    volumeId: string;
+    referencedVolumeId: string;
+    segmentsLocked: number[];
+} | {
+    imageId: string;
+    segmentsLocked: number[];
+    override?: {
+        voxelManager: Types.IVoxelManager<number> | Types.IVoxelManager<Types.RGB>;
+        imageData: vtkImageData;
+    };
+} | null;
+type ModifiedLabelmapToolOperationData = Omit<LabelmapToolOperationData, 'voxelManager' | 'override'> & {
+    voxelManager?: Types.IVoxelManager<number> | Types.IVoxelManager<Types.RGB>;
+    override?: {
+        voxelManager: Types.IVoxelManager<number> | Types.IVoxelManager<Types.RGB>;
+        imageData: vtkImageData;
+    };
+};
+export default class LabelmapBaseTool extends BaseTool {
+    protected _editData: {
+        override: {
+            voxelManager: Types.IVoxelManager<number>;
+            imageData: vtkImageData;
+        };
+        segmentsLocked: number[];
+        imageId?: string;
+        imageIds?: string[];
+        volumeId?: string;
+        referencedVolumeId?: string;
+    } | null;
+    protected _hoverData?: {
+        brushCursor: any;
+        segmentationId: string;
+        segmentIndex: number;
+        segmentColor: [number, number, number, number];
+        viewportIdsToRender: string[];
+        centerCanvas?: Array<number>;
+        viewport: Types.IViewport;
+    };
+    static previewData?: PreviewData;
+    constructor(toolProps: any, defaultToolProps: any);
+    protected get _previewData(): PreviewData;
+    createMemo(segmentId: string, segmentationVoxelManager: any, preview: any): LabelmapMemo.LabelmapMemo;
+    protected createEditData(element: any): EditDataReturnType;
+    protected getEditData({ viewport, representationData, segmentsLocked, segmentationId, }: {
+        viewport: any;
+        representationData: any;
+        segmentsLocked: any;
+        segmentationId: any;
+    }): EditDataReturnType;
+    protected createHoverData(element: any, centerCanvas?: any): {
+        brushCursor: {
+            metadata: {
+                viewPlaneNormal: Types.Point3;
+                viewUp: Types.Point3;
+                FrameOfReferenceUID: string;
+                referencedImageId: string;
+                toolName: string;
+                segmentColor: Types.Color;
+            };
+            data: {};
+        };
+        centerCanvas: any;
+        segmentIndex: number;
+        viewport: Types.IStackViewport | import("@cornerstonejs/core").VolumeViewport;
+        segmentationId: string;
+        segmentColor: Types.Color;
+        viewportIdsToRender: string[];
+    };
+    protected getActiveSegmentationData(viewport: any): {
+        segmentIndex: number;
+        segmentationId: string;
+        segmentColor: Types.Color;
+    };
+    protected getOperationData(element?: any): ModifiedLabelmapToolOperationData;
+    addPreview(element?: HTMLDivElement, options?: {
+        acceptReject: boolean;
+    }): unknown;
+    rejectPreview(element?: HTMLDivElement): void;
+    acceptPreview(element?: HTMLDivElement): void;
+    static viewportContoursToLabelmap(viewport: Types.IViewport, options?: {
+        removeContours: boolean;
+    }): void;
+}
+export {};

package/dist/esm/tools/segmentation/LabelmapBaseTool.js

@@ -0,0 +1,289 @@
+import { getEnabledElement, cache, utilities as csUtils, Enums, eventTarget, BaseVolumeViewport, } from '@cornerstonejs/core';
+import { BaseTool } from '../base';
+import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
+import { getActiveSegmentation } from '../../stateManagement/segmentation/getActiveSegmentation';
+import { getLockedSegmentIndices } from '../../stateManagement/segmentation/segmentLocking';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
+import { getClosestImageIdForStackViewport } from '../../utilities/annotationHydration';
+import { getCurrentLabelmapImageIdForViewport } from '../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
+import { getSegmentIndexColor } from '../../stateManagement/segmentation/config/segmentationColor';
+import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
+import { StrategyCallbacks } from '../../enums';
+import * as LabelmapMemo from '../../utilities/segmentation/createLabelmapMemo';
+import { getAllAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
+import { filterAnnotationsForDisplay } from '../../utilities/planar';
+import { isPointInsidePolyline3D } from '../../utilities/math/polyline';
+import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
+import { fillInsideCircle } from './strategies';
+export default class LabelmapBaseTool extends BaseTool {
+    static { this.previewData = {
+        preview: null,
+        element: null,
+        timerStart: 0,
+        timer: null,
+        startPoint: [NaN, NaN],
+        isDrag: false,
+    }; }
+    constructor(toolProps, defaultToolProps) {
+        super(toolProps, defaultToolProps);
+    }
+    get _previewData() {
+        return LabelmapBaseTool.previewData;
+    }
+    createMemo(segmentId, segmentationVoxelManager, preview) {
+        this.memo ||= LabelmapMemo.createLabelmapMemo(segmentId, segmentationVoxelManager, preview);
+        return this.memo;
+    }
+    createEditData(element) {
+        const enabledElement = getEnabledElement(element);
+        const { viewport } = enabledElement;
+        const activeSegmentation = getActiveSegmentation(viewport.id);
+        if (!activeSegmentation) {
+            const event = new CustomEvent(Enums.Events.ERROR_EVENT, {
+                detail: {
+                    type: 'Segmentation',
+                    message: 'No active segmentation detected, create a segmentation representation before using the brush tool',
+                },
+                cancelable: true,
+            });
+            eventTarget.dispatchEvent(event);
+            return null;
+        }
+        const { segmentationId } = activeSegmentation;
+        const segmentsLocked = getLockedSegmentIndices(segmentationId);
+        const { representationData } = getSegmentation(segmentationId);
+        const editData = this.getEditData({
+            viewport,
+            representationData,
+            segmentsLocked,
+            segmentationId,
+        });
+        return editData;
+    }
+    getEditData({ viewport, representationData, segmentsLocked, segmentationId, }) {
+        if (viewport instanceof BaseVolumeViewport) {
+            const { volumeId } = representationData[SegmentationRepresentations.Labelmap];
+            const actors = viewport.getActors();
+            const isStackViewport = viewport instanceof getClosestImageIdForStackViewport;
+            if (isStackViewport) {
+                const event = new CustomEvent(Enums.Events.ERROR_EVENT, {
+                    detail: {
+                        type: 'Segmentation',
+                        message: 'Cannot perform brush operation on the selected viewport',
+                    },
+                    cancelable: true,
+                });
+                eventTarget.dispatchEvent(event);
+                return null;
+            }
+            const volumes = actors.map((actorEntry) => cache.getVolume(actorEntry.referencedId));
+            const segmentationVolume = cache.getVolume(volumeId);
+            const referencedVolumeIdToThreshold = volumes.find((volume) => csUtils.isEqual(volume.dimensions, segmentationVolume.dimensions))?.volumeId || volumes[0]?.volumeId;
+            return {
+                volumeId,
+                referencedVolumeId: this.configuration.threshold?.volumeId ??
+                    referencedVolumeIdToThreshold,
+                segmentsLocked,
+            };
+        }
+        else {
+            const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
+            if (!segmentationImageId) {
+                return;
+            }
+            return {
+                imageId: segmentationImageId,
+                segmentsLocked,
+            };
+        }
+    }
+    createHoverData(element, centerCanvas) {
+        const enabledElement = getEnabledElement(element);
+        const { viewport } = enabledElement;
+        const camera = viewport.getCamera();
+        const { viewPlaneNormal, viewUp } = camera;
+        const viewportIdsToRender = [viewport.id];
+        const { segmentIndex, segmentationId, segmentColor } = this.getActiveSegmentationData(viewport) || {};
+        const brushCursor = {
+            metadata: {
+                viewPlaneNormal: [...viewPlaneNormal],
+                viewUp: [...viewUp],
+                FrameOfReferenceUID: viewport.getFrameOfReferenceUID(),
+                referencedImageId: '',
+                toolName: this.getToolName(),
+                segmentColor,
+            },
+            data: {},
+        };
+        return {
+            brushCursor,
+            centerCanvas,
+            segmentIndex,
+            viewport,
+            segmentationId,
+            segmentColor,
+            viewportIdsToRender,
+        };
+    }
+    getActiveSegmentationData(viewport) {
+        const viewportId = viewport.id;
+        const activeRepresentation = getActiveSegmentation(viewportId);
+        if (!activeRepresentation) {
+            return;
+        }
+        const { segmentationId } = activeRepresentation;
+        const segmentIndex = getActiveSegmentIndex(segmentationId);
+        if (!segmentIndex) {
+            return;
+        }
+        const segmentColor = getSegmentIndexColor(viewportId, segmentationId, segmentIndex);
+        return {
+            segmentIndex,
+            segmentationId,
+            segmentColor,
+        };
+    }
+    getOperationData(element) {
+        const editData = this._editData || this.createEditData(element);
+        const { segmentIndex, segmentationId, 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._previewData.preview
+                ? this.configuration.preview?.previewColors
+                : null,
+            viewPlaneNormal,
+            toolGroupId: this.toolGroupId,
+            segmentationId,
+            viewUp,
+            activeStrategy: this.configuration.activeStrategy,
+            configuration: this.configuration,
+            preview: this._previewData?.preview,
+            createMemo: this.createMemo.bind(this),
+        };
+        return operationData;
+    }
+    addPreview(element = this._previewData.element, options) {
+        const { _previewData } = this;
+        const acceptReject = options?.acceptReject;
+        if (acceptReject === true) {
+            this.acceptPreview(element);
+        }
+        else if (acceptReject === false) {
+            this.rejectPreview(element);
+        }
+        const enabledElement = getEnabledElement(element);
+        _previewData.preview = this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.AddPreview);
+        _previewData.isDrag = true;
+        return _previewData.preview;
+    }
+    rejectPreview(element = this._previewData.element) {
+        if (!element || !this._previewData.preview) {
+            return;
+        }
+        const enabledElement = getEnabledElement(element);
+        this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.RejectPreview);
+        this._previewData.preview = null;
+        this._previewData.isDrag = false;
+    }
+    acceptPreview(element = this._previewData.element) {
+        if (!element) {
+            return;
+        }
+        this.doneEditMemo();
+        const enabledElement = getEnabledElement(element);
+        this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.AcceptPreview);
+        this._previewData.isDrag = false;
+        this._previewData.preview = null;
+        this.doneEditMemo();
+    }
+    static viewportContoursToLabelmap(viewport, options) {
+        const removeContours = options?.removeContours ?? true;
+        const annotations = getAllAnnotations();
+        const viewAnnotations = filterAnnotationsForDisplay(viewport, annotations);
+        if (!viewAnnotations?.length) {
+            return;
+        }
+        const contourAnnotations = viewAnnotations.filter((annotation) => annotation.data.contour?.polyline?.length);
+        if (!contourAnnotations.length) {
+            return;
+        }
+        const brushInstance = new LabelmapBaseTool({}, {
+            configuration: {
+                strategies: {
+                    FILL_INSIDE_CIRCLE: fillInsideCircle,
+                },
+                activeStrategy: 'FILL_INSIDE_CIRCLE',
+            },
+        });
+        const preview = brushInstance.addPreview(viewport.element);
+        const { memo, segmentationId } = preview;
+        const previewVoxels = memo?.voxelManager || preview.previewVoxelManager;
+        const segmentationVoxels = previewVoxels.sourceVoxelManager || previewVoxels;
+        const { dimensions } = previewVoxels;
+        const imageData = viewport
+            .getDefaultActor()
+            .actor.getMapper()
+            .getInputData();
+        for (const annotation of contourAnnotations) {
+            const boundsIJK = [
+                [Infinity, -Infinity],
+                [Infinity, -Infinity],
+                [Infinity, -Infinity],
+            ];
+            const { polyline } = annotation.data.contour;
+            for (const point of polyline) {
+                const indexPoint = imageData.worldToIndex(point);
+                indexPoint.forEach((v, idx) => {
+                    boundsIJK[idx][0] = Math.min(boundsIJK[idx][0], v);
+                    boundsIJK[idx][1] = Math.max(boundsIJK[idx][1], v);
+                });
+            }
+            boundsIJK.forEach((bound, idx) => {
+                bound[0] = Math.round(Math.max(0, bound[0]));
+                bound[1] = Math.round(Math.min(dimensions[idx] - 1, bound[1]));
+            });
+            const activeIndex = getActiveSegmentIndex(segmentationId);
+            const startPoint = annotation.data.handles?.[0] || polyline[0];
+            const startIndex = imageData.worldToIndex(startPoint).map(Math.round);
+            const startValue = segmentationVoxels.getAtIJKPoint(startIndex) || 0;
+            let hasZeroIndex = false;
+            let hasPositiveIndex = false;
+            for (const polyPoint of polyline) {
+                const polyIndex = imageData.worldToIndex(polyPoint).map(Math.round);
+                const polyValue = segmentationVoxels.getAtIJKPoint(polyIndex);
+                if (polyValue === startValue) {
+                    hasZeroIndex = true;
+                }
+                else if (polyValue >= 0) {
+                    hasPositiveIndex = true;
+                }
+            }
+            const hasBoth = hasZeroIndex && hasPositiveIndex;
+            const segmentIndex = hasBoth
+                ? startValue
+                : startValue === 0
+                    ? activeIndex
+                    : 0;
+            for (let i = boundsIJK[0][0]; i <= boundsIJK[0][1]; i++) {
+                for (let j = boundsIJK[1][0]; j <= boundsIJK[1][1]; j++) {
+                    for (let k = boundsIJK[2][0]; k <= boundsIJK[2][1]; k++) {
+                        const worldPoint = imageData.indexToWorld([i, j, k]);
+                        const isContained = isPointInsidePolyline3D(worldPoint, polyline);
+                        if (isContained) {
+                            previewVoxels.setAtIJK(i, j, k, segmentIndex);
+                        }
+                    }
+                }
+            }
+            if (removeContours) {
+                removeAnnotation(annotation.annotationUID);
+            }
+        }
+        const slices = previewVoxels.getArrayOfModifiedSlices();
+        triggerSegmentationDataModified(segmentationId, slices);
+    }
+}

package/dist/esm/tools/segmentation/PaintFillTool.d.ts

@@ -0,0 +1,13 @@
+import { BaseTool } from '../base';
+import type { PublicToolProps, ToolProps, EventTypes } from '../../types';
+declare class PaintFillTool extends BaseTool {
+    static toolName: any;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    preMouseDownCallback: (evt: EventTypes.InteractionEventType) => boolean;
+    private getFramesModified;
+    private generateHelpers;
+    private getFixedDimension;
+    private generateFloodFillGetter;
+    private generateGetScalarDataPositionFromPlane;
+}
+export default PaintFillTool;