feat: add resetCameraScreenSpace method with offsetRatio input

Port of VTK C++ vtkRenderer::ResetCameraScreenSpace. Uses a screen-space
bounding box to zoom closer to the data, correctly accounting for viewport
aspect ratio for both perspective and parallel projection.

Also adds zoomToBoxUsingViewAngle as a standalone public method.

Closes #1285

Author: skoloCFD

CONTRIBUTING.md

@@ -33,34 +33,27 @@ Please follow the coding style:
     $ git checkout -b new_feature
     ```
 
-6. Start hacking. Additional information on how to create class/test/example can be found
+4. Start hacking. Additional information on how to create class/test/example can be found
    [here](https://kitware.github.io/vtk-js/docs/) in the __Development__ section.
 
     ```sh
     $ edit file1 file2 file3
     $ git add file1 file2 file3
     ```
 
-7. Verify you have correctly formatted code, and that all tests pass:
-
-    ```sh
-    $ npm run reformat
-    $ npm run test
-    ```
-
-8. Use Commitizen to create commits
+5. Use Commitizen to create commits
 
     ```sh
     $ npm run commit
     ```
 
-9. Push commits in your feature branch to your fork in GitHub:
+6. Push commits in your feature branch to your fork in GitHub:
 
     ```sh
     $ git push origin new_feature
     ```
 
-10. Visit your fork in Github, browse to the "**Pull Requests**" link on the left, and use the 
+7. Visit your fork in Github, browse to the "**Pull Requests**" link on the left, and use the 
    "**New Pull Request**" button in the upper right to create a Pull Request.
 
     For more information see: 
@@ -69,7 +62,7 @@ Please follow the coding style:
 If committing changes to `vtk.js@next` or `vtk.js@next-major`, then set your base branch to be `next`
 or `next-major`, respectively. For more info see the section on release channels below.
 
-11. vtk.js uses GitHub for code review and Github Actions to validate proposed patches before they are merged.
+8. vtk.js uses GitHub for code review and Github Actions to validate proposed patches before they are merged.
 
 ## Release Channels
 

Sources/Filters/General/ImageMarchingSquares/index.js

@@ -86,65 +86,57 @@ function vtkImageMarchingSquares(publicAPI, model) {
   /**
    * Retrieve pixel coordinates.
    * @param {Vector3} ijk origin of the pixel
+   * @param {Vector3} origin origin of the image
+   * @param {Vector3} spacing spacing of the image
    * @param {number} kernelX index of the X element
    * @param {number} kernelY index of the Y element
-   * @param {Function} indexToWorld function to convert index to world coordinates
    */
-  publicAPI.getPixelPoints = (ijk, kernelX, kernelY, indexToWorld) => {
-    // pixelPts = a flattened world coordinates array of [ (i,j,k), (i+1,j,k), (i,j+1,k), (i+1,j+1,k)]
-
-    // 0: i, j, k
-    const neighborIJK = [...ijk];
-    indexToWorld(neighborIJK, pixelPts);
-
-    // 1: i+1, j, k
-    neighborIJK[kernelX] += 1;
-    const temp = indexToWorld(neighborIJK, []);
-    pixelPts[3] = temp[0];
-    pixelPts[4] = temp[1];
-    pixelPts[5] = temp[2];
-
-    // 2: i+1, j+1, k
-    neighborIJK[kernelY] += 1;
-    indexToWorld(neighborIJK, temp);
-    pixelPts[9] = temp[0];
-    pixelPts[10] = temp[1];
-    pixelPts[11] = temp[2];
-
-    // 3: i, j+1, k
-    neighborIJK[kernelX] -= 1;
-    indexToWorld(neighborIJK, temp);
-    pixelPts[6] = temp[0];
-    pixelPts[7] = temp[1];
-    pixelPts[8] = temp[2];
+  publicAPI.getPixelPoints = (ijk, origin, spacing, kernelX, kernelY) => {
+    const i = ijk[kernelX];
+    const j = ijk[kernelY];
+
+    // (i,i+1),(j,j+1),(k,k+1) - i varies fastest; then j; then k
+    pixelPts[0] = origin[kernelX] + i * spacing[kernelX]; // 0
+    pixelPts[1] = origin[kernelY] + j * spacing[kernelY];
+
+    pixelPts[2] = pixelPts[0] + spacing[kernelX]; // 1
+    pixelPts[3] = pixelPts[1];
+
+    pixelPts[4] = pixelPts[0]; // 2
+    pixelPts[5] = pixelPts[1] + spacing[kernelY];
+
+    pixelPts[6] = pixelPts[2]; // 3
+    pixelPts[7] = pixelPts[5];
   };
 
   /**
    * Produce points and lines for the polydata.
    * @param {number[]} cVal list of contour values
    * @param {Vector3} ijk origin of the pixel
    * @param {Vector3} dims dimensions of the image
+   * @param {Vector3} origin origin of the image
    * @param {Vector3} spacing sapcing of the image
    * @param {TypedArray} scalars list of scalar values
    * @param {number[]} points list of points
    * @param {number[]} lines list of lines
    * @param {Vector3} increments IJK slice increments
    * @param {number} kernelX index of the X element
    * @param {number} kernelY index of the Y element
-   * @param {Function} indexToWorld function to convert index to world coordinates
    */
   publicAPI.produceLines = (
     cVal,
     ijk,
     dims,
+    origin,
+    spacing,
     scalars,
     points,
     lines,
     increments,
     kernelX,
-    kernelY,
-    indexToWorld
+    kernelY
   ) => {
+    const k = ijk[model.slicingMode];
     const CASE_MASK = [1, 2, 8, 4]; // case table is actually for quad
     const xyz = [];
     let pId;
@@ -163,8 +155,9 @@ function vtkImageMarchingSquares(publicAPI, model) {
       return; // don't get the pixel coordinates, nothing to do
     }
 
-    publicAPI.getPixelPoints(ijk, kernelX, kernelY, indexToWorld);
+    publicAPI.getPixelPoints(ijk, origin, spacing, kernelX, kernelY);
 
+    const z = origin[model.slicingMode] + k * spacing[model.slicingMode];
     for (let idx = 0; pixelLines[idx] >= 0; idx += 2) {
       lines.push(2);
       for (let eid = 0; eid < 2; eid++) {
@@ -180,11 +173,11 @@ function vtkImageMarchingSquares(publicAPI, model) {
           const t =
             (cVal - pixelScalars[edgeVerts[0]]) /
             (pixelScalars[edgeVerts[1]] - pixelScalars[edgeVerts[0]]);
-          const x0 = pixelPts.slice(edgeVerts[0] * 3, (edgeVerts[0] + 1) * 3);
-          const x1 = pixelPts.slice(edgeVerts[1] * 3, (edgeVerts[1] + 1) * 3);
-          xyz[0] = x0[0] + t * (x1[0] - x0[0]);
-          xyz[1] = x0[1] + t * (x1[1] - x0[1]);
-          xyz[2] = x0[2] + t * (x1[2] - x0[2]);
+          const x0 = pixelPts.slice(edgeVerts[0] * 2, (edgeVerts[0] + 1) * 2);
+          const x1 = pixelPts.slice(edgeVerts[1] * 2, (edgeVerts[1] + 1) * 2);
+          xyz[kernelX] = x0[0] + t * (x1[0] - x0[0]);
+          xyz[kernelY] = x0[1] + t * (x1[1] - x0[1]);
+          xyz[model.slicingMode] = z;
           pId = points.length / 3;
           points.push(xyz[0], xyz[1], xyz[2]);
 
@@ -218,12 +211,13 @@ function vtkImageMarchingSquares(publicAPI, model) {
     console.time('msquares');
 
     // Retrieve output and volume data
+    const origin = input.getOrigin();
+    const spacing = input.getSpacing();
     const dims = input.getDimensions();
     const extent = input.getExtent();
     const increments = input.computeIncrements(extent);
     const scalars = input.getPointData().getScalars().getData();
     const [kernelX, kernelY] = getKernels();
-    const indexToWorld = input.indexToWorld;
 
     // Points - dynamic array
     const points = [];
@@ -250,13 +244,14 @@ function vtkImageMarchingSquares(publicAPI, model) {
             model.contourValues[cv],
             ijk,
             dims,
+            origin,
+            spacing,
             scalars,
             points,
             lines,
             increments,
             kernelX,
-            kernelY,
-            indexToWorld
+            kernelY
           );
         }
       }

Sources/IO/Geometry/IFCImporter/index.js

@@ -45,14 +45,14 @@ function vtkIFCImporter(publicAPI, model) {
     const pointValues = new Float32Array(vertices.length / 2);
     const normalsArray = new Float32Array(vertices.length / 2);
 
-    for (let i = 0, p = 0; i < vertices.length; p += 3) {
-      pointValues[p] = vertices[i++];
-      pointValues[p + 1] = vertices[i++];
-      pointValues[p + 2] = vertices[i++];
-
-      normalsArray[p] = vertices[i++];
-      normalsArray[p + 1] = vertices[i++];
-      normalsArray[p + 2] = vertices[i++];
+    for (let i = 0; i < vertices.length; i += 6) {
+      pointValues[i / 2] = vertices[i];
+      pointValues[i / 2 + 1] = vertices[i + 1];
+      pointValues[i / 2 + 2] = vertices[i + 2];
+
+      normalsArray[i / 2] = vertices[i + 3];
+      normalsArray[i / 2 + 1] = vertices[i + 4];
+      normalsArray[i / 2 + 2] = vertices[i + 5];
     }
 
     const nCells = indices.length;
@@ -91,42 +91,48 @@ function vtkIFCImporter(publicAPI, model) {
     const colorArray = new Float32Array(vertices.length / 2);
 
     if (userMatrix) {
-      for (let i = 0, p = 0; i < vertices.length; p += 3) {
-        pointValues[p] = vertices[i++];
-        pointValues[p + 1] = vertices[i++];
-        pointValues[p + 2] = vertices[i++];
-
-        normalsArray[p] = vertices[i++];
-        normalsArray[p + 1] = vertices[i++];
-        normalsArray[p + 2] = vertices[i++];
-
-        colorArray[p] = color.x;
-        colorArray[p + 1] = color.y;
-        colorArray[p + 2] = color.z;
-      }
-
-      vtkMatrixBuilder
+      const transformMatrix = vtkMatrixBuilder
         .buildFromRadian()
-        .setMatrix(userMatrix)
-        .apply(pointValues);
+        .setMatrix(userMatrix);
 
-      vtkMatrixBuilder
+      const normalMatrix = vtkMatrixBuilder
         .buildFromRadian()
-        .multiply3x3(mat3.fromMat4(mat3.create(), userMatrix))
-        .apply(normalsArray);
+        .multiply3x3(mat3.fromMat4(mat3.create(), userMatrix));
+
+      for (let i = 0; i < vertices.length; i += 6) {
+        const point = [vertices[i], vertices[i + 1], vertices[i + 2]];
+        const normal = [vertices[i + 3], vertices[i + 4], vertices[i + 5]];
+
+        transformMatrix.apply(point);
+        normalMatrix.apply(normal);
+
+        pointValues[i / 2] = point[0];
+        pointValues[i / 2 + 1] = point[1];
+        pointValues[i / 2 + 2] = point[2];
+
+        normalsArray[i / 2] = normal[0];
+        normalsArray[i / 2 + 1] = normal[1];
+        normalsArray[i / 2 + 2] = normal[2];
+
+        const colorIndex = i / 2;
+        colorArray[colorIndex] = color.x;
+        colorArray[colorIndex + 1] = color.y;
+        colorArray[colorIndex + 2] = color.z;
+      }
     } else {
-      for (let i = 0, p = 0; i < vertices.length; p += 3) {
-        pointValues[p] = vertices[i++];
-        pointValues[p + 1] = vertices[i++];
-        pointValues[p + 2] = vertices[i++];
-
-        normalsArray[p] = vertices[i++];
-        normalsArray[p + 1] = vertices[i++];
-        normalsArray[p + 2] = vertices[i++];
-
-        colorArray[p] = color.x;
-        colorArray[p + 1] = color.y;
-        colorArray[p + 2] = color.z;
+      for (let i = 0; i < vertices.length; i += 6) {
+        pointValues[i / 2] = vertices[i];
+        pointValues[i / 2 + 1] = vertices[i + 1];
+        pointValues[i / 2 + 2] = vertices[i + 2];
+
+        normalsArray[i / 2] = vertices[i + 3];
+        normalsArray[i / 2 + 1] = vertices[i + 4];
+        normalsArray[i / 2 + 2] = vertices[i + 5];
+
+        const colorIndex = i / 2;
+        colorArray[colorIndex] = color.x;
+        colorArray[colorIndex + 1] = color.y;
+        colorArray[colorIndex + 2] = color.z;
       }
     }
 

Sources/Rendering/Core/Renderer/index.d.ts

@@ -611,6 +611,45 @@ export interface vtkRenderer extends vtkViewport {
    */
   resetCamera(bounds?: Bounds): boolean;
 
+  /**
+   * Zoom the camera so the given screen-space box fills the viewport.
+   *
+   * Matches the VTK C++ vtkRenderer::ZoomToBoxUsingViewAngle behavior.
+   *
+   * @param {{ x: number; y: number; width: number; height: number }} box
+   *   Screen-space rectangle in display (pixel) coordinates.
+   * @param {Number} [offsetRatio=1.0] Scale factor applied to the zoom
+   *   (values < 1 leave a margin around the box).
+   */
+  zoomToBoxUsingViewAngle(
+    box: { x: number; y: number; width: number; height: number },
+    offsetRatio?: number
+  ): void;
+
+  /**
+   * Automatically set up the camera based on the visible actors, using a
+   * screen-space bounding box to zoom closer to the data.
+   *
+   * This method first calls resetCamera to ensure all bounds are visible, then
+   * projects the bounding box corners to screen space and zooms so the actors
+   * fill the specified fraction of the viewport. This correctly accounts for
+   * viewport aspect ratio for both perspective and parallel projection.
+   *
+   * Matches the VTK C++ vtkRenderer::ResetCameraScreenSpace behavior.
+   *
+   * @param {Bounds} [bounds] Optional bounding box to use. If not provided,
+   *   the visible prop bounds are computed automatically.
+   * @param {Number} [offsetRatio=0.9] Fraction of screen space to fill
+   *   (0.9 = 90%, leaving 10% margin at the edges).
+   */
+  resetCameraScreenSpace(bounds?: Bounds | null, offsetRatio?: number): boolean;
+
+  /**
+   * Overload that accepts only offsetRatio (bounds are computed automatically).
+   * @param {Number} offsetRatio Fraction of screen space to fill.
+   */
+  resetCameraScreenSpace(offsetRatio?: number): boolean;
+
   /**
    * Reset the camera clipping range based on a bounding box.
    * @param {Bounds} [bounds]