@cornerstonejs/tools 3.0.2 → 3.0.3

package/dist/esm/tools/annotation/splines/index.d.ts

@@ -0,0 +1,9 @@
+import BSpline from './BSpline';
+import CardinalSpline from './CardinalSpline';
+import CatmullRomSpline from './CatmullRomSpline';
+import CubicSpline from './CubicSpline';
+import LinearSpline from './LinearSpline';
+import QuadraticBezier from './QuadraticBezier';
+import QuadraticSpline from './QuadraticSpline';
+import Spline from './Spline';
+export { BSpline, CardinalSpline, CatmullRomSpline, CubicSpline, LinearSpline, QuadraticBezier, QuadraticSpline, Spline, };

package/dist/esm/tools/annotation/splines/index.js

@@ -0,0 +1,9 @@
+import BSpline from './BSpline';
+import CardinalSpline from './CardinalSpline';
+import CatmullRomSpline from './CatmullRomSpline';
+import CubicSpline from './CubicSpline';
+import LinearSpline from './LinearSpline';
+import QuadraticBezier from './QuadraticBezier';
+import QuadraticSpline from './QuadraticSpline';
+import Spline from './Spline';
+export { BSpline, CardinalSpline, CatmullRomSpline, CubicSpline, LinearSpline, QuadraticBezier, QuadraticSpline, Spline, };

package/dist/esm/tools/base/AnnotationDisplayTool.d.ts

@@ -0,0 +1,14 @@
+import type { Types } from '@cornerstonejs/core';
+import BaseTool from './BaseTool';
+import type { Annotation, Annotations, EventTypes, SVGDrawingHelper } from '../../types';
+import type { StyleSpecifier } from '../../types/AnnotationStyle';
+declare abstract class AnnotationDisplayTool extends BaseTool {
+    static toolName: any;
+    abstract renderAnnotation(enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper): any;
+    filterInteractableAnnotationsForElement(element: HTMLDivElement, annotations: Annotations): Annotations;
+    onImageSpacingCalibrated: (evt: Types.EventTypes.ImageSpacingCalibratedEvent) => void;
+    protected createAnnotation(evt: EventTypes.InteractionEventType): Annotation;
+    protected getReferencedImageId(viewport: Types.IViewport, worldPos: Types.Point3, viewPlaneNormal: Types.Point3, viewUp?: Types.Point3): string;
+    getStyle(property: string, specifications: StyleSpecifier, annotation?: Annotation): unknown;
+}
+export default AnnotationDisplayTool;

package/dist/esm/tools/base/AnnotationDisplayTool.js

@@ -0,0 +1,98 @@
+import { utilities, getEnabledElement, cache, BaseVolumeViewport, } from '@cornerstonejs/core';
+import BaseTool from './BaseTool';
+import { getAnnotationManager } from '../../stateManagement/annotation/annotationState';
+import triggerAnnotationRender from '../../utilities/triggerAnnotationRender';
+import filterAnnotationsForDisplay from '../../utilities/planar/filterAnnotationsForDisplay';
+import { getStyleProperty } from '../../stateManagement/annotation/config/helpers';
+import { getState } from '../../stateManagement/annotation/config';
+class AnnotationDisplayTool extends BaseTool {
+    constructor() {
+        super(...arguments);
+        this.onImageSpacingCalibrated = (evt) => {
+            const { element, imageId } = evt.detail;
+            const imageURI = utilities.imageIdToURI(imageId);
+            const annotationManager = getAnnotationManager();
+            const framesOfReference = annotationManager.getFramesOfReference();
+            framesOfReference.forEach((frameOfReference) => {
+                const frameOfReferenceSpecificAnnotations = annotationManager.getAnnotations(frameOfReference);
+                const toolSpecificAnnotations = frameOfReferenceSpecificAnnotations[this.getToolName()];
+                if (!toolSpecificAnnotations || !toolSpecificAnnotations.length) {
+                    return;
+                }
+                toolSpecificAnnotations.forEach((annotation) => {
+                    if (!annotation.metadata?.referencedImageId) {
+                        return;
+                    }
+                    const referencedImageURI = utilities.imageIdToURI(annotation.metadata.referencedImageId);
+                    if (referencedImageURI === imageURI) {
+                        annotation.invalidated = true;
+                        annotation.data.cachedStats = {};
+                    }
+                });
+                triggerAnnotationRender(element);
+            });
+        };
+    }
+    filterInteractableAnnotationsForElement(element, annotations) {
+        if (!annotations?.length) {
+            return [];
+        }
+        const enabledElement = getEnabledElement(element);
+        const { viewport } = enabledElement;
+        return filterAnnotationsForDisplay(viewport, annotations);
+    }
+    createAnnotation(evt) {
+        const eventDetail = evt.detail;
+        const { currentPoints, element } = eventDetail;
+        const { world: worldPos } = currentPoints;
+        const enabledElement = getEnabledElement(element);
+        const { viewport } = enabledElement;
+        const camera = viewport.getCamera();
+        const { viewPlaneNormal, viewUp, position: cameraPosition } = camera;
+        const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
+        const viewReference = viewport.getViewReference({ points: [worldPos] });
+        return {
+            highlighted: true,
+            invalidated: true,
+            metadata: {
+                toolName: this.getToolName(),
+                ...viewReference,
+                referencedImageId,
+                viewUp,
+                cameraPosition,
+            },
+            data: {
+                cachedStats: {},
+                handles: {
+                    points: [],
+                    activeHandleIndex: null,
+                    textBox: {
+                        hasMoved: false,
+                        worldPosition: [0, 0, 0],
+                        worldBoundingBox: {
+                            topLeft: [0, 0, 0],
+                            topRight: [0, 0, 0],
+                            bottomLeft: [0, 0, 0],
+                            bottomRight: [0, 0, 0],
+                        },
+                    },
+                },
+            },
+        };
+    }
+    getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp) {
+        const targetId = this.getTargetId(viewport);
+        let referencedImageId = targetId.split(/^[a-zA-Z]+:/)[1];
+        if (viewport instanceof BaseVolumeViewport) {
+            const volumeId = utilities.getVolumeId(targetId);
+            const imageVolume = cache.getVolume(volumeId);
+            referencedImageId = utilities.getClosestImageId(imageVolume, worldPos, viewPlaneNormal);
+        }
+        return referencedImageId;
+    }
+    getStyle(property, specifications, annotation) {
+        return getStyleProperty(property, specifications, getState(annotation), this.mode);
+    }
+}
+AnnotationDisplayTool.toolName = 'AnnotationDisplayTool';
+export default AnnotationDisplayTool;

package/dist/esm/tools/base/AnnotationTool.d.ts

@@ -0,0 +1,71 @@
+import type { Types } from '@cornerstonejs/core';
+import AnnotationDisplayTool from './AnnotationDisplayTool';
+import type { Annotation, Annotations, EventTypes, ToolHandle, InteractionTypes, ToolProps, PublicToolProps } from '../../types';
+import type { AnnotationStyle, StyleSpecifier } from '../../types/AnnotationStyle';
+declare abstract class AnnotationTool extends AnnotationDisplayTool {
+    protected eventDispatchDetail: {
+        viewportId: string;
+        renderingEngineId: string;
+    };
+    isDrawing: boolean;
+    isHandleOutsideImage: boolean;
+    editData: {
+        annotation: Annotation;
+        viewportIdsToRender?: string[];
+        newAnnotation?: boolean;
+        handleIndex?: number;
+        movingTextBox?: boolean;
+        hasMoved?: boolean;
+    } | null;
+    static createAnnotation(...annotationBaseData: any[]): Annotation;
+    static createAnnotationForViewport<T extends Annotation>(viewport: any, ...annotationBaseData: any[]): T;
+    static createAndAddAnnotation(viewport: any, ...annotationBaseData: any[]): void;
+    static toolName: any;
+    constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps);
+    abstract addNewAnnotation(evt: EventTypes.InteractionEventType, interactionType: InteractionTypes): Annotation;
+    abstract cancel(element: HTMLDivElement): any;
+    abstract handleSelectedCallback(evt: EventTypes.InteractionEventType, annotation: Annotation, handle: ToolHandle, interactionType: InteractionTypes): void;
+    abstract toolSelectedCallback(evt: EventTypes.InteractionEventType, annotation: Annotation, interactionType: InteractionTypes, canvasCoords?: Types.Point2): void;
+    abstract isPointNearTool(element: HTMLDivElement, annotation: Annotation, canvasCoords: Types.Point2, proximity: number, interactionType: string): boolean;
+    mouseMoveCallback: (evt: EventTypes.MouseMoveEventType, filteredAnnotations?: Annotations) => boolean;
+    getHandleNearImagePoint(element: HTMLDivElement, annotation: Annotation, canvasCoords: Types.Point2, proximity: number): ToolHandle | undefined;
+    getLinkedTextBoxStyle(specifications: StyleSpecifier, annotation?: Annotation): Record<string, unknown>;
+    static isSuvScaled(viewport: Types.IStackViewport | Types.IVolumeViewport, targetId: string, imageId?: string): boolean;
+    isSuvScaled: typeof AnnotationTool.isSuvScaled;
+    protected getAnnotationStyle(context: {
+        annotation: Annotation;
+        styleSpecifier: StyleSpecifier;
+    }): AnnotationStyle;
+    private _imagePointNearToolOrHandle;
+    protected static createAnnotationState(annotation: Annotation, deleting?: boolean): {
+        annotationUID: string;
+        data: {
+            [key: string]: unknown;
+            handles?: {
+                points?: Types.Point3[];
+                activeHandleIndex?: number | null;
+                textBox?: {
+                    hasMoved?: boolean;
+                    worldPosition?: Types.Point3;
+                    worldBoundingBox?: {
+                        topLeft: Types.Point3;
+                        topRight: Types.Point3;
+                        bottomLeft: Types.Point3;
+                        bottomRight: Types.Point3;
+                    };
+                };
+                [key: string]: unknown;
+            };
+            cachedStats?: Record<string, unknown>;
+        };
+        deleting: boolean;
+    };
+    static createAnnotationMemo(element: any, annotation: Annotation, options?: {
+        newAnnotation?: boolean;
+        deleting?: boolean;
+    }): {
+        restoreMemo: () => void;
+    };
+    protected createMemo(element: any, annotation: any, options?: any): void;
+}
+export default AnnotationTool;

package/dist/esm/tools/base/AnnotationTool.js

@@ -0,0 +1,271 @@
+import { BaseVolumeViewport, cache, getEnabledElement, metaData, utilities as csUtils, } from '@cornerstonejs/core';
+import { vec2 } from 'gl-matrix';
+import AnnotationDisplayTool from './AnnotationDisplayTool';
+import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
+import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
+import { addAnnotation, removeAnnotation, getAnnotation, } from '../../stateManagement/annotation/annotationState';
+import { triggerAnnotationModified } from '../../stateManagement/annotation/helpers/state';
+import ChangeTypes from '../../enums/ChangeTypes';
+import { setAnnotationSelected } from '../../stateManagement/annotation/annotationSelection';
+import { addContourSegmentationAnnotation } from '../../utilities/contourSegmentation';
+const { DefaultHistoryMemo } = csUtils.HistoryMemo;
+const { PointsManager } = csUtils;
+class AnnotationTool extends AnnotationDisplayTool {
+    static createAnnotation(...annotationBaseData) {
+        let annotation = {
+            annotationUID: null,
+            highlighted: true,
+            invalidated: true,
+            metadata: {
+                toolName: this.toolName,
+            },
+            data: {
+                text: '',
+                handles: {
+                    points: new Array(),
+                    textBox: {
+                        hasMoved: false,
+                        worldPosition: [0, 0, 0],
+                        worldBoundingBox: {
+                            topLeft: [0, 0, 0],
+                            topRight: [0, 0, 0],
+                            bottomLeft: [0, 0, 0],
+                            bottomRight: [0, 0, 0],
+                        },
+                    },
+                },
+                label: '',
+            },
+        };
+        for (const baseData of annotationBaseData) {
+            annotation = csUtils.deepMerge(annotation, baseData);
+        }
+        return annotation;
+    }
+    static createAnnotationForViewport(viewport, ...annotationBaseData) {
+        return this.createAnnotation({ metadata: viewport.getViewReference() }, ...annotationBaseData);
+    }
+    static createAndAddAnnotation(viewport, ...annotationBaseData) {
+        const annotation = this.createAnnotationForViewport(viewport, ...annotationBaseData);
+        addAnnotation(annotation, viewport.element);
+        triggerAnnotationModified(annotation, viewport.element);
+    }
+    constructor(toolProps, defaultToolProps) {
+        super(toolProps, defaultToolProps);
+        this.mouseMoveCallback = (evt, filteredAnnotations) => {
+            if (!filteredAnnotations) {
+                return false;
+            }
+            const { element, currentPoints } = evt.detail;
+            const canvasCoords = currentPoints.canvas;
+            let annotationsNeedToBeRedrawn = false;
+            for (const annotation of filteredAnnotations) {
+                if (isAnnotationLocked(annotation.annotationUID) ||
+                    !isAnnotationVisible(annotation.annotationUID)) {
+                    continue;
+                }
+                const { data } = annotation;
+                const activateHandleIndex = data.handles
+                    ? data.handles.activeHandleIndex
+                    : undefined;
+                const near = this._imagePointNearToolOrHandle(element, annotation, canvasCoords, 6);
+                const nearToolAndNotMarkedActive = near && !annotation.highlighted;
+                const notNearToolAndMarkedActive = !near && annotation.highlighted;
+                if (nearToolAndNotMarkedActive || notNearToolAndMarkedActive) {
+                    annotation.highlighted = !annotation.highlighted;
+                    annotationsNeedToBeRedrawn = true;
+                }
+                else if (data.handles &&
+                    data.handles.activeHandleIndex !== activateHandleIndex) {
+                    annotationsNeedToBeRedrawn = true;
+                }
+            }
+            return annotationsNeedToBeRedrawn;
+        };
+        this.isSuvScaled = AnnotationTool.isSuvScaled;
+        if (toolProps.configuration?.getTextLines) {
+            this.configuration.getTextLines = toolProps.configuration.getTextLines;
+        }
+        if (toolProps.configuration?.statsCalculator) {
+            this.configuration.statsCalculator =
+                toolProps.configuration.statsCalculator;
+        }
+    }
+    getHandleNearImagePoint(element, annotation, canvasCoords, proximity) {
+        const enabledElement = getEnabledElement(element);
+        const { viewport } = enabledElement;
+        const { data } = annotation;
+        const { isCanvasAnnotation } = data;
+        const { points, textBox } = data.handles;
+        if (textBox) {
+            const { worldBoundingBox } = textBox;
+            if (worldBoundingBox) {
+                const canvasBoundingBox = {
+                    topLeft: viewport.worldToCanvas(worldBoundingBox.topLeft),
+                    topRight: viewport.worldToCanvas(worldBoundingBox.topRight),
+                    bottomLeft: viewport.worldToCanvas(worldBoundingBox.bottomLeft),
+                    bottomRight: viewport.worldToCanvas(worldBoundingBox.bottomRight),
+                };
+                if (canvasCoords[0] >= canvasBoundingBox.topLeft[0] &&
+                    canvasCoords[0] <= canvasBoundingBox.bottomRight[0] &&
+                    canvasCoords[1] >= canvasBoundingBox.topLeft[1] &&
+                    canvasCoords[1] <= canvasBoundingBox.bottomRight[1]) {
+                    data.handles.activeHandleIndex = null;
+                    return textBox;
+                }
+            }
+        }
+        for (let i = 0; i < points?.length; i++) {
+            const point = points[i];
+            const annotationCanvasCoordinate = isCanvasAnnotation
+                ? point.slice(0, 2)
+                : viewport.worldToCanvas(point);
+            const near = vec2.distance(canvasCoords, annotationCanvasCoordinate) < proximity;
+            if (near === true) {
+                data.handles.activeHandleIndex = i;
+                return point;
+            }
+        }
+        data.handles.activeHandleIndex = null;
+    }
+    getLinkedTextBoxStyle(specifications, annotation) {
+        return {
+            visibility: this.getStyle('textBoxVisibility', specifications, annotation),
+            fontFamily: this.getStyle('textBoxFontFamily', specifications, annotation),
+            fontSize: this.getStyle('textBoxFontSize', specifications, annotation),
+            color: this.getStyle('textBoxColor', specifications, annotation),
+            shadow: this.getStyle('textBoxShadow', specifications, annotation),
+            background: this.getStyle('textBoxBackground', specifications, annotation),
+            lineWidth: this.getStyle('textBoxLinkLineWidth', specifications, annotation),
+            lineDash: this.getStyle('textBoxLinkLineDash', specifications, annotation),
+        };
+    }
+    static isSuvScaled(viewport, targetId, imageId) {
+        if (viewport instanceof BaseVolumeViewport) {
+            const volumeId = csUtils.getVolumeId(targetId);
+            const volume = cache.getVolume(volumeId);
+            return volume?.scaling?.PT !== undefined;
+        }
+        const scalingModule = imageId && metaData.get('scalingModule', imageId);
+        return typeof scalingModule?.suvbw === 'number';
+    }
+    getAnnotationStyle(context) {
+        const { annotation, styleSpecifier } = context;
+        const getStyle = (property) => this.getStyle(property, styleSpecifier, annotation);
+        const { annotationUID } = annotation;
+        const visibility = isAnnotationVisible(annotationUID);
+        const locked = isAnnotationLocked(annotationUID);
+        const lineWidth = getStyle('lineWidth');
+        const lineDash = getStyle('lineDash');
+        const color = getStyle('color');
+        const markerSize = getStyle('markerSize');
+        const shadow = getStyle('shadow');
+        const textboxStyle = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+        return {
+            visibility,
+            locked,
+            color,
+            lineWidth,
+            lineDash,
+            lineOpacity: 1,
+            fillColor: color,
+            fillOpacity: 0,
+            shadow,
+            textbox: textboxStyle,
+            markerSize,
+        };
+    }
+    _imagePointNearToolOrHandle(element, annotation, canvasCoords, proximity) {
+        const handleNearImagePoint = this.getHandleNearImagePoint(element, annotation, canvasCoords, proximity);
+        if (handleNearImagePoint) {
+            return true;
+        }
+        const toolNewImagePoint = this.isPointNearTool(element, annotation, canvasCoords, proximity, 'mouse');
+        if (toolNewImagePoint) {
+            return true;
+        }
+    }
+    static createAnnotationState(annotation, deleting) {
+        const { data, annotationUID } = annotation;
+        const cloneData = {
+            ...data,
+            cachedStats: {},
+        };
+        delete cloneData.contour;
+        delete cloneData.spline;
+        const state = {
+            annotationUID,
+            data: structuredClone(cloneData),
+            deleting,
+        };
+        const contour = data.contour;
+        if (contour) {
+            state.data.contour = {
+                ...contour,
+                polyline: null,
+                pointsManager: PointsManager.create3(contour.polyline.length, contour.polyline),
+            };
+        }
+        return state;
+    }
+    static createAnnotationMemo(element, annotation, options) {
+        if (!annotation) {
+            return;
+        }
+        const { newAnnotation, deleting = newAnnotation ? false : undefined } = options || {};
+        const { annotationUID } = annotation;
+        const state = AnnotationTool.createAnnotationState(annotation, deleting);
+        const annotationMemo = {
+            restoreMemo: () => {
+                const newState = AnnotationTool.createAnnotationState(annotation, deleting);
+                const { viewport } = getEnabledElement(element) || {};
+                viewport?.setViewReference(annotation.metadata);
+                if (state.deleting === true) {
+                    state.deleting = false;
+                    Object.assign(annotation.data, state.data);
+                    if (annotation.data.contour) {
+                        const annotationData = annotation.data;
+                        annotationData.contour.polyline = state.data.contour.pointsManager.points;
+                        delete state.data.contour.pointsManager;
+                        if (annotationData.segmentation) {
+                            addContourSegmentationAnnotation(annotation);
+                        }
+                    }
+                    state.data = newState.data;
+                    addAnnotation(annotation, element);
+                    setAnnotationSelected(annotation.annotationUID, true);
+                    viewport?.render();
+                    return;
+                }
+                if (state.deleting === false) {
+                    state.deleting = true;
+                    state.data = newState.data;
+                    setAnnotationSelected(annotation.annotationUID);
+                    removeAnnotation(annotation.annotationUID);
+                    viewport?.render();
+                    return;
+                }
+                const currentAnnotation = getAnnotation(annotationUID);
+                if (!currentAnnotation) {
+                    console.warn('No current annotation');
+                    return;
+                }
+                Object.assign(currentAnnotation.data, state.data);
+                if (currentAnnotation.data.contour) {
+                    currentAnnotation.data
+                        .contour.polyline = state.data.contour.pointsManager.points;
+                }
+                state.data = newState.data;
+                currentAnnotation.invalidated = true;
+                triggerAnnotationModified(currentAnnotation, element, ChangeTypes.History);
+            },
+        };
+        DefaultHistoryMemo.push(annotationMemo);
+        return annotationMemo;
+    }
+    createMemo(element, annotation, options) {
+        this.memo ||= AnnotationTool.createAnnotationMemo(element, annotation, options);
+    }
+}
+AnnotationTool.toolName = 'AnnotationTool';
+export default AnnotationTool;

package/dist/esm/tools/base/BaseTool.d.ts

@@ -0,0 +1,38 @@
+import { utilities } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+import ToolModes from '../../enums/ToolModes';
+import type StrategyCallbacks from '../../enums/StrategyCallbacks';
+import type { InteractionTypes, ToolProps, PublicToolProps } from '../../types';
+declare abstract class BaseTool {
+    static toolName: any;
+    supportedInteractionTypes: InteractionTypes[];
+    configuration: Record<string, any>;
+    toolGroupId: string;
+    mode: ToolModes;
+    protected memo: utilities.HistoryMemo.Memo;
+    static defaults: {
+        configuration: {
+            strategies: {};
+            defaultStrategy: any;
+            activeStrategy: any;
+            strategyOptions: {};
+        };
+    };
+    constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps);
+    static mergeDefaultProps(defaultProps?: {}, additionalProps?: any): any;
+    get toolName(): string;
+    getToolName(): string;
+    applyActiveStrategy(enabledElement: Types.IEnabledElement, operationData: unknown): any;
+    applyActiveStrategyCallback(enabledElement: Types.IEnabledElement, operationData: unknown, callbackType: StrategyCallbacks | string, ...extraArgs: any[]): any;
+    setConfiguration(newConfiguration: Record<string, any>): void;
+    setActiveStrategy(strategyName: string): void;
+    protected getTargetImageData(targetId: string): Types.IImageData | Types.CPUIImageData;
+    protected getTargetId(viewport: Types.IViewport): string | undefined;
+    undo(): void;
+    redo(): void;
+    static createZoomPanMemo(viewport: any): {
+        restoreMemo: () => void;
+    };
+    doneEditMemo(): void;
+}
+export default BaseTool;

package/dist/esm/tools/base/BaseTool.js

@@ -0,0 +1,128 @@
+import { utilities } from '@cornerstonejs/core';
+import ToolModes from '../../enums/ToolModes';
+const { DefaultHistoryMemo } = utilities.HistoryMemo;
+class BaseTool {
+    static { this.defaults = {
+        configuration: {
+            strategies: {},
+            defaultStrategy: undefined,
+            activeStrategy: undefined,
+            strategyOptions: {},
+        },
+    }; }
+    constructor(toolProps, defaultToolProps) {
+        const mergedDefaults = BaseTool.mergeDefaultProps(BaseTool.defaults, defaultToolProps);
+        const initialProps = utilities.deepMerge(mergedDefaults, toolProps);
+        const { configuration = {}, supportedInteractionTypes, toolGroupId, } = initialProps;
+        this.toolGroupId = toolGroupId;
+        this.supportedInteractionTypes = supportedInteractionTypes || [];
+        this.configuration = Object.assign({}, configuration);
+        this.mode = ToolModes.Disabled;
+    }
+    static mergeDefaultProps(defaultProps = {}, additionalProps) {
+        if (!additionalProps) {
+            return defaultProps;
+        }
+        return utilities.deepMerge(defaultProps, additionalProps);
+    }
+    get toolName() {
+        return this.getToolName();
+    }
+    getToolName() {
+        return this.constructor.toolName;
+    }
+    applyActiveStrategy(enabledElement, operationData) {
+        const { strategies, activeStrategy } = this.configuration;
+        return strategies[activeStrategy]?.call(this, enabledElement, operationData);
+    }
+    applyActiveStrategyCallback(enabledElement, operationData, callbackType, ...extraArgs) {
+        const { strategies, activeStrategy } = this.configuration;
+        if (!strategies[activeStrategy]) {
+            throw new Error(`applyActiveStrategyCallback: active strategy ${activeStrategy} not found, check tool configuration or spellings`);
+        }
+        return strategies[activeStrategy][callbackType]?.call(this, enabledElement, operationData, ...extraArgs);
+    }
+    setConfiguration(newConfiguration) {
+        this.configuration = utilities.deepMerge(this.configuration, newConfiguration);
+    }
+    setActiveStrategy(strategyName) {
+        this.setConfiguration({ activeStrategy: strategyName });
+    }
+    getTargetImageData(targetId) {
+        if (targetId.startsWith('imageId:')) {
+            const imageId = targetId.split('imageId:')[1];
+            const imageURI = utilities.imageIdToURI(imageId);
+            let viewports = utilities.getViewportsWithImageURI(imageURI);
+            if (!viewports || !viewports.length) {
+                return;
+            }
+            viewports = viewports.filter((viewport) => {
+                return viewport.getCurrentImageId() === imageId;
+            });
+            if (!viewports || !viewports.length) {
+                return;
+            }
+            return viewports[0].getImageData();
+        }
+        else if (targetId.startsWith('volumeId:')) {
+            const volumeId = utilities.getVolumeId(targetId);
+            const viewports = utilities.getViewportsWithVolumeId(volumeId);
+            if (!viewports || !viewports.length) {
+                return;
+            }
+            return viewports[0].getImageData();
+        }
+        else if (targetId.startsWith('videoId:')) {
+            const imageURI = utilities.imageIdToURI(targetId);
+            const viewports = utilities.getViewportsWithImageURI(imageURI);
+            if (!viewports || !viewports.length) {
+                return;
+            }
+            return viewports[0].getImageData();
+        }
+        else {
+            throw new Error('getTargetIdImage: targetId must start with "imageId:" or "volumeId:"');
+        }
+    }
+    getTargetId(viewport) {
+        const targetId = viewport.getViewReferenceId?.();
+        if (targetId) {
+            return targetId;
+        }
+        throw new Error('getTargetId: viewport must have a getViewReferenceId method');
+    }
+    undo() {
+        this.doneEditMemo();
+        DefaultHistoryMemo.undo();
+    }
+    redo() {
+        DefaultHistoryMemo.redo();
+    }
+    static createZoomPanMemo(viewport) {
+        const state = {
+            pan: viewport.getPan(),
+            zoom: viewport.getZoom(),
+        };
+        const zoomPanMemo = {
+            restoreMemo: () => {
+                const currentPan = viewport.getPan();
+                const currentZoom = viewport.getZoom();
+                viewport.setZoom(state.zoom);
+                viewport.setPan(state.pan);
+                viewport.render();
+                state.pan = currentPan;
+                state.zoom = currentZoom;
+            },
+        };
+        DefaultHistoryMemo.push(zoomPanMemo);
+        return zoomPanMemo;
+    }
+    doneEditMemo() {
+        if (this.memo?.commitMemo?.()) {
+            DefaultHistoryMemo.push(this.memo);
+        }
+        this.memo = null;
+    }
+}
+BaseTool.toolName = 'BaseTool';
+export default BaseTool;

package/dist/esm/tools/base/ContourBaseTool.d.ts

@@ -0,0 +1,25 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Annotation, ContourAnnotation, EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper, AnnotationRenderContext } from '../../types';
+import AnnotationTool from './AnnotationTool';
+import type { ContourWindingDirection } from '../../types/ContourAnnotation';
+declare abstract class ContourBaseTool extends AnnotationTool {
+    constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps);
+    renderAnnotation(enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper): boolean;
+    protected createAnnotation(evt: EventTypes.InteractionEventType): ContourAnnotation;
+    protected addAnnotation(annotation: Annotation, element: HTMLDivElement): string;
+    protected cancelAnnotation(annotation: Annotation): void;
+    protected moveAnnotation(annotation: Annotation, worldPosDelta: Types.Point3): void;
+    protected updateContourPolyline(annotation: ContourAnnotation, polylineData: {
+        points: Types.Point2[];
+        closed?: boolean;
+        targetWindingDirection?: ContourWindingDirection;
+    }, transforms: {
+        canvasToWorld: (point: Types.Point2) => Types.Point3;
+        worldToCanvas: (point: Types.Point3) => Types.Point2;
+    }, options?: {
+        updateWindingDirection?: boolean;
+    }): void;
+    protected getPolylinePoints(annotation: ContourAnnotation): Types.Point3[];
+    protected renderAnnotationInstance(renderContext: AnnotationRenderContext): boolean;
+}
+export { ContourBaseTool as default, ContourBaseTool };