@kitware/vtk.js 34.8.1 → 34.10.0

package/Common/DataModel/Planes.d.ts

@@ -0,0 +1,120 @@
+import { Bounds, Vector3 } from './../../types';
+import vtkDataArray from './../Core/DataArray';
+import vtkImplicitFunction, {
+  IImplicitFunctionInitialValues,
+} from './ImplicitFunction';
+import vtkPlane from './Plane';
+import vtkPoints from './../Core/Points';
+
+/**
+ *
+ */
+export interface IPlanesInitialValues extends IImplicitFunctionInitialValues {
+  points?: vtkPoints;
+  normals?: vtkDataArray;
+  bounds?: Bounds;
+  planes?: number[];
+}
+
+export interface vtkPlanes extends vtkImplicitFunction {
+  /**
+   * Evaluate the function at a point x
+   * @param x The point at which to evaluate the function
+   * @returns The function value at the point x
+   */
+  evaluateFunction(x: Vector3): number;
+
+  /**
+   * Evaluate the gradient at a point x
+   * @param x The point at which to evaluate the gradient
+   * @returns The gradient at the point x
+   */
+  evaluateGradient(x: Vector3): Vector3;
+
+  /**
+   * Get the bounds of the planes.
+   * @returns {Bounds} The bounds of the planes.
+   */
+  getBounds(): Bounds;
+
+  /**
+   * Get the number of planes in the set of planes.
+   */
+  getNumberOfPlanes(): number;
+
+  /**
+   * Get the normals of the plane.
+   * @returns {vtkDataArray} The normals of the plane.
+   */
+  getNormals(): vtkDataArray;
+
+  /**
+   * Get the points of the plane.
+   * @returns {vtkPoints} The points of the plane.
+   */
+  getPoints(): vtkPoints;
+
+  /**
+   * Get the i-th plane
+   * @param {Number} i The index of the plane to get.
+   * @param {vtkPlane} [plane] The vtkPlane instance to fill (optional).
+   * @returns {vtkPlane} The plane instance at the specified index.
+   * If no plane is provided, a new vtkPlane instance will be created.
+   */
+  getPlane(i: number, plane?: vtkPlane): vtkPlane;
+
+  /**
+   * Set the bounds of the planes.
+   * @param {Bounds} bounds The bounds to set.
+   * @returns {Boolean} true if bounds were set, false if they were already set
+   * @see getBounds
+   */
+  setBounds(bounds: Bounds): boolean;
+
+  /**
+   * Set the Frustum planes.
+   * @param {Vector3[]} planes The coordinates of the frustum planes.
+   */
+  setFrustumPlanes(planes: Vector3[]): boolean;
+
+  /**
+   * Set the normals of the plane.
+   * @param {vtkDataArray} normals The normals to set.
+   */
+  setNormals(normals: vtkDataArray): boolean;
+
+  /**
+   * Set the points of the plane.
+   * @param points The points to set.
+   */
+  setPoints(points: vtkPoints): boolean;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkPlane characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IPlanesInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IPlanesInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkPlane.
+ * @param {IPlanesInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(initialValues?: IPlanesInitialValues): vtkPlanes;
+
+/**
+ * vtkPlanes computes the implicit function and function gradient for a set of
+ * planes. The planes must define a convex space.
+ */
+export declare const vtkPlanes: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkPlanes;

package/Common/DataModel/Planes.js

@@ -0,0 +1,281 @@
+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 vtkPlane from './Plane.js';
+import vtkPoints from '../Core/Points.js';
+import { VtkDataTypes } from '../Core/DataArray/Constants.js';
+
+const {
+  vtkErrorMacro,
+  vtkWarningMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
+// vtkPlanes methods
+// ----------------------------------------------------------------------------
+
+function vtkPlanes(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkPlanes');
+
+  // Initialize internal variables
+  model.planes = model.planes || macro.newTypedArray(TYPED_ARRAYS.Float64Array, 24);
+  model.bounds = model.bounds || macro.newTypedArray(TYPED_ARRAYS.Float64Array, 6);
+  model.plane = vtkPlane.newInstance();
+
+  // Public API methods
+  publicAPI.setNormals = normals => {
+    if (normals && normals.getNumberOfComponents() !== 3) {
+      vtkWarningMacro('This array does not have 3 components. Ignoring normals.');
+    }
+    model.normals = normals;
+    publicAPI.modified();
+    return true;
+  };
+
+  /**
+   * Evaluate the function at a point x
+   * @param {*} x The point at which to evaluate the function
+   * @returns The function value at the point x
+   */
+  publicAPI.evaluateFunction = x => {
+    if (!model.points || !model.normals) {
+      vtkErrorMacro('Please define points and/or normals!');
+      return Number.MAX_VALUE;
+    }
+    const numPlanes = model.points.getNumberOfPoints();
+    if (numPlanes !== model.normals.getNumberOfTuples()) {
+      vtkErrorMacro('Number of normals/points inconsistent!');
+      return Number.MAX_VALUE;
+    }
+    let maxVal = -Number.MAX_VALUE;
+    const normal = [];
+    const point = [];
+    for (let i = 0; i < numPlanes; i++) {
+      model.normals.getTuple(i, normal);
+      model.points.getPoint(i, point);
+      const val = vtkPlane.evaluate(normal, point, x);
+      if (val > maxVal) {
+        maxVal = val;
+      }
+    }
+    return maxVal;
+  };
+
+  /**
+   * Evaluate the gradient at a point x
+   * @param {*} x The point at which to evaluate the gradient
+   * @returns The gradient at the point x
+   */
+  publicAPI.evaluateGradient = x => {
+    const retVal = [0, 0, 0];
+    if (!model.points || !model.normals) {
+      vtkErrorMacro('Define points and/or normals first!');
+      return retVal;
+    }
+    const numPlanes = model.points.getNumberOfPoints();
+    if (numPlanes !== model.normals.getNumberOfTuples()) {
+      vtkErrorMacro('The number of normals/points is inconsistent!');
+      return retVal;
+    }
+    let maxVal = -Number.MAX_VALUE;
+    const nTemp = [];
+    const pTemp = [];
+    for (let i = 0; i < numPlanes; i++) {
+      model.normals.getTuple(i, nTemp);
+      model.points.getPoint(i, pTemp);
+      const val = vtkPlane.evaluate(nTemp, pTemp, x);
+      if (val > maxVal) {
+        maxVal = val;
+        retVal[0] = nTemp[0];
+        retVal[1] = nTemp[1];
+        retVal[2] = nTemp[2];
+      }
+    }
+    return retVal;
+  };
+
+  /**
+   * Set the frustum planes
+   * @param {Number[]} planes The planes to set
+   * @returns {Boolean} true if planes were set, false if they were already set
+   */
+  publicAPI.setFrustumPlanes = planes => {
+    if (vtkMath.areEquals(model.planes, planes)) {
+      return false;
+    }
+    model.planes = [...planes];
+    const pts = vtkPoints.newInstance({
+      dataType: VtkDataTypes.DOUBLE
+    });
+    const normals = vtkDataArray.newInstance({
+      numberOfComponents: 3,
+      size: 6 * 3,
+      // 6 planes, each with a normal
+      dataType: VtkDataTypes.DOUBLE
+    });
+    pts.setNumberOfPoints(6);
+    publicAPI.setPoints(pts);
+    publicAPI.setNormals(normals);
+    const n = [];
+    const x = [];
+    for (let i = 0; i < 6; i++) {
+      const planeOffset = 4 * i;
+      n[0] = -planes[planeOffset];
+      n[1] = -planes[planeOffset + 1];
+      n[2] = -planes[planeOffset + 2];
+      x[0] = 0.0;
+      x[1] = 0.0;
+      x[2] = 0.0;
+      if (n[0] !== 0.0) {
+        x[0] = planes[planeOffset + 3] / n[0];
+      } else if (n[1] !== 0.0) {
+        x[1] = planes[planeOffset + 3] / n[1];
+      } else {
+        x[2] = planes[planeOffset + 3] / n[2];
+      }
+      pts.setPoint(i, ...x);
+      normals.setTuple(i, n);
+    }
+    publicAPI.modified();
+    return true;
+  };
+
+  /**
+   * Set the bounds of the planes
+   * @param {*} bounds The bounds to set
+   * @returns {Boolean} true if bounds were set, false if they were already set
+   */
+  publicAPI.setBounds = bounds => {
+    if (vtkMath.areEquals(model.bounds, bounds)) {
+      return false;
+    }
+    model.bounds = [...bounds];
+    const pts = vtkPoints.newInstance();
+    const normals = vtkDataArray.newInstance({
+      numberOfComponents: 3,
+      size: 6 * 3,
+      // 6 planes, each with a normal
+      dataType: VtkDataTypes.DOUBLE
+    });
+    pts.setNumberOfPoints(6);
+    publicAPI.setPoints(pts);
+    publicAPI.setNormals(normals);
+    const n = [];
+    const x = [];
+
+    // The x planes
+    n[0] = -1.0;
+    n[1] = 0.0;
+    n[2] = 0.0;
+    x[0] = bounds[0];
+    x[1] = 0.0;
+    x[2] = 0.0;
+    pts.setPoint(0, ...x);
+    normals.setTuple(0, n);
+    n[0] = 1.0;
+    x[0] = bounds[1];
+    pts.setPoint(1, ...x);
+    normals.setTuple(1, n);
+
+    // The y planes
+    n[0] = 0.0;
+    n[1] = -1.0;
+    n[2] = 0.0;
+    x[0] = 0.0;
+    x[1] = bounds[2];
+    x[2] = 0.0;
+    pts.setPoint(2, ...x);
+    normals.setTuple(2, n);
+    n[1] = 1.0;
+    x[1] = bounds[3];
+    pts.setPoint(3, ...x);
+    normals.setTuple(3, n);
+
+    // The z planes
+    n[0] = 0.0;
+    n[1] = 0.0;
+    n[2] = -1.0;
+    x[0] = 0.0;
+    x[1] = 0.0;
+    x[2] = bounds[4];
+    pts.setPoint(4, ...x);
+    normals.setTuple(4, n);
+    n[2] = 1.0;
+    x[2] = bounds[5];
+    pts.setPoint(5, ...x);
+    normals.setTuple(5, n);
+    publicAPI.modified();
+    return true;
+  };
+
+  /**
+   * Get the number of planes
+   * @returns {Number} the number of planes
+   */
+  publicAPI.getNumberOfPlanes = () => {
+    if (model.points && model.normals) {
+      const npts = model.points.getNumberOfPoints();
+      const nnormals = model.normals.getNumberOfTuples();
+      return Math.min(npts, nnormals);
+    }
+    return 0;
+  };
+
+  /**
+   * Get the i-th plane
+   * @param {*} i
+   * @param {vtkPlane} plane the vtkPlane instance to fill
+   * @returns {vtkPlane} the plane instance
+   */
+  publicAPI.getPlane = function (i) {
+    let plane = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : model.plane;
+    if (i >= 0 && i < publicAPI.getNumberOfPlanes()) {
+      const normal = model.normals.getTuple(i);
+      const point = model.points.getPoint(i);
+      plane.setNormal(normal);
+      plane.setOrigin(point);
+    }
+    return plane;
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  points: null,
+  normals: null,
+  planes: null,
+  bounds: null
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Build VTK API
+  vtkImplicitFunction.extend(publicAPI, model, initialValues);
+  macro.setGet(publicAPI, model, ['points', 'normals']);
+  macro.get(publicAPI, model, ['bounds', 'planes']);
+
+  // Object methods
+  vtkPlanes(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkPlanes');
+
+// ----------------------------------------------------------------------------
+
+var vtkPlanes$1 = {
+  newInstance,
+  extend
+};
+
+export { vtkPlanes$1 as default, extend, newInstance };

package/Common/DataModel.js

@@ -12,6 +12,7 @@ import vtkLine from './DataModel/Line.js';
 import vtkMolecule from './DataModel/Molecule.js';
 import vtkPiecewiseFunction from './DataModel/PiecewiseFunction.js';
 import vtkPlane from './DataModel/Plane.js';
+import vtkPlanes from './DataModel/Planes.js';
 import vtkPointSet from './DataModel/PointSet.js';
 import vtkPolyData from './DataModel/PolyData.js';
 import vtkSelectionNode from './DataModel/SelectionNode.js';
@@ -35,6 +36,7 @@ var DataModel = {
   vtkMolecule,
   vtkPiecewiseFunction,
   vtkPlane,
+  vtkPlanes,
   vtkPointSet,
   vtkPolyData,
   vtkSelectionNode,

package/Interaction/Manipulators/MouseCameraTrackballPanManipulatorAutoCenter.js

@@ -0,0 +1,120 @@
+import { m as macro } from '../../macros2.js';
+import vtkMouseCameraTrackballPanManipulator from './MouseCameraTrackballPanManipulator.js';
+import { mat4, vec3 } from 'gl-matrix';
+
+// ----------------------------------------------------------------------------
+// Helper functions for center of rotation adjustment
+// ----------------------------------------------------------------------------
+
+/**
+ * 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.
+ *
+ * @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);
+}
+function getCameraMatrix(renderer, tempMatrix) {
+  const cam = renderer.getActiveCamera();
+  if (cam) {
+    mat4.copy(tempMatrix, cam.getViewMatrix());
+    return tempMatrix;
+  }
+  return null;
+}
+function vtkMouseCameraTrackballPanManipulatorAutoCenter(publicAPI, model) {
+  model.classHierarchy.push('vtkMouseCameraTrackballPanManipulatorAutoCenter');
+  const tempCameraMatrix = mat4.create();
+  const tempComputeObjects = {
+    matrixA: mat4.create(),
+    matrixB: mat4.create(),
+    newCenter: vec3.create()
+  };
+  const superOnMouseMove = publicAPI.onMouseMove;
+  publicAPI.onMouseMove = (interactor, renderer, position) => {
+    if (!position) {
+      return;
+    }
+    const beforeCameraMatrix = getCameraMatrix(renderer, tempCameraMatrix);
+    superOnMouseMove(interactor, renderer, position);
+    if (beforeCameraMatrix && model.center) {
+      const newCenter = computeNewCenterOfRotation(tempComputeObjects, renderer, beforeCameraMatrix, model.center);
+      publicAPI.setCenter(newCenter);
+      const style = interactor.getInteractorStyle();
+      if (style && style.setCenterOfRotation) {
+        style.setCenterOfRotation(newCenter);
+      }
+    }
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Inheritance
+  vtkMouseCameraTrackballPanManipulator.extend(publicAPI, model, initialValues);
+
+  // Object specific methods
+  vtkMouseCameraTrackballPanManipulatorAutoCenter(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkMouseCameraTrackballPanManipulatorAutoCenter');
+
+// ----------------------------------------------------------------------------
+
+var index = {
+  newInstance,
+  extend
+};
+
+export { index as default, extend, newInstance };

package/Interaction/Style/InteractorStyleManipulator.js

@@ -1,7 +1,6 @@
 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
@@ -102,62 +101,6 @@ 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
@@ -176,14 +119,6 @@ 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 = [];
@@ -480,11 +415,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
   publicAPI.handleMouseMove = callData => {
     model.cachedMousePosition = callData.position;
     if (model.currentManipulator && model.currentManipulator.onMouseMove) {
-      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);
+      model.currentManipulator.onMouseMove(model._interactor, model.getRenderer(callData), callData.position);
       publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
     }
   };
@@ -627,7 +558,6 @@ 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--) {
@@ -638,8 +568,6 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
       }
     }
     if (actionCount) {
-      const newCenter = computeNewCenterOfRotation(tempComputeObjects, renderer, beforeCameraMatrix, model.centerOfRotation);
-      publicAPI.setCenterOfRotation(newCenter);
       publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
     }
   };

package/README.md

@@ -48,8 +48,8 @@ In general VTK tries to be as portable as possible; the specific configurations
 
 vtk.js supports the following development environments:
 
-- Node 14+
-- NPM 7+
+- Node 22+
+- NPM 10+
 
 and we use [@babel/preset-env](https://www.npmjs.com/package/@babel/preset-env) with the [defaults](https://github.com/Kitware/vtk-js/blob/master/.browserslistrc) set of [browsers target](https://browserl.ist/?q=defaults).
 But when built from source this could be adjusted to support any browser as long they provide WebGL.
@@ -78,4 +78,3 @@ See [Copyright.txt][] for details.
 ## Contributing
 
 See [CONTRIBUTING.md](CONTRIBUTING.md) for instructions on how to contribute.
-

package/Rendering/Core/Camera.d.ts

@@ -301,10 +301,17 @@ export interface vtkCamera extends vtkObject {
   getViewAngle(): number;
 
   /**
-   *
+   * Get the view transform
    */
   getViewMatrix(): mat4;
 
+  /**
+   * Get the model transform matrix for the camera.
+   * This matrix could be used for model related transformations such as scale, shear, rotations and translations.
+   * @returns {mat4} mat The value of the model transform matrix.
+   */
+  getModelTransformMatrix(): mat4;
+
   /**
    * Get the ViewPlaneNormal.
    * This vector will point opposite to the direction of projection,
@@ -674,7 +681,14 @@ export interface vtkCamera extends vtkObject {
    * Set the view matrix for the camera.
    * @param {mat4} mat The value of the view matrix.
    */
-  setViewMatrix(mat: mat4): boolean;
+  setViewMatrix(mat: mat4): void;
+
+  /**
+   * Set the model transform matrix for the camera.
+   * This matrix could be used for model related transformations such as scale, shear, rotations and translations.
+   * @param {mat4} mat The value of the model transform matrix.
+   */
+  setModelTransformMatrixMatrix(mat: mat4): void;
 
   /**
    * Set the view up direction for the camera.

package/Rendering/Core/Camera.js

@@ -402,6 +402,10 @@ function vtkCamera(publicAPI, model) {
     mat4.multiply(tmpMatrix, mat, tmpMatrix);
     publicAPI.computeViewParametersFromViewMatrix(tmpMatrix);
   };
+  publicAPI.setModelTransformMatrix = mat => {
+    model.modelTransformMatrix = mat;
+  };
+  publicAPI.getModelTransformMatrix = () => model.modelTransformMatrix;
   publicAPI.setViewMatrix = mat => {
     model.viewMatrix = mat;
     if (model.viewMatrix) {
@@ -412,6 +416,10 @@ function vtkCamera(publicAPI, model) {
   };
   publicAPI.getViewMatrix = () => {
     if (model.viewMatrix) {
+      if (model.modelTransformMatrix) {
+        mat4.multiply(tmpMatrix, model.viewMatrix, model.modelTransformMatrix);
+        return tmpMatrix;
+      }
       return model.viewMatrix;
     }
     mat4.lookAt(tmpMatrix, model.position,
@@ -423,7 +431,11 @@ function vtkCamera(publicAPI, model) {
 
     mat4.transpose(tmpMatrix, tmpMatrix);
     const result = new Float64Array(16);
-    mat4.copy(result, tmpMatrix);
+    if (model.modelTransformMatrix) {
+      mat4.multiply(result, tmpMatrix, model.modelTransformMatrix);
+    } else {
+      mat4.copy(result, tmpMatrix);
+    }
     return result;
   };
   publicAPI.setProjectionMatrix = mat => {
@@ -613,6 +625,7 @@ const DEFAULT_VALUES = {
   freezeFocalPoint: false,
   projectionMatrix: null,
   viewMatrix: null,
+  modelTransformMatrix: null,
   cameraLightTransform: mat4.create(),
   // used for world to physical transformations
   physicalTranslation: [0, 0, 0],

package/Widgets/Core/WidgetManager.js

@@ -186,12 +186,23 @@ function vtkWidgetManager(publicAPI, model) {
       model._interactor.render();
     }
   }
+  const deactivateAllWidgets = () => {
+    let wantRender = false;
+    for (let i = 0; i < model.widgets.length; i++) {
+      const w = model.widgets[i];
+      wantRender ||= !!w.getActiveState();
+      w.deactivateAllHandles();
+    }
+    if (wantRender) model._interactor.render();
+  };
   const handleEvent = async function (callData) {
     let fromTouchEvent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     if (!model.isAnimating && model.pickingEnabled && callData.pokedRenderer === model._renderer) {
       const callID = Symbol('UpdateSelection');
       model._currentUpdateSelectionCallID = callID;
       await updateSelection(callData, fromTouchEvent, callID);
+    } else {
+      deactivateAllWidgets();
     }
   };
   function updateWidgetForRender(w) {

package/index.d.ts

@@ -39,6 +39,7 @@
 /// <reference path="./Common/DataModel/Locator.d.ts" />
 /// <reference path="./Common/DataModel/PiecewiseFunction.d.ts" />
 /// <reference path="./Common/DataModel/Plane.d.ts" />
+/// <reference path="./Common/DataModel/Planes.d.ts" />
 /// <reference path="./Common/DataModel/PointSet.d.ts" />
 /// <reference path="./Common/DataModel/PolyData/Constants.d.ts" />
 /// <reference path="./Common/DataModel/PolyData.d.ts" />

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "34.8.1",
+  "version": "34.10.0",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",
@@ -238,5 +238,6 @@
   "publishConfig": {
     "access": "public"
   },
+  "type": "module",
   "types": "./index.d.ts"
 }