@kitware/vtk.js 23.4.2 → 23.4.4

package/Rendering/Core/ColorTransferFunction/Constants.d.ts

@@ -0,0 +1,17 @@
+export declare enum ColorSpace {
+  RGB = 0,
+  HSV = 1,
+  LAB = 2,
+  DIVERGING = 3,
+}
+
+export declare enum Scale {
+  LINEAR = 0,
+  LOG10 = 1,
+}
+
+declare const _default: {
+	ColorSpace: typeof ColorSpace;
+	Scale: typeof Scale;
+};
+export default _default;

package/Rendering/Core/ColorTransferFunction.js

@@ -1,6 +1,6 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
-import { h as hsv2rgb, i as isNan, E as isInf, F as rgb2hsv, G as rgb2lab, H as lab2rgb, I as floor } from '../../Common/Core/Math/index.js';
+import { h as hsv2rgb, i as isNan, G as isInf, H as rgb2hsv, I as rgb2lab, J as lab2rgb, F as floor } from '../../Common/Core/Math/index.js';
 import vtkScalarsToColors from '../../Common/Core/ScalarsToColors.js';
 import Constants from './ColorTransferFunction/Constants.js';
 

package/Rendering/Core/Coordinate/Constants.d.ts

@@ -0,0 +1,14 @@
+export declare enum Coordinate {
+  DISPLAY = 0,
+  NORMALIZED_DISPLAY = 1,
+  VIEWPORT = 2,
+  NORMALIZED_VIEWPORT = 3,
+  PROJECTION = 4,
+  VIEW = 5,
+  WORLD = 6,
+}
+
+declare const _default: {
+	Coordinate: typeof Coordinate;
+};
+export default _default;

package/Rendering/Core/Coordinate.js

@@ -1,7 +1,7 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
 import Constants from './Coordinate/Constants.js';
-import { J as round, I as floor } from '../../Common/Core/Math/index.js';
+import { E as round, F as floor } from '../../Common/Core/Math/index.js';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 

package/Rendering/Core/Glyph3DMapper/Constants.d.ts

@@ -0,0 +1,17 @@
+export declare enum OrientationModes {
+	DIRECTION = 0,
+	ROTATION = 1,
+	MATRIX = 2,
+}
+
+export declare enum ScaleModes {
+	SCALE_BY_CONSTANT = 0,
+	SCALE_BY_MAGNITUDE = 1,
+	SCALE_BY_COMPONENTS = 2,
+}
+
+declare const _default: {
+	OrientationModes: typeof OrientationModes;
+	ScaleModes: typeof ScaleModes;
+};
+export default _default;

package/Rendering/Core/Glyph3DMapper.js

@@ -4,7 +4,7 @@ import { mat4, vec3, mat3 } from 'gl-matrix';
 import Constants from './Glyph3DMapper/Constants.js';
 import macro from '../../macros.js';
 import vtkMapper from './Mapper.js';
-import { M as createUninitializedBounds, n as norm } from '../../Common/Core/Math/index.js';
+import { N as createUninitializedBounds, n as norm } from '../../Common/Core/Math/index.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }

package/Rendering/Core/HardwareSelector.d.ts

@@ -0,0 +1,84 @@
+import { FieldAssociations } from './../../Common/DataModel/DataSet/Constants';
+import vtkSelectionNode from './../../Common/DataModel/SelectionNode';
+import { vtkObject } from './../../interfaces';
+import vtkRenderer from './Renderer';
+
+export interface vtkHardwareSelector extends vtkObject {
+  /**
+   * Get the picking source data.
+   *
+   * @param {vtkRenderer} renderer
+   * @param {number} fx1 top left x coord
+   * @param {number} fy1 top left y coord
+   * @param {number} fx2 bottom right x coord
+   * @param {number} fy2 bottom right y coord
+   */
+  getSourceDataAsync(
+    renderer: vtkRenderer,
+    fx1: number,
+    fy1: number,
+    fx2: number,
+    fy2: number
+  ): Promise<unknown>;
+
+  /**
+   * Generates a selection.
+   *
+   * @param {vtkRenderer} renderer
+   * @param {number} fx1 top left x coord
+   * @param {number} fy1 top left y coord
+   * @param {number} fx2 bottom right x coord
+   * @param {number} fy2 bottom right y coord
+   */
+  selectAsync(
+    renderer: vtkRenderer,
+    fx1: number,
+    fy1: number,
+    fx2: number,
+    fy2: number
+  ): Promise<vtkSelectionNode[]>;
+
+  /**
+   * Sets the field association.
+   * @param {FieldAssociations} assoc
+   */
+  setFieldAssociation(assoc: FieldAssociations): boolean;
+
+  /**
+   * Gets the field association.
+   */
+  getFieldAssociation(): FieldAssociations;
+
+  /**
+   * Sets whether to capture Z values.
+   * @param {boolean} capture
+   */
+  setCaptureZValues(capture: boolean): boolean;
+
+  /**
+   * Gets whether to capture Z values.
+   */
+  getCaptureZValues(): boolean;
+}
+
+export interface IHardwareSelectorInitialValues {
+  fieldAssociation?: FieldAssociations;
+  captureZValues?: boolean;
+}
+
+export function newInstance(
+  initialValues?: IHardwareSelectorInitialValues
+): vtkHardwareSelector;
+
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IHardwareSelectorInitialValues
+): void;
+
+export const vtkHardwareSelector: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+
+export default vtkHardwareSelector;

package/Rendering/Core/ImageArrayMapper.d.ts

@@ -0,0 +1,253 @@
+import vtkAbstractImageMapper, { IAbstractImageMapperInitialValues } from './AbstractImageMapper';
+import IClosestIJKAxis from './ImageMapper';
+import { Bounds, Nullable } from './../../types';
+import { SlicingMode } from './ImageMapper/Constants';
+import vtkImageData from './../../Common/DataModel/ImageData';
+import vtkCollection from './../../Common/DataModel/Collection';
+
+
+interface ICoincidentTopology {
+	factor: number;
+	offset: number;
+}
+
+interface ISliceToSubSlice {
+	imageIndex: number;
+	subSlice: number;
+}
+
+export interface IImageArrayMapperInitialValues extends IAbstractImageMapperInitialValues {
+  	slicingMode: SlicingMode.K,
+  	sliceToSubSliceMap: ISliceToSubSlice[],
+}
+
+export interface vtkImageArrayMapper extends vtkAbstractImageMapper {
+
+	/**
+	 * 
+	 * @param inputData set input as a vtkCollection of vtkImageData objects.
+	 */
+	setInputData(inputData: vtkCollection): void;
+
+	/**
+	 *  Get vtkImageData corresponding to the provided (global) slice number.
+	 * @param slice (global) slice number. If a slice number is not provided,
+	 * the function uses the current slice number (i.e. the output of getSlice()).
+	 */
+	getImage(slice?: number): Nullable<vtkImageData>;
+
+	/**
+  	 * Return currently active image. This depends on the currently active slice number.
+	 */
+	getCurrentImage(): Nullable<vtkImageData>;
+
+	/**
+     * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
+	 * @return {Bounds} The bounds for the mapper.
+	 */
+	getBounds(): Bounds;
+
+	/**
+	 * Get the bounds for a given slice as [xmin, xmax, ymin, ymax,zmin, zmax].
+	 * @param {Number} [slice] The slice index. If undefined, the current slice is considered.
+	 * @param {Number} [halfThickness] Half the slice thickness in index space (unit voxel
+	 * spacing). If undefined, 0 is considered.
+	 * @return {Number[]} The bounds for a given slice.
+	 */
+	getBoundsForSlice(slice?: number, halfThickness?: number): number[];
+
+	/**
+	 * Get the closest IJK axis
+	 * @return {IClosestIJKAxis} The axis object.
+	 */
+	getClosestIJKAxis(): IClosestIJKAxis;
+
+	/**
+	 * Calculate the total number of slices in the input collection.
+	 */
+	computeTotalSlices(): number;
+
+	/**
+	 * Fetch the pre-calculated total number of slices in the input collection.
+	 */
+	getTotalSlices(): number;
+
+	/**
+	 *
+	 * @param {Number} slice The slice index.
+	 */
+	setSlice(slice: number): boolean;
+
+	/**
+	 * Calculate the global slice number that corresponds to the provided image and subSlice number.
+	 * The global slice number corresponds to the total number of 2D image frames that a collection has.
+	 * @param imageIndex The image number is the index of the vtkImageData object in the input collection.
+	 * @param subSlice The subSlice number is the k-index of a slice within a vtkImageData object in the input collection.
+	 */
+	computeSlice(imageIndex: number, subSlice: number): number;
+
+	/**
+	 * Get the vtkImageData index corresponding to the provided global slice number.
+	 * @param slice global slice number. If a slice number is not provided,
+	 * the function uses the current slice number (i.e. the output of getSlice()).
+	 */
+	getImageIndex(slice?: number): number;
+
+	/**
+	 * Given a global slice number, identify the subSlice number (slice k-index within a vtkImageData).
+	 * @param slice global slice number. If a slice number is not provided,
+	 * the function uses the current slice number (i.e. the output of getSlice()).
+	 */
+	getSubSlice(slice?: number): number;
+
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopology(): ICoincidentTopology
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopologyAsString(): ICoincidentTopology
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopologyLineOffsetParameters(): ICoincidentTopology
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopologyPointOffsetParameters(): ICoincidentTopology
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopologyPolygonOffsetFaces(): ICoincidentTopology
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopologyPolygonOffsetParameters(): ICoincidentTopology;
+
+	/**
+	 *
+	 * @param {Number} factor 
+	 * @param {Number} offset 
+	 */
+	setRelativeCoincidentTopologyLineOffsetParameters(factor: number, offset: number): boolean;
+
+	/**
+	 *
+	 * @param {Number} factor 
+	 * @param {Number} offset 
+	 */
+	setRelativeCoincidentTopologyPointOffsetParameters(factor: number, offset: number): boolean;
+
+	/**
+	 *
+	 * @param {Number} factor 
+	 * @param {Number} offset 
+	 */
+	setRelativeCoincidentTopologyPolygonOffsetParameters(factor: number, offset: number): boolean;
+
+	/**
+	 *
+	 * @param resolveCoincidentTopology
+	 * @default false
+	 */
+	setResolveCoincidentTopology(resolveCoincidentTopology: boolean): boolean;
+
+	/**
+	 *
+	 * @param {Number} factor 
+	 * @param {Number} offset 
+	 */
+	setResolveCoincidentTopologyLineOffsetParameters(factor: number, offset: number): boolean;
+
+	/**
+	 *
+	 * @param {Number} factor 
+	 * @param {Number} offset 
+	 */
+	setResolveCoincidentTopologyPointOffsetParameters(factor: number, offset: number): boolean;
+
+	/**
+	 *
+	 * @param value
+	 */
+	setResolveCoincidentTopologyPolygonOffsetFaces(value: number): boolean;
+
+	/**
+	 *
+	 * @param {Number} factor 
+	 * @param {Number} offset 
+	 */
+	setResolveCoincidentTopologyPolygonOffsetParameters(factor: number, offset: number): boolean;
+
+	/**
+	 *
+	 */
+	setResolveCoincidentTopologyToDefault(): boolean;
+
+	/**
+	 *
+	 */
+	setResolveCoincidentTopologyToOff(): boolean;
+
+	/**
+	 *
+	 */
+	setResolveCoincidentTopologyToPolygonOffset(): boolean;
+
+	/**
+	 * Set the slicing mode. 
+	 * @param {Number} mode The slicing mode.
+	 */
+	setSlicingMode(mode: number): boolean;
+
+	/**
+	 *
+	 * @param {Number[]} p1 The coordinates of the first point.
+	 * @param {Number[]} p2 The coordinates of the second point.
+	 */
+	intersectWithLineForPointPicking(p1: number[], p2: number[]): any;
+
+	/**
+	 *
+	 * @param {Number[]} p1 The coordinates of the first point.
+	 * @param {Number[]} p2 The coordinates of the second point.
+	 */
+	intersectWithLineForCellPicking(p1: number[], p2: number[]): any;
+}
+
+/**
+ * Method use to decorate a given object (publicAPI+model) with vtkImageArrayMapper characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IImageArrayMapperInitialValues} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues?: IImageArrayMapperInitialValues): void;
+
+/**
+ * Method use to create a new instance of vtkImageArrayMapper
+ * @param {IImageArrayMapperInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(initialValues?: IImageArrayMapperInitialValues): vtkImageArrayMapper;
+
+/**
+ * vtkImageArrayMapper provides display support for a collection of single/multi-frame images.
+ * Images can have variable dimensions (width, height, depth in pixels), can be mixture of
+ * color (RGB) and grayscale images, origin point and direction cosines.
+ * It can be associated with a vtkImageSlice prop and placed within a Renderer.
+ *
+ * This class resolves coincident topology with the same methods as vtkMapper.
+ */
+export declare const vtkImageArrayMapper: {
+	newInstance: typeof newInstance;
+	extend: typeof extend;
+	SlicingMode: typeof SlicingMode;
+}
+export default vtkImageArrayMapper;

package/Rendering/Core/ImageArrayMapper.js

@@ -0,0 +1,242 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import macro from '../../macros.js';
+import vtkAbstractImageMapper from './AbstractImageMapper.js';
+import vtkImageMapper from './ImageMapper.js';
+import { N as createUninitializedBounds } from '../../Common/Core/Math/index.js';
+import { intersectWithLineForPointPicking, intersectWithLineForCellPicking } from './AbstractImageMapper/helper.js';
+import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var staticOffsetAPI = CoincidentTopologyHelper.staticOffsetAPI,
+    otherStaticMethods = CoincidentTopologyHelper.otherStaticMethods;
+var vtkErrorMacro = macro.vtkErrorMacro,
+    vtkWarningMacro = macro.vtkWarningMacro;
+var SlicingMode = vtkImageMapper.SlicingMode; // ----------------------------------------------------------------------------
+// vtkImageArrayMapper methods
+// ----------------------------------------------------------------------------
+
+function vtkImageArrayMapper(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkImageArrayMapper'); //------------------
+  // Private functions
+
+  var _computeSliceToSubSliceMap = function _computeSliceToSubSliceMap() {
+    var inputCollection = publicAPI.getInputData();
+
+    if (!inputCollection || inputCollection.empty()) {
+      // clear the map
+      if (model.sliceToSubSliceMap.length !== 0) {
+        model.sliceToSubSliceMap.length = 0;
+        publicAPI.modified();
+      }
+
+      return;
+    }
+
+    if (model.sliceToSubSliceMap.length === 0 || inputCollection.getMTime() > publicAPI.getMTime()) {
+      var perImageMap = inputCollection.map(function (image, index) {
+        var dim = image.getDimensions();
+        var out = new Array(dim[model.slicingMode]);
+
+        for (var i = 0; i < out.length; ++i) {
+          out[i] = {
+            imageIndex: index,
+            subSlice: i
+          };
+        }
+
+        return out;
+      });
+      model.sliceToSubSliceMap = perImageMap.flat();
+      publicAPI.modified();
+    }
+  };
+
+  var _superSetInputData = publicAPI.setInputData;
+  var _superSetInputConnection = publicAPI.setInputConnection; //------------------
+  // Public functions
+
+  publicAPI.setInputData = function (inputData) {
+    _superSetInputData(inputData);
+
+    _computeSliceToSubSliceMap();
+  };
+
+  publicAPI.setInputConnection = function (outputPort) {
+    var port = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+
+    _superSetInputConnection(outputPort, port);
+
+    _computeSliceToSubSliceMap();
+  };
+
+  publicAPI.getImage = function () {
+    var slice = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : publicAPI.getSlice();
+    var inputCollection = publicAPI.getInputData();
+
+    if (!inputCollection) {
+      vtkWarningMacro('No input set.');
+    } else if (slice < 0 || slice >= publicAPI.getTotalSlices()) {
+      vtkWarningMacro('Invalid slice number.');
+    } else {
+      _computeSliceToSubSliceMap();
+
+      return inputCollection.getItem(model.sliceToSubSliceMap[slice].imageIndex);
+    }
+
+    return null;
+  };
+
+  publicAPI.getBounds = function () {
+    var image = publicAPI.getCurrentImage();
+
+    if (!image) {
+      return createUninitializedBounds();
+    }
+
+    if (!model.useCustomExtents) {
+      return image.getBounds();
+    }
+
+    var ex = model.customDisplayExtent.slice(); // use sub-slice of the current image,
+    // which is the k-coordinate.
+
+    var nSlice = publicAPI.getSubSlice();
+    ex[4] = nSlice;
+    ex[5] = nSlice;
+    return image.extentToBounds(ex);
+  };
+
+  publicAPI.getBoundsForSlice = function () {
+    var slice = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : publicAPI.getSlice();
+    var halfThickness = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    var image = publicAPI.getImage(slice);
+
+    if (!image) {
+      return createUninitializedBounds();
+    }
+
+    var extent = image.getSpatialExtent();
+    var nSlice = publicAPI.getSubSlice(slice);
+    extent[4] = nSlice - halfThickness;
+    extent[5] = nSlice + halfThickness;
+    return image.extentToBounds(extent);
+  };
+
+  publicAPI.getClosestIJKAxis = function () {
+    return {
+      ijkMode: model.slicingMode,
+      flip: false
+    };
+  };
+
+  publicAPI.computeTotalSlices = function () {
+    var inputCollection = publicAPI.getInputData();
+    var collectionLength = inputCollection.getNumberOfItems();
+    var slicesCount = 0;
+
+    for (var i = 0; i < collectionLength; ++i) {
+      var image = inputCollection.getItem(i);
+
+      if (image) {
+        slicesCount += image.getDimensions()[model.slicingMode];
+      }
+    }
+
+    return slicesCount;
+  };
+
+  publicAPI.getTotalSlices = function () {
+    _computeSliceToSubSliceMap();
+
+    return model.sliceToSubSliceMap.length;
+  }; // set slice number in terms of imageIndex and subSlice number.
+
+
+  publicAPI.setSlice = function (slice) {
+    var inputCollection = publicAPI.getInputData();
+
+    if (!inputCollection) {
+      // No input is set
+      vtkWarningMacro('No input set.');
+      return;
+    }
+
+    var totalSlices = publicAPI.getTotalSlices();
+
+    if (slice >= 0 && slice < totalSlices) {
+      model.slice = slice;
+      publicAPI.modified();
+    } else {
+      vtkErrorMacro("Slice number out of range. Acceptable range is: [0, ".concat(totalSlices > 0 ? totalSlices - 1 : 0, "]slice <= totalSlices"));
+    }
+  };
+
+  publicAPI.computeSlice = function (imageIndex, subSlice) {
+    _computeSliceToSubSliceMap();
+
+    return model.sliceToSubSliceMap.findIndex(function (x) {
+      return x.imageIndex === imageIndex && x.subSlice === subSlice;
+    });
+  };
+
+  publicAPI.getImageIndex = function () {
+    var _model$sliceToSubSlic;
+
+    var slice = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : publicAPI.getSlice();
+
+    _computeSliceToSubSliceMap();
+
+    return (_model$sliceToSubSlic = model.sliceToSubSliceMap[slice]) === null || _model$sliceToSubSlic === void 0 ? void 0 : _model$sliceToSubSlic.imageIndex;
+  };
+
+  publicAPI.getSubSlice = function () {
+    var _model$sliceToSubSlic2;
+
+    var slice = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : publicAPI.getSlice();
+
+    _computeSliceToSubSliceMap();
+
+    return (_model$sliceToSubSlic2 = model.sliceToSubSliceMap[slice]) === null || _model$sliceToSubSlic2 === void 0 ? void 0 : _model$sliceToSubSlic2.subSlice;
+  };
+
+  publicAPI.getCurrentImage = function () {
+    return publicAPI.getImage(publicAPI.getSlice());
+  };
+
+  publicAPI.intersectWithLineForPointPicking = function (p1, p2) {
+    return intersectWithLineForPointPicking(p1, p2, publicAPI);
+  };
+
+  publicAPI.intersectWithLineForCellPicking = function (p1, p2) {
+    return intersectWithLineForCellPicking(p1, p2, publicAPI);
+  };
+} // ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {
+  slicingMode: SlicingMode.K,
+  sliceToSubSliceMap: []
+};
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+
+  vtkAbstractImageMapper.extend(publicAPI, model, initialValues); // Build VTK API
+
+  macro.get(publicAPI, model, ['slicingMode']);
+  CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model); // Object methods
+
+  vtkImageArrayMapper(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkImageArrayMapper'); // ----------------------------------------------------------------------------
+
+var index = _objectSpread(_objectSpread({
+  newInstance: newInstance,
+  extend: extend
+}, staticOffsetAPI), otherStaticMethods);
+
+export { index as default, extend, newInstance };

package/Rendering/Core/ImageMapper/Constants.d.ts

@@ -0,0 +1,14 @@
+export declare enum SlicingMode {
+	NONE = -1,
+	I = 0,
+	J = 1,
+	K = 2,
+	X = 3,
+	Y = 4,
+	Z = 5,
+}
+
+declare const _default: {
+	SlicingMode: typeof SlicingMode;
+};
+export default _default;

package/Rendering/Core/ImageMapper.js

@@ -2,7 +2,7 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import Constants from './ImageMapper/Constants.js';
 import macro from '../../macros.js';
 import vtkAbstractMapper from './AbstractMapper.js';
-import { A as clampValue, N as multiply3x3_vect3, M as createUninitializedBounds } from '../../Common/Core/Math/index.js';
+import { A as clampValue, M as multiply3x3_vect3, N as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 import vtkPlane from '../../Common/DataModel/Plane.js';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
 import { vec3 } from 'gl-matrix';

package/Rendering/Core/ImageProperty/Constants.d.ts

@@ -0,0 +1,9 @@
+export declare enum InterpolationType {
+	NEAREST = 0,
+	LINEAR = 1,
+}
+
+declare const _default: {
+	InterpolationType: typeof InterpolationType;
+};
+export default _default;