@kitware/vtk.js 34.6.0 → 34.7.0

package/Common/Core/Math/index.js

@@ -258,6 +258,16 @@ function normalize(x) {
   }
   return den;
 }
+function normalize4D(x) {
+  const den = norm(x, 3);
+  if (den !== 0.0) {
+    x[0] /= den;
+    x[1] /= den;
+    x[2] /= den;
+    x[3] /= den;
+  }
+  return den;
+}
 function perpendiculars(x, y, z, theta) {
   const x2 = x[0] * x[0];
   const y2 = x[1] * x[1];
@@ -2171,6 +2181,7 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   cross: cross,
   norm: norm,
   normalize: normalize,
+  normalize4D: normalize4D,
   perpendiculars: perpendiculars,
   projectVector: projectVector,
   dot2D: dot2D,
@@ -2256,4 +2267,4 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   'default': vtkMath
 });
 
-export { Pi 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, identity as J, multiplyMatrix as K, floor as L, isInf as M, rgb2hsv as N, rgb2lab as O, lab2rgb as P, round as Q, normalize2D as R, nearestPowerOfTwo as S, multiply3x3_vect3 as T, getSparseOrthogonalMatrix as U, areBoundsInitialized as V, floatRGB2HexCode as W, isPowerOfTwo as X, angleBetweenVectors as Y, signedAngleBetweenVectors as Z, createArray as _, areMatricesEqual as a, floatToHex2 as a$, ceil as a0, min as a1, max as a2, arrayMin as a3, arrayMax as a4, ceilLog2 as a5, factorial as a6, binomial as a7, beginCombination as a8, nextCombination as a9, roundNumber as aA, matrix3x3ToQuaternion as aB, multiplyQuaternion as aC, orthogonalize3x3 as aD, diagonalize3x3 as aE, singularValueDecomposition3x3 as aF, luFactorLinearSystem as aG, luSolveLinearSystem as aH, estimateMatrixCondition as aI, solveHomogeneousLeastSquares as aJ, solveLeastSquares as aK, hex2float as aL, lab2xyz as aM, xyz2lab as aN, rgb2xyz as aO, computeBoundsFromPoints as aP, clampAndNormalizeValue as aQ, getScalarTypeFittingRange as aR, getAdjustedScalarRange as aS, extentIsWithinOtherExtent as aT, boundsIsWithinOtherBounds as aU, pointIsWithinBounds as aV, solve3PointCircle as aW, inf as aX, negInf as aY, isFinite as aZ, isNaN as a_, randomSeed as aa, getSeed as ab, gaussian as ac, multiplyScalar2D as ad, multiplyAccumulate2D as ae, outer as af, projectVector as ag, dot2D as ah, projectVector2D as ai, gaussianAmplitude as aj, gaussianWeight as ak, outer2D as al, norm2D as am, rowsToMat4 as an, columnsToMat4 as ao, columnsToMat3 as ap, LUFactor3x3 as aq, LUSolve3x3 as ar, linearSolve3x3 as as, multiply3x3_mat3 as at, transpose3x3 as au, invert3x3 as av, identity3x3 as aw, isIdentity as ax, isIdentity3x3 as ay, quaternionToMatrix3x3 as az, roundVector as b, float2CssRGBA as b0, 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, 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 };

package/Common/Core/Math.d.ts

@@ -203,7 +203,7 @@ export function getSeed(): number;
 export function random(minValue: number, maxValue: number): number;
 
 /**
- * Addition of two 3-vectors.
+ * Add two 3-vectors.
  * @param {Vector3} a The first 3D vector.
  * @param {Vector3} b The second 3D vector.
  * @param {Vector3} out The output 3D vector.
@@ -215,7 +215,7 @@ export function random(minValue: number, maxValue: number): number;
 export function add(a: Vector3, b: Vector3, out: Vector3): Vector3;
 
 /**
- * Subtraction of two 3-vectors.
+ * Substract two 3-vectors.
  * @param {Vector3} a The first 3D vector.
  * @param {Vector3} b The second 3D vector.
  * @param {Vector3} out The output 3D vector.
@@ -227,7 +227,7 @@ export function add(a: Vector3, b: Vector3, out: Vector3): Vector3;
 export function subtract(a: Vector3, b: Vector3, out: Vector3): Vector3;
 
 /**
- *
+ * Multiply a 3-vector by a scalar.
  * @param {Vector3} vec
  * @param {Number} scalar
  * @example
@@ -238,7 +238,7 @@ export function subtract(a: Vector3, b: Vector3, out: Vector3): Vector3;
 export function multiplyScalar(vec: Vector3, scalar: number): Vector3;
 
 /**
- *
+ * Multiply a 3-vector by a scalar.
  * @param {Vector2} vec
  * @param {Number} scalar
  * @example
@@ -249,7 +249,7 @@ export function multiplyScalar(vec: Vector3, scalar: number): Vector3;
 export function multiplyScalar2D(vec: Vector2, scalar: number): Vector2;
 
 /**
- *
+ * Multiply two 3-vectors.
  * @param {Vector3} a
  * @param {Vector3} b
  * @param {Number} scalar
@@ -267,7 +267,7 @@ export function multiplyAccumulate(
 ): Vector3;
 
 /**
- *
+ * Multiply two 2-vectors.
  * @param {Vector2} a
  * @param {Vector2} b
  * @param {Number} scalar
@@ -285,7 +285,7 @@ export function multiplyAccumulate2D(
 ): Vector2;
 
 /**
- *
+ * Dot product of two 3-vectors.
  * @param {Vector3} x
  * @param {Vector3} y
  * @example
@@ -312,17 +312,23 @@ export function outer(x: Vector3, y: Vector3, out_3x3: Matrix3x3): void;
 export function cross(x: Vector3, y: Vector3, out: Vector3): Vector3;
 
 /**
- *
- * @param {Number[]} x
- * @param {Number} n
+ * Compute the norm of a vector.
+ * @param {Number[]} x The vector to compute the norm of.
+ * @param {Number} [n] The number of components to consider (default is 3).
  */
-export function norm(x: number[], n: number): number;
+export function norm(x: number[], n?: number): number;
 
 /**
  * Normalize in place. Returns norm.
- * @param {Vector3} x The vector to normlize.
+ * @param {Number[]} x The vector to normalize.
  */
-export function normalize(x: Vector3): number;
+export function normalize(x: number[]): number;
+
+/**
+ * Normalize in place. Returns norm.
+ * @param {Number[]} x The vector to normalize.
+ */
+export function normalize4D(x: number[]): number;
 
 /**
  * Given a unit vector v1, find two unit vectors v2 and v3 such that v1 cross v2 = v3
@@ -339,10 +345,10 @@ export function perpendiculars(
 ): void;
 
 /**
- *
- * @param {Vector3} a
- * @param {Vector3} b
- * @param {Vector3} projection
+ * Project vector `a` onto vector `b` and returns the result in projection vector.
+ * @param {Vector3} a The first 3D vector.
+ * @param {Vector3} b The second 3D vector.
+ * @param {Vector3} projection The projection 3D vector.
  */
 export function projectVector(
   a: Vector3,
@@ -351,7 +357,7 @@ export function projectVector(
 ): boolean;
 
 /**
- *
+ * Compute the dot product of two 2D vectors.
  * @param {Vector2} x
  * @param {Vector2} y
  */

package/Common/Core/Math.js

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

package/Common/DataModel/Triangle.js

@@ -1,6 +1,6 @@
-import { m as macro } from '../../macros2.js';
+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, p as invertMatrix } from '../Core/Math/index.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 vtkLine from './Line.js';
 import vtkPlane from './Plane.js';
 
@@ -590,21 +590,16 @@ function vtkTriangle(publicAPI, model) {
    * @param {Number[]} derivs - The derivatives.
    */
   publicAPI.derivatives = (subId, pcoords, values, dim, derivs) => {
-    const x0 = [];
-    const x1 = [];
-    const x2 = [];
-    model.points.getPoint(0, x0);
-    model.points.getPoint(1, x1);
-    model.points.getPoint(2, x2);
+    const x0 = model.points.getPoint(0);
+    const x1 = model.points.getPoint(1);
+    const x2 = model.points.getPoint(2);
     const n = [];
     const v10 = [];
     const v20 = [];
     const v = [];
     computeNormal(x0, x1, x2, n);
-    for (let i = 0; i < 3; i++) {
-      v10[i] = x1[i] - x0[i];
-      v[i] = x2[i] - x0[i];
-    }
+    subtract(x1, x0, v10);
+    subtract(x2, x0, v);
     cross(n, v10, v20);
     const lenX = normalize(v10); // check for degenerate triangle
 
@@ -629,7 +624,7 @@ function vtkTriangle(publicAPI, model) {
     const J = [v1[0] - v0[0], v1[1] - v0[1], v2[0] - v0[0], v2[1] - v0[1]];
 
     // Compute inverse Jacobian (expects flat array)
-    const JI = new Array(4).fill(0.0);
+    const JI = macro.newTypedArray(TYPED_ARRAYS.Float64Array, 4);
     invertMatrix(J, JI, 2); // returns flat array [JI00, JI01, JI10, JI11]
 
     // Compute derivatives

package/Filters/Core/Cutter.js

@@ -257,6 +257,7 @@ function vtkCutter(publicAPI, model) {
       const name = pointData.getArrayName(arrayIdx);
       const array = vtkDataArray.newInstance({
         name,
+        dataType: pointData.getArrayByIndex(arrayIdx).getDataType(),
         values: newPointData[name],
         numberOfComponents: pointData.getArrayByIndex(arrayIdx).getNumberOfComponents()
       });

package/IO/Misc/OBJWriter.d.ts

@@ -0,0 +1,103 @@
+import vtkPolyData from './../../Common/DataModel/PolyData';
+import vtkTexture from './../../Rendering/Core/Texture';
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+
+/**
+ *
+ */
+export interface IOBJWriterInitialValues {
+  modelFilename?: string;
+  materialFilename?: string;
+  texture?: vtkTexture;
+  textureFileName?: string;
+}
+
+type vtkOBJWriterBase = vtkObject & vtkAlgorithm;
+
+export interface vtkOBJWriter extends vtkOBJWriterBase {
+  /**
+   * Get the zip file containing the OBJ and MTL files.
+   */
+  exportAsZip(): Promise<Uint8Array>;
+
+  /**
+   * Get the MTL file as a string.
+   */
+  getMtl(): string;
+
+  /**
+   *
+   * @param inData
+   * @param outData
+   */
+  requestData(inData: any, outData: any): void;
+
+  /**
+   * Set the material filename.
+   * @param materialFilename
+   * @returns {boolean} true if the material file name was set successfully
+   */
+  setMaterialFilename(materialFilename: string): boolean;
+
+  /**
+   * Set the model filename.
+   * @param modelFilename
+   */
+  setModelFilename(modelFilename: string): boolean;
+
+  /**
+   * Set the texture instance.
+   * @param {vtkTexture} texture
+   * @returns {boolean} true if the texture was set successfully
+   */
+  setTexture(texture: vtkTexture): boolean;
+
+  /**
+   * Set the texture file name.
+   * @param {string} textureFileName
+   * @returns {boolean} true if the texture file name was set successfully
+   */
+  setTextureFileName(textureFileName: string): boolean;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkOBJWriter characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IOBJWriterInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IOBJWriterInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkOBJWriter
+ * @param {IOBJWriterInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: IOBJWriterInitialValues
+): vtkOBJWriter;
+
+/**
+ *
+ * @param {vktPolyData} polyData
+ */
+export function writeOBJ(polyData: vtkPolyData): vtkPolyData;
+
+/**
+ * vtkOBJWriter writes wavefront obj (.obj) files in ASCII form. OBJ files
+ * contain the geometry including lines, triangles and polygons. Normals and
+ * texture coordinates on points are also written if they exist.
+ *
+ * One can specify a texture passing a vtkTexture using `setTexture`. If a texture is
+ * set, additional .mtl and .png files are generated.
+ */
+export declare const vtkOBJWriter: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+  writeOBJ: typeof writeOBJ;
+};
+export default vtkOBJWriter;

package/IO/Misc/OBJWriter.js

@@ -0,0 +1,235 @@
+import { strToU8, zipSync } from 'fflate';
+import { m as macro } from '../../macros2.js';
+import vtkCellArray from '../../Common/Core/CellArray.js';
+import vtkTriangleStrip from '../../Common/DataModel/TriangleStrip.js';
+
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
+// Global methods
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+// vtkOBJWriter methods
+// ----------------------------------------------------------------------------
+
+const writeFaces = (faces, withNormals, withTCoords) => {
+  let outputData = '';
+  const fd = faces.getData();
+  let offset = 0;
+  while (offset < fd.length) {
+    const faceSize = fd[offset++];
+    outputData += 'f';
+    for (let i = 0; i < faceSize; i++) {
+      outputData += ` ${fd[offset + i] + 1}`;
+      if (withTCoords) {
+        outputData += `/${fd[offset + i] + 1}`;
+        if (withNormals) {
+          outputData += `//${fd[offset + i] + 1}`;
+        }
+      } else if (withNormals) {
+        outputData += `//${fd[offset + i] + 1}`;
+      }
+    }
+    offset += faceSize;
+    outputData += '\n';
+  }
+  return outputData;
+};
+const writeLines = lines => {
+  let outputData = '';
+  const ld = lines.getData();
+  let offset = 0;
+  while (offset < ld.length) {
+    const lineSize = ld[offset++];
+    outputData += 'l';
+    for (let i = 0; i < lineSize; i++) {
+      outputData += ` ${ld[offset + i] + 1}`;
+    }
+    offset += lineSize;
+    outputData += '\n';
+  }
+  return outputData;
+};
+const writePoints = (pts, normals, tcoords) => {
+  const outputData = [];
+  const nbPts = pts.getNumberOfPoints();
+  let p;
+
+  // Positions
+  for (let i = 0; i < nbPts; i++) {
+    p = pts.getPoint(i);
+    outputData.push(`v ${p[0]} ${p[1]} ${p[2]}`);
+  }
+
+  // Normals
+  if (normals) {
+    for (let i = 0; i < nbPts; i++) {
+      p = normals.getTuple(i);
+      outputData.push(`vn ${p[0]} ${p[1]} ${p[2]}`);
+    }
+  }
+
+  // Textures
+  if (tcoords) {
+    for (let i = 0; i < nbPts; i++) {
+      p = tcoords.getTuple(i);
+      if (p[0] !== -1.0) {
+        outputData.push(`vt ${p[0]} ${p[1]}`);
+      }
+    }
+  }
+  return `${outputData.join('\n')}\n`;
+};
+const writeMTL = (materialName, textureFileName) => {
+  const outputData = [];
+  outputData.push(`newmtl ${materialName}`);
+  outputData.push(`map_Kd ${textureFileName}`);
+  return outputData.join('\n');
+};
+const writeOBJ = (polyData, materialFilename, materialName) => {
+  let outputData = '# VTK.js generated OBJ File\n';
+  const pts = polyData.getPoints();
+  const polys = polyData.getPolys();
+  const strips = polyData.getStrips() ? polyData.getStrips().getData() : null;
+  const lines = polyData.getLines();
+  const normals = polyData.getPointData().getNormals();
+  const tcoords = polyData.getPointData().getTCoords();
+  const hasPtNormals = normals !== null;
+  const hasPtTCoords = tcoords !== null;
+  if (!pts) {
+    vtkErrorMacro('No data to write!');
+    return outputData;
+  }
+  if (materialFilename) {
+    // Write material library
+    outputData += `mtllib ${materialFilename}\n`;
+  }
+
+  // Write material if a texture is specified
+  if (materialName) {
+    // declare material in obj file
+    outputData += `usemtl ${materialName}\n`;
+  }
+
+  // Write points
+  outputData += writePoints(pts, normals, tcoords);
+
+  // Decompose any triangle strips into triangles
+  const polyStrips = vtkCellArray.newInstance();
+  if (strips && strips.length > 0) {
+    vtkTriangleStrip.decomposeStrip(pts, polyStrips);
+  }
+
+  // Write triangle strips
+  if (polyStrips.getNumberOfCells() > 0) {
+    outputData += writeFaces(polyStrips, hasPtNormals, hasPtTCoords);
+  }
+
+  // Write polygons.
+  if (polys) {
+    outputData += writeFaces(polys, hasPtNormals, hasPtTCoords);
+  }
+
+  // Write lines.
+  if (lines) {
+    outputData += writeLines(lines);
+  }
+  return outputData;
+};
+
+// ----------------------------------------------------------------------------
+// Static API
+// ----------------------------------------------------------------------------
+
+const STATIC = {
+  writeOBJ
+};
+
+// ----------------------------------------------------------------------------
+// vtkOBJWriter methods
+// ----------------------------------------------------------------------------
+
+function vtkOBJWriter(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkOBJWriter');
+  publicAPI.exportAsZip = () => {
+    publicAPI.update();
+    const modelFilename = model.modelFilename;
+    const materialFilename = model.materialFilename;
+    const textureFileName = model.textureFileName;
+    const imageData = model.texture.getInputAsJsImageData?.();
+    const zipContent = {};
+    zipContent[`${modelFilename}.obj`] = strToU8(model.output[0]);
+    zipContent[`${materialFilename}.mtl`] = strToU8(model.mtl);
+    const canvas = new OffscreenCanvas(imageData.width, imageData.height);
+    const ctx = canvas.getContext('2d');
+    ctx.putImageData(imageData, 0, 0);
+    return new Promise(resolve => {
+      canvas.toBlob(async blob => {
+        const arrayBuffer = await blob.arrayBuffer();
+        zipContent[`${textureFileName}.png`] = new Uint8Array(arrayBuffer);
+        resolve(zipSync(zipContent));
+      }, 'image/png');
+    });
+  };
+  publicAPI.requestData = (inData, outData) => {
+    const input = inData[0];
+    if (!input || !input.isA('vtkPolyData')) {
+      vtkErrorMacro('Invalid or missing vtkPolyData input');
+      return;
+    }
+
+    // Update output
+    const materialFilename = `${model.materialFilename}.mtl`;
+    const textureFileName = `${model.textureFileName}.png`;
+    outData[0] = writeOBJ(input, materialFilename, model.materialName);
+    model.mtl = writeMTL(model.materialName, textureFileName);
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  modelFilename: 'model',
+  materialName: 'mat_01',
+  materialFilename: 'material',
+  texture: null,
+  textureFileName: 'texture'
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let 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.get(publicAPI, model, ['mtl']);
+  macro.set(publicAPI, model, ['modelFilename', 'materialFilename', 'texture', 'textureFileName']);
+
+  // Object specific methods
+  vtkOBJWriter(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkOBJWriter');
+
+// ----------------------------------------------------------------------------
+
+var vtkOBJWriter$1 = {
+  newInstance,
+  extend,
+  ...STATIC
+};
+
+export { STATIC, vtkOBJWriter$1 as default, extend, newInstance };

package/IO/Misc.js

@@ -5,6 +5,7 @@ import vtkJSONNucleoReader from './Misc/JSONNucleoReader.js';
 import vtkJSONReader from './Misc/JSONReader.js';
 import vtkMTLReader from './Misc/MTLReader.js';
 import vtkOBJReader from './Misc/OBJReader.js';
+import vtkOBJWriter from './Misc/OBJWriter.js';
 import vtkPDBReader from './Misc/PDBReader.js';
 import vtkSkyboxReader from './Misc/SkyboxReader.js';
 import vtkGCodeReader from './Misc/GCodeReader.js';
@@ -17,6 +18,7 @@ var Misc = {
   vtkJSONReader,
   vtkMTLReader,
   vtkOBJReader,
+  vtkOBJWriter,
   vtkPDBReader,
   vtkSkyboxReader,
   vtkGCodeReader

package/Interaction/Style/InteractorStyleManipulator.js

@@ -1,6 +1,7 @@
 import { m as macro } from '../../macros2.js';
 import { MouseButton } from '../../Rendering/Core/RenderWindowInteractor/Constants.js';
 import vtkInteractorStyle from '../../Rendering/Core/InteractorStyle.js';
+import { mat4, vec3 } from 'gl-matrix';
 
 const {
   vtkDebugMacro
@@ -101,6 +102,62 @@ function dollyByFactor(interactor, renderer, factor) {
     renderer.updateLightsGeometryToFollowCamera();
   }
 }
+function getCameraMatrix(renderer, tempMatrix) {
+  const cam = renderer.getActiveCamera();
+  if (cam) {
+    mat4.copy(tempMatrix, cam.getViewMatrix());
+    return tempMatrix;
+  }
+  return null;
+}
+
+/**
+ * Transforms a vector by the transformation delta between two matrices.
+ *
+ * @param {Object} tempObjects - Temporary matrices/vectors for computation
+ * @param {mat4} beforeMatrix - Matrix before transformation
+ * @param {mat4} afterMatrix - Matrix after transformation
+ * @param {Array} vector - Vector to transform [x, y, z]
+ * @returns {Array} Transformed vector [x, y, z]
+ */
+function transformVectorByTransformation(tempObjects, beforeMatrix, afterMatrix, vector) {
+  const {
+    matrixA,
+    matrixB,
+    newCenter
+  } = tempObjects;
+
+  // The view matrix from vtk.js is row-major, but gl-matrix expects column-major.
+  // We need to transpose them before use.
+  mat4.transpose(matrixA, beforeMatrix);
+  mat4.transpose(matrixB, afterMatrix);
+  mat4.invert(matrixB, matrixB);
+
+  // Compute delta transformation matrix
+  mat4.multiply(matrixA, matrixB, matrixA);
+  vec3.transformMat4(newCenter, vector, matrixA);
+  return newCenter;
+}
+
+/**
+ * Computes the new center of rotation based on camera movement.
+ * When the camera moves (pan), the center of rotation should move
+ * by the same transformation to maintain consistent rotation behavior.
+ *
+ * @param {Object} tempObjects - Temporary matrices/vectors for computation
+ * @param {Object} renderer - VTK renderer
+ * @param {mat4} beforeCameraMatrix - Camera view matrix before movement
+ * @param {Array} oldCenterOfRotation - Previous center of rotation [x, y, z]
+ * @returns {Array} New center of rotation [x, y, z]
+ */
+function computeNewCenterOfRotation(tempObjects, renderer, beforeCameraMatrix, oldCenterOfRotation) {
+  const cam = renderer.getActiveCamera();
+  if (!cam || !beforeCameraMatrix) {
+    return oldCenterOfRotation;
+  }
+  const afterMatrixRowMajor = cam.getViewMatrix();
+  return transformVectorByTransformation(tempObjects, beforeCameraMatrix, afterMatrixRowMajor, oldCenterOfRotation);
+}
 
 // ----------------------------------------------------------------------------
 // Static API
@@ -119,6 +176,14 @@ const STATIC = {
 function vtkInteractorStyleManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkInteractorStyleManipulator');
+
+  // Initialize temporary objects to reduce garbage collection
+  const tempCameraMatrix = mat4.create();
+  const tempComputeObjects = {
+    matrixA: mat4.create(),
+    matrixB: mat4.create(),
+    newCenter: vec3.create()
+  };
   model.currentVRManipulators = new Map();
   model.mouseManipulators = [];
   model.keyboardManipulators = [];
@@ -415,7 +480,11 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
   publicAPI.handleMouseMove = callData => {
     model.cachedMousePosition = callData.position;
     if (model.currentManipulator && model.currentManipulator.onMouseMove) {
-      model.currentManipulator.onMouseMove(model._interactor, model.getRenderer(callData), callData.position);
+      const renderer = model.getRenderer(callData);
+      const beforeCameraMatrix = getCameraMatrix(renderer, tempCameraMatrix);
+      model.currentManipulator.onMouseMove(model._interactor, renderer, callData.position);
+      const newCenter = computeNewCenterOfRotation(tempComputeObjects, renderer, beforeCameraMatrix, model.centerOfRotation);
+      publicAPI.setCenterOfRotation(newCenter);
       publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
     }
   };
@@ -557,16 +626,20 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
 
   //----------------------------------------------------------------------------
   publicAPI.handlePan = callData => {
+    const renderer = model.getRenderer(callData);
+    const beforeCameraMatrix = getCameraMatrix(renderer, tempCameraMatrix);
     let count = model.gestureManipulators.length;
     let actionCount = 0;
     while (count--) {
       const manipulator = model.gestureManipulators[count];
       if (manipulator && manipulator.isPanEnabled()) {
-        manipulator.onPan(model._interactor, model.getRenderer(callData), callData.translation);
+        manipulator.onPan(model._interactor, renderer, callData.translation);
         actionCount++;
       }
     }
     if (actionCount) {
+      const newCenter = computeNewCenterOfRotation(tempComputeObjects, renderer, beforeCameraMatrix, model.centerOfRotation);
+      publicAPI.setCenterOfRotation(newCenter);
       publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
     }
   };

package/Rendering/Core/Camera.d.ts

@@ -156,11 +156,11 @@ export interface vtkCamera extends vtkObject {
   getFreezeFocalPoint(): boolean;
 
   /**
-   * Not implemented yet
    * Get the plane equations that bound the view frustum.
-   * @param {Number} aspect Camera frustum aspect ratio.
+   * @param {Number} [aspect] Camera frustum aspect ratio (default: 1.0).
+   * @param {Float64Array} [planes] Optional array to fill with the plane equations.
    */
-  getFrustumPlanes(aspect: number): void;
+  getFrustumPlanes(aspect?: number, planes?: Float64Array): Float64Array;
 
   /**
    * Not implemented yet

package/Rendering/Core/Camera.js

@@ -1,6 +1,6 @@
 import { mat4, vec4, vec3, quat } from 'gl-matrix';
 import { m as macro } from '../../macros2.js';
-import { r as radiansFromDegrees, k as add, j as cross } from '../../Common/Core/Math/index.js';
+import { r as radiansFromDegrees, k as add, J as normalize4D, j as cross } from '../../Common/Core/Math/index.js';
 
 const {
   vtkDebugMacro
@@ -274,8 +274,38 @@ function vtkCamera(publicAPI, model) {
   publicAPI.setObliqueAngles = (alpha, beta) => {};
   publicAPI.getOrientation = () => {};
   publicAPI.getOrientationWXYZ = () => {};
-  publicAPI.getFrustumPlanes = aspect => {
-    // Return array of 24 params (4 params for each of 6 plane equations)
+  publicAPI.getFrustumPlanes = function () {
+    let aspect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1.0;
+    let planes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Float64Array(24);
+    const normals = [
+    // Left
+    [1, 0, 0, 1],
+    // Right
+    [-1, 0, 0, 1],
+    // Bottom
+    [0, 1, 0, 1],
+    // Top
+    [0, -1, 0, 1],
+    // Near
+    [0, 0, 1, 1],
+    // Far
+    [0, 0, -1, 1]];
+
+    // Get the composite projection matrix
+    const matrix = publicAPI.getCompositeProjectionMatrix(aspect, -1, 1);
+
+    // Transform the normals to world coordinates
+    for (let i = 0; i < 6; i++) {
+      vec4.transformMat4(normals[i], normals[i], matrix);
+
+      // Normalize the plane normal
+      normalize4D(normals[i]);
+      planes[4 * i + 0] = normals[i][0];
+      planes[4 * i + 1] = normals[i][1];
+      planes[4 * i + 2] = normals[i][2];
+      planes[4 * i + 3] = normals[i][3];
+    }
+    return planes;
   };
   publicAPI.getCameraLightTransformMatrix = matrix => {
     mat4.copy(matrix, model.cameraLightTransform);

package/Rendering/Core/ColorTransferFunction/CssFilters.js

@@ -1,4 +1,4 @@
-import { J as identity, K as multiplyMatrix } from '../../../Common/Core/Math/index.js';
+import { K as identity, L as multiplyMatrix } from '../../../Common/Core/Math/index.js';
 
 /**
  * A helper file to transform RGBA points using CSS filters equivalent

package/Rendering/Core/ColorTransferFunction.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../macros2.js';
-import { h as hsv2rgb, i as isNan, L as floor, M as isInf, N as rgb2hsv, O as rgb2lab, P as lab2rgb } from '../../Common/Core/Math/index.js';
+import { h as hsv2rgb, i as isNan, M as floor, N as isInf, O as rgb2hsv, P as rgb2lab, Q as lab2rgb } from '../../Common/Core/Math/index.js';
 import vtkScalarsToColors from '../../Common/Core/ScalarsToColors.js';
 import Constants from './ColorTransferFunction/Constants.js';
 

package/Rendering/Core/Coordinate.js

@@ -1,6 +1,6 @@
 import { m as macro } from '../../macros2.js';
 import Constants from './Coordinate/Constants.js';
-import { Q as round, L as floor } from '../../Common/Core/Math/index.js';
+import { R as round, M as floor } from '../../Common/Core/Math/index.js';
 
 const {
   Coordinate

package/Rendering/Core/CubeAxesActor.js

@@ -1,6 +1,6 @@
 import { vec3, mat4 } from 'gl-matrix';
 import * as d3 from 'd3-scale';
-import { R as normalize2D, S as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { S as normalize2D, T as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import { m as macro } from '../../macros2.js';
 import vtkActor from './Actor.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';

package/Rendering/Core/ImageMapper.js

@@ -2,7 +2,7 @@ import Constants from './ImageMapper/Constants.js';
 import { m as macro } from '../../macros2.js';
 import vtkAbstractImageMapper from './AbstractImageMapper.js';
 import { intersectWithLineForPointPicking, intersectWithLineForCellPicking } from './AbstractImageMapper/helper.js';
-import { F as clampValue, T as multiply3x3_vect3, I as createUninitializedBounds, U as getSparseOrthogonalMatrix } from '../../Common/Core/Math/index.js';
+import { F as clampValue, U as multiply3x3_vect3, I as createUninitializedBounds, V as getSparseOrthogonalMatrix } from '../../Common/Core/Math/index.js';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
 
 const {

package/Rendering/Core/Renderer.js

@@ -2,7 +2,7 @@ import { mat4, vec3 } from 'gl-matrix';
 import { n as newInstance$1, g as get, e as setGet, k as getArray, l as setGetArray, i as moveToProtected, c as macro } from '../../macros2.js';
 import vtkCamera from './Camera.js';
 import vtkLight from './Light.js';
-import { V as areBoundsInitialized, u as uninitializeBounds, r as radiansFromDegrees, d as dot, I as createUninitializedBounds } from '../../Common/Core/Math/index.js';
+import { W as areBoundsInitialized, u as uninitializeBounds, r as radiansFromDegrees, d as dot, I as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 import vtkViewport from './Viewport.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 

package/Rendering/Core/ScalarBarActor.js

@@ -1,5 +1,5 @@
 import * as d3 from 'd3-scale';
-import { S as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { T as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import { m as macro } from '../../macros2.js';
 import vtkActor from './Actor.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';

package/Rendering/Core/TextActor.js

@@ -5,7 +5,7 @@ import vtkActor2D from './Actor2D.js';
 import vtkMapper2D from './Mapper2D.js';
 import vtkTextProperty from './TextProperty.js';
 import ImageHelper from '../../Common/Core/ImageHelper.js';
-import { W as floatRGB2HexCode } from '../../Common/Core/Math/index.js';
+import { X as floatRGB2HexCode } from '../../Common/Core/Math/index.js';
 
 // ----------------------------------------------------------------------------
 // vtkTextActor methods

package/Rendering/Core/VolumeProperty.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../macros2.js';
-import { F as clampValue, L as floor } from '../../Common/Core/Math/index.js';
+import { F as clampValue, M as floor } from '../../Common/Core/Math/index.js';
 import vtkColorTransferFunction from './ColorTransferFunction.js';
 import vtkPiecewiseFunction from '../../Common/DataModel/PiecewiseFunction.js';
 import Constants from './VolumeProperty/Constants.js';

package/Rendering/OpenGL/PolyDataMapper2D.js

@@ -8,7 +8,7 @@ import vtkReplacementShaderMapper from './ReplacementShaderMapper.js';
 import vtkShaderProgram from './ShaderProgram.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import vtkOpenGLTexture from './Texture.js';
-import { Q as round } from '../../Common/Core/Math/index.js';
+import { R as round } from '../../Common/Core/Math/index.js';
 import { DisplayLocation } from '../Core/Property2D/Constants.js';
 import { registerOverride } from './ViewNodeFactory.js';
 

package/Rendering/OpenGL/Texture.js

@@ -3,7 +3,7 @@ import Constants from './Texture/Constants.js';
 import HalfFloat from '../../Common/Core/HalfFloat.js';
 import { n as newInstance$1, o as obj, s as set, e as setGet, g as get, i as moveToProtected, a as newTypedArray, c as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { X as isPowerOfTwo, S as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { Y as isPowerOfTwo, T as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
 import supportsNorm16LinearCached from './Texture/supportsNorm16Linear.js';

package/Widgets/Widgets3D/AngleWidget.js

@@ -3,7 +3,7 @@ import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
 import vtkPolyLineRepresentation from '../Representations/PolyLineRepresentation.js';
 import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
-import { s as subtract, Y as angleBetweenVectors } from '../../Common/Core/Math/index.js';
+import { s as subtract, Z as angleBetweenVectors } from '../../Common/Core/Math/index.js';
 import widgetBehavior from './AngleWidget/behavior.js';
 import generateState from './AngleWidget/state.js';
 import { ViewTypes } from '../Core/WidgetManager/Constants.js';

package/Widgets/Widgets3D/ResliceCursorWidget/behavior.js

@@ -1,7 +1,7 @@
 import { m as macro } from '../../../macros2.js';
 import vtkBoundingBox from '../../../Common/DataModel/BoundingBox.js';
 import vtkLine from '../../../Common/DataModel/Line.js';
-import { k as add, l as normalize, s as subtract, d as dot, j as cross, m as multiplyAccumulate, x as multiplyScalar, Z as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
+import { k as add, l as normalize, s as subtract, d as dot, j as cross, m as multiplyAccumulate, x as multiplyScalar, _ as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
 import { getLineNames, getOtherLineName, updateState, boundPointOnPlane, getLinePlaneName, getLineInPlaneName, rotateVector } from './helpers.js';
 import { InteractionMethodsName, ScrollingMethods, planeNameToViewType } from './Constants.js';
 

package/Widgets/Widgets3D/ResliceCursorWidget/helpers.js

@@ -2,7 +2,7 @@ import vtkBoundingBox, { STATIC } from '../../../Common/DataModel/BoundingBox.js
 import vtkCubeSource from '../../../Filters/Sources/CubeSource.js';
 import vtkCutter from '../../../Filters/Core/Cutter.js';
 import vtkPlane from '../../../Common/DataModel/Plane.js';
-import { s as subtract, l as normalize, j as cross, x as multiplyScalar, m as multiplyAccumulate, Z as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
+import { s as subtract, l as normalize, j as cross, x as multiplyScalar, m as multiplyAccumulate, _ as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../../Common/Core/MatrixBuilder.js';
 import { viewTypeToPlaneName, planeNameToViewType, planeNames } from './Constants.js';
 

package/index.d.ts

@@ -113,6 +113,7 @@
 /// <reference path="./IO/Misc/JSONReader.d.ts" />
 /// <reference path="./IO/Misc/MTLReader.d.ts" />
 /// <reference path="./IO/Misc/OBJReader.d.ts" />
+/// <reference path="./IO/Misc/OBJWriter.d.ts" />
 /// <reference path="./IO/Misc/PDBReader.d.ts" />
 /// <reference path="./IO/XML/XMLImageDataReader.d.ts" />
 /// <reference path="./IO/XML/XMLPolyDataReader.d.ts" />

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "34.6.0",
+  "version": "34.7.0",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",