larvitar 1.5.14 → 2.0.2

package/dist/imaging/monitors/memory.d.ts

@@ -0,0 +1,41 @@
+/** @module monitors/memory
+ *  @desc This file provides utility functions for
+ *        monitoring memory usage
+ */
+/**
+ * Check memory allocation and clear memory if needed
+ * @instance
+ * @function checkAndClearMemory
+ * @param {Number} - Number of bytes to allocate
+ * @param {Array} - Rendered Series ids
+ */
+export declare const checkAndClearMemory: (bytes: number, renderedSeriesIds: string[]) => void;
+/**
+ * Check memory allocation and returns false if js Heap size has reached its limit
+ * @instance
+ * @function checkMemoryAllocation
+ * @param {Number} - Number of bytes to allocate
+ * @return {Boolean} - Returns a boolean flag to warn the user about memory allocation limit
+ */
+export declare const checkMemoryAllocation: (bytes: number) => boolean;
+/**
+ * Check performance.memory browser support and returns used Js Heap Size in Mb
+ * @instance
+ * @function getUsedMemory
+ * @return {Number} - Returns used JSHeapSize in bytes or NaN if not supported
+ */
+export declare const getUsedMemory: () => any;
+/**
+ * Check performance.memory browser support and returns available Js Heap Size in Mb
+ * @instance
+ * @function getAvailableMemory
+ * @return {Number} - Returns available JSHeapSize in bytes or NaN if not supported
+ */
+export declare const getAvailableMemory: () => number;
+/**
+ * Check performance.memory browser support and returns available Js Heap Size in Mb
+ * @instance
+ * @function setAvailableMemory
+ * @param {Number} - Number of GB to set as maximum custom memory limit
+ */
+export declare const setAvailableMemory: (value: number) => void;

package/dist/imaging/monitors/performance.d.ts

@@ -0,0 +1,23 @@
+/** @module monitors/performance
+ *  @desc This file provides utility functions for
+ *        monitoring performance usage
+ */
+/**
+ * Get performance monitor
+ * @instance
+ * @function getPerformanceMonitor
+ * @returns {Boolean} - Performance monitor status
+ */
+export declare const getPerformanceMonitor: () => boolean;
+/**
+ * Set performance monitor ON
+ * @instance
+ * @function activatePerformanceMonitor
+ */
+export declare const activatePerformanceMonitor: () => void;
+/**
+ * Set performance monitor OFF
+ * @instance
+ * @function deactivatePerformanceMonitor
+ */
+export declare const deactivatePerformanceMonitor: () => void;

package/dist/imaging/parsers/ecg.d.ts

@@ -0,0 +1,15 @@
+/** @module imaging/parsers/ecg
+ *  @desc  This file provides functionalities for
+ *         handling ECG signales in DICOM files
+ */
+import { DataSet } from "dicom-parser";
+/**
+ * Generate an array of points representing the ECG signal
+ * @instance
+ * @function parseECG
+ * @param {DataSet} dataSet - the DICOM dataset
+ * @param {String} tag - the tag of the ECG signal
+ * @param {Number} nSampling - the sampling rate
+ * @returns {void}
+ */
+export declare function parseECG(seriesId: string, dataSet: DataSet, tag: string, nSampling?: number): void;

package/dist/imaging/parsers/nrrd.d.ts

@@ -0,0 +1,3 @@
+export function parse(nrrdBuffer: ArrayBuffer, options: {
+    headerOnly: boolean;
+}): Object;

package/dist/imaging/tools/custom/4dSliceScrollTool.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @public
+ * @class 4DScrollMouseWheelTool
+ * @memberof Tools
+ *
+ * @classdesc Tool for scrolling through a series using the mouse wheel.
+ * @extends Tools.Base.BaseTool
+ */
+export default class Slice4DScrollMouseWheelTool {
+    constructor(props?: {});
+    mouseWheelCallback(evt: any): void;
+}

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

@@ -0,0 +1,18 @@
+declare const BorderMagnifyTool_base: any;
+export default class BorderMagnifyTool extends BorderMagnifyTool_base {
+    [x: string]: any;
+    constructor(props?: {});
+    /**
+     * Event handler for the "keydown" event to toggle the visibility of borders and info on "B" key press.
+     * @param {KeyboardEvent} event
+     * @returns {void}
+     */
+    handleKeyDown(event: KeyboardEvent): void;
+    /**
+     * Overrides the _drawMagnificationTool method to add configurable borders and display zoom/ROI dimensions.
+     * @param {*} evt
+     * @returns {void}
+     */
+    _drawMagnificationTool(evt: any): void;
+}
+export {};

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

@@ -0,0 +1,409 @@
+/**
+ * @public
+ * @class ContoursTool
+ * @memberof Tools.Annotation
+ * @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;
+    /**
+     * Event handler for MOUSE_DOWN during drawing event loop.
+     *
+     * @event
+     * @param {Object} evt - The event.
+     * @returns {undefined}
+     */
+    _drawingMouseDownCallback(evt: Object): undefined;
+    /**
+     * Event handler for MOUSE_MOVE during drawing event loop.
+     *
+     * @event
+     * @param {Object} evt - The event.
+     * @returns {undefined}
+     */
+    _drawingMouseMoveCallback(evt: Object): undefined;
+    /**
+     * Event handler for MOUSE_DRAG during drawing event loop.
+     *
+     * @event
+     * @param {Object} evt - The event.
+     * @returns {undefined}
+     */
+    _drawingMouseDragCallback(evt: Object): undefined;
+    /**
+     * Event handler for MOUSE_UP during drawing event loop.
+     *
+     * @event
+     * @param {Object} evt - The event.
+     * @returns {undefined}
+     */
+    _drawingMouseUpCallback(evt: Object): undefined;
+    /**
+     * Event handler for MOUSE_DOUBLE_CLICK during drawing event loop.
+     *
+     * @event
+     * @param {Object} evt - The event.
+     * @returns {undefined}
+     */
+    _drawingMouseDoubleClickCallback(evt: Object): undefined;
+    /**
+     * Event handler for MOUSE_UP during handle drag event loop.
+     *
+     * @private
+     * @param {Object} evt - The event.
+     * @returns {undefined}
+     */
+    private _editMouseUpCallback;
+    /**
+     * Event handler for MOUSE_DRAG during handle drag event loop.
+     *
+     * @event
+     * @param {Object} evt - The event.
+     * @returns {undefined}
+     */
+    _editMouseDragCallback(evt: Object): undefined;
+    /**
+     * Event handler for TOUCH_START during drawing event loop.
+     *
+     * @event
+     * @param {Object} evt - The event.
+     * @returns {undefined}
+     */
+    _drawingTouchStartCallback(evt: Object): undefined;
+    /**
+     * Event handler for TOUCH_DRAG during drawing event loop.
+     *
+     * @event
+     * @param {Object} evt - The event.
+     * @returns {undefined}
+     */
+    _drawingTouchDragCallback(evt: Object): undefined;
+    /**
+     * Event handler for DOUBLE_TAP during drawing event loop.
+     *
+     * @event
+     * @param {Object} evt - The event.
+     * @returns {undefined}
+     */
+    _drawingDoubleTapClickCallback(evt: Object): undefined;
+    /**
+     * Event handler for TOUCH_DRAG during handle drag event loop.
+     *
+     * @event
+     * @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;
+    /**
+     * 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;
+    /**
+     * 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.
+     * @modifies {toolState}
+     * @returns {undefined}
+     */
+    private _dropHandle;
+    /**
+     * Begining of drawing loop when tool is active and a click event happens far
+     * from existing handles.
+     *
+     * @private
+     * @param {Object} evt - The event.
+     * @returns {undefined}
+     */
+    private _startDrawing;
+    _activeDrawingToolReference: any;
+    /**
+     * Adds a point on mouse click in polygon mode.
+     *
+     * @private
+     * @param {Object} eventData - data object associated with an event.
+     * @returns {undefined}
+     */
+    private _addPoint;
+    /**
+     * If in pencilMode, check the mouse position is farther than the minimum
+     * distance between points, then add a point.
+     *
+     * @private
+     * @param {Object} eventData - Data object associated with an event.
+     * @param {Object} points - Data object associated with the tool.
+     * @returns {undefined}
+     */
+    private _addPointPencilMode;
+    /**
+     * Ends the active drawing loop and completes the polygon.
+     *
+     * @private
+     * @param {Object} element - The element on which the roi is being drawn.
+     * @param {Object} handleNearby - the handle nearest to the mouse cursor.
+     * @returns {undefined}
+     */
+    private _endDrawing;
+    /**
+     * Returns a handle of a particular tool if it is close to the mouse cursor
+     *
+     * @private
+     * @param {Object} element - The element on which the roi is being drawn.
+     * @param {Object} data      Data object associated with the tool.
+     * @param {*} coords
+     * @returns {Number|Object|Boolean}
+     */
+    private _pointNearHandle;
+    /**
+     * Returns a handle if it is close to the mouse cursor (all tools)
+     *
+     * @private
+     * @param {Object} eventData - data object associated with an event.
+     * @returns {Object}
+     */
+    private _pointNearHandleAllTools;
+    /**
+     * Gets the current mouse location and stores it in the configuration object.
+     *
+     * @private
+     * @param {Object} eventData The data assoicated with the event.
+     * @returns {undefined}
+     */
+    private _getMouseLocation;
+    /**
+     * Returns true if the proposed location of a new handle is invalid.
+     *
+     * @private
+     * @param {Object} data      Data object associated with the tool.
+     * @param {Object} eventData The data assoicated with the event.
+     * @returns {Boolean}
+     */
+    private _checkInvalidHandleLocation;
+    /**
+     * Returns true if the proposed location of a new handle is invalid (in polygon mode).
+     *
+     * @private
+     *
+     * @param {Object} data - data object associated with the tool.
+     * @param {Object} eventData The data assoicated with the event.
+     * @returns {Boolean}
+     */
+    private _checkHandlesPolygonMode;
+    /**
+     * Returns true if the proposed location of a new handle is invalid (in pencilMode).
+     *
+     * @private
+     * @param {Object} data - data object associated with the tool.
+     * @param {Object} eventData The data associated with the event.
+     * @returns {Boolean}
+     */
+    private _checkHandlesPencilMode;
+    /**
+     * Returns true if the mouse position is far enough from previous points (in pencilMode).
+     *
+     * @private
+     * @param {Object} data - data object associated with the tool.
+     * @param {Object} eventData The data associated with the event.
+     * @returns {Boolean}
+     */
+    private _invalidHandlePencilMode;
+    /**
+     * 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.
+     * @returns {boolean}            True if the distance is smaller than the
+     *                              allowed canvas spacing.
+     */
+    private _isDistanceSmallerThanCompleteSpacingCanvas;
+    /**
+     * 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.
+     * @returns {boolean}            True if the distance is smaller than the
+     *                              allowed canvas spacing.
+     */
+    private _isDistanceSmallerThanSpacing;
+    /**
+     * 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
+     *                              allowed canvas spacing.
+     */
+    private _isDistanceLargerThanSpacing;
+    /**
+     * 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  {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;
+    /**
+     * Adds drawing loop event listeners.
+     *
+     * @private
+     * @param {Object} element - The viewport element to add event listeners to.
+     * @param {string} interactionType - The interactionType used for the loop.
+     * @modifies {element}
+     * @returns {undefined}
+     */
+    private _activateDraw;
+    _drawingInteractionType: string | null | undefined;
+    /**
+     * Removes drawing loop event listeners.
+     *
+     * @private
+     * @param {Object} element - The viewport element to add event listeners to.
+     * @modifies {element}
+     * @returns {undefined}
+     */
+    private _deactivateDraw;
+    /**
+     * Adds modify loop event listeners.
+     *
+     * @private
+     * @param {Object} element - The viewport element to add event listeners to.
+     * @modifies {element}
+     * @returns {undefined}
+     */
+    private _activateModify;
+    /**
+     * Removes modify loop event listeners.
+     *
+     * @private
+     * @param {Object} 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;
+    /**
+     * Fire MEASUREMENT_MODIFIED event on provided element
+     * @param {any} element which freehand data has been modified
+     * @param {any} measurementData the measurment data
+     * @returns {void}
+     */
+    fireModifiedEvent(element: any, measurementData: any): void;
+    fireCompletedEvent(element: any, measurementData: any): void;
+    set spacing(arg: any);
+    get spacing(): any;
+    set activeHandleRadius(arg: any);
+    get activeHandleRadius(): any;
+    set completeHandleRadius(arg: any);
+    get completeHandleRadius(): any;
+    set alwaysShowHandles(arg: any);
+    get alwaysShowHandles(): any;
+    set invalidColor(arg: any);
+    get invalidColor(): any;
+    /**
+     * Ends the active drawing loop and removes the polygon.
+     *
+     * @public
+     * @param {Object} element - The element on which the roi is being drawn.
+     * @returns {null}
+     */
+    public cancelDrawing(element: Object): null;
+    /**
+     * New image event handler.
+     *
+     * @public
+     * @param  {Object} evt The event.
+     * @returns {null}
+     */
+    public newImageCallback(evt: Object): null;
+}

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

@@ -0,0 +1,18 @@
+/**
+ * @public
+ * @class DiameterTool
+ * @memberof Tools.Annotation
+ * @classdesc Create and position an annotation that measures the
+ * length and width of a region.
+ * @extends Tools.Base.BaseAnnotationTool
+ */
+export class DiameterTool {
+    constructor(props: 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;
+}

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

@@ -0,0 +1,22 @@
+/**
+ * @public
+ * @class BrushTool
+ * @memberof Tools.Brush
+ * @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;
+    preventCtrl(): void;
+    /**
+     * Paints the data to the labelmap.
+     *
+     * @protected
+     * @param  {Object} evt The data object associated with the event.
+     * @returns {void}
+     */
+    protected _paint(evt: Object): void;
+}

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

@@ -0,0 +1,45 @@
+/**
+ * @public
+ * @class EllipticalRoiTool
+ * @memberof Tools.Annotation
+ * @classdesc Tool for drawing elliptical regions of interest, and measuring
+ * the statistics of the enclosed pixels.
+ * @extends Tools.Base.BaseAnnotationTool
+ */
+export default class EllipticalRoiTool {
+    constructor(props?: {});
+    throttledUpdateCachedStats: any;
+    createNewMeasurement(eventData: any): {
+        computeMeasurements: any;
+        visible: boolean;
+        active: boolean;
+        color: undefined;
+        invalidated: boolean;
+        handles: {
+            start: {
+                x: any;
+                y: any;
+                highlight: boolean;
+                active: boolean;
+            };
+            end: {
+                x: any;
+                y: any;
+                highlight: boolean;
+                active: boolean;
+            };
+            initialRotation: any;
+            textBox: {
+                active: boolean;
+                hasMoved: boolean;
+                movesIndependently: boolean;
+                drawnIndependently: boolean;
+                allowedOutsideImage: boolean;
+                hasBoundingBox: boolean;
+            };
+        };
+    } | undefined;
+    pointNearTool(element: any, data: any, coords: any, interactionType: any): boolean;
+    updateCachedStats(image: any, element: any, data: any): void;
+    renderToolData(evt: any): void;
+}

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

@@ -0,0 +1,54 @@
+declare namespace _default {
+    export { _checkIfDrawing as mouseClickCallback };
+    export { _resetHandles as initializeMixin };
+    export { renderToolData };
+    export { _resetHandles };
+    export { _addPoint };
+    export { _applyStrategy };
+}
+export default _default;
+/**
+ * Entry point, manage workflow starting / ending
+ * @param {Object} evt
+ */
+declare function _checkIfDrawing(evt: Object): void;
+/**
+ * Sets the start and end handle points to empty objects
+ *
+ * @private
+ * @method _resetHandles
+ * @returns {undefined}
+ */
+declare function _resetHandles(): undefined;
+declare class _resetHandles {
+    handles: {
+        points: never[];
+    };
+    currentHandle: number;
+}
+/**
+ * Override for `freehandSegmentationMixin`'s `renderToolData` method to render a polyline instead
+ * of a freehand region with the first and last point connected. Apply after the `freehandSegmentationMixin`.
+ *
+ * @override
+ * @param {Object} evt The cornerstone render event.
+ * @returns {null}
+ */
+declare function renderToolData(evt: Object): null;
+/**
+ * Adds a point on mouse click in polygon mode.
+ *
+ * @private
+ * @param {Object} evt - data object associated with an event.
+ * @returns {void}
+ */
+declare function _addPoint(evt: Object): void;
+/**
+ * Event handler for MOUSE_UP/TOUCH_END during handle drag event loop.
+ *
+ * @private
+ * @method _applyStrategy
+ * @param {(CornerstoneTools.event#MOUSE_UP|CornerstoneTools.event#TOUCH_END)} evt Interaction event emitted by an enabledElement
+ * @returns {void}
+ */
+declare function _applyStrategy(evt: any): void;

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

@@ -0,0 +1,11 @@
+/**
+ * @public
+ * @class PolylineScissorsTool
+ * @memberof Tools
+ * @classdesc Tool for manipulating labelmap data by drawing a polyline polygon.
+ * @extends Tools.Base.BaseTool
+ */
+export default class PolylineScissorsTool {
+    /** @inheritdoc */
+    constructor(props?: {});
+}