larvitar 4.0.0-alpha.2 → 4.0.0-alpha.20

package/dist/661.larvitar.js

@@ -1,5 +1,14 @@
-var larvitar;
-/******/ (() => { // webpackBootstrap
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else if(typeof exports === 'object')
+		exports["larvitar"] = factory();
+	else
+		root["larvitar"] = factory();
+})(self, () => {
+return /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
 /***/ 6221:
@@ -279,7 +288,8 @@ var larvitar;
 /******/ 	
 /******/ 	// run startup
 /******/ 	var __webpack_exports__ = __webpack_require__.x();
-/******/ 	larvitar = __webpack_exports__;
 /******/ 	
+/******/ 	return __webpack_exports__;
 /******/ })()
-;
+;
+});

package/dist/694.larvitar.js

@@ -1,5 +1,14 @@
-var larvitar;
-/******/ (() => { // webpackBootstrap
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else if(typeof exports === 'object')
+		exports["larvitar"] = factory();
+	else
+		root["larvitar"] = factory();
+})(self, () => {
+return /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
 /***/ 1234:
@@ -254,7 +263,8 @@ var larvitar;
 /******/ 	
 /******/ 	// run startup
 /******/ 	var __webpack_exports__ = __webpack_require__.x();
-/******/ 	larvitar = __webpack_exports__;
 /******/ 	
+/******/ 	return __webpack_exports__;
 /******/ })()
-;
+;
+});

package/dist/imaging/MetaDataTypes.d.ts

@@ -1,6 +1,7 @@
 export type ExtendedMetaDataTypes = MetaDataTypes & {
     [key: string]: unknown;
 };
+export declare const arrayTags: string[];
 export type MetaDataTypes = {
     x20000010?: number;
     x2000001e?: MetaDataTypes[];

package/dist/imaging/imageParsing.d.ts

@@ -4,7 +4,7 @@
 import { DataSet } from "dicom-parser";
 import { ImageObject, MetaData } from "./types";
 import { getImageManager } from "./imageManagers";
-import type { ExtendedMetaDataTypes } from "./MetaDataTypes";
+import { type ExtendedMetaDataTypes } from "./MetaDataTypes";
 /**
  * Reset series stack object and its internal data
  * @instance

package/dist/imaging/imageRendering.d.ts

@@ -3,7 +3,8 @@
  *         rendering images in html canvas using cornerstone
  */
 import cornerstone from "cornerstone-core";
-import { RenderProps, Series, StoreViewport, Viewport } from "./types";
+import { DisplayedArea, RenderProps, Series, StoreViewport, Viewport } from "./types";
+import { ViewportComplete } from "./tools/types";
 /**
  * Purge the cornestone internal cache
  * If seriesId is passed as argument only imageIds of the series are purged from internal cache
@@ -106,6 +107,23 @@ export declare const unloadViewport: (elementId: string) => void;
  * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
  */
 export declare const resizeViewport: (elementId: string | HTMLElement) => void;
+/**
+ * Check if the displayed image is anisotropic (row pixel spacing !== col pixel spacing)
+ * @instance
+ * @function isAnisotropic
+ * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
+ * @returns {Boolean}
+ */
+export declare const isAnisotropic: (elementId: string) => boolean;
+/**
+ * Retrieves Anisotropic Viewport displayedArea properties
+ * @instance
+ * @function getAnisotropicDisplayedArea
+ * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
+ * @param {ViewportComplete} viewport - The viewport
+ * @returns {DisplayedArea}
+ */
+export declare const getAnisotropicDisplayedArea: (id: string, viewport: ViewportComplete) => DisplayedArea | undefined;
 /**
  * Cache image and render it in a html div using cornerstone
  * @instance

package/dist/imaging/imageStore.d.ts

@@ -32,7 +32,7 @@ type SetPayload = ["errorLog" | "leftActiveTool" | "rightActiveTool", string] |
     ("progress" | "loading" | "minPixelValue" | "maxPixelValue" | "minSliceId" | "maxSliceId" | "minTimeId" | "maxTimeId" | "rotation" | "scale" | "sliceId" | "timeId" | "thickness" | "numberOfFrames" | "numberOfTemporalPositions"),
     string,
     number
-] | ["cached", string, string, boolean] | ["timestamp", string, number | undefined] | ["uniqueUID" | "modality", string, string | undefined] | ["pendingSliceId", string, number | undefined] | ["timestamps" | "timeIds", string, number[]] | ["pixelShift", string, number[] | undefined] | [
+] | ["cached", string, string, boolean] | ["timestamp", string, number | undefined] | ["uniqueUID" | "modality" | "filterName", string, string | undefined] | ["pendingSliceId", string, number | undefined] | ["timestamps" | "timeIds", string, number[]] | ["pixelShift", string, number[] | undefined] | [
     "contrast" | "dimensions" | "spacing" | "translation",
     string,
     number,
@@ -62,6 +62,7 @@ declare const _default: {
     setTimeId: (elementId: string, timeIndex: number) => void;
     setDSAEnabled: (elementId: string, enabled: boolean) => void;
     setDSAPixelShift: (elementId: string, pixelShift?: number[]) => void;
+    setImageFilter: (elementId: string, filterName: string) => void;
     resetActiveTools(): void;
     get: (props: string | string[] | undefined) => any;
     addStoreListener: (listener: (data: Store) => {}) => (data: Store) => {};

package/dist/imaging/imageUtils.d.ts

@@ -2,7 +2,7 @@
  *  @desc This file provides utility functions for
  *        manipulating image pixels and image metadata
  */
-import type { CustomDataSet, MetaData, ReslicedInstance, Series } from "./types";
+import type { CustomDataSet, MetaData, ReslicedInstance, Series, TypedArray } from "./types";
 /**
  * @typedef {Object} CornerstoneSeries
  * @property {Array} imageIds Array of the instances imageIds
@@ -16,20 +16,30 @@ import type { CustomDataSet, MetaData, ReslicedInstance, Series } from "./types"
  * @param {Array} el - The image_orientation dicom tag
  */
 export declare const getNormalOrientation: (el: [number, number, number, number, number, number]) => number[];
+/**
+ * Get the min and max pixel value from pixelData
+ * @instance
+ * @function getMinPixelValue
+ * @param {Array} pixelData - Pixel data array
+ */
+export declare const getMinMaxPixelValue: (pixelData: number[] | TypedArray) => {
+    minPixelValue: number;
+    maxPixelValue: number;
+};
 /**
  * Get the min pixel value from pixelData
  * @instance
  * @function getMinPixelValue
  * @param {Array} pixelData - Pixel data array
  */
-export declare const getMinPixelValue: (pixelData: number[]) => number;
+export declare const getMinPixelValue: (pixelData: number[] | TypedArray) => number;
 /**
  * Get the max pixel value from pixelData
  * @instance
  * @function getMaxPixelValue
  * @param {Array} pixelData - Pixel data array
  */
-export declare const getMaxPixelValue: (pixelData: number[]) => number;
+export declare const getMaxPixelValue: (pixelData: number[] | TypedArray) => number;
 /**
  * Create the pixel representation string (type and length) from dicom tags
  * @instance

package/dist/imaging/postProcessing/applyKernel.d.ts

@@ -0,0 +1,29 @@
+import { Image, TypedArray, KernelConfig } from "../types";
+/**
+ * Apply convolution filter to DICOM image
+ * @param {Object} loadedImage - The DICOM image object
+ * @param {string} filterName - Name of the filter to apply
+ * @param {number} multiplier - Optional multiplier for kernel values (default: 1)
+ * @returns {TypedArray} - Convolved pixel data
+ */
+export declare function applyConvolutionFilter(loadedImage: Image, filterName: string, generateImage?: boolean, multiplier?: number): Partial<Image> | TypedArray;
+/**
+ * Create the filtered image
+ * @param {string} name - Name for the new kernel
+ * @param {Object} config - Kernel configuration (modality, label, size, kernel)
+ * @returns {Partial<Image>} - Convolved pixel data
+ */
+export declare function createFilteredImage(loadedImage: Image, filteredPixelArray: number[]): Partial<Image>;
+/**
+ * Add custom kernel to the global object
+ * @param {string} name - Name for the new kernel
+ * @param {Object} config - Kernel configuration (modality, label, size, kernel)
+ */
+export declare function addCustomKernel(name: string, config: KernelConfig): void;
+/**
+ * Get kernels
+ * @returns {Object} - CONVOLUTION_KERNELS object
+ */
+export declare function getKernels(): {
+    [x: string]: KernelConfig;
+};

package/dist/imaging/tools/default.d.ts

@@ -2,7 +2,13 @@
  *  @desc  This file provides definitions
  *         for default tools
  */
-import type { ToolConfig, ToolMouseKeys, ToolSettings, ToolStyle } from "./types";
+import type { CursorOptions, ToolConfig, ToolMouseKeys, ToolSettings, ToolStyle, ToolStyle3D } from "./types";
+declare const DEFAULT_TOOLS_3D: {
+    [key: string]: ToolConfig;
+};
+declare const DEFAULT_TOOLS_MPR: {
+    [key: string]: ToolConfig;
+};
 /**
  * These tools are added with `addDefaultTools()`
  */
@@ -15,6 +21,18 @@ declare const DEFAULT_TOOLS: {
 declare const dvTools: {
     [key: string]: any;
 };
+/**
+ * D/Vision Lab 3D custom tools
+ */
+declare const dvTools3D: {
+    [key: string]: any;
+};
+/**
+ * D/Vision Lab MPR custom tools
+ */
+declare const dvToolsMPR: {
+    [key: string]: any;
+};
 /**
  * Tools default style
  * Available font families :
@@ -23,6 +41,7 @@ declare const dvTools: {
  * Arial, Lucida Grande, sans-serif;
  */
 declare const DEFAULT_STYLE: ToolStyle;
+declare const DEFAULT_STYLE_3D: ToolStyle3D;
 /**
  * Tools default settings
  */
@@ -46,8 +65,31 @@ declare const setDefaultToolsProps: (newProps: Partial<ToolConfig>[]) => void;
  * Register a custom tool
  * @param {String} toolName - The name of the tool
  * @param {Object} toolClass - The tool class
+ * @param {String} toolVersion - The version of the tool, can be "MPR", "3D" (to be used with cs3D) or "" (default - cs legacy)
  * NOTE: toolName must be unique
  * NOTE: toolClass must be a valid cornerstone tool
  */
-declare const registerExternalTool: (toolName: string, toolClass: any) => void;
-export { DEFAULT_TOOLS, DEFAULT_STYLE, DEFAULT_SETTINGS, DEFAULT_MOUSE_KEYS, dvTools, getDefaultToolsByType, setDefaultToolsProps, registerExternalTool };
+declare const registerExternalTool: (toolName: string, toolClass: any, toolVersion?: "MPR" | "3D" | "", toolCursor?: string, cursorOptions?: CursorOptions) => void;
+/**
+ * Register a custom tool cursor
+ * @param {String} toolName - The name of the tool
+ * @param {string} iconContent - The tool class
+ * @param {CursorOptions} cursorOptions - tthe  cursor options
+  ex.
+      const iconContent = `
+          <svg xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30">
+            <image href="data:image/svg+xml;base64,${measurementBase64}" width="30" height="30" style="filter: invert(100%);"/>
+          </svg>
+        `;
+      const cursorOptions = {
+        iconSize: 30,
+        mousePoint: { x: 15, y: 15 },
+        mousePointerGroupString: ``,
+        viewBox: {
+          x: 0,
+          y: 0
+        }
+      };
+ */
+export declare const registerCursor: (toolName: string, iconContent: string, cursorOptions: CursorOptions) => void;
+export { DEFAULT_TOOLS, DEFAULT_TOOLS_3D, DEFAULT_TOOLS_MPR, DEFAULT_STYLE, DEFAULT_STYLE_3D, DEFAULT_SETTINGS, DEFAULT_MOUSE_KEYS, dvTools, dvTools3D, dvToolsMPR, getDefaultToolsByType, setDefaultToolsProps, registerExternalTool };

package/dist/imaging/tools/types.d.ts

@@ -1,5 +1,5 @@
 import { EnabledElement } from "cornerstone-core";
-import { Image, Viewport } from "../types";
+import { DisplayedArea, Image, Viewport } from "../types";
 type ToolOptions = {
     mouseButtonMask?: number | number[];
     supportedInteractionTypes?: string[];
@@ -24,6 +24,30 @@ export type ToolConfig = {
     currentMode?: string;
     offset?: number;
 };
+export type ToolStyle3D = {
+    global: {
+        angleArcLineDash: string;
+        color: string;
+        colorHighlighted: string;
+        colorLocked: string;
+        colorSelected: string;
+        lineDash: string;
+        lineWidth: string;
+        markerSize: string;
+        shadow: boolean;
+        textBoxBackground: string;
+        textBoxColor: string;
+        textBoxColorHighlighted: string;
+        textBoxColorLocked: string;
+        textBoxColorSelected: string;
+        textBoxFontFamily: string;
+        textBoxFontSize: string;
+        textBoxLinkLineDash: string;
+        textBoxLinkLineWidth: string;
+        textBoxShadow: boolean;
+        textBoxVisibility: boolean;
+    };
+};
 export type ToolStyle = {
     width: number;
     color: string;
@@ -33,6 +57,13 @@ export type ToolStyle = {
     fontSize: number;
     backgroundColor: string;
 };
+export type CursorOptions = {
+    name: string;
+    iconSize: number;
+    mousePoint: Coords;
+    mousePointerGroupString: string;
+    viewBox: Coords;
+};
 export type ToolSettings = {
     mouseEnabled: boolean;
     touchEnabled: boolean;
@@ -131,7 +162,7 @@ export type HandlePosition = {
 };
 export interface ViewportComplete extends Viewport {
     initialRotation: number;
-    displayedArea: any;
+    displayedArea: DisplayedArea;
     scale: number;
     rotation: number;
     vflip: boolean;

package/dist/imaging/types.d.ts

@@ -3,7 +3,7 @@ import { DataSet } from "dicom-parser";
 import { MetaDataTypes } from "./MetaDataTypes";
 import { MetaDataReadable } from "./MetaDataReadable";
 import { Element } from "dicom-parser";
-import { Overlay } from "./tools/types";
+import { Coords, DisplayAreaVisualizations, Overlay } from "./tools/types";
 export type tags = {
     [x: string]: Element;
 }[];
@@ -58,6 +58,7 @@ export type StoreViewport = {
     numberOfTemporalPositions?: number;
     numberOfFrames?: number;
     timeIndex?: number;
+    filterName?: string;
     viewport: {
         scale: number;
         rotation: number;
@@ -143,6 +144,7 @@ export type DSA = {
 };
 export type Series = {
     imageIds: string[];
+    imageIds3D: string[];
     instances: {
         [key: string]: Instance;
     };
@@ -186,21 +188,15 @@ export interface Layer extends cornerstone.EnabledElementLayer {
 }
 export interface Viewport extends cornerstone.Viewport {
     newImageIdIndex: number;
-    displayedArea: {
-        tlhc: {
-            x: number;
-            y: number;
-        };
-        brhc: {
-            x: number;
-            y: number;
-        };
-        columnPixelSpacing: number;
-        rowPixelSpacing: number;
-        presentationSizeMode: string;
-    };
     overlayColor?: boolean | string;
 }
+export type DisplayedArea = {
+    tlhc?: Coords;
+    brhc?: Coords;
+    presentationSizeMode?: DisplayAreaVisualizations;
+    rowPixelSpacing?: number;
+    columnPixelSpacing?: number;
+};
 export type Contours = {
     [key: string]: {
         [key: string]: Array<{
@@ -288,6 +284,7 @@ export type NrrdInputVolume = {
 export type NrrdSeries = {
     currentImageIdIndex: number;
     imageIds: string[];
+    imageIds3D: string[];
     instances: {
         [key: string]: Instance;
     };
@@ -338,7 +335,14 @@ type translation = {
     x: number;
     y: number;
 };
+export type KernelConfig = {
+    Label: string;
+    Size: number;
+    Kernel: number[][];
+    Modality?: string[];
+};
 export type RenderProps = {
+    filterName?: string;
     cached?: boolean;
     imageIndex?: number;
     scale?: number;

package/dist/imaging3d/imageRendering.d.ts

@@ -11,11 +11,79 @@ import { MprViewport } from "./types";
  * @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
+ * @param {RenderProps} options - Optional rendering options
  * @return {Promise} Return a promise which will resolve when image is displayed
  */
 export declare const renderImage: (seriesStack: Series, elementId: string | HTMLElement, options?: RenderProps) => Promise<{
     success: boolean;
     renderingEngine: cornerstone.RenderingEngine;
 }>;
-export declare const renderMpr: (seriesStack: Series, mprViewports: MprViewport[], options?: RenderProps) => Promise<unknown>;
+/**
+ * Initialize a rendering engine with a renderingEngineId
+ * @instance
+ * @function initializeRenderingEngine
+ * @param {string} renderingEngineId - The unique identifier of the rendering engine to initialize
+ * @return {cornerstone.RenderingEngine} Returns the initialized rendering engine
+ * @throws {Error} If the rendering engine with the same UID already exists
+ */
+export declare const initializeRenderingEngine: (renderingEngineId: string) => cornerstone.RenderingEngine | void;
+/**
+ * Destroy a rendering engine by its unique UID
+ * @instance
+ * @function destroyRenderingEngine
+ * @param {string} renderingEngineId - The unique identifier of the rendering engine to destroy
+ * @return {void}
+ * @throws {Error} If the rendering engine does not exist or has already been destroyed
+ */
+export declare const destroyRenderingEngine: (renderingEngineId: string) => void;
+/**
+ * Initialize volume viewports for a rendering engine
+ * @instance
+ * @function initializeVolumeViewports
+ * @param {string} renderingEngineId - The unique identifier of the rendering engine to initialize
+ * @param {MprViewport[]} mprViewports - An array of MprViewport objects to initialize
+ * @returns {void}
+ */
+export declare const initializeVolumeViewports: (renderingEngineId: string, mprViewports: MprViewport[]) => void;
+/**
+ * Load and cache a volume from a series
+ * @instance
+ * @function loadAndCacheVolume
+ * @param {Series} series - The series object containing imageIds and instances
+ * @returns {cornerstone.ImageVolume | cornerstone.Types.IStreamingImageVolume} Returns a promise that resolves to the loaded volume
+ */
+export declare const loadAndCacheVolume: (series: Series) => Promise<cornerstone.ImageVolume | cornerstone.Types.IStreamingImageVolume>;
+/**
+ * Set a volume for a rendering engine
+ * @instance
+ * @function setVolumeForRenderingEngine
+ * @param {string} volumeId - The unique identifier of the volume to set
+ * @param {string} renderingEngineId - The unique identifier of the rendering engine to set the volume for
+ * @returns
+ */
+export declare const setVolumeForRenderingEngine: (volumeId: string, renderingEngineId: string) => void;
+export declare const renderMpr: (series: Series, renderingEngineId: string, options?: RenderProps) => Promise<cornerstone.RenderingEngine>;
+/**
+ * Unload a MPR rendering engine
+ * @instance
+ * @function unloadMpr
+ * @param {string} renderingEngineId - The unique identifier of the rendering engine to unload
+ * @returns {void}
+ */
+export declare const unloadMpr: (renderingEngineId: string) => void;
+/**
+ * Resize a rendering engine
+ * @instance
+ * @function resizeRenderingEngine
+ * @param {string} renderingEngineId - The unique identifier of the rendering engine to resize
+ * @returns {void}
+ */
+export declare const resizeRenderingEngine: (renderingEngineId: string) => void;
+/**
+ * Reset viewport values (contrast, pan and zoom)
+ * @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" | "pan" | "zoom">) => void;

package/dist/imaging3d/tools/custom/exampleCustomTool.d.ts

@@ -0,0 +1,44 @@
+import { BaseTool } from "@cornerstonejs/tools";
+import { Viewport } from "@cornerstonejs/core";
+import * as EventTypes from "@cornerstonejs/tools/dist/esm/types/EventTypes";
+/**
+ * WindowLevel tool manipulates the windowLevel applied to a viewport. It
+ * provides a way to set the windowCenter and windowWidth of a viewport
+ * by dragging mouse over the image.
+ *
+ */
+declare class CustomWWWLTool extends BaseTool {
+    static toolName: string;
+    constructor(toolProps?: {}, defaultToolProps?: {
+        supportedInteractionTypes: string[];
+    });
+    touchDragCallback(evt: EventTypes.InteractionEventType): void;
+    mouseDragCallback(evt: EventTypes.InteractionEventType): void;
+    getPTScaledNewRange({ deltaPointsCanvas, lower, upper, clientHeight, viewport, volumeId, isPreScaled }: {
+        deltaPointsCanvas: number[];
+        lower: number;
+        upper: number;
+        clientHeight: number;
+        viewport: Viewport;
+        volumeId?: string;
+        isPreScaled: boolean;
+    }): {
+        lower: number;
+        upper: number;
+    };
+    getNewRange({ viewport, deltaPointsCanvas, volumeId, lower, upper }: {
+        viewport: any;
+        deltaPointsCanvas: any;
+        volumeId: any;
+        lower: any;
+        upper: any;
+    }): {
+        lower: number;
+        upper: number;
+    };
+    _getMultiplierFromDynamicRange(viewport: any, volumeId: any): number;
+    _getImageDynamicRangeFromViewport(viewport: any): number;
+    _getImageDynamicRangeFromMiddleSlice: (scalarData: any, dimensions: any) => number;
+    private _getMinMax;
+}
+export default CustomWWWLTool;

package/dist/imaging3d/tools/main.d.ts

@@ -2,18 +2,107 @@
  *  @desc  This file provides functionalities
  *         for initializing tools and stacks
  */
-import { RenderingEngine } from "@cornerstonejs/core";
+import * as cornerstone from "@cornerstonejs/core";
+import * as cornerstoneTools from "@cornerstonejs/tools";
+import type { ToolConfig, ToolSettings, ToolStyle3D } from "../../imaging/tools/types";
+import type { RenderingEngine } from "@cornerstonejs/core";
+/**
+ * Initialize cornerstone tools with default configuration (extended with custom configuration)
+ * @function initializeCSTools
+ * @param {ToolSettings} settings - the settings object (see tools/default.js)
+ * @param {ToolStyle} style - the style object (see tools/default.js)
+ * @example larvitar.initializeCSTools({showSVGCursors:false}, {color: "0000FF"});
+ */
+export declare const initializeCSTools: (settings?: ToolSettings, style?: ToolStyle3D) => Promise<void>;
+/**
+ * Set cornerstone tools custom configuration (extend default configuration)
+ * @function setToolsStyle
+ * @param {Object} style - the style object (see tools/defaults.js)
+ */
+export declare const setToolsStyle: (style?: ToolStyle3D) => void;
+/**
+ * Add a cornerstone 3D tool (grab it from original library or dvision custom 3D or MPR tools)
+ * @param {String} toolName
+ * @param {Partial<ToolConfig>} customConfig
+ * @param {String} type The type of tool to add (3D or MPR)
+ * @param {String} groupId The cornerstone3D Tool GroupID
+ * @example larvitar.addTool("ScaleOverlay", {configuration:{minorTickLength: 10, majorTickLength: 25}}, "viewer")
+ */
+export declare const addTool: (toolName: string, customConfig: Partial<ToolConfig>, groupId?: string, type?: string) => void;
 /**
  * @function addDefaultTools
  * @desc Adds default tools to the rendering engine (wwwl, pan, zoom, stackScroll)
- * @param elementId - the id of the element where the tools will be added
- * @param renderingEngine - the rendering engine where the tools will be added
+ * @param {String[]} elementIds - the ids of the elements where the tools will be added
+ * @param {RenderingEngine} renderingEngine - the rendering engine where the tools will be added
+ * @param {String} type The type of tool to add (3D or MPR)
+ * @param {String} groupId The cornerstone3D Tool GroupID
+ */
+export declare const addDefaultTools: (elementIds: string[], renderingEngine: RenderingEngine, type?: string, toolGroupId?: string) => void;
+/**
+ * Set Tool "active" on all elements (ie, rendered and manipulable)
+ * @param toolName - The tool name.
+ * @param options - The tool options (mouseButtonMask, etc). If not provided, the default options will be used.
+ * @param groupId - The tool group id. @default "default"
+ * @param doNotSetInStore - Flag to not set the active tool in the store. @default false
+ */
+export declare const setToolActive: (toolName: string, options?: Partial<ToolConfig["options"]>, groupId?: string, doNotSetInStore?: boolean) => void;
+export declare const setToolPassive: (toolName: string, groupId?: string, resetCursor?: boolean) => void;
+export declare const setToolEnabled: (toolName: string, groupId?: string, resetCursor?: boolean) => void;
+export declare const setToolDisabled: (toolName: string, groupId?: string, resetCursor?: boolean) => void;
+/**
+ * @function syncViewportsVOI
+ * @desc  Synchronizes the contrast of two (volume) viewports
+ * @param id - unique id for the synchronizer @default "default"
+ * @param targetViewportId - the id of the target viewport where the camera will be synced
+ * @param sourceViewportId - the id of the source viewport from where the camera position will be taken
+ */
+export declare const syncViewportsVOI: (id: string | undefined, syncedViewportIds: string[]) => void;
+/**
+ * @function syncViewports
+ * @desc  Synchronizes the camera position and contrast of two (volume) viewports
+ * @param id - unique id for the synchronizer @default "default"
+ * @param targetViewportId - the id of the target viewport where the camera will be synced
+ * @param sourceViewportId - the id of the source viewport from where the camera position will be taken
+ * @param otherViewportIds - the ids of other viewports to sync VOI with
+ */
+export declare const syncViewports: (id: string | undefined, targetViewportId: string, sourceViewportId: string, otherViewportIds: string[]) => void;
+/**
+ * @function syncViewportsSlabAndCamera
+ * @desc  Synchronizes the camera position and/or the slab of two (volume) viewports
+ * @param id - unique id for the synchronizer @default "default"
+ * @param syncTypes - the types of synchronization to perform (camera, slab)
+ * @param viewportIds - the ids of the viewport to synchronize
+ */
+export declare const syncViewportsSlabAndCamera: (id?: string, syncTypes?: string[], ...viewportIds: string[]) => void;
+/**
+ * Create a tool group and add the specified viewports and tools to it.
+ * @function createToolGroup
+ * @param groupId - The id of the tool group to create. @default "default"
+ * @param viewports
+ * @param tools
+ * @param type - MPR or 3D
+ * @returns toolGroup - The created tool group.
+ */
+export declare const createToolGroup: (groupId?: string, viewports?: string[], tools?: any[], type?: string) => cornerstoneTools.Types.IToolGroup | undefined;
+/**
+ * Destroys a tool group and the tools added to it.
+ * @function destroyToolGroup
+ * @param groupId - The id of the tool group to destroy. @default "default"
+ * @returns void
+ */
+export declare const destroyToolGroup: (groupId?: string) => void;
+/**
+ * Set slab thickness and mode for a given viewport
+ * @function setSlab
+ * @param slabThickness - The thickness of the slab [in mm].
+ * @param slabMode - The blend mode to use for the slab.
+ * @param viewportId - The id of the viewport where the slab will be set.
  */
-export declare const addDefaultTools: (elementId: string, renderingEngine: RenderingEngine) => void;
+export declare const setSlab: (slabThickness: number, slabMode: cornerstone.Enums.BlendModes, viewportId: string) => void;
 /**
- * @function addDefaultTools3D
- * @desc Adds default tools to the rendering engine (crosshairs)
- * @param elementIds - the ids of the elements where the tools will be added
- * @param renderingEngine - the rendering engine where the tools will be added
+ * Set the window width and level for a given viewport
+ * @param ww - window width
+ * @param wl - window level
+ * @param viewportId - The id of the viewport where the window width and level will be set.
  */
-export declare const addDefaultTools3D: (elementIds: string[], renderingEngine: RenderingEngine) => void;
+export declare const setWWWL: (ww: number, wl: number, viewportId: string) => void;

package/dist/imaging3d/types.d.ts

@@ -1,4 +1,9 @@
 import { Enums } from "@cornerstonejs/core";
+export type { Types, VolumeViewport, StackViewport, BaseVolumeViewport } from "@cornerstonejs/core";
+export type { IEnabledElement, Point2, Point3, ICamera } from "@cornerstonejs/core/dist/esm/types";
+export type { Annotation, CanvasCoordinates, EventTypes, InteractionTypes, PublicToolProps, SVGDrawingHelper, TextBoxHandle, ToolHandle, ToolProps } from "@cornerstonejs/tools/dist/esm/types";
+export type { Handles } from "@cornerstonejs/tools/dist/esm/types/AnnotationTypes";
+export type { ROICachedStats } from "@cornerstonejs/tools/dist/esm/types/ToolSpecificAnnotationTypes";
 export type MprViewport = {
     viewportId: string;
     orientation: Enums.OrientationAxis;