@cornerstonejs/tools 3.0.2 → 3.0.4

package/dist/esm/tools/annotation/RegionSegmentTool.js

@@ -0,0 +1,102 @@
+import { vec2, vec3 } from 'gl-matrix';
+import { getEnabledElement, utilities as csUtils, getRenderingEngine, } from '@cornerstonejs/core';
+import { drawCircle as drawCircleSvg } from '../../drawingSvg';
+import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
+import { Events } from '../../enums';
+import triggerAnnotationRenderForViewportUIDs from '../../utilities/triggerAnnotationRenderForViewportIds';
+import { growCut } from '../../utilities/segmentation';
+import GrowCutBaseTool from '../base/GrowCutBaseTool';
+class RegionSegmentTool extends GrowCutBaseTool {
+    static { this.toolName = 'RegionSegment'; }
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            positiveSeedVariance: 0.5,
+            negativeSeedVariance: 0.9,
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this._dragCallback = (evt) => {
+            const eventData = evt.detail;
+            const { element, currentPoints } = eventData;
+            const { world: currentWorldPoint } = currentPoints;
+            const enabledElement = getEnabledElement(element);
+            const { viewport } = enabledElement;
+            this.growCutData.circleBorderPoint = currentWorldPoint;
+            triggerAnnotationRenderForViewportUIDs([viewport.id]);
+        };
+        this._endCallback = async (evt) => {
+            const eventData = evt.detail;
+            const { element } = eventData;
+            const enabledElement = getEnabledElement(element);
+            const { viewport } = enabledElement;
+            this.runGrowCut();
+            this._deactivateDraw(element);
+            this.growCutData = null;
+            resetElementCursor(element);
+            triggerAnnotationRenderForViewportUIDs([viewport.id]);
+        };
+        this._deactivateDraw = (element) => {
+            element.removeEventListener(Events.MOUSE_UP, this._endCallback);
+            element.removeEventListener(Events.MOUSE_DRAG, this._dragCallback);
+            element.removeEventListener(Events.MOUSE_CLICK, this._endCallback);
+        };
+    }
+    async preMouseDownCallback(evt) {
+        const eventData = evt.detail;
+        const { element, currentPoints } = eventData;
+        const { world: worldPoint } = currentPoints;
+        const enabledElement = getEnabledElement(element);
+        const { viewport, renderingEngine } = enabledElement;
+        await super.preMouseDownCallback(evt);
+        Object.assign(this.growCutData, {
+            circleCenterPoint: worldPoint,
+            circleBorderPoint: worldPoint,
+        });
+        this._activateDraw(element);
+        hideElementCursor(element);
+        triggerAnnotationRenderForViewportUIDs([viewport.id]);
+        return true;
+    }
+    async getGrowCutLabelmap(growCutData) {
+        const { segmentation: { referencedVolumeId }, renderingEngineId, viewportId, circleCenterPoint, circleBorderPoint, options, } = growCutData;
+        const renderingEngine = getRenderingEngine(renderingEngineId);
+        const viewport = renderingEngine.getViewport(viewportId);
+        const worldCircleRadius = vec3.len(vec3.sub(vec3.create(), circleCenterPoint, circleBorderPoint));
+        const sphereInfo = {
+            center: circleCenterPoint,
+            radius: worldCircleRadius,
+        };
+        return growCut.runGrowCutForSphere(referencedVolumeId, sphereInfo, viewport, options);
+    }
+    _activateDraw(element) {
+        element.addEventListener(Events.MOUSE_UP, this._endCallback);
+        element.addEventListener(Events.MOUSE_DRAG, this._dragCallback);
+        element.addEventListener(Events.MOUSE_CLICK, this._endCallback);
+    }
+    renderAnnotation(enabledElement, svgDrawingHelper) {
+        if (!this.growCutData) {
+            return;
+        }
+        const { viewport } = enabledElement;
+        const { segmentation: segmentationData, circleCenterPoint, circleBorderPoint, } = this.growCutData;
+        const canvasCenterPoint = viewport.worldToCanvas(circleCenterPoint);
+        const canvasBorderPoint = viewport.worldToCanvas(circleBorderPoint);
+        const vecCenterToBorder = vec2.sub(vec2.create(), canvasBorderPoint, canvasCenterPoint);
+        const circleRadius = vec2.len(vecCenterToBorder);
+        if (csUtils.isEqual(circleRadius, 0)) {
+            return;
+        }
+        const annotationUID = 'growcut';
+        const circleUID = '0';
+        const { color } = this.getSegmentStyle({
+            segmentationId: segmentationData.segmentationId,
+            segmentIndex: segmentationData.segmentIndex,
+            viewportId: viewport.id,
+        });
+        drawCircleSvg(svgDrawingHelper, annotationUID, circleUID, canvasCenterPoint, circleRadius, {
+            color,
+        });
+    }
+}
+export default RegionSegmentTool;

package/dist/esm/tools/annotation/SplineContourSegmentationTool.d.ts

@@ -0,0 +1,8 @@
+import type { PublicToolProps } from '../../types';
+import SplineROITool from './SplineROITool';
+declare class SplineContourSegmentationTool extends SplineROITool {
+    static toolName: string;
+    constructor(toolProps: PublicToolProps);
+    protected isContourSegmentationTool(): boolean;
+}
+export default SplineContourSegmentationTool;

package/dist/esm/tools/annotation/SplineContourSegmentationTool.js

@@ -0,0 +1,17 @@
+import { utilities } from '@cornerstonejs/core';
+import SplineROITool from './SplineROITool';
+class SplineContourSegmentationTool extends SplineROITool {
+    static { this.toolName = 'SplineContourSegmentationTool'; }
+    constructor(toolProps) {
+        const initialProps = utilities.deepMerge({
+            configuration: {
+                calculateStats: false,
+            },
+        }, toolProps);
+        super(initialProps);
+    }
+    isContourSegmentationTool() {
+        return true;
+    }
+}
+export default SplineContourSegmentationTool;

package/dist/esm/tools/annotation/SplineROITool.d.ts

@@ -0,0 +1,73 @@
+import type { Types } from '@cornerstonejs/core';
+import { ChangeTypes } from '../../enums';
+import type { Annotation, EventTypes, ToolHandle, PublicToolProps, ToolProps, AnnotationRenderContext } from '../../types';
+import type { ContourAnnotation, SplineROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import ContourSegmentationBaseTool from '../base/ContourSegmentationBaseTool';
+declare enum SplineTypesEnum {
+    Cardinal = "CARDINAL",
+    Linear = "LINEAR",
+    CatmullRom = "CATMULLROM",
+    BSpline = "BSPLINE"
+}
+declare enum SplineToolActions {
+    AddControlPoint = "addControlPoint",
+    DeleteControlPoint = "deleteControlPoint"
+}
+declare class SplineROITool extends ContourSegmentationBaseTool {
+    static toolName: string;
+    static SplineTypes: typeof SplineTypesEnum;
+    static Actions: typeof SplineToolActions;
+    _throttledCalculateCachedStats: Function;
+    editData: {
+        annotation: SplineROIAnnotation;
+        viewportIdsToRender: Array<string>;
+        handleIndex?: number;
+        movingTextBox?: boolean;
+        newAnnotation?: boolean;
+        hasMoved?: boolean;
+        lastCanvasPoint?: Types.Point2;
+        contourHoleProcessingEnabled?: boolean;
+    } | null;
+    isDrawing: boolean;
+    isHandleOutsideImage: boolean;
+    fireChangeOnUpdate: {
+        annotationUID: string;
+        changeType: ChangeTypes;
+        contourHoleProcessingEnabled: boolean;
+    };
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    addNewAnnotation(evt: EventTypes.InteractionEventType): SplineROIAnnotation;
+    isPointNearTool: (element: HTMLDivElement, annotation: SplineROIAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;
+    toolSelectedCallback: (evt: EventTypes.InteractionEventType, annotation: SplineROIAnnotation) => void;
+    handleSelectedCallback: (evt: EventTypes.InteractionEventType, annotation: SplineROIAnnotation, handle: ToolHandle) => void;
+    _endCallback: (evt: EventTypes.InteractionEventType) => void;
+    private _keyDownCallback;
+    private _mouseMoveCallback;
+    private _mouseDownCallback;
+    private _dragCallback;
+    cancel(element: HTMLDivElement): string;
+    triggerAnnotationCompleted: (annotation: SplineROIAnnotation, contourHoleProcessingEnabled: boolean) => void;
+    triggerAnnotationModified: (annotation: SplineROIAnnotation, enabledElement: Types.IEnabledElement, changeType?: ChangeTypes) => void;
+    triggerChangeEvent: (annotation: SplineROIAnnotation, enabledElement: Types.IEnabledElement, changeType: ChangeTypes, contourHoleProcessingEnabled: any) => void;
+    private _activateModify;
+    private _deactivateModify;
+    private _activateDraw;
+    private _deactivateDraw;
+    protected isContourSegmentationTool(): boolean;
+    protected renderAnnotationInstance(renderContext: AnnotationRenderContext): boolean;
+    protected createInterpolatedSplineControl(annotation: any): void;
+    protected createAnnotation(evt: EventTypes.InteractionEventType): ContourAnnotation;
+    private _renderStats;
+    addControlPointCallback: (evt: EventTypes.InteractionEventType, annotation: SplineROIAnnotation) => void;
+    private _deleteControlPointByIndex;
+    deleteControlPointCallback: (evt: EventTypes.InteractionEventType, annotation: SplineROIAnnotation) => void;
+    _isSplineROIAnnotation(annotation: Annotation): annotation is SplineROIAnnotation;
+    private _getSplineConfig;
+    private _updateSplineInstance;
+    private _calculateCachedStats;
+    static hydrate: (viewportId: string, points: Types.Point3[], options?: {
+        annotationUID?: string;
+        splineType?: SplineTypesEnum;
+    }) => SplineROIAnnotation;
+}
+export default SplineROITool;