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

package/dist/esm/tools/SculptorTool/CircleSculptCursor.js

@@ -0,0 +1,107 @@
+import { getEnabledElement } from '@cornerstonejs/core';
+import { distancePointToContour } from '../distancePointToContour';
+import { drawCircle as drawCircleSvg } from '../../drawingSvg';
+import { point } from '../../utilities/math';
+class CircleSculptCursor {
+    constructor() {
+        this.toolInfo = {
+            toolSize: null,
+            maxToolSize: null,
+        };
+    }
+    static { this.shapeName = 'Circle'; }
+    renderShape(svgDrawingHelper, canvasLocation, options) {
+        const circleUID = '0';
+        drawCircleSvg(svgDrawingHelper, 'SculptorTool', circleUID, canvasLocation, this.toolInfo.toolSize, options);
+    }
+    pushHandles(viewport, sculptData) {
+        const { points, mouseCanvasPoint } = sculptData;
+        const pushedHandles = { first: undefined, last: undefined };
+        for (let i = 0; i < points.length; i++) {
+            const handleCanvasPoint = viewport.worldToCanvas(points[i]);
+            const distanceToHandle = point.distanceToPoint(handleCanvasPoint, mouseCanvasPoint);
+            if (distanceToHandle > this.toolInfo.toolSize) {
+                continue;
+            }
+            this.pushOneHandle(i, distanceToHandle, sculptData);
+            if (pushedHandles.first === undefined) {
+                pushedHandles.first = i;
+                pushedHandles.last = i;
+            }
+            else {
+                pushedHandles.last = i;
+            }
+        }
+        return pushedHandles;
+    }
+    configureToolSize(evt) {
+        const toolInfo = this.toolInfo;
+        if (toolInfo.toolSize && toolInfo.maxToolSize) {
+            return;
+        }
+        const eventData = evt.detail;
+        const element = eventData.element;
+        const minDim = Math.min(element.clientWidth, element.clientHeight);
+        const maxRadius = minDim / 12;
+        toolInfo.toolSize = maxRadius;
+        toolInfo.maxToolSize = maxRadius;
+    }
+    updateToolSize(canvasCoords, viewport, activeAnnotation) {
+        const toolInfo = this.toolInfo;
+        const radius = distancePointToContour(viewport, activeAnnotation, canvasCoords);
+        if (radius > 0) {
+            toolInfo.toolSize = Math.min(toolInfo.maxToolSize, radius);
+        }
+    }
+    getMaxSpacing(minSpacing) {
+        return Math.max(this.toolInfo.toolSize / 4, minSpacing);
+    }
+    getInsertPosition(previousIndex, nextIndex, sculptData) {
+        let insertPosition;
+        const { points, element, mouseCanvasPoint } = sculptData;
+        const toolSize = this.toolInfo.toolSize;
+        const enabledElement = getEnabledElement(element);
+        const { viewport } = enabledElement;
+        const previousCanvasPoint = viewport.worldToCanvas(points[previousIndex]);
+        const nextCanvasPoint = viewport.worldToCanvas(points[nextIndex]);
+        const midPoint = [
+            (previousCanvasPoint[0] + nextCanvasPoint[0]) / 2.0,
+            (previousCanvasPoint[1] + nextCanvasPoint[1]) / 2.0,
+        ];
+        const distanceToMidPoint = point.distanceToPoint(mouseCanvasPoint, midPoint);
+        if (distanceToMidPoint < toolSize) {
+            const directionUnitVector = {
+                x: (midPoint[0] - mouseCanvasPoint[0]) / distanceToMidPoint,
+                y: (midPoint[1] - mouseCanvasPoint[1]) / distanceToMidPoint,
+            };
+            insertPosition = [
+                mouseCanvasPoint[0] + toolSize * directionUnitVector.x,
+                mouseCanvasPoint[1] + toolSize * directionUnitVector.y,
+            ];
+        }
+        else {
+            insertPosition = midPoint;
+        }
+        const worldPosition = viewport.canvasToWorld(insertPosition);
+        return worldPosition;
+    }
+    pushOneHandle(i, distanceToHandle, sculptData) {
+        const { points, mousePoint } = sculptData;
+        const toolSize = this.toolInfo.toolSize;
+        const handle = points[i];
+        const directionUnitVector = {
+            x: (handle[0] - mousePoint[0]) / distanceToHandle,
+            y: (handle[1] - mousePoint[1]) / distanceToHandle,
+            z: (handle[2] - mousePoint[2]) / distanceToHandle,
+        };
+        const position = {
+            x: mousePoint[0] + toolSize * directionUnitVector.x,
+            y: mousePoint[1] + toolSize * directionUnitVector.y,
+            z: mousePoint[2] + toolSize * directionUnitVector.z,
+        };
+        handle[0] = position.x;
+        handle[1] = position.y;
+        handle[2] = position.z;
+    }
+}
+export default CircleSculptCursor;

package/dist/esm/tools/SculptorTool.d.ts

@@ -0,0 +1,41 @@
+import type { Types } from '@cornerstonejs/core';
+import { BaseTool } from './base';
+import type { EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
+import type { ISculptToolShape } from '../types/ISculptToolShape';
+export type SculptData = {
+    mousePoint: Types.Point3;
+    mouseCanvasPoint: Types.Point2;
+    points: Array<Types.Point3>;
+    maxSpacing: number;
+    element: HTMLDivElement;
+};
+declare class SculptorTool extends BaseTool {
+    static toolName: string;
+    registeredShapes: Map<any, any>;
+    private isActive;
+    private selectedShape;
+    private commonData;
+    private sculptData?;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    registerShapes<T extends ISculptToolShape>(shapeName: string, shapeClass: new () => T): void;
+    preMouseDownCallback: (evt: EventTypes.InteractionEventType) => boolean;
+    mouseMoveCallback: (evt: EventTypes.InteractionEventType) => void;
+    protected sculpt(eventData: any, points: Array<Types.Point3>): void;
+    protected interpolatePointsWithinMaxSpacing(i: number, points: Array<Types.Point3>, indicesToInsertAfter: Array<number>, maxSpacing: number): void;
+    private updateCursor;
+    private filterSculptableAnnotationsForElement;
+    private configureToolSize;
+    private insertNewHandles;
+    private findNewHandleIndices;
+    private insertHandleRadially;
+    private selectFreehandTool;
+    private getClosestFreehandToolOnElement;
+    private endCallback;
+    private dragCallback;
+    protected activateModify(element: HTMLDivElement): void;
+    protected deactivateModify(element: HTMLDivElement): void;
+    setToolShape(toolShape: string): void;
+    renderAnnotation(enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper): void;
+}
+export declare const contourIndex: (i: number, length: number) => number;
+export default SculptorTool;

package/dist/esm/tools/SculptorTool.js

@@ -0,0 +1,289 @@
+import { getEnabledElement } from '@cornerstonejs/core';
+import { BaseTool } from './base';
+import { getAnnotations } from '../stateManagement';
+import { point } from '../utilities/math';
+import { Events, ToolModes, AnnotationStyleStates } from '../enums';
+import { triggerAnnotationRenderForViewportIds } from '../utilities/triggerAnnotationRenderForViewportIds';
+import { hideElementCursor, resetElementCursor, } from '../cursors/elementCursor';
+import { getStyleProperty } from '../stateManagement/annotation/config/helpers';
+import { triggerAnnotationModified } from '../stateManagement/annotation/helpers/state';
+import CircleSculptCursor from './SculptorTool/CircleSculptCursor';
+import { distancePointToContour } from './distancePointToContour';
+import { getToolGroupForViewport } from '../store/ToolGroupManager';
+class SculptorTool extends BaseTool {
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            minSpacing: 1,
+            referencedToolNames: [
+                'PlanarFreehandROI',
+                'PlanarFreehandContourSegmentationTool',
+            ],
+            toolShape: 'circle',
+            referencedToolName: 'PlanarFreehandROI',
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this.registeredShapes = new Map();
+        this.isActive = false;
+        this.commonData = {
+            activeAnnotationUID: null,
+            viewportIdsToRender: [],
+            isEditingOpenContour: false,
+            canvasLocation: undefined,
+        };
+        this.preMouseDownCallback = (evt) => {
+            const eventData = evt.detail;
+            const element = eventData.element;
+            this.configureToolSize(evt);
+            this.selectFreehandTool(eventData);
+            if (this.commonData.activeAnnotationUID === null) {
+                return;
+            }
+            this.isActive = true;
+            hideElementCursor(element);
+            this.activateModify(element);
+            return true;
+        };
+        this.mouseMoveCallback = (evt) => {
+            if (this.mode === ToolModes.Active) {
+                this.configureToolSize(evt);
+                this.updateCursor(evt);
+            }
+            else {
+                this.commonData.canvasLocation = undefined;
+            }
+        };
+        this.endCallback = (evt) => {
+            const eventData = evt.detail;
+            const { element } = eventData;
+            const config = this.configuration;
+            const enabledElement = getEnabledElement(element);
+            this.isActive = false;
+            this.deactivateModify(element);
+            resetElementCursor(element);
+            const { renderingEngineId, viewportId } = enabledElement;
+            const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
+            const toolInstance = toolGroup.getToolInstance(config.referencedToolName);
+            const annotations = this.filterSculptableAnnotationsForElement(element);
+            const activeAnnotation = annotations.find((annotation) => annotation.annotationUID === this.commonData.activeAnnotationUID);
+            if (toolInstance.configuration.calculateStats) {
+                activeAnnotation.invalidated = true;
+            }
+            triggerAnnotationModified(activeAnnotation, element);
+        };
+        this.dragCallback = (evt) => {
+            const eventData = evt.detail;
+            const element = eventData.element;
+            this.updateCursor(evt);
+            const annotations = this.filterSculptableAnnotationsForElement(element);
+            const activeAnnotation = annotations.find((annotation) => annotation.annotationUID === this.commonData.activeAnnotationUID);
+            if (!annotations?.length || !this.isActive) {
+                return;
+            }
+            const points = activeAnnotation.data.contour.polyline;
+            this.sculpt(eventData, points);
+        };
+        this.registerShapes(CircleSculptCursor.shapeName, CircleSculptCursor);
+        this.setToolShape(this.configuration.toolShape);
+    }
+    registerShapes(shapeName, shapeClass) {
+        const shape = new shapeClass();
+        this.registeredShapes.set(shapeName, shape);
+    }
+    sculpt(eventData, points) {
+        const config = this.configuration;
+        const element = eventData.element;
+        const enabledElement = getEnabledElement(element);
+        const { viewport } = enabledElement;
+        const cursorShape = this.registeredShapes.get(this.selectedShape);
+        this.sculptData = {
+            mousePoint: eventData.currentPoints.world,
+            mouseCanvasPoint: eventData.currentPoints.canvas,
+            points,
+            maxSpacing: cursorShape.getMaxSpacing(config.minSpacing),
+            element: element,
+        };
+        const pushedHandles = cursorShape.pushHandles(viewport, this.sculptData);
+        if (pushedHandles.first !== undefined) {
+            this.insertNewHandles(pushedHandles);
+        }
+    }
+    interpolatePointsWithinMaxSpacing(i, points, indicesToInsertAfter, maxSpacing) {
+        const { element } = this.sculptData;
+        const enabledElement = getEnabledElement(element);
+        const { viewport } = enabledElement;
+        const nextHandleIndex = contourIndex(i + 1, points.length);
+        const currentCanvasPoint = viewport.worldToCanvas(points[i]);
+        const nextCanvasPoint = viewport.worldToCanvas(points[nextHandleIndex]);
+        const distanceToNextHandle = point.distanceToPoint(currentCanvasPoint, nextCanvasPoint);
+        if (distanceToNextHandle > maxSpacing) {
+            indicesToInsertAfter.push(i);
+        }
+    }
+    updateCursor(evt) {
+        const eventData = evt.detail;
+        const element = eventData.element;
+        const enabledElement = getEnabledElement(element);
+        const { renderingEngine, viewport } = enabledElement;
+        this.commonData.viewportIdsToRender = [viewport.id];
+        const annotations = this.filterSculptableAnnotationsForElement(element);
+        if (!annotations?.length) {
+            return;
+        }
+        const activeAnnotation = annotations.find((annotation) => annotation.annotationUID === this.commonData.activeAnnotationUID);
+        this.commonData.canvasLocation = eventData.currentPoints.canvas;
+        if (this.isActive) {
+            activeAnnotation.highlighted = true;
+        }
+        else {
+            const cursorShape = this.registeredShapes.get(this.selectedShape);
+            const canvasCoords = eventData.currentPoints.canvas;
+            cursorShape.updateToolSize(canvasCoords, viewport, activeAnnotation);
+        }
+        triggerAnnotationRenderForViewportIds(this.commonData.viewportIdsToRender);
+    }
+    filterSculptableAnnotationsForElement(element) {
+        const config = this.configuration;
+        const enabledElement = getEnabledElement(element);
+        const { renderingEngineId, viewportId } = enabledElement;
+        const sculptableAnnotations = [];
+        const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
+        const toolInstance = toolGroup.getToolInstance(config.referencedToolName);
+        config.referencedToolNames.forEach((referencedToolName) => {
+            const annotations = getAnnotations(referencedToolName, element);
+            if (annotations) {
+                sculptableAnnotations.push(...annotations);
+            }
+        });
+        return toolInstance.filterInteractableAnnotationsForElement(element, sculptableAnnotations);
+    }
+    configureToolSize(evt) {
+        const cursorShape = this.registeredShapes.get(this.selectedShape);
+        cursorShape.configureToolSize(evt);
+    }
+    insertNewHandles(pushedHandles) {
+        const indicesToInsertAfter = this.findNewHandleIndices(pushedHandles);
+        let newIndexModifier = 0;
+        for (let i = 0; i < indicesToInsertAfter?.length; i++) {
+            const insertIndex = indicesToInsertAfter[i] + 1 + newIndexModifier;
+            this.insertHandleRadially(insertIndex);
+            newIndexModifier++;
+        }
+    }
+    findNewHandleIndices(pushedHandles) {
+        const { points, maxSpacing } = this.sculptData;
+        const indicesToInsertAfter = [];
+        for (let i = pushedHandles.first; i <= pushedHandles.last; i++) {
+            this.interpolatePointsWithinMaxSpacing(i, points, indicesToInsertAfter, maxSpacing);
+        }
+        return indicesToInsertAfter;
+    }
+    insertHandleRadially(insertIndex) {
+        const { points } = this.sculptData;
+        if (insertIndex > points.length - 1 &&
+            this.commonData.isEditingOpenContour) {
+            return;
+        }
+        const cursorShape = this.registeredShapes.get(this.selectedShape);
+        const previousIndex = insertIndex - 1;
+        const nextIndex = contourIndex(insertIndex, points.length);
+        const insertPosition = cursorShape.getInsertPosition(previousIndex, nextIndex, this.sculptData);
+        const handleData = insertPosition;
+        points.splice(insertIndex, 0, handleData);
+    }
+    selectFreehandTool(eventData) {
+        const closestAnnotationUID = this.getClosestFreehandToolOnElement(eventData);
+        if (closestAnnotationUID === undefined) {
+            return;
+        }
+        this.commonData.activeAnnotationUID = closestAnnotationUID;
+    }
+    getClosestFreehandToolOnElement(eventData) {
+        const { element } = eventData;
+        const enabledElement = getEnabledElement(element);
+        const { viewport } = enabledElement;
+        const config = this.configuration;
+        const annotations = this.filterSculptableAnnotationsForElement(element);
+        if (!annotations?.length) {
+            return;
+        }
+        const canvasPoints = eventData.currentPoints.canvas;
+        const closest = {
+            distance: Infinity,
+            toolIndex: undefined,
+            annotationUID: undefined,
+        };
+        for (let i = 0; i < annotations?.length; i++) {
+            if (annotations[i].isLocked || !annotations[i].isVisible) {
+                continue;
+            }
+            const distanceFromTool = distancePointToContour(viewport, annotations[i], canvasPoints);
+            if (distanceFromTool === -1) {
+                continue;
+            }
+            if (distanceFromTool < closest.distance) {
+                closest.distance = distanceFromTool;
+                closest.toolIndex = i;
+                closest.annotationUID = annotations[i].annotationUID;
+            }
+        }
+        this.commonData.isEditingOpenContour =
+            !annotations[closest.toolIndex].data.contour.closed;
+        config.referencedToolName =
+            annotations[closest.toolIndex].metadata.toolName;
+        return closest.annotationUID;
+    }
+    activateModify(element) {
+        element.addEventListener(Events.MOUSE_UP, this.endCallback);
+        element.addEventListener(Events.MOUSE_CLICK, this.endCallback);
+        element.addEventListener(Events.MOUSE_DRAG, this.dragCallback);
+        element.addEventListener(Events.TOUCH_TAP, this.endCallback);
+        element.addEventListener(Events.TOUCH_END, this.endCallback);
+        element.addEventListener(Events.TOUCH_DRAG, this.dragCallback);
+    }
+    deactivateModify(element) {
+        element.removeEventListener(Events.MOUSE_UP, this.endCallback);
+        element.removeEventListener(Events.MOUSE_CLICK, this.endCallback);
+        element.removeEventListener(Events.MOUSE_DRAG, this.dragCallback);
+        element.removeEventListener(Events.TOUCH_TAP, this.endCallback);
+        element.removeEventListener(Events.TOUCH_END, this.endCallback);
+        element.removeEventListener(Events.TOUCH_DRAG, this.dragCallback);
+    }
+    setToolShape(toolShape) {
+        this.selectedShape =
+            this.registeredShapes.get(toolShape) ?? CircleSculptCursor.shapeName;
+    }
+    renderAnnotation(enabledElement, svgDrawingHelper) {
+        const { viewport } = enabledElement;
+        const { element } = viewport;
+        const viewportIdsToRender = this.commonData.viewportIdsToRender;
+        if (!this.commonData.canvasLocation ||
+            this.mode !== ToolModes.Active ||
+            !viewportIdsToRender.includes(viewport.id)) {
+            return;
+        }
+        const annotations = this.filterSculptableAnnotationsForElement(element);
+        if (!annotations?.length) {
+            return;
+        }
+        const styleSpecifier = {
+            toolGroupId: this.toolGroupId,
+            toolName: this.getToolName(),
+            viewportId: enabledElement.viewport.id,
+        };
+        let color = getStyleProperty('color', styleSpecifier, AnnotationStyleStates.Default, this.mode);
+        if (this.isActive) {
+            color = getStyleProperty('color', styleSpecifier, AnnotationStyleStates.Highlighted, this.mode);
+        }
+        const cursorShape = this.registeredShapes.get(this.selectedShape);
+        cursorShape.renderShape(svgDrawingHelper, this.commonData.canvasLocation, {
+            color,
+        });
+    }
+}
+export const contourIndex = (i, length) => {
+    return (i + length) % length;
+};
+SculptorTool.toolName = 'SculptorTool';
+export default SculptorTool;

package/dist/esm/tools/SegmentationIntersectionTool.d.ts

@@ -0,0 +1,18 @@
+import type { Types } from '@cornerstonejs/core';
+import type { PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
+import AnnotationDisplayTool from './base/AnnotationDisplayTool';
+import type { Annotation } from '../types';
+export interface SegmentationIntersectionAnnotation extends Annotation {
+    data: {
+        actorsWorldPointsMap: Map<string, Map<string, object>>;
+    };
+}
+declare class SegmentationIntersectionTool extends AnnotationDisplayTool {
+    static toolName: any;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    _init: () => void;
+    onSetToolEnabled: () => void;
+    onCameraModified: (evt: Types.EventTypes.CameraModifiedEvent) => void;
+    renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
+}
+export default SegmentationIntersectionTool;

package/dist/esm/tools/SegmentationIntersectionTool.js

@@ -0,0 +1,177 @@
+import { getRenderingEngine } from '@cornerstonejs/core';
+import { addAnnotation, getAnnotations, } from '../stateManagement/annotation/annotationState';
+import { drawPath } from '../drawingSvg';
+import { getToolGroup } from '../store/ToolGroupManager';
+import triggerAnnotationRenderForViewportIds from '../utilities/triggerAnnotationRenderForViewportIds';
+import AnnotationDisplayTool from './base/AnnotationDisplayTool';
+import { distanceToPoint } from '../utilities/math/point';
+import { pointToString } from '../utilities/pointToString';
+import { polyDataUtils } from '../utilities';
+class SegmentationIntersectionTool extends AnnotationDisplayTool {
+    constructor(toolProps = {}, defaultToolProps = {
+        configuration: {
+            opacity: 0.5,
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this._init = () => {
+            const viewportsInfo = getToolGroup(this.toolGroupId).viewportsInfo;
+            if (!viewportsInfo?.length) {
+                console.warn(this.getToolName() + 'Tool: No viewports found');
+                return;
+            }
+            const firstViewport = getRenderingEngine(viewportsInfo[0].renderingEngineId)?.getViewport(viewportsInfo[0].viewportId);
+            if (!firstViewport) {
+                return;
+            }
+            const frameOfReferenceUID = firstViewport.getFrameOfReferenceUID();
+            const annotations = getAnnotations(this.getToolName(), frameOfReferenceUID);
+            if (!annotations?.length) {
+                const actorsWorldPointsMap = new Map();
+                calculateSurfaceSegmentationIntersections(actorsWorldPointsMap, viewportsInfo);
+                const newAnnotation = {
+                    highlighted: true,
+                    invalidated: true,
+                    metadata: {
+                        toolName: this.getToolName(),
+                        FrameOfReferenceUID: frameOfReferenceUID,
+                        referencedImageId: null,
+                    },
+                    data: {
+                        actorsWorldPointsMap,
+                    },
+                };
+                addAnnotation(newAnnotation, frameOfReferenceUID);
+            }
+            triggerAnnotationRenderForViewportIds(viewportsInfo.map(({ viewportId }) => viewportId));
+        };
+        this.onSetToolEnabled = () => {
+            this._init();
+        };
+        this.onCameraModified = (evt) => {
+            this._init();
+        };
+        this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
+            const { viewport, FrameOfReferenceUID } = enabledElement;
+            let renderStatus = false;
+            const annotations = getAnnotations(this.getToolName(), FrameOfReferenceUID);
+            if (!annotations?.length) {
+                return renderStatus;
+            }
+            const annotation = annotations[0];
+            const { annotationUID } = annotation;
+            const actorsWorldPointsMap = annotation.data.actorsWorldPointsMap;
+            calculateSurfaceSegmentationIntersectionsForViewport(actorsWorldPointsMap, viewport);
+            const actorEntries = viewport.getActors();
+            const cacheId = getCacheId(viewport);
+            actorEntries.forEach((actorEntry) => {
+                if (!actorEntry?.clippingFilter) {
+                    return;
+                }
+                const actorWorldPointMap = actorsWorldPointsMap.get(actorEntry.uid);
+                if (!actorWorldPointMap) {
+                    return;
+                }
+                if (!actorWorldPointMap.get(cacheId)) {
+                    return;
+                }
+                let polyLineIdx = 1;
+                const { worldPointsSet, color } = actorWorldPointMap.get(cacheId);
+                for (let i = 0; i < worldPointsSet.length; i++) {
+                    const worldPoints = worldPointsSet[i];
+                    const canvasPoints = worldPoints.map((point) => viewport.worldToCanvas(point));
+                    const options = {
+                        color: color,
+                        fillColor: color,
+                        fillOpacity: this.configuration.opacity,
+                        closePath: true,
+                        lineWidth: 2,
+                    };
+                    const polyLineUID = actorEntry.uid + '#' + polyLineIdx;
+                    drawPath(svgDrawingHelper, annotationUID, polyLineUID, canvasPoints, options);
+                    polyLineIdx++;
+                }
+            });
+            renderStatus = true;
+            return renderStatus;
+        };
+    }
+}
+function calculateSurfaceSegmentationIntersections(actorsWorldPointsMap, viewportsInfo) {
+    viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
+        const viewport = getRenderingEngine(renderingEngineId)?.getViewport(viewportId);
+        calculateSurfaceSegmentationIntersectionsForViewport(actorsWorldPointsMap, viewport);
+    });
+}
+function calculateSurfaceSegmentationIntersectionsForViewport(actorsWorldPointsMap, viewport) {
+    const actorEntries = viewport.getActors();
+    const cacheId = getCacheId(viewport);
+    actorEntries.forEach((actorEntry) => {
+        if (!actorEntry?.clippingFilter) {
+            return;
+        }
+        let actorWorldPointsMap = actorsWorldPointsMap.get(actorEntry.uid);
+        if (!actorWorldPointsMap) {
+            actorWorldPointsMap = new Map();
+            actorsWorldPointsMap.set(actorEntry.uid, actorWorldPointsMap);
+        }
+        if (!actorWorldPointsMap.get(cacheId)) {
+            const polyData = actorEntry.clippingFilter.getOutputData();
+            const worldPointsSet = polyDataUtils.getPolyDataPoints(polyData);
+            if (!worldPointsSet) {
+                return;
+            }
+            const colorArray = actorEntry.actor.getProperty().getColor();
+            const color = colorToString(colorArray);
+            actorWorldPointsMap.set(cacheId, { worldPointsSet, color });
+        }
+    });
+}
+function getCacheId(viewport) {
+    const { viewPlaneNormal } = viewport.getCamera();
+    const imageIndex = viewport.getCurrentImageIdIndex();
+    return `${viewport.id}-${pointToString(viewPlaneNormal)}-${imageIndex}`;
+}
+function colorToString(colorArray) {
+    function colorComponentToString(component) {
+        let componentString = Math.floor(component * 255).toString(16);
+        if (componentString.length === 1) {
+            componentString = '0' + componentString;
+        }
+        return componentString;
+    }
+    return ('#' +
+        colorComponentToString(colorArray[0]) +
+        colorComponentToString(colorArray[1]) +
+        colorComponentToString(colorArray[2]));
+}
+function removeExtraPoints(viewport, worldPointsSet) {
+    return worldPointsSet.map((worldPoints) => {
+        const canvasPoints = worldPoints.map((point) => {
+            const canvasPoint = viewport.worldToCanvas(point);
+            return [Math.floor(canvasPoint[0]), Math.floor(canvasPoint[1])];
+        });
+        let lastPoint;
+        const newWorldPoints = [];
+        let newCanvasPoints = [];
+        for (let i = 0; i < worldPoints.length; i++) {
+            if (lastPoint) {
+                if (distanceToPoint(lastPoint, canvasPoints[i]) > 0) {
+                    newWorldPoints.push(worldPoints[i]);
+                    newCanvasPoints.push(canvasPoints[i]);
+                }
+            }
+            lastPoint = canvasPoints[i];
+        }
+        const firstPoint = newCanvasPoints[0];
+        for (let j = Math.min(30, newCanvasPoints.length); j < newCanvasPoints.length; j++) {
+            if (distanceToPoint(firstPoint, newCanvasPoints[j]) < 0.5) {
+                newCanvasPoints = newCanvasPoints.slice(0, j);
+                return newWorldPoints.slice(0, j);
+            }
+        }
+        return newWorldPoints;
+    });
+}
+SegmentationIntersectionTool.toolName = 'SegmentationIntersection';
+export default SegmentationIntersectionTool;

package/dist/esm/tools/StackScrollTool.d.ts

@@ -1,13 +1,15 @@
 import { BaseTool } from './base';
-import { PublicToolProps, ToolProps, EventTypes } from '../types';
+import type { PublicToolProps, ToolProps, EventTypes } from '../types';
 declare class StackScrollTool extends BaseTool {
     static toolName: any;
     deltaY: number;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    mouseWheelCallback(evt: EventTypes.MouseWheelEventType): void;
     mouseDragCallback(evt: EventTypes.InteractionEventType): void;
     touchDragCallback(evt: EventTypes.InteractionEventType): void;
     _dragCallback(evt: EventTypes.InteractionEventType): void;
+    _scrollDrag(evt: EventTypes.InteractionEventType): void;
+    _scroll(evt: EventTypes.MouseWheelEventType): void;
     _getPixelPerImage(viewport: any): number;
-    _getNumberOfSlices(viewport: any): number;
 }
 export default StackScrollTool;