@kitware/vtk.js 25.5.0 → 25.7.1

package/Filters/General/ContourTriangulator.d.ts

@@ -0,0 +1,122 @@
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+import { Nullable, TypedArray, Vector3 } from './../../types';
+import vtkCellArray from './../../Common/Core/CellArray';
+import vtkPolyData from './../../Common/DataModel/PolyData';
+import vtkPoints from './../../Common/Core/Points';
+
+/**
+ *
+ */
+export interface IContourTriangulatorInitialValues {
+	triangulatePolys?: boolean;
+}
+
+type vtkContourTriangulatorBase = vtkObject & vtkAlgorithm;
+
+export interface vtkContourTriangulator extends vtkContourTriangulatorBase {
+	/**
+	 *
+	 * @param {any} inData
+	 * @param {any} outData
+	 */
+	requestData(inData: any, outData: any): void;
+}
+
+// ----------------------------------------------------------------------------
+// Static API
+// ----------------------------------------------------------------------------
+
+/**
+ * This is a complex subroutine that takes a collection of lines that
+ * were formed by cutting a polydata with a plane, and generates
+ * a face that has those lines as its edges.  The lines must form one
+ * or more closed contours, but they need not be sorted.
+ *
+ * Only "numLine" lines starting from "firstLine" are used to create new
+ * polygons, and the new polygons are appended to "polys". The normal of
+ * the cut plane must be provided so that polys will be correctly oriented.
+ *
+ * Given some closed contour lines, create a triangle mesh that fills
+ * those lines. The input lines do not have to be in tail-to-tip order.
+ * Only numLines starting from firstLine will be used. Note that holes
+ * can be indicated by contour loops whose normals are in the opposite
+ * direction to the provided normal.
+ *
+ * @param {vtkPolyData} polyData
+ * @param {Number} firstLine
+ * @param {Number} numLines
+ * @param {vtkCellArray} polys
+ * @param {Nullable<Vector3>} normal If null, the function will compute
+ * the normal of the polys.
+ * @param {Boolean} [triangulatePolys] (default: true) If set to true
+ * the resulting polygons will be triangulated, otherwise the polygons
+ * themselves will be added to the output.
+ * @param {Boolean} [diagnoseOnTriangulationError] (default: false)
+ * If this option is set to true and there was a triangulation error
+ * this will add the polys as outlines to the output.
+ * @returns {Boolean} Returns true if triangulation was successful,
+ * false otherwise.
+ */
+export function triangulateContours(
+	polyData: vtkPolyData,
+	firstLine: number,
+	numLines: number,
+	polys: vtkCellArray,
+	normal: Nullable<Vector3>,
+	triangulatePolys?: boolean,
+	diagnoseOnTriangulationError?: boolean
+): boolean;
+
+/**
+ * A robust method for triangulating a polygon. It cleans up the polygon
+ * and then applies the ear-cut triangulation. A zero return value
+ * indicates that triangulation failed.
+ *
+ * @param {Array<Number>|TypedArray} polygon Array of point indices defining the polygon
+ * @param {vtkPoints} points The point coordinates of the polygon
+ * @param {vtkCellArray} triangles The cell array that is going to be
+ * filled with the triangulation
+ * @returns {Boolean} Returns true if triangulation was successful,
+ * false otherwise.
+ */
+export function triangulatePolygon(
+	polygon: Array<number> | TypedArray,
+	points: vtkPoints,
+	triangles: vtkCellArray
+): boolean;
+
+/**
+ * Method use to decorate a given object (publicAPI+model) with vtkContourTriangulator characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IContourTriangulatorInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+	publicAPI: object,
+	model: object,
+	initialValues?: IContourTriangulatorInitialValues
+): void;
+
+// ----------------------------------------------------------------------------
+
+/**
+ * Method use to create a new instance of vtkContourTriangulator
+ * @param {IContourTriangulatorInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+	initialValues?: IContourTriangulatorInitialValues
+): vtkContourTriangulator;
+
+/**
+ * vtkContourTriangulator
+ */
+export declare const vtkContourTriangulator: {
+	newInstance: typeof newInstance;
+	extend: typeof extend;
+	// static
+	triangulateContours: typeof triangulateContours;
+	triangulatePolygon: typeof triangulatePolygon;
+};
+
+export default vtkContourTriangulator;

package/Filters/General/ContourTriangulator.js

@@ -0,0 +1,200 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import macro from '../../macros.js';
+import vtkCellArray from '../../Common/Core/CellArray.js';
+import vtkPolygon from '../../Common/DataModel/Polygon.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
+import { vtkCCSMakePolysFromLines, vtkCCSJoinLooseEnds, vtkCCSFindTrueEdges, vtkCCSMakeHoleyPolys, vtkCCSCutHoleyPolys, vtkCCSSplitAtPinchPoints, vtkCCSTriangulate } from './ContourTriangulator/helper.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 vtkErrorMacro = macro.vtkErrorMacro;
+var TRIANGULATION_ERROR_DISPLAY = false;
+
+function triangulateContours(polyData, firstLine, numLines, polys, normal) {
+  var triangulatePolys = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : true;
+  var triangulationFailure = false; // If no cut lines were generated, there's nothing to do
+
+  if (numLines <= 0) {
+    return false;
+  }
+
+  var points = polyData.getPoints(); // Join all the new lines into connected groups, i.e. polygons.
+  // If we are lucky these will be simple, convex polygons. But
+  // we can't count on that.
+
+  var newPolys = [];
+  var incompletePolys = [];
+  var oriented = normal != null;
+  vtkCCSMakePolysFromLines(polyData, firstLine, firstLine + numLines, oriented, newPolys, incompletePolys); // if no normal specified, then compute one from largest contour
+
+  var computedNormal = normal;
+
+  if (normal == null) {
+    var maxnorm = 0;
+    var n = [];
+
+    for (var i = 0; i < newPolys.length; i++) {
+      var norm = vtkPolygon.getNormal(newPolys[i], points, n);
+
+      if (norm > maxnorm) {
+        maxnorm = norm;
+        computedNormal[0] = n[0];
+        computedNormal[1] = n[1];
+        computedNormal[2] = n[2];
+      }
+    }
+  } // Join any loose ends. If the input was a closed surface then there
+  // will not be any loose ends, so this is provided as a service to users
+  // who want to clip a non-closed surface.
+
+
+  vtkCCSJoinLooseEnds(newPolys, incompletePolys, points, computedNormal); // Some points might be in the middle of straight line segments.
+  // These points can be removed without changing the shape of the
+  // polys, and removing them makes triangulation more stable.
+  // Unfortunately removing these points also means that the polys
+  // will no longer form a watertight cap over the cut.
+
+  var polyEdges = [];
+  var originalEdges = [];
+  vtkCCSFindTrueEdges(newPolys, points, polyEdges, originalEdges); // Next we have to check for polygons with holes, i.e. polygons that
+  // have other polygons inside. Each polygon is "grouped" with the
+  // polygons that make up its holes.
+  // Initialize each group to hold just one polygon.
+
+  var numNewPolys = newPolys.length;
+  var polyGroups = [];
+
+  for (var _i = 0; _i < numNewPolys; _i++) {
+    polyGroups[_i] = [_i];
+  } // Find out which polys are holes in larger polys. Create a group
+  // for each poly where the first member of the group is the larger
+  // poly, and all other members are the holes. The number of polyGroups
+  // will be the same as the number of polys, and any polys that are
+  // holes will have a matching empty group.
+
+
+  vtkCCSMakeHoleyPolys(newPolys, points, polyGroups, polyEdges, originalEdges, computedNormal, oriented); // Make cuts to create simple polygons out of the holey polys.
+  // After this is done, each polyGroup will have exactly 1 polygon,
+  // and no polys will be holes. This is currently the most computationally
+  // expensive part of the process.
+
+  if (!vtkCCSCutHoleyPolys(newPolys, points, polyGroups, polyEdges, computedNormal)) {
+    triangulationFailure = true;
+  } // Some polys might be self-intersecting. Split the polys at each intersection point.
+
+
+  vtkCCSSplitAtPinchPoints(newPolys, points, polyGroups, polyEdges, computedNormal, oriented); // ------ Triangulation code ------
+  // Go through all polys and triangulate them
+
+  for (var polyId = 0; polyId < polyGroups.length; polyId++) {
+    // If group is empty, then poly was a hole without a containing poly
+    if (polyGroups[polyId].length === 0) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+
+    if (!triangulatePolys) {
+      polys.insertNextCell(originalEdges.slice(1, originalEdges.length));
+    } else if (!vtkCCSTriangulate(newPolys[polyId], points, polyEdges[polyId], originalEdges, polys, computedNormal)) {
+      triangulationFailure = false; // Diagnostic code: show the polys as outlines
+    }
+  }
+
+  return !triangulationFailure;
+} // ---------------------------------------------------
+
+
+function triangulatePolygon(polygon, points, triangles) {
+  var poly = _toConsumableArray(polygon);
+
+  var polys = [poly];
+  var originalEdges = [];
+  var polyEdges = [];
+  vtkCCSFindTrueEdges(polys, points, polyEdges, originalEdges);
+  var edges = polyEdges[0];
+  var success = true;
+  var normal = [];
+  var norm = vtkPolygon.getNormal(poly, points, normal);
+
+  if (norm !== 0) {
+    success = vtkCCSTriangulate(poly, points, edges, originalEdges, triangles, normal);
+  }
+
+  return success;
+}
+
+var STATIC = {
+  triangulateContours: triangulateContours,
+  triangulatePolygon: triangulatePolygon
+};
+
+function vtkContourTriangulator(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkContourTriangulator');
+
+  publicAPI.requestData = function (inData, outData) {
+    // implement requestData
+    var input = inData[0];
+    var output = vtkPolyData.newInstance();
+    outData[0] = output;
+
+    if (!input) {
+      vtkErrorMacro('Invalid or missing input');
+      return false;
+    }
+
+    var triangulationError = false;
+    var lines = input.getLines();
+
+    if (lines == null || lines.getNumberOfCells() === 0) {
+      return true;
+    }
+
+    input.buildCells();
+    var polysArray = vtkCellArray.newInstance({
+      dataType: VtkDataTypes.DOUBLE,
+      empty: true
+    });
+    output.setPolys(polysArray);
+    output.setPoints(input.getPoints());
+    output.getPointData().passData(input.getPointData());
+    triangulationError = !triangulateContours(input, input.getNumberOfVerts(), lines.getNumberOfCells(), polysArray, [], model.triangulatePolys);
+
+    if (triangulationError && TRIANGULATION_ERROR_DISPLAY) {
+      vtkErrorMacro('Triangulation failed, output might have holes.');
+    }
+
+    return true;
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {
+  triangulatePolys: true
+}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues); // Make this a VTK object
+
+  macro.obj(publicAPI, model); // Also make it an algorithm with one input and one output
+
+  macro.algo(publicAPI, model, 1, 1);
+  macro.setGet(publicAPI, model, ['triangulate']); // Object specific methods
+
+  vtkContourTriangulator(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkContourTriangulator'); // ----------------------------------------------------------------------------
+
+var vtkContourTriangulator$1 = _objectSpread({
+  newInstance: newInstance,
+  extend: extend
+}, STATIC);
+
+export { STATIC, vtkContourTriangulator$1 as default, extend, newInstance };

package/Filters/General/ImageMarchingCubes.js

@@ -1,7 +1,7 @@
 import macro from '../../macros.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
-import { l as normalize } from '../../Common/Core/Math/index.js';
+import { m as normalize } from '../../Common/Core/Math/index.js';
 import vtkCaseTable from './ImageMarchingCubes/caseTable.js';
 
 var vtkErrorMacro = macro.vtkErrorMacro,

package/Filters/General/MoleculeToRepresentation.js

@@ -1,7 +1,7 @@
 import macro from '../../macros.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { l as normalize } from '../../Common/Core/Math/index.js';
+import { m as normalize } from '../../Common/Core/Math/index.js';
 import { a as atomElem } from '../../Utilities/XMLConverter/chemistry/elements.json.js';
 
 var vtkErrorMacro = macro.vtkErrorMacro,

package/Filters/General/OBBTree.js

@@ -2,7 +2,7 @@ import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 import vtkCellArray from '../../Common/Core/CellArray.js';
 import vtkLine from '../../Common/DataModel/Line.js';
-import { d as dot, j as cross, n as norm, w as jacobi, l as normalize, k as add } from '../../Common/Core/Math/index.js';
+import { d as dot, k as cross, n as norm, w as jacobi, m as normalize, l as add } from '../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 import vtkOBBNode from './OBBTree/OBBNode.js';
 import vtkPoints from '../../Common/Core/Points.js';

package/Filters/General/TubeFilter.js

@@ -1,7 +1,7 @@
 import macro from '../../macros.js';
 import vtkCellArray from '../../Common/Core/CellArray.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { l as normalize, j as cross, n as norm, d as dot, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
+import { m as normalize, k as cross, n as norm, d as dot, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 import vtkPoints from '../../Common/Core/Points.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import { DesiredOutputPrecision } from '../../Common/DataModel/DataSetAttributes/Constants.js';

package/Filters/General/WindowedSincPolyDataFilter.js

@@ -2,7 +2,7 @@ import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { t as vtkMath } from '../../Common/Core/Math/index.js';
+import { g as vtkMath } from '../../Common/Core/Math/index.js';
 import { AttributeTypes } from '../../Common/DataModel/DataSetAttributes/Constants.js';
 import vtkPoints from '../../Common/Core/Points.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';

package/Filters/Sources/PlaneSource.js

@@ -2,7 +2,7 @@ import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { s as subtract, l as normalize, d as dot, j as cross, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
+import { s as subtract, m as normalize, d as dot, k as cross, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 

package/Filters/Texture/TextureMapToPlane.js

@@ -1,6 +1,6 @@
 import macro from '../../macros.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { l as normalize, d as dot, j as cross, f as distance2BetweenPoints, z as determinant3x3, A as rowsToMat3 } from '../../Common/Core/Math/index.js';
+import { m as normalize, d as dot, k as cross, f as distance2BetweenPoints, z as determinant3x3, A as rowsToMat3 } from '../../Common/Core/Math/index.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 
 var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------

package/Interaction/Manipulators/KeyboardCameraManipulator.js

@@ -1,7 +1,7 @@
 import macro from '../../macros.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkCompositeKeyboardManipulator from './CompositeKeyboardManipulator.js';
-import { k as add, l as normalize, j as cross } from '../../Common/Core/Math/index.js';
+import { l as add, m as normalize, k as cross } from '../../Common/Core/Math/index.js';
 
 var vtkErrorMacro = macro.vtkErrorMacro;
 var ANIMATION_REQUESTER = 'vtkKeyboardCameraManipulator'; // ----------------------------------------------------------------------------

package/Interaction/Manipulators/MouseCameraAxisRotateManipulator.js

@@ -3,7 +3,7 @@ import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
-import { r as radiansFromDegrees, j as cross } from '../../Common/Core/Math/index.js';
+import { r as radiansFromDegrees, k as cross } from '../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 
 // vtkMouseCameraAxisRotateManipulator methods

package/Interaction/Manipulators/MouseCameraTrackballPanManipulator.js

@@ -1,7 +1,7 @@
 import macro from '../../macros.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
-import { j as cross } from '../../Common/Core/Math/index.js';
+import { k as cross } from '../../Common/Core/Math/index.js';
 
 // vtkMouseCameraTrackballPanManipulator methods
 // ----------------------------------------------------------------------------

package/Interaction/Manipulators/MouseCameraTrackballRotateManipulator.js

@@ -2,7 +2,7 @@ import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
-import { x as multiplyScalar, d as dot, k as add, r as radiansFromDegrees, j as cross } from '../../Common/Core/Math/index.js';
+import { x as multiplyScalar, d as dot, l as add, r as radiansFromDegrees, k as cross } from '../../Common/Core/Math/index.js';
 
 // vtkMouseCameraTrackballRotateManipulator methods
 // ----------------------------------------------------------------------------

package/Interaction/Manipulators/MouseCameraUnicamManipulator.js

@@ -5,7 +5,7 @@ import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
 import vtkInteractorStyleConstants from '../../Rendering/Core/InteractorStyle/Constants.js';
 import vtkMouseCameraUnicamRotateManipulator from './MouseCameraUnicamRotateManipulator.js';
 import macro from '../../macros.js';
-import { s as subtract, x as multiplyScalar, l as normalize, d as dot, r as radiansFromDegrees, j as cross } from '../../Common/Core/Math/index.js';
+import { s as subtract, x as multiplyScalar, m as normalize, d as dot, r as radiansFromDegrees, k as cross } from '../../Common/Core/Math/index.js';
 
 var States = vtkInteractorStyleConstants.States; // ----------------------------------------------------------------------------
 // vtkMouseCameraUnicamManipulator methods

package/Interaction/Manipulators/MouseCameraUnicamRotateManipulator.js

@@ -10,7 +10,7 @@ import vtkSphereSource from '../../Filters/Sources/SphereSource.js';
 import { FieldAssociations } from '../../Common/DataModel/DataSet/Constants.js';
 import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
-import { C as areEquals, l as normalize, d as dot, D as clampValue, s as subtract, j as cross, x as multiplyScalar, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
+import { C as areEquals, m as normalize, d as dot, D as clampValue, s as subtract, k as cross, x as multiplyScalar, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 
 var States = vtkInteractorStyleConstants.States; // ----------------------------------------------------------------------------
 // vtkMouseCameraUnicamRotateManipulator methods

package/Interaction/Style/InteractorStyleMPRSlice.js

@@ -1,6 +1,6 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
-import { l as normalize, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
+import { m as normalize, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 import vtkInteractorStyleManipulator from './InteractorStyleManipulator.js';
 import vtkMouseCameraTrackballRotateManipulator from '../Manipulators/MouseCameraTrackballRotateManipulator.js';

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, F as getMajorAxisIndex } from '../../Common/Core/Math/index.js';
+import { k as cross, F as getMajorAxisIndex } from '../../Common/Core/Math/index.js';
 
 var DEFAULT_STEP_WIDTH = 512;
 

package/Rendering/Core/Actor2D.d.ts

@@ -1,7 +1,7 @@
 import vtkProp, { IPropInitialValues } from './Prop';
 import vtkCoordinate from './Coordinate';
 import vtkMapper from './Mapper';
-import vtkProperty from './Property';
+import vtkProperty2D, { IProperty2DInitialValues } from './Property2D';
 import { Bounds } from './../../types';
 
 /**
@@ -9,7 +9,7 @@ import { Bounds } from './../../types';
  */
 export interface IActor2DInitialValues extends IPropInitialValues {
 	mapper?: vtkMapper;
-	property?: vtkProperty;
+	property?: vtkProperty2D;
 	layerNumber?: number;
 	positionCoordinate?: vtkCoordinate;
 	positionCoordinate2?: vtkCoordinate;
@@ -31,12 +31,18 @@ export interface vtkActor2D extends vtkProp {
 
 	/**
 	 * Return the property object that controls this actors surface
-	 * properties. This should be an instance of a vtkProperty object. Every
+	 * properties. This should be an instance of a vtkProperty2D object. Every
 	 * actor must have a property associated with it. If one isn’t specified,
 	 * then one will be generated automatically. Multiple actors can share one
 	 * property object.
 	 */
-	getProperty(): vtkProperty;
+	getProperty(): vtkProperty2D;
+
+	/**
+	 * Create a new property suitable for use with this type of Actor.
+	 * @param {IProperty2DInitialValues} [initialValues] (default: {})
+	 */
+	 makeProperty(initialValues?: IProperty2DInitialValues): vtkProperty2D;
 
 	/**
 	 * 
@@ -112,8 +118,8 @@ export function newInstance(initialValues?: IActor2DInitialValues): vtkActor2D;
  * vtkProp. The actor also has scaling and maintains a reference to the
  * defining geometry (i.e., the mapper), rendering properties, and possibly a
  * texture map.
- * @see [vtkMapper](./Rendering_Core_Mapper.html)2D
- * @see [vtkProperty](./Rendering_Core_Property.html)2D 
+ * @see [vtkMapper2D](./Rendering_Core_Mapper2D.html)
+ * @see [vtkProperty2D](./Rendering_Core_Property2D.html)
  */
 export declare const vtkActor2D: {
 	newInstance: typeof newInstance,

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

@@ -5,7 +5,8 @@ import vtkLine from '../../Common/DataModel/Line.js';
 import vtkPicker from './Picker.js';
 import vtkPolyLine from '../../Common/DataModel/PolyLine.js';
 import vtkTriangle from '../../Common/DataModel/Triangle.js';
-import { l as normalize } from '../../Common/Core/Math/index.js';
+import vtkQuad from '../../Common/DataModel/Quad.js';
+import { m as normalize } from '../../Common/Core/Math/index.js';
 import { CellType } from '../../Common/DataModel/CellTypes/Constants.js';
 import { vec3 } from 'gl-matrix';
 
@@ -18,7 +19,7 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 function createCellMap() {
   var _ref;
 
-  return _ref = {}, _defineProperty(_ref, CellType.VTK_LINE, vtkLine.newInstance()), _defineProperty(_ref, CellType.VTK_POLY_LINE, vtkPolyLine.newInstance()), _defineProperty(_ref, CellType.VTK_TRIANGLE, vtkTriangle.newInstance()), _ref;
+  return _ref = {}, _defineProperty(_ref, CellType.VTK_LINE, vtkLine.newInstance()), _defineProperty(_ref, CellType.VTK_POLY_LINE, vtkPolyLine.newInstance()), _defineProperty(_ref, CellType.VTK_TRIANGLE, vtkTriangle.newInstance()), _defineProperty(_ref, CellType.VTK_QUAD, vtkQuad.newInstance()), _ref;
 }
 
 function clipLineWithPlane(mapper, matrix, p1, p2) {

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;

package/Rendering/Core/Light.js

@@ -1,5 +1,5 @@
 import macro from '../../macros.js';
-import { l as normalize, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
+import { m as normalize, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
 import { vec3 } from 'gl-matrix';
 
 var LIGHT_TYPES = ['HeadLight', 'CameraLight', 'SceneLight']; // ----------------------------------------------------------------------------

package/Rendering/Core/Picker.js

@@ -2,7 +2,7 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
 import vtkAbstractPicker from './AbstractPicker.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
-import { d as dot, l as normalize, n as norm, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
+import { d as dot, m as normalize, n as norm, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 import { mat4, vec4 } from 'gl-matrix';
 
 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/Property2D.d.ts

@@ -2,7 +2,7 @@ import { vtkObject } from './../../interfaces';
 import { RGBColor } from './../../types';
 import { DisplayLocation } from './Property2D/Constants';
 
-interface IProperty2DInitialValues{
+export interface IProperty2DInitialValues{
 	color?: RGBColor;
 	opacity?: number;
 	pointSize?: number;

package/Rendering/Core/VolumeProperty.d.ts

@@ -5,7 +5,7 @@ import { InterpolationType, OpacityMode } from './VolumeProperty/Constants';
 
 export interface IVolumePropertyInitialValues  {
 	independentComponents?: boolean;
-	shade?: number;
+	shade?: boolean;
 	ambient?: number;
 	diffuse?: number;
 	specular?: number;
@@ -111,7 +111,7 @@ export interface vtkVolumeProperty extends vtkObject {
 	/**
 	 * Get the shading of a volume.
 	 */
-	getShade(): number;
+	getShade(): boolean;
 
 	/**
 	 *
@@ -236,9 +236,9 @@ export interface vtkVolumeProperty extends vtkObject {
 	 * turning shading off is generally the same as setting ambient=1,
 	 * diffuse=0, specular=0. Shading can be independently turned on/off per
 	 * component.
-	 * @param {Number} shade 
+	 * @param {Boolean} shade
 	 */
-	setShade(shade: number): boolean;
+	setShade(shade: boolean): boolean;
 
 	/**
 	 *

package/Rendering/Core/VolumeProperty.js

@@ -237,7 +237,7 @@ function vtkVolumeProperty(publicAPI, model) {
 var DEFAULT_VALUES = {
   independentComponents: true,
   interpolationType: InterpolationType.FAST_LINEAR,
-  shade: 0,
+  shade: false,
   ambient: 0.1,
   diffuse: 0.7,
   specular: 0.2,