larvitar 1.5.14 → 2.0.2

package/dist/imaging/imageStore.d.ts

@@ -0,0 +1,121 @@
+/** @module imaging/imageStore
+ *  @desc This file provides functionalities
+ *        for data config store.
+ */
+type StoreSeries = {
+    imageIds: string[];
+    progress: number;
+};
+type Store = {
+    colormapId: string;
+    errorLog: string;
+    leftActiveTool?: string;
+    rightActiveTool?: string;
+    series: {
+        [seriesUID: string]: StoreSeries;
+    };
+    viewports: {
+        [key: string]: typeof DEFAULT_VIEWPORT;
+    };
+    [key: string]: any;
+};
+type SetPayload = ["errorLog" | "leftActiveTool" | "rightActiveTool", string] | [
+    "isColor" | "isMultiframe" | "isPDF" | "isTimeserie" | "ready",
+    string,
+    boolean
+] | [
+    ("progress" | "loading" | "minPixelValue" | "maxPixelValue" | "minSliceId" | "maxSliceId" | "minTimeId" | "maxTimeId" | "rotation" | "scale" | "sliceId" | "timeId" | "thickness"),
+    string,
+    number
+] | ["timestamp", string, number | undefined] | ["pendingSliceId", string, number | undefined] | ["timestamps" | "timeIds", string, number[]] | [
+    "contrast" | "dimensions" | "spacing" | "translation",
+    string,
+    number,
+    number
+] | [
+    "defaultViewport",
+    string,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    boolean
+];
+export declare const DEFAULT_VIEWPORT: {
+    loading: number;
+    ready: boolean;
+    minSliceId: number;
+    maxSliceId: number;
+    sliceId: number;
+    pendingSliceId?: number;
+    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;
+        };
+    };
+};
+export type Viewport = typeof DEFAULT_VIEWPORT;
+export declare const set: (payload: SetPayload) => void;
+declare const _default: {
+    initialize: () => void;
+    addViewport: (name: string) => void;
+    deleteViewport: (name: string) => void;
+    addSeriesId: (seriesId: string, imageIds: string[]) => void;
+    removeSeriesId: (seriesId: string) => void;
+    resetSeriesIds: () => void;
+    setSliceId: (elementId: string, imageIndex: number) => void;
+    setPendingSliceId: (elementId: string, imageIndex: number) => void;
+    setMaxSliceId: (elementId: string, imageIndex: number) => void;
+    get: (props: string | string[]) => any;
+    addStoreListener: (listener: (data: Store) => {}) => (data: Store) => {};
+    removeStoreListener: () => undefined;
+    addViewportListener: (elementId: string, listener: (data: typeof DEFAULT_VIEWPORT) => {}) => void;
+    removeViewportListener: (elementId: string) => void;
+    addSeriesListener: (seriesId: string, listener: (data: StoreSeries) => {}) => void;
+    removeSeriesListener: (seriesId: string) => void;
+};
+export default _default;

package/dist/imaging/imageTags.d.ts

@@ -0,0 +1,22 @@
+import { DataSet, Element } from "dicom-parser";
+/**
+ * Parse a DICOM Tag according to its type
+ * @instance
+ * @function parseTag
+ * @param {Object} dataSet - The parsed dataset object from dicom parser
+ * @param {String} propertyName - The tag name
+ * @param {Object} element - The parsed dataset element
+ * @return {String} - The DICOM Tag value
+ */
+export declare function parseTag<T>(dataSet: DataSet, propertyName: string, //x0000000 string
+element: Element): Element | T | undefined;
+/**
+ * Extract tag value according to its value rapresentation, see
+ * {@link http://dicom.nema.org/dicom/2013/output/chtml/part05/sect_6.2.html}
+ * @instance
+ * @function getTagValue
+ * @param {Object} dataSet - the dataset
+ * @param {String} tag - the desired tag key
+ * @return {Number | Array | String} - the desired tag value
+ */
+export declare const getTagValue: (dataSet: DataSet, tag: string) => any;

package/dist/imaging/imageTools.d.ts

@@ -0,0 +1,20 @@
+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;

package/dist/imaging/imageUtils.d.ts

@@ -0,0 +1,165 @@
+/** @module imaging/imageUtils
+ *  @desc This file provides utility functions for
+ *        manipulating image pixels and image metadata
+ */
+import type { CustomDataSet, MetaData, ReslicedInstance, Series } from "./types";
+import { MetaDataTypes } from "./MetaDataTypes";
+/**
+ * @typedef {Object} CornerstoneSeries
+ * @property {Array} imageIds Array of the instances imageIds
+ * @property {Array} instances Array of instances
+ * @property {Number} currentImageIndex Currently loaded image id index in the imageIds array
+ */
+/**
+ * Return computed 3D normal from two 3D vectors
+ * @instance
+ * @function getNormalOrientation
+ * @param {Array} el - The image_orientation dicom tag
+ */
+export declare const getNormalOrientation: (el: [number, number, number, number, number, number]) => number[];
+/**
+ * If a value is provided, returns it, otherwise get the min pixel value from pixelData
+ * @instance
+ * @function getMinPixelValue
+ * @param {Number} value - The min value
+ * @param {Array} pixelData - Pixel data array
+ */
+export declare const getMinPixelValue: (value: number, pixelData: Uint16Array) => number | undefined;
+/**
+ * If a value is provided, returns it, otherwise get the max pixel value from pixelData
+ * @instance
+ * @function getMaxPixelValue
+ * @param {Number} value - The max value
+ * @param {Array} pixelData - Pixel data array
+ */
+export declare const getMaxPixelValue: (value: string, pixelData: Uint16Array) => string | number | undefined;
+/**
+ * Create the pixel representation string (type and length) from dicom tags
+ * @instance
+ * @function getPixelRepresentation
+ * @param {Object} dataSet - The dataset
+ * @returns {String} The pixel representation in the form Sint / Uint + bytelength
+ */
+export declare const getPixelRepresentation: (dataSet: CustomDataSet) => string;
+/**
+ * Get a typed array from a representation type
+ * @instance
+ * @function getTypedArrayFromDataType
+ * @param {Object} dataType - The data type
+ * @returns {TypedArray} The typed array
+ */
+export declare const getTypedArrayFromDataType: (dataType: string) => Uint8ArrayConstructor | Int8ArrayConstructor | Uint16ArrayConstructor | Int16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor | null;
+/**
+ * Sort the array of images ids of a series trying with:
+ * - content time order, if the series has cardiacNumberOfImages tag > 1
+ * - position order, if series has needed patient position tags
+ * - instance order, if series has instance numbers tags
+ * The priority of the method depends on the instanceSortPriority value
+ * @instance
+ * @function getSortedStack
+ * @param {Object} seriesData - The dataset
+ * @param {Array} sortPriorities - An array which represents the priority tasks
+ * @param {Bool} returnSuccessMethod - Boolean for returning the success method
+ * @return {Object} The sorted stack
+ */
+export declare const getSortedStack: (seriesData: Series, sortPriorities: Array<"imagePosition" | "contentTime" | "instanceNumber">, returnSuccessMethod: boolean) => string[];
+/**
+ * Sort the array of instanceUIDs according to imageIds sorted using sortSeriesStack
+ * @instance
+ * @function getSortedUIDs
+ * @param {Object} seriesData - The dataset
+ * @return {Object} The sorted instanceUIDs
+ */
+export declare const getSortedUIDs: (seriesData: Series) => {
+    [key: string]: string;
+};
+/**
+ * Generate a randomUUID in the form 'uy0x2qz9jk9co642cjfus'
+ * @instance
+ * @function randomId
+ * @return {String} - Random uid
+ */
+export declare const randomId: () => string;
+/**
+ * Get the mean value of a specified dicom tag in a serie
+ * @instance
+ * @function getMeanValue
+ * @param {Object} series - The cornerstone series object
+ * @param {Object} tag - The target tag key
+ * @param {Bool} isArray - True if tag value is an array
+ * @return {Number} - Tag mean value
+ */
+export declare const getMeanValue: (series: Series, tag: keyof MetaData, isArray: boolean) => number | number[];
+/**
+ * Compute resliced metadata from a cornerstone data structure
+ * @instance
+ * @function getReslicedMetadata
+ * @param {String} reslicedSeriesId - The id of the resliced serie
+ * @param {String} fromOrientation - Source orientation (eg axial, coronal or sagittal)
+ * @param {String} toOrientation - Target orientation (eg axial, coronal or sagittal)
+ * @param {Object} seriesData - The original series data
+ * @param {String} imageLoaderName - The registered loader name
+ * @return {Object} - Cornerstone series object, filled only with metadata
+ */
+export declare const getReslicedMetadata: (reslicedSeriesId: string, fromOrientation: "axial" | "coronal" | "sagittal", toOrientation: "axial" | "coronal" | "sagittal", seriesData: Series, imageLoaderName: string) => {
+    imageIds: string[];
+    instances: {
+        [key: string]: ReslicedInstance;
+    };
+    currentImageIdIndex: number;
+};
+/**
+ * Compute cmpr metadata from pyCmpr data (generated using Scyther {@link https://github.com/dvisionlab/Scyther})
+ * @instance
+ * @function getCmprMetadata
+ * @param {String} reslicedSeriesId - The id of the resliced serie
+ * @param {String} imageLoaderName - The registered loader name
+ * @param {Object} header - The header of the resliced serie from Scyther
+ * @return {Object} - Cornerstone series object, filled only with metadata
+ */
+export declare const getCmprMetadata: (reslicedSeriesId: string, imageLoaderName: string, header: any) => {
+    imageIds: string[];
+    instances: {
+        [key: string]: ReslicedInstance;
+    };
+};
+/**
+ * Get pixel data for a single resliced slice, from cornerstone data structure
+ * @instance
+ * @function getReslicedPixeldata
+ * @param {String} imageId - The id of the resulting image
+ * @param {Object} originalData - The original series data (source)
+ * @param {Object} reslicedData - The resliced series data (target)
+ * @return {Object} - A single resliced slice pixel array
+ */
+export declare const getReslicedPixeldata: (imageId: string, originalData: Series, reslicedData: Series) => Uint16Array | Float64Array | Uint8Array | Int8Array | Int16Array | Int32Array | Uint32Array | Float32Array;
+/**
+ * Get distance between two slices
+ * @instance
+ * @function getDistanceBetweenSlices
+ * @param {Object} seriesData - The series data
+ * @param {Number} sliceIndex1 - The first slice index
+ * @param {Number} sliceIndex2 - The second slice index
+ * @return {Number} - The distance value
+ */
+export declare const getDistanceBetweenSlices: (seriesData: Series, sliceIndex1: number, sliceIndex2: number) => number | undefined;
+/**
+ * @instance
+ * @function getImageMetadata
+ * @param {String} seriesId - The seriesUID
+ * @param {String} instanceUID - The SOPInstanceUID
+ * @return {Array} - List of metadata objects: tag, name and value
+ */
+export declare const getImageMetadata: (seriesId: string, instanceUID: string) => {
+    tag: string;
+    name: string;
+    value: string | number | number[] | MetaDataTypes[] | null | undefined;
+}[];
+/**
+ * Check if a div tag is a valid DOM HTMLElement
+ * @instance
+ * @function isElement
+ * @param {Object} o - The div tag
+ * @return {Boolean} - True if is an element otherwise returns False
+ */
+export declare const isElement: (o: any) => any;

package/dist/imaging/loaders/commonLoader.d.ts

@@ -0,0 +1,103 @@
+/** @module loaders/commonLoader
+ *  @desc This file provides functionalities for
+ *        custom DICOMImageLoaders
+ */
+import { DataSet } from "dicom-parser";
+import type { ImageObject, MetaData, Series } from "../types";
+/**
+ * Update and initialize larvitar manager in order to parse and load a single dicom object
+ * @instance
+ * @function updateLarvitarManager
+ * @param {Object} imageObject The single dicom object
+ * @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 updateLarvitarManager: (imageObject: ImageObject, customId?: string, sliceIndex?: number) => {
+    [key: string]: Series | import("./nrrdLoader").NrrdSeries;
+};
+/**
+ * This function can be called in order to populate the Larvitar manager
+ * @instance
+ * @function populateLarvitarManager
+ * @param {String} seriesId The Id of the series
+ * @param {Object} seriesData The series data
+ * @returns {manager} the Larvitar manager
+ */
+export declare const populateLarvitarManager: (seriesId: string, seriesData: Series) => {
+    [key: string]: Series | import("./nrrdLoader").NrrdSeries;
+};
+/**
+ * Return the common data loader manager
+ * @instance
+ * @function getLarvitarManager
+ * @returns {Object} the loader manager
+ */
+export declare const getLarvitarManager: () => {
+    [key: string]: Series | import("./nrrdLoader").NrrdSeries;
+};
+/**
+ * Return the common image tracker
+ * @instance
+ * @function getLarvitarImageTracker
+ * @returns {Object} the image tracker
+ */
+export declare const getLarvitarImageTracker: () => {
+    [key: string]: string;
+};
+/**
+ * Reset the Larvitar Manager store
+ * @instance
+ * @function resetLarvitarManager
+ */
+export declare const resetLarvitarManager: () => void;
+/**
+ * Remove a stored seriesId from the larvitar Manager
+ * @instance
+ * @function removeSeriesFromLarvitarManager
+ * @param {String} seriesId The Id of the series
+ */
+export declare const removeSeriesFromLarvitarManager: (seriesId: string) => void;
+/**
+ * Return the data of a specific seriesId stored in the DICOM Manager
+ * @instance
+ * @function getSeriesDataFromLarvitarManager
+ * @param {String} seriesId The Id of the series
+ * @return {Object} larvitar manager data
+ */
+export declare const getSeriesDataFromLarvitarManager: (seriesId: string) => Series | import("./nrrdLoader").NrrdSeries | null;
+/**
+ * Compute and return image frame
+ * @instance
+ * @function getImageFrame
+ * @param {Object} metadata metadata object
+ * @param {Object} dataSet dicom dataset
+ * @returns {Object} specific image frame
+ */
+export declare const getImageFrame: (metadata: MetaData, dataSet: DataSet) => {
+    samplesPerPixel: any;
+    photometricInterpretation: any;
+    planarConfiguration: any;
+    rows: any;
+    columns: any;
+    bitsAllocated: any;
+    pixelRepresentation: any;
+    smallestPixelValue: any;
+    largestPixelValue: any;
+    redPaletteColorLookupTableDescriptor: any;
+    greenPaletteColorLookupTableDescriptor: any;
+    bluePaletteColorLookupTableDescriptor: any;
+    redPaletteColorLookupTableData: any;
+    greenPaletteColorLookupTableData: any;
+    bluePaletteColorLookupTableData: any;
+    pixelData: undefined;
+    ImageData: undefined;
+};
+/**
+ * Return the SOP Instance UID of a specific imageId stored in the Larvitar Manager
+ * @instance
+ * @function getSopInstanceUIDFromLarvitarManager
+ * @param {String} larvitarSeriesInstanceUID The Id of the series
+ * @param {String} imageId The Id of the image
+ * @returns {String} sopInstanceUID
+ */
+export declare const getSopInstanceUIDFromLarvitarManager: (larvitarSeriesInstanceUID: string, imageId: string) => string | null | undefined;

package/dist/imaging/loaders/dicomLoader.d.ts

@@ -0,0 +1,29 @@
+/** @module loaders/dicomLoader
+ *  @desc This file provides functionalities for
+ *        custom DICOM Loader
+ */
+import type { Series } from "../types";
+/**
+ * Load and cache a single image
+ * @instance
+ * @function cacheImage
+ * @param {Object} seriesData The series data
+ * @param {number} imageIndex The image index in the imageIds array
+ */
+export declare const cacheImage: (seriesData: Series, imageIndex: number) => Promise<true>;
+/**
+ * Load and cache images
+ * @instance
+ * @function cacheImages
+ * @param {Object} seriesData The series data
+ * @param {Function} callback Optional callback function
+ */
+export declare const cacheImages: (seriesData: Series, callback?: Function) => Promise<void>;
+/**
+ * Get the dicom imageId from dicom loader
+ * @instance
+ * @function getDicomImageId
+ * @param {String} dicomLoaderName dicom loader name
+ * @return {String} current dicom image id
+ */
+export declare const getDicomImageId: (dicomLoaderName: string) => string;

package/dist/imaging/loaders/fileLoader.d.ts

@@ -0,0 +1,33 @@
+/** @module loaders/fileLoader
+ *  @desc This file provides functionalities for
+ *        custom File Loader
+ */
+export declare var fileManager: {
+    [key: string]: string;
+};
+/**
+ * Reset the Custom File Loader
+ * @instance
+ * @function resetFileLoader
+ */
+export declare const resetFileLoader: () => void;
+/**
+ * Reset the File Manager store
+ * @instance
+ * @function resetFileManager
+ */
+export declare const resetFileManager: () => void;
+/**
+ * Populate File Manager
+ * @instance
+ * @function populateFileManager
+ * @return {String} current file image id
+ */
+export declare const populateFileManager: (file: File) => void;
+/**
+ * Get the file imageId from file loader
+ * @instance
+ * @function getFileImageId
+ * @return {String} current file image id
+ */
+export declare const getFileImageId: (file: File) => string | null;

package/dist/imaging/loaders/multiframeLoader.d.ts

@@ -0,0 +1,37 @@
+/** @module loaders/multiframeLoader
+ *  @desc This file is a custom DICOM loader for multiframe images
+ */
+import type { Image, Series } from "../types";
+/**
+ * Custom MultiFrame Loader Function
+ * @export
+ * @function loadMultiFrameImage
+ * @param {String} imageId - ImageId tag
+ * @returns {Function} Custom Image Creation Function
+ */
+export declare const loadMultiFrameImage: (imageId: string) => {
+    promise: Promise<Image>;
+};
+/**
+ * Build the multiframe layout in the larvitar Manager
+ * @export
+ * @function buildMultiFrameImage
+ * @param {String} seriesId - SeriesId tag
+ * @param {Object} serie - parsed serie object
+ */
+export declare const buildMultiFrameImage: (seriesId: string, serie: Series) => void;
+/**
+ * Get the custom imageId from custom loader
+ * @instance
+ * @function getMultiFrameImageId
+ * @param {String} customLoaderName The custom loader name
+ * @return {String} the custom image id
+ */
+export declare const getMultiFrameImageId: (customLoaderName: string) => string;
+/**
+ * Clear the multiframe cache
+ * @instance
+ * @function clearMultiFrameCache
+ * @param {String} seriesId - SeriesId tag
+ */
+export declare const clearMultiFrameCache: (seriesId: string) => void;

package/dist/imaging/loaders/nrrdLoader.d.ts

@@ -0,0 +1,113 @@
+/** @module loaders/nrrdLoader
+ *  @desc This file provides functionalities for
+ *        custom NRRD Loader
+ */
+import { ImageLoader } from "cornerstone-core";
+import type { Instance, Volume, MetaData } from "../types";
+import { DataSet } from "dicom-parser";
+type NrrdInputVolume = {
+    header: {
+        sizes: number[];
+        "space directions": number[][];
+        "space origin": [number, number];
+        kinds: string[];
+        type: string;
+    };
+    data: Uint16Array;
+};
+export type NrrdSeries = {
+    currentImageIdIndex: number;
+    imageIds: string[];
+    instances: {
+        [key: string]: Instance;
+    };
+    instanceUIDs: {
+        [key: string]: string;
+    };
+    numberOfImages: number;
+    seriesDescription: string;
+    seriesUID: string;
+    customLoader: string;
+    nrrdHeader: NrrdHeader;
+    bytes: number;
+    dataSet?: DataSet;
+    metadata?: MetaData;
+    ecgData?: number[];
+};
+type NrrdHeader = {
+    volume: Volume;
+    intercept: number;
+    slope: number;
+    repr: string;
+    phase: string;
+    study_description: string;
+    series_description: string;
+    acquisition_date: string;
+    [imageId: string]: string | number | Volume | NrrdInstance;
+};
+type NrrdInstance = {
+    instanceUID: string;
+    seriesDescription: string;
+    seriesModality: string;
+    patientName: string;
+    bitsAllocated: number;
+    pixelRepresentation: string;
+};
+/**
+ * Build the data structure for the provided image orientation
+ * @instance
+ * @function buildNrrdImage
+ * @param {Object} volume The volume object
+ * @param {String} seriesId The Id of the series
+ * @param {Object} custom_header A custom header object
+ * @return {Object} volume data
+ */
+export declare const buildNrrdImage: (volume: NrrdInputVolume, seriesId: string, custom_header: NrrdHeader) => Partial<NrrdSeries>;
+/**
+ * Get the custom imageId from custom loader
+ * @instance
+ * @function getNrrdImageId
+ * @param {String} customLoaderName The custom loader name
+ * @return {String} the custom image id
+ */
+export declare const getNrrdImageId: (customLoaderName: string) => string;
+/**
+ * Custom cornerstone image loader for nrrd files
+ * @instance
+ * @function loadNrrdImage
+ * @param {String} imageId The image id
+ * @return {Object} custom image object
+ */
+export declare const loadNrrdImage: ImageLoader;
+/**
+ * Retrieve imageId for a slice in the given orientation
+ * @instance
+ * @function getImageIdFromSlice
+ * @param {Integer} sliceNumber The image slice number
+ * @param {String} orientation The orientation tag
+ * @param {String} seriesId The series id
+ * @return {String} image id
+ */
+export declare const getImageIdFromSlice: (sliceNumber: number, orientation: string, seriesId: string) => string;
+/**
+ * Retrieve slice number for a the given orientation
+ * @instance
+ * @function getSliceNumberFromImageId
+ * @param {String} imageId The image slice id
+ * @param {String} orientation The orientation tag
+ * @param {String} seriesId The series id
+ * @return {Integer} The image slice number
+ */
+export declare const getSliceNumberFromImageId: (imageId: string, orientation: string) => number;
+/**
+ * Get series dimension for each view
+ * @instance
+ * @function getNrrdSerieDimensions
+ * @return {Object} Series dimension for each view
+ */
+export declare const getNrrdSerieDimensions: () => {
+    axial: number[];
+    coronal: number[];
+    sagittal: number[];
+};
+export {};

package/dist/imaging/loaders/resliceLoader.d.ts

@@ -0,0 +1,15 @@
+/** @module loaders/resliceLoader
+ *  @desc This file provides functionalities for
+ *        custom Reslice Loader
+ */
+import type { Image } from "../types";
+/**
+ * Custom Loader for DICOMImageLoader
+ * @instance
+ * @function loadReslicedImage
+ * @param {String} imageId The Id of the image
+ * @returns {Object} custom image object
+ */
+export declare const loadReslicedImage: (imageId: string) => {
+    promise: Promise<Image>;
+};