fix: resetCameraScreenSpace fully consistent with VTK cpp

#1285

Author: skoloCFD

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

@@ -612,10 +612,26 @@ export interface vtkRenderer extends vtkViewport {
   resetCamera(bounds?: Bounds): boolean;
 
   /**
-   * Reset the camera accounting for viewport aspect ratio to prevent cropping.
-   * This is similar to resetCamera but computes the parallel scale from view space
-   * dimensions, which fixes issues where narrow viewports crop significantly.
-   * @param {Number} [offsetRatio=0.9] The fraction of space to use (default 0.9 = 90%, leaving 10% margin)
+   * 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;
 

Sources/Rendering/Core/Renderer/index.js

@@ -464,144 +464,108 @@ function vtkRenderer(publicAPI, model) {
     return true;
   };
 
-  publicAPI.resetCameraScreenSpace = (offsetRatio = 0.9) => {
-    const boundsToUse = publicAPI.computeVisiblePropBounds();
-    const center = [0, 0, 0];
+  // Port of VTK C++ vtkRenderer::ResetCameraScreenSpace.
+  // Uses a screen-space bounding box to zoom closer to the data.
+  publicAPI.resetCameraScreenSpace = (bounds = null, offsetRatio = 0.9) => {
+    let effectiveBounds = bounds;
+    let effectiveOffsetRatio = offsetRatio;
+    if (typeof bounds === 'number') {
+      effectiveOffsetRatio = bounds;
+      effectiveBounds = null;
+    }
+
+    const boundsToUse = effectiveBounds || publicAPI.computeVisiblePropBounds();
 
     if (!vtkMath.areBoundsInitialized(boundsToUse)) {
       vtkDebugMacro('Cannot reset camera!');
       return false;
     }
 
-    let vn = null;
+    // Make sure all bounds are visible to project into screen space
+    publicAPI.resetCamera(boundsToUse);
 
-    if (publicAPI.getActiveCamera()) {
-      vn = model.activeCamera.getViewPlaneNormal();
-    } else {
-      vtkErrorMacro('Trying to reset non-existent camera');
-      return false;
+    // Get the view from the render window to access viewport size and
+    // world-to-display conversion
+    let view = null;
+    if (model._renderWindow && model._renderWindow.getViews) {
+      const views = model._renderWindow.getViews();
+      if (views.length > 0) {
+        view = views[0];
+      }
     }
 
-    // Reset the perspective zoom factors, otherwise subsequent zooms will cause
-    // the view angle to become very small and cause bad depth sorting.
-    model.activeCamera.setViewAngle(30.0);
-
-    center[0] = (boundsToUse[0] + boundsToUse[1]) / 2.0;
-    center[1] = (boundsToUse[2] + boundsToUse[3]) / 2.0;
-    center[2] = (boundsToUse[4] + boundsToUse[5]) / 2.0;
+    if (!view || !view.getViewportSize) {
+      return true;
+    }
 
-    let w1 = boundsToUse[1] - boundsToUse[0];
-    let w2 = boundsToUse[3] - boundsToUse[2];
-    let w3 = boundsToUse[5] - boundsToUse[4];
-    w1 *= w1;
-    w2 *= w2;
-    w3 *= w3;
-    let radius = w1 + w2 + w3;
+    const size = view.getViewportSize(publicAPI);
+    if (!size || size[0] <= 0 || size[1] <= 0) {
+      return true;
+    }
 
-    // If we have just a single point, pick a radius of 1.0
-    radius = radius === 0 ? 1.0 : radius;
+    const aspect = size[0] / size[1];
 
-    // compute the radius of the enclosing sphere
-    radius = Math.sqrt(radius) * 0.5;
+    // Compute the screen-space bounding box by projecting all 8 corners
+    let xmin = Number.MAX_VALUE;
+    let ymin = Number.MAX_VALUE;
+    let xmax = -Number.MAX_VALUE;
+    let ymax = -Number.MAX_VALUE;
 
-    const angle = vtkMath.radiansFromDegrees(model.activeCamera.getViewAngle());
-    const distance = radius / Math.sin(angle * 0.5);
-
-    // check view-up vector against view plane normal
-    const vup = model.activeCamera.getViewUp();
-    if (Math.abs(vtkMath.dot(vup, vn)) > 0.999) {
-      vtkWarningMacro('Resetting view-up since view plane normal is parallel');
-      model.activeCamera.setViewUp(-vup[2], vup[0], vup[1]);
+    for (let i = 0; i < 2; ++i) {
+      for (let j = 0; j < 2; ++j) {
+        for (let k = 0; k < 2; ++k) {
+          const nd = publicAPI.worldToNormalizedDisplay(
+            boundsToUse[i],
+            boundsToUse[2 + j],
+            boundsToUse[4 + k],
+            aspect
+          );
+          const dx = nd[0] * size[0];
+          const dy = nd[1] * size[1];
+          xmin = Math.min(dx, xmin);
+          xmax = Math.max(dx, xmax);
+          ymin = Math.min(dy, ymin);
+          ymax = Math.max(dy, ymax);
+        }
+      }
     }
 
-    // Set up camera position and focal point first (needed for view matrix)
-    model.activeCamera.setFocalPoint(center[0], center[1], center[2]);
-    model.activeCamera.setPosition(
-      center[0] + distance * vn[0],
-      center[1] + distance * vn[1],
-      center[2] + distance * vn[2]
+    // Project the focal point in screen space
+    const fp = model.activeCamera.getFocalPoint();
+    const fpNd = publicAPI.worldToNormalizedDisplay(
+      fp[0],
+      fp[1],
+      fp[2],
+      aspect
     );
+    const fpDisplayX = fpNd[0] * size[0];
+    const fpDisplayY = fpNd[1] * size[1];
 
-    // Calculate parallel scale accounting for viewport aspect ratio
-    // This mirrors C++ VTK behavior by transforming bounds to view space
-    // and computing the parallel scale from view space dimensions.
-    // This fixes the issue where narrow viewports crop significantly (issue #1285)
-    let parallelScale = radius;
-
-    // For parallel projection, compute parallel scale from view space bounds
-    if (model._renderWindow && model.activeCamera.getParallelProjection()) {
-      try {
-        // Get the view from render window to access viewport size
-        const views = model._renderWindow.getViews
-          ? model._renderWindow.getViews()
-          : [];
-        if (views.length > 0) {
-          const view = views[0];
-          const dims = view.getViewportSize
-            ? view.getViewportSize(publicAPI)
-            : null;
-          if (dims && dims[0] > 0 && dims[1] > 0) {
-            const aspect = dims[0] / dims[1];
-
-            // Get corner points of the bounds in world space
-            const visiblePoints = [];
-            vtkBoundingBox.getCorners(boundsToUse, visiblePoints);
-
-            // Transform bounds to view space using the view matrix
-            // The view matrix is now valid since we've set up the camera
-            const viewBounds = vtkBoundingBox.reset([]);
-            const viewMatrix = model.activeCamera.getViewMatrix();
-            const viewMatrixTransposed = new Float64Array(16);
-            mat4.copy(viewMatrixTransposed, viewMatrix);
-            mat4.transpose(viewMatrixTransposed, viewMatrixTransposed);
-
-            for (let i = 0; i < visiblePoints.length; ++i) {
-              const point = visiblePoints[i];
-              const viewPoint = new Float64Array(3);
-              vec3.transformMat4(viewPoint, point, viewMatrixTransposed);
-              vtkBoundingBox.addPoint(viewBounds, ...viewPoint);
-            }
-
-            // Get lengths in view space
-            const xLength = vtkBoundingBox.getLength(viewBounds, 0);
-            const yLength = vtkBoundingBox.getLength(viewBounds, 1);
-
-            // Apply offset ratio to add white space buffer
-            // offsetRatio is the fraction of space to use (default 0.9 = 90%, leaving 10% margin)
-            const marginMultiplier = 1.0 / offsetRatio;
-            const xLengthWithMargin = marginMultiplier * xLength;
-            const yLengthWithMargin = marginMultiplier * yLength;
-
-            // Use max of height and width/aspect to ensure everything fits
-            // This accounts for viewport aspect ratio to prevent cropping
-            // This mirrors C++ VTK behavior
-            parallelScale =
-              0.5 * Math.max(yLengthWithMargin, xLengthWithMargin / aspect);
-          }
-        }
-      } catch (e) {
-        // If we can't get aspect ratio, fall back to using radius
-        vtkDebugMacro(
-          'ResetCameraScreenSpace could not get aspect ratio, using radius for parallel scale'
-        );
-      }
-    }
+    // The focal point must be at the center of the box
+    const xCenterFocalPoint = Math.trunc(fpDisplayX);
+    const yCenterFocalPoint = Math.trunc(fpDisplayY);
+    const xCenterBox = Math.trunc((xmin + xmax) / 2);
+    const yCenterBox = Math.trunc((ymin + ymax) / 2);
 
-    publicAPI.resetCameraClippingRange(boundsToUse);
+    const xDiff = 2 * (xCenterFocalPoint - xCenterBox);
+    const yDiff = 2 * (yCenterFocalPoint - yCenterBox);
 
-    // setup parallel scale (computed from view space for parallel projection)
-    model.activeCamera.setParallelScale(parallelScale);
+    xmin += Math.min(xDiff, 0);
+    xmax += Math.max(xDiff, 0);
+    ymin += Math.min(yDiff, 0);
+    ymax += Math.max(yDiff, 0);
 
-    // update reasonable world to physical values
-    model.activeCamera.setPhysicalScale(radius);
-    model.activeCamera.setPhysicalTranslation(
-      -center[0],
-      -center[1],
-      -center[2]
-    );
+    // ZoomToBoxUsingViewAngle
+    const boxWidth = xmax - xmin;
+    const boxHeight = ymax - ymin;
+
+    if (boxWidth > 0 && boxHeight > 0) {
+      const zf1 = size[0] / boxWidth;
+      const zf2 = size[1] / boxHeight;
+      const zoomFactor = Math.min(zf1, zf2);
+      model.activeCamera.zoom(zoomFactor * effectiveOffsetRatio);
+    }
 
-    // Here to let parallel/distributed compositing intercept
-    // and do the right thing.
     publicAPI.invokeEvent(RESET_CAMERA_EVENT);
 
     return true;