cov-chain-of-view-spatial-reasoning

name	cov-chain-of-view-spatial-reasoning
title	CoV: Chain-of-View Prompting for Spatial Reasoning
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2601.05172
keywords	["Vision-Language Models","Spatial Reasoning","3D Understanding","Test-Time Scaling"]
description	Enable vision-language models to perform embodied question answering in 3D environments through active camera exploration. CoV uses training-free test-time reasoning to iteratively select relevant viewpoints and adjust camera angles until sufficient context is gathered, achieving 11-13% accuracy improvements across spatial reasoning benchmarks.

When to Use This Skill

• Embodied question answering in 3D environments (OpenEQA, ScanQA)
• Spatial reasoning tasks requiring multi-view understanding
• Scenarios with pre-rendered or real-world multi-view scenes
• Applications where model retraining is expensive or infeasible
• Tasks benefiting from test-time scaling and iterative refinement

When NOT to Use This Skill

• Single-view-only applications (camera exploration adds overhead)
• Real-time systems requiring immediate response (iterative reasoning is inherently slower)
• 2D image understanding without 3D structure
• Applications with latency constraints prohibiting multiple inference passes

Problem Summary

Vision-language models excel at understanding single images or text, but struggle with embodied question answering in 3D environments. The core constraint: models are limited to finite input views, preventing them from exploring the scene to gather spatially distributed information. Traditional approaches either use fixed viewpoint sets or require expensive retraining to adapt viewing strategies. This creates a fundamental capability gap for spatial reasoning tasks requiring dynamic perspective selection.

Solution: Training-Free Chain-of-View Framework

Use test-time prompting to enable iterative camera control and view selection without model modification or retraining.

class ChainOfViewReasoner:
    def __init__(self, vlm_model, scene_3d):
        self.vlm = vlm_model
        self.scene = scene_3d
        self.selected_views = []
        self.camera_pose = None

    def run_chain_of_view(self, question, max_iterations=5):
        """Iteratively select views and adjust camera until question answered"""

        # Stage 1: Coarse-grained view selection
        anchor_views = self.select_anchor_views(question, num_anchors=4)
        self.selected_views.extend(anchor_views)

        
         iteration  (max_iterations):
            
            visual_context = .render_selected_views(.selected_views)

            
            reasoning = .vlm.generate(
                visual_context, question,
                prompt_template=
            )

            
            action = .parse_camera_action(reasoning)

            
             action != :
                .apply_camera_action(action)
                new_view = .render_current_view()
                .selected_views.append(new_view)

            
             .should_terminate(reasoning):
                

        
        final_answer = .vlm.generate(
            visual_context=visual_context,
            question=question,
            prompt_template=
        )

         final_answer

     ():
        
        
        keywords = extract_keywords(question)

        
        view_scores = []
         view  .scene.all_views:
            relevance_score = compute_visual_relevance(view, keywords)
            view_scores.append((view, relevance_score))

        
        anchor_views = select_diverse_top_k(view_scores, k=num_anchors)
         anchor_views

     ():
        
        translation_map = {
            : [, , -],
            : [, , ],
            : [-, , ],
            : [, , ],
            : [, , ],
            : [, -, ]
        }

        rotation_map = {
            : (, , ),
            : (, , ),
            : (, , )
        }

         action  translation_map:
            translation = translation_map[action]
            .camera_pose = .camera_pose @ se3_translate(translation)
         action  rotation_map:
            rotation = rotation_map[action]
            .camera_pose = .camera_pose @ se3_rotate(rotation)