@kitware/vtk.js 34.8.0 → 34.9.1

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/VectorText/Utils.js

@@ -384,7 +384,7 @@ function addTriangle(layers, a, b, c, verticesArray, uvArray, colorArray, color)
     uvArray.push(uv[0], uv[1]);
   });
   if (colorArray && color) {
-    for (let i = 0; i < 3; ++i) colorArray.push(color[0], color[1], color[2]);
+    for (let i = 0; i < 3; ++i) colorArray.push(color[0] * 255, color[1] * 255, color[2] * 255);
   }
 }
 
@@ -417,7 +417,7 @@ function addQuad(layers, a, b, c, d, verticesArray, uvArray, colorArray, color)
   uvArray.push(uvs[2][0], uvs[2][1]);
   uvArray.push(uvs[3][0], uvs[3][1]);
   if (colorArray && color) {
-    for (let i = 0; i < 6; ++i) colorArray.push(color[0], color[1], color[2]);
+    for (let i = 0; i < 6; ++i) colorArray.push(color[0] * 255, color[1] * 255, color[2] * 255);
   }
 }
 

package/Rendering/Core/VectorText.js

@@ -258,7 +258,7 @@ function vtkVectorText(publicAPI, model) {
     let letterIndex = 0;
     model.shapes.forEach(shape => {
       let color = null;
-      if (typeof model.perLetterFaceColors === 'function') {
+      if (model.perLetterFaceColors) {
         color = model.perLetterFaceColors(letterIndex) || [1, 1, 1];
       }
       addShape(shape, offsetSize, color);
@@ -285,12 +285,12 @@ function vtkVectorText(publicAPI, model) {
     polyData.setPolys(cells);
 
     // Set points (vertices)
-    polyData.getPoints().setData(new Float32Array(model.verticesArray), 3);
+    polyData.getPoints().setData(Float32Array.from(model.verticesArray), 3);
 
     // Set texture coordinates
     const da = vtkDataArray.newInstance({
       numberOfComponents: 2,
-      values: new Float32Array(model.uvArray),
+      values: Float32Array.from(model.uvArray),
       name: 'TEXCOORD_0'
     });
     pointData.addArray(da);
@@ -300,7 +300,7 @@ function vtkVectorText(publicAPI, model) {
     if (model.colorArray && model.colorArray.length) {
       const ca = vtkDataArray.newInstance({
         numberOfComponents: 3,
-        values: new Float32Array(model.colorArray),
+        values: Uint8Array.from(model.colorArray),
         name: 'Colors'
       });
       pointData.addArray(ca);

package/Rendering/OpenGL/Glyph3DMapper.js

@@ -5,7 +5,9 @@ import vtkHardwareSelector from './HardwareSelector.js';
 import vtkProperty from '../Core/Property.js';
 import vtkOpenGLPolyDataMapper from './PolyDataMapper.js';
 import vtkShaderProgram from './ShaderProgram.js';
+import { computeCoordShiftAndScale } from './CellArrayBufferObject/helpers.js';
 import { registerOverride } from './ViewNodeFactory.js';
+import { primTypes } from './Helper.js';
 
 const {
   vtkErrorMacro
@@ -25,6 +27,17 @@ const StartEvent = {
 const EndEvent = {
   type: 'EndEvent'
 };
+const MAT4_BYTE_SIZE = 64;
+const MAT4_ELEMENT_COUNT = 16;
+function applyShiftScaleToMat(mat, shift, scale) {
+  // the translation component of a 4x4 column-major matrix
+  mat[12] = (mat[12] - shift[0]) * scale[0];
+  mat[13] = (mat[13] - shift[1]) * scale[1];
+  mat[14] = (mat[14] - shift[2]) * scale[2];
+  mat[0] *= scale[0];
+  mat[5] *= scale[1];
+  mat[10] *= scale[2];
+}
 
 // ----------------------------------------------------------------------------
 // vtkOpenGLSphereMapper methods
@@ -389,9 +402,15 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
     return false;
   };
   publicAPI.buildBufferObjects = (ren, actor) => {
+    const garray = model.renderable.getMatrixArray();
+    const pts = model.renderable.getInputData(0).getPoints();
+    const {
+      useShiftAndScale,
+      coordShift,
+      coordScale
+    } = computeCoordShiftAndScale(pts);
     if (model.hardwareSupport) {
       // update the buffer objects if needed
-      const garray = model.renderable.getMatrixArray();
       const narray = model.renderable.getNormalArray();
       const carray = model.renderable.getColorArray();
       if (!model.matrixBuffer) {
@@ -404,6 +423,13 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
         model.pickBuffer = vtkBufferObject.newInstance();
         model.pickBuffer.setOpenGLRenderWindow(model._openGLRenderWindow);
       }
+      if (useShiftAndScale) {
+        const buf = garray.buffer;
+        for (let ptIdx = 0; ptIdx < garray.byteLength; ptIdx += MAT4_BYTE_SIZE) {
+          const mat = new Float32Array(buf, ptIdx, MAT4_ELEMENT_COUNT);
+          applyShiftScaleToMat(mat, coordShift, coordScale);
+        }
+      }
       if (model.renderable.getBuildTime().getMTime() > model.glyphBOBuildTime.getMTime()) {
         model.matrixBuffer.upload(garray, ObjectType.ARRAY_BUFFER);
         model.normalBuffer.upload(narray, ObjectType.ARRAY_BUFFER);
@@ -430,7 +456,15 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
         model.glyphBOBuildTime.modified();
       }
     }
-    return superClass.buildBufferObjects(ren, actor);
+    superClass.buildBufferObjects(ren, actor);
+
+    // apply shift + scale to primitives AFTER vtkOpenGLPolyDataMapper.buildBufferObjects
+    // so that the Glyph3DMapper gets the last say in the shift + scale
+    if (useShiftAndScale) {
+      for (let i = primTypes.Start; i < primTypes.End; i++) {
+        model.primitives[i].getCABO().setCoordShiftAndScale(coordShift, coordScale);
+      }
+    }
   };
 }
 

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "34.8.0",
+  "version": "34.9.1",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",
@@ -30,7 +30,7 @@
   "main": "./index.js",
   "module": "./index.js",
   "dependencies": {
-    "@babel/runtime": "7.22.11",
+    "@babel/runtime": "^7.28.2",
     "@types/webxr": "^0.5.5",
     "commander": "9.2.0",
     "d3-scale": "4.0.2",
@@ -67,7 +67,7 @@
     "babel-loader": "8.2.5",
     "babel-plugin-istanbul": "6.1.1",
     "buffer": "6.0.3",
-    "commitizen": "4.2.5",
+    "commitizen": "^4.3.1",
     "concurrently": "7.1.0",
     "copy-webpack-plugin": "10.2.4",
     "cross-env": "7.0.3",
@@ -125,7 +125,7 @@
     "webpack-bundle-analyzer": "4.5.0",
     "webpack-cli": "4.9.2",
     "webpack-dashboard": "3.3.7",
-    "webpack-dev-server": "4.9.0",
+    "webpack-dev-server": "^5.2.2",
     "webpack-merge": "5.8.0",
     "webpack-notifier": "1.15.0",
     "wslink": "1.12.4",
@@ -238,5 +238,6 @@
   "publishConfig": {
     "access": "public"
   },
+  "type": "module",
   "types": "./index.d.ts"
 }