@cornerstonejs/tools 3.0.2 → 3.0.4

package/dist/esm/eventListeners/annotations/contourSegmentation/contourSegmentationCompleted.js

@@ -0,0 +1,233 @@
+import { getEnabledElement, utilities as csUtils } from '@cornerstonejs/core';
+import getViewportsForAnnotation from '../../../utilities/getViewportsForAnnotation';
+import * as math from '../../../utilities/math';
+import triggerAnnotationRenderForViewportIds from '../../../utilities/triggerAnnotationRenderForViewportIds';
+import { getViewportIdsWithToolToRender } from '../../../utilities/viewportFilters';
+import { addAnnotation, removeAnnotation, getAllAnnotations, getChildAnnotations, addChildAnnotation, clearParentAnnotation, } from '../../../stateManagement/annotation/annotationState';
+import { ContourWindingDirection } from '../../../types/ContourAnnotation';
+import { triggerAnnotationModified } from '../../../stateManagement/annotation/helpers/state';
+import updateContourPolyline from '../../../utilities/contours/updateContourPolyline';
+import { addContourSegmentationAnnotation, areSameSegment, isContourSegmentationAnnotation, removeContourSegmentationAnnotation, } from '../../../utilities/contourSegmentation';
+import { getToolGroupForViewport } from '../../../store/ToolGroupManager';
+import { hasTool, hasToolByName } from '../../../store/addTool';
+const DEFAULT_CONTOUR_SEG_TOOL_NAME = 'PlanarFreehandContourSegmentationTool';
+export default async function contourSegmentationCompletedListener(evt) {
+    const sourceAnnotation = evt.detail
+        .annotation;
+    if (!isContourSegmentationAnnotation(sourceAnnotation)) {
+        return;
+    }
+    const viewport = getViewport(sourceAnnotation);
+    const contourSegmentationAnnotations = getValidContourSegmentationAnnotations(viewport, sourceAnnotation);
+    if (!contourSegmentationAnnotations.length) {
+        return;
+    }
+    const sourcePolyline = convertContourPolylineToCanvasSpace(sourceAnnotation.data.contour.polyline, viewport);
+    const targetAnnotationInfo = findIntersectingContour(viewport, sourcePolyline, contourSegmentationAnnotations);
+    if (!targetAnnotationInfo) {
+        return;
+    }
+    const { targetAnnotation, targetPolyline, isContourHole } = targetAnnotationInfo;
+    if (isContourHole) {
+        const { contourHoleProcessingEnabled = false } = evt.detail;
+        if (!contourHoleProcessingEnabled) {
+            return;
+        }
+        createPolylineHole(viewport, targetAnnotation, sourceAnnotation);
+    }
+    else {
+        combinePolylines(viewport, targetAnnotation, targetPolyline, sourceAnnotation, sourcePolyline);
+    }
+}
+function isFreehandContourSegToolRegisteredForViewport(viewport, silent = false) {
+    const toolName = 'PlanarFreehandContourSegmentationTool';
+    const toolGroup = getToolGroupForViewport(viewport.id, viewport.renderingEngineId);
+    let errorMessage;
+    if (!toolGroup.hasTool(toolName)) {
+        errorMessage = `Tool ${toolName} not added to ${toolGroup.id} toolGroup`;
+    }
+    else if (!toolGroup.getToolOptions(toolName)) {
+        errorMessage = `Tool ${toolName} must be in active/passive state`;
+    }
+    if (errorMessage && !silent) {
+        console.warn(errorMessage);
+    }
+    return !errorMessage;
+}
+function getViewport(annotation) {
+    const viewports = getViewportsForAnnotation(annotation);
+    const viewportWithToolRegistered = viewports.find((viewport) => isFreehandContourSegToolRegisteredForViewport(viewport, true));
+    return viewportWithToolRegistered ?? viewports[0];
+}
+function convertContourPolylineToCanvasSpace(polyline, viewport) {
+    const numPoints = polyline.length;
+    const projectedPolyline = new Array(numPoints);
+    for (let i = 0; i < numPoints; i++) {
+        projectedPolyline[i] = viewport.worldToCanvas(polyline[i]);
+    }
+    return projectedPolyline;
+}
+function getValidContourSegmentationAnnotations(viewport, sourceAnnotation) {
+    const { annotationUID: sourceAnnotationUID } = sourceAnnotation;
+    const allAnnotations = getAllAnnotations();
+    return allAnnotations.filter((targetAnnotation) => targetAnnotation.annotationUID &&
+        targetAnnotation.annotationUID !== sourceAnnotationUID &&
+        isContourSegmentationAnnotation(targetAnnotation) &&
+        areSameSegment(targetAnnotation, sourceAnnotation) &&
+        viewport.isReferenceViewable(targetAnnotation.metadata));
+}
+function findIntersectingContour(viewport, sourcePolyline, contourSegmentationAnnotations) {
+    const sourceAABB = math.polyline.getAABB(sourcePolyline);
+    for (let i = 0; i < contourSegmentationAnnotations.length; i++) {
+        const targetAnnotation = contourSegmentationAnnotations[i];
+        const targetPolyline = convertContourPolylineToCanvasSpace(targetAnnotation.data.contour.polyline, viewport);
+        const targetAABB = math.polyline.getAABB(targetPolyline);
+        const aabbIntersect = math.aabb.intersectAABB(sourceAABB, targetAABB);
+        const lineSegmentsIntersect = aabbIntersect &&
+            math.polyline.intersectPolyline(sourcePolyline, targetPolyline);
+        const isContourHole = aabbIntersect &&
+            !lineSegmentsIntersect &&
+            math.polyline.containsPoints(targetPolyline, sourcePolyline);
+        if (lineSegmentsIntersect || isContourHole) {
+            return { targetAnnotation, targetPolyline, isContourHole };
+        }
+    }
+}
+export function createPolylineHole(viewport, targetAnnotation, holeAnnotation) {
+    const { windingDirection: targetWindingDirection } = targetAnnotation.data.contour;
+    const { windingDirection: holeWindingDirection } = holeAnnotation.data.contour;
+    addChildAnnotation(targetAnnotation, holeAnnotation);
+    removeContourSegmentationAnnotation(holeAnnotation);
+    const { contour: holeContour } = holeAnnotation.data;
+    const holePolyline = convertContourPolylineToCanvasSpace(holeContour.polyline, viewport);
+    updateContourPolyline(holeAnnotation, {
+        points: holePolyline,
+        closed: holeContour.closed,
+    }, viewport);
+    const { element } = viewport;
+    const updatedToolNames = new Set([
+        DEFAULT_CONTOUR_SEG_TOOL_NAME,
+        targetAnnotation.metadata.toolName,
+        holeAnnotation.metadata.toolName,
+    ]);
+    for (const toolName of updatedToolNames.values()) {
+        const viewportIdsToRender = getViewportIdsWithToolToRender(element, toolName);
+        triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+    }
+}
+function getContourHolesData(viewport, annotation) {
+    return getChildAnnotations(annotation).map((holeAnnotation) => {
+        const polyline = convertContourPolylineToCanvasSpace(holeAnnotation.data.contour.polyline, viewport);
+        return { annotation: holeAnnotation, polyline };
+    });
+}
+function combinePolylines(viewport, targetAnnotation, targetPolyline, sourceAnnotation, sourcePolyline) {
+    if (!hasToolByName(DEFAULT_CONTOUR_SEG_TOOL_NAME)) {
+        console.warn(`${DEFAULT_CONTOUR_SEG_TOOL_NAME} is not registered in cornerstone`);
+        return;
+    }
+    if (!isFreehandContourSegToolRegisteredForViewport(viewport)) {
+        return;
+    }
+    const sourceStartPoint = sourcePolyline[0];
+    const mergePolylines = math.polyline.containsPoint(targetPolyline, sourceStartPoint);
+    const contourHolesData = getContourHolesData(viewport, targetAnnotation);
+    const unassignedContourHolesSet = new Set(contourHolesData);
+    const reassignedContourHolesMap = new Map();
+    const assignHoleToPolyline = (parentPolyline, holeData) => {
+        let holes = reassignedContourHolesMap.get(parentPolyline);
+        if (!holes) {
+            holes = [];
+            reassignedContourHolesMap.set(parentPolyline, holes);
+        }
+        holes.push(holeData);
+        unassignedContourHolesSet.delete(holeData);
+    };
+    const newPolylines = [];
+    if (mergePolylines) {
+        const mergedPolyline = math.polyline.mergePolylines(targetPolyline, sourcePolyline);
+        newPolylines.push(mergedPolyline);
+        Array.from(unassignedContourHolesSet.keys()).forEach((holeData) => assignHoleToPolyline(mergedPolyline, holeData));
+    }
+    else {
+        const subtractedPolylines = math.polyline.subtractPolylines(targetPolyline, sourcePolyline);
+        subtractedPolylines.forEach((newPolyline) => {
+            newPolylines.push(newPolyline);
+            Array.from(unassignedContourHolesSet.keys()).forEach((holeData) => {
+                const containsHole = math.polyline.containsPoints(newPolyline, holeData.polyline);
+                if (containsHole) {
+                    assignHoleToPolyline(newPolyline, holeData);
+                    unassignedContourHolesSet.delete(holeData);
+                }
+            });
+        });
+    }
+    Array.from(reassignedContourHolesMap.values()).forEach((contourHolesDataArray) => contourHolesDataArray.forEach((contourHoleData) => clearParentAnnotation(contourHoleData.annotation)));
+    const { element } = viewport;
+    const enabledElement = getEnabledElement(element);
+    const { metadata, data } = targetAnnotation;
+    const { handles, segmentation } = data;
+    const { textBox } = handles;
+    removeAnnotation(sourceAnnotation.annotationUID);
+    removeAnnotation(targetAnnotation.annotationUID);
+    for (let i = 0; i < newPolylines.length; i++) {
+        const polyline = newPolylines[i];
+        const startPoint = viewport.canvasToWorld(polyline[0]);
+        const endPoint = viewport.canvasToWorld(polyline[polyline.length - 1]);
+        const newAnnotation = {
+            metadata: {
+                ...metadata,
+                toolName: DEFAULT_CONTOUR_SEG_TOOL_NAME,
+                originalToolName: metadata.originalToolName || metadata.toolName,
+            },
+            data: {
+                cachedStats: {},
+                handles: {
+                    points: [startPoint, endPoint],
+                    textBox: textBox ? { ...textBox } : undefined,
+                },
+                contour: {
+                    polyline: [],
+                    closed: true,
+                },
+                spline: targetAnnotation.data.spline,
+                segmentation: {
+                    ...segmentation,
+                },
+            },
+            annotationUID: csUtils.uuidv4(),
+            highlighted: true,
+            invalidated: true,
+            isLocked: false,
+            isVisible: undefined,
+            interpolationUID: targetAnnotation.interpolationUID,
+            interpolationCompleted: targetAnnotation.interpolationCompleted,
+        };
+        updateContourPolyline(newAnnotation, {
+            points: polyline,
+            closed: true,
+            targetWindingDirection: ContourWindingDirection.Clockwise,
+        }, viewport);
+        addAnnotation(newAnnotation, element);
+        addContourSegmentationAnnotation(newAnnotation);
+        triggerAnnotationModified(newAnnotation, viewport.element);
+        reassignedContourHolesMap
+            .get(polyline)
+            ?.forEach((holeData) => addChildAnnotation(newAnnotation, holeData.annotation));
+    }
+    updateViewports(enabledElement, targetAnnotation, sourceAnnotation);
+}
+function updateViewports(enabledElement, targetAnnotation, sourceAnnotation) {
+    const { viewport } = enabledElement;
+    const { element } = viewport;
+    const updatedTtoolNames = new Set([
+        DEFAULT_CONTOUR_SEG_TOOL_NAME,
+        targetAnnotation.metadata.toolName,
+        sourceAnnotation.metadata.toolName,
+    ]);
+    for (const toolName of updatedTtoolNames.values()) {
+        const viewportIdsToRender = getViewportIdsWithToolToRender(element, toolName);
+        triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+    }
+    return new Promise((resolve) => window.requestAnimationFrame(resolve));
+}

package/dist/esm/eventListeners/annotations/contourSegmentation/contourSegmentationRemoved.d.ts

@@ -0,0 +1,2 @@
+import type { AnnotationRemovedEventType } from '../../../types/EventTypes';
+export default function contourSegmentationRemovedListener(evt: AnnotationRemovedEventType): void;

package/dist/esm/eventListeners/annotations/contourSegmentation/contourSegmentationRemoved.js

@@ -0,0 +1,5 @@
+import { removeContourSegmentationAnnotation } from '../../../utilities/contourSegmentation';
+export default function contourSegmentationRemovedListener(evt) {
+    const annotation = evt.detail.annotation;
+    removeContourSegmentationAnnotation(annotation);
+}

package/dist/esm/eventListeners/annotations/contourSegmentation/index.d.ts

@@ -0,0 +1,2 @@
+export { default as contourSegmentationCompleted } from './contourSegmentationCompleted';
+export { default as contourSegmentationRemoved } from './contourSegmentationRemoved';

package/dist/esm/eventListeners/annotations/contourSegmentation/index.js

@@ -0,0 +1,2 @@
+export { default as contourSegmentationCompleted } from './contourSegmentationCompleted';
+export { default as contourSegmentationRemoved } from './contourSegmentationRemoved';

package/dist/esm/eventListeners/annotations/index.d.ts

@@ -0,0 +1,5 @@
+import annotationCompletedListener from './annotationCompletedListener';
+import annotationSelectionListener from './annotationSelectionListener';
+import annotationModifiedListener from './annotationModifiedListener';
+import annotationRemovedListener from './annotationRemovedListener';
+export { annotationCompletedListener, annotationSelectionListener, annotationModifiedListener, annotationRemovedListener, };

package/dist/esm/eventListeners/annotations/index.js

@@ -0,0 +1,5 @@
+import annotationCompletedListener from './annotationCompletedListener';
+import annotationSelectionListener from './annotationSelectionListener';
+import annotationModifiedListener from './annotationModifiedListener';
+import annotationRemovedListener from './annotationRemovedListener';
+export { annotationCompletedListener, annotationSelectionListener, annotationModifiedListener, annotationRemovedListener, };

package/dist/esm/eventListeners/index.d.ts

@@ -0,0 +1,7 @@
+import mouseEventListeners from './mouse';
+import touchEventListeners from './touch';
+import wheelEventListener from './wheel';
+import keyEventListener from './keyboard';
+import { segmentationDataModifiedEventListener, segmentationModifiedListener, imageChangeEventListener } from './segmentation';
+import { annotationCompletedListener, annotationSelectionListener, annotationModifiedListener, annotationRemovedListener } from './annotations';
+export { mouseEventListeners, touchEventListeners, wheelEventListener, keyEventListener, segmentationModifiedListener, segmentationDataModifiedEventListener, imageChangeEventListener, annotationCompletedListener, annotationSelectionListener, annotationModifiedListener, annotationRemovedListener, };

package/dist/esm/eventListeners/index.js

@@ -0,0 +1,7 @@
+import mouseEventListeners from './mouse';
+import touchEventListeners from './touch';
+import wheelEventListener from './wheel';
+import keyEventListener from './keyboard';
+import { segmentationDataModifiedEventListener, segmentationModifiedListener, imageChangeEventListener, } from './segmentation';
+import { annotationCompletedListener, annotationSelectionListener, annotationModifiedListener, annotationRemovedListener, } from './annotations';
+export { mouseEventListeners, touchEventListeners, wheelEventListener, keyEventListener, segmentationModifiedListener, segmentationDataModifiedEventListener, imageChangeEventListener, annotationCompletedListener, annotationSelectionListener, annotationModifiedListener, annotationRemovedListener, };

package/dist/esm/eventListeners/keyboard/index.d.ts

@@ -0,0 +1,9 @@
+import { getModifierKey } from './keyDownListener';
+declare function enable(element: HTMLDivElement): void;
+declare function disable(element: HTMLDivElement): void;
+declare const _default: {
+    enable: typeof enable;
+    disable: typeof disable;
+    getModifierKey: typeof getModifierKey;
+};
+export default _default;

package/dist/esm/eventListeners/keyboard/index.js

@@ -0,0 +1,13 @@
+import keyDownListener, { getModifierKey } from './keyDownListener';
+function enable(element) {
+    disable(element);
+    element.addEventListener('keydown', keyDownListener);
+}
+function disable(element) {
+    element.removeEventListener('keydown', keyDownListener);
+}
+export default {
+    enable,
+    disable,
+    getModifierKey,
+};

package/dist/esm/eventListeners/keyboard/keyDownListener.d.ts

@@ -0,0 +1,4 @@
+declare function keyListener(evt: KeyboardEvent): void;
+export declare function getModifierKey(): number | undefined;
+export declare function resetModifierKey(): void;
+export default keyListener;

package/dist/esm/eventListeners/keyboard/keyDownListener.js

@@ -0,0 +1,64 @@
+import { getEnabledElement, triggerEvent } from '@cornerstonejs/core';
+import Events from '../../enums/Events';
+const defaultState = {
+    renderingEngineId: undefined,
+    viewportId: undefined,
+    key: undefined,
+    keyCode: undefined,
+    element: null,
+};
+let state = {
+    renderingEngineId: undefined,
+    viewportId: undefined,
+    key: undefined,
+    keyCode: undefined,
+    element: null,
+};
+function keyListener(evt) {
+    state.element = evt.currentTarget;
+    const enabledElement = getEnabledElement(state.element);
+    const { renderingEngineId, viewportId } = enabledElement;
+    state.renderingEngineId = renderingEngineId;
+    state.viewportId = viewportId;
+    state.key = evt.key;
+    state.keyCode = evt.keyCode;
+    evt.preventDefault();
+    const eventDetail = {
+        renderingEngineId: state.renderingEngineId,
+        viewportId: state.viewportId,
+        element: state.element,
+        key: state.key,
+        keyCode: state.keyCode,
+    };
+    triggerEvent(eventDetail.element, Events.KEY_DOWN, eventDetail);
+    document.addEventListener('keyup', _onKeyUp);
+    document.addEventListener('visibilitychange', _onVisibilityChange);
+    state.element.removeEventListener('keydown', keyListener);
+}
+function _onVisibilityChange() {
+    document.removeEventListener('visibilitychange', _onVisibilityChange);
+    if (document.visibilityState === 'hidden') {
+        resetModifierKey();
+    }
+}
+function _onKeyUp(evt) {
+    const eventDetail = {
+        renderingEngineId: state.renderingEngineId,
+        viewportId: state.viewportId,
+        element: state.element,
+        key: state.key,
+        keyCode: state.keyCode,
+    };
+    document.removeEventListener('keyup', _onKeyUp);
+    document.removeEventListener('visibilitychange', _onVisibilityChange);
+    state.element.addEventListener('keydown', keyListener);
+    state = structuredClone(defaultState);
+    triggerEvent(eventDetail.element, Events.KEY_UP, eventDetail);
+}
+export function getModifierKey() {
+    return state.keyCode;
+}
+export function resetModifierKey() {
+    state.keyCode = undefined;
+}
+export default keyListener;

package/dist/esm/eventListeners/mouse/getMouseEventPoints.d.ts

@@ -0,0 +1,2 @@
+import type { IPoints } from '../../types';
+export default function getMouseEventPoints(evt: MouseEvent, element?: HTMLDivElement): IPoints;

package/dist/esm/eventListeners/mouse/getMouseEventPoints.js

@@ -0,0 +1,31 @@
+import { getEnabledElement } from '@cornerstonejs/core';
+export default function getMouseEventPoints(evt, element) {
+    const elementToUse = element || evt.currentTarget;
+    const { viewport } = getEnabledElement(elementToUse) || {};
+    if (!viewport) {
+        return;
+    }
+    const clientPoint = _clientToPoint(evt);
+    const pagePoint = _pageToPoint(evt);
+    const canvasPoint = _pagePointsToCanvasPoints(elementToUse, pagePoint);
+    const worldPoint = viewport.canvasToWorld(canvasPoint);
+    return {
+        page: pagePoint,
+        client: clientPoint,
+        canvas: canvasPoint,
+        world: worldPoint,
+    };
+}
+function _pagePointsToCanvasPoints(element, pagePoint) {
+    const rect = element.getBoundingClientRect();
+    return [
+        pagePoint[0] - rect.left - window.pageXOffset,
+        pagePoint[1] - rect.top - window.pageYOffset,
+    ];
+}
+function _pageToPoint(evt) {
+    return [evt.pageX, evt.pageY];
+}
+function _clientToPoint(evt) {
+    return [evt.clientX, evt.clientY];
+}

package/dist/esm/eventListeners/mouse/index.d.ts

@@ -0,0 +1,7 @@
+declare function disable(element: HTMLDivElement): void;
+declare function enable(element: HTMLDivElement): void;
+declare const _default: {
+    enable: typeof enable;
+    disable: typeof disable;
+};
+export default _default;

package/dist/esm/eventListeners/mouse/index.js

@@ -0,0 +1,24 @@
+import mouseDoubleClickListener from './mouseDoubleClickListener';
+import mouseDownListener, { mouseDoubleClickIgnoreListener, } from './mouseDownListener';
+import mouseMoveListener from './mouseMoveListener';
+function disable(element) {
+    element.removeEventListener('dblclick', mouseDoubleClickListener);
+    element.removeEventListener('mousedown', mouseDownListener);
+    element.removeEventListener('mousemove', mouseMoveListener);
+    element.removeEventListener('dblclick', mouseDoubleClickIgnoreListener, {
+        capture: true,
+    });
+}
+function enable(element) {
+    disable(element);
+    element.addEventListener('dblclick', mouseDoubleClickListener);
+    element.addEventListener('mousedown', mouseDownListener);
+    element.addEventListener('mousemove', mouseMoveListener);
+    element.addEventListener('dblclick', mouseDoubleClickIgnoreListener, {
+        capture: true,
+    });
+}
+export default {
+    enable,
+    disable,
+};

package/dist/esm/eventListeners/mouse/mouseDoubleClickListener.d.ts

@@ -0,0 +1,2 @@
+declare function mouseDoubleClickListener(evt: MouseEvent): void;
+export default mouseDoubleClickListener;

package/dist/esm/eventListeners/mouse/mouseDoubleClickListener.js

@@ -0,0 +1,32 @@
+import { getEnabledElement, triggerEvent } from '@cornerstonejs/core';
+import Events from '../../enums/Events';
+import getMouseEventPoints from './getMouseEventPoints';
+function mouseDoubleClickListener(evt) {
+    const element = evt.currentTarget;
+    const { viewportId, renderingEngineId } = getEnabledElement(element);
+    const startPoints = getMouseEventPoints(evt, element);
+    const deltaPoints = {
+        page: [0, 0],
+        client: [0, 0],
+        canvas: [0, 0],
+        world: [0, 0, 0],
+    };
+    const eventDetail = {
+        event: evt,
+        eventName: Events.MOUSE_DOUBLE_CLICK,
+        viewportId,
+        renderingEngineId,
+        camera: {},
+        element,
+        startPoints,
+        lastPoints: startPoints,
+        currentPoints: startPoints,
+        deltaPoints,
+    };
+    const consumed = !triggerEvent(element, Events.MOUSE_DOUBLE_CLICK, eventDetail);
+    if (consumed) {
+        evt.stopImmediatePropagation();
+        evt.preventDefault();
+    }
+}
+export default mouseDoubleClickListener;

package/dist/esm/eventListeners/mouse/mouseDownListener.d.ts

@@ -0,0 +1,4 @@
+declare function mouseDownListener(evt: MouseEvent): void;
+export declare function getMouseButton(): number;
+export declare function mouseDoubleClickIgnoreListener(evt: MouseEvent): void;
+export default mouseDownListener;