💻 computer science

PoseGravity: Pose Estimation from Points and Lines with Axis Prior

This paper introduces PoseGravity, an efficient algorithm that estimates absolute camera pose from point and line features by leveraging an axis prior to solve the problem as the intersection of a hyperbola and a unit circle, while also providing simplified closed-form solutions for planar and minimal configurations.

Original authors: Akshay Chandrasekhar

Published 2026-07-01

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Akshay Chandrasekhar

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Idea: Finding Your Way with a "Gravity Compass"

Imagine you are holding a smartphone in a dark room. You take a picture of a basketball court, but you don't know exactly where you are standing or which way you are facing. Usually, a computer needs to look at many different things in the picture (like the hoop, the lines, the corners) to figure out its position. This is like trying to solve a puzzle with a million pieces; it's hard and slow.

However, your phone has a secret weapon: an IMU (Inertial Measurement Unit). This is a tiny sensor that knows which way is "down" because of gravity.

PoseGravity is a new math trick that says: "If we already know which way is down (the gravity vector), we don't need to guess the whole puzzle. We just need to figure out how much we are spinning around that 'down' axis."

This changes the problem from a complex 6-dimensional maze into a much simpler 4-dimensional one. It's like knowing you are standing on a specific floor of a building; you only need to figure out which room you are in, not which floor you are on.

The Ingredients: Points and Lines

In computer vision, we usually look for two types of clues in an image:

Points: Like the center of a basketball hoop or a specific corner of a building.
Lines: Like the painted lines on the court or the edge of a wall.

Most previous methods were picky eaters. Some could only handle points, some only lines, and some could only handle very specific, small numbers of them. If you gave them a mix of points and lines, or too many, they often got stuck or gave up.

PoseGravity is like a chef who can cook anything. It can take any combination of points and lines (whether you have 2 or 200) and find the perfect answer every time.

How It Works: The "Spinning Top" Analogy

Think of the camera as a spinning top.

Without the gravity clue: The top could be tilted in any direction, spinning at any speed, and floating anywhere in the room. There are too many possibilities.
With the gravity clue: We know the top is standing upright on its point (the gravity axis). It can only spin left or right around that vertical stick.

The paper's algorithm treats this spinning motion like a simple circle. It sets up a mathematical equation that looks for the "lowest point" in a valley (the best solution). Because the problem is so simplified, the algorithm can find the absolute bottom of that valley instantly, without needing to guess and check (which is what slower methods do).

Special Shortcuts: The "Minimal" and "Flat" Cases

The authors found two special scenarios where the math becomes even faster, like taking a shortcut through a park instead of walking around the block:

The Minimal Case (The "Two Clue" Trick): Sometimes you only have two clues (like two eyes on a face, or two baskets on a court). The paper shows that with the gravity help, you can solve the puzzle instantly with a simple quadratic equation (a basic math formula you might remember from high school).
The Planar Case (The "Flat Floor" Trick): If all the objects you are looking at are on a flat floor (like a soccer field), the math simplifies again. The algorithm has a special "closed-form" solution for this, meaning it calculates the answer directly without any loops or guessing.

Why It's Better: Speed and Accuracy

The paper tested this method against other existing solutions using millions of fake scenarios (synthetic experiments) and real photos of buildings.

Speed: It is significantly faster. While other methods might take time to process a large number of lines, this method stays fast because it solves for rotation and position at the same time in a single pass.
Accuracy: It is more accurate, especially when the data is noisy (blurry or imperfect). Because it uses the gravity clue, it doesn't get confused as easily.
Reliability: It guarantees finding the best possible answer (the global optimum), whereas other methods might get stuck in a "local minimum" (a small dip in the valley that looks like the bottom but isn't).

Summary

PoseGravity is a new, super-fast, and super-accurate way to tell a camera where it is. By using the simple fact that "down is down" (gravity), it turns a difficult 3D puzzle into an easy 2D spin. It works with any mix of dots and lines, handles messy data better than before, and is the first method to solve this specific type of problem for any combination of features.

Technical Summary: PoseGravity

Problem Definition

The paper addresses the problem of estimating absolute camera pose (rotation $R$ and translation $T$ ) from 2D-3D feature correspondences, specifically when a prior on the camera's rotation axis is available. This prior, often derived from IMU gravity measurements, vanishing points, or domain assumptions, reduces the problem's degrees of freedom from six to four. While the rotation matrix $R$ typically has three degrees of freedom, the axis prior constrains it to a single degree of freedom (rotation about the known axis).

The core challenge addressed is solving this constrained pose problem for arbitrary combinations of point and line correspondences in both minimal (under-constrained) and over-constrained scenarios. Existing methods are often limited to specific feature types (e.g., lines only or points only), specific configurations (e.g., minimal P2P), or rely on local optimization routines that require good initializations and may not guarantee global optimality.

Methodology

1. Problem Formulation

The authors formulate the pose estimation problem using linear projective constraints for $n$ point correspondences and $m$ line correspondences.

Axis Prior: Without loss of generality, the known axis is aligned with the world $y$ -axis ( $g = [0, 1, 0]^T$ ). This constrains the rotation matrix $R$ to a specific form dependent on a single angle $\theta$ , where $x = \cos(\theta)$ and $y = \sin(\theta)$ satisfy $x^2 + y^2 = 1$ .
Least Squares Objective: For over-constrained cases ( $>2$ correspondences), the problem is cast as a constrained least squares minimization. The translation $T$ is analytically eliminated as a function of the rotation parameters $r = [x, y, 1]^T$ , reducing the problem to minimizing a quadratic objective function $\Omega$ subject to the unit-norm constraint $x^2 + y^2 = 1$ .

2. Global Optimization Strategy

The reduced problem is a constrained quadratic minimization:
$\min_{r} r^T \Omega r \quad \text{s.t.} \quad x^2 + y^2 = 1$
The authors solve this globally using the method of Lagrange multipliers. The problem is transformed into a simplified space via orthogonal diagonalization of the leading $2 \times 2$ submatrix $A$ of $\Omega$ . The solution involves finding the roots of a secular equation.

Case Analysis: The solution space is exhaustively analyzed based on the eigenvalues of $A$ $A$ and the vector $c$ $c$ (derived from $\Omega$ $Ω$ ).
- Case 1 ( $\lambda \notin \text{spec}(A)$ ): The optimal solution is found by solving a quartic secular equation. The authors prove that a unique global minimizer exists in the domain $\lambda < \lambda_1$ (the smallest eigenvalue), which can be efficiently found via iterative methods like Newton's or Halley's method.
- Case 2 ( $\lambda \in \text{spec}(A)$ ): Specific sub-cases are handled where the vector $c$ has zero components, leading to closed-form solutions involving projections onto the feasible set.
Global Optimality: The paper proves that the derived solution corresponds to the global minimum of the objective function, recovering all finite global solutions.

3. Special Configurations

The method provides streamlined closed-form solutions for specific physically meaningful cases:

Minimal Configurations: For exactly two points or one point and one line, the rank of the objective matrix $\Omega$ is at most 1. This reduces the problem to finding the intersection of a projective line with the unit circle, solvable via a simple quadratic equation.
Planar Configurations: When all 3D features lie on a plane orthogonal to the world $y$ -axis (e.g., ground plane features), the problem simplifies further. The solution becomes the eigenvector of $A$ corresponding to its smallest eigenvalue, expressible in a simple closed form.

Key Contributions

Generalized Solution: The first algorithm to provide a complete, globally optimal solution for the axis-constrained pose problem (PoseGravity) using arbitrary combinations of points and lines.
Global Optimality: Unlike previous approaches that rely on local optimization or iterative refinement from initial guesses, this method guarantees the globally optimal solution in all cases.
Efficiency: The algorithm operates in $O(n)$ time. It avoids expensive operations like large matrix nullspaces or high-degree polynomial root finding (beyond the necessary quartic/secular equation) by leveraging the reduced dimensionality of the problem.
Closed-Form Special Cases: The derivation of efficient closed-form solutions for minimal and planar configurations, which are common in real-world applications (e.g., RANSAC iterations, ground-plane detection).
Theoretical Insight: The work characterizes the general PnPnL problem as a function of only two variables (the axis prior), allowing for the visualization of the loss landscape and offering new perspectives on problem structure.

Experimental Results

Extensive synthetic and real-world experiments validate the approach:

Accuracy: In synthetic tests with varying noise levels and feature counts, the proposed method achieves competitive or superior accuracy compared to state-of-the-art axis-prior solvers (VPnL, gPnLup, Sweeney). It particularly excels in planar configurations where other methods often struggle.
Robustness: The method demonstrates improved accuracy as the number of features and noise levels increase, effectively exploiting geometric information.
Speed: The algorithm significantly outperforms general-purpose solvers (like SQPnP) and other axis-prior methods in runtime. It scales efficiently with the number of inputs, largely due to the single-pass estimation of rotation and translation.
Real-World Validation: Tested on the VGG multi-view dataset, the solver achieved the best translation accuracy and lowest projective loss in most scenes. When used as an initializer for Newton's method in general PnP, it converged to the same minimum as SQPnP but with substantially faster execution times.

Significance and Claims

The paper claims that PoseGravity offers a significant advancement in pose estimation by leveraging axis priors to reduce problem dimensionality while maintaining global optimality.

Versatility: It unifies the treatment of points and lines, a capability the authors note is a "first-of-its-kind" for axis-constrained estimation.
Practical Utility: The ability to handle minimal cases and planar configurations with closed-form solutions makes the method highly suitable for real-time applications, RANSAC loops, and scenarios with limited feature availability.
Efficiency: The $O(n)$ complexity and avoidance of external libraries make it computationally efficient, outperforming general-purpose solvers even when those solvers are optimized.

The authors conclude that this approach provides a robust, fast, and accurate foundation for applications such as augmented reality, visual odometry, and structure from motion, particularly in environments where gravity or heading information is available.