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

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

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

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

@@ -0,0 +1,8 @@
+import * as contourSegUtils from '../../utilities/contourSegmentation';
+import { contourSegmentationCompleted } from './contourSegmentation';
+export default function annotationCompletedListener(evt) {
+    const annotation = evt.detail.annotation;
+    if (contourSegUtils.isContourSegmentationAnnotation(annotation)) {
+        contourSegmentationCompleted(evt);
+    }
+}

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

@@ -1,9 +1,6 @@
-import { getRenderingEngine } from '@cornerstonejs/core';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 function annotationModifiedListener(evt) {
-    const { viewportId, renderingEngineId } = evt.detail;
-    const renderingEngine = getRenderingEngine(renderingEngineId);
-    triggerAnnotationRenderForViewportIds(renderingEngine, [viewportId]);
+    const { viewportId } = evt.detail;
+    triggerAnnotationRenderForViewportIds([viewportId]);
 }
 export default annotationModifiedListener;
-//# sourceMappingURL=annotationModifiedListener.js.map

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

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

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

@@ -0,0 +1,8 @@
+import * as contourSegUtils from '../../utilities/contourSegmentation';
+import { contourSegmentationRemoved } from './contourSegmentation';
+export default function annotationRemovedListener(evt) {
+    const annotation = evt.detail.annotation;
+    if (contourSegUtils.isContourSegmentationAnnotation(annotation)) {
+        contourSegmentationRemoved(evt);
+    }
+}

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

@@ -1,5 +1,5 @@
 import { getRenderingEngines } from '@cornerstonejs/core';
-import { triggerAnnotationRenderForViewportIds } from '../../utilities';
+import { triggerAnnotationRenderForViewportIds } from '../../utilities/triggerAnnotationRenderForViewportIds';
 function annotationSelectionListener(evt) {
     const deselectedAnnotation = evt.detail.removed;
     if (!deselectedAnnotation.length) {
@@ -9,8 +9,7 @@ function annotationSelectionListener(evt) {
     renderingEngines.forEach((renderingEngine) => {
         const viewports = renderingEngine.getViewports();
         const viewportIds = viewports.map((vp) => vp.id);
-        triggerAnnotationRenderForViewportIds(renderingEngine, viewportIds);
+        triggerAnnotationRenderForViewportIds(viewportIds);
     });
 }
 export default annotationSelectionListener;
-//# sourceMappingURL=annotationSelectionListener.js.map

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

@@ -0,0 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ContourSegmentationAnnotation } from '../../../types/ContourSegmentationAnnotation';
+import type { AnnotationCompletedEventType } from '../../../types/EventTypes';
+export default function contourSegmentationCompletedListener(evt: AnnotationCompletedEventType): Promise<void>;
+export declare function createPolylineHole(viewport: Types.IViewport, targetAnnotation: ContourSegmentationAnnotation, holeAnnotation: ContourSegmentationAnnotation): void;

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

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

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

@@ -1,4 +1,5 @@
+import annotationCompletedListener from './annotationCompletedListener';
 import annotationSelectionListener from './annotationSelectionListener';
 import annotationModifiedListener from './annotationModifiedListener';
-export { annotationSelectionListener, annotationModifiedListener };
-//# sourceMappingURL=index.js.map
+import annotationRemovedListener from './annotationRemovedListener';
+export { annotationCompletedListener, annotationSelectionListener, annotationModifiedListener, annotationRemovedListener, };

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

@@ -2,6 +2,6 @@ import mouseEventListeners from './mouse';
 import touchEventListeners from './touch';
 import wheelEventListener from './wheel';
 import keyEventListener from './keyboard';
-import { segmentationDataModifiedEventListener, segmentationRepresentationModifiedEventListener, segmentationRepresentationRemovedEventListener, segmentationModifiedListener } from './segmentation';
-import { annotationSelectionListener, annotationModifiedListener } from './annotations';
-export { mouseEventListeners, touchEventListeners, wheelEventListener, keyEventListener, segmentationRepresentationModifiedEventListener, segmentationModifiedListener, segmentationRepresentationRemovedEventListener, segmentationDataModifiedEventListener, annotationSelectionListener, annotationModifiedListener, };
+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

@@ -2,7 +2,6 @@ import mouseEventListeners from './mouse';
 import touchEventListeners from './touch';
 import wheelEventListener from './wheel';
 import keyEventListener from './keyboard';
-import { segmentationDataModifiedEventListener, segmentationRepresentationModifiedEventListener, segmentationRepresentationRemovedEventListener, segmentationModifiedListener, } from './segmentation';
-import { annotationSelectionListener, annotationModifiedListener, } from './annotations';
-export { mouseEventListeners, touchEventListeners, wheelEventListener, keyEventListener, segmentationRepresentationModifiedEventListener, segmentationModifiedListener, segmentationRepresentationRemovedEventListener, segmentationDataModifiedEventListener, annotationSelectionListener, annotationModifiedListener, };
-//# sourceMappingURL=index.js.map
+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.js

@@ -11,4 +11,3 @@ export default {
     disable,
     getModifierKey,
 };
-//# sourceMappingURL=index.js.map

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

@@ -1,4 +1,3 @@
-import _cloneDeep from 'lodash.clonedeep';
 import { getEnabledElement, triggerEvent } from '@cornerstonejs/core';
 import Events from '../../enums/Events';
 const defaultState = {
@@ -53,7 +52,7 @@ function _onKeyUp(evt) {
     document.removeEventListener('keyup', _onKeyUp);
     document.removeEventListener('visibilitychange', _onVisibilityChange);
     state.element.addEventListener('keydown', keyListener);
-    state = _cloneDeep(defaultState);
+    state = structuredClone(defaultState);
     triggerEvent(eventDetail.element, Events.KEY_UP, eventDetail);
 }
 export function getModifierKey() {
@@ -63,4 +62,3 @@ export function resetModifierKey() {
     state.keyCode = undefined;
 }
 export default keyListener;
-//# sourceMappingURL=keyDownListener.js.map

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

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

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

@@ -1,7 +1,10 @@
 import { getEnabledElement } from '@cornerstonejs/core';
 export default function getMouseEventPoints(evt, element) {
     const elementToUse = element || evt.currentTarget;
-    const { viewport } = getEnabledElement(elementToUse);
+    const { viewport } = getEnabledElement(elementToUse) || {};
+    if (!viewport) {
+        return;
+    }
     const clientPoint = _clientToPoint(evt);
     const pagePoint = _pageToPoint(evt);
     const canvasPoint = _pagePointsToCanvasPoints(elementToUse, pagePoint);
@@ -26,4 +29,3 @@ function _pageToPoint(evt) {
 function _clientToPoint(evt) {
     return [evt.clientX, evt.clientY];
 }
-//# sourceMappingURL=getMouseEventPoints.js.map

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

@@ -22,4 +22,3 @@ export default {
     enable,
     disable,
 };
-//# sourceMappingURL=index.js.map

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

@@ -30,4 +30,3 @@ function mouseDoubleClickListener(evt) {
     }
 }
 export default mouseDoubleClickListener;
-//# sourceMappingURL=mouseDoubleClickListener.js.map

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

@@ -1,5 +1,6 @@
 import { getEnabledElement, triggerEvent } from '@cornerstonejs/core';
 import Events from '../../enums/Events';
+import { MouseBindings } from '../../enums/ToolBindings';
 import mouseMoveListener from './mouseMoveListener';
 import getMouseEventPoints from './getMouseEventPoints';
 const { MOUSE_DOWN, MOUSE_DOWN_ACTIVATE, MOUSE_CLICK, MOUSE_UP, MOUSE_DRAG } = Events;
@@ -102,6 +103,10 @@ function _doMouseDown(evt) {
     }
 }
 function _onMouseDrag(evt) {
+    const enabledElement = getEnabledElement(state.element);
+    if (!enabledElement?.viewport) {
+        return;
+    }
     const currentPoints = getMouseEventPoints(evt, state.element);
     const lastPoints = _updateMouseEventsLastPoints(state.element, state.lastPoints);
     const deltaPoints = _getDeltaPoints(currentPoints, lastPoints);
@@ -211,7 +216,10 @@ function _copyPoints(points) {
     return JSON.parse(JSON.stringify(points));
 }
 function _updateMouseEventsLastPoints(element, lastPoints) {
-    const { viewport } = getEnabledElement(element);
+    const { viewport } = getEnabledElement(element) || {};
+    if (!viewport) {
+        return lastPoints;
+    }
     const world = viewport.canvasToWorld(lastPoints.canvas);
     return {
         page: lastPoints.page,
@@ -221,6 +229,14 @@ function _updateMouseEventsLastPoints(element, lastPoints) {
     };
 }
 function _getDeltaPoints(currentPoints, lastPoints) {
+    if (!currentPoints || !lastPoints) {
+        return {
+            page: [0, 0],
+            client: [0, 0],
+            canvas: [0, 0],
+            world: [0, 0, 0],
+        };
+    }
     return {
         page: _subtractPoints2D(currentPoints.page, lastPoints.page),
         client: _subtractPoints2D(currentPoints.client, lastPoints.client),
@@ -248,4 +264,3 @@ export function mouseDoubleClickIgnoreListener(evt) {
     }
 }
 export default mouseDownListener;
-//# sourceMappingURL=mouseDownListener.js.map

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

@@ -23,4 +23,3 @@ function mouseMoveListener(evt) {
     }
 }
 export default mouseMoveListener;
-//# sourceMappingURL=mouseMoveListener.js.map

package/dist/esm/eventListeners/segmentation/imageChangeEventListener.js

@@ -0,0 +1,120 @@
+import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import { BaseVolumeViewport, getEnabledElement, Enums, getEnabledElementByIds, cache, utilities, } from '@cornerstonejs/core';
+import { triggerSegmentationRender } from '../../stateManagement/segmentation/SegmentationRenderingEngine';
+import { updateLabelmapSegmentationImageReferences } from '../../stateManagement/segmentation/updateLabelmapSegmentationImageReferences';
+import { getCurrentLabelmapImageIdForViewport } from '../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
+import { SegmentationRepresentations } from '../../enums';
+import { getLabelmapActorUID } from '../../stateManagement/segmentation/helpers/getSegmentationActor';
+import { getSegmentationRepresentations } from '../../stateManagement/segmentation/getSegmentationRepresentation';
+const enable = function (element) {
+    const { viewport } = getEnabledElement(element);
+    if (viewport instanceof BaseVolumeViewport) {
+        return;
+    }
+    element.addEventListener(Enums.Events.STACK_NEW_IMAGE, _imageChangeEventListener);
+    element.addEventListener(Enums.Events.IMAGE_RENDERED, _imageChangeEventListener);
+};
+const disable = function (element) {
+    element.removeEventListener(Enums.Events.STACK_NEW_IMAGE, _imageChangeEventListener);
+    element.removeEventListener(Enums.Events.IMAGE_RENDERED, _imageChangeEventListener);
+};
+const perViewportManualTriggers = new Map();
+function _imageChangeEventListener(evt) {
+    const eventData = evt.detail;
+    const { viewportId, renderingEngineId } = eventData;
+    const { viewport } = getEnabledElementByIds(viewportId, renderingEngineId);
+    const representations = getSegmentationRepresentations(viewportId);
+    if (!representations?.length) {
+        return;
+    }
+    const labelmapRepresentations = representations.filter((representation) => representation.type === SegmentationRepresentations.Labelmap);
+    const actors = viewport.getActors();
+    labelmapRepresentations.forEach((representation) => {
+        const { segmentationId } = representation;
+        updateLabelmapSegmentationImageReferences(viewportId, segmentationId);
+    });
+    const labelmapActors = labelmapRepresentations
+        .map((representation) => {
+        const actorUID = getLabelmapActorUID(representation.segmentationId);
+        return actors.find((actor) => actor.uid === actorUID);
+    })
+        .filter((actor) => actor !== undefined);
+    if (!labelmapActors.length) {
+        return;
+    }
+    labelmapActors.forEach((actor) => {
+        const validActor = labelmapRepresentations.find((representation) => {
+            const derivedImageId = getCurrentLabelmapImageIdForViewport(viewportId, representation.segmentationId);
+            return derivedImageId === actor.referencedId;
+        });
+        if (!validActor) {
+            viewport.removeActors([actor.uid]);
+        }
+    });
+    labelmapRepresentations.forEach((representation) => {
+        const { segmentationId } = representation;
+        const currentImageId = viewport.getCurrentImageId();
+        const derivedImageId = getCurrentLabelmapImageIdForViewport(viewportId, segmentationId);
+        if (!derivedImageId) {
+            return;
+        }
+        const derivedImage = cache.getImage(derivedImageId);
+        if (!derivedImage) {
+            console.warn('No derived image found in the cache for segmentation representation', representation);
+            return;
+        }
+        const segmentationActorInput = actors.find((actor) => actor.referencedId === derivedImageId);
+        if (!segmentationActorInput) {
+            const { dimensions, spacing, direction } = viewport.getImageDataMetadata(derivedImage);
+            const currentImage = cache.getImage(currentImageId) ||
+                {
+                    imageId: currentImageId,
+                };
+            const { origin: currentOrigin } = viewport.getImageDataMetadata(currentImage);
+            const originToUse = currentOrigin;
+            const scalarArray = vtkDataArray.newInstance({
+                name: 'Pixels',
+                numberOfComponents: 1,
+                values: [...derivedImage.voxelManager.getScalarData()],
+            });
+            const imageData = vtkImageData.newInstance();
+            imageData.setDimensions(dimensions[0], dimensions[1], 1);
+            imageData.setSpacing(spacing);
+            imageData.setDirection(direction);
+            imageData.setOrigin(originToUse);
+            imageData.getPointData().setScalars(scalarArray);
+            imageData.modified();
+            viewport.addImages([
+                {
+                    imageId: derivedImageId,
+                    actorUID: getLabelmapActorUID(segmentationId),
+                    callback: ({ imageActor }) => {
+                        imageActor.getMapper().setInputData(imageData);
+                    },
+                },
+            ]);
+            triggerSegmentationRender(viewportId);
+            return;
+        }
+        else {
+            const segmentationImageData = segmentationActorInput.actor
+                .getMapper()
+                .getInputData();
+            if (segmentationImageData.setDerivedImage) {
+                segmentationImageData.setDerivedImage(derivedImage);
+            }
+            else {
+                utilities.updateVTKImageDataWithCornerstoneImage(segmentationImageData, derivedImage);
+            }
+        }
+        viewport.render();
+        if (evt.type === Enums.Events.IMAGE_RENDERED) {
+            viewport.element.removeEventListener(Enums.Events.IMAGE_RENDERED, _imageChangeEventListener);
+        }
+    });
+}
+export default {
+    enable,
+    disable,
+};

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

@@ -1,5 +1,4 @@
-import segmentationRepresentationModifiedEventListener from './segmentationRepresentationModifiedEventListener';
 import segmentationDataModifiedEventListener from './segmentationDataModifiedEventListener';
-import segmentationRepresentationRemovedEventListener from './segmentationRepresentationRemovedEventListener';
 import segmentationModifiedListener from './segmentationModifiedEventListener';
-export { segmentationRepresentationModifiedEventListener, segmentationDataModifiedEventListener, segmentationRepresentationRemovedEventListener, segmentationModifiedListener, };
+import imageChangeEventListener from './imageChangeEventListener';
+export { segmentationDataModifiedEventListener, segmentationModifiedListener, imageChangeEventListener, };

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

@@ -1,6 +1,4 @@
-import segmentationRepresentationModifiedEventListener from './segmentationRepresentationModifiedEventListener';
 import segmentationDataModifiedEventListener from './segmentationDataModifiedEventListener';
-import segmentationRepresentationRemovedEventListener from './segmentationRepresentationRemovedEventListener';
 import segmentationModifiedListener from './segmentationModifiedEventListener';
-export { segmentationRepresentationModifiedEventListener, segmentationDataModifiedEventListener, segmentationRepresentationRemovedEventListener, segmentationModifiedListener, };
-//# sourceMappingURL=index.js.map
+import imageChangeEventListener from './imageChangeEventListener';
+export { segmentationDataModifiedEventListener, segmentationModifiedListener, imageChangeEventListener, };

package/dist/esm/eventListeners/segmentation/labelmap/onLabelmapSegmentationDataModified.d.ts

@@ -0,0 +1,3 @@
+import type { SegmentationDataModifiedEventType } from '../../../types/EventTypes';
+declare const onLabelmapSegmentationDataModified: (evt: SegmentationDataModifiedEventType) => void;
+export default onLabelmapSegmentationDataModified;