@kitware/vtk.js 23.4.3 → 23.4.4

package/Proxy/Core/PiecewiseFunctionProxy.d.ts

@@ -0,0 +1,62 @@
+import vtkLookupTableProxy from './LookupTableProxy';
+import vtkPiecewiseFunction from './../../Common/DataModel/PiecewiseFunction';
+import { VtkProxy } from './../../macros';
+
+// [x, r/h, g/s, b/v, m=0.5, s=0.0]
+export interface PiecewiseGaussian {
+  position: number;
+  height: number;
+  width: number;
+  xBias: number;
+  yBias: number;
+}
+
+export interface PiecewiseNode {
+  x: number;
+  y: number;
+  midpoint: number;
+  sharpness: number;
+}
+
+export enum IPiecewiseFunctionProxyMode {
+  Gaussians = 0,
+  Points = 1,
+  Nodes = 2,
+}
+
+export interface IPiecewiseFunctionProxyDefaults {
+  Gaussians: PiecewiseGaussian[];
+  Points: number[][];
+  Nodes: PiecewiseNode[];
+}
+
+export interface vtkPiecewiseFunctionProxy extends VtkProxy {
+  setGaussians(gaussians: PiecewiseGaussian[]): void;
+  getGaussians(): PiecewiseGaussian[];
+  setPoints(points: number[][]): void;
+  getPoints(): number[][];
+  setNodes(nodes: PiecewiseNode[]): void;
+  getNodes(): PiecewiseNode[];
+  setMode(mode: number): void;
+  getMode(): number;
+  applyMode(): void;
+  getLookupTableProxy(): vtkLookupTableProxy;
+  setDataRange(min: number, max: number): void;
+  getDataRange(): [number, number];
+  getPiecewiseFunction(): vtkPiecewiseFunction;
+}
+
+export interface IPiecewiseFunctionProxyInitialValues {
+  piecewiseFunction?: vtkPiecewiseFunction;
+}
+
+export function newInstance(
+  initialValues?: IPiecewiseFunctionProxyInitialValues
+): vtkPiecewiseFunctionProxy;
+
+export declare const vtkPiecewiseFunctionProxy: {
+  newInstance: typeof newInstance;
+  Mode: typeof IPiecewiseFunctionProxyMode;
+  Defaults: IPiecewiseFunctionProxyDefaults;
+};
+export default vtkPiecewiseFunctionProxy;

package/Proxy/Core/ProxyManager.d.ts

@@ -0,0 +1,115 @@
+import { vtkObject } from './../../interfaces';
+import vtkSourceProxy from './SourceProxy';
+import vtkViewProxy from './ViewProxy';
+import vtkAbstractRepresentationProxy from './AbstractRepresentationProxy';
+import vtkLookupTableProxy from './LookupTableProxy';
+import vtkPiecewiseFunctionProxy from './PiecewiseFunctionProxy';
+import { VtkProxy } from './../../macros';
+
+export type ProxyConfiguration = object;
+
+export interface ProxyRegistrationChangeInfo {
+  action: 'register' | 'unregister';
+  proxyId: string;
+  proxyName: string;
+  proxyGroup: string;
+  proxy: VtkProxy;
+}
+
+export interface IProxyManagerInitialValues {
+  proxyConfiguration?: ProxyConfiguration;
+}
+
+export interface vtkProxyManager extends vtkObject {
+  // core //
+
+  setProxyConfiguration(config: ProxyConfiguration): boolean;
+  getProxyConfiguration(): ProxyConfiguration;
+
+  setActiveSource<T>(sourceProxy: vtkSourceProxy<T>): boolean;
+  getActiveSource<T>(): vtkSourceProxy<T>;
+
+  setActiveView(viewProxy: vtkViewProxy): boolean;
+  getActiveView(): vtkViewProxy;
+
+  onProxyRegistrationChange(
+    callback: (changeInfo: ProxyRegistrationChangeInfo) => void
+  );
+
+  getProxyById<T extends VtkProxy>(id: string): T | undefined;
+  getProxyGroups(): string[];
+  getProxyInGroup(groupName: string): VtkProxy[];
+
+  getSources(): vtkSourceProxy<any>[];
+  getRepresentations(): vtkAbstractRepresentationProxy[];
+  getViews(): vtkViewProxy[];
+
+  createProxy<T extends VtkProxy>(
+    group: string,
+    name: string,
+    options?: Object
+  ): T;
+
+  getRepresentation<T extends vtkAbstractRepresentationProxy>(
+    source: vtkSourceProxy<any>,
+    view: vtkViewProxy
+  ): T | null;
+
+  deleteProxy(proxy: VtkProxy): void;
+
+  // view //
+
+  render(view?: vtkViewProxy): void;
+  renderAllViews(): void;
+  setAnimationOnAllViews(): void;
+  autoAnimateViews(debounceTimeout: number): void;
+  resizeAllViews(): void;
+  resetCamera(view?: vtkViewProxy): void;
+  createRepresentationInAllViews(source: vtkSourceProxy<any>): void;
+  resetCameraInAllViews(): void;
+
+  // properties //
+
+  // these are specific to the proxy configuration...
+  getLookupTable(arrayName: string, options?: any): vtkLookupTableProxy;
+  getPiecewiseFunction(
+    arrayName: string,
+    options?: any
+  ): vtkPiecewiseFunctionProxy;
+  rescaleTransferFunctionToDataRange(
+    arrayName: string,
+    dataRange: [number, number]
+  ): void;
+}
+
+/**
+ * Decorates a given publicAPI + model with vtkProxyManager characteristics.
+ *
+ * @param publicAPI
+ * @param model
+ * @param {IProxyManagerInitialValues} [initialValues]
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IProxyManagerInitialValues
+): void;
+
+/**
+ * Creates a vtkProxyManager.
+ * @param {IProxyManagerInitialValues} [initialValues]
+ */
+export function newInstance(
+  initialValues?: IProxyManagerInitialValues
+): vtkProxyManager;
+
+/**
+ * vtkProxyManager is the central manager for managing proxy resources
+ * in vtk.js.
+ */
+export declare const vtkProxyManager: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+
+export default vtkProxyManager;

package/Proxy/Core/SourceProxy.d.ts

@@ -0,0 +1,22 @@
+import { vtkAlgorithm } from './../../interfaces';
+import { VtkProxy } from './../../macros';
+
+export interface vtkSourceProxy<T> extends VtkProxy {
+  setInputProxy(source: vtkSourceProxy<T>): void;
+  setInputData(dataset: T, type?: string): void;
+  setInputAlgorithm(
+    algo: vtkAlgorithm,
+    type: string,
+    autoUpdate: boolean
+  ): void;
+  update(): void;
+
+  getName(): string;
+  setName(name: string): boolean;
+  getType(): string;
+  getDataset(): T | null;
+  getAlgo(): vtkAlgorithm | null;
+  getInputProxy(): vtkSourceProxy<T> | null;
+}
+
+export default vtkSourceProxy;

package/Proxy/Core/View2DProxy.d.ts

@@ -0,0 +1,7 @@
+import vtkViewProxy from './ViewProxy';
+
+export interface vtkView2DProxy extends vtkViewProxy {
+  getAxis(): number;
+}
+
+export default vtkView2DProxy;

package/Proxy/Core/View2DProxy.js

@@ -1,7 +1,7 @@
 import macro from '../../macros.js';
 import vtkMouseRangeManipulator from '../../Interaction/Manipulators/MouseRangeManipulator.js';
 import vtkViewProxy from './ViewProxy.js';
-import { j as cross, D as getMajorAxisIndex } from '../../Common/Core/Math/index.js';
+import { k as cross, D as getMajorAxisIndex } from '../../Common/Core/Math/index.js';
 
 var DEFAULT_STEP_WIDTH = 512;
 

package/Proxy/Core/ViewProxy.d.ts

@@ -0,0 +1,86 @@
+import vtkActor from './../../Rendering/Core/Actor';
+import vtkAbstractRepresentationProxy from './AbstractRepresentationProxy';
+import { Vector3, Vector4 } from './../../types';
+import vtkCamera from './../../Rendering/Core/Camera';
+import vtkRenderWindowInteractor from './../../Rendering/Core/RenderWindowInteractor';
+import vtkInteractorStyle from './../../Rendering/Core/InteractorStyle';
+import { vtkSubscription, vtkObject } from './../../interfaces';
+import vtkRenderer from './../../Rendering/Core/Renderer';
+import vtkRenderWindow from './../../Rendering/Core/RenderWindow';
+import vtkOpenGLRenderWindow from './../../Rendering/OpenGL/RenderWindow';
+import { VtkProxy } from './../../macros';
+
+export interface vtkViewProxy extends VtkProxy {
+  setPresetToInteractor3D(nameOrDefinitions: string | Object): boolean;
+  setPresetToInteractor2D(nameOrDefinitions: string | Object): boolean;
+
+  setOrientationAxesType(type: string): void;
+  setOrientationAxesVisibility(visible: boolean): boolean;
+  registerOrientationAxis(name: string, actor: vtkActor): void;
+  unregisterOrientationAxis(name: string): void;
+  listOrientationAxis(): string[];
+  setPresetToOrientationAxes(nameOrDefinitions: string | Object): boolean;
+
+  setContainer(container: HTMLElement | null): void;
+  resize(): void;
+  renderLater(): void;
+  render(blocking?: boolean): void;
+  resetCamera(): void;
+
+  addRepresentation(representation: vtkAbstractRepresentationProxy): void;
+  removeRepresentation(representation: vtkAbstractRepresentationProxy): void;
+
+  // TODO correct?
+  captureImage(opts: { format: string } & Object): Array<Promise<string>>;
+  openCaptureImage(target: string): void;
+
+  // TODO corner annotations
+
+  setBackground(color: Vector3 | Vector4): void;
+  getBackground(): Vector3 | Vector4;
+
+  setAnimation(enable: boolean, requester?: vtkObject);
+
+  updateOrientation(
+    axisIndex: 0 | 1 | 2,
+    orientation: -1 | 1,
+    viewUp: Vector3,
+    animateSteps: number
+  ): Promise<void>;
+  moveCamera(
+    focalPoint: Vector3,
+    position: Vector3,
+    viewUp: Vector3,
+    animateSteps: number
+  ): Promise<void>;
+
+  resetOrientation(animateSteps: number): void;
+  rotate(angle): void;
+
+  focusTo(focalPoint: Vector3): void;
+
+  getCamera(): vtkCamera;
+  // getAnnotationOpacity
+  getContainer(): HTMLElement | null;
+  // getCornerAnnotation
+  getInteractor(): vtkRenderWindowInteractor;
+  getInteractorStyle2D(): vtkInteractorStyle;
+  getInteractorStyle3D(): vtkInteractorStyle;
+  getOpenGLRenderWindow(): vtkOpenGLRenderWindow;
+  getOrientationAxesType(): string;
+  getPresetToOrientationAxes(): any;
+  getRenderer(): vtkRenderer;
+  getRenderWindow(): vtkRenderWindow;
+  getRepresentations(): vtkAbstractRepresentationProxy[];
+  getUseParallelRendering(): boolean;
+  getDisableAnimation(): boolean;
+  setDisableAnimation(disabled: boolean): boolean;
+
+  onResize(
+    cb: (size: { width: number; height: number }) => void
+  ): vtkSubscription;
+
+  // TODO proxy property mappings
+}
+
+export default vtkViewProxy;

package/Proxy/Representations/SliceRepresentationProxy.d.ts

@@ -0,0 +1,27 @@
+import vtkAbstractRepresentationProxy from './../Core/AbstractRepresentationProxy';
+
+export interface vtkSliceRepresentationProxy
+  extends vtkAbstractRepresentationProxy {
+  /**
+   * @param mode XYZIJK
+   */
+  setSlicingMode(mode: string): boolean;
+  getSlicingMode(): string;
+  getSliceIndex(): number;
+  getAnnotations(): any;
+
+  // proxy property mappings
+
+  setVisibility(visible: boolean): boolean;
+  getVisibility(): boolean;
+  setWindowWidth(width: number): boolean;
+  getWindowWidth(): number;
+  setWindowLevel(level: number): boolean;
+  getWindowLevel(): number;
+  setInterpolationType(type: number): boolean;
+  getInterpolationType(): number;
+  setSlice(type: number): boolean;
+  getSlice(): number;
+}
+
+export default vtkSliceRepresentationProxy;

package/Proxy/Representations/VolumeRepresentationProxy.d.ts

@@ -0,0 +1,44 @@
+import vtkAbstractRepresentationProxy from './../Core/AbstractRepresentationProxy';
+import vtkImageCropFilter from './../../Filters/General/ImageCropFilter';
+
+export interface vtkVolumeRepresentationProxy
+  extends vtkAbstractRepresentationProxy {
+  setIs2DVolume(is2D: boolean): void;
+  getIs2DVolume(): boolean;
+  isVisible(): boolean;
+  setVisibility(visible: boolean): void;
+  getVisibility(): boolean;
+  setSliceVisibility(isVisible: boolean): void;
+  getSliceVisibility(): boolean;
+  setSampleDistance(samp: number): void;
+  getSampleDistance(): number;
+  setEdgeGradient(grad: number): void;
+  getEdgeGradient(): number;
+  getCropFilter(): vtkImageCropFilter;
+
+  // proxy property mappings
+  getXSlice(): number;
+  setXSlice(slice: number): boolean;
+  getYSlice(): number;
+  setYSlice(slice: number): boolean;
+  getZSlice(): number;
+  setZSlice(slice: number): boolean;
+  getVolumeVisibility(): boolean;
+  setVolumeVisibility(visible: boolean): boolean;
+  getXSliceVisibility(): boolean;
+  setXSliceVisibility(visible: boolean): boolean;
+  getYSliceVisibility(): boolean;
+  setYSliceVisibility(visible: boolean): boolean;
+  getZSliceVisibility(): boolean;
+  setZSliceVisibility(visible: boolean): boolean;
+  getWindowWidth(): number;
+  setWindowWidth(width: number): boolean;
+  getWindowLevel(): number;
+  setWindowLevel(level: number): boolean;
+  getUseShadow(): boolean;
+  setUseShadow(useShadow: boolean): boolean;
+  getCroppingPlanes(): number[];
+  setCroppingPlanes(planes: number[]): boolean;
+}
+
+export default vtkVolumeRepresentationProxy;

package/README.md

@@ -48,8 +48,8 @@ In general VTK tries to be as portable as possible; the specific configurations
 
 vtk.js supports the following development environments:
 
-- Node 12+
-- NPM 6+
+- Node 14+
+- NPM 7+
 
 and we use [@babel/preset-env](https://www.npmjs.com/package/@babel/preset-env) with the [defaults](https://github.com/Kitware/vtk-js/blob/master/.browserslistrc) set of [browsers target](https://browserl.ist/?q=defaults).
 But when built from source this could be adjusted to support any browser as long they provide WebGL.

package/Rendering/Core/AbstractImageMapper/helper.js

@@ -0,0 +1,127 @@
+import { vec3 } from 'gl-matrix';
+import vtkPlane from '../../../Common/DataModel/Plane.js';
+
+/**
+ * Perform plane-line intersection, where the line is defined by two points (p1, p2),
+ * and the plane is defined by the imageData and slice number.
+ *
+ * @param {Vector3} p1
+ * @param {Vector3} p2
+ * @param {vtkImageMapper|vtkImageArrayMapper} mapper
+ */
+
+function doPicking(p1, p2, mapper) {
+  var imageData = mapper.getCurrentImage();
+  var extent = imageData.getExtent(); // Slice origin
+
+  var ijk = [extent[0], extent[2], extent[4]];
+
+  var _mapper$getClosestIJK = mapper.getClosestIJKAxis(),
+      ijkMode = _mapper$getClosestIJK.ijkMode;
+
+  var nSlice = mapper.isA('vtkImageArrayMapper') ? mapper.getSubSlice() : mapper.getSlice();
+
+  if (ijkMode !== mapper.getSlicingMode()) {
+    // If not IJK slicing, get the IJK slice from the XYZ position/slice
+    nSlice = mapper.getSliceAtPosition(nSlice);
+  }
+
+  ijk[ijkMode] += nSlice;
+  var worldOrigin = [0, 0, 0];
+  imageData.indexToWorld(ijk, worldOrigin); // Normal computation
+
+  ijk[ijkMode] += 1;
+  var worldNormal = [0, 0, 0];
+  imageData.indexToWorld(ijk, worldNormal);
+  worldNormal[0] -= worldOrigin[0];
+  worldNormal[1] -= worldOrigin[1];
+  worldNormal[2] -= worldOrigin[2];
+  vec3.normalize(worldNormal, worldNormal);
+  var intersect = vtkPlane.intersectWithLine(p1, p2, worldOrigin, worldNormal);
+
+  if (intersect.intersection) {
+    var point = intersect.x;
+    var absoluteIJK = [0, 0, 0];
+    imageData.worldToIndex(point, absoluteIJK); // `t` is the parametric position along the line
+    // defined in Plane.intersectWithLine
+
+    return {
+      t: intersect.t,
+      absoluteIJK: absoluteIJK
+    };
+  }
+
+  return null;
+}
+/**
+ * Implement point picking for image plane.
+ * The plane is defined by the imageData and current slice number,
+ * set in the input mapper.
+ *
+ * @param {Vector3} p1
+ * @param {Vector3} p2
+ * @param {vtkImageMapper|vtkImageArrayMapper} mapper
+ */
+
+
+function intersectWithLineForPointPicking(p1, p2, mapper) {
+  var pickingData = doPicking(p1, p2, mapper);
+
+  if (pickingData) {
+    var imageData = mapper.getCurrentImage();
+    var extent = imageData.getExtent(); // Get closer integer ijk
+    // NB: point picking means closest slice, means rounding
+
+    var ijk = [Math.round(pickingData.absoluteIJK[0]), Math.round(pickingData.absoluteIJK[1]), Math.round(pickingData.absoluteIJK[2])]; // Are we outside our actual extent
+
+    if (ijk[0] < extent[0] || ijk[0] > extent[1] || ijk[1] < extent[2] || ijk[1] > extent[3] || ijk[2] < extent[4] || ijk[2] > extent[5]) {
+      return null;
+    }
+
+    return {
+      t: pickingData.t,
+      ijk: ijk
+    };
+  }
+
+  return null;
+}
+/**
+ * Implement cell picking for image plane.
+ * The plane is defined by the imageData and current slice number,
+ * set in the input mapper.
+ *
+ * @param {Vector3} p1
+ * @param {Vector3} p2
+ * @param {vtkImageMapper|vtkImageArrayMapper} mapper
+ */
+
+function intersectWithLineForCellPicking(p1, p2, mapper) {
+  var pickingData = doPicking(p1, p2, mapper);
+
+  if (pickingData) {
+    var imageData = mapper.getCurrentImage();
+    var extent = imageData.getExtent();
+    var absIJK = pickingData.absoluteIJK; // Get closer integer ijk
+    // NB: cell picking means closest voxel, means flooring
+
+    var ijk = [Math.floor(absIJK[0]), Math.floor(absIJK[1]), Math.floor(absIJK[2])]; // Are we outside our actual extent
+
+    if (ijk[0] < extent[0] || ijk[0] > extent[1] - 1 || ijk[1] < extent[2] || ijk[1] > extent[3] - 1 || ijk[2] < extent[4] || // handle single-slice images
+    ijk[2] > (extent[5] ? extent[5] - 1 : extent[5])) {
+      return null;
+    } // Parametric coordinates within cell
+
+
+    var pCoords = [absIJK[0] - ijk[0], absIJK[1] - ijk[1], absIJK[2] - ijk[2]];
+    return {
+      t: pickingData.t,
+      ijk: ijk,
+      pCoords: pCoords
+    };
+  }
+
+  return null;
+}
+
+export { intersectWithLineForCellPicking, intersectWithLineForPointPicking };

package/Rendering/Core/AbstractImageMapper.d.ts

@@ -0,0 +1,82 @@
+import vtkAbstractMapper3D, { IAbstractMapper3DInitialValues } from './AbstractMapper3D';
+import vtkImageData from './../../Common/DataModel/ImageData';
+import { Nullable } from './../../types';
+
+
+export interface IAbstractImageMapperInitialValues extends IAbstractMapper3DInitialValues {
+	customDisplayExtent?: number[];
+	useCustomExtents?: boolean;
+	slice?: number;
+}
+
+export interface vtkAbstractImageMapper extends vtkAbstractMapper3D {
+
+	/**
+	 *
+	 */
+	getIsOpaque(): boolean;
+
+	/**
+  	 * Return currently active image for the mapper. Overridden by deriving classes.
+	 */
+	getCurrentImage(): Nullable<vtkImageData>;
+
+	/**
+	 * Get the slice index.
+	 */
+	getSlice(): number;
+
+	/**
+	 *
+	 * @param {Number} slice The slice index.
+	 */
+	setSlice(slice: number): boolean;
+
+	/**
+	 *
+	 */
+	getUseCustomExtents(): boolean;
+
+	/**
+	 *
+	 * @param {Boolean} useCustomExtents
+	 */
+	setUseCustomExtents(useCustomExtents: boolean): boolean;
+
+	/**
+	 *
+	 * @param {Number} x1 The x coordinate of the first point.
+	 * @param {Number} x2 The x coordinate of the second point.
+	 * @param {Number} y1 The y coordinate of the first point.
+	 * @param {Number} y2 The y coordinate of the second point.
+	 * @param {Number} z1 The z coordinate of the first point.
+	 * @param {Number} z2 The z coordinate of the second point.
+	 */
+	setCustomDisplayExtent(x1: number, x2: number, y1: number, y2: number, z1: number, z2: number): boolean;
+
+	/**
+	 *
+	 * @param customDisplayExtent
+	 */
+	setCustomDisplayExtentFrom(customDisplayExtent: number[]): boolean;
+}
+
+/**
+ * Method use to decorate a given object (publicAPI+model) with vtkAbstractImageMapper characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IAbstractImageMapperInitialValues} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues?: IAbstractImageMapperInitialValues): void;
+
+/**
+ * vtkImageMapper provides 2D image display support for vtk.
+ * 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 vtkAbstractImageMapper: {
+	extend: typeof extend;
+}
+export default vtkAbstractImageMapper;

package/Rendering/Core/AbstractImageMapper.js

@@ -0,0 +1,44 @@
+import macro from '../../macros.js';
+import vtkAbstractMapper3D from './AbstractMapper3D.js';
+
+// vtkAbstractImageMapper methods
+// ----------------------------------------------------------------------------
+
+function vtkAbstractImageMapper(publicAPI, model) {
+  model.classHierarchy.push('vtkAbstractImageMapper');
+
+  publicAPI.getIsOpaque = function () {
+    return true;
+  };
+
+  publicAPI.getCurrentImage = function () {
+    return null;
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {
+  slice: 0,
+  customDisplayExtent: [0, 0, 0, 0, 0, 0],
+  useCustomExtents: false,
+  backgroundColor: [0, 0, 0, 1]
+}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+
+  vtkAbstractMapper3D.extend(publicAPI, model, initialValues);
+  macro.setGet(publicAPI, model, ['slice', 'useCustomExtents']);
+  macro.setGetArray(publicAPI, model, ['customDisplayExtent'], 6);
+  macro.setGetArray(publicAPI, model, ['backgroundColor'], 4);
+  vtkAbstractImageMapper(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var vtkAbstractImageMapper$1 = {
+  extend: extend
+};
+
+export { vtkAbstractImageMapper$1 as default, extend };

package/Rendering/Core/Camera.js

@@ -1,7 +1,7 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import { mat4, vec4, vec3, quat } from 'gl-matrix';
 import macro from '../../macros.js';
-import { r as radiansFromDegrees, k as add, j as cross } from '../../Common/Core/Math/index.js';
+import { r as radiansFromDegrees, l as add, k as cross } from '../../Common/Core/Math/index.js';
 
 var vtkDebugMacro = macro.vtkDebugMacro;
 /* eslint-disable new-cap */

package/Rendering/Core/CellPicker.js

@@ -1,6 +1,6 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
-import { l as normalize } from '../../Common/Core/Math/index.js';
+import { g as normalize } from '../../Common/Core/Math/index.js';
 import vtkPicker from './Picker.js';
 import vtkPoints from '../../Common/Core/Points.js';
 import vtkTriangle from '../../Common/DataModel/Triangle.js';

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

@@ -0,0 +1,24 @@
+/**
+ * vtkColorMaps represents a global registry of preset color maps.
+ */
+
+import { Vector3 } from '../../../types';
+
+export interface IColorMapPreset {
+  Name: string;
+  Creator?: string;
+  ColorSpace?: string;
+  NanColor?: Vector3;
+  RGBPoints: number[];
+  IndexedColors?: number[];
+  Annotations?: (number | string)[];
+}
+
+export declare const vtkColorMaps: {
+  addPreset(preset: IColorMapPreset): void;
+  removePresetByName(name: string): void;
+  getPresetByName(name: string): IColorMapPreset;
+  rgbPresetNames: string[];
+};
+
+export default vtkColorMaps;