齐次坐标与无穷远点的技术疑问：优化应用中的困惑

Hey there! I totally get where you're coming from—homogeneous coordinates and infinite points feel like abstract textbook concepts until you try to wrap them into a practical problem like optimization. Let's break this down step by step, starting with the core of infinite points and then tying it to your optimization use case.

First, Let's Recap the Essence of Infinite Points #

In projective geometry, infinite points exist to resolve the "parallel lines never meet" problem from Euclidean geometry. In homogeneous coordinates:

• For 2D space, an infinite point is represented as [x, y, 0]^T—the 0 in the last component signals that this point lies infinitely far along the direction defined by (x, y).
• For 3D space, it's [x, y, z, 0]^T, pointing along the 3D direction vector (x, y, z).

Crucially, these coordinates are scale-invariant: k*[x, y, 0]^T represents the same infinite point as [x, y, 0]^T (where k ≠ 0). This is a key property that often trips people up when moving to optimization.

Why Infinite Points Matter for Optimization #

You mentioned using homogeneous coordinates for translation matrices (a staple of affine transformations), but infinite points shine in projective optimization problems—think camera calibration, SLAM, or 3D reconstruction. Here's why:

• When a real-world point is extremely far from the camera (e.g., distant landmarks, stars), its projection onto the image plane is almost unaffected by the camera's translation. Only rotation changes where it appears.
• Modeling such points as infinite points lets you simplify your optimization problem: you can drop translation-related variables for those points, reducing computational load and improving stability.

Addressing Common "Fundamental" Confusions #

Since you hit a snag when thinking about the essence of infinite points, here are solutions to the most frequent pain points:

1. How to Handle Scale Invariance in Optimization? #

The scale ambiguity of homogeneous infinite points can break optimization solvers (they'll waste iterations scaling the coordinate vector). Fix this by adding a normalization constraint:

• For 2D infinite points, normalize the first two components so x² + y² = 1.
• For 3D, normalize x² + y² + z² = 1.
  This locks the coordinate to a unit sphere, eliminating the scale degree of freedom.

2. How to Build a Loss Function for Infinite Points? #

Unlike finite points, infinite points don't have a Euclidean position to compare against. Instead, you optimize based on direction consistency:

• For example, in SLAM, if you observe a distant landmark across multiple frames, the direction from the camera to the landmark (encoded in the infinite point's homogeneous coordinates) should match the direction derived from each frame's image observations.
• The loss function would measure the angular difference between the predicted direction and the observed direction from the image.

3. When Should I Use Infinite Points vs. Finite Points? #

Use infinite points when:

• The target's distance is at least 10x the camera's field of view diameter (so translation has negligible impact on projection).
• You want to reduce optimization variables to speed up convergence or avoid overfitting.
• You're dealing with pure rotation estimation (e.g., camera orientation tracking without translation).

Example: Optimization in Visual Odometry #

Suppose you're tracking a distant mountain range in a drone's camera feed. Instead of modeling each mountain peak as a 3D point (which would require estimating X/Y/Z), you model them as 3D infinite points [x, y, z, 0]^T. Your optimization problem then only needs to estimate the drone's rotation between frames, since translation won't change where the peaks appear in the image. This makes the solver faster and more robust to noise.

If your specific "fundamental problem" is more niche (like numerical stability issues or constraint formulation), feel free to share more details—I'd be happy to dive deeper!

内容的提问来源于stack exchange，提问作者user510