@cornerstonejs/tools 3.0.2 → 3.0.4

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

@@ -0,0 +1,10 @@
+import { BaseTool } from './base';
+import type { EventTypes, PublicToolProps, ToolProps } from '../types';
+declare class AnnotationEraserTool extends BaseTool {
+    static toolName: any;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    preMouseDownCallback: (evt: EventTypes.InteractionEventType) => boolean;
+    preTouchStartCallback: (evt: EventTypes.InteractionEventType) => boolean;
+    _deleteNearbyAnnotations(evt: EventTypes.InteractionEventType, interactionType: string): boolean;
+}
+export default AnnotationEraserTool;

package/dist/esm/tools/AnnotationEraserTool.js

@@ -0,0 +1,56 @@
+import { BaseTool, AnnotationTool } from './base';
+import { getAnnotations, getAnnotation, removeAnnotation, } from '../stateManagement/annotation/annotationState';
+import { setAnnotationSelected } from '../stateManagement/annotation/annotationSelection';
+import { getToolGroupForViewport } from '../store/ToolGroupManager';
+class AnnotationEraserTool extends BaseTool {
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+    }) {
+        super(toolProps, defaultToolProps);
+        this.preMouseDownCallback = (evt) => {
+            return this._deleteNearbyAnnotations(evt, 'mouse');
+        };
+        this.preTouchStartCallback = (evt) => {
+            return this._deleteNearbyAnnotations(evt, 'touch');
+        };
+    }
+    _deleteNearbyAnnotations(evt, interactionType) {
+        const { renderingEngineId, viewportId, element, currentPoints } = evt.detail;
+        const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
+        if (!toolGroup) {
+            return false;
+        }
+        const tools = toolGroup._toolInstances;
+        const annotationsToRemove = [];
+        for (const toolName in tools) {
+            const toolInstance = tools[toolName];
+            if (typeof toolInstance.isPointNearTool !== 'function' ||
+                typeof toolInstance.filterInteractableAnnotationsForElement !==
+                    'function') {
+                continue;
+            }
+            const annotations = getAnnotations(toolName, element);
+            const interactableAnnotations = toolInstance.filterInteractableAnnotationsForElement(element, annotations);
+            if (!interactableAnnotations) {
+                continue;
+            }
+            for (const annotation of interactableAnnotations) {
+                if (toolInstance.isPointNearTool(element, annotation, currentPoints.canvas, 10, interactionType)) {
+                    annotationsToRemove.push(annotation.annotationUID);
+                }
+            }
+        }
+        for (const annotationUID of annotationsToRemove) {
+            setAnnotationSelected(annotationUID);
+            const annotation = getAnnotation(annotationUID);
+            AnnotationTool.createAnnotationMemo(element, annotation, {
+                deleting: true,
+            });
+            removeAnnotation(annotationUID);
+        }
+        evt.preventDefault();
+        return true;
+    }
+}
+AnnotationEraserTool.toolName = 'Eraser';
+export default AnnotationEraserTool;

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

@@ -0,0 +1,71 @@
+import { AnnotationTool } from './base';
+import type { Types } from '@cornerstonejs/core';
+import type { Annotation, Annotations, EventTypes, ToolHandle, PublicToolProps, ToolProps, InteractionTypes, SVGDrawingHelper } from '../types';
+interface CrosshairsAnnotation extends Annotation {
+    data: {
+        handles: {
+            rotationPoints: Types.Point3[];
+            slabThicknessPoints: Types.Point3[];
+            activeOperation: number | null;
+            toolCenter: Types.Point3;
+        };
+        activeViewportIds: string[];
+        viewportId: string;
+    };
+}
+declare class CrosshairsTool extends AnnotationTool {
+    static toolName: any;
+    toolCenter: Types.Point3;
+    _getReferenceLineColor?: (viewportId: string) => string;
+    _getReferenceLineControllable?: (viewportId: string) => boolean;
+    _getReferenceLineDraggableRotatable?: (viewportId: string) => boolean;
+    _getReferenceLineSlabThicknessControlsOn?: (viewportId: string) => boolean;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    initializeViewport: ({ renderingEngineId, viewportId, }: Types.IViewportId) => {
+        normal: Types.Point3;
+        point: Types.Point3;
+    };
+    _getViewportsInfo: () => any[];
+    onSetToolActive(): void;
+    onSetToolPassive(): void;
+    onSetToolEnabled(): void;
+    onSetToolDisabled(): void;
+    resetCrosshairs: () => void;
+    computeToolCenter: () => void;
+    _computeToolCenter: (viewportsInfo: any) => void;
+    addNewAnnotation: (evt: EventTypes.InteractionEventType) => CrosshairsAnnotation;
+    cancel: () => void;
+    getHandleNearImagePoint(element: HTMLDivElement, annotation: Annotation, canvasCoords: Types.Point2, proximity: number): ToolHandle | undefined;
+    handleSelectedCallback: (evt: EventTypes.InteractionEventType, annotation: Annotation) => void;
+    isPointNearTool: (element: HTMLDivElement, annotation: CrosshairsAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;
+    toolSelectedCallback: (evt: EventTypes.InteractionEventType, annotation: Annotation, interactionType: InteractionTypes) => void;
+    onCameraModified: (evt: any) => void;
+    onResetCamera: (evt: any) => void;
+    mouseMoveCallback: (evt: EventTypes.MouseMoveEventType, filteredToolAnnotations: Annotations) => boolean;
+    filterInteractableAnnotationsForElement: (element: any, annotations: any) => any;
+    renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
+    _getAnnotations: (enabledElement: Types.IEnabledElement) => Annotation[];
+    _onNewVolume: () => void;
+    _unsubscribeToViewportNewVolumeSet(viewportsInfo: any): void;
+    _subscribeToViewportNewVolumeSet(viewports: any): void;
+    _autoPanViewportIfNecessary(viewportId: string, renderingEngine: Types.IRenderingEngine): void;
+    _areViewportIdArraysEqual: (viewportIdArrayOne: any, viewportIdArrayTwo: any) => boolean;
+    _getAnnotationsForViewportsWithDifferentCameras: (enabledElement: any, annotations: any) => any;
+    _filterViewportWithSameOrientation: (enabledElement: any, referenceAnnotation: any, annotations: any) => any;
+    _filterAnnotationsByUniqueViewportOrientations: (enabledElement: any, annotations: any) => any[];
+    _checkIfViewportsRenderingSameScene: (viewport: any, otherViewport: any) => any;
+    _jump: (enabledElement: any, jumpWorld: any) => boolean;
+    _activateModify: (element: any) => void;
+    _deactivateModify: (element: any) => void;
+    _endCallback: (evt: EventTypes.InteractionEventType) => void;
+    _dragCallback: (evt: EventTypes.InteractionEventType) => void;
+    setSlabThickness(viewport: any, slabThickness: any): void;
+    _isClockWise(a: any, b: any, c: any): boolean;
+    _applyDeltaShiftToSelectedViewportCameras(renderingEngine: any, viewportsAnnotationsToUpdate: any, delta: any): void;
+    _applyDeltaShiftToViewportCamera(renderingEngine: Types.IRenderingEngine, annotation: any, delta: any): void;
+    _pointNearReferenceLine: (annotation: any, canvasCoords: any, proximity: any, lineViewport: any) => boolean;
+    _getRotationHandleNearImagePoint(viewport: any, annotation: any, canvasCoords: any, proximity: any): any;
+    _getSlabThicknessHandleNearImagePoint(viewport: any, annotation: any, canvasCoords: any, proximity: any): any;
+    _pointNearTool(element: any, annotation: any, canvasCoords: any, proximity: any): boolean;
+}
+export default CrosshairsTool;