larvitar 3.6.2 → 3.6.3

package/dist/imaging/imageContours.d.ts

@@ -15,4 +15,4 @@ import { Contours } from "./types";
  */
 export declare const parseContours: (contoursData: {
     [key: string]: Uint8Array;
-}, pointBatchSize: number, segmentationName: string, viewports: Array<string>) => Contours;
+}, pointBatchSize: number, segmentationName: string, viewports?: Array<string>) => Contours;

package/dist/imaging/imageTools.d.ts

@@ -1,20 +1,145 @@
-export function addDefaultTools(toolToActivate: any): void;
-export function addDiameterTool(elementId: string, diameters: any[], seriesId: string): void;
-export function addContoursTool(rawContours: Object, maskName: string): void;
-export function addMaskEditingTool(mask: any[], callback: Function, targetViewport: string): void;
-export function setSegmentationConfig(config: Object): void;
-export function getCurrentMaskData(viewportId: string): any[];
-export function addStackStateToElement(seriesId: string, element: HTMLElement): void;
-export function addSeedsTool(preLoadSeeds: any[], initViewport: string): void;
-export function clearMeasurements(): void;
-export function setToolActive(toolName: string, options: Object, activeViewport: string, viewports: any[]): void;
-export function setToolDisabled(toolName: string, activeViewport: string, viewports: any[]): void;
-export function setToolEnabled(toolName: string, activeViewport: string, viewports: any[]): void;
-export function setToolPassive(toolName: string, activeViewport: string, viewports: any[]): void;
-export function getToolState(toolName: string): Object;
-export function clearToolStateByName(toolName: string, options: Object): void;
-export function updateDiameterTool(diameterId: string | number, value: Object, seriesId: string, viewportId: string): void;
-export function addToolStateSingleSlice(element: HTMLElement, toolName: string, data: Object | any[], slice: number, seriesId: string): void;
-export function clearCornerstoneElements(): void;
-export function syncToolStack(srcSliceNumber: number, toolName: string, viewport: string, seriesId: string): void;
-export function updateStackToolState(elementId: string, imageIndex: number): void;
+/** @module imaging/imageTools
+ *  @desc This file provides functionalities for
+ *        interacting with cornerstone tools
+ *        DEPRECATION WARNING: these are legacy functions
+ *        that will be removed soon. Use the corresponding
+ *        functions in /tools/main.js instead.
+ *        For this reason, this file will not be translated to TypeScript.
+ */
+import { DiameterStateData, SegmentationConfig } from "./tools/types";
+/**
+ * Add Diameter tool
+ * @function addDiameterTool
+ * @param {String} elementId - The target hmtl element id or its DOM HTMLElement
+ * @param {Array} diameters - The array of diameter objects.
+ * @param {String} seriesId - The id of the target serie.
+ */
+export declare const addDiameterTool: (elementId: string, diameters: number[], seriesId: string) => void;
+/**
+ * Add Contour tool
+ * @function addContoursTool
+ * @param {Object} rawContours - The contours object (generated from a segmentation mask).
+ * @param {String} maskName - The name tag that identify the mask
+ */
+/**
+ * Add Contour tool
+ * @function addContoursTool
+ * @param {Object} rawContours - The contours object (generated from a segmentation mask).
+ * @param {String} maskName - The name tag that identify the mask
+ */
+export declare const addContoursTool: (rawContours: {
+    [key: string]: Uint8Array;
+}, maskName: string) => void;
+/**
+ * Add mask editing tool
+ * @function addMaskEditingTool
+ * @param {Array} mask - The mask data.
+ * @param {Function} callback - The tool initialization callback
+ * @param {String} targetViewport - The target hmtl element id.
+ */
+export declare const addMaskEditingTool: (mask: string[], callback: () => void, targetViewport: string) => void;
+/**
+ * Modify configuration for cornerstone tools segmentation module
+ * @function setSegmentationConfig
+ * @param {Object} config - The custom configuration.
+ * @example
+ * Example of custom configuration
+ * config = {
+      renderOutline: true,
+      renderFill: true,
+      shouldRenderInactiveLabelmaps: true,
+      radius: 10,
+      minRadius: 1,
+      maxRadius: 50,
+      segmentsPerLabelmap: 65535,
+      fillAlpha: 0.7,
+      fillAlphaInactive: 0.1,
+      outlineAlpha: 0.7,
+      outlineAlphaInactive: 0.35,
+      outlineWidth: 3,
+      storeHistory: true
+    };
+ */
+export declare const setSegmentationConfig: (config: Partial<SegmentationConfig>) => void;
+/**
+ * Get mask editing tool current data from state
+ * @function getCurrentMaskData
+ * @param {String} viewportId - The target hmtl element id.
+ * @return {Array} labelmap3D - The mask array
+ */
+export declare const getCurrentMaskData: (viewportId: string) => unknown[];
+/**
+ * Add Stack State to a single hmtl element
+ * @function addStackStateToElement
+ * @param {String} seriesId - The id of the target serie.
+ * @param {HTMLElement} element - The target hmtl element.
+ */
+export declare const addStackStateToElement: (seriesId: string, element: HTMLElement) => void;
+/**
+ * Add seeds tool
+ * @function addSeedsTool
+ * @param {Array} preLoadSeeds - The array of seeds to load as initialization.
+ * @param {String} initViewport - The hmtl element id to be used for tool initialization.
+ */
+export declare const addSeedsTool: (preLoadSeeds: string[], initViewport: string) => void;
+/**
+ * Delete all measurements from tools state, for tools that have the "cleaneable" prop set to true in tools/default.js
+ * @function clearMeasurements
+ */
+export declare const clearMeasurements: () => void;
+/**
+ * Get tool data for all enabled elements
+ * @function getToolState
+ * @param {String} toolName - The tool name.
+ * @return {Object} - Tool data grouped by element id
+ */
+export declare const getToolState: (toolName: string) => any;
+/**
+ * Clear tool data for a subset of seeds
+ * @function clearToolStateByName
+ * @param {String} toolName - The tool name.
+ * @param {Object} options - Props used to select the data to delete (at the moment only {name : "targetName"} is implemented)
+ */
+export declare const clearToolStateByName: (toolName: string, options: any) => void;
+/**
+ * Update diameter tool with new value (removing old one)
+ * @function updateDiameterTool
+ * @param {String | Number} diameterId - The id that identify the diameter data.
+ * @param {Object} value - The object representing the new diameter data.
+ * @param {String} seriesId - The target serie id.
+ * @param {String} viewportId - The viewport id.
+ */
+export declare const updateDiameterTool: (diameterId: string, value: {
+    tool: DiameterStateData;
+}, seriesId: string, viewportId: string) => void;
+/**
+ * Add tool data for a single target slice
+ * @function addToolStateSingleSlice
+ * @param {HTMLElement} element - The target hmtl element.
+ * @param {String} toolName - The tool name.
+ * @param {Object | Array} data - The tool data to add (tool-specific)
+ * @param {Number} slice - The target slice to put the data in.
+ * @param {String} seriesId - The target serie id.
+ */
+export declare const addToolStateSingleSlice: (element: HTMLElement, toolName: string, data: Partial<DiameterStateData>, slice: number, seriesId?: string) => void;
+/**
+ * Clear tool state and disable all cornerstone elements
+ * @function clearCornerstoneElements
+ */
+export declare const clearCornerstoneElements: () => void;
+/**
+ * Sync the cornerstone tools stack given a slice as data source
+ * @function syncToolStack
+ * @param {Number} srcSliceNumber - The slice to be used as data source.
+ * @param {String} toolName - The name of the tool to sync.
+ * @param {String} viewport - The target viewport id.
+ * @param {String} seriesId - The target serie id.
+ */
+export declare const syncToolStack: (srcSliceNumber: number, toolName: string, viewport: string, seriesId: string) => void;
+/**
+ * Update slice index in cornerstone tools stack state
+ * @function updateStackToolState
+ * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
+ * @param {Number} imageIndex - The new imageIndex value.
+ */
+export declare const updateStackToolState: (elementId: string | HTMLElement, imageIndex: number) => void;

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

@@ -1,21 +1,28 @@
-declare const BorderMagnifyTool_base: any;
-export default class BorderMagnifyTool extends BorderMagnifyTool_base {
-    [x: string]: any;
-    constructor(props?: {});
+import { EventData } from "../types";
+declare const MagnifyTool: any;
+export default class BorderMagnifyTool extends MagnifyTool {
+    static [x: string]: any;
+    constructor(props?: {
+        showBorders?: boolean;
+        showInfo?: boolean;
+        borderColor?: string;
+    });
+    activeCallback(element: HTMLElement): void;
+    disabledCallback(element: HTMLElement): void;
+    passiveCallback(element: HTMLElement): void;
     /**
      * 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;
-    activeCallback(element: any): void;
-    disabledCallback(element: any): void;
-    passiveCallback(element: any): void;
     /**
      * Overrides the _drawMagnificationTool method to add configurable borders and display zoom/ROI dimensions.
      * @param {*} evt
      * @returns {void}
      */
-    _drawMagnificationTool(evt: any): void;
+    _drawMagnificationTool(evt?: {
+        detail: EventData;
+    }): void;
 }
 export {};

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

@@ -1,3 +1,5 @@
+import { Coords, EventData, MeasurementData, MeasurementMouseEvent } from "../types";
+declare const BaseAnnotationTool: any;
 /**
  * @public
  * @class WwwcRemoveRegionTool
@@ -6,14 +8,10 @@
  * @classdesc Tool for setting wwwc based on a rectangular region.
  * @extends Tools.Base.BaseTool
  */
-export default class WwwcRemoveRegionTool {
+export default class WwwcRemoveRegionTool extends BaseAnnotationTool {
+    static [x: string]: any;
     constructor(props?: {});
-    dataHandles: any[];
-    element: any;
-    _drawingMouseUpCallback: (evt: any) => void;
-    _editMouseUpCallback: (evt: any) => void;
-    throttledUpdateCachedStats: any;
-    createNewMeasurement(eventData: any): {
+    createNewMeasurement(eventData: EventData): {
         computeMeasurements: any;
         visible: boolean;
         active: boolean;
@@ -21,18 +19,18 @@ export default class WwwcRemoveRegionTool {
         invalidated: boolean;
         handles: {
             start: {
-                x: any;
-                y: any;
+                x: number;
+                y: number;
                 highlight: boolean;
                 active: boolean;
             };
             end: {
-                x: any;
-                y: any;
+                x: number;
+                y: number;
                 highlight: boolean;
                 active: boolean;
             };
-            initialRotation: any;
+            initialRotation: number;
             textBox: {
                 active: boolean;
                 hasMoved: boolean;
@@ -43,20 +41,18 @@ export default class WwwcRemoveRegionTool {
             };
         };
     } | undefined;
-    originalWW: any;
-    originalWC: any;
-    pointNearTool(element: any, data: any, coords: any, interactionType: any): boolean;
-    updateCachedStats(image: any, element: any, data: any): void;
-    renderToolData(evt: any): void;
-    mode: any;
-    _withinHandleBoxes(startCanvas: any, endCanvas: any): boolean;
+    pointNearTool(element: Element, data: MeasurementData, coords: Coords, interactionType: string): boolean;
+    updateCachedStats(image: cornerstone.Image, element: Element, data: MeasurementData): void;
+    renderToolData(evt: MeasurementMouseEvent): void;
+    _withinHandleBoxes(startCanvas: Coords, endCanvas: Coords): boolean;
     /**
      * 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
+     * @param {MeasurementMouseEvent} evt Interaction event emitted by an enabledElement
      * @returns {void}
      */
-    private _applyStrategy;
+    _applyStrategy(evt: MeasurementMouseEvent): void;
 }
+export {};