larvitar 1.5.13 → 2.0.0

package/dist/imaging/imageAnonymization.d.ts

@@ -0,0 +1,12 @@
+/** @module imaging/imageAnonymization
+ *  @desc This file provides anonymization functionalities on DICOM images
+ * following http://dicom.nema.org/medical/dicom/current/output/html/part15.html#chapter_E
+ */
+import { Series } from "./types";
+/**
+ * Anonymize DICOM series' metadata using sha256
+ * @function anonymize
+ * @param {Object} series - Cornerstone series object
+ * @returns {Object} anonymized_series: Cornerstone anonymized series object
+ */
+export declare const anonymize: (series: Series) => Series;

package/dist/imaging/imageColormaps.d.ts

@@ -0,0 +1,47 @@
+/** @module imaging/imageColormaps
+ *  @desc  This file provides functionalities for
+ *         handling colormaps
+ */
+/**
+ * Fill a canvas with pixelData representing the colormap
+ * @instance
+ * @function getColormapsList
+ * @returns {Array} A list of cornerstone colormaps
+ */
+export declare function getColormapsList(): {
+    id: any;
+    key: any;
+}[];
+/**
+ * Add a custom color map to cornerstone list
+ * @instance
+ * @function addColorMap
+ * @param {String} colormapId - the new colormap id
+ * @param {String} colormapName - the new colormap name
+ * @param {Array} colors - array containing 255 rgb colors (ie [[r,g,b], [r,g,b], ...])
+ */
+export declare function addColorMap(colormapId: string, colormapName: string, colors: Array<Array<number>>): any;
+/**
+ * Fill a canvas with pixelData representing the colormap
+ * @instance
+ * @function fillPixelData
+ * @param {HTMLCanvasElement} canvas - target canvas
+ * @param {String} colormapId - the colormap name
+ */
+export declare function fillPixelData(canvas: HTMLCanvasElement, colormapId: string): void;
+/**
+ * Apply a color map on a viewport
+ * @instance
+ * @function applyColorMap
+ * @param {String} colormapId - the colormap name
+ * @param {Array} viewportNames - List of viewports where to apply preset
+ */
+export declare function applyColorMap(colormapId: string, viewportNames?: Array<string>): any;
+/**
+ * Converts an HSV  (Hue, Saturation, Value) color to RGB (Red, Green, Blue) color value
+ * @param {Number} hue A number representing the hue color value
+ * @param {Number} sat A number representing the saturation color value
+ * @param {Number} val A number representing the value color value
+ * @returns {Number[]} An RGB color array
+ */
+export declare function HSVToRGB(hue: number, sat: number, val: number): number[];

package/dist/imaging/imageContours.d.ts

@@ -0,0 +1,18 @@
+/** @module imaging/imageContours
+ *  @desc This file provides functionalities to render a set of points on a canvas.
+ *        Use this in order to render image contours (e.g. from binary masks).
+ */
+import { Contours } from "./types";
+/**
+ * Parse raw data to contours object for each viewport
+ * @export
+ * @function parseContours
+ * @param {Array} contoursData - Raw data
+ * @param {Number} pointBatchSize - Number of points that defines a contour segment (default to 2)
+ * @param {String} segmentationName - Mask object name
+ * @param {Array} viewports - Viewport array ids
+ * @returns {Number} Number of array elements consumed
+ */
+export declare const parseContours: (contoursData: {
+    [key: string]: Uint8Array;
+}, pointBatchSize: number, segmentationName: string, viewports: Array<string>) => Contours;

package/dist/imaging/imageIo.d.ts

@@ -0,0 +1,42 @@
+/** @module imaging/imageIo
+ *  @desc This file provides I/O functionalities on NRRD files and DICOM images
+ */
+import { Series, Header, TypedArray } from "./types";
+/**
+ * Build the image header from slices' metadata
+ * @function buildHeader
+ * @param {Object} series - Cornerstone series object
+ * @returns {Object} header: image metadata
+ */
+export declare const buildHeader: (series: Series) => Header;
+/**
+ * Get cached pixel data
+ * @function getCachedPixelData
+ * @param {String} imageId - ImageId of the cached image
+ * @returns {Promise} A promise which will resolve to a pixel data array or fail if an error occurs
+ */
+export declare const getCachedPixelData: (imageId: string) => Promise<number[]>;
+/**
+ * Build the contiguous typed array from slices
+ * @function buildData
+ * @param {Object} series - Cornerstone series object
+ * @param {Bool} useSeriesData - Flag to force using "series" data instead of cached ones
+ * @returns {Array} Contiguous pixel array
+ */
+export declare const buildData: (series: Series, useSeriesData: boolean) => Uint16Array | Float64Array | Uint8Array | Int8Array | Int16Array | Int32Array | Uint32Array | Float32Array | undefined;
+/**
+ * Build the contiguous typed array from slices (async version)
+ * @function buildDataAsync
+ * @param {Object} series - Cornerstone series object
+ * @param {Number} time - Time(s) to wait for garbage collector
+ * @param {Function} resolve - Promise resolve function
+ * @param {Function} reject - Promise reject function
+ */
+export declare const buildDataAsync: (series: Series, time: number, resolve: (response: TypedArray) => void, reject: (response: string) => void) => void;
+/**
+ * Import NRRD image from bufferArray
+ * @function importNRRDImage
+ * @param {ArrayBuffer} bufferArray - buffer array from nrrd file
+ * @returns {Array} Parsed pixel data array
+ */
+export declare const importNRRDImage: (bufferArray: ArrayBuffer) => Object;

package/dist/imaging/imageLayers.d.ts

@@ -0,0 +1,56 @@
+/** @module imaging/imageLayers
+ *  @desc This file provides functionalities for
+ *        rendering image layers using cornerstone stack
+ */
+import { Series } from "./types";
+/**
+ * Build the image layers object
+ * @function buildLayers
+ * @param {Object} series - Cornerstone series object
+ * @param {String} tag - Tag for the layer
+ * @param {Object} options - layer options {opacity:float, colormap: str}
+ * @returns {Object} Cornerstone layer object
+ */
+export declare const buildLayer: (series: Series, tag: string, options: {
+    opacity: number;
+    colormap: string;
+}) => {
+    imageIds: string[];
+    currentImageIdIndex: number;
+    options: {
+        name: string;
+        opacity: number;
+        visible: boolean;
+        viewport: {
+            colormap: string;
+        };
+    };
+};
+/**
+ * Change the options of a layer
+ * @instance
+ * @function updateLayer
+ * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
+ * @param {string} layer - The layer id
+ * @param {Object} options - The new layer's options
+ */
+export declare const updateLayer: (elementId: string | HTMLElement, layerId: string, options: {
+    opacity: number;
+    colormap: string;
+}) => void;
+/**
+ * Get the active layer
+ * @instance
+ * @function getActiveLayer
+ * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
+ * @returns {Object} layer - The active layer object
+ */
+export declare const getActiveLayer: (elementId: string | HTMLElement) => import("cornerstone-core").EnabledElementLayer | undefined;
+/**
+ * Set the active layer
+ * @instance
+ * @function setActiveLayer
+ * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
+ * @param {String} layerId - The id of the layer
+ */
+export declare const setActiveLayer: (elementId: string | HTMLElement, layerId: string) => void;

package/dist/imaging/imageLoading.d.ts

@@ -0,0 +1,65 @@
+/** @module imaging/imageLoading
+ *  @desc This file provides functionalities for
+ *        initialize, configure and update DICOMImageLoader
+ */
+import { ImageObject } from "./types";
+import { getLarvitarManager } from "./loaders/commonLoader";
+declare const globalConfig: {
+    maxWebWorkers: number;
+    startWebWorkersOnDemand: boolean;
+    taskConfiguration: {
+        decodeTask: {
+            loadCodecsOnStartup: boolean;
+            initializeCodecsOnStartup: boolean;
+            strict: boolean;
+        };
+    };
+};
+/**
+ * Configure DICOMImageLoader
+ * @instance
+ * @function initializeImageLoader
+ * @param {Object} config - Custom config @default globalConfig
+ */
+export declare const initializeImageLoader: (config?: typeof globalConfig) => void;
+/**
+ * Configure cornerstoneWebImageLoader
+ * @instance
+ * @function initializeWebImageLoader
+ */
+export declare const initializeWebImageLoader: () => void;
+/**
+ * Configure cornerstoneFileImageLoader
+ * @instance
+ * @function initializeFileImageLoader
+ */
+export declare const initializeFileImageLoader: () => void;
+/**
+ * Register custom NRRD ImageLoader
+ * @instance
+ * @function registerNRRDImageLoader
+ */
+export declare const registerNRRDImageLoader: () => void;
+/**
+ * Register custom Reslice ImageLoader
+ * @instance
+ * @function registerResliceLoader
+ */
+export declare const registerResliceLoader: () => void;
+/**
+ * Register custom MultiFrame ImageLoader
+ * @instance
+ * @function registerMultiFrameImageLoader
+ */
+export declare const registerMultiFrameImageLoader: () => void;
+/**
+ * Update the allSeriesStack object using DICOMImageLoader fileManager
+ * @instance
+ * @function updateLoadedStack
+ * @param {Object} seriesData - Cornerstone series object
+ * @param {Object} allSeriesStack - Dict containing all series objects
+ * @param {String} customId - Optional custom id to overwrite seriesUID as default one
+ * @param {number} sliceIndex - Optional custom index to overwrite slice index as default one
+ */
+export declare const updateLoadedStack: (seriesData: ImageObject, allSeriesStack: ReturnType<typeof getLarvitarManager>, customId?: string, sliceIndex?: number) => void;
+export {};

package/dist/imaging/imageParsing.d.ts

@@ -0,0 +1,46 @@
+/** @module imaging/imageParsing
+ *  @desc  This file provides functionalities for parsing DICOM image files
+ */
+import { DataSet } from "dicom-parser";
+import { ImageObject } from "./types";
+import { getLarvitarManager } from "./loaders/commonLoader";
+import type { MetaDataTypes } from "./MetaDataTypes";
+/**
+ * Reset series stack object and its internal data
+ * @instance
+ * @function clearImageParsing
+ * @param {Object} seriesStack - Parsed series stack object
+ */
+export declare const clearImageParsing: (seriesStack: ReturnType<typeof getLarvitarManager> | null) => void;
+/**
+ * Read dicom files and return allSeriesStack object
+ * @instance
+ * @function readFiles
+ * @param {Array} entries - List of file objects
+ * @returns {Promise} - Return a promise which will resolve to a image object list or fail if an error occurs
+ */
+export declare const readFiles: (entries: File[]) => Promise<unknown>;
+/**
+ * Read a single dicom file and return parsed object
+ * @instance
+ * @function readFile
+ * @param {File} entry - File object
+ * @returns {Promise} - Return a promise which will resolve to a image object or fail if an error occurs
+ */
+export declare const readFile: (entry: File) => Promise<ImageObject>;
+type ExtendedMetaDataTypes = MetaDataTypes & {
+    [key: string]: unknown;
+};
+/**
+ * Parse metadata from dicom parser dataSet object
+ * @instance
+ * @function parseDataSet
+ * @param {Object} dataSet - dicom parser dataSet object
+ * @param {Object} metadata - Initialized metadata object
+ * @param {Array} customFilter - Optional filter: {tags:[], frameId: 0}
+ */
+export declare const parseDataSet: (dataSet: DataSet, metadata: ExtendedMetaDataTypes, customFilter?: {
+    tags: string[];
+    frameId: number;
+}) => void;
+export {};

package/dist/imaging/imagePresets.d.ts

@@ -0,0 +1,43 @@
+/** @module imaging/imagePresets
+ *  @desc  This file provides functionalities for
+ *         image presets for ww and wc
+ */
+/**
+ * Object used to list image presets
+ * @object
+ */
+declare const IMAGE_PRESETS: {
+    name: string;
+    ww: number;
+    wl: number;
+}[];
+/**
+ * Get Image presets object
+ * @instance
+ * @function getImagePresets
+ */
+export declare const getImagePresets: () => {
+    name: string;
+    ww: number;
+    wl: number;
+}[];
+/**
+ * Set Image presets
+ * @instance
+ * @function setImagePreset
+ * @param {Array} viewportNames - List of viewports where to apply preset
+ * @param {String} preset - The image preset name or the preset object
+ */
+export declare const setImagePreset: (viewportNames: string[], preset: string | (typeof IMAGE_PRESETS)[0]) => void;
+/**
+ * Set Image presets
+ * @instance
+ * @function setImageCustomPreset
+ * @param {Array} viewportNames - List of viewports where to apply preset
+ * @param {Object} customValues - {wl: value, ww: value}
+ */
+export declare const setImageCustomPreset: (viewportNames: string[], customValues: {
+    wl: number;
+    ww: number;
+}) => void;
+export {};

package/dist/imaging/imageRendering.d.ts

@@ -0,0 +1,238 @@
+/** @module imaging/imageRendering
+ *  @desc  This file provides functionalities for
+ *         rendering images in html canvas using cornerstone
+ */
+import cornerstone from "cornerstone-core";
+import { Image, Series, StoreViewportOptions, Viewport } from "./types";
+/**
+ * Purge the cornestone internal cache
+ * If seriesId is passed as argument only imageIds of the series are purged from internal cache
+ * @instance
+ * @function clearImageCache
+ * @param {String} seriesId - The id of the serie
+ */
+export declare const clearImageCache: (seriesId?: string) => void;
+/**
+ * Load and cache a single image
+ * Add series's imageIds into store
+ * @instance
+ * @function loadAndCacheImage
+ * @param {Object} series the parsed series data
+ * @param {number} imageIndex the image index in the imageIds array
+ */
+export declare function loadAndCacheImage(series: Series, imageIndex: number): Promise<true>;
+/**
+ * Load and cache all serie's images
+ * Add series's imageIds into store
+ * @instance
+ * @function loadAndCacheImages
+ * @param {Object} series the parsed series data
+ * @param {Function} callback a callback function
+ */
+export declare function loadAndCacheImages(series: Series, callback: (payload: {
+    seriesId: string;
+    loading: number;
+    series: Series;
+}) => any): void;
+/**
+ * Render a PDF from a DICOM Encapsulated PDF
+ * @instance
+ * @function renderDICOMPDF
+ * @param {Object} seriesStack - The original series data object
+ * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
+ * @returns {Promise} - Return a promise which will resolve when pdf is displayed
+ */
+export declare const renderDICOMPDF: (seriesStack: Series, elementId: string | HTMLElement) => Promise<true>;
+/**
+ * Render an image (png or jpg) from File on a html div using cornerstone
+ * @instance
+ * @function renderFileImage
+ * @param {Object} file - The image File object
+ * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
+ * @returns {Promise} - Return a promise which will resolve when image is displayed
+ */
+export declare const renderFileImage: (file: File, elementId: string | HTMLElement) => Promise<unknown> | undefined;
+/**
+ * Render an image (png or jpg) from web url on a html div using cornerstone
+ * @instance
+ * @function renderWebImage
+ * @param {String} url - The image data url
+ * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
+ * @returns {Promise} - Return a promise which will resolve when image is displayed
+ */
+export declare const renderWebImage: (url: string, elementId: string | HTMLElement) => Promise<cornerstone.Image>;
+/**
+ * Unrender an image on a html div using cornerstone
+ * @instance
+ * @function disableViewport
+ * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
+ */
+export declare const disableViewport: (elementId: string | HTMLElement) => void;
+/**
+ * Unrender an image on a html div using cornerstone
+ * Remove image from cornerstone cache and remove from store
+ * @instance
+ * @function unloadViewport
+ * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
+ * @param {String} seriesId - The id of the serie
+ */
+export declare const unloadViewport: (elementId: string, seriesId: string) => void;
+/**
+ * Resize a viewport using cornerstone resize
+ * And forcing fit to window
+ * @instance
+ * @function resizeViewport
+ * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
+ */
+export declare const resizeViewport: (elementId: string | HTMLElement) => void;
+/**
+ * Cache image and render it in a html div using cornerstone
+ * @instance
+ * @function renderImage
+ * @param {Object} seriesStack - The original series data object
+ * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
+ * @param {Object} defaultProps - Optional default props
+ * @return {Promise} Return a promise which will resolve when image is displayed
+ */
+export declare const renderImage: (seriesStack: Series, elementId: string | HTMLElement, defaultProps: StoreViewportOptions) => Promise<true>;
+/**
+ * Update the cornerstone image with new imageIndex
+ * @instance
+ * @function updateImage
+ * @param {Object} series - The original series data object
+ * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
+ * @param {Number} imageIndex - The index of the image to be rendered
+ * @param {Boolean} cacheImage - A flag to handle image cache
+ */
+export declare const updateImage: (series: Series, elementId: string | HTMLElement, imageIndex: number, cacheImage: boolean) => Promise<void>;
+/**
+ * Reset viewport values (scale, translation and wwwc)
+ * @instance
+ * @function resetViewports
+ * @param {Array} elementIds - The array of hmtl div ids
+ * @param {Array} keys - The array of viewport sections to resets (default is all)
+ */
+export declare const resetViewports: (elementIds: string[], keys?: Array<"contrast" | "scaleAndTranslation" | "rotation" | "flip" | "zoom">) => void;
+/**
+ * Update viewport data in store
+ * @instance
+ * @function updateViewportData
+ * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
+ * @param {Object} viewportData - The new viewport data
+ */
+export declare const updateViewportData: (elementId: string, viewportData: Viewport, activeTool: string) => void;
+/**
+ * Store the viewport data into internal storage
+ * @instance
+ * @function storeViewportData
+ * @param {Object} image - The cornerstone image frame
+ * @param {String} elementId - The html div id used for rendering
+ * @param {String} viewport - The viewport tag name
+ * @param {Object} data - The viewport data object
+ */
+export declare const storeViewportData: (image: cornerstone.Image, elementId: string, viewport: Viewport, data: ReturnType<typeof getSeriesData>) => void;
+/**
+ * Invert pixels of an image
+ * @instance
+ * @function invertImage
+ * @param {Object} elementId - The html div id used for rendering or its DOM HTMLElement
+ */
+export declare const invertImage: (elementId: string | HTMLElement) => void;
+/**
+ * Flip image around horizontal axis
+ * @instance
+ * @function flipImageHorizontal
+ * @param {Object} elementId - The html div id used for rendering or its DOM HTMLElement
+ */
+export declare const flipImageHorizontal: (elementId: string | HTMLElement) => void;
+/**
+ * Flip image around vertical axis
+ * @instance
+ * @function flipImageVertical
+ * @param {Object} elementId - The html div id used for rendering or its DOM HTMLElement
+ */
+export declare const flipImageVertical: (elementId: string | HTMLElement) => void;
+/**
+ * Rotate image by 90° in left direction
+ * @instance
+ * @function rotateImageLeft
+ * @param {Object} elementId - The html div id used for rendering or its DOM HTMLElement
+ */
+export declare const rotateImageLeft: (elementId: string | HTMLElement) => void;
+/**
+ * Rotate image by 90° in right direction
+ * @instance
+ * @function rotateImageRight
+ * @param {Object} elementId - The html div id used for rendering or its DOM HTMLElement
+ */
+export declare const rotateImageRight: (elementId: string | HTMLElement) => void;
+/**
+ * Get series metadata from default props and series' metadata
+ * @instance
+ * @function getSeriesData
+ * @param {Object} series - The parsed data series
+ * @param {Object} defaultProps - Optional default properties
+ * @return {Object} data - A data dictionary with parsed tags' values
+ */
+declare const getSeriesData: (series: Series, defaultProps: StoreViewportOptions) => {
+    loading: number;
+    ready: boolean;
+    minSliceId: number;
+    maxSliceId: number;
+    sliceId: number;
+    pendingSliceId?: number | undefined;
+    minTimeId: number;
+    maxTimeId: number;
+    timeId: number;
+    timestamp: number;
+    timestamps: number[];
+    timeIds: number[];
+    rows: number;
+    cols: number;
+    spacing_x: number;
+    spacing_y: number;
+    thickness: number;
+    minPixelValue: number;
+    maxPixelValue: number;
+    isColor: boolean;
+    isMultiframe: boolean;
+    isTimeserie: boolean;
+    isPDF: boolean;
+    viewport: {
+        scale: number;
+        rotation: number;
+        translation: {
+            x: number;
+            y: number;
+        };
+        voi: {
+            windowCenter: number;
+            windowWidth: number;
+        };
+        rows: number;
+        cols: number;
+        spacing_x: number;
+        spacing_y: number;
+        thickness: number;
+    };
+    default: {
+        scale: number;
+        rotation: number;
+        translation: {
+            x: number;
+            y: number;
+        };
+        voi: {
+            windowCenter: number;
+            windowWidth: number;
+            invert: boolean;
+        };
+    };
+} & {
+    imageIndex: number;
+    imageId: string;
+    numberOfSlices: number;
+    numberOfTemporalPositions: number;
+    timeIndex?: number | undefined;
+};
+export {};

package/dist/imaging/imageReslice.d.ts

@@ -0,0 +1,14 @@
+/** @module imaging/imageReslice
+ *  @desc  This file provides functionalities for
+ *         image reslice in orthogonal directions
+ */
+import { Series } from "./types";
+/**
+ * Reslice a serie from native orientation to coronal or sagittal orientation
+ * @instance
+ * @function resliceSeries
+ * @param {Object} seriesData the original series data
+ * @param {String} orientation the reslice orientation [coronal or sagittal]
+ * @returns {Promise} - Return a promise which will resolve when data is available
+ */
+export declare function resliceSeries(seriesData: Series, orientation: "axial" | "coronal" | "sagittal"): Promise<unknown>;