@kitware/vtk.js 23.4.3 → 23.4.4

package/Filters/General/ContourTriangulator.d.ts

@@ -0,0 +1,136 @@
+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;
+
+	/**
+	 * Sets the behavior of the filter regarding polys.
+	 * @param {boolean} triangulate whether the filter should triangulate polys
+	 * or leave them untouched. True by default
+	 * @return {boolean} true if it changes
+	 */
+	setTriangulatePolys(triangulate: boolean): boolean;
+
+	/**
+	 * Returns the behavior of the filter regarding polys.
+	 * @return {boolean} True if the filter triangulates polys, false otherwise.
+	 */
+	getTriangulatePolys(): boolean;
+}
+
+// ----------------------------------------------------------------------------
+// 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,202 @@
+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 || normal === void 0 ? void 0 : normal.length) < 3;
+  vtkCCSMakePolysFromLines(polyData, firstLine, firstLine + numLines, oriented, newPolys, incompletePolys); // if no normal specified, then compute one from largest contour
+
+  var computedNormal = normal;
+
+  if (!oriented) {
+    computedNormal = [0, 0, 1];
+    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 = new Array(numNewPolys);
+
+  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]; // FIXME: do not instantiate a new polydata each time the filter is executed.
+
+    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, null, 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, ['triangulatePolys']); // 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 { g 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 { g 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/OBBNode.js

@@ -0,0 +1,82 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import macro from '../../../macros.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; }
+// vtkOBBNode methods
+// ----------------------------------------------------------------------------
+
+function vtkOBBNode(publicAPI, model) {
+  // Set our classname
+  model.classHierarchy.push('vtkOBBNode');
+  /**
+   * Copy a vtkOBBNode into an other one
+   * @param {vtkOBBNode} nodeSource
+   * @param {vtkOBBNode} nodeTarget
+   */
+
+  publicAPI.deepCopy = function (nodeSource) {
+    publicAPI.setCorner(nodeSource.getCorner());
+    var axes = nodeSource.getAxes();
+    publicAPI.setAxes([_toConsumableArray(axes[0]), _toConsumableArray(axes[1]), _toConsumableArray(axes[2])]);
+    publicAPI.setCells(_toConsumableArray(nodeSource.getCells()));
+
+    if (nodeSource.getKids()) {
+      var kids0 = vtkOBBNode.newInstance();
+      kids0.setParent(publicAPI);
+      var kids1 = vtkOBBNode.newInstance();
+      kids1.setParent(publicAPI);
+      kids0.deepCopy(nodeSource.getKids()[0]);
+      kids1.deepCopy(nodeSource.getKids()[1], kids1);
+      publicAPI.setKids(kids0, kids1);
+    }
+  };
+
+  publicAPI.getAxis = function (axis) {
+    return model.axes[axis];
+  };
+} // ----------------------------------------------------------------------------
+
+
+function defaultValues(initialValues) {
+  return _objectSpread({
+    corner: [0, 0, 0],
+    // center point of this node
+    axes: [[0, 0, 0], [0, 0, 0], [0, 0, 0]],
+    // the axes defining the OBB - ordered from long->short
+    cells: []
+  }, initialValues);
+} // ----------------------------------------------------------------------------
+
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, defaultValues(initialValues));
+  model.corner = [0, 0, 0];
+  model.axes = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];
+  model.parent = null; // parent node; null if root
+
+  model.kids = null; // two children of this node; nullptr if leaf
+
+  model.cells = []; // list of cells in node
+  // Build VTK API
+
+  macro.setGet(publicAPI, model, ['parent', 'cells', 'kids']); // macro.setGetArray(publicAPI, model, ['kids'], 2);
+
+  macro.setGetArray(publicAPI, model, ['corner', 'axes'], 3); // Make this a VTK object
+
+  macro.obj(publicAPI, model); // Object specific methods
+
+  vtkOBBNode(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkOBBNode'); // ----------------------------------------------------------------------------
+
+var vtkOBBNode$1 = {
+  newInstance: newInstance,
+  extend: extend
+};
+
+export { vtkOBBNode$1 as default, extend, newInstance };

package/Filters/General/OBBTree/helper.js

@@ -0,0 +1,92 @@
+import { CellType } from '../../../Common/DataModel/CellTypes/Constants.js';
+import vtkOBJReader from '../../../IO/Misc/OBJReader.js';
+
+/**
+ * Get the correct point ID from a cell id
+ * @param {Array} cellPtsIds
+ * @param {CellType} type
+ * @param {Number} idx
+ * @returns {Object} Contains three point's id of cells as 'ptId0', 'ptId1', 'ptId2'
+ */
+
+function getCellTriangles(cellPtsIds, type, idx) {
+  var ptId0 = -1;
+  var ptId1 = -1;
+  var ptId2 = -1;
+  var cellListLength = cellPtsIds.length;
+
+  switch (type) {
+    case CellType.VTK_TRIANGLE:
+    case CellType.VTK_POLYGON:
+    case CellType.VTK_QUAD:
+      {
+        if (idx > cellListLength) break;
+        ptId0 = cellPtsIds[0];
+        ptId1 = cellPtsIds[idx + 1];
+        ptId2 = cellPtsIds[idx + 2];
+        break;
+      }
+
+    case CellType.VTK_TRIANGLE_STRIP:
+      {
+        // eslint-disable-next-line no-bitwise
+        var idx1 = idx + 1 + (idx & 1); // eslint-disable-next-line no-bitwise
+
+        var idx2 = idx + 2 - (idx & 1);
+        if (idx1 > cellListLength || idx2 > cellListLength) break;
+        ptId0 = cellPtsIds[idx];
+        ptId1 = cellPtsIds[idx1];
+        ptId2 = cellPtsIds[idx2];
+        break;
+      }
+
+    default:
+      ptId0 = -1;
+      ptId1 = -1;
+      ptId2 = -1;
+      break;
+  }
+
+  return {
+    ptId0: ptId0,
+    ptId1: ptId1,
+    ptId2: ptId2
+  };
+}
+/**
+ * Concatenate second typed array to the first typed array.
+ * @param {TypedArray} first
+ * @param {TypedArray} second Must be of the same type as first
+ * @return {TypedArray}
+ */
+
+function pushArray(first, second) {
+  var firstLength = first.length;
+  var result = new first.constructor(firstLength + second.length);
+  result.set(first);
+  result.set(second, firstLength);
+  return result;
+}
+/**
+ * Load an obj with point's colors
+ *
+ * @param {string} url path to the OBJ file
+ * @return Promise
+ * ---> success : Return vtkPolyData
+ * ---> failed : Error message
+ */
+
+function loadOBJ(url) {
+  return new Promise(function (resolve, reject) {
+    var reader = vtkOBJReader.newInstance();
+    reader.setUrl(url).then(function () {
+      var data = reader.getOutputData();
+      resolve(data);
+    }, function () {
+      // eslint-disable-next-line prefer-promise-reject-errors
+      reject('Error when loading ', url);
+    });
+  });
+}
+
+export { getCellTriangles, loadOBJ, pushArray };