larvitar 3.6.2 → 3.6.3

package/dist/imaging/tools/custom/contourTool.d.ts

@@ -1,3 +1,11 @@
+/** @module imaging/tools/custom/contourTool
+ *  @desc  This file provides functionalities for
+ *         rendering segmentation contours with a
+ *         custom cornestone tool
+ */
+import { Image } from "cornerstone-core";
+import { ContourData, Coords, EventData, HandlePosition, HandleTextBox, MeasurementData, MeasurementMouseEvent } from "../types";
+declare const BaseAnnotationTool: any;
 /**
  * @public
  * @class ContoursTool
@@ -5,20 +13,62 @@
  * @classdesc Tool for drawing a set of contours
  * @extends Tools.Base.BaseAnnotationTool
  */
-export class ContoursTool {
-    constructor(props?: {});
-    isMultiPartTool: boolean;
-    _drawing: boolean;
-    _dragging: boolean;
-    _modifying: boolean;
+export declare class ContoursTool extends BaseAnnotationTool {
+    static [x: string]: any;
+    constructor(props?: {
+        contoursParsedData?: ContourData;
+        segmentationName?: string;
+    });
+    initializeContours(contourData: ContourData, segmentationName: string): void;
+    createNewMeasurement(eventData: EventData): MeasurementData | undefined;
     /**
-     * Event handler for MOUSE_DOWN during drawing event loop.
      *
-     * @event
-     * @param {Object} evt - The event.
+     *
+     * @param {*} element element
+     * @param {*} data data
+     * @param {*} coords coords
+     * @returns {Boolean}
+     */
+    pointNearTool(element: HTMLElement, data: MeasurementData, coords: Coords): boolean;
+    /**
+     * @param {*} element
+     * @param {*} data
+     * @param {*} coords
+     * @returns {number} the distance in px from the provided coordinates to the
+     * closest rendered portion of the annotation. -1 if the distance cannot be
+     * calculated.
+     */
+    distanceFromPoint(element: HTMLElement, data: MeasurementData, coords: Coords): number;
+    /**
+     * @param {*} element
+     * @param {*} data
+     * @param {*} coords
+     * @returns {number} the distance in canvas units from the provided coordinates to the
+     * closest rendered portion of the annotation. -1 if the distance cannot be
+     * calculated.
+     */
+    distanceFromPointCanvas(element: HTMLElement, data: MeasurementData, coords: Coords): number;
+    /**
+     *
+     *
+     *
+     * @param {Object} image image
+     * @param {Object} element element
+     * @param {Object} data data
+     *
+     * @returns {void}  void
+     */
+    updateCachedStats(image: Image, element: HTMLElement, data: MeasurementData): void;
+    /**
+     *
+     *
+     * @param {*} evt
      * @returns {undefined}
      */
-    _drawingMouseDownCallback(evt: Object): undefined;
+    renderToolData(evt: MeasurementMouseEvent): void;
+    addNewMeasurement(evt: MeasurementMouseEvent): void;
+    preMouseDownCallback(evt: MeasurementMouseEvent): boolean;
+    handleSelectedCallback(evt: MeasurementMouseEvent, toolData: any, handle: HandlePosition, interactionType?: string): void;
     /**
      * Event handler for MOUSE_MOVE during drawing event loop.
      *
@@ -26,7 +76,7 @@ export class ContoursTool {
      * @param {Object} evt - The event.
      * @returns {undefined}
      */
-    _drawingMouseMoveCallback(evt: Object): undefined;
+    _drawingMouseMoveCallback(evt: MeasurementMouseEvent): void;
     /**
      * Event handler for MOUSE_DRAG during drawing event loop.
      *
@@ -34,63 +84,71 @@ export class ContoursTool {
      * @param {Object} evt - The event.
      * @returns {undefined}
      */
-    _drawingMouseDragCallback(evt: Object): undefined;
+    _drawingMouseDragCallback(evt: MeasurementMouseEvent): void;
     /**
-     * Event handler for MOUSE_UP during drawing event loop.
+     * Event handler for TOUCH_DRAG during drawing event loop.
      *
      * @event
      * @param {Object} evt - The event.
      * @returns {undefined}
      */
-    _drawingMouseUpCallback(evt: Object): undefined;
+    _drawingTouchDragCallback(evt: MeasurementMouseEvent): void;
+    _drawingDrag(evt: MeasurementMouseEvent): void;
     /**
-     * Event handler for MOUSE_DOUBLE_CLICK during drawing event loop.
+     * Event handler for MOUSE_UP during drawing event loop.
      *
      * @event
      * @param {Object} evt - The event.
      * @returns {undefined}
      */
-    _drawingMouseDoubleClickCallback(evt: Object): undefined;
+    _drawingMouseUpCallback(evt: MeasurementMouseEvent): void;
     /**
-     * Event handler for MOUSE_UP during handle drag event loop.
+     * Event handler for MOUSE_DOWN during drawing event loop.
      *
-     * @private
+     * @event
      * @param {Object} evt - The event.
      * @returns {undefined}
      */
-    private _editMouseUpCallback;
+    _drawingMouseDownCallback(evt: MeasurementMouseEvent): void;
     /**
-     * Event handler for MOUSE_DRAG during handle drag event loop.
+     * Event handler for TOUCH_START during drawing event loop.
      *
      * @event
      * @param {Object} evt - The event.
      * @returns {undefined}
      */
-    _editMouseDragCallback(evt: Object): undefined;
+    _drawingTouchStartCallback(evt: MeasurementMouseEvent): void;
+    /** Ends the active drawing loop and completes the polygon.
+     *
+     * @public
+     * @param {Object} element - The element on which the roi is being drawn.
+     * @returns {null}
+     */
+    completeDrawing(element: HTMLElement): void;
     /**
-     * Event handler for TOUCH_START during drawing event loop.
+     * Event handler for MOUSE_DOUBLE_CLICK during drawing event loop.
      *
      * @event
      * @param {Object} evt - The event.
      * @returns {undefined}
      */
-    _drawingTouchStartCallback(evt: Object): undefined;
+    _drawingMouseDoubleClickCallback(evt: MeasurementMouseEvent): void;
     /**
-     * Event handler for TOUCH_DRAG during drawing event loop.
+     * Event handler for DOUBLE_TAP during drawing event loop.
      *
      * @event
      * @param {Object} evt - The event.
      * @returns {undefined}
      */
-    _drawingTouchDragCallback(evt: Object): undefined;
+    _drawingDoubleTapClickCallback(evt: MeasurementMouseEvent): void;
     /**
-     * Event handler for DOUBLE_TAP during drawing event loop.
+     * Event handler for MOUSE_DRAG during handle drag event loop.
      *
      * @event
      * @param {Object} evt - The event.
      * @returns {undefined}
      */
-    _drawingDoubleTapClickCallback(evt: Object): undefined;
+    _editMouseDragCallback(evt: MeasurementMouseEvent): void;
     /**
      * Event handler for TOUCH_DRAG during handle drag event loop.
      *
@@ -98,92 +156,33 @@ export class ContoursTool {
      * @param {Object} evt - The event.
      * @returns {void}
      */
-    _editTouchDragCallback(evt: Object): void;
-    throttledUpdateCachedStats: any;
-    initializeContours(contourData: any, segmentationName: any): void;
-    createNewMeasurement(eventData: any): {
-        visible: boolean;
-        active: boolean;
-        invalidated: boolean;
-        color: undefined;
-        handles: {
-            points: never[];
-        };
-    } | undefined;
-    /**
-     *
-     *
-     * @param {*} element element
-     * @param {*} data data
-     * @param {*} coords coords
-     * @returns {Boolean}
-     */
-    pointNearTool(element: any, data: any, coords: any): boolean;
-    /**
-     * @param {*} element
-     * @param {*} data
-     * @param {*} coords
-     * @returns {number} the distance in px from the provided coordinates to the
-     * closest rendered portion of the annotation. -1 if the distance cannot be
-     * calculated.
-     */
-    distanceFromPoint(element: any, data: any, coords: any): number;
-    /**
-     * @param {*} element
-     * @param {*} data
-     * @param {*} coords
-     * @returns {number} the distance in canvas units from the provided coordinates to the
-     * closest rendered portion of the annotation. -1 if the distance cannot be
-     * calculated.
-     */
-    distanceFromPointCanvas(element: any, data: any, coords: any): number;
-    /**
-     *
-     *
-     *
-     * @param {Object} image image
-     * @param {Object} element element
-     * @param {Object} data data
-     *
-     * @returns {void}  void
-     */
-    updateCachedStats(image: Object, element: Object, data: Object): void;
-    /**
-     *
-     *
-     * @param {*} evt
-     * @returns {undefined}
-     */
-    renderToolData(evt: any): undefined;
-    addNewMeasurement(evt: any): void;
-    preMouseDownCallback(evt: any): boolean;
-    handleSelectedCallback(evt: any, toolData: any, handle: any, interactionType?: string): void;
-    _drawingDrag(evt: any): void;
-    /** Ends the active drawing loop and completes the polygon.
-     *
-     * @public
-     * @param {Object} element - The element on which the roi is being drawn.
-     * @returns {null}
-     */
-    public completeDrawing(element: Object): null;
+    _editTouchDragCallback(evt: MeasurementMouseEvent): void;
     /**
      * Returns the previous handle to the current one.
      * @param {Number} currentHandle - the current handle index
      * @param {Array} points - the handles Array of the freehand data
      * @returns {Number} - The index of the previos handle
      */
-    _getPrevHandleIndex(currentHandle: number, points: any[]): number;
+    _getPrevHandleIndex(currentHandle: number, points: HandlePosition[]): number;
+    /**
+     * Event handler for MOUSE_UP during handle drag event loop.
+     *
+     * @private
+     * @param {Object} evt - The event.
+     * @returns {undefined}
+     */
+    _editMouseUpCallback(evt: MeasurementMouseEvent): void;
     /**
      * Places a handle of the freehand tool if the new location is valid.
      * If the new location is invalid the handle snaps back to its previous position.
      *
      * @private
-     * @param {Object} eventData - Data object associated with the event.
-     * @param {Object} toolState - The data associated with the freehand tool.
+     * @param {EventData} eventData - Data object associated with the event.
+     * @param {any} toolState - The data associated with the freehand tool.
      * @modifies {toolState}
      * @returns {undefined}
      */
-    private _dropHandle;
+    _dropHandle(eventData: EventData, toolState: any): void;
     /**
      * Begining of drawing loop when tool is active and a click event happens far
      * from existing handles.
@@ -192,8 +191,7 @@ export class ContoursTool {
      * @param {Object} evt - The event.
      * @returns {undefined}
      */
-    private _startDrawing;
-    _activeDrawingToolReference: any;
+    _startDrawing(evt: MeasurementMouseEvent): void;
     /**
      * Adds a point on mouse click in polygon mode.
      *
@@ -201,7 +199,7 @@ export class ContoursTool {
      * @param {Object} eventData - data object associated with an event.
      * @returns {undefined}
      */
-    private _addPoint;
+    _addPoint(eventData: EventData): void;
     /**
      * If in pencilMode, check the mouse position is farther than the minimum
      * distance between points, then add a point.
@@ -211,7 +209,7 @@ export class ContoursTool {
      * @param {Object} points - Data object associated with the tool.
      * @returns {undefined}
      */
-    private _addPointPencilMode;
+    _addPointPencilMode(eventData: EventData, points: HandlePosition[]): void;
     /**
      * Ends the active drawing loop and completes the polygon.
      *
@@ -220,7 +218,7 @@ export class ContoursTool {
      * @param {Object} handleNearby - the handle nearest to the mouse cursor.
      * @returns {undefined}
      */
-    private _endDrawing;
+    _endDrawing(element: HTMLElement, handleNearby?: boolean): void;
     /**
      * Returns a handle of a particular tool if it is close to the mouse cursor
      *
@@ -230,7 +228,7 @@ export class ContoursTool {
      * @param {*} coords
      * @returns {Number|Object|Boolean}
      */
-    private _pointNearHandle;
+    _pointNearHandle(element: HTMLElement, data: MeasurementData, coords: Coords): number | HandleTextBox | undefined;
     /**
      * Returns a handle if it is close to the mouse cursor (all tools)
      *
@@ -238,7 +236,10 @@ export class ContoursTool {
      * @param {Object} eventData - data object associated with an event.
      * @returns {Object}
      */
-    private _pointNearHandleAllTools;
+    _pointNearHandleAllTools(eventData: EventData): {
+        handleNearby: number | HandleTextBox;
+        toolIndex: number;
+    } | undefined;
     /**
      * Gets the current mouse location and stores it in the configuration object.
      *
@@ -246,7 +247,7 @@ export class ContoursTool {
      * @param {Object} eventData The data assoicated with the event.
      * @returns {undefined}
      */
-    private _getMouseLocation;
+    _getMouseLocation(eventData: EventData): void;
     /**
      * Returns true if the proposed location of a new handle is invalid.
      *
@@ -255,7 +256,7 @@ export class ContoursTool {
      * @param {Object} eventData The data assoicated with the event.
      * @returns {Boolean}
      */
-    private _checkInvalidHandleLocation;
+    _checkInvalidHandleLocation(data: MeasurementData, eventData: EventData): true | undefined;
     /**
      * Returns true if the proposed location of a new handle is invalid (in polygon mode).
      *
@@ -265,7 +266,7 @@ export class ContoursTool {
      * @param {Object} eventData The data assoicated with the event.
      * @returns {Boolean}
      */
-    private _checkHandlesPolygonMode;
+    _checkHandlesPolygonMode(data: MeasurementData, eventData: EventData): boolean;
     /**
      * Returns true if the proposed location of a new handle is invalid (in pencilMode).
      *
@@ -274,7 +275,7 @@ export class ContoursTool {
      * @param {Object} eventData The data associated with the event.
      * @returns {Boolean}
      */
-    private _checkHandlesPencilMode;
+    _checkHandlesPencilMode(data: MeasurementData, eventData: EventData): any;
     /**
      * Returns true if the mouse position is far enough from previous points (in pencilMode).
      *
@@ -283,7 +284,7 @@ export class ContoursTool {
      * @param {Object} eventData The data associated with the event.
      * @returns {Boolean}
      */
-    private _invalidHandlePencilMode;
+    _invalidHandlePencilMode(data: MeasurementData, eventData: EventData): boolean;
     /**
      * Returns true if two points are closer than this.configuration.spacing.
      *
@@ -294,42 +295,42 @@ export class ContoursTool {
      * @returns {boolean}            True if the distance is smaller than the
      *                              allowed canvas spacing.
      */
-    private _isDistanceSmallerThanCompleteSpacingCanvas;
+    _isDistanceSmallerThanCompleteSpacingCanvas(element: HTMLElement, p1: Coords, p2: Coords): boolean;
     /**
      * Returns true if two points are closer than this.configuration.spacing.
      *
      * @private
-     * @param  {Object} element     The element on which the roi is being drawn.
-     * @param  {Object} p1          The first point, in pixel space.
-     * @param  {Object} p2          The second point, in pixel space.
+     * @param  {HTMLElement} element     The element on which the roi is being drawn.
+     * @param  {Coords} p1          The first point, in pixel space.
+     * @param  {Coords} p2          The second point, in pixel space.
      * @returns {boolean}            True if the distance is smaller than the
      *                              allowed canvas spacing.
      */
-    private _isDistanceSmallerThanSpacing;
+    _isDistanceSmallerThanSpacing(element: HTMLElement, p1: Coords, p2: Coords): boolean;
     /**
      * Returns true if two points are farther than this.configuration.spacing.
      *
      * @private
-     * @param  {Object} element     The element on which the roi is being drawn.
-     * @param  {Object} p1          The first point, in pixel space.
-     * @param  {Object} p2          The second point, in pixel space.
-     * @returns {boolean}            True if the distance is smaller than the
+     * @param  {HTMLElement} element     The element on which the roi is being drawn.
+     * @param  {Coords} p1          The first point, in pixel space.
+     * @param  {Coords} p2          The second point, in pixel space.
+     * @returns {boolean}           True if the distance is larger than the
      *                              allowed canvas spacing.
      */
-    private _isDistanceLargerThanSpacing;
+    _isDistanceLargerThanSpacing(element: HTMLElement, p1: Coords, p2: Coords): boolean;
     /**
      * Compares the distance between two points to this.configuration.spacing.
      *
      * @private
-     * @param  {Object} element     The element on which the roi is being drawn.
-     * @param  {Object} p1          The first point, in pixel space.
-     * @param  {Object} p2          The second point, in pixel space.
+     * @param  {HTMLElement} element     The element on which the roi is being drawn.
+     * @param  {Coords} p1          The first point, in pixel space.
+     * @param  {Coords} p2          The second point, in pixel space.
      * @param  {string} comparison  The comparison to make.
      * @param  {number} spacing     The allowed canvas spacing
      * @returns {boolean}           True if the distance is smaller than the
      *                              allowed canvas spacing.
      */
-    private _compareDistanceToSpacing;
+    _compareDistanceToSpacing(element: HTMLElement, p1: Coords, p2: Coords, comparison?: string, spacing?: any): boolean;
     /**
      * Adds drawing loop event listeners.
      *
@@ -339,8 +340,7 @@ export class ContoursTool {
      * @modifies {element}
      * @returns {undefined}
      */
-    private _activateDraw;
-    _drawingInteractionType: string | null | undefined;
+    _activateDraw(element: HTMLElement, interactionType?: string): void;
     /**
      * Removes drawing loop event listeners.
      *
@@ -349,47 +349,47 @@ export class ContoursTool {
      * @modifies {element}
      * @returns {undefined}
      */
-    private _deactivateDraw;
+    _deactivateDraw(element: HTMLElement): void;
     /**
      * Adds modify loop event listeners.
      *
      * @private
-     * @param {Object} element - The viewport element to add event listeners to.
+     * @param {HTMLElement} element - The viewport element to add event listeners to.
      * @modifies {element}
      * @returns {undefined}
      */
-    private _activateModify;
+    _activateModify(element: HTMLElement): void;
     /**
      * Removes modify loop event listeners.
      *
      * @private
-     * @param {Object} element - The viewport element to add event listeners to.
+     * @param {HTMLElement} element - The viewport element to add event listeners to.
      * @modifies {element}
      * @returns {undefined}
      */
-    private _deactivateModify;
-    passiveCallback(element: any): void;
-    enabledCallback(element: any): void;
-    disabledCallback(element: any): void;
-    _closeToolIfDrawing(element: any): void;
+    _deactivateModify(element: HTMLElement): void;
+    passiveCallback(element: HTMLElement): void;
+    enabledCallback(element: HTMLElement): void;
+    disabledCallback(element: HTMLElement): void;
+    _closeToolIfDrawing(element: HTMLElement): void;
     /**
      * Fire MEASUREMENT_MODIFIED event on provided element
-     * @param {any} element which freehand data has been modified
-     * @param {any} measurementData the measurment data
+     * @param {HTMLElement} element which freehand data has been modified
+     * @param {MeasurementData} measurementData the measurment data
      * @returns {void}
      */
-    fireModifiedEvent(element: any, measurementData: any): void;
-    fireCompletedEvent(element: any, measurementData: any): void;
-    set spacing(value: any);
+    fireModifiedEvent(element: HTMLElement, measurementData: MeasurementData): void;
+    fireCompletedEvent(element: HTMLElement, measurementData: MeasurementData): void;
     get spacing(): any;
-    set activeHandleRadius(value: any);
+    set spacing(value: any);
     get activeHandleRadius(): any;
-    set completeHandleRadius(value: any);
+    set activeHandleRadius(value: any);
     get completeHandleRadius(): any;
-    set alwaysShowHandles(value: any);
+    set completeHandleRadius(value: any);
     get alwaysShowHandles(): any;
-    set invalidColor(value: any);
+    set alwaysShowHandles(value: any);
     get invalidColor(): any;
+    set invalidColor(value: any);
     /**
      * Ends the active drawing loop and removes the polygon.
      *
@@ -397,7 +397,7 @@ export class ContoursTool {
      * @param {Object} element - The element on which the roi is being drawn.
      * @returns {null}
      */
-    public cancelDrawing(element: Object): null;
+    cancelDrawing(element: HTMLElement): void;
     /**
      * New image event handler.
      *
@@ -405,5 +405,6 @@ export class ContoursTool {
      * @param  {Object} evt The event.
      * @returns {null}
      */
-    public newImageCallback(evt: Object): null;
+    newImageCallback(evt: MeasurementMouseEvent): void;
 }
+export {};

package/dist/imaging/tools/custom/diameterTool.d.ts

@@ -1,3 +1,69 @@
+/** @module imaging/tools/custom/diameterTool
+ *  @desc  This file provides functionalities for
+ *         a custom diameter cornestone tool
+ */
+declare const BidirectionalTool: any;
+interface DiameterToolProps {
+    name?: string;
+    dataArray?: ToolDataItem[];
+    seriesId?: string;
+}
+interface ToolDataItem {
+    id: number;
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    x3: number;
+    y3: number;
+    x4: number;
+    y4: number;
+    value_max: number;
+    value_min: number;
+    slice: number;
+}
+interface ToolHandle {
+    x: number;
+    y: number;
+    index: number | null;
+    drawnIndependently: boolean;
+    allowedOutsideImage: boolean;
+    highlight: boolean;
+    active: boolean;
+    locked?: boolean;
+    hasMoved?: boolean;
+    movesIndependently?: boolean;
+    hasBoundingBox?: boolean;
+    boundingBox?: {
+        width: number;
+        height: number;
+        left: number;
+        top: number;
+    };
+}
+interface ToolData {
+    toolType: string;
+    name: string;
+    isCreating: boolean;
+    visible: boolean;
+    active: boolean;
+    invalidated: boolean;
+    handles: {
+        start: ToolHandle;
+        end: ToolHandle;
+        perpendicularStart: ToolHandle;
+        perpendicularEnd: ToolHandle;
+        textBox: ToolHandle;
+    };
+    longestDiameter: string;
+    shortestDiameter: string;
+}
+interface MeasurementEvent extends Event {
+    detail: {
+        measurementData: ToolData;
+    };
+    element: HTMLElement;
+}
 /**
  * @public
  * @class DiameterTool
@@ -6,13 +72,15 @@
  * length and width of a region.
  * @extends Tools.Base.BaseAnnotationTool
  */
-export class DiameterTool {
-    constructor(props: any);
+export declare class DiameterTool extends BidirectionalTool {
+    static [x: string]: any;
     name: string;
-    initializeTool(dataArray: any, elementId: any, seriesId: any): void;
-    passiveCallback(element: any): void;
-    measureOnGoingCallback(event: any): void;
-    isBeenModified: boolean | undefined;
-    lastData: any;
-    measureEndCallback(event: any): void;
+    isBeenModified: boolean;
+    lastData: ToolData | null;
+    constructor(props: DiameterToolProps);
+    initializeTool(dataArray: ToolDataItem[], elementId: string, seriesId: string): void;
+    passiveCallback(element: HTMLElement): void;
+    measureOnGoingCallback(event: MeasurementEvent): void;
+    measureEndCallback(event: MeasurementEvent): void;
 }
+export {};

package/dist/imaging/tools/custom/editMaskTool.d.ts

@@ -1,3 +1,9 @@
+/** @module imaging/tools/custom/editMaskTool
+ *  @desc  This file provides functionalities for
+ *         a custom mask cornestone tool
+ */
+import { MaskData, MeasurementMouseEvent } from "../types";
+declare const BaseBrushTool: any;
 /**
  * @public
  * @class BrushTool
@@ -5,11 +11,16 @@
  * @classdesc Tool for drawing segmentations on an image.
  * @extends Tools.Base.BaseBrushTool
  */
-export class EditMaskTool {
-    constructor(props?: {});
-    touchDragCallback: (evt: Object) => void;
-    _initializeTool(mask: any, callback: any): void;
-    activeCallback(element: any, options: any): void;
+export declare class EditMaskTool extends BaseBrushTool {
+    static [x: string]: any;
+    constructor(props?: {
+        mask?: MaskData;
+        initCallback?: Function;
+    });
+    _initializeTool(mask: MaskData, callback: Function): void;
+    activeCallback(element: HTMLElement, options: {
+        force: string;
+    }): void;
     preventCtrl(): void;
     /**
      * Paints the data to the labelmap.
@@ -18,5 +29,6 @@ export class EditMaskTool {
      * @param  {Object} evt The data object associated with the event.
      * @returns {void}
      */
-    protected _paint(evt: Object): void;
+    _paint(evt: MeasurementMouseEvent): void;
 }
+export {};