A 360° panorama is usually stored as an equirectangular image, a flat latitude–longitude grid in which the top and bottom rows each stand for a single point (a pole) and the middle row stands for the entire equator. Networks trained on this grid count every pixel equally, so the stretched ceiling and floor regions dominate both training and errors. Separately, language and multimodal models that "revise their own output" often make things worse: they break answers that were already right. This note argues that these two problems meet in panoramic refinement. When a model refines its own panoramic prediction, we expect it to fail in a pattern organized by latitude. It will rewrite correct content where pixels are dense in information, and it will spend its effort on oversampled polar regions that matter little on the actual sphere. Refining the whole image every round also multiplies inference time.
The proposal is to measure self-correction failure separately for each latitude band, using solid angle (true area on the sphere) rather than pixel counts. We then fix it with a refiner that only edits small equal-area patches on the sphere that a learned gate flags as worth editing, and copies everything else through unchanged. Because the gate leaves unflagged regions untouched, those regions cannot be corrupted. Compute scales with the flagged area instead of with the number of iterations times the full image. Panoramic depth estimation is the testbed because it has per-pixel ground truth. That lets us say objectively whether each region went from right to wrong or from wrong to right, which is the central difficulty that verifier-free self-correction cannot otherwise resolve.
Core Claim
Self-correction on spherical data has a geometric structure that existing analyses miss. Confidence v.s. Critique splits self-correction into two quantities. Confidence Level (CL) is the chance that a correct output stays correct after revision. Critique Score (CS) is the chance that a wrong output becomes correct. The paper shows the two trade off against each other under prompting, so a more aggressive critic corrupts more correct outputs. Work on spherical losses finds that uniform pixel weighting makes models overfit stretched polar regions and under-serve the equator (Yan et al., Li et al.). It also finds that polar areas dominate the output's dynamic range, the "polar dominance effect" (Cao et al., PanDA).
We claim three things. First, a naively trained refiner working on the equirectangular image shows CL and CS that vary systematically with latitude. Second, reweighting the loss by latitude moves the CS/CL trade-off around but does not remove it. Third, an equal-area, gated patch refiner can raise CS without lowering CL in any band, at a latency close to a single pass.
To make this measurable, tile the sphere into equal-area patches $p$ and call a patch correct if its absolute relative depth error is below a threshold $\tau$. Write $c_0(p)$ and $c_1(p)$ for "patch $p$ is correct" before and after refinement, and restrict both quantities to a latitude band $B$. Then
$$\mathrm{CL}_B = \Pr\big[c_1(p) \mid c_0(p),\ p \in B\big], \qquad \mathrm{CS}_B = \Pr\big[c_1(p) \mid \neg c_0(p),\ p \in B\big].$$
Because the patches have equal area, these probabilities are weighted by solid angle automatically. No cosine correction is needed.
Research Program
The work has three parts.
Diagnostic study. We start from a strong single-pass panoramic depth model in the style of PanDA and train a conventional refiner. This refiner takes the panorama and the current depth map in equirectangular form, outputs a revised depth map, uses a uniform per-pixel loss, and runs for a fixed number of rounds. We measure $\mathrm{CL}_B$ and $\mathrm{CS}_B$ over latitude bands on Matterport3D and Stanford2D3D, along with which bands receive most of the edit magnitude. The hypothesis has a direction and could be wrong. We expect CL to be lowest in the equatorial bands, where detail is concentrated, and edit mass to concentrate near the poles. If CL and CS turn out flat across latitude, the geometric part of the claim fails and the work reduces to generic gated refinement. We would report that as the finding.
The method. The method borrows pieces from three sources. Patch centers come from an equal-area tiling in the spirit of the HEALPix grid used by Linander et al.. We use that grid only to place patches, not as a new backbone, so ordinary planar networks still work. Each patch is resampled onto a tangent plane by gnomonic projection, the same local undistorted view used by the deformable convolutions in SpND. A small gate network reads each patch's image, current depth, and features from the base model, and predicts whether refining that patch will reduce its error. This gate is a learned verifier. We build one because Scaling Test-Time Compute Without Verification or RL is Suboptimal argues that refinement without any verification signal hits a performance ceiling. Its supervision is cheap here, since the true benefit of refinement is computable on labeled training panoramas. Flagged patches pass through a planar refiner and are blended back into the equirectangular map with feathered weights. Unflagged patches are copied unchanged.
Training follows the main finding of Confidence v.s. Critique: mix "keep" examples, where the target equals the input, with "fix" examples. We sweep the mixing ratio around their reported best of roughly 40/60, and we tune it separately per latitude band. Refinement stops when the gate flags no patches or when a budget runs out. This is a spatial counterpart to the in-process refinement of PASR. PASR showed on text that fixing errors as they arise beats regenerating from scratch, cutting tokens by 41.6% while improving accuracy. Our version replaces "which reasoning step to revise" with "which piece of the sphere to revise."
A transfer check on generation. We run a narrower test on panoramic outpainting. The question is whether the iterative "Repaint" denoising in SpND shows the same latitude-structured corruption across its iterations. We measure pole-region quality by projecting the panorama onto a cube map, following SMGD, and ask whether gating the resampled region by patch improves pole-region FID at matched time.
Baselines
Do nothing. The naive reference point is the single-pass base model with no refinement. The strongest existing instance is PanDA-Large, which PanDA reports at RMSE 0.3305 on Matterport3D, against 0.4052 for S2Net and 0.4941 for UniFuse. We will reproduce it, or the closest available equivalent, and report both its conventional RMSE and our area-weighted RMSE, because the published number counts pixels rather than solid angle. On Stanford2D3D the file gives only a 15–30% zero-shot reduction with no per-dataset value, so no reported per-dataset result was found on Lacuna for Stanford2D3D, and we will use our reproduction. All refiners start from the same base predictions. To beat this baseline, the method must lower area-weighted RMSE and also keep CL at or above 0.95 in every latitude band, while costing at most about 1.5 times the single-pass wall-clock time.
Full-image refinement. This is the strongest competitor for the refinement question itself. It is a refiner on the full equirectangular image with a fixed number of rounds, trained with the same backbone size, data (Structured3D, Deep360, and the Matterport3D training split), and tuning budget as ours. We run it twice: once with a uniform loss, and once with the cosine-latitude loss weighting of Mou et al. and Huo et al.. The weighted version is the obvious fix for the geometry and the main threat to our claim. Beating it means higher $\mathrm{CS}_B$ at equal or higher $\mathrm{CL}_B$ in equatorial bands, at lower latency.
Cube-map refinement. This is a perspective baseline that refines the six cube faces with a planar network, so each face sees almost no distortion.
Ablations. Three ablations isolate the key ingredients. The first refines every patch with no gate, which isolates the gate's effect on corruption. The second flags random patches at the same flagged area, which isolates whether the gate's choices matter. The third uses patches on a uniform equirectangular grid instead of an equal-area tiling, which isolates the spherical geometry.
Why not just…?
Why not just weight the refiner's loss by cosine of latitude? This is the most serious alternative. It may fix where the refiner spends its effort. But weighting changes which errors the refiner cares about, not whether it rewrites content that is already correct. A full-image refiner still repaints every pixel every round, so it can still corrupt correct regions and still pays full-image cost per iteration. The weighted full-image baseline settles this directly. If it matches our method on both $\mathrm{CL}_B$ and $\mathrm{CS}_B$, then the gate adds only speed, and we would present the work as a latency result, not a self-correction result.
Why not refine cube faces or switch the backbone to an equal-area mesh? Cube faces remove distortion but introduce seams. PanDA found that the equirectangular format beat cube maps for depth because it keeps global structure intact. Equal-area meshes such as HEALPix (Linander et al.) require custom backbones. Our design keeps a pretrained equirectangular base model and uses equal-area tiling only for local edits. The cube-map baseline tests whether seams actually cost accuracy in a refinement setting.
Why not use a multimodal LLM critic, as in Volcano or Idea2Img? Critique-and-revise loops of this kind add 2–3 times the latency (Volcano, Idea2Img). They also show confirmation bias toward their own outputs (AlphaGRPO) and reason in planar layouts. More basically, they cannot judge metric depth. For the generation check we will log how often such a critic flags regions near the poles, but it is not a viable depth baseline.
Why not just add more refinement rounds or take a better single-pass model? Repeated rounds run strictly in sequence (Padmakumar et al.), and under the trade-off from Confidence v.s. Critique they can compound corruption. We will plot $\mathrm{CL}_B$ against the number of rounds to show this. A stronger single-pass model is the do-nothing baseline above. If it already leaves few errors to fix, the gate should flag little and cost little, which is the intended behavior.
Proposed Experiments
Diagnostic. The first decisive test is the latitude-resolved CL/CS curve for the uniform full-image refiner on Matterport3D and Stanford2D3D. The theory makes a directional prediction, and a flat curve would retire the geometric half of the claim. No reported result was found on Lacuna for latitude-resolved self-correction metrics on any panoramic task, so this measurement is new in its own right.
Main comparison. We plot accuracy against latency, meaning area-weighted RMSE and RMSE versus wall-clock time on one GPU, for all baselines and ablations. Alongside it we report per-band CL and CS and the fraction of the sphere's area that gets refined. A positive result means three things hold together. The gated method beats PanDA-Large's 0.3305 RMSE as reproduced. It sits on or beyond the accuracy–latency frontier set by the cosine-weighted full-image refiner. And it lowers CL in no band.
Robustness. We train on synthetic data and test on real panoramas, and we evaluate on rotated, tilted panoramas using the Möbius rotation augmentation from PanDA. This checks whether the gate's choices follow scene content rather than fixed latitude positions.
Generation transfer. We gate the resampled region in SpND's iterative outpainting and compare pole-region FID and generation time against ungated Repaint. SMGD's reported 21.05 pole-region FID at 2.69 seconds serves as an external reference point for open-loop generation.
References
- Confidence v.s. Critique: A Decomposition of Self-Correction Capability for LLMs
- Distortion and Uncertainty Aware Loss for Panoramic Depth Completion
- SGAT4PASS: Spherical Geometry-Aware Transformer for PAnoramic Semantic Segmentation
- PanDA: Towards Panoramic Depth Anything with Unlabeled Panoramas and Mobius Spatial Augmentation
- PEAR: Equal Area Weather Forecasting on the Sphere
- Spherical-Nested Diffusion Model for Panoramic Image Outpainting
- Scaling Test-Time Compute Without Verification or RL is Suboptimal
- A Stitch in Time Saves Nine: Proactive Self-Refinement for Language Models
- Spherical Manifold Guided Diffusion Model for Panoramic Image Generation
- 360DVD: Controllable Panorama Video Generation with 360-Degree Video Diffusion Model
- Unequal Error Protection Aided Region of Interest Aware Wireless Panoramic Video
- Volcano: Mitigating Multimodal Hallucination through Self-Feedback Guided Revision
- Idea2Img: Iterative Self-refinement with GPT-4V for Automatic Image Design and Generation
- AlphaGRPO: Unlocking Self-Reflective Multimodal Generation in Unified Multimodal Models via Decompositional Verifiable Reward
- Extrapolative Controlled Sequence Generation via Iterative Refinement