init commit

LICENSE.md

@@ -0,0 +1,43 @@
+## NVIDIA License for DynPose-100K
+
+### 1. Definitions
+
+- “Licensor” means any person or entity that distributes its Work.
+- “Work” means (a) the original work of authorship made available under this license, which may include software, documentation, or other files, and (b) any additions to or derivative works  thereof  that are made available under this license.
+- The terms “reproduce,” “reproduction,” “derivative works,” and “distribution” have the meaning as provided under U.S. copyright law; provided, however, that for the purposes of this license, derivative works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work.
+- Works are “made available” under this license by including in or with the Work either (a) a copyright notice referencing the applicability of this license to the Work, or (b) a copy of this license.
+
+### 2. License Grant
+
+#### 2.1 Copyright Grant.
+Subject to the terms and conditions of this license, each Licensor grants to you a perpetual, worldwide, non-exclusive, royalty-free, copyright license to use, reproduce, prepare derivative works of, publicly display, publicly perform, sublicense and distribute its Work and any resulting derivative works in any form.
+
+### 3. Limitations
+
+#### 3.1 Redistribution.
+You may reproduce or distribute the Work only if (a) you do so under this license, (b) you include a complete copy of this license with your distribution, and (c) you retain without modification any copyright, patent, trademark, or attribution notices that are present in the Work.
+
+#### 3.2 Derivative Works.
+You may specify that additional or different terms apply to the use, reproduction, and distribution of your derivative works of the Work (“Your Terms”) only if (a) Your Terms provide that the use limitation in Section 3.3 applies to your derivative works, and (b) you identify the specific derivative works that are subject to Your Terms. Notwithstanding Your Terms, this license (including the redistribution requirements in Section 3.1) will continue to apply to the Work itself.
+
+#### 3.3 Use Limitation.
+The Work and any derivative works thereof only may be used or intended for use non-commercially. Notwithstanding the foregoing, NVIDIA Corporation and its affiliates may use the Work and any derivative works commercially. As used herein, “non-commercially” means for non-commercial research purposes only.
+
+#### 3.4 Patent Claims.
+If you bring or threaten to bring a patent claim against any Licensor (including any claim, cross-claim or counterclaim in a lawsuit) to enforce any patents that you allege are infringed by any Work, then your rights under this license from such Licensor (including the grant in Section 2.1) will terminate immediately.
+
+#### 3.5 Trademarks.
+This license does not grant any rights to use any Licensor’s or its affiliates’ names, logos, or trademarks, except as necessary to reproduce the notices described in this license.
+
+#### 3.6 Termination.
+If you violate any term of this license, then your rights under this license (including the grant in Section 2.1) will terminate immediately.
+
+### 4. Disclaimer of Warranty.
+
+THE WORK IS PROVIDED “AS IS” WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WARRANTIES OR CONDITIONS OF 
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE OR NON-INFRINGEMENT. YOU BEAR THE RISK OF UNDERTAKING ANY ACTIVITIES UNDER THIS LICENSE. 
+
+### 5. Limitation of Liability.
+
+EXCEPT AS PROHIBITED BY APPLICABLE LAW, IN NO EVENT AND UNDER NO LEGAL THEORY, WHETHER IN TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE SHALL ANY LICENSOR BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR RELATED TO THIS LICENSE, THE USE OR INABILITY TO USE THE WORK (INCLUDING BUT NOT LIMITED TO LOSS OF GOODWILL, BUSINESS INTERRUPTION, LOST PROFITS OR DATA, COMPUTER FAILURE OR MALFUNCTION, OR ANY OTHER DAMAGES OR LOSSES), EVEN IF THE LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+

README.md

@@ -0,0 +1,157 @@
+---
+license: other
+language:
+- en
+pretty_name: dynpose-100k
+size_categories:
+- 100K<n<1M
+task_categories:
+- other
+---
+# DynPose-100K
+
+**[Dynamic Camera Poses and Where to Find Them](https://research.nvidia.com/labs/dir/dynpose-100k)** \
+[Chris Rockwell<sup>1,2</sup>](https://crockwell.github.io), [Joseph Tung<sup>3</sup>](https://jot-jt.github.io/), [Tsung-Yi Lin<sup>1</sup>](https://tsungyilin.info/), 
+[Ming-Yu Liu<sup>1</sup>](https://mingyuliu.net/), [David F. Fouhey<sup>3</sup>](https://cs.nyu.edu/~fouhey/), [Chen-Hsuan Lin<sup>1</sup>](https://chenhsuanlin.bitbucket.io/) \
+<sup>1</sup>NVIDIA <sup>2</sup>University of Michigan <sup>3</sup>New York University
+
+[![Project Website](https://img.shields.io/static/v1?label=Project&message=Website&color=red)](https://research.nvidia.com/labs/dir/dynpose-100k) [![arXiv](https://img.shields.io/badge/arXiv-XXXX.XXXXX-b31b1b.svg)](https://arxiv.org/abs/XXXX.XXXXX)
+
+![DynPose-100K Teaser](teaser.png)
+
+## Overview
+
+DynPose-100K is a large-scale dataset of diverse, dynamic videos with camera annotations. We curate 100K videos containing dynamic content while ensuring cameras can be accurately estimated (including intrinsics and poses), addressing two key challenges:
+1. Identifying videos suitable for camera estimation
+2. Improving camera estimation algorithms for dynamic videos
+
+| Characteristic | Value |
+| --- | --- |
+| **Size** | 100K videos |
+| **Resolution** | 1280×720 (720p) |
+| **Annotation type** | Camera poses (world-to-camera), intrinsics |
+| **Format** | MP4 (videos), PKL (camera data), JPG (frames) |
+| **Frame rate** | 12 fps (extracted frames) |
+| **Storage** | ~200 GB (videos) + ~400 GB (frames) + 0.7 GB (annotations) |
+| **License** | NVIDIA License (for DynPose-100K) |
+
+## DynPose-100K Download
+
+DynPose-100K contains diverse Internet videos annotated with state-of-the-art camera pose estimation. Videos were selected from 3.2M candidates through advanced filtering.
+
+### 1. Camera annotation download (0.7 GB)
+```bash
+git clone https://huggingface.co/datasets/nvidia/dynpose-100k
+cd dynpose-100k
+unzip dynpose_100k.zip
+export DYNPOSE_100K_ROOT=$(pwd)/dynpose_100k
+```
+
+### 2. Video download (~200 GB for all videos at 720p)
+```bash
+git clone https://github.com/snap-research/Panda-70M.git
+pip install -e Panda-70M/dataset_dataloading/video2dataset
+```
+- For experiments we use (1280, 720) video resolution rather than the default (640, 360). To download at this resolution (optional), modify [download size](https://github.com/snap-research/Panda-70M/blob/main/dataset_dataloading/video2dataset/video2dataset/configs/panda70m.yaml#L5) to 720
+```bash
+video2dataset --url_list="${DYNPOSE_100K_ROOT}/metadata.csv" --output_folder="${DYNPOSE_100K_ROOT}/video" \
+              --url_col="url" --caption_col="caption" --clip_col="timestamp" \
+              --save_additional_columns="[matching_score,desirable_filtering,shot_boundary_detection]" \
+              --config="video2dataset/video2dataset/configs/panda70m.yaml"
+```
+
+### 3. Video frame extraction (~400 GB for 12 fps over all videos at 720p)
+```bash
+python scripts/extract_frames.py --input_video_dir ${DYNPOSE_100K_ROOT}/video \
+    --output_frame_parent ${DYNPOSE_100K_ROOT}/frames-12fps \
+    --url_list ${DYNPOSE_100K_ROOT}/metadata.csv \
+    --uid_mapping ${DYNPOSE_100K_ROOT}/uid_mapping.csv
+```
+
+### 4. Camera pose visualization
+Create a conda environment if you haven't done so:
+```bash
+conda env create -f environment.yml
+conda activate dynpose-100k
+```
+Run the below under the `dynpose-100k` environment:
+```bash
+python scripts/visualize_pose.py --dset dynpose_100k --dset_parent ${DYNPOSE_100K_ROOT}
+```
+
+### Dataset structure
+```
+dynpose_100k
+ ├── cameras
+ |     ├── 00011ee6-cbc1-4ec4-be6f-292bfa698fc6.pkl {uid}
+ |          ├── poses {camera poses (all frames) ([N',3,4])}
+ |          ├── intrinsics {camera intrinsic matrix ([3,3])}
+ |          ├── frame_idxs {corresponding frame indices ([N']), values within [0,N-1]}
+ |          ├── mean_reproj_error {average reprojection error from SfM ([N'])}
+ |          ├── num_points {number of reprojected points ([N'])}
+ |          ├── num_frames {number of video frames N (scalar)}
+ |          # where N' is number of registered frames
+ |     ├── 00031466-5496-46fa-a992-77772a118b17.pkl
+ |          ├── poses # camera poses (all frames) ([N',3,4])
+ |          └── ...
+ |     └── ...
+ ├── video
+ |     ├── 00011ee6-cbc1-4ec4-be6f-292bfa698fc6.mp4 {uid}
+ |     ├── 00031466-5496-46fa-a992-77772a118b17.mp4
+ |     └── ...
+ ├── frames-12fps
+ |     ├── 00011ee6-cbc1-4ec4-be6f-292bfa698fc6 {uid}
+ |          ├── 00001.jpg {frame id}
+ |          ├── 00002.jpg
+ |          └── ...
+ |     ├── 00031466-5496-46fa-a992-77772a118b17
+ |          ├── 00001.jpg
+ |          └── ...
+ |     └── ...
+ ├── metadata.csv {used to download video & extract frames}
+ |     ├── uid
+ |     ├── 00031466-5496-46fa-a992-77772a118b17
+ |     └── ...
+ ├── uid_mapping.csv {used to download video & extract frames}
+ |     ├── videoID,url,timestamp,caption,matching_score,desirable_filtering,shot_boundary_detection
+ |     ├── --106WvnIhc,https://www.youtube.com/watch?v=--106WvnIhc,"[['0:13:34.029', '0:13:40.035']]",['A man is swimming in a pool with an inflatable mattress.'],[0.44287109375],['desirable'],"[[['0:00:00.000', '0:00:05.989']]]"
+ |     └── ...
+ ├── viz_list.txt {used as index for pose visualization}
+ |     ├── 004cd3b5-8af4-4613-97a0-c51363d80c31 {uid}
+ |     ├── 0c3e06ae-0d0e-4c41-999a-058b4ea6a831
+ |     └── ...
+ ```
+
+## LightSpeed Benchmark
+
+LightSpeed contains ground truth camera pose and is used to validate DynPose-100K's pose annotation method.
+
+Coming soon!
+
+## FAQ
+
+**Q: What coordinate system do the camera poses use?**  
+A: Camera poses are world-to-camera and follow OpenCV "RDF" convention (same as COLMAP): X axis points to the right, the Y axis to the bottom, and the Z axis to the front as seen from the image.
+
+**Q: How do I map between frame indices and camera poses?**  
+A: The `frame_idxs` field in each camera PKL file contains the corresponding frame indices for the poses.
+
+**Q: How can I contribute to this dataset?**  
+A: Please contact the authors for collaboration opportunities.
+
+## Citation
+
+If you find this dataset useful in your research, please cite our paper:
+
+```bibtex
+@inproceedings{rockwell2025dynpose,
+    author = {Rockwell, Chris and Tung, Joseph and Lin, Tsung-Yi and Liu, Ming-Yu and Fouhey, David F. and Lin, Chen-Hsuan},
+    title = {Dynamic Camera Poses and Where to Find Them},
+    booktitle = {CVPR},
+    year = 2025
+}
+```
+
+## Acknowledgements
+
+We thank Gabriele Leone and the NVIDIA Lightspeed Content Tech team for sharing the original 3D assets and scene data for creating the Lightspeed benchmark. We thank Yunhao Ge, Zekun Hao, Yin Cui, Xiaohui Zeng, Zhaoshuo Li, Hanzi Mao, Jiahui Huang, Justin Johnson, JJ Park and Andrew Owens for invaluable inspirations, discussions and feedback on this project.

dynpose_100k.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0cfe45ada47dcf0a42ecf8570433dcdbb44bdfad5c000060acd17a4f7c99684a
+size 703105132

environment.yml

@@ -0,0 +1,45 @@
+name: dynpose-100k
+channels:
+  - defaults
+dependencies:
+  - _libgcc_mutex=0.1=main
+  - _openmp_mutex=5.1=1_gnu
+  - ca-certificates=2024.11.26=h06a4308_0
+  - ld_impl_linux-64=2.40=h12ee557_0
+  - libffi=3.4.4=h6a678d5_1
+  - libgcc-ng=11.2.0=h1234567_1
+  - libgomp=11.2.0=h1234567_1
+  - libstdcxx-ng=11.2.0=h1234567_1
+  - ncurses=6.4=h6a678d5_0
+  - openssl=3.0.15=h5eee18b_0
+  - pip=24.2=py39h06a4308_0
+  - python=3.9.21=he870216_1
+  - readline=8.2=h5eee18b_0
+  - setuptools=75.1.0=py39h06a4308_0
+  - sqlite=3.45.3=h5eee18b_0
+  - tk=8.6.14=h39e8969_0
+  - wheel=0.44.0=py39h06a4308_0
+  - xz=5.4.6=h5eee18b_1
+  - zlib=1.2.13=h5eee18b_1
+  - pip:
+    - contourpy==1.3.0
+    - cycler==0.12.1
+    - ffmpeg-python==0.2.0
+    - fonttools==4.55.3
+    - future==1.0.0
+    - importlib-resources==6.4.5
+    - kiwisolver==1.4.7
+    - matplotlib==3.9.4
+    - numpy==2.0.2
+    - packaging==24.2
+    - pandas==2.2.3
+    - pillow==11.0.0
+    - plotly==5.24.1
+    - pyparsing==3.2.0
+    - python-dateutil==2.9.0.post0
+    - pytz==2024.2
+    - six==1.17.0
+    - tenacity==9.0.0
+    - tqdm==4.67.1
+    - tzdata==2024.2
+    - zipp==3.21.0

scripts/extract_frames.py

@@ -0,0 +1,94 @@
+# -----------------------------------------------------------------------------
+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+#
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+# -----------------------------------------------------------------------------
+
+import argparse
+import ast
+import csv
+import json
+import os
+import shutil
+import subprocess
+from tqdm import tqdm
+
+
+def get_vid_mapping(input_video_dir):
+    """
+    Create mapping from video ID to local file path.
+
+    Args:
+        input_video_dir: Directory containing downloaded videos organized in folders
+
+    Returns:
+        vid_mapping: Dictionary mapping video IDs to local file paths
+    """
+    print("mapping video id to local path")
+    vid_mapping = {}
+    folders = [x for x in os.listdir(input_video_dir) if os.path.isdir(f"{input_video_dir}/{x}")]
+    for folder in sorted(folders):
+        vids = [x for x in os.listdir(f"{input_video_dir}/{folder}") if x[-4:] == ".mp4"]
+        for vid in tqdm(sorted(vids)):
+            vid_path = f"{input_video_dir}/{folder}/{vid}"
+            vid_json = f"{input_video_dir}/{folder}/{vid[:-4]}.json"
+            # Extract video ID from URL in JSON metadata
+            vid_name = json.load(open(vid_json))["url"].split("?v=")[-1]
+            vid_mapping[vid_name] = vid_path
+    return vid_mapping
+
+
+def extract(url_list, input_video_dir, output_frame_parent, uid_mapping):
+    """
+    Extract frames from videos at 12 fps.
+
+    Args:
+        url_list: CSV file containing video URLs and timestamps
+        input_video_dir: Directory containing downloaded videos
+        output_frame_parent: Output directory for extracted frames
+        uid_mapping: CSV file mapping timestamps to unique IDs
+    """
+    vid_mapping = get_vid_mapping(input_video_dir)
+
+    with open(uid_mapping, "r") as file2:
+        with open(url_list, "r") as file:
+            csv_reader = csv.reader(file)
+            csv_reader2 = csv.reader(file2)
+            for i, (row, row2) in enumerate(tqdm(zip(csv_reader, csv_reader2))):
+                # Skip header row and empty rows
+                if i == 0 or len(row) == 0:
+                    continue
+
+                try:
+                    full_vid_path = vid_mapping[row[0]]
+                except KeyError:
+                    if i % 10 == 0:
+                        print("video not found, skipping", row[0])
+                    continue
+
+                print("extracting", row[0])
+                for j, timestamps in enumerate(ast.literal_eval(row[2])):
+                    uid = row2[j]
+                    # Copy video with unique ID name
+                    vid_parent = os.path.dirname(os.path.dirname(full_vid_path))
+                    vid_uid_path = shutil.copyfile(full_vid_path, f"{vid_parent}/{uid}.mp4")
+                    os.makedirs(f"{output_frame_parent}/{uid}", exist_ok=True)
+                    # Extract frames using ffmpeg
+                    cmd = f"nice -n 19 ffmpeg -i {vid_uid_path} -q:v 2 -vf fps=12 {output_frame_parent}/{uid}/%05d.jpg"
+
+                    subprocess.run(cmd, shell=True, capture_output=True)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--url_list", type=str, help="path for url list")
+    parser.add_argument("--input_video_dir", type=str, help="video directory")
+    parser.add_argument("--output_frame_parent", type=str, help="parent for output frames")
+    parser.add_argument("--uid_mapping", type=str, help="path for uid mapping")
+    args = parser.parse_args()
+    print("args", args)
+    extract(args.url_list, args.input_video_dir, args.output_frame_parent, args.uid_mapping)

scripts/visualize_pose.py

@@ -0,0 +1,334 @@
+# -----------------------------------------------------------------------------
+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+#
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+# -----------------------------------------------------------------------------
+
+import argparse
+import matplotlib
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+import pickle as pkl
+import plotly.graph_objs as go
+import plotly.io as pio
+from tqdm import tqdm
+
+matplotlib.use("agg")
+
+
+class Pose():
+    """
+    A class of operations on camera poses (numpy arrays with shape [...,3,4]).
+    Each [3,4] camera pose takes the form of [R|t].
+    """
+
+    def __call__(self, R=None, t=None):
+        """
+        Construct a camera pose from the given rotation matrix R and/or translation vector t.
+
+        Args:
+            R: Rotation matrix [...,3,3] or None
+            t: Translation vector [...,3] or None
+
+        Returns:
+            pose: Camera pose matrix [...,3,4]
+        """
+        assert R is not None or t is not None
+        if R is None:
+            if not isinstance(t, np.ndarray):
+                t = np.array(t)
+            R = np.eye(3, device=t.device).repeat(*t.shape[:-1], 1, 1)
+        elif t is None:
+            if not isinstance(R, np.ndarray):
+                R = np.array(R)
+            t = np.zeros(R.shape[:-1], device=R.device)
+        else:
+            if not isinstance(R, np.ndarray):
+                R = np.array(R)
+            if not isinstance(t, np.ndarray):
+                t = np.tensor(t)
+        assert R.shape[:-1] == t.shape and R.shape[-2:] == (3, 3)
+        R = R.astype(np.float32)
+        t = t.astype(np.float32)
+        pose = np.concatenate([R, t[..., None]], axis=-1)  # [...,3,4]
+        assert pose.shape[-2:] == (3, 4)
+        return pose
+
+    def invert(self, pose, use_inverse=False):
+        """
+        Invert a camera pose.
+
+        Args:
+            pose: Camera pose matrix [...,3,4]
+            use_inverse: Whether to use matrix inverse instead of transpose
+
+        Returns:
+            pose_inv: Inverted camera pose matrix [...,3,4]
+        """
+        R, t = pose[..., :3], pose[..., 3:]
+        R_inv = R.inverse() if use_inverse else R.transpose(0, 2, 1)
+        t_inv = (-R_inv @ t)[..., 0]
+        pose_inv = self(R=R_inv, t=t_inv)
+        return pose_inv
+
+    def compose(self, pose_list):
+        """
+        Compose a sequence of poses together.
+        pose_new(x) = poseN o ... o pose2 o pose1(x)
+
+        Args:
+            pose_list: List of camera poses to compose
+
+        Returns:
+            pose_new: Composed camera pose
+        """
+        pose_new = pose_list[0]
+        for pose in pose_list[1:]:
+            pose_new = self.compose_pair(pose_new, pose)
+        return pose_new
+
+    def compose_pair(self, pose_a, pose_b):
+        """
+        Compose two poses together.
+        pose_new(x) = pose_b o pose_a(x)
+
+        Args:
+            pose_a: First camera pose
+            pose_b: Second camera pose
+
+        Returns:
+            pose_new: Composed camera pose
+        """
+        R_a, t_a = pose_a[..., :3], pose_a[..., 3:]
+        R_b, t_b = pose_b[..., :3], pose_b[..., 3:]
+        R_new = R_b @ R_a
+        t_new = (R_b @ t_a + t_b)[..., 0]
+        pose_new = self(R=R_new, t=t_new)
+        return pose_new
+
+    def scale_center(self, pose, scale):
+        """
+        Scale the camera center from the origin.
+        0 = R@c+t --> c = -R^T@t (camera center in world coordinates)
+        0 = R@(sc)+t' --> t' = -R@(sc) = -R@(-R^T@st) = st
+
+        Args:
+            pose: Camera pose to scale
+            scale: Scale factor
+
+        Returns:
+            pose_new: Scaled camera pose
+        """
+        R, t = pose[..., :3], pose[..., 3:]
+        pose_new = np.concatenate([R, t * scale], axis=-1)
+        return pose_new
+
+
+def to_hom(X):
+    """Get homogeneous coordinates of the input by appending ones."""
+    X_hom = np.concatenate([X, np.ones_like(X[..., :1])], axis=-1)
+    return X_hom
+
+
+def cam2world(X, pose):
+    """Transform points from camera to world coordinates."""
+    X_hom = to_hom(X)
+    pose_inv = Pose().invert(pose)
+    return X_hom @ pose_inv.transpose(0, 2, 1)
+
+
+def get_camera_mesh(pose, depth=1):
+    """
+    Create a camera mesh visualization.
+
+    Args:
+        pose: Camera pose matrix
+        depth: Size of the camera frustum
+
+    Returns:
+        vertices: Camera mesh vertices
+        faces: Camera mesh faces
+        wireframe: Camera wireframe vertices
+    """
+    vertices = np.array([[-0.5, -0.5, 1],
+                         [0.5, -0.5, 1],
+                         [0.5, 0.5, 1],
+                         [-0.5, 0.5, 1],
+                         [0, 0, 0]]) * depth  # [6,3]
+    faces = np.array([[0, 1, 2],
+                      [0, 2, 3],
+                      [0, 1, 4],
+                      [1, 2, 4],
+                      [2, 3, 4],
+                      [3, 0, 4]])  # [6,3]
+    vertices = cam2world(vertices[None], pose)  # [N,6,3]
+    wireframe = vertices[:, [0, 1, 2, 3, 0, 4, 1, 2, 4, 3]]  # [N,10,3]
+    return vertices, faces, wireframe
+
+
+def merge_xyz_indicators_plotly(xyz):
+    """Merge xyz coordinate indicators for plotly visualization."""
+    xyz = xyz[:, [[-1, 0], [-1, 1], [-1, 2]]]  # [N,3,2,3]
+    xyz_0, xyz_1 = unbind_np(xyz, axis=2)  # [N,3,3]
+    xyz_dummy = xyz_0 * np.nan
+    xyz_merged = np.stack([xyz_0, xyz_1, xyz_dummy], axis=2)  # [N,3,3,3]
+    xyz_merged = xyz_merged.reshape(-1, 3)
+    return xyz_merged
+
+
+def get_xyz_indicators(pose, length=0.1):
+    """Get xyz coordinate axis indicators for a camera pose."""
+    xyz = np.eye(4, 3)[None] * length
+    xyz = cam2world(xyz, pose)
+    return xyz
+
+
+def merge_wireframes_plotly(wireframe):
+    """Merge camera wireframes for plotly visualization."""
+    wf_dummy = wireframe[:, :1] * np.nan
+    wireframe_merged = np.concatenate([wireframe, wf_dummy], axis=1).reshape(-1, 3)
+    return wireframe_merged
+
+
+def merge_meshes(vertices, faces):
+    """Merge multiple camera meshes into a single mesh."""
+    mesh_N, vertex_N = vertices.shape[:2]
+    faces_merged = np.concatenate([faces + i * vertex_N for i in range(mesh_N)], axis=0)
+    vertices_merged = vertices.reshape(-1, vertices.shape[-1])
+    return vertices_merged, faces_merged
+
+
+def unbind_np(array, axis=0):
+    """Split numpy array along specified axis into list."""
+    if axis == 0:
+        return [array[i, :] for i in range(array.shape[0])]
+    elif axis == 1 or (len(array.shape) == 2 and axis == -1):
+        return [array[:, j] for j in range(array.shape[1])]
+    elif axis == 2 or (len(array.shape) == 3 and axis == -1):
+        return [array[:, :, j] for j in range(array.shape[2])]
+    else:
+        raise ValueError("Invalid axis. Use 0 for rows or 1 for columns.")
+
+
+def plotly_visualize_pose(poses, vis_depth=0.5, xyz_length=0.5, center_size=2, xyz_width=5, mesh_opacity=0.05):
+    """
+    Create plotly visualization traces for camera poses.
+
+    Args:
+        poses: Camera poses to visualize [N,3,4]
+        vis_depth: Size of camera frustum visualization
+        xyz_length: Length of coordinate axis indicators
+        center_size: Size of camera center markers
+        xyz_width: Width of coordinate axis lines
+        mesh_opacity: Opacity of camera frustum mesh
+
+    Returns:
+        plotly_traces: List of plotly visualization traces
+    """
+    N = len(poses)
+    centers_cam = np.zeros([N, 1, 3])
+    centers_world = cam2world(centers_cam, poses)
+    centers_world = centers_world[:, 0]
+    # Get the camera wireframes.
+    vertices, faces, wireframe = get_camera_mesh(poses, depth=vis_depth)
+    xyz = get_xyz_indicators(poses, length=xyz_length)
+    vertices_merged, faces_merged = merge_meshes(vertices, faces)
+    wireframe_merged = merge_wireframes_plotly(wireframe)
+    xyz_merged = merge_xyz_indicators_plotly(xyz)
+    # Break up (x,y,z) coordinates.
+    wireframe_x, wireframe_y, wireframe_z = unbind_np(wireframe_merged, axis=-1)
+    xyz_x, xyz_y, xyz_z = unbind_np(xyz_merged, axis=-1)
+    centers_x, centers_y, centers_z = unbind_np(centers_world, axis=-1)
+    vertices_x, vertices_y, vertices_z = unbind_np(vertices_merged, axis=-1)
+    # Set the color map for the camera trajectory and the xyz indicators.
+    color_map = plt.get_cmap("gist_rainbow")  # red -> yellow -> green -> blue -> purple
+    center_color = []
+    faces_merged_color = []
+    wireframe_color = []
+    xyz_color = []
+    x_color, y_color, z_color = *np.eye(3).T,
+    for i in range(N):
+        # Set the camera pose colors (with a smooth gradient color map).
+        r, g, b, _ = color_map(i / (N - 1))
+        rgb = np.array([r, g, b]) * 0.8
+        wireframe_color += [rgb] * 11
+        center_color += [rgb]
+        faces_merged_color += [rgb] * 6
+        xyz_color += [x_color] * 3 + [y_color] * 3 + [z_color] * 3
+    # Plot in plotly.
+    plotly_traces = [
+        go.Scatter3d(x=wireframe_x, y=wireframe_y, z=wireframe_z, mode="lines",
+                     line=dict(color=wireframe_color, width=1)),
+        go.Scatter3d(x=xyz_x, y=xyz_y, z=xyz_z, mode="lines", line=dict(color=xyz_color, width=xyz_width)),
+        go.Scatter3d(x=centers_x, y=centers_y, z=centers_z, mode="markers",
+                     marker=dict(color=center_color, size=center_size, opacity=1)),
+        go.Mesh3d(x=vertices_x, y=vertices_y, z=vertices_z,
+                  i=[f[0] for f in faces_merged], j=[f[1] for f in faces_merged], k=[f[2] for f in faces_merged],
+                  facecolor=faces_merged_color, opacity=mesh_opacity),
+    ]
+    return plotly_traces
+
+
+def write_html(poses, file, dset, vis_depth=1, xyz_length=0.2, center_size=0.01, xyz_width=2):
+    """Write camera pose visualization to HTML file."""
+    if dset == "lightspeed":
+        xyz_length = xyz_length / 3
+        xyz_width = xyz_width
+        vis_depth = vis_depth / 3
+        center_size *= 3
+
+    traces_poses = plotly_visualize_pose(poses, vis_depth=vis_depth, xyz_length=xyz_length,
+                                         center_size=center_size, xyz_width=xyz_width, mesh_opacity=0.05)
+    traces_all2 = traces_poses
+    layout2 = go.Layout(scene=dict(xaxis=dict(visible=False), yaxis=dict(visible=False), zaxis=dict(visible=False),
+                                   dragmode="orbit", aspectratio=dict(x=1, y=1, z=1), aspectmode="data"),
+                        height=400, width=600, showlegend=False)
+
+    fig2 = go.Figure(data=traces_all2, layout=layout2)
+    html_str2 = pio.to_html(fig2, full_html=False)
+
+    file.write(html_str2)
+
+
+def viz_poses(i, seq, file, dset, dset_parent):
+    """Visualize camera poses for a sequence and write to HTML file."""
+    if "/" in seq:
+        seq = "_".join(seq.split("/"))
+
+    if "mp4" in seq:
+        seq = seq[:-4]
+
+    file.write(f"<span style='font-size: 18pt;'>{i} {seq}</span><br>")
+
+    if dset == "dynpose_100k":
+        with open(f"{dset_parent}/cameras/{seq}.pkl", "rb") as f:
+            poses = pkl.load(f)["poses"]
+    else:
+        with open(f"{dset_parent}/poses.pkl", "rb") as f:
+            poses = pkl.load(f)[seq]
+
+    write_html(poses, file, dset)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--dset", type=str, default="dynpose_100k", choices=["dynpose_100k", "lightspeed"])
+    parser.add_argument("--dset_parent", type=str, default=".")
+    args = parser.parse_args()
+
+    outdir = f"pose_viz/{args.dset}"
+    os.makedirs(outdir, exist_ok=True)
+    split_size = 6  # to avoid poses disappearing
+
+    viz_list = f"{args.dset_parent}/viz_list.txt"
+    seqs = open(viz_list).read().split()
+
+    for j in tqdm(range(int(np.ceil(len(seqs)/split_size)))):
+        with open(f"{outdir}/index_{str(j)}.html", "w") as file:
+            for i, seq in enumerate(tqdm(seqs[j*split_size:j*split_size+split_size])):
+                viz_poses(i, seq, file, args.dset, args.dset_parent)