@kitware/vtk.js 34.6.0 → 34.8.0

package/Filters/Sources/PlatonicSolidSource.js

@@ -0,0 +1,149 @@
+import { m as macro } from '../../macros2.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import vtkPoints from '../../Common/Core/Points.js';
+import vtkCellArray from '../../Common/Core/CellArray.js';
+import { SolidType } from './PlatonicSolidSource/Constants.js';
+import { DesiredOutputPrecision } from '../../Common/DataModel/DataSetAttributes/Constants.js';
+import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
+
+const a = 0.61803398875;
+const b = 0.38196601125;
+const c = 0.5;
+const d = 0.30901699;
+const e = Math.sqrt(2);
+const f = Math.sqrt(3.0);
+const geometries = {
+  tetrahedron: {
+    points: [1, 1, 1, -1, 1, -1, 1, -1, -1, -1, -1, 1],
+    cells: [0, 2, 1, 1, 2, 3, 0, 3, 2, 0, 1, 3],
+    numPoints: 4,
+    cellSize: 3,
+    numCells: 4,
+    scale: 1.0 / f
+  },
+  cube: {
+    points: [-1, -1, -1, 1, -1, -1, 1, 1, -1, -1, 1, -1, -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1],
+    cells: [0, 1, 5, 4, 0, 4, 7, 3, 4, 5, 6, 7, 3, 7, 6, 2, 1, 2, 6, 5, 0, 3, 2, 1],
+    numPoints: 8,
+    cellSize: 4,
+    numCells: 6,
+    scale: 1.0 / f
+  },
+  octahedron: {
+    points: [-1, -1, 0, 1, -1, 0, 1, 1, 0, -1, 1, 0, 0, 0, -e, 0, 0, e],
+    cells: [4, 1, 0, 4, 2, 1, 4, 3, 2, 4, 0, 3, 0, 1, 5, 1, 2, 5, 2, 3, 5, 3, 0, 5],
+    numPoints: 6,
+    cellSize: 3,
+    numCells: 8,
+    scale: 1.0 / e
+  },
+  icosahedron: {
+    points: [0, d, -c, 0, d, c, 0, -d, c, -d, c, 0, -d, -c, 0, d, c, 0, d, -c, 0, 0, -d, -c, c, 0, d, -c, 0, d, -c, 0, -d, c, 0, -d],
+    cells: [0, 3, 5, 1, 5, 3, 1, 9, 2, 1, 2, 8, 0, 11, 7, 0, 7, 10, 2, 4, 6, 7, 6, 4, 3, 10, 9, 4, 9, 10, 5, 8, 11, 6, 11, 8, 1, 3, 9, 1, 8, 5, 0, 10, 3, 0, 5, 11, 7, 4, 10, 7, 11, 6, 2, 9, 4, 2, 6, 8],
+    numPoints: 12,
+    cellSize: 3,
+    numCells: 20,
+    scale: 1.0 / 0.58778524999243
+  },
+  dodecahedron: {
+    points: [b, 0, 1, -b, 0, 1, b, 0, -1, -b, 0, -1, 0, 1, -b, 0, 1, b, 0, -1, -b, 0, -1, b, 1, b, 0, 1, -b, 0, -1, b, 0, -1, -b, 0, -a, a, a, a, -a, a, -a, -a, -a, a, a, -a, a, a, a, -a, a, -a, -a, -a, a, a, -a, -a],
+    cells: [0, 16, 5, 12, 1, 1, 18, 7, 13, 0, 2, 19, 6, 14, 3, 3, 17, 4, 15, 2, 4, 5, 16, 8, 15, 5, 4, 17, 10, 12, 6, 7, 18, 11, 14, 7, 6, 19, 9, 13, 8, 16, 0, 13, 9, 9, 19, 2, 15, 8, 10, 17, 3, 14, 11, 11, 18, 1, 12, 10],
+    numPoints: 20,
+    cellSize: 5,
+    numCells: 12,
+    scale: 1.0 / 1.070466269319
+  }
+};
+
+// ----------------------------------------------------------------------------
+// vtkPlatonicSolidSource methods
+// ----------------------------------------------------------------------------
+
+function vtkPlatonicSolidSource(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkPlatonicSolidSource');
+  publicAPI.requestData = (inData, outData) => {
+    const output = outData[0] || vtkPolyData.newInstance();
+    let solidData;
+    switch (model.solidType) {
+      case SolidType.VTK_SOLID_TETRAHEDRON:
+        solidData = geometries.tetrahedron;
+        break;
+      case SolidType.VTK_SOLID_CUBE:
+        solidData = geometries.cube;
+        break;
+      case SolidType.VTK_SOLID_OCTAHEDRON:
+        solidData = geometries.octahedron;
+        break;
+      case SolidType.VTK_SOLID_ICOSAHEDRON:
+        solidData = geometries.icosahedron;
+        break;
+      case SolidType.VTK_SOLID_DODECAHEDRON:
+        solidData = geometries.dodecahedron;
+        break;
+      default:
+        solidData = geometries.tetrahedron;
+        break;
+    }
+    let pointType;
+    if (model.outputPointsPrecision === DesiredOutputPrecision.SINGLE) {
+      pointType = VtkDataTypes.FLOAT;
+    } else if (model.outputPointsPrecision === DesiredOutputPrecision.DOUBLE) {
+      pointType = VtkDataTypes.DOUBLE;
+    }
+    const points = vtkPoints.newInstance({
+      dataType: pointType,
+      numberOfPoints: solidData.numPoints
+    });
+    for (let i = 0; i < solidData.points.length; i += 3) {
+      points.insertNextPoint(solidData.scale * solidData.points[i] * model.scale, solidData.scale * solidData.points[i + 1] * model.scale, solidData.scale * solidData.points[i + 2] * model.scale);
+    }
+    const polys = vtkCellArray.newInstance();
+    for (let i = 0; i < solidData.cells.length; i += solidData.cellSize) {
+      const cell = solidData.cells.slice(i, i + solidData.cellSize);
+      polys.insertNextCell(cell);
+    }
+    output.setPoints(points);
+    output.setPolys(polys);
+    outData[0] = output;
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  solidType: SolidType.VTK_SOLID_TETRAHEDRON,
+  outputPointsPrecision: DesiredOutputPrecision.DEFAULT,
+  scale: 1
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Build VTK API
+  macro.obj(publicAPI, model);
+  macro.setGet(publicAPI, model, ['solidType', 'outputPointsPrecision', 'scale']);
+  macro.algo(publicAPI, model, 0, 1);
+
+  // Object methods
+  vtkPlatonicSolidSource(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkPlatonicSolidSource');
+
+// ----------------------------------------------------------------------------
+
+var vtkPlatonicSolidSource$1 = {
+  newInstance,
+  extend,
+  SolidType
+};
+
+export { vtkPlatonicSolidSource$1 as default, extend, newInstance };

package/Filters/Sources.js

@@ -1,3 +1,4 @@
+import vtkArcSource from './Sources/ArcSource.js';
 import vtkArrowSource from './Sources/ArrowSource.js';
 import vtkCircleSource from './Sources/CircleSource.js';
 import vtkConcentricCylinderSource from './Sources/ConcentricCylinderSource.js';
@@ -6,15 +7,18 @@ import vtkCubeSource from './Sources/CubeSource.js';
 import vtkCursor3D from './Sources/Cursor3D.js';
 import vtkCylinderSource from './Sources/CylinderSource.js';
 import vtkDiskSource from './Sources/DiskSource.js';
+import vtkEllipseArcSource from './Sources/EllipseArcSource.js';
 import vtkImageGridSource from './Sources/ImageGridSource.js';
 import vtkLineSource from './Sources/LineSource.js';
 import vtkPlaneSource from './Sources/PlaneSource.js';
+import vtkPlatonicSolidSource from './Sources/PlatonicSolidSource.js';
 import vtkPointSource from './Sources/PointSource.js';
 import vtkRTAnalyticSource from './Sources/RTAnalyticSource.js';
 import vtkSLICSource from './Sources/SLICSource.js';
 import vtkSphereSource from './Sources/SphereSource.js';
 
 var Sources = {
+  vtkArcSource,
   vtkArrowSource,
   vtkCircleSource,
   vtkConcentricCylinderSource,
@@ -23,9 +27,11 @@ var Sources = {
   vtkCursor3D,
   vtkCylinderSource,
   vtkDiskSource,
+  vtkEllipseArcSource,
   vtkImageGridSource,
   vtkLineSource,
   vtkPlaneSource,
+  vtkPlatonicSolidSource,
   vtkPointSource,
   vtkRTAnalyticSource,
   vtkSLICSource,

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,237 @@
+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 = document.createElement('canvas');
+    canvas.width = imageData.width;
+    canvas.height = 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/Proxy/Representations/GlyphRepresentationProxy.js

@@ -7,6 +7,7 @@ import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkColorTransferFunction from '../../Rendering/Core/ColorTransferFunction.js';
 import vtkAbstractRepresentationProxy from '../Core/AbstractRepresentationProxy.js';
+import '../../Filters/Sources/ArcSource.js';
 import '../../Filters/Sources/ArrowSource.js';
 import '../../Filters/Sources/CircleSource.js';
 import '../../Filters/Sources/ConcentricCylinderSource.js';
@@ -15,9 +16,11 @@ import '../../Filters/Sources/CubeSource.js';
 import '../../Filters/Sources/Cursor3D.js';
 import '../../Filters/Sources/CylinderSource.js';
 import '../../Filters/Sources/DiskSource.js';
+import '../../Filters/Sources/EllipseArcSource.js';
 import '../../Filters/Sources/ImageGridSource.js';
 import '../../Filters/Sources/LineSource.js';
 import '../../Filters/Sources/PlaneSource.js';
+import '../../Filters/Sources/PlatonicSolidSource.js';
 import '../../Filters/Sources/PointSource.js';
 import '../../Filters/Sources/RTAnalyticSource.js';
 import '../../Filters/Sources/SLICSource.js';

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