@kitware/vtk.js 34.11.3 → 34.13.0

package/Common/Core/CellArray.d.ts

@@ -46,6 +46,11 @@ export interface vtkCellArray extends vtkDataArray {
    * @returns {Number} Idx of where the cell was inserted
    */
   insertNextCell(cellPointIds: number[]): number;
+
+  /**
+   * Get the maximum cell size.
+   */
+  getMaxCellSize(): number;
 }
 
 /**

package/Common/Core/CellArray.js

@@ -113,6 +113,7 @@ function vtkCellArray(publicAPI, model) {
     }
     return cellId;
   };
+  publicAPI.getMaxCellSize = () => publicAPI.getCellSizes().reduce((a, b) => Math.max(a, b), 0);
 }
 
 // ----------------------------------------------------------------------------

package/Common/Core/Math/index.js

@@ -2267,4 +2267,4 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   'default': vtkMath
 });
 
-export { createArray as $, rowsToMat3 as A, degreesFromRadians as B, ldexp as C, xyz2rgb as D, areEquals as E, clampValue as F, arrayRange as G, getMajorAxisIndex as H, createUninitializedBounds as I, normalize4D as J, identity as K, multiplyMatrix as L, floor as M, isInf as N, rgb2hsv as O, rgb2lab as P, lab2rgb as Q, round as R, normalize2D as S, nearestPowerOfTwo as T, multiply3x3_vect3 as U, getSparseOrthogonalMatrix as V, areBoundsInitialized as W, floatRGB2HexCode as X, isPowerOfTwo as Y, angleBetweenVectors as Z, signedAngleBetweenVectors as _, areMatricesEqual as a, isNaN as a$, Pi as a0, ceil as a1, min as a2, max as a3, arrayMin as a4, arrayMax as a5, ceilLog2 as a6, factorial as a7, binomial as a8, beginCombination as a9, quaternionToMatrix3x3 as aA, roundNumber as aB, matrix3x3ToQuaternion as aC, multiplyQuaternion as aD, orthogonalize3x3 as aE, diagonalize3x3 as aF, singularValueDecomposition3x3 as aG, luFactorLinearSystem as aH, luSolveLinearSystem as aI, estimateMatrixCondition as aJ, solveHomogeneousLeastSquares as aK, solveLeastSquares as aL, hex2float as aM, lab2xyz as aN, xyz2lab as aO, rgb2xyz as aP, computeBoundsFromPoints as aQ, clampAndNormalizeValue as aR, getScalarTypeFittingRange as aS, getAdjustedScalarRange as aT, extentIsWithinOtherExtent as aU, boundsIsWithinOtherBounds as aV, pointIsWithinBounds as aW, solve3PointCircle as aX, inf as aY, negInf as aZ, isFinite as a_, nextCombination as aa, randomSeed as ab, getSeed as ac, gaussian as ad, multiplyScalar2D as ae, multiplyAccumulate2D as af, outer as ag, projectVector as ah, dot2D as ai, projectVector2D as aj, gaussianAmplitude as ak, gaussianWeight as al, outer2D as am, norm2D as an, rowsToMat4 as ao, columnsToMat4 as ap, columnsToMat3 as aq, LUFactor3x3 as ar, LUSolve3x3 as as, linearSolve3x3 as at, multiply3x3_mat3 as au, transpose3x3 as av, invert3x3 as aw, identity3x3 as ax, isIdentity as ay, isIdentity3x3 as az, roundVector as b, floatToHex2 as b0, float2CssRGBA as b1, clampVector as c, dot as d, distance2BetweenPoints as e, vtkMath as f, solveLinearSystem as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, invertMatrix as p, jacobiN as q, radiansFromDegrees as r, subtract as s, perpendiculars as t, uninitializeBounds as u, vtkMath$1 as v, jacobi as w, multiplyScalar as x, random as y, determinant3x3 as z };
+export { createArray as $, rowsToMat3 as A, degreesFromRadians as B, ldexp as C, xyz2rgb as D, areEquals as E, clampValue as F, arrayRange as G, getMajorAxisIndex as H, createUninitializedBounds as I, normalize4D as J, identity as K, multiplyMatrix as L, floor as M, isInf as N, rgb2hsv as O, rgb2lab as P, lab2rgb as Q, round as R, normalize2D as S, nearestPowerOfTwo as T, multiply3x3_vect3 as U, getSparseOrthogonalMatrix as V, areBoundsInitialized as W, floatRGB2HexCode as X, isPowerOfTwo as Y, angleBetweenVectors as Z, signedAngleBetweenVectors as _, areMatricesEqual as a, isNaN as a$, Pi as a0, ceil as a1, min as a2, max as a3, arrayMin as a4, arrayMax as a5, ceilLog2 as a6, factorial as a7, binomial as a8, beginCombination as a9, quaternionToMatrix3x3 as aA, roundNumber as aB, matrix3x3ToQuaternion as aC, multiplyQuaternion as aD, orthogonalize3x3 as aE, diagonalize3x3 as aF, singularValueDecomposition3x3 as aG, luFactorLinearSystem as aH, luSolveLinearSystem as aI, estimateMatrixCondition as aJ, solveHomogeneousLeastSquares as aK, solveLeastSquares as aL, hex2float as aM, lab2xyz as aN, xyz2lab as aO, rgb2xyz as aP, computeBoundsFromPoints as aQ, clampAndNormalizeValue as aR, getScalarTypeFittingRange as aS, getAdjustedScalarRange as aT, extentIsWithinOtherExtent as aU, boundsIsWithinOtherBounds as aV, pointIsWithinBounds as aW, solve3PointCircle as aX, inf as aY, negInf as aZ, isFinite as a_, nextCombination as aa, randomSeed as ab, getSeed as ac, gaussian as ad, multiplyScalar2D as ae, multiplyAccumulate2D as af, outer as ag, projectVector as ah, dot2D as ai, projectVector2D as aj, gaussianAmplitude as ak, gaussianWeight as al, outer2D as am, norm2D as an, rowsToMat4 as ao, columnsToMat4 as ap, columnsToMat3 as aq, LUFactor3x3 as ar, LUSolve3x3 as as, linearSolve3x3 as at, multiply3x3_mat3 as au, transpose3x3 as av, invert3x3 as aw, identity3x3 as ax, isIdentity as ay, isIdentity3x3 as az, vtkMath as b, floatToHex2 as b0, float2CssRGBA as b1, roundVector as c, dot as d, clampVector as e, distance2BetweenPoints as f, solveLinearSystem as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, invertMatrix as p, jacobiN as q, radiansFromDegrees as r, subtract as s, perpendiculars as t, uninitializeBounds as u, vtkMath$1 as v, jacobi as w, multiplyScalar as x, random as y, determinant3x3 as z };

package/Common/Core/Math.d.ts

@@ -788,7 +788,7 @@ export function solveLinearSystem(A: Matrix, x: number[], size: number): number;
  * @param {Number} [size] The square size of the matrix to invert : 4 for a 4x4
  * @param {Number[]} [index]
  * @param {Number[]} [column]
- * @return AI on success, null otherwise
+ * @returns AI on success, null otherwise
  */
 export function invertMatrix(
   A: Matrix,
@@ -1136,6 +1136,7 @@ export function isFinite(value: any): boolean;
  * operations such as dot and cross products and vector norm; matrix determinant
  * for 2x2 and 3x3 matrices; univariate polynomial solvers; and for random
  * number generation (for backward compatibility only).
+ * **Contrary to the rest of vtk.js, vtkMath is in row-major format (similar to VTK C++).**
  */
 export declare const vtkMath: {
   createArray: typeof createArray;

package/Common/Core/Math.js

@@ -1,4 +1,4 @@
 import 'seedrandom';
 import '../../macros2.js';
 import './Math/Constants.js';
-export { ar as LUFactor3x3, as as LUSolve3x3, a0 as Pi, k as add, Z as angleBetweenVectors, W as areBoundsInitialized, E as areEquals, a as areMatricesEqual, a5 as arrayMax, a4 as arrayMin, G as arrayRange, a9 as beginCombination, a8 as binomial, aV as boundsIsWithinOtherBounds, a1 as ceil, a6 as ceilLog2, aR as clampAndNormalizeValue, F as clampValue, c as clampVector, aq as columnsToMat3, ap as columnsToMat4, aQ as computeBoundsFromPoints, $ as createArray, I as createUninitializedBounds, j as cross, f as default, B as degreesFromRadians, o as determinant2x2, z as determinant3x3, aF as diagonalize3x3, e as distance2BetweenPoints, d as dot, ai as dot2D, aJ as estimateMatrixCondition, aU as extentIsWithinOtherExtent, a7 as factorial, b1 as float2CssRGBA, X as floatRGB2HexCode, b0 as floatToHex2, M as floor, ad as gaussian, ak as gaussianAmplitude, al as gaussianWeight, aT as getAdjustedScalarRange, H as getMajorAxisIndex, aS as getScalarTypeFittingRange, ac as getSeed, V as getSparseOrthogonalMatrix, aM as hex2float, h as hsv2rgb, K as identity, ax as identity3x3, aY as inf, aw as invert3x3, p as invertMatrix, a_ as isFinite, ay as isIdentity, az as isIdentity3x3, N as isInf, a$ as isNaN, i as isNan, Y as isPowerOfTwo, w as jacobi, q as jacobiN, Q as lab2rgb, aN as lab2xyz, C as ldexp, at as linearSolve3x3, aH as luFactorLinearSystem, aI as luSolveLinearSystem, aC as matrix3x3ToQuaternion, a3 as max, a2 as min, au as multiply3x3_mat3, U as multiply3x3_vect3, m as multiplyAccumulate, af as multiplyAccumulate2D, L as multiplyMatrix, aD as multiplyQuaternion, x as multiplyScalar, ae as multiplyScalar2D, T as nearestPowerOfTwo, aZ as negInf, aa as nextCombination, n as norm, an as norm2D, l as normalize, S as normalize2D, J as normalize4D, aE as orthogonalize3x3, ag as outer, am as outer2D, t as perpendiculars, aW as pointIsWithinBounds, ah as projectVector, aj as projectVector2D, aA as quaternionToMatrix3x3, r as radiansFromDegrees, y as random, ab as randomSeed, O as rgb2hsv, P as rgb2lab, aP as rgb2xyz, R as round, aB as roundNumber, b as roundVector, A as rowsToMat3, ao as rowsToMat4, _ as signedAngleBetweenVectors, aG as singularValueDecomposition3x3, aX as solve3PointCircle, aK as solveHomogeneousLeastSquares, aL as solveLeastSquares, g as solveLinearSystem, s as subtract, av as transpose3x3, u as uninitializeBounds, aO as xyz2lab, D as xyz2rgb } from './Math/index.js';
+export { ar as LUFactor3x3, as as LUSolve3x3, a0 as Pi, k as add, Z as angleBetweenVectors, W as areBoundsInitialized, E as areEquals, a as areMatricesEqual, a5 as arrayMax, a4 as arrayMin, G as arrayRange, a9 as beginCombination, a8 as binomial, aV as boundsIsWithinOtherBounds, a1 as ceil, a6 as ceilLog2, aR as clampAndNormalizeValue, F as clampValue, e as clampVector, aq as columnsToMat3, ap as columnsToMat4, aQ as computeBoundsFromPoints, $ as createArray, I as createUninitializedBounds, j as cross, b as default, B as degreesFromRadians, o as determinant2x2, z as determinant3x3, aF as diagonalize3x3, f as distance2BetweenPoints, d as dot, ai as dot2D, aJ as estimateMatrixCondition, aU as extentIsWithinOtherExtent, a7 as factorial, b1 as float2CssRGBA, X as floatRGB2HexCode, b0 as floatToHex2, M as floor, ad as gaussian, ak as gaussianAmplitude, al as gaussianWeight, aT as getAdjustedScalarRange, H as getMajorAxisIndex, aS as getScalarTypeFittingRange, ac as getSeed, V as getSparseOrthogonalMatrix, aM as hex2float, h as hsv2rgb, K as identity, ax as identity3x3, aY as inf, aw as invert3x3, p as invertMatrix, a_ as isFinite, ay as isIdentity, az as isIdentity3x3, N as isInf, a$ as isNaN, i as isNan, Y as isPowerOfTwo, w as jacobi, q as jacobiN, Q as lab2rgb, aN as lab2xyz, C as ldexp, at as linearSolve3x3, aH as luFactorLinearSystem, aI as luSolveLinearSystem, aC as matrix3x3ToQuaternion, a3 as max, a2 as min, au as multiply3x3_mat3, U as multiply3x3_vect3, m as multiplyAccumulate, af as multiplyAccumulate2D, L as multiplyMatrix, aD as multiplyQuaternion, x as multiplyScalar, ae as multiplyScalar2D, T as nearestPowerOfTwo, aZ as negInf, aa as nextCombination, n as norm, an as norm2D, l as normalize, S as normalize2D, J as normalize4D, aE as orthogonalize3x3, ag as outer, am as outer2D, t as perpendiculars, aW as pointIsWithinBounds, ah as projectVector, aj as projectVector2D, aA as quaternionToMatrix3x3, r as radiansFromDegrees, y as random, ab as randomSeed, O as rgb2hsv, P as rgb2lab, aP as rgb2xyz, R as round, aB as roundNumber, c as roundVector, A as rowsToMat3, ao as rowsToMat4, _ as signedAngleBetweenVectors, aG as singularValueDecomposition3x3, aX as solve3PointCircle, aK as solveHomogeneousLeastSquares, aL as solveLeastSquares, g as solveLinearSystem, s as subtract, av as transpose3x3, u as uninitializeBounds, aO as xyz2lab, D as xyz2rgb } from './Math/index.js';

package/Common/Core/MatrixBuilder.d.ts

@@ -131,6 +131,7 @@ declare function buildFromRadian(): Transform;
  * The `vtkMatrixBuilder` class provides a system to create a mat4
  * transformation matrix. All functions return the MatrixBuilder Object
  * instance, allowing transformations to be chained.
+ * **Note**: Contrary to vtkMath, vtkMatrixBuilder uses column-major format.
  *
  * @example
  * ```js

package/Common/DataModel/BoundingBox.js

@@ -842,6 +842,7 @@ const STATIC = {
   getLengths,
   getMaxLength,
   getDiagonalLength,
+  getDiagonalLength2,
   getMinPoint,
   getMaxPoint,
   getXRange,

package/Common/DataModel/DataSet.js

@@ -1,39 +1,10 @@
 import { m as macro } from '../../macros2.js';
 import vtk from '../../vtk.js';
+import vtkBoundingBox from './BoundingBox.js';
 import vtkDataSetAttributes from './DataSetAttributes.js';
+import { b as vtkMath } from '../Core/Math/index.js';
 import Constants from './DataSet/Constants.js';
 
-// import vtkBoundingBox from '../BoundingBox';
-// import * as vtkMath from '../../Core/Math';
-//
-// function getBounds(dataset) {
-//   if (dataset.bounds) {
-//     return dataset.bounds;
-//   }
-//   if (dataset.type && dataset[dataset.type]) {
-//     const ds = dataset[dataset.type];
-//     if (ds.bounds) {
-//       return ds.bounds;
-//     }
-//     if (ds.Points && ds.Points.bounds) {
-//       return ds.Points.bounds;
-//     }
-
-//     if (ds.Points && ds.Points.values) {
-//       const array = ds.Points.values;
-//       const bbox = [...vtkBoundingBox.INIT_BOUNDS];
-//       const size = array.length;
-//       const delta = ds.Points.numberOfComponents ? ds.Points.numberOfComponents : 3;
-//       for (let idx = 0; idx < size; idx += delta) {
-//         vtkBoundingBox.addPoint(bbox, array[idx * delta], array[(idx * delta) + 1], array[(idx * delta) + 2]);
-//       }
-//       ds.Points.bounds = bbox;
-//       return ds.Points.bounds;
-//     }
-//   }
-//   return vtkMath.createUninitializedBounds();
-// }
-
 // ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
@@ -56,6 +27,60 @@ function vtkDataSet(publicAPI, model) {
       model[fieldName] = vtk(model[fieldName]);
     }
   });
+
+  //------------------------------------------------------------------------------
+  // Compute the data bounding box from data points.
+  publicAPI.computeBounds = () => {
+    if (model.modifiedTime && model.computeTime && model.modifiedTime > model.computeTime || !model.computeTime) {
+      const points = publicAPI.getPoints();
+      if (points?.getNumberOfPoints()) {
+        // Compute bounds from points
+        vtkBoundingBox.setBounds(model.bounds, points.getBoundsByReference());
+      } else {
+        model.bounds = vtkMath.createUninitializedBounds();
+      }
+      // Update computeTime
+      model.computeTime = macro.getCurrentGlobalMTime();
+    }
+  };
+
+  /**
+   * Returns the squared length of the diagonal of the bounding box
+   */
+  publicAPI.getLength2 = () => {
+    const bounds = publicAPI.getBoundsByReference();
+    if (!bounds || bounds.length !== 6) return 0;
+    return vtkBoundingBox.getDiagonalLength2(bounds);
+  };
+
+  /**
+   * Returns the length of the diagonal of the bounding box
+   */
+  publicAPI.getLength = () => Math.sqrt(publicAPI.getLength2());
+
+  /**
+   * Returns the center of the bounding box as [x, y, z]
+   */
+  publicAPI.getCenter = () => {
+    const bounds = publicAPI.getBoundsByReference();
+    if (!bounds || bounds.length !== 6) return [0, 0, 0];
+    return vtkBoundingBox.getCenter(bounds);
+  };
+
+  /**
+   * Get the bounding box of a cell with the given cellId
+   * @param {Number} cellId - The id of the cell
+   * @returns {Number[]} - The bounds as [xmin, xmax, ymin, ymax, zmin, zmax]
+   */
+  publicAPI.getCellBounds = cellId => {
+    const cell = publicAPI.getCell(cellId);
+    if (cell) {
+      return cell.getBounds();
+    }
+    return vtkMath.createUninitializedBounds();
+  };
+  publicAPI.getBounds = macro.chain(() => publicAPI.computeBounds, publicAPI.getBounds);
+  publicAPI.getBoundsByReference = macro.chain(() => publicAPI.computeBounds, publicAPI.getBoundsByReference);
   const superShallowCopy = publicAPI.shallowCopy;
   publicAPI.shallowCopy = function (other) {
     let debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
@@ -92,7 +117,7 @@ function extend(publicAPI, model) {
   // Object methods
   macro.obj(publicAPI, model);
   macro.setGet(publicAPI, model, DATASET_FIELDS);
-
+  macro.getArray(publicAPI, model, ['bounds'], 6);
   // Object specific methods
   vtkDataSet(publicAPI, model);
 }

package/Common/DataModel/DataSetAttributes/FieldData.js

@@ -34,8 +34,8 @@ function vtkFieldData(publicAPI, model) {
   publicAPI.copyStructure = other => {
     publicAPI.initializeFields();
     model.copyFieldFlags = other.getCopyFieldFlags().map(x => x); // Deep-copy
-    model.arrays = other.arrays().map(x => ({
-      array: x
+    model.arrays = other.getArrays().map(x => ({
+      data: x
     })); // Deep-copy
     // TODO: Copy array information objects (once we support information objects)
   };

package/Common/DataModel/ImageData.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../macros2.js';
-import { b as roundVector, c as clampVector } from '../Core/Math/index.js';
+import { c as roundVector, e as clampVector } from '../Core/Math/index.js';
 import vtkBoundingBox from './BoundingBox.js';
 import vtkDataSet from './DataSet.js';
 import vtkStructuredData from './StructuredData.js';

package/Common/DataModel/IncrementalOctreeNode.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../macros2.js';
-import { e as distance2BetweenPoints } from '../Core/Math/index.js';
+import { f as distance2BetweenPoints } from '../Core/Math/index.js';
 
 const {
   vtkErrorMacro

package/Common/DataModel/IncrementalOctreePointLocator.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../macros2.js';
-import { f as vtkMath } from '../Core/Math/index.js';
+import { b as vtkMath } from '../Core/Math/index.js';
 import vtkBoundingBox from './BoundingBox.js';
 import vtkIncrementalOctreeNode from './IncrementalOctreeNode.js';
 import vtkAbstractPointLocator from './AbstractPointLocator.js';

package/Common/DataModel/Line.js

@@ -1,7 +1,7 @@
 import { m as macro } from '../../macros2.js';
 import Constants from './Line/Constants.js';
 import vtkCell from './Cell.js';
-import { d as dot, e as distance2BetweenPoints, s as subtract, g as solveLinearSystem } from '../Core/Math/index.js';
+import { d as dot, f as distance2BetweenPoints, s as subtract, g as solveLinearSystem } from '../Core/Math/index.js';
 import { quat } from 'gl-matrix';
 
 const {

package/Common/DataModel/MergePoints.js

@@ -122,9 +122,9 @@ const newInstance = macro.newInstance(extend, 'vtkMergePoints');
 
 // ----------------------------------------------------------------------------
 
-var index = {
+var vtkMergePoints$1 = {
   newInstance,
   extend
 };
 
-export { index as default, extend, newInstance };
+export { vtkMergePoints$1 as default, extend, newInstance };

package/Common/DataModel/Planes.js

@@ -1,7 +1,7 @@
 import { m as macro, T as TYPED_ARRAYS } from '../../macros2.js';
 import vtkDataArray from '../Core/DataArray.js';
 import vtkImplicitFunction from './ImplicitFunction.js';
-import { f as vtkMath } from '../Core/Math/index.js';
+import { b as vtkMath } from '../Core/Math/index.js';
 import vtkPlane from './Plane.js';
 import vtkPoints from '../Core/Points.js';
 import { VtkDataTypes } from '../Core/DataArray/Constants.js';

package/Common/DataModel/PointLocator.js

@@ -1,6 +1,6 @@
 import { m as macro } from '../../macros2.js';
 import vtkCellArray from '../Core/CellArray.js';
-import { f as vtkMath } from '../Core/Math/index.js';
+import { b as vtkMath } from '../Core/Math/index.js';
 import vtkPoints from '../Core/Points.js';
 import vtkAbstractPointLocator from './AbstractPointLocator.js';
 import vtkBoundingBox from './BoundingBox.js';

package/Common/DataModel/PolyData.d.ts

@@ -66,9 +66,15 @@ export interface vtkPolyData extends vtkPointSet {
   getLines(): vtkCellArray;
 
   /**
-   *
+   * Get the links between points and cells.
    */
-  getLinks(): any;
+  getLinks(): any; // vtkCellLinks
+
+  /**
+   * Get the maximum cell size.
+   * Returns 0 if there is no cell.
+   */
+  getMaxCellSize(): number;
 
   /**
    * Determine the number of cells composing the polydata.
@@ -104,7 +110,7 @@ export interface vtkPolyData extends vtkPointSet {
    * Topological inquiry to get cells using point.
    * @param ptId
    */
-  getPointCells(ptId: any): void;
+  getPointCells(ptId: number): void;
 
   /**
    * Get the cell array defining polys.

package/Common/DataModel/PolyData.js

@@ -5,7 +5,11 @@ import vtkCellLinks from './CellLinks.js';
 import vtkCellTypes from './CellTypes.js';
 import vtkLine from './Line.js';
 import vtkPointSet from './PointSet.js';
+import vtkPolyLine from './PolyLine.js';
+import vtkPolygon from './Polygon.js';
+import vtkQuad from './Quad.js';
 import vtkTriangle from './Triangle.js';
+import vtkTriangleStrip from './TriangleStrip.js';
 import { CellType } from './CellTypes/Constants.js';
 import { POLYDATA_FIELDS } from './PolyData/Constants.js';
 
@@ -14,8 +18,12 @@ const {
 } = macro;
 const CELL_FACTORY = {
   [CellType.VTK_LINE]: vtkLine,
+  [CellType.VTK_QUAD]: vtkQuad,
   [CellType.VTK_POLY_LINE]: vtkLine,
-  [CellType.VTK_TRIANGLE]: vtkTriangle
+  [CellType.VTK_TRIANGLE]: vtkTriangle,
+  [CellType.VTK_TRIANGLE_STRIP]: vtkTriangleStrip,
+  [CellType.VTK_POLY_LINE]: vtkPolyLine,
+  [CellType.VTK_POLYGON]: vtkPolygon
 };
 
 // ----------------------------------------------------------------------------
@@ -206,6 +214,7 @@ function vtkPolyData(publicAPI, model) {
     cell.initialize(publicAPI.getPoints(), cellInfo.cellPointIds);
     return cell;
   };
+  publicAPI.getMaxCellSize = () => POLYDATA_FIELDS.reduce((max, type) => Math.max(max, model[type]?.getMaxCellSize?.() ?? 0), 0);
 }
 
 // ----------------------------------------------------------------------------

package/Common/DataModel/Polygon.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../macros2.js';
-import { d as dot, s as subtract, j as cross, k as add, l as normalize, e as distance2BetweenPoints, n as norm } from '../Core/Math/index.js';
+import { d as dot, s as subtract, j as cross, k as add, l as normalize, f as distance2BetweenPoints, 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/Quad.js

@@ -1,6 +1,6 @@
 import { m as macro } from '../../macros2.js';
 import vtkCell from './Cell.js';
-import { e as distance2BetweenPoints } from '../Core/Math/index.js';
+import { f as distance2BetweenPoints } from '../Core/Math/index.js';
 import { CellType } from './CellTypes/Constants.js';
 import vtkTriangle from './Triangle.js';
 import vtkPoints from '../Core/Points.js';

package/Common/DataModel/Triangle.js

@@ -1,6 +1,6 @@
 import { m as macro, T as TYPED_ARRAYS } from '../../macros2.js';
 import vtkCell from './Cell.js';
-import { d as dot, j as cross, l as normalize, m as multiplyAccumulate, e as distance2BetweenPoints, o as determinant2x2, s as subtract, p as invertMatrix } from '../Core/Math/index.js';
+import { d as dot, j as cross, l as normalize, m as multiplyAccumulate, f as distance2BetweenPoints, o as determinant2x2, s as subtract, p as invertMatrix } from '../Core/Math/index.js';
 import vtkLine from './Line.js';
 import vtkPlane from './Plane.js';
 

package/Common/Transform/Transform.d.ts

@@ -286,6 +286,7 @@ export function newInstance(
  * Most of the methods for manipulating this transformation (e.g. transformMatrices, transformMatrix) (TODO: Translate, Rotate, Concatenate...) can operate in either PreMultiply (the default) or PostMultiply mode. In PreMultiply mode, the translation, concatenation, etc. will occur before any transformations which are represented by the current matrix. In PostMultiply mode, the additional transformation will occur after any transformations represented by the current matrix.
  *
  * This class performs all of its operations in a right handed coordinate system with right handed rotations. Some other graphics libraries use left handed coordinate systems and rotations.
+ * **Note**: vtkTransform uses column-major format.
  *
  * @example
  * ```js

package/Common/Transform/Transform.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../macros2.js';
-import { f as vtkMath } from '../Core/Math/index.js';
+import { b as vtkMath } from '../Core/Math/index.js';
 import { IDENTITY } from '../Core/Math/Constants.js';
 import { vec3, mat4, quat, mat3 } from 'gl-matrix';
 

package/Filters/Core/CleanPolyData.d.ts

@@ -0,0 +1,208 @@
+import { DesiredOutputPrecision } from './../../Common/DataModel/DataSetAttributes';
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+import { Bounds, Vector3 } from './../../types';
+
+/**
+ * Initial values for vtkCleanPolyData.
+ */
+export interface ICleanPolyDataInitialValues {
+  /**
+   * The tolerance used for point merging.
+   */
+  tolerance?: number;
+
+  /**
+   * Whether the tolerance is absolute or relative.
+   */
+  toleranceIsAbsolute?: boolean;
+
+  /**
+   * The absolute tolerance value.
+   */
+  absoluteTolerance?: number;
+
+  /**
+   * The desired output precision for points.
+   */
+  outputPointsPrecision?: DesiredOutputPrecision;
+
+  /**
+   * Whether to merge points.
+   */
+  pointMerging?: boolean;
+
+  /**
+   * Whether to convert lines to points.
+   */
+  convertLinesToPoints?: boolean;
+
+  /**
+   * Whether to convert polygons to lines.
+   */
+  convertPolysToLines?: boolean;
+
+  /**
+   * Whether to convert strips to polygons.
+   */
+  convertStripsToPolys?: boolean;
+}
+
+type vtkCleanPolyDataBase = vtkObject & vtkAlgorithm;
+
+export interface vtkCleanPolyData extends vtkCleanPolyDataBase {
+  /**
+   * Create default locator.
+   */
+  createDefaultLocator(): void;
+
+  /**
+   * Get the absolute tolerance value.
+   */
+  getAbsoluteTolerance(): number;
+
+  /**
+   * Get whether to convert lines to points.
+   */
+  getConvertLinesToPoints(): boolean;
+
+  /**
+   * Get whether to convert polygons to lines.
+   */
+  getConvertPolysToLines(): boolean;
+
+  /**
+   * Get whether to convert strips to polygons.
+   */
+  getConvertStripsToPolys(): boolean;
+
+  /**
+   * Get the output points precision.
+   */
+  getOutputPointsPrecision(): DesiredOutputPrecision;
+
+  /**
+   * Get whether to merge points.
+   */
+  getPointMerging(): boolean;
+
+  /**
+   * Get the tolerance used for point merging.
+   */
+  getTolerance(): number;
+
+  /**
+   * Get whether the tolerance is absolute or relative.
+   */
+  getToleranceIsAbsolute(): boolean;
+
+  /**
+   * Operate on a bounding box by applying a transformation.
+   *
+   * @param {Bounds} inBounds The input bounding box.
+   * @param {Bounds} outBounds The output bounding box.
+   */
+  operateOnBounds(inBounds: Bounds, outBounds: Bounds): void;
+
+  /**
+   * Operate on a point by applying a transformation.
+   *
+   * @param {Vector3} point The point to operate on.
+   */
+  operateOnPoint(point: Vector3): void;
+
+  /**
+   *
+   * @param inData
+   * @param outData
+   */
+  requestData(inData: any, outData: any): void;
+
+  /**
+   * Set the absolute tolerance value.
+   * This is only used if ToleranceIsAbsolute is true.
+   * Initial value is 0.0
+   * @param {Number} absoluteTolerance The absolute tolerance value.
+   */
+  setAbsoluteTolerance(absoluteTolerance: number): boolean;
+
+  /**
+   * Set whether to convert lines to points.
+   * @param {Boolean} convertLinesToPoints
+   */
+  setConvertLinesToPoints(convertLinesToPoints: boolean): boolean;
+
+  /**
+   * Set whether to convert polygons to lines.
+   * @param {Boolean} convertPolysToLines
+   */
+  setConvertPolysToLines(convertPolysToLines: boolean): boolean;
+
+  /**
+   * Set whether to convert strips to polygons.
+   * @param {Boolean} convertStripsToPolys
+   */
+  setConvertStripsToPolys(convertStripsToPolys: boolean): boolean;
+
+  /**
+   * Set the desired output precision for points.
+   * Initial value is DEFAULT_PRECISION.
+   * @param {DesiredOutputPrecision} outputPointsPrecision The outputPointsPrecision value.
+   */
+  setOutputPointsPrecision(
+    outputPointsPrecision: DesiredOutputPrecision
+  ): boolean;
+
+  /**
+   * Set whether to merge points.
+   * Initial value is false.
+   * @param {Boolean} pointMerging The pointMerging value.
+   */
+  setPointMerging(pointMerging: boolean): boolean;
+
+  /**
+   * Set the tolerance used for point merging.
+   * This is ignored if ToleranceIsAbsolute is true.
+   * Initial value is 0.0
+   * @param {Number} tolerance The tolerance value.
+   */
+  setTolerance(tolerance: number): boolean;
+
+  /**
+   * Set whether the tolerance is absolute or relative.
+   * Initial value is false (relative).
+   * @param {Boolean} toleranceIsAbsolute The toleranceIsAbsolute value.
+   */
+  setToleranceIsAbsolute(toleranceIsAbsolute: boolean): boolean;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkCleanPolyData characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {ICleanPolyDataInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: ICleanPolyDataInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkCleanPolyData.
+ * @param {ICleanPolyDataInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: ICleanPolyDataInitialValues
+): vtkCleanPolyData;
+
+/**
+ * vtkCleanPolyData merge exactly coincident points.
+ *
+ * vtkCleanPolyData is a locator object to quickly locate points in 3D.
+ */
+export declare const vtkCleanPolyData: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkCleanPolyData;