🤖 AI

ParaScale: Scale-Calibrated Camera-Motion Transfer via a Gauge-Invariant Parallax Number

ParaScale is a plug-and-play module that enables scale-calibrated camera-motion transfer between videos of incompatible scales by preserving a gauge-invariant Parallax Number, thereby eliminating motion exaggeration or suppression without requiring retraining.

Original authors: Zijie Meng

Published 2026-06-19

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Zijie Meng

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

Imagine you are a film director. You have a reference video of a camera sweeping majestically across a galaxy. You want to copy that exact camera movement for a new video you are making, but this time, the scene is just a coffee cup sitting on a desk.

If you try to copy the galaxy movement directly onto the coffee cup, two things go wrong:

The Galaxy Move on the Desk: The camera moves so slowly across the tiny desk that you can't even see it happening. It looks like the camera is frozen.
The Desk Move on the Galaxy: Conversely, if you try to copy a tiny nudge from a desk scene onto a galaxy, the camera would shoot out of the frame at lightning speed, making the video look chaotic and broken.

The paper ParaScale solves this problem. Here is how it works, using simple analogies.

The Problem: The "Scale" Mismatch

The authors explain that when a camera moves, what you actually see on the screen depends on two things:

How far the camera physically moves.
How far away the objects are.

Think of it like walking past a tree. If you walk 1 meter past a tree that is 10 meters away, the tree seems to shift a little bit. But if you walk that same 1 meter past a tree that is only 1 meter away, the tree seems to zoom past you wildly.

In computer vision, we can often guess how the camera moved and how far objects are, but we can't know the absolute size. We don't know if the "1 meter" we calculated is actually 1 meter, or 1 kilometer, or 1 millimeter. We only know the ratio between the movement and the distance.

The Solution: The "Parallax Number"

The authors discovered a special number they call the Parallax Number (Π).

Think of this number as the "Intensity of the Feeling."

It doesn't care if you are filming a galaxy or a coffee cup.
It only cares: How much does the background seem to shift relative to how far the camera moved?

If you want to transfer a camera move from a galaxy video to a coffee cup video, you shouldn't copy the raw distance the camera moved. Instead, you should copy the Parallax Number. This ensures that the feeling of the movement feels the same to the viewer, regardless of the size of the scene.

How ParaScale Works (The "Plug-and-Play" Module)

The paper introduces a tool called ParaScale. You can think of it as a universal translator for camera movements.

Read the Feeling: It looks at the reference video (the galaxy) and calculates the "Parallax Number" for every single frame. It ignores the actual size and focuses on the feeling of the motion.
Measure the Target: It looks at the new video (the coffee cup) and measures how deep the scene is.
Adjust the Gear: It automatically adjusts the camera movement speed for the coffee cup video.
- If the coffee cup scene is "small," it speeds up the camera movement so the background shifts just as much as it did in the galaxy video.
- If the scene is "huge," it slows the camera down.
Leave Rotation Alone: It only changes the forward/backward/sideways movement. It leaves the spinning (rotation) exactly as it was, because spinning looks the same whether you are near or far.

Why This is a Big Deal

The authors tested this on scenes ranging from tiny tabletop objects to massive cosmic landscapes (a difference of 10,000 times in size).

Without ParaScale: The camera moves either too slow to see or too fast to watch. The "feeling" is completely wrong.
With ParaScale: The camera movement feels perfectly natural in both the tiny and huge scenes. The "feeling" is preserved.

They also created a new way to measure success called PCE (Parallax Consistency Error). Unlike old methods that might trick you into thinking a move is good just because it looks similar, PCE checks if the intensity of the movement is actually correct. ParaScale reduced this error by more than 3 times compared to previous methods.

The Bottom Line

ParaScale is a smart, automatic tool that lets you copy camera moves from any video to any other video, no matter how different their sizes are. It does this by focusing on the feeling of the motion rather than the raw numbers, ensuring that a move that feels "epic" in a space movie feels "epic" (not tiny) when applied to a video of a coffee cup, and vice versa. It requires no retraining and works with existing video generators.

Technical Summary: ParaScale

Problem Statement

Reference-driven camera control in generative video aims to transfer the cinematic motion of a reference clip to a newly generated target scene. However, a fundamental geometric incompatibility exists between arbitrary reference and target scenes: they often operate at vastly different physical scales (e.g., a camera sweeping across a galaxy versus nudging across a desk).

Current methods typically extract a camera trajectory (translation $T$ and rotation $\omega$ ) from a reference and inject it directly into a target generator. This "naive" transfer fails because monocular reconstruction recovers translation and depth only up to an unknown global scale factor (a similarity transformation). Consequently, the absolute translation magnitude $\|T\|$ is meaningless without a corresponding depth scale $Z$ . When a reference trajectory is applied to a target with a different scene scale, the resulting motion is either imperceptible (if the target is "larger" than the reference) or violently exaggerated (if the target is "smaller"), breaking the visual fidelity of the generation.

Methodology: The Parallax Number and ParaScale

Theoretical Foundation

The paper establishes that the perceived strength of translational motion is governed not by the raw translation vector, but by the ratio of translation to depth. Based on the projection equation for a point at depth $Z$ , the image motion induced by translation scales as $\|T\|/Z$ .

The authors define the Parallax Number ( $\Pi$ ) as a dimensionless, gauge-invariant descriptor:
$\Pi_t = \frac{\|\Delta T_t\|}{\bar{Z}_t}$
Where:

$\|\Delta T_t\|$ is the inter-frame camera baseline (translation magnitude).
$\bar{Z}_t$ is the robust median scene depth for that frame.

The paper proves that $\Pi$ is invariant under the depth-scale gauge (scaling both $T$ and $Z$ by a factor $s$ leaves $\Pi$ unchanged). Therefore, $\Pi$ , rather than the raw trajectory $T$ , is the unique quantity that must be preserved to achieve scale-faithful motion transfer.

The ParaScale Module

ParaScale is a plug-and-play, training-free module inserted between pose extraction and pose injection in a generative pipeline. It operates as follows:

Extraction: From the reference video, it estimates the camera trajectory and a robust median depth $\bar{Z}^{ref}_t$ using monocular Structure-from-Motion (SfM) and a depth estimator. It computes the gauge-invariant Parallax Number $\Pi^{ref}_t$ .
Target Estimation: For the target scene, it estimates the median depth $\bar{Z}^{tgt}_t$ from the conditioning image or first latent.
Re-realization: It calculates a per-frame translational gain $\alpha_t$ to match the reference Parallax Number to the target's depth:
$\alpha_t = \frac{\bar{Z}^{tgt}_t}{\bar{Z}^{ref}_t}$
The calibrated translation is $T^{cal}_t = \alpha_t T^{ref}_t$ , while the rotation $R^{cal}_t$ is passed through unchanged ( $R^{ref}_t$ ).
Injection: The calibrated extrinsics are converted to the format required by the generator (e.g., Plücker maps or raw $RT$ matrices) and fed into a frozen, pose-conditioned diffusion model.

Theoretical proofs in the paper demonstrate that this per-frame adaptation is necessary and sufficient to preserve the temporal parallax profile, whereas global scaling or no scaling fails when scene depth varies over time or differs significantly between scenes.

Evaluation Metric: PCE

To quantify scale fidelity, the authors introduce the Parallax Consistency Error (PCE):
$\text{PCE} = \frac{1}{N} \sum_{t=1}^{N} \left| \log \frac{\Pi^{out}_t}{\Pi^{ref}_t} \right|$
Unlike standard metrics like TransErr (which rely on similarity alignment and can hide global scale mismatches), PCE is scale-symmetric and gauge-invariant. It directly exposes discrepancies in the perceived motion strength.

Key Contributions

Gauge-Invariant Principle: The identification of the Parallax Number ( $\Pi$ ) as the correct invariant for motion transfer, proving that preserving raw trajectories is geometrically flawed.
ParaScale: A training-free, generator-agnostic inference-time module that re-realizes $\Pi$ per frame against the target scene's depth, requiring no retraining of the generative backbone.
PCE Metric: A new evaluation metric that specifically measures scale-faithfulness and exposes scene-scale mismatches that traditional metrics miss.
Empirical Validation: Demonstration across four orders of magnitude in scene scale (tabletop, human/room, architectural, and cosmic) and multiple backbone architectures.

Results

Experiments were conducted using a Wan2.1 diffusion transformer backbone with Plücker conditioning, comparing ParaScale against Raw transfer, Global-norm scaling, MotionMaster, and CameraCtrl II's training-time scale calibration.

Scale Fidelity: ParaScale is the only method that keeps the realized Parallax Number on the identity line across all scale regimes. Raw transfer significantly under-drives cosmic scenes and over-drives tabletop scenes.
Error Reduction: ParaScale reduces the Parallax Consistency Error (PCE) by more than 3 $\times$ compared to uncalibrated Raw transfer and outperforms Global-norm and training-time calibration methods.
Visual Fidelity: The method achieves these gains without loss of visual quality; FVD (Fréchet Video Distance) and CLIP-SIM scores are preserved or improved compared to baselines.
Generality: The module works effectively across different generator types (Plücker-conditioned and Matrix-conditioned) without retraining.

Significance and Claims

The paper claims that ParaScale addresses a "silent assumption" in reference-driven controllers: that trajectory numbers are directly reusable. By formalizing the geometric fact that translation-induced motion is depth-dependent, the authors provide a rigorous solution to the scale mismatch problem.

The significance lies in enabling creators to reuse cinematic camera moves across vastly different contexts (from macro to cosmic scales) without manual intervention or retraining. The paper asserts that ParaScale is the first method to expose and re-realize the gauge-invariant Parallax Number at inference time between arbitrary references and targets.

Limitations: The authors note that the method relies on monocular depth estimates (where errors propagate linearly into the gain $\alpha_t$ ) and assumes a rigid scene geometry as per the underlying projection model. Extending the approach to dynamic scenes and anisotropic scale fields is identified as future work.