@kitware/vtk.js 25.4.0 → 25.7.0

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/IO/Core/DataAccessHelper/HtmlDataAccessHelper.js

@@ -1,4 +1,4 @@
-import pako from 'pako';
+import { strFromU8, decompressSync } from 'fflate';
 import macro from '../../../macros.js';
 import Base64 from '../../../Common/Core/Base64.js';
 import Endian from '../../../Common/Core/Endian.js';
@@ -59,9 +59,7 @@ function fetchArray(instance, baseURL, array) {
         var bText = atob(txt);
 
         if (options.compression) {
-          bText = pako.inflate(bText, {
-            to: 'string'
-          });
+          bText = strFromU8(decompressSync(bText));
         }
 
         array.values = JSON.parse(bText);
@@ -74,11 +72,9 @@ function fetchArray(instance, baseURL, array) {
 
         if (options.compression) {
           if (array.dataType === 'string' || array.dataType === 'JSON') {
-            array.buffer = pako.inflate(new Uint8Array(array.buffer), {
-              to: 'string'
-            });
+            array.buffer = strFromU8(decompressSync(new Uint8Array(array.buffer)));
           } else {
-            array.buffer = pako.inflate(new Uint8Array(array.buffer)).buffer;
+            array.buffer = decompressSync(new Uint8Array(array.buffer)).buffer;
           }
         }
 

package/IO/Core/DataAccessHelper/HttpDataAccessHelper.js

@@ -1,5 +1,5 @@
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import pako from 'pako';
+import { decompressSync, strFromU8 } from 'fflate';
 import macro from '../../../macros.js';
 import Endian from '../../../Common/Core/Endian.js';
 import { DataTypeByteSize } from '../../../Common/Core/DataArray/Constants.js';
@@ -48,9 +48,7 @@ function fetchBinary(url) {
       if (xhr.readyState === 4) {
         if (xhr.status === 200 || xhr.status === 0) {
           if (options.compression) {
-            resolve(pako.inflate(new Uint8Array(xhr.response), {
-              to: 'arraybuffer'
-            }).buffer);
+            resolve(decompressSync(new Uint8Array(xhr.response)).buffer);
           } else {
             resolve(xhr.response);
           }
@@ -101,11 +99,9 @@ function fetchArray(instance, baseURL, array) {
 
             if (options.compression) {
               if (array.dataType === 'string' || array.dataType === 'JSON') {
-                array.buffer = pako.inflate(new Uint8Array(array.buffer), {
-                  to: 'string'
-                });
+                array.buffer = strFromU8(decompressSync(new Uint8Array(array.buffer)));
               } else {
-                array.buffer = pako.inflate(new Uint8Array(array.buffer)).buffer;
+                array.buffer = decompressSync(new Uint8Array(array.buffer)).buffer;
               }
             }
 
@@ -175,9 +171,7 @@ function fetchJSON(instance, url) {
 
         if (xhr.status === 200 || xhr.status === 0) {
           if (options.compression) {
-            resolve(JSON.parse(pako.inflate(new Uint8Array(xhr.response), {
-              to: 'string'
-            })));
+            resolve(JSON.parse(strFromU8(decompressSync(new Uint8Array(xhr.response)))));
           } else {
             resolve(JSON.parse(xhr.responseText));
           }
@@ -222,9 +216,7 @@ function fetchText(instance, url) {
 
         if (xhr.status === 200 || xhr.status === 0) {
           if (options.compression) {
-            resolve(pako.inflate(new Uint8Array(xhr.response), {
-              to: 'string'
-            }));
+            resolve(strFromU8(decompressSync(new Uint8Array(xhr.response))));
           } else {
             resolve(xhr.responseText);
           }