Cavia: Camera-controllable Multi-view Video Diffusion with View-Integrated Attention

## Abstract

Abstract In recent years there have been remarkable breakthroughs in image-to-video generation.
However, the 3D consistency and camera controllability of generated frames have remained unsolved. Recent studies have attempted to incorporate camera control into the generation process, but their results are often limited to simple trajectories or lack the ability to generate consistent videos from multiple distinct camera paths for the same scene. To address these limitations, we introduce Cavia , a novel framework for camera-controllable, multi-view video generation, capable of converting an input image into multiple spatiotemporally consistent videos. Our framework extends the spatial and temporal attention modules into view-integrated attention modules, improving both viewpoint and temporal consistency. This flexible design allows for joint training with diverse curated data sources, including scene-level static videos, object-level synthetic multi-view dynamic videos, and real-world monocular dynamic videos. To our best knowledge, Cavia is the first of its kind that allows the user to precisely specify camera motion while obtaining object motion.
Extensive experiments demonstrate that Cavia surpasses state-of-the-art methods in terms of geometric consistency and perceptual quality. Project Page: https://ir1d.github.io/Cavia/

## 1 Introduction

The rapid development of diffusion models has enabled significant advancements in video generative models. Early efforts have explored various approaches, either training a video model from scratch or by fine-tuning pre-trained image generation models with additional temporal layers (Stability, ; Wang et al., ; Ho et al., ; Singer et al., ; Ho et al., ; Nan et al., ). The training data of these video models typically consist of a curated mixture of image (Schuhmann et al., ) and video datasets (Bain et al., ; Wang et al., ; ; Nan et al., ).
While substantial progress has been made in improving model architectures and refining training data, relatively little research has been conducted on the 3D consistency and camera controllability of generated videos.

To tackle this issue, several recent works (Wang et al., ; He et al., ; Bahmani et al., ; Xu et al., ; Hou et al., ) have attempted to introduce camera controllability in video generation, aiming to ensure that generated frames adhere to viewpoint instructions, thereby improving 3D consistency.
These works either enhance viewpoint control through better conditioning signals (Wang et al., ; He et al., ; Bahmani et al., ) or by utilizing geometric priors, such as epipolar constraints (Xu et al., ) or explicit 3D representations (Hou et al., ).
However, despite these efforts, the generated videos often lack precise 3D consistency or are restricted to static scenes with little to no object motion. Moreover, it remains challenging for monocular video generators to produce multi-view consistent videos of the same scene from different camera trajectories.

Since independently sampling multiple sequences often results in significantly inconsistent scenes, generating multiple video sequences simultaneously is desirable. However, this remains extremely challenging due to the scarcity of multi-view video data in the wild, leading to multi-view generations limited to inconsistent near-static scenes or synthetic objects.
A concurrent work, CVD (Kuang et al., ), builds on multi-view static videos (Zhou et al., ) and warping-augmented monocular videos (Bain et al., ), but it can only generate videos with limited baselines, yielding inconsistent results when object motion is present. Another concurrent work, Vivid-ZOO (Li et al., ), leverages dynamic objects from Objaverse (Deitke et al., ) dataset and renders multi-view videos to train a video generator.
However, due to limited data sources, their results are primarily object-centric frames from fixed viewpoints, lacking realistic backgrounds.

To address these challenges, we propose Cavia, a novel framework that extends a monocular video generator (Stability, ) to generate multi-view consistent videos with precise camera control. We enhance the spatial and temporal attention modules to cross-view and cross-frame 3D attentions respectively, improving consistency across both viewpoints and frames.
Our model architecture enables a novel joint training strategy that fully utilizes static, monocular, and multi-view dynamic videos. Static videos (Zhou et al., ; Yu et al., ; Xia et al., ; Reizenstein et al., ; Deitke et al., ; ) are converted to multi-view formats to ensure the geometric consistency in the generated frames. We then incorporate rendered synthetic multi-view videos of dynamic 3D objects (Liang et al., ; Jiang et al., ; Li et al., ) to teach the model to generate reasonable object motion. To prevent overfitting on synthetic data, we finetune the model on pose-annotated monocular videos (Wang et al., ; Nan et al., ) to enhance performance on complex scenes.
Our framework synthesizes cross-view and cross-frame consistent videos, and extensive evaluations on real and text-to-image generated images show its applicability across challenging indoor, outdoor, object-centric, and large-scene cases. We systematically measure the quality of the generated videos in terms of per-video and cross-view geometric consistency and perceptual quality. Our experiments demonstrate our superiority compared to previous works both qualitatively and quantitatively. Our experiments demonstrate superior performance compared to previous methods, both qualitatively and quantitatively. Additionally, we show that our method can extrapolate to generate four views during inference and enable 3D reconstruction of the generated frames.

Our main contributions can be summarized as follows,

- •
We propose a novel framework, Cavia, for generating multi-view videos with camera controllability. We introduce view-integrated attentions, namely cross-view and cross-frame 3D attentions, to enhance consistency across viewpoints and frames.
- •
We introduce an effective joint training strategy that leverages a curated mixture of static, monocular dynamic, and multi-view dynamic videos, ensuring geometric consistency, high-quality object motion, and background preservation in the generated results.
- •
Our experiments demonstrate superior geometric and perceptual quality in both monocular video generation and cross-video consistency compared to baseline methods. Additionally, our flexible framework can operate on four views at inference, offering improved view consistency and enabling 3D reconstruction of the generated frames.

## 2 Related Works

### 2.1 Camera Controllable Video Diffusion Models

Recent advancements in video diffusion models have significantly benefited from scaling model architectures and leveraging extensive datasets (Bain et al., ; Wang et al., ; ), leading to impressive capabilities in generating high-quality videos (Stability, ; Ho et al., ; Singer et al., ; Ho et al., ; ).
While large foundational video diffusion models exist, our work focuses on enhancing camera control over video diffusion processes, a rapidly growing area of research. AnimateDiff (Guo et al., ) and Stable Video Diffusion (SVD) (Stability, ) employ individual camera LoRA (Hu et al., ) models for specific camera motions. MotionCtrl (Wang et al., ) improves flexibility by introducing camera matrices, while CameraCtrl (He et al., ), CamCo (Xu et al., ), and VD3D (Bahmani et al., ) enhance the camera control accuracy by introducing Plücker coordinates to the video models via controlnet (Zhang & Agrawala, ). To further improve the geometric consistency, CamCo (Xu et al., ) applies epipolar constraints and CamTrol (Hou et al., ) incorporates 3D Gaussians (Kerbl et al., ). However, these methods focus on monocular video generation, limiting their ability to sample multiple consistent video sequences of the same scene from distinct camera paths. CVD (Kuang et al., ) extends CameraCtrl (He et al., ) for multi-view video generation, but their results are constrained to simple camera and object motion. ViVid-Zoo (Li et al., ) extends MVDream (Shi et al., ) for multi-view purposes but is limited to object-centric results with fixed viewpoints. In contrast, our work explores view-integrated attentions for more precise camera control over arbitrary viewpoints and introduces a joint training strategy leveraging data mixtures to improve novel-view performance in complex scenes.

### 2.2 Multi-view Image Generation

Early approaches such as MVDiffusion (Tang et al., ) focused on generating multiview images in parallel by employing correspondence-aware attention mechanisms, enabling effective cross-view information interaction, particularly for textured scene meshes. Recent approaches like Zero123++ (Shi et al., ), Direct2.5 (Lu et al., ), Instant3D (Li et al., ), MVDream (Shi et al., ), MVDiffusion++ (Tang et al., ), CAT3D (Gao et al., ), and Wonder3D (Long et al., ) have introduced single-pass frameworks for multiview generation, utilizing multiview self-attention to improve viewpoint consistency. Other works, such as SyncDreamer (Liu et al., ), One-2-3-45 (Liu et al., ), Cascade-Zero123 (Chen et al., ) and ConsistNet (Yang et al., ), incorporate multiview features into 3D volumes to facilitate 3D-aware diffusion models (Liu et al., ; Watson et al., ).
Meanwhile, techniques such as Pose-Guided Diffusion (Tseng et al., ), Era3D (Li et al., ), Epidiff (Huang et al., ), and SPAD (Kant et al., ) have integrated epipolar-based features to facilitate enhanced viewpoint fusion within diffusion models. Finally, approaches like V3D (Chen et al., ), IM-3D (Melas-Kyriazi et al., ), SV3D (Voleti et al., ) and Vivid-1-to-3 (Kwak et al., ) leverage priors from video diffusion models to achieve multiview generation with improved consistency.
However, these methods focus on generating static 3D objects or scenes, while our work introduces vivid object motion into multiview dynamic video generation in complex scenes.

### 2.3 4D Generation

Recent efforts in 4D generation have explored various methods (Singer et al., ; Zhao et al., ; Bahmani et al., ; Zheng et al., ; Ling et al., ) that use score distillation from video diffusion models to optimize dynamic NeRFs or 3D Gaussians for text- or image-conditioned scenes.
Follow-up works (Jiang et al., ; Ren et al., ; Yin et al., ; Ren et al., ; Zeng et al., ; Pan et al., ) investigate video-to-4D generation, enabling controllable 4D scene generation from monocular videos.
More recent methods (Liang et al., ; Xie et al., ; Zhang et al., ) utilize video diffusion models to address the spatial-temporal consistency required for efficient 4D generation.
However, these approaches primarily focus on object-centric generation and face challenges in producing realistic results with complex backgrounds. In contrast, our work emphasizes generating multi-view, 3D-consistent videos for complex scenes.

## 3 Method

### 3.1 Overview

Image-to-video generation takes a single image $I_{0}$ as input and outputs a video sequence $O_{1},\cdots,O_{n}$. By introducing camera control, the model additionally takes in a sequence of camera information $C_{1},\cdots,C_{n}$, which dictates the desired viewpoint changes for the output sequence. In the multi-view scenario, we extend each batch of the camera control signal and output video sequence to $V$ sequences.
In the following paragraphs, we present our proposed Cavia framework in detail.
First, we outline the preliminaries of image-to-video diffusion and describe how camera controllability is introduced in monocular video generation. Then, we elaborate on the model design for multi-view consistent video generation.
An overview of our framework is provided in Fig. 1.

Figure: Figure 1: An overview of Cavia is shown in (a). We introduce view-integrated attention modules, namely cross-view attentions and cross-frame attentions, which enforce viewpoint and temporal consistency of the generated frames, respectively. As illustrated in (b) and (c), our view-integrated attention incorporates additional feature dimensions into the attention mechanism, enhancing consistency across views and frames.
Refer to caption: x1.png

### 3.2 Camera Controllable Video Diffusion Model

#### Preliminaries

Our model builds on pre-trained Stable Video Diffusion (SVD) (Stability, ).
SVD extends Stable Diffusion 2.1(Rombach et al., ) by adding temporal convolution and attention layers, following the VideoLDM architecture (Blattmann et al., ).
SVD is trained with a continuous-time noise scheduler (Karras et al., ). In each iteration, the training data is perturbed by Gaussian noise $\mathbf{n}(t)\sim\mathcal{N}(0,\sigma^{2}(t)\mathbf{I})$ and the diffusion model is tasked with estimating the clean data $x_{0}\sim p_{0}$. Let $p(\mathbf{x};\sigma(t))$ denote the marginal probability of noisy data $\mathbf{x}_{t}=\mathbf{x}_{0}+\mathbf{n}(t)$, the iterative refinement process of diffusion model corresponds to the probability flow ordinary differential equation (ODE):

$$ $d\mathbf{x}=-\dot{\sigma}(t)\sigma(t)\nabla_{\mathbf{x}}\log p(\mathbf{x}; \sigma(t))dt.$ (1) $$

$\nabla_{\mathbf{x}}\log p(\mathbf{x};\sigma(t))$ refers to the score function, which is parameterized by a denoiser $D_{\bm{\theta}}$ through
$\nabla_{\mathbf{x}}\log p(\mathbf{x};\sigma)\approx\left(D_{\bm{\theta}}(
\mathbf{x};\sigma)-\mathbf{x}\right)/\sigma^{2}$. We follow the EDM-preconditioning framework (Karras et al., ; Stability, ) and parameterize $D_{\bm{\theta}}$ with a neural network $F_{\bm{\theta}}$ as follows,

$$ $D_{\bm{\theta}}=c_{\text{skip}}\mathbf{x}+c_{\text{out}}F_{\bm{\theta}}(c_{ \text{in}}\mathbf{x};c_{\text{noise}}).$ (2) $$

During training, the network $F_{\bm{\theta}}$ is optimized using denoising score matching for $D_{\bm{\theta}}$:

$$ $\mathbb{E}\left[\left\|D_{\bm{\theta}}\left(\mathbf{x}_{0}+\mathbf{n};\sigma, \text{cond}\right)-\mathbf{x}_{0}\right\|_{2}^{2}\right].$ (3) $$

#### Camera Conditioning

Although SVD is pre-trained on various high-quality video and image data, it does not natively support precise camera control instructions directly.
To address this, we introduce camera conditioning to the model via Plücker coordinates  (Jia, ), which is widely adopted as position
embeddings in 360^∘ unbounded light fields(Sitzmann et al., ). Plücker coordinates are defined as $P=(d^{\prime},o\times d^{\prime})$, where $\times$ is the cross product and $d^{\prime}$ refers to the normalized ray direction $d^{\prime}=\frac{d}{||d||}$. Let camera extrinsic matrix be $E=[\bf{R}|\bf{T}]$ and intrinsic matrix be $\bf{K}$,
the ray direction $d_{x,y}$ for 2D pixel located at $(x,y)$ is formulated as $d=\bf{R}\bf{K}^{-1}(\begin{smallmatrix}x\\
y\\
1\end{smallmatrix})+\bf{T}$.
These spatial Plücker coordinates are concatenated channel-wise with the original latent inputs of SVD. We enlarge the convolution kernel of the first layer accordingly. The newly introduced matrices are zero-initialized to ensure training stability.

We utilize a relative camera coordinate system, where the first frame is positioned at the world origin with an identity matrix for rotation. The following frames are rotated accordingly. To stabilize training, we normalize the scale of the training sequences to a unit scale. This is implemented by resizing the maximum distance-to-origin in the multi-view camera sequence to 1.

#### Cross-frame Attention for Temporal Consistency

Vanilla 1D temporal attention in the SVD backbone is insufficient for modeling large pixel displacements when the viewpoint changes (Shi et al., ; Yang et al., ). In vanilla 1D temporal attention, attention matrices are calculated over the frame number dimension, and latent features only interact with features from the same spatial location across frames. This limits information flow between different spatial-temporal locations. While this might not be a big issue for video generation with limited motion, viewpoint changes typically cause significant pixel displacements, which calls for better architecture for more efficient information propagation.

To overcome this issue, we inflate the original 1D temporal attention modules in the SVD network into 3D cross-frame temporal attention modules, allowing for joint modeling of spatial-temporal feature coherence.
The inflation operation can be achieved by rearranging the latent features before the attention matrix calculations.
Consider the latent features of shape $(B\hskip 2.5ptV\hskip 2.5ptF\hskip 2.5ptC\hskip 2.5ptH\hskip 2.5ptW)$ where $F$ refers to the length of frames and $V$ is the number of views, instead of employing 1D attention mechanism on rearranged shape of $((B\hskip 2.5ptV\hskip 2.5ptH\hskip 2.5ptW)\hskip 2.5ptF\hskip 2.5ptC)$, our inflated attention operates on the rearranged shape of $((B\hskip 2.5ptV)\hskip 2.5pt(F\hskip 2.5ptH\hskip 2.5ptW)\hskip 2.5ptC)$, integrating spatial features into the attention matrices.
A visualization is provided in Fig. 1(c).

Since our rearrange operation only alters the sequence length of the attention inputs without modifying the feature dimensions, we can seamlessly inherit the pre-trained weights from the SVD backbone for our purpose. Thanks to this rearrange operation, our inflated temporal attention now calculates the similarity of spatial-temporal features simultaneously, accommodating larger pixel displacements while maintaining temporal consistency.

### 3.3 Consistent Multi-view Video Diffusion Model

Adding Plücker coordinates for camera control and introducing improved temporal attention allows the video diffusion model to generate reasonably consistent monocular videos. However, for multi-view generation, a monocular video diffusion model that generates samples independently cannot ensure view consistency across multiple sequences. To address this, we introduce novel design mechanisms and training strategies to extend the monocular video diffusion model to the multi-view generation task.

#### Cross-view Attention for Multi-view consistency

To improve cross-view consistency in multi-view videos, we aim to encourage information exchange during the generation process.
Since our temporal cross-frame attention modules already handle intra-view feature connections within each video sequence, we focus on exchanging inter-view signals through the spatial cross-view modules.
Inspired by MVDream (Shi et al., ), we introduce 3D cross-view attention modules, inflated from the spatial attention blocks of SVD (Stability, ).
Specifically, we rearrange the V views such that frames at each corresponding timesteps are concatenated before being sent into the attention modules.
In detail, we rearrange the latent features from shape $(B\hskip 2.5ptV\hskip 2.5ptF\hskip 2.5ptC\hskip 2.5ptH\hskip 2.5ptW)$ to $(((B\hskip 2.5ptF)(V\hskip 2.5ptH\hskip 2.5ptW)\hskip 2.5ptC)$ instead of $(((B\hskip 2.5ptV\hskip 2.5ptF)(H\hskip 2.5ptW)\hskip 2.5ptC)$. A visualization is provided in Fig. 1(b).

Since only the second-to-last dimension, representing token length, is extended while other dimensions remain unchanged, our inflated spatial attention can inherit the model weights from the monocular setting. This flexibility allows our model to leverage training data with varying numbers of views and facilitates extrapolation to additional views at inference.
To handle multi-view generation, we introduce an additional view dimension to the input data.
To maintain workflow simplicity, we absorb the view dimension into the batch dimension during processing of other blocks, ensuring flexibility in handling different numbers of views.

## 4 Joint Training Strategy on Curated Data Mixtures

Thanks to the view-integrated attention mechanism, which allows for inheriting the module weights, our framework can leverage various data sources, including static, multi-view dynamic, and monocular videos. This is hard to achieve in previous methods. In this section, we first illustrate our joint training strategy, followed by details on the curated data mixtures.

### 4.1 Joint Training on Data Mixtures

For videos capturing static scenes (Zhou et al., ; Yu et al., ; Xia et al., ; Reizenstein et al., ; Deitke et al., ; ), we consider all frames to be temporally synchronized.
An arbitrary subsequence of length $(F-1)\times V+1$ from the original video can be reformatted into a $V$-view sequence with a shared starting frame and $F$ total frames per view. Static scenes also allow frame order reversal, providing additional augmentation opportunities.
We further prepare multi-view dynamic videos by rendering animatable objects from Objaverse (Liang et al., ; Jiang et al., ). We design random smooth trajectories with diverse elevation and azimuth changes to avoid overfitting on simple camera movements. These trajectories start from a shared random forward-facing starting point and result in $n\times v$ frames in total.

To avoid the model overfitting on synthetic images with simple backgrounds, we include a portion of data from monocular in-the-wild videos (Wang et al., ; Nan et al., ). Training multi-view camera control from monocular videos is extremely challenging. Although CamCo (Xu et al., ) and 4DiM (Watson et al., ) have explored joint training for monocular video generation, these approaches are unsuitable for multi-view scenarios. The concurrent work CVD (Kuang et al., ) explored homography warping to augment the monocular videos into pseudo-multi-view videos, but the limited realism of these augmentations restricts their ability to generate complex camera and object motion.

To overcome these issues, we choose to jointly train our model on monocular and multi-view videos to effectively utilize the abundant object motion information from all data sources. We annotate the monocular videos with camera poses using Particle-SfM (Zhao et al., ).
Since in-the-wild monocular videos often contain noisy or unnatural content, we apply a rigorous filtering pipeline to remove unsuitable clips.
These curated video clips, sourced from InternVid (Wang et al., ) and OpenVid (Nan et al., ) datasets, provide rich object motion as well as complex backgrounds that mitigate the gap between scene-level static data and object-level dynamic data.
We rearrange monocular videos as $V=1$ samples so that all data items can be processed uniformly without bells and whistles. Thanks to our view-integrated attention modules, which accommodate varying token lengths, the varying view numbers $V$ do not affect the training process.

Figure: Figure 2: Statistics of the (a) point cloud size, (b) aesthetic score, and (c) camera motion classification result for our monocular video dataset.
Refer to caption: x2.png

Figure: Figure 3: Sources of our training videos.
Refer to caption: extracted/5924086/figures/data.png

### 4.2 Data Curation

We begin by training our model extensively on static video data sourced from various publicly available datasets. Wild-RGBD (Xia et al., ) includes nearly 20,000 RGB-D videos across 46 common object categories.
MVImgNet (Yu et al., ) comprises 219,188 videos featuring objects from 238 classes. DL3DV-10K (Ling et al., ) provides 7,000 long-duration videos captured in both indoor and outdoor environments. CO3Dv2 (Reizenstein et al., ) contains 34,000 turntable-like videos of rigid objects, crowd-sourced by nonexperts using cellphone cameras. Objaverse (Deitke et al., ) and Objaverse-XL (Deitke et al., ) exhaustively crawl 10 million publicly available 3D assets. From these, we filtered out low-quality assets, such as those with incorrect textures or overly simplistic geometry, yielding a high-quality subset of 400,000 assets.

Similar to Diffusion4D (Liang et al., ) and Animate3D (Jiang et al., ), we filter the animatable objects from Objaverse’s Sketchfab subset. We exclude objects with excessive motion, which might result in partial observations, as well as nearly static objects with minimal motion. This curation process helps us obtain 19,000 high-quality dynamic assets that can be rendered from arbitrary viewpoints and timesteps, facilitating multi-view video generation. During each training iteration, we augment the frames with randomly selected background colors.

To improve the model’s ability to generate object motion in the presence of complex backgrounds, we prepare monocular videos with camera pose annotations similar to CamCo (Xu et al., ). First, we use Particle-SfM (Zhao et al., ) to estimate the camera poses for randomly sampled frames from videos from InternVid (Wang et al., ) and OpenVid (Nan et al., ). Inspired by CO3D (Reizenstein et al., ) and CamCo (Xu et al., ), we remove the videos where SfM fails to register all available frames or produces a point cloud with too few points or too many points.
Fig. 2(a) shows the point count statistics. A point cloud with too few points indicates poor frame registration to a shared 3D representation, while too many points suggest a mostly static scene, which is undesirable as we focus on object motion. Additionally, non-registered frames may indicate potential scene changes.
We then apply a rigorous filtering pipeline to ensure the quality of the video samples used for training.
This includes filtering based on aesthetic scores, optical character recognition (OCR), and camera motion classification using optical flow. Videos containing detected character regions are aggressively removed. Fig. 2(b) and (c) present statistics on aesthetic score and camera motion classification results. Videos with low aesthetic scores or those classified as having static camera motion are excluded from the training set. Ultimately, we construct a dataset of 393,000 monocular videos annotated with camera poses. We provide a summary of the data sources used in Fig. 3. More details and analysis are provided in the appendix.

Figure: Figure 4: Per-video qualitative comparisons. The first frame in each reference set is the input image. Neither the image nor the camera trajectories were seen during model training. Video results are provided in supplementary for clearer qualitative comparisons.
Refer to caption: x3.png

## 5 Experiments

In this section, we present experimental results and analysis. Video comparisons are included in the supplementary material for optimal visual evaluation.
It is important to note that for all qualitative and quantitative evaluations, neither the input images nor the camera trajectories were used during model training.

### 5.1 Quantitative Comparisons

#### 3D Consistency of Frames

We evaluate the 3D consistency of the generated videos using COLMAP (Schönberger & Frahm, ; Schönberger et al., ). COLMAP is widely adopted for 3D reconstruction methods where camera pose estimation is required for in-the-wild images. We configure the COLMAP following previous methods (Deng et al., ; Xu et al., ) for best few-view performance.
A higher COLMAP error rate indicates poorer 3D consistency in the input images. Motivated by this, we report COLMAP errors as a measure of the 3D consistency of the frames. Each video is retried up to five times to reduce randomness.
We randomly sample 1,000 video sequences from RealEstate10K (Zhou et al., ) test set for evaluation.
Since we have ground truth 3D scenes, we use the ground truth camera pose sequences as the viewpoint instruction of the video model and compare the generated frames against the ground truth images.
Similar to prior works (He et al., ; Xu et al., ), we extract the estimated camera poses and calculate the relative translation and rotation differences.
Specifically, given two camera pose sequences, we convert them to relative poses and align the first frames to world origin.
We then measure the angular errors in translation and rotation. Unlike previous works (He et al., ; Xu et al., ) that calculate the Euclidean distance of translation vectors, we use angular error measurements to ensure the camera pose scales are normalized, addressing scale ambiguity. As shown in Tab. 1, we calculate the area under the cumulative error curve (AUC) of frames whose rotation and translations are below certain thresholds ($5^{\circ}$, $10^{\circ}$, $20^{\circ}$). Our method significantly outperforms existing baselines.

Figure: Figure 5: Qualitative comparisons for 2-view video generations. Each generation consists of two rows, where each row represents a sequence of generated frames, with columns showing frames at the same timestep. Neither the image nor the camera trajectories were used during model training. Red dotted lines are annotated to highlight object motion. Video results are included in the supplementary material for clearer comparisons.
Refer to caption: x4.png

**Table 1: Quantitative comparison for monocular geometry consistency on RealEstate10K test set.**
| Methods | FID $\downarrow$ | FVD $\downarrow$ | COLMAP error$\downarrow$ | Rot. AUC $\uparrow$ | Trans. AUC $\uparrow$ |
| --- | --- | --- | --- | --- | --- |
| (@$5^{\circ}/10^{\circ}/20^{\circ}$) | (@$5^{\circ}/10^{\circ}/20^{\circ}$) |  |  |  |  |
| SVD | 16.89 | 139.64 | 30.3% | 14.4 / 22.8 / 35.3 | 0.2 / 1.0 / 3.2 |
| MotionCtrl | 21.09 | 119.06 | 55.0% | 8.6 / 13.9 / 22.2 | 0.6 / 2.1 / 5.7 |
| CameraCtrl | 14.69 | 105.41 | 19.3% | 21.4 / 32.9 / 48.4 | 0.3 / 1.3 / 4.4 |
| Ours | 11.43 | 55.10 | 14.4% | 22.9 / 34.5 / 50.1 | 5.1 / 12.7 / 24.6 |

**Table 2: Quantitative comparison for 2-view video generation.**
| Scenes | Methods | FID $\downarrow$ | FVD $\downarrow$ | Rot. AUC $\uparrow$ | Trans. AUC $\uparrow$ | Prec. $\uparrow$ | MS. $\uparrow$ |
| --- | --- | --- | --- | --- | --- | --- | --- |
| (@$5^{\circ}/10^{\circ}/20^{\circ}$) | (@$5^{\circ}/10^{\circ}/20^{\circ}$) |  |  |  |  |  |  |
| Real10K | SVD | 37.99 | 296.95 | 7.9 / 13.5 / 28.2 | 0.2 / 0.7 / 2.4 | 6.49 | 4.17 |
| MotionCtrl | 29.23 | 277.05 | 8.1 / 16.5 / 29.4 | 1.5 / 5.3 / 16.1 | 11.45 | 5.90 |  |
| CameraCtrl | 12.57 | 131.32 | 22.4 / 38.5 / 56.2 | 0.6 / 2.5 / 8.2 | 19.49 | 11.25 |  |
| Ours | 8.82 | 94.86 | 23.9 / 37.4 / 52.9 | 3.3 / 10.2 / 23.5 | 29.39 | 15.22 |  |
| General | MotionCtrl | 47.31 | 313.92 | 4.9 / 11.3 / 21.9 | 0.7 / 2.4 / 8.2 | 8.12 | 3.93 |
| CameraCtrl | 26.71 | 221.23 | 14.1 / 26.9 / 43.2 | 0.5 / 1.7 / 5.7 | 15.13 | 7.35 |  |
| Ours | 26.12 | 173.70 | 19.7 / 32.7 / 48.4 | 0.8 / 2.8 / 8.7 | 33.10 | 19.96 |  |

#### Multi-view Consistency

Alongside evaluating the individual monocular frame pose accuracy using COLMAP-based metrics, we further assess the cross-video consistency of the corresponding frames from generated multi-view videos.
We randomly sample 1,000 videos, each with 27 frames, from RealEstate10k (Zhou et al., ) test set and convert each video into a two-view sequence with 14 frames per view.
The new camera pose sequences are generated by setting the 14th frame as the world origin and positioning the remaining frames relative to it. The scales of the scenes are normalized so that the maximum distance from the origin is 1.
Following CVD (Kuang et al., ), we adopt SuperGlue (Sarlin et al., ) to find correspondences and estimate the camera poses between each time-aligned set of frames.
SuperGlue not only measures angular errors in the rotation and translation but also computes the epipolar error of the matched correspondences.
We similarly collect the AUC for frame pairs with rotation and translation errors below specific thresholds ($5^{\circ}$, $10^{\circ}$, $20^{\circ}$). The epipolar errors for the estimated correspondences are summarized to the precision (P) and matching score (MS). As shown in Tab. 2, our method outperforms baselines greatly. The “Real10K” category means that the input images are taken from the corresponding RealEstate10K test sequence, while the “General” means that the input images are taken from 1,000 randomly sampled images in the test split of our monocular video dataset.

#### Visual Quality

To assess the frame perceptual quality, we evaluate visual quality using FID (Heusel et al., ) and FVD (Unterthiner et al., ). FID and FVD measure the feature-space similarity of two sets of images and videos, respectively. In our case, they quantify the distribution distance between the generated frame sequences and the ground-truth frames. We provide monocular evaluations in Tab. 1 and multi-view evaluations in Tab. 2.
As shown in these tables, our proposed framework enjoys the best visual quality. For both the “Real10K” and “General” categories, the ground-truth videos used to calculate these metrics are the video sequences corresponding to the input frames. These video sequences are from the test set split of the datasets and are not seen during training.

### 5.2 Qualtitative Comparison

We provide qualitative comparisons on RealEstate10k (Zhou et al., ) scenes in Fig. 4 and text-to-image generated images in Fig. 5. As shown in Fig. 4, our method produces videos with precise camera control, whereas MotionCtrl tends to generate overly smooth trajectories that simplify the viewpoint instructions, and CameraCtrl suffers from severe distortions at novel viewpoints. For example, in the first case, the camera instruction involves multiple panning operations, first panning left and then panning right. Still, MotionCtrl only pans left, ignoring the rest of the instructions. CameraCtrl’s outputs, particularly in the first two cases, exhibit noticeable distortion, with the walls bending in the later frames.
Additionally, in the third and fourth cases, where the camera trajectories cover a long distance, both MotionCtrl and CameraCtrl produce unrealistic hallucinations, introducing artifacts such as merging indoor and outdoor pixels or distorting input pixels to compensate for a lack of generation ability.
In Fig. 5, we observe that MotionCtrl and CameraCtrl tend to generate static scenes without any object motion. Although their methods produce realistic novel views, the synthesized objects remain static. In contrast, our method generates vivid object motion while maintaining accurate camera control. We highlight the object motion in Fig. 5 using auxiliary red lines. We encourage readers to view the supplementary videos for optimal visual comparisons.

### 5.3 Ablation Studies and Applications

Due to the space limit, we refer readers to the Appendix for ablation studies and applications of our framework. We provide detailed ablation studies in Sec. D on our proposed framework. Additionally, we explore the 3D reconstruction of our generated frames and four-view generation capabilities in Sec. E. Videos are included in the supplementary material for optimal qualitative comparison.

## 6 Conclusion

In this paper, we propose Cavia, a novel framework for consistent multi-view camera-controllable video generation. Our framework incorporates cross-frame and cross-view attentions for effective camera controllability and view consistency. Our model benefits from joint training using static 3D scenes and objects, animatable objects, and in-the-wild monocular videos.
Extensive experiments demonstrate the superiority of our method over previous works in terms of geometric consistency and perceptual quality.

## Appendix A Additional Implementation Details

Our training is divided into static stage and dynamic stage.
Our static stage is trained for around 500k iterations and our dynamic stage is trained for roughly 300k iterations.
The effective batch size is 128 and the learning rate is 1e-4. Our video length is 14 frames for each view with the first frame shared across views. Our model is fine-tuned at $256\times 256$ spatial resolution from the SVD 1.0 checkpoint. The training data are prepared by first center-cropping the original videos and then resizing each frame to the shape of $256\times 256$. In the dynamic stage, 30% of iterations are used to train on monocular videos. During static training, the strides of frames are randomly sampled in the range of [1, 8]. For monocular videos, the strides are sampled in the range of [1, 2]. For dynamic multi-view object renderings, the strides are fixed to 1 to use all rendered frames since we already introduced randomness in the frame rate during rendering.
At inference time, the decoding chunk is set to 14 so all frames are decoded altogether. We sample 25 steps to obtain all our results.

## Appendix B Additional Data Curation Details

In this section, we provide additional details on our data processing and curation pipelines.

#### Static 3D Objects

Our static objects data comprises multi-view images rendered from the Objaverse (Deitke et al., ) and Objaverse-XL(Deitke et al., ) dataset. Similar to InstantMesh, we use a filtered high-quality subset of the original dataset to train our model. The filtering goal is to remove objects that satisfy any of the following criteria: (\romannum1) objects without texture maps, (\romannum2) objects with rendered images occupying less than 10% of the view from any angle, (\romannum3) including multiple separate objects, (\romannum4) objects with no caption information provided by the Cap3D dataset, and (\romannum5) low-quality objects. The classification of “low-quality” objects is determined based on the presence of tags such as “lowpoly” and its variants (e.g., “low poly”) in the metadata. By applying our filtering criteria, we curated approximately 400k high-quality instances from the initial pool of 800k objects in the Objaverse dataset.

For each 3D object, we use Blender’s EEVEE renderer to render an 84-frame RGBA orbit at $512\times 512$ resolution. we adaptively position the camera to a distance sufficient to ensure that the rendered object content makes good and consistent use of the image extents without being clipped in any view. For each frame, the azimuths can be irregularly spaced, and the elevation can vary per view. Specifically, the sequence of camera elevations for each orbit is obtained from a random weighted combination of sinusoids with different frequencies. The azimuth angles are sampled regularly, and then a small amount of noise is added to make them irregular. The elevation values are smoothed using a simple convolution kernel and then clamped to a maximum elevation of 89 degrees.

#### Static 3D Scenes

Our static scenes data are sourced from RealEstate10k (Zhou et al., ), WildRGBD (Xia et al., ), MVImgNet (Yu et al., ), CO3Dv2 (Reizenstein et al., ), and DL3DV-10K (Ling et al., ).
For RealEstate10k, we use the train/test split released by PixelSplat (Charatan et al., ). During training, we sample every 8 original frames to construct the training sequences.
For DL3DV-10K, we construct training sequences from the publicly available 7k subset. Since each video is very long for the DL3DV-10k dataset, we offline randomly sample multiple sequences from a single ground truth video to obtain multiple training data items.
For CO3Dv2, we remove the video sequences that contain whole-black images to avoid temporally inconsistent frames.
For WildRGBD and MVImgNet we use all classes available and removed sequences whose lengths are not enough for two-view training (shorter than 27 frames).

#### Dynamic 3D Objects

Our dynamic 3D objects are similarly rendered as the static 3D objects. The filtering pipelines remain mostly the same as the static objects, except that we introduce additional workflows to consider object motion. Inspired by previous works (Liang et al., ; Jiang et al., ; Li et al., ) that employ animatable objects from Objaverse. We render multiple fixed-view videos to examine the motion quality of the objects. We utilize lpips (Zhang et al., ) to measure the similarity of nearby frames and consider an object to be static if lpips similarity is above a certain threshold. Additionally, we render the alpha masks of the object and use this as an indicator of whether the object has moved out of the visible regions. Consequently, we remove objects with too large or sudden movements as well as objects with little-to-no motion. These filterings result in 19,000 objects. Our rendering strategy is also very similar to that of static 3D objects, introducing random elevation and azimuth changes to complicate the trajectories, except that we additionally introduce a random frame stride at rendering to augment the object motion. The stride is sampled individually for each object from the range [1, 3]. A larger the stride leads to renderings with faster object motion.

#### Monocular Videos

Our monocular video filtering pipeline involves filtering according to Particle-SfM output, OCR, aesthetic score, and camera motion. As mentioned in Sec. 4.2, we first attempt to annotate the camera poses for the video frames using Particle-SfM (Zhao et al., ). Take InternVid (Wang et al., ) as an example, roughly 10 million video clips are processed and around 3 million samples are successfully processed by Particle-SfM. For each video, we start from the first frame and randomly select a frame stride of 1 or 2. The total number of images sent to Particle-SfM is 32 images. Our point count filtering is empirically implemented as a cut-off at 1,000 points and 40,000 points. Point clouds with too few points are removed due to the concern that the frames are poorly registered. Point clouds with too many points are avoided because their limited object motion. This aggressive filtering results in around 2 million samples for further processing. We then evaluate all the video clips using OCR detection algorithms and remove the samples whose detected text regions are larger then ${10^{-4}}$ of the image resolution (i.e. 6 pixels). This process results in 604,000 samples. The next step is filtering with aesthetic scores and videos with aesthetic score annotations smaller than 4 are removed. 467,000 videos are left after these filtering process. Finally, we employ a camera motion classifier extended from the Open-Sora pipeline(^1^11[https://github.com/hpcaitech/Open-Sora/tree/main/tools/caption/camera_motion](https://github.com/hpcaitech/Open-Sora/tree/main/tools/caption/camera_motion)). The main motivation is that optical-flow on consecutive frames can be summarized to a global motion vector, assuming the most parts of the scene is moving in a uniform direction. Optical flow is first obtained using cv2.calcOpticalFlowFarneback for each consecutive frame pairs. Then, the magnitudes and directions are calculated via cv2.cartToPolar. These magnitudes and directions are classified into 8 categories: static, zoom out, zoom in, pan left, tilt up, pan right, tilt down, and unknown. The results of the frame pairs are summarized to obtain the final result of each video clip. When a certain type appears more than 50%, the type for the whole video clip is determined directly. We aggressively classify a video clip as static if any of its frame pairs is categorized into static or unknown. Finally, we obtain 355,000 clips that satisfy our needs. The process is similarly applied to OpenVid (Nan et al., )’s Panda-70M subset Chen et al. () and we obtained 38,000 clips. In summary, our monocular video dataset consists of 393,000 clips.

**Table 3: Ablation Studies on each of our introduced modules. “w/o Plucker” refers to replacing the Plucker coordinate conditioning with one-dimensional conditioning as in MotionCtrl. “w/o Cross-frame” refers to replacing the Cross-frame attention with vanilla 1D temporal attention. “w/o Cross-view” refers to replacing the Cross-view attention with vanilla spatial attention. “Ours (Static)” means the model is only trained on static video datasets. “Ours (w/o Mono)” means that the model is fine-tuned on synthetic multi-view datasets, but is not trained with monocular video datasets. “Ours (Full)” means that the model is trained on all available data sources.**
| Scenes | Methods | FID$\downarrow$ | FVD$\downarrow$ | Rot. AUC $\uparrow$ | Trans. AUC $\uparrow$ | Prec. $\uparrow$ | MS. $\uparrow$ |
| --- | --- | --- | --- | --- | --- | --- | --- |
| (@$5^{\circ}/10^{\circ}/20^{\circ}$) | (@$5^{\circ}/10^{\circ}/20^{\circ}$) |  |  |  |  |  |  |
| Real10K | w/o Plücker | 12.75 | 195.84 | 12.1 / 21.9 / 35.5 | 1.6 / 5.8 / 16.4 | 14.74 | 10.02 |
| w/o Cross-frame | 17.04 | 154.54 | 21.4 / 34.8 / 50.1 | 3.8 / 11.1 / 24.2 | 25.67 | 12.70 |  |
| w/o Cross-view | 9.45 | 106.82 | 22.8 / 36.7 / 52.4 | 2.7 / 8.7 / 22.1 | 27.57 | 14.65 |  |
| Ours | 8.82 | 94.86 | 23.9 / 37.4 / 52.9 | 3.3 / 10.2 / 23.5 | 29.39 | 15.22 |  |
| General | w/o Cross-frame | 71.39 | 249.02 | 9.8 / 19.1 / 32.7 | 0.5 / 1.9 / 6.6 | 13.20 | 8.97 |
| w/o Cross-view | 30.89 | 246.68 | 14.9 / 27.4 / 42.9 | 1.2 / 4.3 / 12.2 | 17.58 | 9.59 |  |
| Ours (Static) | 27.20 | 185.58 | 15.9 / 28.7 / 44.1 | 1.4 / 4.6 / 12.9 | 21.75 | 12.04 |  |
| Ours (w/o Mono) | 35.79 | 243.05 | 15.0 / 27.1 / 42.6 | 0.3 / 1.3 / 4.2 | 18.55 | 10.78 |  |
| Ours (Full) | 26.12 | 173.70 | 19.7 / 32.7 / 48.4 | 0.8 / 2.8 / 8.7 | 33.10 | 19.96 |  |

Figure: Figure 6: Ablation studies on Plücker coordinates and Cross-frame Attention. Video results are provided in supplementary for clearer qualitative comparisons.
Refer to caption: x5.png

Figure: Figure 7: Ablation studies on Cross-view Attention. Video results are provided in supplementary for clearer qualitative comparisons.
Refer to caption: x6.png

Figure: Figure 8: Ablation studies on the joint training strategy on monocular videos. Video results are provided in supplementary for clearer qualitative comparisons.
Refer to caption: x7.png

## Appendix C Evaluation Details

For MotionCtrl and CameraCtrl, we use the open-source checkpoints trained from SVD released by the authors. These checkpoints are designed for image-to-video tasks so we can have fair comparisons. We use “clean-fid”(^2^22[https://github.com/GaParmar/clean-fid](https://github.com/GaParmar/clean-fid)) and “common-metrics-on-video-quality”(^3^33[https://github.com/JunyaoHu/common_metrics_on_video_quality](https://github.com/JunyaoHu/common_metrics_on_video_quality)) for obtaining FID and FVD, respectively. Our FVD results are reported in VideoGPT (Yan et al., ) format. Our COLMAP is configured following DSNeRF (Deng et al., ) and CamCo (Xu et al., ) to improve the few-view reconstruction performance. Concretely speaking, we enable --SiftMatching.max_num_matches 65536 to support robust feature matching. To ensure that the SfM results best align with our videos, we set --ImageReader.single_camera 1 since most videos in our datasets consist of frames captured from a single camera.

## Appendix D Ablation Studies

In this section, we conduct extensive evaluations for ablation studies. We provide video comparisons in the supplementary.
We provide thorough quantitative comparisons in Tab. 3 to illustrate the importance of our proposed components. The models are evaluated using RealEstate10K camera trajectories. For the “Real10K” and “General” categories, the testing images are from our test set split of RealEstate10K and InternVid, respectively. Our full model enjoys the best perceptual quality and geometric consistency.

We first examine the importance of Plucker coordinates conditioning and the cross-frame attention modules. As shown in Fig. 6, model variants without cross-frame attention contains severe distortion artifacts, such as the bent walls. The model variant without Plucker coordinates results in simplified camera motion that ignores the complex camera viewpoint instructions.

We then evaluate the model variant without cross-view attention. As shown in Fig. 7, we observe that removing the cross-view attention module results in multiple individual video samples that contain different object motions. For example, the penguin moves differently in the first case, and the wood sticks in the fire appear differently in the second case. This behavior is not desirable because our goal is to obtain multiple videos from different camera paths of the same scene.

Finally, we examine the importance of our monocular video joint training strategy. As shown in Fig. 8, we observe that when overfitting on dynamic objects from Objaverse, the generated results tend to contain frames with simplified backgrounds. This is mainly because, during the training, all data samples from Objaverse are implemented with single random color backgrounds. Our model benefits from joint training on monocular videos and preserves the ability to generate complex backgrounds when object motion is present.

Figure: Figure 9: Four-view video comparison. The result of CVD is taken from their website. CVD tends to generate black border pixels, potentially due to its homography warping augmentations during training. In comparison, our method produces frames with better geometric consistency and perceptual quality.
Refer to caption: x8.png

Figure: Figure 10: 3D Reconstruction comparison. We render the reconstructed 3D Gaussians from an elliptical trajectory consisting of 16 novel views. The result of CVD is taken from their website. CVD’s reconstruction results suffer from floaters and blurry artifacts due to the inconsistency in their generated frames. In comparison, our method produces sharper results with clearer visual quality.
Refer to caption: x9.png

## Appendix E Applications

In this section, we provide additional results on four-view inference and 3D reconstruction of our generated frames.

### E.1 Advancing to Four Views at Inference

Our cross-view attention design enables us to extrapolate to more views straightforwardly at inference time. This design is more efficient compared with the concurrent work CVD (Kuang et al., ) which requires enumeration of viewpoint pairs at inference time. We conduct a side-by-side comparison for 4-view generation in Fig. 9. Our method enjoys better consistency and shows more realistic results than CVD (Kuang et al., ). In comparison, CVD tends to produce artifacts at border regions. For example, the structure of the wall (first case) and the window (second case) change when the viewpoint changes. The results from CVD are taken from their author’s website. We provide video comparisons in the supplementary. We also provide more 4-view generation results from Cavia in our supplementary.

### E.2 3D Reconstruction of Generated Frames

We further perform 3D reconstruction on our generated frames. We render our reconstructed 3D Gaussians from an elliptical trajectory consisting of 16 novel views. We provide a side-by-side comparison with the concurrent work CVD (Kuang et al., ) in Fig. 10.
Compared with the results of CVD, our frames are more geometrically consistent and result in clearer 3D reconstruction and fewer floaters. For example, the results from CVD produce floaters on the cupboard regions and generate blurry artifacts for the wall and the TV due to inconsistencies. We provide video comparisons in the supplementary for clearer comparisons. We also provide additional 3D reconstruction results of Cavia’s generated frames in the supplementary.

## Appendix F Limitations

Our framework has limited ability to generate large object motion, mainly due to the limitation of the base video generator SVD (Stability, ). We will explore better base models in future works.
Moreover, our data curation pipelines assume a simple camera model using shared camera intrinsic across frames. While enabling easier data preparation, this limits our model from generalizing to complex camera intrinsic changes at inference time, which is widely adopted in cinematography.
Additionally, for simplicity, our framework is trained with normalized scales of scenes, which can be further improved if potentially calibrated with metric scale. We will explore calibration techniques for better quality if a well-generalizable metric depth estimator becomes publicly available.

## Peer Reviews

confidence: 3
contribution: 2
initial_rating: 5
presentation: 1
questions: 1. Visualization vs. Metric-Based Improvement: In Figure 5, the differences among the results appear minimal. What factors contribute to the significant metric-based improvements under the 2-view setting despite the subtle visual changes?

2. GPU Memory Usage of Cross-Frame Attention: Given the extended token length in the cross-frame attention module, does this component impose a significant demand on GPU memory?
soundness: 2
strengths: 1. Novel Framework for Camera-Controllable Video Generation: This paper introduces an innovative framework aimed at generating videos with precise camera control.

2. Superior Performance over Baselines: The proposed method demonstrates an  improvement over baseline models across key performance metrics.

3. Good Monocular Setting Results: Under a monocular setting, the experimental results exhibit substantial improvements in the generated videos.
summary: This paper presents a novel framework, Cavia, designed for generating multi-view videos with precise camera control. The authors introduce view-integrated attention mechanisms that enhance 3D consistency across perspectives. Additionally, Cavia is trained on a curated blend of static, monocular dynamic, and multi-view dynamic videos. Cavia demonstrates superior performance over baseline methods in both monocular video generation and cross-view consistency.
weaknesses: 1. Limited Distinction in Visualization Results (Figure 5): The visual examples provided in Figure 5 lack noticeable differences, which undermines the claimed improvements. This inconsistency between visual and metric-based results calls into question the interpretability and significance of the enhancements.

2. Poor Presentation: (i) The method section is minimal, with only three formulars, all of which are borrowed from references. The lack of detailed descriptions of the pipeline leaves the approach unclear and less accessible for readers. (ii) The paper includes non-standardized expressions, such as "(B V F C H W)" in Line 222. Additionally, Section 4 is ambiguously presented, making it difficult to comprehend.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: See weaknesses
soundness: 4
strengths: 1. Writing is good, and is easy to follow.
2. The model is simple and effective, and easy to use the existing pre-trained video generation models.
3. The data preparation process is logical and effective, it leverages a mix of statics multi-view, monocular videos, and synthetic multi-view datas. The model benefits from such a broader range of training data, enhancing its generalization and robustness.
4. Extensive experiments demonstrate the effectiveness of each design choice.
summary: This paper introduces CAVIA, a framework that advances video generator by adding camera controllability and enabling 4D generation. Specially, it focuses on generating multi-view consistent videos, allowing precise control over camera movement while maintaining object and scene consistency across frames. The Plücker embedding is adopted to inject camera features to the video generator. The cross-frame attention is used to enhancing temporal consistency within each video clip, and the cross view attention is utilized to enhance the content consistency between across different video clips. 
CAVIA is also novel in its usage of multiple data sources, including static and dynamic, multi-view datas. This methods tested on various datasets and compared with some existing methods, demonstrating its state-of-the-art performance.
weaknesses: The main weaknesses are in the experiment part:
1. What are the "general" videos come from? Compared to the RealEstate10K dataset, does the "general" videos have larger camera motion? And does the dynamic complexity is limited?
2. In Table 2, there should be some quantitative comparisons with the CVD model.
3. In the provided videos, the object dynamic degree is limited, can you provide a comparison on the object dynamic degree between CAVIA and the base video generation model SVD?

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: 1. In Table 3, I'm curious why the impact of "w/o cross-view" is even smaller than that of "w/o cross-frame." Intuitively, cross-view should be an essential component for multi-view setups (without it, it's challenging to maintain multi-view consistency and motion synchronization), whereas cross-frame primarily enhances the accuracy. Does this result imply that most of the outcomes are actually static, and similar results could be achieved through independent monocular camera control?

2. Is your model fully tuned? What is the parameter count?

3. Are the results of the ablation study in Table 3 based on monocular camera control or multi-view camera control? It would be advisable to evaluate these two settings separately.
soundness: 3
strengths: 1. From the qualitative and quantitative results, it is evident that this method indeed offers superior camera trajectory control accuracy. This advantage is attributed to the benefits brought by 3D temporal attention (maybe also fulltuning) and the carefully collected training dataset.

2. To overcome the scarcity of multi-view video dataset, a curated mixture of existing available static, monocular dynamic, and multi-view dynamic videos is exploited via joint training scheme. This provides a solution for addressing data issues in future research on this task.

3. The experimental evaluation and comparison are comprehensive, evaluating the geometric accuracy of camera control from multiple perspectives. It demonstrates noticeable superiority of the proposed method.
summary: This paper presents a novel method for camera-controllable multi-view video generation. Leveraging a pre-trained I2V model, the method introduces camera-conditioned Plücker coordinates in the latent space for conditional control. Additionally, it extends spatial attention into cross-view attention and promotes 1D temporal attention into cross-frame 3D attention. These enhancements have been evaluated and found beneficial for achieving cross-view and cross-frame consistency, as well as precise camera control.

To address the challenge of limited multi-view video data, an effective joint training strategy is proposed, utilizing a curated mixture of static, monocular dynamic, and multi-view dynamic videos. Experiments demonstrate the superiority of the proposed method over existing competitors in terms of multi-view consistency and camera control precision. However, it is worth noting that most of the demonstrated examples pertain to specific domains, involving minimal dynamics and simple backgrounds, which raises questions about the method's performance in more general scenarios.
weaknesses: 1. The technical novelty is mild. Adopting plucker embedding for camera control is not new. Extending spatial attention for cross-view attention is also straightforward. Anyway, it is inspiring that 3D attention instead of 1D temporal attention is highly desired to help camera control accuracy, and this is well validated by multiple experiments.


2. One of the major weakness is the less convincing results. 
The most important aspects of multi-view video generation are motion synchronization and geometric consistency. However, most of the examples presented in the paper involve minimal object movement (either a single object with a simple, weakly moving background or entirely static scenes), and the camera angles do not vary significantly, with most shots taken from the same side of the object. This makes it difficult to evaluate the proposed method's capabilities in this task.

For example, I would like to see examples like this: "on a street with vehicles and pedestrians, a horse is running, with one camera capturing a global view from behind the horse and another camera tracking from the side". Showing more examples like this would be more convincing and demonstrate the value of controllable multi-view video generation.


3. In my understanding, making use of monocular videos could promote the model's generalization. But most of the cases in the paper, are close to the style of Objeverse dataset. Is it because the fulltuning destroyed the capabiliy of SVD in generating realistic style and scene? If so, this should be claimed as a limitation, especially compared to those adapter plugin methods like MotionCtrl and CameraCtrl.


4. From the results in Fig. 8, it appears that while the introduction of monocular video increases generalization ability, such as maintaining the content of the input images, it also affects the accuracy of multi-view camera control. In the second row of (b), the shooting direction for the fish and the fox did not turn as expected.

---

confidence: 5
contribution: 2
initial_rating: 5
presentation: 3
questions: - The camera conditions are normalized to a unit scale, can this approach still achieve variable speed camera control similar to MotionCtrl?

- Is it sufficient for the filter method used in Particle-sfm for camera pose estimation to rely on the number of points for accurate pose estimation in videos with significant object motion?

- It would be beneficial to include data samples from various sources to enhance understanding. Additionally, filtering out poor quality samples is necessary.
soundness: 3
strengths: - The Cross-View Attention and Cross-Frame Attention mechanisms are intuitively designed and effectively enhance temporal consistency. The incorporation of 3D attention particularly strengthens this aspect.

- The joint training strategy is commendable for its use of diverse dataset sources, including monocular videos and multi-view videos, which contributes to the robustness of the model.
summary: This paper introduces Cavia, a novel framework for generating multi-view videos with camera controllability. It incorporates view-integrated attention mechanisms—specifically, cross-view and cross-frame 3D attentions—to enhance consistency across different viewpoints and frames. The paper also presents an effective joint training strategy that leverages a curated mix of static, monocular dynamic, and multi-view dynamic videos. This approach ensures geometric consistency, high-quality object motion, and background preservation in the generated results. Experimental results show that Cavia outperforms baseline methods in terms of geometric and perceptual quality for monocular video generation and cross-video consistency. Additionally, the flexible framework can process four views at inference, leading to improved view consistency and enabling 3D reconstruction of the generated frames.
weaknesses: - The video content presented demonstrates low dynamics (object), which may limit the ability to fully showcase the capabilities of the proposed method.

- The contribution of this work appears to be incremental. The proposed method shares significant similarities with CVD, suggesting that the innovations may be more evolutionary than revolutionary.

- The trajectories showcased in the supplementary demo are relatively simple, which raises questions about the model's ability to generalize to more complex scenarios. Further demonstration on a broader range of data would help to substantiate the method's effectiveness.

Meta-review: The paper receives mixed ratings from four reviewers. Most of the reviewers are leaning to reject the submission. They mainly have several concerns regarding this submission, including the insufficient novelty of embedding camera poses as a condition, the unconvincing results shown in the experimental part, and the poor presentation quality. Based on these critical comments, AC recommends a rejection for this time.

Decision: Reject