nvs2colmap 0.2.0__tar.gz → 0.3.0__tar.gz

{nvs2colmap-0.2.0 → nvs2colmap-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nvs2colmap
-Version: 0.2.0
+Version: 0.3.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>
@@ -34,6 +34,8 @@ Utilities for converting novel view synthesis datasets to COLMAP format.
 
 - **Neural 3D Video Dataset**: scenes with `poses_bounds.npy` and one `mp4`
   file per camera. See `nvs2colmap/n3dv/README.md`.
+- **Dynamic 3D Gaussians**: scenes with `train_meta.json`, `test_meta.json`,
+  images in `ims/`, and masks in `seg/`. See `nvs2colmap/dynamic3dgs/README.md`.
 
 ## Supported Datasets
 
@@ -48,6 +50,10 @@ Utilities for converting novel view synthesis datasets to COLMAP format.
   [liuyubian/Robo360](https://huggingface.co/datasets/liuyubian/Robo360),
   paper
   [Robo360: A 3D Omnispective Multi-Material Robotic Manipulation Dataset](https://arxiv.org/abs/2312.06686).
+- **Dynamic 3D Gaussians**: dataset
+  [JonathonLuiten/Dynamic3DGaussians](https://github.com/JonathonLuiten/Dynamic3DGaussians),
+  paper
+  [Dynamic 3D Gaussians: Tracking by Persistent Dynamic View Synthesis](https://arxiv.org/abs/2308.09713).
 
 ## Quick Start
 
@@ -88,18 +94,36 @@ 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 \
+  --ffmpeg ffmpeg \
+  --ffprobe ffprobe \
   --video-extension MP4 \
   --n-frames 1 \
   --use-colmap \
-  --colmap-executable data/colmap/COLMAP.bat \
+  --colmap-executable colmap \
   --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/`. When
-`--start-number N` is provided, decoding starts from source video frame `N`, and
-the generated folders/images are also numbered from `N`.
+Link a Dynamic 3D Gaussians scene, including its masks, and write per-frame
+COLMAP text models:
+
+```bash
+python -m nvs2colmap.dynamic3dgs \
+  --path data/basketball \
+  --n-frames 150
+```
+
+For Neural 3D Video scenes, decoded frames are written to `frame*/images` by
+default, 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/`. When `--start-number N` is provided, decoding starts
+from source video frame `N`, and the generated folders/images are also numbered
+from `N`.
+
+For Dynamic 3D Gaussians scenes, images from both `train_meta.json` and
+`test_meta.json` are hardlinked into `frame*/images`, and included masks are
+hardlinked into `frame*/image_masks` (`cam01.jpg` pairs with `cam01.jpg.png`).
+`--no-train-camera` and `--no-test-camera` drop one split. The same
+`--use-colmap` switch writes images to `frame*/input` and runs COLMAP.
+`--start-number` uses the same 1-based output numbering; source file
+`000000.jpg` is frame `1`.

{nvs2colmap-0.2.0 → nvs2colmap-0.3.0}/README.md

@@ -6,6 +6,8 @@ Utilities for converting novel view synthesis datasets to COLMAP format.
 
 - **Neural 3D Video Dataset**: scenes with `poses_bounds.npy` and one `mp4`
   file per camera. See `nvs2colmap/n3dv/README.md`.
+- **Dynamic 3D Gaussians**: scenes with `train_meta.json`, `test_meta.json`,
+  images in `ims/`, and masks in `seg/`. See `nvs2colmap/dynamic3dgs/README.md`.
 
 ## Supported Datasets
 
@@ -20,6 +22,10 @@ Utilities for converting novel view synthesis datasets to COLMAP format.
   [liuyubian/Robo360](https://huggingface.co/datasets/liuyubian/Robo360),
   paper
   [Robo360: A 3D Omnispective Multi-Material Robotic Manipulation Dataset](https://arxiv.org/abs/2312.06686).
+- **Dynamic 3D Gaussians**: dataset
+  [JonathonLuiten/Dynamic3DGaussians](https://github.com/JonathonLuiten/Dynamic3DGaussians),
+  paper
+  [Dynamic 3D Gaussians: Tracking by Persistent Dynamic View Synthesis](https://arxiv.org/abs/2308.09713).
 
 ## Quick Start
 
@@ -60,18 +66,36 @@ 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 \
+  --ffmpeg ffmpeg \
+  --ffprobe ffprobe \
   --video-extension MP4 \
   --n-frames 1 \
   --use-colmap \
-  --colmap-executable data/colmap/COLMAP.bat \
+  --colmap-executable colmap \
   --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/`. When
-`--start-number N` is provided, decoding starts from source video frame `N`, and
-the generated folders/images are also numbered from `N`.
+Link a Dynamic 3D Gaussians scene, including its masks, and write per-frame
+COLMAP text models:
+
+```bash
+python -m nvs2colmap.dynamic3dgs \
+  --path data/basketball \
+  --n-frames 150
+```
+
+For Neural 3D Video scenes, decoded frames are written to `frame*/images` by
+default, 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/`. When `--start-number N` is provided, decoding starts
+from source video frame `N`, and the generated folders/images are also numbered
+from `N`.
+
+For Dynamic 3D Gaussians scenes, images from both `train_meta.json` and
+`test_meta.json` are hardlinked into `frame*/images`, and included masks are
+hardlinked into `frame*/image_masks` (`cam01.jpg` pairs with `cam01.jpg.png`).
+`--no-train-camera` and `--no-test-camera` drop one split. The same
+`--use-colmap` switch writes images to `frame*/input` and runs COLMAP.
+`--start-number` uses the same 1-based output numbering; source file
+`000000.jpg` is frame `1`.

{nvs2colmap-0.2.0 → nvs2colmap-0.3.0}/nvs2colmap/colmap.py

@@ -41,7 +41,6 @@ def run_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:

nvs2colmap-0.3.0/nvs2colmap/dynamic3dgs/__main__.py

@@ -0,0 +1,130 @@
+"""Extract Dynamic 3D Gaussians 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 .camera_meta import read_camera_meta
+from .link_frames import count_frame_dirs, link_frames
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Extract a Dynamic 3D Gaussians scene and convert train_meta.json "
+            "and test_meta.json to per-frame COLMAP text models."
+        )
+    )
+    parser.add_argument(
+        "--path",
+        type=Path,
+        required=True,
+        help="Scene directory containing train_meta.json, test_meta.json, ims/, and seg/.",
+    )
+    parser.add_argument(
+        "--n-frames",
+        type=int,
+        help="Number of frames to extract and write. Defaults to the frames listed in the camera metadata.",
+    )
+    parser.add_argument(
+        "--start-number",
+        type=int,
+        default=1,
+        help="1-based source frame to start extracting from; output frame folders use the same starting number.",
+    )
+    parser.add_argument(
+        "--no-train-camera",
+        action="store_true",
+        help="Do not extract cameras listed in train_meta.json.",
+    )
+    parser.add_argument(
+        "--no-test-camera",
+        action="store_true",
+        help="Do not extract cameras listed in test_meta.json.",
+    )
+    parser.add_argument(
+        "--skip-frame-linking",
+        action="store_true",
+        help="Only convert camera metadata 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.",
+    )
+    args = parser.parse_args()
+    if args.no_train_camera and args.no_test_camera:
+        parser.error("Cannot set both --no-train-camera and --no-test-camera.")
+    return args
+
+
+def main() -> None:
+    args = parse_args()
+    folder = args.path.resolve()
+
+    cameras, available_frames = read_camera_meta(
+        folder,
+        include_train=not args.no_train_camera,
+        include_test=not args.no_test_camera,
+    )
+
+    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_frame_linking:
+        if n_frames is None:
+            n_frames = available_frames - args.start_number + 1
+        link_frames(
+            folder=folder,
+            frame_pattern=frame_output_pattern,
+            cameras=cameras,
+            n_frames=n_frames,
+            start_number=args.start_number,
+            image_dirname=image_dir_name,
+        )
+    elif n_frames is None:
+        n_frames = count_frame_dirs(frame_output_pattern, start_number=args.start_number)
+
+    colmap_cameras = [camera.camera for camera in cameras]
+    if not args.use_colmap:
+        write_video_colmap_text_model(
+            output_pattern=frame_output_pattern / "sparse" / "0",
+            cameras=colmap_cameras,
+            n_frames=n_frames,
+            start_number=args.start_number,
+            image_extension="",
+        )
+    else:
+        run_video_colmap(
+            output_pattern=frame_output_pattern,
+            cameras=colmap_cameras,
+            n_frames=n_frames,
+            start_number=args.start_number,
+            image_extension="",
+            colmap_executable=args.colmap_executable,
+            use_gpu=args.colmap_use_gpu,
+        )
+
+    print(f"Done: {folder}")
+
+
+if __name__ == "__main__":
+    main()

nvs2colmap-0.3.0/nvs2colmap/dynamic3dgs/camera_meta.py

@@ -0,0 +1,98 @@
+"""Read Dynamic 3D Gaussians train and test camera metadata."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+import torch
+
+from nvs2colmap.utils import matrix_to_quaternion
+from nvs2colmap.write_model import CameraModel
+
+
+@dataclass(frozen=True)
+class ParsedCameraMeta:
+    """One static camera and the image filenames for each frame."""
+
+    camera: CameraModel
+    filenames: list[str]
+
+
+def read_meta(folder: Path, meta_name: str) -> tuple[list[ParsedCameraMeta], int]:
+    folder = Path(folder)
+    meta_path = folder / meta_name
+    with meta_path.open() as f:
+        camera_meta = json.load(f)
+
+    n_frames = len(camera_meta["fn"])
+    if n_frames == 0:
+        raise ValueError(f"No frames found in {meta_path}")
+    for key in ("k", "w2c", "cam_id"):
+        if any(camera_meta[key][frame_index] != camera_meta[key][0] for frame_index in range(n_frames)):
+            raise ValueError(f"{meta_name} {key} changes across frames.")
+
+    width = int(camera_meta["w"])
+    height = int(camera_meta["h"])
+    cameras = []
+    seen_ids = set()
+    for camera_index, (k, w2c, camera_id) in enumerate(
+        zip(camera_meta["k"][0], camera_meta["w2c"][0], camera_meta["cam_id"][0])
+    ):
+        camera_id = int(camera_id)
+        if camera_id in seen_ids:
+            raise ValueError(f"{meta_name} lists camera {camera_id} more than once.")
+        seen_ids.add(camera_id)
+        filenames = [camera_meta["fn"][frame_index][camera_index] for frame_index in range(n_frames)]
+        w2c_tensor = torch.tensor(w2c, dtype=torch.float64)
+        quaternion = matrix_to_quaternion(w2c_tensor[:3, :3])
+        cameras.append(
+            ParsedCameraMeta(
+                camera=CameraModel(
+                    name=f"cam{camera_id:02d}{Path(filenames[0]).suffix}",
+                    width=width,
+                    height=height,
+                    fx=float(k[0][0]),
+                    fy=float(k[1][1]),
+                    cx=float(k[0][2]),
+                    cy=float(k[1][2]),
+                    qvec=quaternion.detach().cpu().numpy(),
+                    tvec=w2c_tensor[:3, 3].detach().cpu().numpy(),
+                ),
+                filenames=filenames,
+            )
+        )
+    return cameras, n_frames
+
+
+def read_camera_meta(
+    folder: Path,
+    include_train: bool = True,
+    include_test: bool = True,
+) -> tuple[list[ParsedCameraMeta], int]:
+    if not include_train and not include_test:
+        raise ValueError("At least one of train and test cameras must be included.")
+
+    n_frames = None
+    train_cameras, train_n_frames = [], None
+    if include_train:
+        train_cameras, train_n_frames = read_meta(folder, "train_meta.json")
+        n_frames = train_n_frames
+    test_cameras, test_n_frames = [], None
+    if include_test:
+        test_cameras, test_n_frames = read_meta(folder, "test_meta.json")
+        n_frames = test_n_frames
+
+    if include_train and include_test and train_n_frames != test_n_frames:
+        raise ValueError("train_meta.json and test_meta.json list different frame counts.")
+    cameras = train_cameras + test_cameras
+
+    merged: dict[str, ParsedCameraMeta] = {}
+    for camera in cameras:
+        if camera.camera.name in merged:
+            raise ValueError(f"Camera {camera.camera.name} appears in more than one metadata file.")
+        merged[camera.camera.name] = camera
+    if not merged:
+        raise ValueError("No cameras selected.")
+    return [merged[name] for name in sorted(merged)], n_frames

nvs2colmap-0.3.0/nvs2colmap/dynamic3dgs/link_frames.py

@@ -0,0 +1,52 @@
+"""Link Dynamic 3D Gaussians images and masks into per-frame folders."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Sequence
+
+from .camera_meta import ParsedCameraMeta
+
+
+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 link_file(src: Path, dst: Path) -> None:
+    if not src.is_file():
+        raise FileNotFoundError(f"Missing source file: {src}")
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    if dst.exists():
+        dst.unlink()
+    os.link(src, dst)
+
+
+def link_frames(
+    folder: Path,
+    frame_pattern: Path,
+    cameras: Sequence[ParsedCameraMeta],
+    n_frames: int,
+    start_number: int = 1,
+    image_dirname: str = "images",
+) -> None:
+    folder = Path(folder)
+    frame_pattern = str(frame_pattern)
+    for offset in range(n_frames):
+        frame_index = start_number - 1 + offset
+        frame_dir = Path(frame_pattern % (start_number + offset))
+        image_dir = frame_dir / image_dirname
+        mask_dir = frame_dir / "image_masks"
+        for camera in cameras:
+            filename = camera.filenames[frame_index]
+            link_file(folder / "ims" / filename, image_dir / camera.camera.name)
+            mask_src = folder / "seg" / Path(filename).with_suffix(".png")
+            if mask_src.is_file():
+                link_file(mask_src, mask_dir / f"{camera.camera.name}.png")

nvs2colmap-0.3.0/nvs2colmap/extract_videos.py

@@ -0,0 +1,117 @@
+"""Extract one or more videos into per-frame image folders."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from nvs2colmap.utils import extract_video_frames_parallel
+
+
+def extract_videos(
+    video_paths: list[Path],
+    output_pattern: Path,
+    start_number: int = 1,
+    n_frames: int | None = None,
+    ffmpeg_executable: str = "ffmpeg",
+    ffprobe_executable: str = "ffprobe",
+    ffmpeg_processes: int = 1,
+    image_extension: str = ".png",
+) -> int:
+    if not image_extension.startswith("."):
+        image_extension = f".{image_extension}"
+
+    jobs = []
+    for index, video_path in enumerate(video_paths, start=1):
+        if not video_path.is_file():
+            raise FileNotFoundError(f"Missing video file: {video_path}")
+        jobs.append((video_path, str(output_pattern / f"{index:04d}{image_extension}")))
+
+    if not jobs:
+        raise ValueError("At least one video path is required.")
+
+    extracted_frame_counts = extract_video_frames_parallel(
+        jobs,
+        start_number=start_number,
+        n_frames=n_frames,
+        ffmpeg_executable=ffmpeg_executable,
+        ffprobe_executable=ffprobe_executable,
+        process_count=ffmpeg_processes,
+    )
+    return max(extracted_frame_counts)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Extract videos into frame folders. For input videos v1.mp4 v2.mp4 "
+            "and --output-pattern 'frame%d/images', extracted images are named "
+            "frame1/images/0001.png, frame1/images/0002.png, etc."
+        )
+    )
+    parser.add_argument(
+        "videos",
+        type=Path,
+        nargs="+",
+        help="Video files to extract. Image names follow this input order.",
+    )
+    parser.add_argument(
+        "--output-pattern",
+        type=Path,
+        required=True,
+        help="Per-frame output directory pattern, for example 'frame%%d/images'.",
+    )
+    parser.add_argument(
+        "--n-frames",
+        type=int,
+        help="Number of frames to extract. Defaults to each video's available frame count.",
+    )
+    parser.add_argument(
+        "--start-number",
+        type=int,
+        default=1,
+        help="1-based source frame to start extracting from; output frame folders use the same starting number.",
+    )
+    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(
+        "--ffmpeg-processes",
+        type=int,
+        default=1,
+        help="Number of ffmpeg processes to run in parallel.",
+    )
+    parser.add_argument(
+        "--image-extension",
+        default=".png",
+        help="Image extension written by ffmpeg.",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    n_frames = extract_videos(
+        video_paths=args.videos,
+        output_pattern=args.output_pattern,
+        start_number=args.start_number,
+        n_frames=args.n_frames,
+        ffmpeg_executable=args.ffmpeg_executable,
+        ffprobe_executable=args.ffprobe_executable,
+        ffmpeg_processes=args.ffmpeg_processes,
+        image_extension=args.image_extension,
+    )
+    print(f"Done: extracted up to {n_frames} frames per video.")
+
+
+if __name__ == "__main__":
+    main()

{nvs2colmap-0.2.0 → nvs2colmap-0.3.0}/nvs2colmap.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nvs2colmap
-Version: 0.2.0
+Version: 0.3.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>
@@ -34,6 +34,8 @@ Utilities for converting novel view synthesis datasets to COLMAP format.
 
 - **Neural 3D Video Dataset**: scenes with `poses_bounds.npy` and one `mp4`
   file per camera. See `nvs2colmap/n3dv/README.md`.
+- **Dynamic 3D Gaussians**: scenes with `train_meta.json`, `test_meta.json`,
+  images in `ims/`, and masks in `seg/`. See `nvs2colmap/dynamic3dgs/README.md`.
 
 ## Supported Datasets
 
@@ -48,6 +50,10 @@ Utilities for converting novel view synthesis datasets to COLMAP format.
   [liuyubian/Robo360](https://huggingface.co/datasets/liuyubian/Robo360),
   paper
   [Robo360: A 3D Omnispective Multi-Material Robotic Manipulation Dataset](https://arxiv.org/abs/2312.06686).
+- **Dynamic 3D Gaussians**: dataset
+  [JonathonLuiten/Dynamic3DGaussians](https://github.com/JonathonLuiten/Dynamic3DGaussians),
+  paper
+  [Dynamic 3D Gaussians: Tracking by Persistent Dynamic View Synthesis](https://arxiv.org/abs/2308.09713).
 
 ## Quick Start
 
@@ -88,18 +94,36 @@ 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 \
+  --ffmpeg ffmpeg \
+  --ffprobe ffprobe \
   --video-extension MP4 \
   --n-frames 1 \
   --use-colmap \
-  --colmap-executable data/colmap/COLMAP.bat \
+  --colmap-executable colmap \
   --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/`. When
-`--start-number N` is provided, decoding starts from source video frame `N`, and
-the generated folders/images are also numbered from `N`.
+Link a Dynamic 3D Gaussians scene, including its masks, and write per-frame
+COLMAP text models:
+
+```bash
+python -m nvs2colmap.dynamic3dgs \
+  --path data/basketball \
+  --n-frames 150
+```
+
+For Neural 3D Video scenes, decoded frames are written to `frame*/images` by
+default, 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/`. When `--start-number N` is provided, decoding starts
+from source video frame `N`, and the generated folders/images are also numbered
+from `N`.
+
+For Dynamic 3D Gaussians scenes, images from both `train_meta.json` and
+`test_meta.json` are hardlinked into `frame*/images`, and included masks are
+hardlinked into `frame*/image_masks` (`cam01.jpg` pairs with `cam01.jpg.png`).
+`--no-train-camera` and `--no-test-camera` drop one split. The same
+`--use-colmap` switch writes images to `frame*/input` and runs COLMAP.
+`--start-number` uses the same 1-based output numbering; source file
+`000000.jpg` is frame `1`.

{nvs2colmap-0.2.0 → nvs2colmap-0.3.0}/nvs2colmap.egg-info/SOURCES.txt

@@ -3,8 +3,11 @@ README.md
 pyproject.toml
 ./nvs2colmap/__init__.py
 ./nvs2colmap/colmap.py
+./nvs2colmap/extract_videos.py
 ./nvs2colmap/write_model.py
-./nvs2colmap/dynamic3dgs/__init__.py
+./nvs2colmap/dynamic3dgs/__main__.py
+./nvs2colmap/dynamic3dgs/camera_meta.py
+./nvs2colmap/dynamic3dgs/link_frames.py
 ./nvs2colmap/n3dv/__main__.py
 ./nvs2colmap/n3dv/extract_videos.py
 ./nvs2colmap/n3dv/poses_bounds.py
@@ -15,6 +18,7 @@ pyproject.toml
 ./nvs2colmap/utils/rotation.py
 nvs2colmap/__init__.py
 nvs2colmap/colmap.py
+nvs2colmap/extract_videos.py
 nvs2colmap/write_model.py
 nvs2colmap.egg-info/PKG-INFO
 nvs2colmap.egg-info/SOURCES.txt
@@ -22,7 +26,9 @@ nvs2colmap.egg-info/dependency_links.txt
 nvs2colmap.egg-info/entry_points.txt
 nvs2colmap.egg-info/requires.txt
 nvs2colmap.egg-info/top_level.txt
-nvs2colmap/dynamic3dgs/__init__.py
+nvs2colmap/dynamic3dgs/__main__.py
+nvs2colmap/dynamic3dgs/camera_meta.py
+nvs2colmap/dynamic3dgs/link_frames.py
 nvs2colmap/n3dv/__main__.py
 nvs2colmap/n3dv/extract_videos.py
 nvs2colmap/n3dv/poses_bounds.py

nvs2colmap-0.3.0/nvs2colmap.egg-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+nvs2colmap-dynamic3dgs = nvs2colmap.dynamic3dgs.__main__:main
+nvs2colmap-extract-videos = nvs2colmap.extract_videos:main
+nvs2colmap-n3dv = nvs2colmap.n3dv.__main__:main

{nvs2colmap-0.2.0 → nvs2colmap-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nvs2colmap"
-version = "0.2.0"
+version = "0.3.0"
 description = "Utilities for converting novel view synthesis datasets to COLMAP format."
 readme = "README.md"
 authors = [{ name = "Howard Yin", email = "yindaheng98@gmail.com" }]
@@ -41,7 +41,9 @@ Repository = "https://github.com/yindaheng98/NVS2COLMAP"
 Issues = "https://github.com/yindaheng98/NVS2COLMAP/issues"
 
 [project.scripts]
+nvs2colmap-extract-videos = "nvs2colmap.extract_videos:main"
 nvs2colmap-n3dv = "nvs2colmap.n3dv.__main__:main"
+nvs2colmap-dynamic3dgs = "nvs2colmap.dynamic3dgs.__main__:main"
 
 [tool.setuptools]
 packages = { find = { include = ["nvs2colmap*"] } }

nvs2colmap-0.2.0/nvs2colmap.egg-info/entry_points.txt

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