nvs2colmap 0.1.0__py3-none-any.whl

nvs2colmap/colmap.py

@@ -0,0 +1,91 @@
+"""Run COLMAP processing for generated per-frame folders."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Sequence
+
+from nvs2colmap.write_model import CameraModel
+from nvs2colmap.utils.colmap import (
+    exhaustive_matcher,
+    feature_extractor,
+    image_undistorter,
+    mapper,
+    point_triangulator,
+    read_db,
+)
+
+
+def build_colmap_records(
+    cameras: Sequence[CameraModel],
+    image_extension: str = ".png",
+) -> tuple[dict[str, str], dict[str, str]]:
+    colmap_cameras, colmap_images = {}, {}
+    for camera in cameras:
+        img_name = f"{camera.name}{image_extension}"
+        colmap_cameras[img_name] = (
+            f"PINHOLE {camera.width} {camera.height} "
+            f"{camera.fx} {camera.fy} {camera.cx} {camera.cy}"
+        )
+        q, t = camera.qvec, camera.tvec
+        colmap_images[img_name] = f"{q[0]} {q[1]} {q[2]} {q[3]} {t[0]} {t[1]} {t[2]}"
+    return colmap_cameras, colmap_images
+
+
+def run_colmap(
+    folder: Path,
+    cameras: Sequence[CameraModel],
+    image_extension: str = ".png",
+    colmap_executable: str = "colmap",
+    use_gpu: str = "1",
+) -> None:
+    folder = Path(folder)
+    colmap_executable = os.path.abspath(colmap_executable)
+    colmap_cameras, colmap_images = build_colmap_records(cameras, image_extension)
+
+    if feature_extractor(str(folder), use_gpu=use_gpu, colmap_executable=colmap_executable) != 0:
+        raise RuntimeError("Feature extraction failed")
+    if exhaustive_matcher(str(folder), use_gpu=use_gpu, colmap_executable=colmap_executable) != 0:
+        raise RuntimeError("Feature matching failed")
+
+    cam_ids, image_ids = read_db(str(folder))
+
+    mapper_input_path = folder / "distorted" / "sparse" / "loading"
+    os.makedirs(mapper_input_path, exist_ok=True)
+    with open(mapper_input_path / "cameras.txt", "w") as f:
+        for img_name, cam_id in sorted(cam_ids.items(), key=lambda i: i[1]):
+            f.write(f"{cam_id} {colmap_cameras[img_name]}\n")
+    with open(mapper_input_path / "images.txt", "w") as f:
+        for img_name, image_id in sorted(image_ids.items(), key=lambda i: i[1]):
+            f.write(f"{image_id} {colmap_images[img_name]} {cam_ids[img_name]} {img_name}\n\n")
+    open(mapper_input_path / "points3D.txt", "w").close()
+
+    if point_triangulator(str(folder), str(mapper_input_path), colmap_executable=colmap_executable) != 0:
+        raise RuntimeError("Triangulation failed")
+    if mapper(str(folder), str(mapper_input_path), colmap_executable=colmap_executable) != 0:
+        raise RuntimeError("Mapping failed")
+
+    # To fit sparse init in instantsplat
+    if image_undistorter(str(folder), colmap_executable=colmap_executable) != 0:
+        raise RuntimeError("Image undistortion failed")
+
+
+def run_video_colmap(
+    output_pattern: Path,
+    cameras: Sequence[CameraModel],
+    n_frames: int,
+    start_number: int = 1,
+    image_extension: str = ".png",
+    colmap_executable: str = "colmap",
+    use_gpu: str = "1",
+) -> None:
+    output_pattern = str(output_pattern)
+    for frame in range(start_number, start_number + n_frames):
+        run_colmap(
+            folder=Path(output_pattern % frame),
+            cameras=cameras,
+            image_extension=image_extension,
+            colmap_executable=colmap_executable,
+            use_gpu=use_gpu,
+        )

nvs2colmap/n3dv/__main__.py

@@ -0,0 +1,126 @@
+"""Extract Neural 3D Video Dataset scenes into per-frame COLMAP folders."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from nvs2colmap.colmap import run_video_colmap
+from nvs2colmap.write_model import write_video_colmap_text_model
+
+from .extract_videos import count_frame_dirs, extract_videos
+from .poses_bounds import read_poses_bounds
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Extract a Neural 3D Video Dataset scene and convert poses_bounds.npy "
+            "to per-frame COLMAP text models."
+        )
+    )
+    parser.add_argument(
+        "--path",
+        type=Path,
+        required=True,
+        help="Scene directory containing poses_bounds.npy and camera mp4 files.",
+    )
+    parser.add_argument(
+        "--n-frames",
+        type=int,
+        help="Number of frames to extract and write. Defaults to the video frame count when extracting.",
+    )
+    parser.add_argument(
+        "--ffmpeg",
+        dest="ffmpeg_executable",
+        default="ffmpeg",
+        help="ffmpeg executable.",
+    )
+    parser.add_argument(
+        "--ffprobe",
+        dest="ffprobe_executable",
+        default="ffprobe",
+        help="ffprobe executable.",
+    )
+    parser.add_argument(
+        "--image-extension",
+        default=".png",
+        help="Image extension written by ffmpeg and referenced by COLMAP text files.",
+    )
+    parser.add_argument(
+        "--video-extension",
+        default=".mp4",
+        help="Video extension used to discover camera videos.",
+    )
+    parser.add_argument(
+        "--skip-video-extraction",
+        action="store_true",
+        help="Only convert poses_bounds.npy for existing frame folders.",
+    )
+    parser.add_argument(
+        "--use-colmap",
+        action="store_true",
+        help=(
+            "Run COLMAP feature extraction, matching, triangulation, mapping, "
+            "and undistortion instead of only writing sparse/0 text models."
+        ),
+    )
+    parser.add_argument(
+        "--colmap-executable",
+        default="colmap",
+        help="COLMAP executable used when --use-colmap is set.",
+    )
+    parser.add_argument(
+        "--colmap-use-gpu",
+        dest="colmap_use_gpu",
+        default="1",
+        help="Whether COLMAP SIFT extraction/matching should use GPU when --use-colmap is set.",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    folder = args.path.resolve()
+
+    cameras = read_poses_bounds(folder, args.video_extension)
+
+    n_frames = args.n_frames
+    frame_output_pattern = folder / "frame%d"
+    image_dir_name = "input" if args.use_colmap else "images"
+    if not args.skip_video_extraction:
+        n_frames = extract_videos(
+            folder=folder,
+            output_pattern=frame_output_pattern / image_dir_name,
+            cameras=cameras,
+            n_frames=n_frames,
+            ffmpeg_executable=args.ffmpeg_executable,
+            ffprobe_executable=args.ffprobe_executable,
+            video_extension=args.video_extension,
+            image_extension=args.image_extension,
+        )
+    elif n_frames is None:
+        n_frames = count_frame_dirs(frame_output_pattern)
+
+    if not args.use_colmap:
+        write_video_colmap_text_model(
+            output_pattern=frame_output_pattern / "sparse" / "0",
+            cameras=cameras,
+            n_frames=n_frames,
+            image_extension=args.image_extension,
+        )
+    else:
+        run_video_colmap(
+            output_pattern=frame_output_pattern,
+            cameras=cameras,
+            n_frames=n_frames,
+            image_extension=args.image_extension,
+            colmap_executable=args.colmap_executable,
+            use_gpu=args.colmap_use_gpu,
+        )
+
+    print(f"Done: {folder}")
+
+
+if __name__ == "__main__":
+    main()

nvs2colmap/n3dv/extract_videos.py

@@ -0,0 +1,49 @@
+"""Extract Neural 3D Video camera videos into frame image folders."""
+
+from pathlib import Path
+
+from nvs2colmap.write_model import CameraModel
+from nvs2colmap.utils import extract_video_frames
+
+
+def count_frame_dirs(output_pattern: Path, start_number: int = 1) -> int:
+    output_pattern = str(output_pattern)
+    frame = start_number
+    while Path(output_pattern % frame).is_dir():
+        frame += 1
+    n_frames = frame - start_number
+    if n_frames == 0:
+        raise FileNotFoundError(f"No frame directories found from pattern: {output_pattern}")
+    return n_frames
+
+
+def extract_videos(
+    folder: Path,
+    output_pattern: Path,
+    cameras: list[CameraModel],
+    n_frames: int | None = None,
+    ffmpeg_executable: str = "ffmpeg",
+    ffprobe_executable: str = "ffprobe",
+    video_extension: str = ".mp4",
+    image_extension: str = ".png",
+) -> int:
+    if not video_extension.startswith("."):
+        video_extension = f".{video_extension}"
+
+    extracted_n_frames = 0
+    for camera in cameras:
+        video_path = folder / f"{camera.name}{video_extension}"
+        if not video_path.is_file():
+            raise FileNotFoundError(f"Missing camera video: {video_path}")
+        camera_output_pattern = output_pattern / f"{camera.name}{image_extension}"
+        camera_n_frames = extract_video_frames(
+            video_path=video_path,
+            output_pattern=str(camera_output_pattern),
+            n_frames=n_frames,
+            ffmpeg_executable=ffmpeg_executable,
+            ffprobe_executable=ffprobe_executable,
+        )
+        extracted_n_frames = max(extracted_n_frames, camera_n_frames)
+    if extracted_n_frames == 0:
+        raise ValueError("No cameras to extract.")
+    return extracted_n_frames

nvs2colmap/n3dv/poses_bounds.py

@@ -0,0 +1,73 @@
+"""Read Neural 3D Video poses_bounds.npy camera metadata."""
+
+import numpy as np
+import torch
+from pathlib import Path
+
+from nvs2colmap.write_model import CameraModel
+from nvs2colmap.utils import matrix_to_quaternion
+
+
+def read_camera_meta_n3dv(folder):
+    folder = Path(folder)
+    # Inverse of: https://github.com/Fyusion/LLFF/blob/master/llff/poses/pose_utils.py#L11
+    poses_arr = torch.tensor(np.load(folder / "poses_bounds.npy"))
+    poses = poses_arr[:, :-2].reshape(-1, 3, 5)
+    bds = poses_arr[:, -2:]
+    hwf = poses[:, :, 4]
+    c2w = torch.zeros((poses.shape[0], 4, 4), dtype=poses.dtype)
+    # switch from [-y, x, z] (poses_bounds format) back to [x, -y, -z] (colmap format)
+    c2w[:, :3, 0:1] = poses[:, :3, 1:2]
+    c2w[:, :3, 1:2] = poses[:, :3, 0:1]
+    c2w[:, :3, 2:3] = -poses[:, :3, 2:3]
+    c2w[:, :3, 3:4] = poses[:, :3, 3:4]
+    c2w[:, 3, 3] = 1
+    w2c = torch.linalg.inv(c2w)
+    Rs = w2c[:, :3, :3]
+    Ts = w2c[:, :3, 3]
+    return poses.shape[0], Rs, Ts, hwf, bds
+
+
+def list_camera_videos(folder: Path, video_extension: str = ".mp4") -> list[Path]:
+    if not video_extension.startswith("."):
+        video_extension = f".{video_extension}"
+    video_extension = video_extension.lower()
+    videos = [
+        path
+        for path in folder.iterdir()
+        if path.is_file() and path.suffix.lower() == video_extension
+    ]
+    if not videos:
+        raise FileNotFoundError(f"No {video_extension} camera videos found in {folder}")
+    return sorted(videos)
+
+
+def read_poses_bounds(folder, video_extension: str = ".mp4") -> list[CameraModel]:
+    folder = Path(folder)
+    camera_meta = read_camera_meta_n3dv(folder)
+    n_cameras, Rs, Ts, hwf, bds = camera_meta
+    camera_videos = list_camera_videos(folder, video_extension)
+    if len(camera_videos) != n_cameras:
+        raise ValueError(f"Expected {n_cameras} camera videos, got {len(camera_videos)}.")
+
+    cameras = []
+    for i in range(n_cameras):
+        height, width = hwf[i, 0], hwf[i, 1]
+        fx = fy = hwf[i, 2]
+        cx, cy = width / 2, height / 2
+        R, T = Rs[i], Ts[i]
+        q, t = matrix_to_quaternion(R), T
+        cameras.append(
+            CameraModel(
+                name=camera_videos[i].stem,
+                width=int(round(float(width))),
+                height=int(round(float(height))),
+                fx=float(fx),
+                fy=float(fy),
+                cx=float(cx),
+                cy=float(cy),
+                qvec=q.detach().cpu().numpy(),
+                tvec=t.detach().cpu().numpy(),
+            )
+        )
+    return cameras

nvs2colmap/utils/__init__.py

@@ -0,0 +1,31 @@
+"""Utility helpers exported for package-level imports."""
+
+from .colmap import (
+    execute,
+    exhaustive_matcher,
+    feature_extractor,
+    image_undistorter,
+    mapper,
+    model_converter_bin,
+    model_converter_txt,
+    point_triangulator,
+    read_db,
+)
+from .ffmpeg import count_video_frames, extract_video_frames
+from .rotation import matrix_to_quaternion, standardize_quaternion
+
+__all__ = [
+    "count_video_frames",
+    "execute",
+    "exhaustive_matcher",
+    "extract_video_frames",
+    "feature_extractor",
+    "image_undistorter",
+    "mapper",
+    "matrix_to_quaternion",
+    "model_converter_bin",
+    "model_converter_txt",
+    "point_triangulator",
+    "read_db",
+    "standardize_quaternion",
+]

nvs2colmap/utils/colmap.py

@@ -0,0 +1,104 @@
+"""COLMAP command helpers."""
+
+import sqlite3
+import subprocess
+import os
+
+
+def execute(cmd):
+    proc = subprocess.Popen(cmd, shell=False)
+    proc.communicate()
+    return proc.returncode
+
+
+def feature_extractor(folder, use_gpu="1", colmap_executable="colmap"):
+    os.makedirs(os.path.join(folder, "distorted"), exist_ok=True)
+    cmd = [
+        colmap_executable, "feature_extractor",
+        "--database_path", os.path.join(folder, "distorted", "database.db"),
+        "--image_path", os.path.join(folder, "input"),
+        "--ImageReader.camera_model", "PINHOLE",
+        "--SiftExtraction.use_gpu", use_gpu,
+        "--ImageReader.single_camera_per_image", "1",
+    ]
+    return execute(cmd)
+
+
+def exhaustive_matcher(folder, use_gpu="1", colmap_executable="colmap"):
+    cmd = [
+        colmap_executable, "exhaustive_matcher",
+        "--database_path", os.path.join(folder, "distorted", "database.db"),
+        "--SiftMatching.use_gpu", use_gpu,
+    ]
+    return execute(cmd)
+
+
+def read_db(folder):
+    conn = sqlite3.connect(os.path.join(folder, "distorted", "database.db"))
+    c = conn.cursor()
+    c.execute(f"SELECT camera_id,image_id,name FROM main.images")
+    camera_ids, image_ids = {}, {}
+    for camera_id, image_id, name in c.fetchall():
+        camera_ids[name] = camera_id
+        image_ids[name] = image_id
+    conn.close()
+    return camera_ids, image_ids
+
+
+def point_triangulator(folder, mapper_input_path, colmap_executable="colmap"):
+    cmd = [
+        colmap_executable, "point_triangulator",
+        "--database_path", os.path.join(folder, "distorted", "database.db"),
+        "--input_path", mapper_input_path,
+        "--output_path", mapper_input_path,
+        "--image_path", os.path.join(folder, "input")
+    ]
+    return execute(cmd)
+
+
+def mapper(folder, mapper_input_path, colmap_executable="colmap"):
+    os.makedirs(os.path.join(folder, "distorted", "sparse", "0"), exist_ok=True)
+    cmd = [
+        colmap_executable, "mapper",
+        "--database_path", os.path.join(folder, "distorted", "database.db"),
+        "--image_path", os.path.join(folder, "input"),
+        "--Mapper.ba_global_function_tolerance=0.000001",
+        "--input_path", mapper_input_path,
+        "--output_path", os.path.join(folder, "distorted", "sparse", "0")
+    ]
+    return execute(cmd)
+
+
+def model_converter_txt(folder, colmap_executable="colmap"):
+    mapper_output_path = os.path.join(folder, "distorted", "sparse", "0")
+    os.makedirs(mapper_output_path, exist_ok=True)
+    cmd = [
+        colmap_executable, "model_converter",
+        "--input_path", mapper_output_path,
+        "--output_path", mapper_output_path,
+        "--output_type=TXT",
+    ]
+    return execute(cmd)
+
+
+def model_converter_bin(folder, colmap_executable="colmap"):
+    mapper_output_path = os.path.join(folder, "distorted", "sparse", "0")
+    os.makedirs(mapper_output_path, exist_ok=True)
+    cmd = [
+        colmap_executable, "model_converter",
+        "--input_path", mapper_output_path,
+        "--output_path", mapper_output_path,
+        "--output_type=BIN",
+    ]
+    return execute(cmd)
+
+
+def image_undistorter(folder, colmap_executable="colmap"):
+    cmd = [
+        colmap_executable, "image_undistorter",
+        "--image_path", os.path.join(folder, "input"),
+        "--input_path", os.path.join(folder, "distorted", "sparse", "0"),
+        "--output_path", folder,
+        "--output_type=COLMAP",
+    ]
+    return execute(cmd)

nvs2colmap/utils/ffmpeg.py

@@ -0,0 +1,68 @@
+"""ffmpeg helpers."""
+
+import os
+import subprocess
+
+
+def count_video_frames(
+    video_path,
+    start_number: int = 1,
+    n_frames: int | None = None,
+    ffprobe_executable: str = "ffprobe",
+) -> int:
+    assert start_number >= 1, f"start_number must be >= 1, got {start_number}."
+
+    cmd = [
+        ffprobe_executable,
+        "-v",
+        "error",
+        "-count_frames",
+        "-select_streams",
+        "v:0",
+        "-show_entries",
+        "stream=nb_read_frames",
+        "-of",
+        "default=nokey=1:noprint_wrappers=1",
+        str(video_path),
+    ]
+    output = subprocess.check_output(cmd, text=True).strip()
+    video_frame_count = int(output)
+    available_frame_count = video_frame_count - start_number + 1
+    assert available_frame_count > 0, f"start_number {start_number} is outside {video_frame_count} frames in {video_path}."
+
+    if n_frames is None:
+        return available_frame_count
+
+    assert n_frames >= 1, f"n_frames must be >= 1, got {n_frames}."
+    return min(n_frames, available_frame_count)
+
+
+def extract_video_frames(
+    video_path, output_pattern,
+    start_number: int = 1, n_frames: int | None = None,
+    ffmpeg_executable: str = "ffmpeg", ffprobe_executable: str = "ffprobe",
+) -> int:
+    frame_count = count_video_frames(
+        video_path,
+        start_number=start_number,
+        n_frames=n_frames,
+        ffprobe_executable=ffprobe_executable,
+    )
+
+    for frame in range(start_number, start_number + frame_count):
+        os.makedirs(os.path.dirname(output_pattern % frame), exist_ok=True)
+
+    cmd = [
+        ffmpeg_executable,
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-i",
+        str(video_path),
+        "-frames:v", str(frame_count),
+        "-start_number", str(start_number),
+        str(output_pattern), "-y",
+    ]
+    print(" ".join(str(part) for part in cmd))
+    subprocess.run(cmd, check=True)
+    return frame_count

nvs2colmap/utils/rotation.py

@@ -0,0 +1,99 @@
+"""Rotation conversion utilities."""
+
+import torch
+import torch.nn.functional as F
+
+
+def standardize_quaternion(quaternions: torch.Tensor) -> torch.Tensor:
+    """
+    Convert a unit quaternion to a standard form: one in which the real
+    part is non negative.
+
+    Args:
+        quaternions: Quaternions with real part first,
+            as tensor of shape (..., 4).
+
+    Returns:
+        Standardized quaternions as tensor of shape (..., 4).
+    Source: https://pytorch3d.readthedocs.io/en/latest/_modules/pytorch3d/transforms/rotation_conversions.html
+    """
+    return torch.where(quaternions[..., 0:1] < 0, -quaternions, quaternions)
+
+
+def _sqrt_positive_part(x: torch.Tensor) -> torch.Tensor:
+    """
+    Returns torch.sqrt(torch.max(0, x))
+    but with a zero subgradient where x is 0.
+    Source: https://pytorch3d.readthedocs.io/en/latest/_modules/pytorch3d/transforms/rotation_conversions.html
+    """
+    ret = torch.zeros_like(x)
+    positive_mask = x > 0
+    # if torch.is_grad_enabled():
+    #     ret[positive_mask] = torch.sqrt(x[positive_mask])
+    # else:
+    #     ret = torch.where(positive_mask, torch.sqrt(x), ret)
+    ret[positive_mask] = torch.sqrt(x[positive_mask])
+    return ret
+
+
+def matrix_to_quaternion(matrix: torch.Tensor) -> torch.Tensor:
+    """
+    Convert rotations given as rotation matrices to quaternions.
+
+    Args:
+        matrix: Rotation matrices as tensor of shape (..., 3, 3).
+
+    Returns:
+        quaternions with real part first, as tensor of shape (..., 4).
+    Source: https://pytorch3d.readthedocs.io/en/latest/_modules/pytorch3d/transforms/rotation_conversions.html
+    """
+    if matrix.size(-1) != 3 or matrix.size(-2) != 3:
+        raise ValueError(f"Invalid rotation matrix shape {matrix.shape}.")
+
+    batch_dim = matrix.shape[:-2]
+    m00, m01, m02, m10, m11, m12, m20, m21, m22 = torch.unbind(
+        matrix.reshape(batch_dim + (9,)), dim=-1
+    )
+
+    q_abs = _sqrt_positive_part(
+        torch.stack(
+            [
+                1.0 + m00 + m11 + m22,
+                1.0 + m00 - m11 - m22,
+                1.0 - m00 + m11 - m22,
+                1.0 - m00 - m11 + m22,
+            ],
+            dim=-1,
+        )
+    )
+
+    # we produce the desired quaternion multiplied by each of r, i, j, k
+    quat_by_rijk = torch.stack(
+        [
+            # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and
+            #  `int`.
+            torch.stack([q_abs[..., 0] ** 2, m21 - m12, m02 - m20, m10 - m01], dim=-1),
+            # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and
+            #  `int`.
+            torch.stack([m21 - m12, q_abs[..., 1] ** 2, m10 + m01, m02 + m20], dim=-1),
+            # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and
+            #  `int`.
+            torch.stack([m02 - m20, m10 + m01, q_abs[..., 2] ** 2, m12 + m21], dim=-1),
+            # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and
+            #  `int`.
+            torch.stack([m10 - m01, m20 + m02, m21 + m12, q_abs[..., 3] ** 2], dim=-1),
+        ],
+        dim=-2,
+    )
+
+    # We floor here at 0.1 but the exact level is not important; if q_abs is small,
+    # the candidate won't be picked.
+    flr = torch.tensor(0.1).to(dtype=q_abs.dtype, device=q_abs.device)
+    quat_candidates = quat_by_rijk / (2.0 * q_abs[..., None].max(flr))
+
+    # if not for numerical problems, quat_candidates[i] should be same (up to a sign),
+    # forall i; we pick the best-conditioned one (with the largest denominator)
+    out = quat_candidates[
+        F.one_hot(q_abs.argmax(dim=-1), num_classes=4) > 0.5, :
+    ].reshape(batch_dim + (4,))
+    return standardize_quaternion(out)

nvs2colmap/write_model.py

@@ -0,0 +1,67 @@
+"""Base COLMAP data structures and text model writers."""
+
+import os
+from dataclasses import dataclass
+from typing import Sequence
+
+import numpy as np
+
+
+@dataclass(frozen=True)
+class CameraModel:
+    """A static camera model converted from one row of poses_bounds.npy."""
+
+    name: str
+    width: int
+    height: int
+    fx: float
+    fy: float
+    cx: float
+    cy: float
+    qvec: np.ndarray
+    tvec: np.ndarray
+
+
+def write_colmap_text_model(
+    path,
+    cameras: Sequence[CameraModel],
+    image_extension: str = ".png",
+) -> None:
+    colmap_cameras, colmap_images = {}, {}
+    for camera in cameras:
+        img_name = f"{camera.name}{image_extension}"
+        height, width = camera.height, camera.width
+        fx, fy = camera.fx, camera.fy
+        cx, cy = camera.cx, camera.cy
+        colmap_cameras[img_name] = f"PINHOLE {width} {height} {fx} {fy} {cx} {cy}"
+        q, t = camera.qvec, camera.tvec
+        colmap_images[img_name] = f"{q[0]} {q[1]} {q[2]} {q[3]} {t[0]} {t[1]} {t[2]}"
+
+    cam_ids = {f"{camera.name}{image_extension}": i for i, camera in enumerate(cameras, start=1)}
+    image_ids = {f"{camera.name}{image_extension}": i for i, camera in enumerate(cameras, start=1)}
+
+    mapper_input_path = path
+    os.makedirs(mapper_input_path, exist_ok=True)
+    with open(os.path.join(mapper_input_path, "cameras.txt"), "w") as f:
+        for img_name, cam_id in sorted(cam_ids.items(), key=lambda i: i[1]):
+            f.write(f"{cam_id} {colmap_cameras[img_name]}\n")
+    with open(os.path.join(mapper_input_path, "images.txt"), "w") as f:
+        for img_name, image_id in sorted(image_ids.items(), key=lambda i: i[1]):
+            f.write(f"{image_id} {colmap_images[img_name]} {cam_ids[img_name]} {img_name}\n\n")
+    open(os.path.join(mapper_input_path, "points3D.txt"), "w").close()
+
+
+def write_video_colmap_text_model(
+    output_pattern,
+    cameras: Sequence[CameraModel],
+    n_frames: int,
+    start_number: int = 1,
+    image_extension: str = ".png",
+) -> None:
+    output_pattern = str(output_pattern)
+    for frame in range(start_number, start_number + n_frames):
+        write_colmap_text_model(
+            output_pattern % frame,
+            cameras,
+            image_extension=image_extension,
+        )

nvs2colmap-0.1.0.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: nvs2colmap
+Version: 0.1.0
+Summary: Utilities for converting novel view synthesis datasets to COLMAP format.
+Author-email: Howard Yin <yindaheng98@gmail.com>
+Maintainer-email: Howard Yin <yindaheng98@gmail.com>
+Project-URL: Homepage, https://github.com/yindaheng98/NVS2COLMAP
+Project-URL: Documentation, https://github.com/yindaheng98/NVS2COLMAP#readme
+Project-URL: Repository, https://github.com/yindaheng98/NVS2COLMAP
+Project-URL: Issues, https://github.com/yindaheng98/NVS2COLMAP/issues
+Keywords: colmap,novel-view-synthesis,neural-3d-video,3d-reconstruction,computer-vision
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: torch
+Dynamic: license-file
+
+# NVS2COLMAP
+
+Utilities for converting novel view synthesis datasets to COLMAP format.
+
+## Supported Formats
+
+- **Neural 3D Video Dataset**: scenes with `poses_bounds.npy` and one `mp4`
+  file per camera. See `nvs2colmap/n3dv/README.md`.
+
+## Supported Datasets
+
+- **Neural 3D Video Dataset**: dataset
+  [facebookresearch/Neural_3D_Video](https://github.com/facebookresearch/Neural_3D_Video),
+  paper
+  [Neural 3D Video Synthesis from Multi-view Video](https://arxiv.org/abs/2103.02597).
+- **StreamRF / Meet Room Dataset**: dataset
+  [AlgoHunt/StreamRF](https://github.com/AlgoHunt/StreamRF), paper
+  [Streaming Radiance Fields for 3D Video Synthesis](https://arxiv.org/abs/2210.14831).
+- **Robo360**: dataset
+  [liuyubian/Robo360](https://huggingface.co/datasets/liuyubian/Robo360),
+  paper
+  [Robo360: A 3D Omnispective Multi-Material Robotic Manipulation Dataset](https://arxiv.org/abs/2312.06686).
+
+## Quick Start
+
+Install the Python runtime dependencies:
+
+```bash
+pip install numpy torch
+```
+
+For Neural 3D Video scenes, the command also needs `ffmpeg` and `ffprobe` on
+`PATH`, or explicit paths via `--ffmpeg` and `--ffprobe`. If you want to run
+the full COLMAP pipeline, also provide a COLMAP executable via
+`--colmap-executable`.
+
+Extract a Neural 3D Video scene and write per-frame COLMAP text models:
+
+```bash
+python -m nvs2colmap.n3dv \
+  --path data/coffee_martini \
+  --ffmpeg ffmpeg \
+  --ffprobe ffprobe \
+  --n-frames 300
+```
+
+Run the full COLMAP pipeline for each frame:
+
+```bash
+python -m nvs2colmap.n3dv \
+  --path data/Robo360/xarm6_gold_rope_in_basket_2 \
+  --ffmpeg D:/MyPrograms/ffmpeg.exe \
+  --ffprobe D:/MyPrograms/ffprobe.exe \
+  --video-extension MP4 \
+  --n-frames 1 \
+  --use-colmap \
+  --colmap-executable data/colmap/COLMAP.bat \
+  --colmap-use-gpu 1
+```
+
+By default, decoded frames are written to `frame*/images`, and the command also
+writes `frame*/sparse/0` text models. With `--use-colmap`, decoded frames are
+written to `frame*/input`, and each frame additionally gets the standard
+COLMAP outputs such as `distorted/`, `images/`, `sparse/`, and `stereo/`.

nvs2colmap-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+nvs2colmap/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nvs2colmap/colmap.py,sha256=gWXjLhCq6bXd9djuJMTDe5ityXl8DQvNM6rnbGKOR0o,3334
+nvs2colmap/write_model.py,sha256=ku4l1xBOU8yibrZJvYX32pluLwBovlEepMcPsCj35hk,2244
+nvs2colmap/dynamic3dgs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nvs2colmap/n3dv/__main__.py,sha256=4vBIay787OqKhL3P_DGKr45GwZ1T5ay8qMyolsNhrb4,3851
+nvs2colmap/n3dv/extract_videos.py,sha256=9cngqMXddzVswiYD2gMWvE5KzjMrPrJlcqCSqOxFDvQ,1735
+nvs2colmap/n3dv/poses_bounds.py,sha256=_m0i-vrwW9M5yWFFExKFwjLMtyC13myUVcCg_rAjBh4,2572
+nvs2colmap/stnerf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nvs2colmap/utils/__init__.py,sha256=xzEaKJoUQgx8V6swE2XA0XgE7lCpIbhOQ1tQu_ePHHM,720
+nvs2colmap/utils/colmap.py,sha256=ubfICJLQLc2ZpnntR4sdVMDLo8Xe4nOSGadPwAVfIrA,3441
+nvs2colmap/utils/ffmpeg.py,sha256=hJD9OXx7Qe_gdqGnE0jcuqVoRG8NOSFMTIe2VOlaMKQ,1928
+nvs2colmap/utils/rotation.py,sha256=0kX_jUXwP1Zi305AaKDyLdkIY9rWaldE70Wz7zEE_MM,3701
+nvs2colmap-0.1.0.dist-info/licenses/LICENSE,sha256=FVon4L020BfAcR4lOrma9lvbMf-6AYGcsXD9uKKFAlk,1066
+nvs2colmap-0.1.0.dist-info/METADATA,sha256=xKA7BmmdteT2ObUZ4JuVf1xknCA9XwAPGQm5dtTxbVY,3369
+nvs2colmap-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+nvs2colmap-0.1.0.dist-info/entry_points.txt,sha256=PbwBOs0j_u2YXvZ1kYeoVExCoeTU5BL9VpJhZZJBZL4,66
+nvs2colmap-0.1.0.dist-info/top_level.txt,sha256=SpoGd8Uz0ksy9BkVHl2e6QLQtW6s5YarGkAoTTjDp2k,11
+nvs2colmap-0.1.0.dist-info/RECORD,,

nvs2colmap-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nvs2colmap-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+nvs2colmap-n3dv = nvs2colmap.n3dv.__main__:main

nvs2colmap-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Howard Yin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

nvs2colmap-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+nvs2colmap