@kitware/vtk.js 24.9.0 → 24.12.0

package/Common/DataModel/PolyLine.d.ts

@@ -0,0 +1,63 @@
+import { Vector2, Vector3 } from './../../types';
+import vtkCell, { ICellInitialValues } from './Cell';
+import { IIntersectWithLine } from './Line';
+
+export interface IPolyLineInitialValues extends ICellInitialValues { }
+
+export interface vtkPolyLine extends vtkCell {
+
+	/**
+	 * Get the topological dimensional of the cell (0, 1, 2 or 3).
+	 */
+	getCellDimension(): number;
+
+	/**
+	 * @param {number} t1
+	 * @param {number} t2
+	 * @param {Vector3} p1 The first point coordinate.
+	 * @param {Vector3} p2 The second point coordinate.
+	 * @param {Number} tol The tolerance to use.
+	 * @param {Vector3} x The point which intersect the line.
+	 * @param {Vector3} pcoords The parametric coordinates.
+	 */
+	intersectWithLine(t1: number, t2: number, p1: Vector3, p2: Vector3, tol: number, x: Vector3, pcoords: Vector3): IIntersectWithLine;
+
+  /**
+   * Determine global coordinate (x[3]) from subId and parametric coordinates.
+   * Also returns interpolation weights. (The number of weights is equal to
+   * the number of points in the cell.)
+   * 
+   * @param {number} subId
+   * @param {Vector3} pcoords The parametric coordinates
+   * @param {Vector3} x The global coordinate
+   * @param {Vector2} weights The interpolation weights
+   */
+  evaluateLocation(subId: number, pcoords: Vector3, x: Vector3, weights: Vector2): void
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkPolyLine characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IPolyLineInitialValues} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues?: IPolyLineInitialValues): void;
+
+/**
+ * Method used to create a new instance of vtkPolyLine.
+ * @param {IPolyLineInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(initialValues?: IPolyLineInitialValues): vtkPolyLine;
+
+/** 
+ * vtkPolyLine is a cell which representant a poly line.
+ * 
+ * @see vtkCell
+ */
+export declare const vtkPolyLine: {
+	newInstance: typeof newInstance,
+	extend: typeof extend;
+};
+
+export default vtkPolyLine;

package/Common/DataModel/PolyLine.js

@@ -0,0 +1,77 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import macro from '../../macros.js';
+import vtkCell from './Cell.js';
+import vtkLine from './Line.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; }
+
+function vtkPolyLine(publicAPI, model) {
+  model.classHierarchy.push('vtkPolyLine');
+
+  var superClass = _objectSpread({}, publicAPI);
+
+  var line = vtkLine.newInstance();
+  line.getPoints().setNumberOfPoints(2);
+
+  publicAPI.getCellDimension = function () {
+    return 1;
+  };
+
+  publicAPI.intersectWithLine = function (t1, t2, p1, p2, tol, x, pcoords) {
+    var outObj = {
+      intersect: 0,
+      t: Number.MAX_VALUE,
+      subId: 0,
+      betweenPoints: null
+    };
+    var numLines = superClass.getPoints().getNumberOfPoints() - 1;
+    var pDistMin = Number.MAX_VALUE;
+
+    for (var subId = 0; subId < numLines; subId++) {
+      var pCoords = [0, 0, 0];
+      line.getPoints().getData().set(model.points.getData().subarray(3 * subId, 3 * (subId + 2)));
+      var lineIntersected = line.intersectWithLine(p1, p2, tol, x, pcoords);
+
+      if (lineIntersected.intersect === 1 && lineIntersected.t <= outObj.t + tol && lineIntersected.t >= t1 && lineIntersected.t <= t2) {
+        outObj.intersect = 1;
+        var pDist = line.getParametricDistance(pCoords);
+
+        if (pDist < pDistMin || pDist === pDistMin && lineIntersected.t < outObj.t) {
+          outObj.subId = subId;
+          outObj.t = lineIntersected.t;
+          pDistMin = pDist;
+        }
+      }
+    }
+
+    return outObj;
+  };
+
+  publicAPI.evaluateLocation = function (subId, pcoords, x, weights) {
+    line.getPoints().getData().set(model.points.getData().subarray(3 * subId, 3 * (subId + 2)));
+    return line.evaluateLocation(pcoords, x, weights);
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+  vtkCell.extend(publicAPI, model, initialValues);
+  vtkPolyLine(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkPolyLine'); // ----------------------------------------------------------------------------
+
+var vtkPolyLine$1 = {
+  newInstance: newInstance,
+  extend: extend
+};
+
+export { vtkPolyLine$1 as default, extend, newInstance };

package/Common/DataModel/Polygon.js

@@ -1,6 +1,6 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
-import { l as normalize, g as subtract, j as cross, k as add, d as dot, n as norm } from '../Core/Math/index.js';
+import { l as normalize, s as subtract, j as cross, k as add, d as dot, n as norm } from '../Core/Math/index.js';
 import vtkLine from './Line.js';
 import vtkPlane from './Plane.js';
 import vtkPriorityQueue from '../Core/PriorityQueue.js';

package/Common/DataModel/Spline1D/Constants.js

@@ -0,0 +1,17 @@
+// Boundary conditions available to compute open splines
+// DEFAULT : desired slope at boundary point is derivative from two points (boundary and second interior)
+// DERIVATIVE : desired slope at boundary point is the boundary value given.
+// SECOND_DERIVATIVE : second derivative at boundary point is the boundary value given.
+// SECOND_DERIVATIVE_INTERIOR_POINT : desired second derivative at boundary point is the boundary value given times second derivative
+// at first interior point.
+var BoundaryCondition = {
+  DEFAULT: 0,
+  DERIVATIVE: 1,
+  SECOND_DERIVATIVE: 2,
+  SECOND_DERIVATIVE_INTERIOR_POINT: 3
+};
+var Constants = {
+  BoundaryCondition: BoundaryCondition
+};
+
+export { BoundaryCondition, Constants as default };

package/Common/DataModel/Spline1D.d.ts

@@ -3,6 +3,19 @@ import { vtkObject } from './../../interfaces' ;
 
 export interface ISpline1DInitialValues {}
 
+// Boundary conditions available to compute open splines
+// DEFAULT : desired slope at boundary point is derivative from two points (boundary and second interior)
+// DERIVATIVE : desired slope at boundary point is the boundary value given.
+// SECOND_DERIVATIVE : second derivative at boundary point is the boundary value given.
+// SECOND_DERIVATIVE_INTERIOR_POINT : desired second derivative at boundary point is the boundary value given times second derivative
+// at first interior point.
+export enum BoundaryCondition {
+	DEFAULT,
+	DERIVATIVE,
+	SECOND_DERIVATIVE,
+	SECOND_DERIVATIVE_INTERIOR_POINT,
+  }
+
 export interface vtkSpline1D extends vtkObject {
 
 	/**
@@ -19,9 +32,14 @@ export interface vtkSpline1D extends vtkObject {
 	 * @param {Number} size 
 	 * @param {Float32Array} work 
 	 * @param {Number[]} x 
-	 * @param {Number[]} y 
+	 * @param {Number[]} y
+	 * @param {Object} options
+	 * @param {BoundaryCondition} options.leftConstraint
+	 * @param {Number} options.leftValue
+	 * @param {BoundaryCondition} options.rightConstraint
+	 * @param {Number} options.rightValue
 	 */
-	computeOpenCoefficients(size: number, work: Float32Array, x: number[], y: number[]): void;
+	computeOpenCoefficients(size: number, work: Float32Array, x: number[], y: number[], options: { leftConstraint: BoundaryCondition, leftValue: number, rightConstraint: BoundaryCondition, rightValue: Number }): void;
 		
 	/**
 	 * 

package/Common/DataModel/Spline3D/Constants.d.ts

@@ -0,0 +1,9 @@
+export declare enum splineKind {
+	CARDINAL_SPLINE = 'CARDINAL_SPLINE',
+	KOCHANEK_SPLINE = 'KOCHANEK_SPLINE',
+}
+
+declare const _default: {
+	splineKind: typeof splineKind;
+};
+export default _default;

package/Common/DataModel/Spline3D.d.ts

@@ -1,10 +1,5 @@
-import { vtkObject } from './../../interfaces' ;
-
-export enum splineKind {
-	CARDINAL_SPLINE,
-	KOCHANEK_SPLINE,
-}
-
+import { vtkObject } from './../../interfaces';
+import { splineKind } from './Spline3D/Constants';
 
 export interface ISpline3DInitialValues {
 	close?: boolean;
@@ -52,7 +47,7 @@ export function newInstance(initialValues?: ISpline3DInitialValues): vtkSpline3D
  * at any given point inside the spline intervals.
  */
 export declare const vtkSpline3D: {
-	newInstance: typeof newInstance,
-	extend: typeof extend
+	newInstance: typeof newInstance;
+	extend: typeof extend;
 };
 export default vtkSpline3D;

package/Common/DataModel/Spline3D.js

@@ -11,7 +11,7 @@ function vtkSpline3D(publicAPI, model) {
   // Set our classname
   model.classHierarchy.push('vtkSpline3D'); // --------------------------------------------------------------------------
 
-  function computeCoefficients1D(spline, points) {
+  function computeCoefficients1D(spline, points, boundaryConditionValue) {
     if (points.length === 0) {
       vtkErrorMacro('Splines require at least one points');
     } // If we have only one point we create a spline
@@ -25,23 +25,27 @@ function vtkSpline3D(publicAPI, model) {
     var size = points.length;
     var work = null;
     var intervals = null;
+    work = new Float32Array(size);
 
-    if (model.close) {
-      work = new Float32Array(size);
-
-      if (model.intervals.length === 0) {
-        intervals = new Float32Array(size);
+    if (model.intervals.length === 0) {
+      intervals = new Float32Array(size);
 
-        for (var i = 0; i < intervals.length; i++) {
-          intervals[i] = i;
-        }
-      } else {
-        intervals = model.intervals;
+      for (var i = 0; i < intervals.length; i++) {
+        intervals[i] = i;
       }
+    } else {
+      intervals = model.intervals;
+    }
 
+    if (model.close) {
       spline.computeCloseCoefficients(size, work, intervals, points);
     } else {
-      vtkErrorMacro('Open splines are not supported yet!');
+      spline.computeOpenCoefficients(size, work, intervals, points, {
+        leftConstraint: model.boundaryCondition,
+        leftValue: boundaryConditionValue,
+        rightConstraint: model.boundaryCondition,
+        rightValue: boundaryConditionValue
+      });
     }
   } // --------------------------------------------------------------------------
 
@@ -56,9 +60,9 @@ function vtkSpline3D(publicAPI, model) {
     var z = points.map(function (pt) {
       return pt[2];
     });
-    computeCoefficients1D(model.splineX, x);
-    computeCoefficients1D(model.splineY, y);
-    computeCoefficients1D(model.splineZ, z);
+    computeCoefficients1D(model.splineX, x, model.boundaryConditionValues[0]);
+    computeCoefficients1D(model.splineY, y, model.boundaryConditionValues[1]);
+    computeCoefficients1D(model.splineZ, z, model.boundaryConditionValues[2]);
   }; // --------------------------------------------------------------------------
 
 
@@ -101,6 +105,7 @@ var DEFAULT_VALUES = {
   close: false,
   intervals: [],
   kind: splineKind.KOCHANEK_SPLINE,
+  boundaryConditionValues: [0, 0, 0],
   // Passed to the vtkKochanekSpline1D
   tension: 0,
   continuity: 0,

package/Filters/General/ImageCropFilter.d.ts

@@ -1,10 +1,12 @@
 import { vtkAlgorithm, vtkObject } from './../../interfaces';
 
+type CroppingPlanes = number[];
+
 /**
  *
  */
-interface IImageCropFilterInitialValues {
-	croppingPlanes?: any;
+export interface IImageCropFilterInitialValues {
+	croppingPlanes?: CroppingPlanes;
 }
 
 type vtkImageCropFilterBase = vtkObject & vtkAlgorithm;
@@ -15,18 +17,19 @@ export interface vtkImageCropFilter extends vtkImageCropFilterBase {
 	 * Get The cropping planes, in IJK space.
 	 * @default [0, 0, 0, 0, 0, 0].
 	 */
-	getCroppingPlanes(): number[];
+	getCroppingPlanes(): CroppingPlanes;
 
 	/**
 	 * Get The cropping planes, in IJK space.
 	 * @default [0, 0, 0, 0, 0, 0].
 	 */
-	getCroppingPlanesByReference(): number[];
+	getCroppingPlanesByReference(): CroppingPlanes;
 
 	/**
 	 *
 	 */
 	isResetAvailable(): boolean;
+
 	/**
 	 *
 	 */
@@ -43,13 +46,13 @@ export interface vtkImageCropFilter extends vtkImageCropFilterBase {
 	 *
 	 * @param croppingPlanes
 	 */
-	setCroppingPlanes(croppingPlanes: number[]): boolean;
+	setCroppingPlanes(croppingPlanes: CroppingPlanes): boolean;
 
 	/**
 	 *
 	 * @param croppingPlanes
 	 */
-	setCroppingPlanesFrom(croppingPlanes: number[]): boolean;
+	setCroppingPlanesFrom(croppingPlanes: CroppingPlanes): boolean;
 }
 
 /**

package/Filters/Sources/LineSource.js

@@ -1,6 +1,6 @@
 import macro from '../../macros.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
-import { g as subtract, n as norm } from '../../Common/Core/Math/index.js';
+import { s as subtract, n as norm } from '../../Common/Core/Math/index.js';
 
 var vtkWarningMacro = macro.vtkWarningMacro; // ----------------------------------------------------------------------------
 // vtkLineSource methods

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 { g as subtract, l as normalize, d as dot, j as cross, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
+import { s as subtract, l as normalize, d as dot, j 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/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 { g 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, l as normalize, d as dot, r as radiansFromDegrees, j 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 { B as areEquals, l as normalize, d as dot, C as clampValue, g as subtract, j as cross, x as multiplyScalar, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
+import { B as areEquals, l as normalize, d as dot, C as clampValue, s as subtract, j as cross, x as multiplyScalar, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 
 var States = vtkInteractorStyleConstants.States; // ----------------------------------------------------------------------------
 // vtkMouseCameraUnicamRotateManipulator methods

package/Interaction/Widgets/OrientationMarkerWidget/Constants.d.ts

@@ -0,0 +1,11 @@
+export declare enum Corners {
+	TOP_LEFT = 'TOP_LEFT',
+	TOP_RIGHT = 'TOP_RIGHT',
+	BOTTOM_LEFT = 'BOTTOM_LEFT',
+	BOTTOM_RIGHT = 'BOTTOM_RIGHT',
+}
+
+declare const _default: {
+	Corners: typeof Corners;
+};
+export default _default;

package/Interaction/Widgets/OrientationMarkerWidget.d.ts

@@ -4,13 +4,8 @@ import vtkAxesActor from './../../Rendering/Core/AxesActor';
 import vtkRenderer from './../../Rendering/Core/Renderer';
 import vtkRenderWindowInteractor from './../../Rendering/Core/RenderWindowInteractor';
 import { Nullable } from './../../types';
+import { Corners } from './OrientationMarkerWidget/Constants';
 
-export enum Corners {
-	TOP_LEFT,
-	TOP_RIGHT,
-	BOTTOM_LEFT,
-	BOTTOM_RIGHT,
-}
 
 /**
  * 
@@ -177,5 +172,6 @@ export function newInstance(initialValues?: IOrientationMarkerWidgetInitialValue
 export declare const vtkOrientationMarkerWidget: {
 	newInstance: typeof newInstance;
 	extend: typeof extend;
+	Corners: typeof Corners;
 }
 export default vtkOrientationMarkerWidget;

package/Rendering/Core/CellPicker.js

@@ -1,9 +1,12 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
-import { l as normalize } from '../../Common/Core/Math/index.js';
+import vtkCellTypes from '../../Common/DataModel/CellTypes.js';
+import vtkLine from '../../Common/DataModel/Line.js';
 import vtkPicker from './Picker.js';
-import vtkPoints from '../../Common/Core/Points.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 { CellType } from '../../Common/DataModel/CellTypes/Constants.js';
 import { vec3 } 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; }
@@ -12,6 +15,12 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 // Global methods
 // ----------------------------------------------------------------------------
 
+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;
+}
+
 function clipLineWithPlane(mapper, matrix, p1, p2) {
   var outObj = {
     planeId: -1,
@@ -214,8 +223,10 @@ function vtkCellPicker(publicAPI, model) {
     var minXYZ = [0, 0, 0];
     var pDistMin = Number.MAX_VALUE;
     var minPCoords = [0, 0, 0];
-    var minCellId = -1;
-    var minCell = vtkTriangle.newInstance();
+    var minCellId = null;
+    var minCell = null;
+    var minCellType = null;
+    var subId = null;
     var x = [];
     var data = mapper.getInputData();
 
@@ -235,30 +246,35 @@ function vtkCellPicker(publicAPI, model) {
       }
     }
 
-    if (data.getPolys) {
-      var cellObject = data.getPolys();
-      var points = data.getPoints();
-      var cellData = cellObject.getData();
-      var cellId = 0;
-      var pointsIdList = [-1, -1, -1];
-      var cell = vtkTriangle.newInstance();
-      var cellPoints = vtkPoints.newInstance(); // cross all cells
+    if (data.getCells) {
+      if (!data.getCells()) {
+        data.buildLinks();
+      }
 
-      for (var i = 0; i < cellData.length; cellId++) {
-        var pCoords = [0, 0, 0];
-        var nbPointsInCell = cellData[i++];
-        cellPoints.setNumberOfPoints(nbPointsInCell); // Extract cell points
+      var tempCellMap = createCellMap();
+      var minCellMap = createCellMap();
+      var numberOfCells = data.getNumberOfCells();
 
-        for (var _j = 0; _j < nbPointsInCell; _j++) {
-          pointsIdList[_j] = cellData[i++];
-        } // Create cell from points
+      for (var cellId = 0; cellId < numberOfCells; cellId++) {
+        var pCoords = [0, 0, 0];
+        minCellType = data.getCellType(cellId);
+        var cell = tempCellMap[minCellType];
 
+        if (cell == null) {
+          // eslint-disable-next-line no-continue
+          continue;
+        }
 
-        cell.initialize(points, pointsIdList);
+        minCell = minCellMap[minCellType];
+        data.getCell(cellId, cell);
         var cellPicked = void 0;
 
         {
-          cellPicked = cell.intersectWithLine(p1, p2, tol, x, pCoords);
+          if (vtkCellTypes.hasSubCells(minCellType)) {
+            cellPicked = cell.intersectWithLine(t1, t2, p1, p2, tol, x, pCoords);
+          } else {
+            cellPicked = cell.intersectWithLine(p1, p2, tol, x, pCoords);
+          }
         }
 
         if (cellPicked.intersect === 1 && cellPicked.t <= tMin + model.tolerance && cellPicked.t >= t1 && cellPicked.t <= t2) {
@@ -267,6 +283,7 @@ function vtkCellPicker(publicAPI, model) {
           if (pDist < pDistMin || pDist === pDistMin && cellPicked.t < tMin) {
             tMin = cellPicked.t;
             pDistMin = pDist;
+            subId = cellPicked.subId;
             minCellId = cellId;
             cell.deepCopy(minCell);
 
@@ -281,17 +298,21 @@ function vtkCellPicker(publicAPI, model) {
 
     if (minCellId >= 0 && tMin < model.globalTMin) {
       resetPickInfo();
+      var nbPointsInCell = minCell.getNumberOfPoints();
+      var weights = new Array(nbPointsInCell);
 
-      var _nbPointsInCell = minCell.getNumberOfPoints();
-
-      var weights = new Array(_nbPointsInCell);
-
-      for (var _i = 0; _i < _nbPointsInCell; _i++) {
-        weights[_i] = 0.0;
+      for (var i = 0; i < nbPointsInCell; i++) {
+        weights[i] = 0.0;
       }
 
       var point = [];
-      minCell.evaluateLocation(minPCoords, point, weights); // Return the polydata to the user
+
+      if (vtkCellTypes.hasSubCells(minCellType)) {
+        minCell.evaluateLocation(subId, minPCoords, point, weights);
+      } else {
+        minCell.evaluateLocation(minPCoords, point, weights);
+      } // Return the polydata to the user
+
 
       model.dataSet = data;
       model.cellId = minCellId;
@@ -302,10 +323,10 @@ function vtkCellPicker(publicAPI, model) {
       var maxWeight = 0;
       var iMaxWeight = -1;
 
-      for (var _i2 = 0; _i2 < _nbPointsInCell; _i2++) {
-        if (weights[_i2] > maxWeight) {
-          iMaxWeight = _i2;
-          maxWeight = weights[_i2];
+      for (var _i = 0; _i < nbPointsInCell; _i++) {
+        if (weights[_i] > maxWeight) {
+          iMaxWeight = _i;
+          maxWeight = weights[_i];
         }
       } // If maximum weight is found, use it to get the PointId
 

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

@@ -0,0 +1,26 @@
+export declare enum ColorMode {
+	DEFAULT = 0,
+	MAP_SCALARS = 1,
+	DIRECT_SCALARS = 2,
+}
+
+export declare enum ScalarMode {
+	DEFAULT = 0,
+	USE_POINT_DATA = 1,
+	USE_CELL_DATA = 2,
+	USE_POINT_FIELD_DATA = 3,
+	USE_CELL_FIELD_DATA = 4,
+	USE_FIELD_DATA = 5,
+}
+
+export declare enum GetArray {
+	BY_ID = 0,
+	BY_NAME = 1,
+}
+
+declare const _default: {
+	ColorMode: typeof ColorMode;
+	ScalarMode: typeof ScalarMode;
+	GetArray: typeof GetArray;
+};
+export default _default;

package/Rendering/Core/Mapper.d.ts

@@ -1,25 +1,6 @@
 import { Bounds, Nullable, Range } from './../../types';
 import vtkAbstractMapper3D, { IAbstractMapper3DInitialValues } from './AbstractMapper3D';
-
-export enum ColorMode {
-	DEFAULT,
-	MAP_SCALARS,
-	DIRECT_SCALARS,
-}
-
-export enum ScalarMode {
-	DEFAULT,
-	USE_POINT_DATA,
-	USE_CELL_DATA,
-	USE_POINT_FIELD_DATA,
-	USE_CELL_FIELD_DATA,
-	USE_FIELD_DATA,
-}
-
-export enum GetArray {
-	BY_ID,
-	BY_NAME,
-}
+import { ColorMode, GetArray, ScalarMode } from './Mapper/Constants';
 
 interface IPrimitiveCount {
 	points: number;
@@ -166,7 +147,7 @@ export interface vtkMapper extends vtkAbstractMapper3D {
 	/**
 	 * Return the method of coloring scalar data.
 	 */
-	getColorMode(): number;
+	getColorMode(): ColorMode;
 
 	/**
 	 * Return the method of coloring scalar data.
@@ -643,5 +624,8 @@ export declare const vtkMapper: {
 	getResolveCoincidentTopologyLineOffsetParameters: typeof getResolveCoincidentTopologyLineOffsetParameters;
 	getResolveCoincidentTopologyPointOffsetParameters: typeof getResolveCoincidentTopologyPointOffsetParameters;
 	getResolveCoincidentTopologyPolygonOffsetParameters: typeof getResolveCoincidentTopologyPolygonOffsetParameters;
+	ColorMode: typeof ColorMode;
+	ScalarMode: typeof ScalarMode;
+	GetArray: typeof GetArray;
 }
 export default vtkMapper;