Upload 2 files

README.md

@@ -0,0 +1,61 @@
+---
+language: 
+- en
+license: "apache-2.0"
+---
+
+# Dataset Card
+## 📷 SynCamVideo Dataset
+### 1. Dataset Introduction
+The SynCamVideo Dataset is a multi-camera synchronized video dataset rendered using the Unreal Engine 5. It consists of 1,000 different scenes, each captured by 36 cameras, resulting in a total of 36,000 videos. SynCamVideo features 50 different animals as the "main subject" and utilizes 20 different locations from [Poly Haven](https://polyhaven.com/hdris) as backgrounds. In each scene, 1-2 subjects are selected from the 50 animals and move along a predefined trajectory, the background is randomly chosen from the 20 locations, the 36 cameras simultaneously record the subjects' movements.
+
+The SynCamVideo Dataset can be used to train multi-camera synchronized video generation models, inspiring applications in areas such as filmmaking and multi-view data generation for downstream tasks.
+
+### 2. File Structure
+```
+SynCamVideo
+├── train
+│   ├── videos    # training videos
+│   │   ├── scene1    # one scene
+│   │   │   ├── xxx.mp4    # synchronized 100-frame videos at 480x720 resolution
+│   │   │   └── ...
+│   │   │   ...
+│   │   └── scene1000
+│   │       ├── xxx.mp4
+│   │       └── ...
+│   ├── cameras    # training cameras
+│   │   ├── scene1    # one scene
+│   │   │   └── xxx.json    # extrinsic parameters corresponding to the videos
+│   │   │   ...
+│   │   └── scene1000
+│   │       └── xxx.json
+│   └──caption
+│       └── cogvideox_caption.csv    # caption generated with "THUDM/cogvlm2-llama3-caption"
+└──val
+    └── cameras    # validation cameras
+        ├── Hemi36_4m_0    # distance=4m, elevation=0°
+        │   └── Hemi36_4m_0.json    # 36 cameras: distance=4m, elevation=0°, azimuth=i * 10°
+        │   ...
+        └── Hemi36_7m_45
+            └── Hemi36_7m_45.json
+```
+
+### 3. Useful scripts
+- Camera Visualization
+```python
+python vis_cam.py --pose_file_path ./SynCamVideo-Dataset/val/cameras/Hemi36_4m_0/Hemi36_4m_0.json --num_cameras 36
+```
+
+The visualization script is modified from [CameraCtrl](https://github.com/hehao13/CameraCtrl/blob/main/tools/visualize_trajectory.py), thanks for their inspiring work.
+
+![image/jpeg](https://cdn-uploads.huggingface.co/production/uploads/6530bf50f145530101ec03a2/OnRORQxdWoB_uIonaAuEv.jpeg)
+
+## Citation
+
+```bibtex
+
+```
+
+## Contact
+
+[Jianhong Bai](https://jianhongbai.github.io/)

vis_cam.py

@@ -0,0 +1,130 @@
+import argparse
+import numpy as np
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+from matplotlib.patches import Patch
+from mpl_toolkits.mplot3d.art3d import Poly3DCollection
+import json
+
+class CameraPoseVisualizer:
+    def __init__(self, xlim, ylim, zlim):
+        self.fig = plt.figure(figsize=(18, 7))
+        self.ax = self.fig.add_subplot(projection='3d')
+        self.plotly_data = None
+        self.ax.set_aspect("auto")
+        self.ax.set_xlim(xlim)
+        self.ax.set_ylim(ylim)
+        self.ax.set_zlim(zlim)
+        self.ax.set_xlabel('x')
+        self.ax.set_ylabel('y')
+        self.ax.set_zlabel('z')
+        print('initialize camera pose visualizer')
+
+    def extrinsic2pyramid(self, extrinsic, color_map='red', hw_ratio=9/16, base_xval=1, zval=3):
+        vertex_std = np.array([[0, 0, 0, 1],
+                               [base_xval, -base_xval * hw_ratio, zval, 1],
+                               [base_xval, base_xval * hw_ratio, zval, 1],
+                               [-base_xval, base_xval * hw_ratio, zval, 1],
+                               [-base_xval, -base_xval * hw_ratio, zval, 1]])
+        vertex_transformed = vertex_std @ extrinsic.T
+        meshes = [[vertex_transformed[0, :-1], vertex_transformed[1][:-1], vertex_transformed[2, :-1]],
+                            [vertex_transformed[0, :-1], vertex_transformed[2, :-1], vertex_transformed[3, :-1]],
+                            [vertex_transformed[0, :-1], vertex_transformed[3, :-1], vertex_transformed[4, :-1]],
+                            [vertex_transformed[0, :-1], vertex_transformed[4, :-1], vertex_transformed[1, :-1]],
+                            [vertex_transformed[1, :-1], vertex_transformed[2, :-1], vertex_transformed[3, :-1], vertex_transformed[4, :-1]]]
+
+        color = color_map if isinstance(color_map, str) else plt.cm.rainbow(color_map)
+
+        self.ax.add_collection3d(
+            Poly3DCollection(meshes, facecolors=color, linewidths=0.3, edgecolors=color, alpha=0.35))
+
+    def customize_legend(self, list_label):
+        list_handle = []
+        for idx, label in enumerate(list_label):
+            color = plt.cm.viridis(idx / len(list_label))
+            patch = Patch(color=color, label=label)
+            list_handle.append(patch)
+        plt.legend(loc='right', bbox_to_anchor=(1.8, 0.5), handles=list_handle)
+
+    def colorbar(self, max_frame_length):
+        cmap = mpl.cm.rainbow
+        norm = mpl.colors.Normalize(vmin=0, vmax=max_frame_length)
+        self.fig.colorbar(mpl.cm.ScalarMappable(norm=norm, cmap=cmap), ax=self.ax, orientation='vertical', label='Frame Number')
+
+    def show(self):
+        plt.title('Extrinsic Parameters')
+        plt.savefig('extrinsic_parameters.jpg', format='jpg', dpi=300)
+        plt.show()
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--pose_file_path', default='./SynCamVideo-Dataset/val/cameras/Hemi36_4m_0/Hemi36_4m_0.json', type=str, help='the path of the pose file')
+    parser.add_argument('--hw_ratio', default=16/16, type=float, help='the height over width of the film plane')
+    parser.add_argument('--num_cameras', type=int, default=36)
+    parser.add_argument('--base_xval', type=float, default=0.08)
+    parser.add_argument('--zval', type=float, default=0.15)
+    parser.add_argument('--x_min', type=float, default=-2)
+    parser.add_argument('--x_max', type=float, default=2)
+    parser.add_argument('--y_min', type=float, default=-2)
+    parser.add_argument('--y_max', type=float, default=2)
+    parser.add_argument('--z_min', type=float, default=-1.)
+    parser.add_argument('--z_max', type=float, default=1)
+    return parser.parse_args()
+
+def get_c2w(w2cs, transform_matrix, relative_c2w=True):
+    if relative_c2w:
+        target_cam_c2w = np.array([
+            [1, 0, 0, 0],
+            [0, 1, 0, 0],
+            [0, 0, 1, 0],
+            [0, 0, 0, 1]
+        ])
+        abs2rel = target_cam_c2w @ w2cs[0]
+        ret_poses = [target_cam_c2w, ] + [abs2rel @ np.linalg.inv(w2c) for w2c in w2cs[1:]]
+    else:
+        ret_poses = [np.linalg.inv(w2c) for w2c in w2cs]
+    ret_poses = [transform_matrix @ x for x in ret_poses]
+    return np.array(ret_poses, dtype=np.float32)
+
+def parse_matrix(matrix_str):
+    rows = matrix_str.strip().split('] [')
+    matrix = []
+    for row in rows:
+        row = row.replace('[', '').replace(']', '')
+        if len((list(map(float, row.split())))) == 3:
+            matrix.append((list(map(float, row.split()))) +[0.])
+        else:
+            matrix.append(list(map(float, row.split())))
+    return np.array(matrix)
+
+if __name__ == '__main__':
+    args = get_args()
+
+    with open(args.pose_file_path, 'r') as file:
+        data = json.load(file)
+
+    cameras = [parse_matrix(data[name]) for name in sorted(data.keys())]
+    cameras = np.transpose(np.stack(cameras), (0, 2, 1))
+
+    w2cs = []
+    for cam in cameras:
+        if cam.shape[0] == 3:
+            cam = np.vstack((cam, np.array([[0, 0, 0, 1]])))
+        cam = cam[:, [1, 2, 0, 3]]
+        cam[:3, 1] *= -1.
+        w2cs.append(np.linalg.inv(cam))
+
+    w2cs = w2cs[:args.num_cameras]
+    scale = max(max(abs(w2c[:3, 3])) for w2c in w2cs)
+    for w2c in w2cs:
+        w2c[:3, 3] /= scale
+    transform_matrix = np.array([[1, 0, 0, 0], [0, 0, 1, 0], [0, -1, 0, 0], [0, 0, 0, 1]])
+    c2ws = get_c2w(w2cs, transform_matrix, True)
+
+    visualizer = CameraPoseVisualizer([args.x_min, args.x_max], [args.y_min, args.y_max], [args.z_min, args.z_max])
+    for frame_idx, c2w in enumerate(c2ws):
+        visualizer.extrinsic2pyramid(c2w, frame_idx / args.num_cameras, hw_ratio=args.hw_ratio, base_xval=args.base_xval,
+                                     zval=(args.zval))
+    visualizer.colorbar(args.num_cameras)
+    visualizer.show()