Upload folder using huggingface_hub

README.md

@@ -0,0 +1,213 @@
+---
+license: cc0-1.0
+task_categories:
+  - image-to-3d
+  - depth-estimation
+tags:
+  - nerf
+  - 3d-gaussian-splatting
+  - 3dgs
+  - nerfstudio
+  - multi-view
+  - depth-maps
+  - normal-maps
+  - point-cloud
+  - computer-vision
+  - 3d-reconstruction
+pretty_name: "DX.GL Multi-View Datasets"
+size_categories:
+  - 1K<n<10K
+---
+
+# DX.GL Multi-View Datasets for NeRF & 3D Gaussian Splatting
+
+Multi-view training datasets rendered from CC0 3D models via [DX.GL](https://dx.gl). Each dataset includes calibrated camera poses, depth maps, normal maps, binary masks, and point clouds — ready for [nerfstudio](https://docs.nerf.studio/) out of the box.
+
+**10 objects × 196 views × 1024×1024 resolution × full sphere coverage.**
+
+## Quick Start
+
+```bash
+# Download a dataset (Apple, 196 views, 1024x1024)
+wget https://dx.gl/api/v/EJbs8npt2RVM/vCHDLxjWG65d/dataset -O apple.zip
+unzip apple.zip -d apple
+
+# Train with nerfstudio
+pip install nerfstudio
+ns-train splatfacto --data ./apple \
+  --max-num-iterations 20000 \
+  --pipeline.model.sh-degree 3 \
+  --pipeline.model.background-color white
+```
+
+Or use the download script:
+
+```bash
+pip install requests
+python download_all.py
+```
+
+## What's in Each Dataset ZIP
+
+```
+dataset/
+├── images/           # RGB frames (PNG, transparent background)
+│   ├── frame_00000.png
+│   └── ...
+├── depth/            # 8-bit grayscale depth maps
+├── depth_16bit/      # 16-bit grayscale depth maps (higher precision)
+├── normals/          # World-space normal maps
+├── masks/            # Binary alpha masks
+├── transforms.json   # Camera poses (nerfstudio / instant-ngp format)
+└── points3D.ply      # Sparse point cloud for initialization
+```
+
+### transforms.json Format
+
+Compatible with both **nerfstudio** and **instant-ngp**:
+
+```json
+{
+  "camera_angle_x": 0.857,
+  "camera_angle_y": 0.857,
+  "fl_x": 693.5,
+  "fl_y": 693.5,
+  "cx": 400,
+  "cy": 400,
+  "w": 800,
+  "h": 800,
+  "depth_near": 0.85,
+  "depth_far": 2.35,
+  "ply_file_path": "points3D.ply",
+  "frames": [
+    {
+      "file_path": "images/frame_00000.png",
+      "depth_file_path": "depth/frame_00000.png",
+      "normal_file_path": "normals/frame_00000.png",
+      "mask_file_path": "masks/frame_00000.png",
+      "transform_matrix": [[...], [...], [...], [0, 0, 0, 1]]
+    }
+  ]
+}
+```
+
+## Specs
+
+| Property | Value |
+|---|---|
+| **Views** | 196 per object |
+| **Resolution** | 1024×1024 |
+| **Coverage** | Full sphere (±89° elevation) |
+| **Point cloud** | ~200k points |
+| **Camera distribution** | Fibonacci golden-angle spiral |
+| **Background** | Transparent (RGBA) |
+| **Lighting** | Studio HDRI + directional lights |
+
+## Camera Distribution
+
+Views are distributed on a full sphere (±89° elevation) using a golden-angle Fibonacci spiral. The distribution is uniform in solid angle — more views near the equator, fewer near the poles — optimized for NeRF/3DGS training.
+
+![Camera Distribution](camera-distribution.png)
+
+## Objects
+
+| # | Object | Category | Download | Browse |
+|---|---|---|---|---|
+| 1 | Apple | organic | [ZIP](https://dx.gl/api/v/EJbs8npt2RVM/vCHDLxjWG65d/dataset) | [View](https://dx.gl/datasets/vCHDLxjWG65d) |
+| 2 | Cash Register | electronics | [ZIP](https://dx.gl/api/v/EJbs8npt2RVM/JfjLRexr6J7z/dataset) | [View](https://dx.gl/datasets/JfjLRexr6J7z) |
+| 3 | Drill | tool | [ZIP](https://dx.gl/api/v/EJbs8npt2RVM/A0dcsk7HHgAg/dataset) | [View](https://dx.gl/datasets/A0dcsk7HHgAg) |
+| 4 | Fire Extinguisher | metallic | [ZIP](https://dx.gl/api/v/EJbs8npt2RVM/cLgyqM5mhQoq/dataset) | [View](https://dx.gl/datasets/cLgyqM5mhQoq) |
+| 5 | LED Lightbulb | glass | [ZIP](https://dx.gl/api/v/EJbs8npt2RVM/ZuYmv3K9xN7u/dataset) | [View](https://dx.gl/datasets/ZuYmv3K9xN7u) |
+| 6 | Measuring Tape | tool | [ZIP](https://dx.gl/api/v/EJbs8npt2RVM/qqvDYx7RtHZd/dataset) | [View](https://dx.gl/datasets/qqvDYx7RtHZd) |
+| 7 | Modern Arm Chair | furniture | [ZIP](https://dx.gl/api/v/EJbs8npt2RVM/KLBJAuie9JaB/dataset) | [View](https://dx.gl/datasets/KLBJAuie9JaB) |
+| 8 | Multi Cleaner 5L | product | [ZIP](https://dx.gl/api/v/EJbs8npt2RVM/79gDW15Gw9Ft/dataset) | [View](https://dx.gl/datasets/79gDW15Gw9Ft) |
+| 9 | Potted Plant | organic | [ZIP](https://dx.gl/api/v/EJbs8npt2RVM/o4c5zRyGuT7W/dataset) | [View](https://dx.gl/datasets/o4c5zRyGuT7W) |
+| 10 | Wet Floor Sign | plastic | [ZIP](https://dx.gl/api/v/EJbs8npt2RVM/tHdRul1GzzoU/dataset) | [View](https://dx.gl/datasets/tHdRul1GzzoU) |
+
+All source models from [Polyhaven](https://polyhaven.com) (CC0).
+
+## Pre-trained 3DGS Splats
+
+We include pre-trained Gaussian Splat `.ply` files (nerfstudio splatfacto, 20k iterations, SH degree 3) for each object. Download them with:
+
+```bash
+python download_all.py --splats
+```
+
+Or view them directly:
+
+- [DX.GL Splat Viewer](https://dx.gl/splat/index.html) (all 10 models, use ← → to browse)
+- [SuperSplat Editor](https://superspl.at/editor) (drag-drop the .ply)
+- nerfstudio viewer: `ns-viewer --load-config outputs/*/config.yml`
+
+### Training Parameters
+
+```bash
+ns-train splatfacto --data ./dataset \
+  --max-num-iterations 20000 \
+  --pipeline.model.sh-degree 3 \
+  --pipeline.model.background-color white \
+  --pipeline.model.cull-alpha-thresh 0.2 \
+  --pipeline.model.densify-size-thresh 0.005 \
+  --pipeline.model.use-scale-regularization True \
+  --pipeline.model.max-gauss-ratio 5.0
+```
+
+Training time: ~10 minutes on RTX 4000 Pro Ada (70W) at the 196×1024 tier.
+
+## Rendering Pipeline
+
+Datasets are rendered using [DX.GL](https://dx.gl)'s cloud GPU rendering pipeline:
+
+- **Lighting**: Studio HDRI environment with PBR materials
+- **Camera**: Fibonacci golden-angle sphere distribution
+- **Depth**: Tight near/far planes from model bounding sphere for maximum precision
+- **Point cloud**: Back-projected from depth maps, ~1000 points per view
+- **Background**: Transparent (RGBA)
+
+## Modalities
+
+| Modality | Format | Notes |
+|---|---|---|
+| **RGB** | PNG, RGBA | Transparent background, PBR-lit |
+| **Depth (8-bit)** | PNG, grayscale | Normalized to near/far range |
+| **Depth (16-bit)** | PNG, grayscale | RG-encoded, higher precision |
+| **Normals** | PNG, RGB | World-space, MeshNormalMaterial |
+| **Masks** | PNG, grayscale | Binary alpha from RGB alpha channel |
+| **Point Cloud** | PLY, binary | XYZ + RGB, ~100k points |
+| **Camera Poses** | JSON | 4×4 camera-to-world matrices |
+
+## License
+
+All source 3D models are **CC0** (public domain) from [Polyhaven](https://polyhaven.com). The rendered datasets inherit this license — use them for anything, no attribution required.
+
+## Citation
+
+```bibtex
+@misc{dxgl_multiview_2026,
+  title  = {DX.GL Multi-View Datasets for NeRF and 3D Gaussian Splatting},
+  author = {DXGL},
+  year   = {2026},
+  url    = {https://huggingface.co/datasets/dxgl/multiview-datasets},
+  note   = {Multi-view datasets with depth, normals, masks, and point clouds. Rendered via DX.GL.}
+}
+```
+
+## Links
+
+- **This collection**: [dx.gl/datasets/polyhaven-10](https://dx.gl/datasets/polyhaven-10)
+- **Browse all datasets**: [dx.gl/datasets](https://dx.gl/datasets)
+- **Pipeline details**: [dx.gl/for-research](https://dx.gl/for-research)
+- **API documentation**: [dx.gl/portal/docs](https://dx.gl/portal/docs)
+- **Generate your own**: [dx.gl/signup](https://dx.gl/signup) (2 free renders included)
+
+## Feedback
+
+We're actively improving the rendering pipeline. If you find issues with depth accuracy, mask quality, camera calibration, or view distribution — please open a Discussion on this repo. Specific feedback we're looking for:
+
+- Depth map accuracy at object edges
+- Mask quality for transparent/reflective materials
+- Point cloud alignment with RGB views
+- View distribution quality for your training method
+- Missing modalities or metadata
+- Any other issues or suggestions?

download_all.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""
+Download DX.GL multi-view datasets from the manifest.
+
+Usage:
+  python download_all.py                           # download all datasets
+  python download_all.py --object apple            # specific object
+  python download_all.py --output ./datasets       # custom output directory
+  python download_all.py --splats                  # also download pre-trained .ply splats
+
+Requires: pip install requests
+"""
+
+import argparse
+import json
+import os
+import sys
+
+try:
+    import requests
+except ImportError:
+    print("Please install requests: pip install requests")
+    sys.exit(1)
+
+MANIFEST_URL = "https://huggingface.co/datasets/dxgl/multiview-datasets/resolve/main/manifest.json"
+MANIFEST_LOCAL = os.path.join(os.path.dirname(os.path.abspath(__file__)), "manifest.json")
+
+
+def load_manifest():
+    """Load manifest from local file or download from HuggingFace."""
+    if os.path.exists(MANIFEST_LOCAL):
+        with open(MANIFEST_LOCAL) as f:
+            return json.load(f)
+    print(f"Downloading manifest from {MANIFEST_URL} ...")
+    resp = requests.get(MANIFEST_URL)
+    resp.raise_for_status()
+    return resp.json()
+
+
+def download_file(url, dest_path):
+    """Download a file with progress display."""
+    resp = requests.get(url, stream=True)
+    resp.raise_for_status()
+    total = int(resp.headers.get("content-length", 0))
+    downloaded = 0
+    with open(dest_path, "wb") as f:
+        for chunk in resp.iter_content(chunk_size=1 << 20):
+            f.write(chunk)
+            downloaded += len(chunk)
+            if total > 0:
+                pct = downloaded / total * 100
+                mb = downloaded / 1e6
+                print(f"\r  {mb:.1f} MB ({pct:.0f}%)", end="", flush=True)
+    print()
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Download DX.GL multi-view datasets")
+    parser.add_argument("--object", default=None,
+                        help="Download only a specific object (by name, case-insensitive)")
+    parser.add_argument("--output", default="./dxgl-datasets",
+                        help="Output directory (default: ./dxgl-datasets)")
+    parser.add_argument("--splats", action="store_true",
+                        help="Also download pre-trained 3DGS .ply files")
+    parser.add_argument("--extract", action="store_true", default=True,
+                        help="Extract ZIPs after download (default: true)")
+    parser.add_argument("--no-extract", action="store_true",
+                        help="Keep ZIPs without extracting")
+    args = parser.parse_args()
+
+    manifest = load_manifest()
+    objects = manifest["objects"]
+
+    # Filter by object name
+    if args.object:
+        objects = [o for o in objects if args.object.lower() in o["name"].lower()]
+        if not objects:
+            print(f"No object matching '{args.object}' found in manifest.")
+            sys.exit(1)
+
+    os.makedirs(args.output, exist_ok=True)
+
+    total_downloads = 0
+    for obj in objects:
+        name_slug = obj["name"].lower().replace(" ", "_")
+        filename = f"{name_slug}.zip"
+        dest_path = os.path.join(args.output, filename)
+
+        if os.path.exists(dest_path):
+            print(f"  Skipping {filename} (already exists)")
+            continue
+
+        print(f"Downloading {obj['name']} ...")
+        download_file(obj["download_url"], dest_path)
+        total_downloads += 1
+
+        # Extract
+        if args.extract and not args.no_extract:
+            import zipfile
+            extract_dir = os.path.join(args.output, name_slug)
+            os.makedirs(extract_dir, exist_ok=True)
+            with zipfile.ZipFile(dest_path) as zf:
+                zf.extractall(extract_dir)
+            print(f"  Extracted to {extract_dir}")
+
+    # Download splats
+    if args.splats:
+        splats_dir = os.path.join(args.output, "splats")
+        os.makedirs(splats_dir, exist_ok=True)
+        for obj in objects:
+            if "splat_url" not in obj or not obj["splat_url"]:
+                continue
+            name_slug = obj["name"].lower().replace(" ", "_")
+            dest_path = os.path.join(splats_dir, f"{name_slug}.ply")
+            if os.path.exists(dest_path):
+                print(f"  Skipping {name_slug}.ply (already exists)")
+                continue
+            print(f"Downloading splat: {obj['name']} ...")
+            download_file(obj["splat_url"], dest_path)
+            total_downloads += 1
+
+    print(f"\nDone. Downloaded {total_downloads} files to {args.output}")
+    if total_downloads == 0:
+        print("(All files already existed — delete them to re-download)")
+
+
+if __name__ == "__main__":
+    main()

manifest.json

@@ -0,0 +1,114 @@
+{
+  "name": "dxgl-multiview-datasets",
+  "version": "1.0",
+  "description": "Multi-view datasets rendered from CC0 3D models via DX.GL. Calibrated cameras with RGB, depth, normals, masks, and point clouds.",
+  "pipeline": "DX.GL GPU Renderer",
+  "format": "nerfstudio / instant-ngp (transforms.json)",
+  "coverage": "sphere",
+  "modalities": ["rgb", "depth_8bit", "depth_16bit", "normals", "masks", "pointcloud", "camera_poses"],
+  "license": "CC0-1.0",
+  "source": "Polyhaven (polyhaven.com)",
+  "tier": { "views": 196, "resolution": "1024x1024", "points": 200000 },
+  "objects": [
+    {
+      "name": "Apple",
+      "source_url": "https://polyhaven.com/a/food_apple_01",
+      "license": "CC0",
+      "category": "organic",
+      "render_id": "vCHDLxjWG65d",
+      "download_url": "https://dx.gl/api/v/EJbs8npt2RVM/vCHDLxjWG65d/dataset",
+      "dataset_url": "https://dx.gl/datasets/vCHDLxjWG65d",
+      "splat_url": "https://dx.gl/splat/apple.ply"
+    },
+    {
+      "name": "Cash Register",
+      "source_url": "https://polyhaven.com/a/cash_register",
+      "license": "CC0",
+      "category": "electronics",
+      "render_id": "JfjLRexr6J7z",
+      "download_url": "https://dx.gl/api/v/EJbs8npt2RVM/JfjLRexr6J7z/dataset",
+      "dataset_url": "https://dx.gl/datasets/JfjLRexr6J7z",
+      "splat_url": "https://dx.gl/splat/cash_register.ply"
+    },
+    {
+      "name": "Drill",
+      "source_url": "https://polyhaven.com/a/drill",
+      "license": "CC0",
+      "category": "tool",
+      "render_id": "A0dcsk7HHgAg",
+      "download_url": "https://dx.gl/api/v/EJbs8npt2RVM/A0dcsk7HHgAg/dataset",
+      "dataset_url": "https://dx.gl/datasets/A0dcsk7HHgAg",
+      "splat_url": "https://dx.gl/splat/drill.ply"
+    },
+    {
+      "name": "Fire Extinguisher",
+      "source_url": "https://polyhaven.com/a/korean_fire_extinguisher",
+      "license": "CC0",
+      "category": "metallic",
+      "render_id": "cLgyqM5mhQoq",
+      "download_url": "https://dx.gl/api/v/EJbs8npt2RVM/cLgyqM5mhQoq/dataset",
+      "dataset_url": "https://dx.gl/datasets/cLgyqM5mhQoq",
+      "splat_url": "https://dx.gl/splat/fire_extinguisher.ply"
+    },
+    {
+      "name": "LED Lightbulb",
+      "source_url": "https://polyhaven.com/a/lightbulb_led",
+      "license": "CC0",
+      "category": "glass",
+      "render_id": "ZuYmv3K9xN7u",
+      "download_url": "https://dx.gl/api/v/EJbs8npt2RVM/ZuYmv3K9xN7u/dataset",
+      "dataset_url": "https://dx.gl/datasets/ZuYmv3K9xN7u",
+      "splat_url": "https://dx.gl/splat/led_lightbulb.ply"
+    },
+    {
+      "name": "Measuring Tape",
+      "source_url": "https://polyhaven.com/a/measuring_tape",
+      "license": "CC0",
+      "category": "tool",
+      "render_id": "qqvDYx7RtHZd",
+      "download_url": "https://dx.gl/api/v/EJbs8npt2RVM/qqvDYx7RtHZd/dataset",
+      "dataset_url": "https://dx.gl/datasets/qqvDYx7RtHZd",
+      "splat_url": "https://dx.gl/splat/measuring_tape.ply"
+    },
+    {
+      "name": "Modern Arm Chair",
+      "source_url": "https://polyhaven.com/a/modern_arm_chair",
+      "license": "CC0",
+      "category": "furniture",
+      "render_id": "KLBJAuie9JaB",
+      "download_url": "https://dx.gl/api/v/EJbs8npt2RVM/KLBJAuie9JaB/dataset",
+      "dataset_url": "https://dx.gl/datasets/KLBJAuie9JaB",
+      "splat_url": "https://dx.gl/splat/modern_arm_chair.ply"
+    },
+    {
+      "name": "Multi Cleaner 5L",
+      "source_url": "https://polyhaven.com/a/multi_cleaner_5_litre",
+      "license": "CC0",
+      "category": "product",
+      "render_id": "79gDW15Gw9Ft",
+      "download_url": "https://dx.gl/api/v/EJbs8npt2RVM/79gDW15Gw9Ft/dataset",
+      "dataset_url": "https://dx.gl/datasets/79gDW15Gw9Ft",
+      "splat_url": "https://dx.gl/splat/multi_cleaner_5l.ply"
+    },
+    {
+      "name": "Potted Plant",
+      "source_url": "https://polyhaven.com/a/potted_plant",
+      "license": "CC0",
+      "category": "organic",
+      "render_id": "o4c5zRyGuT7W",
+      "download_url": "https://dx.gl/api/v/EJbs8npt2RVM/o4c5zRyGuT7W/dataset",
+      "dataset_url": "https://dx.gl/datasets/o4c5zRyGuT7W",
+      "splat_url": "https://dx.gl/splat/potted_plant.ply"
+    },
+    {
+      "name": "Wet Floor Sign",
+      "source_url": "https://polyhaven.com/a/wet_floor_sign",
+      "license": "CC0",
+      "category": "plastic",
+      "render_id": "tHdRul1GzzoU",
+      "download_url": "https://dx.gl/api/v/EJbs8npt2RVM/tHdRul1GzzoU/dataset",
+      "dataset_url": "https://dx.gl/datasets/tHdRul1GzzoU",
+      "splat_url": "https://dx.gl/splat/wet_floor_sign.ply"
+    }
+  ]
+}

train_all.py

@@ -0,0 +1,351 @@
+#!/usr/bin/env python3
+"""
+Train 3D Gaussian Splats for all DX.GL multi-view datasets.
+
+Downloads datasets (if needed), trains each with nerfstudio splatfacto,
+exports the PLY, and converts to .splat for web viewers.
+
+Usage:
+  python train_all.py                              # train all objects
+  python train_all.py --object apple               # train specific object
+  python train_all.py --data-dir ./dxgl-datasets   # custom dataset location
+  python train_all.py --output ./splats            # custom output directory
+  python train_all.py --iterations 30000           # custom iteration count
+  python train_all.py --dry-run                    # show what would be trained
+
+Requires:
+  pip install nerfstudio requests plyfile numpy
+"""
+
+import argparse
+import glob
+import json
+import os
+import struct
+import subprocess
+import sys
+import time
+
+try:
+    import numpy as np
+    from plyfile import PlyData
+except ImportError:
+    print("Please install dependencies: pip install plyfile numpy requests")
+    sys.exit(1)
+
+MANIFEST_LOCAL = os.path.join(os.path.dirname(os.path.abspath(__file__)), "manifest.json")
+
+# Validated training params (from tuning on RTX 4000 Pro Ada)
+DEFAULT_ITERATIONS = 20000
+TRAIN_PARAMS = [
+    "--pipeline.model.sh-degree", "3",
+    "--pipeline.model.background-color", "white",
+    "--pipeline.model.cull-alpha-thresh", "0.2",
+    "--pipeline.model.densify-size-thresh", "0.005",
+    "--pipeline.model.use-scale-regularization", "True",
+    "--pipeline.model.max-gauss-ratio", "5.0",
+]
+
+
+# ── PLY → .splat conversion (from scripts/ply-to-splat.py) ──────────────
+
+SH_C0 = 0.28209479177387814  # 1 / (2 * sqrt(pi))
+
+
+def _ply_field(v, *names):
+    """Find the first matching field name in PLY vertex data."""
+    available = v.data.dtype.names if hasattr(v.data, "dtype") else v.dtype.names
+    for name in names:
+        if name in available:
+            return v[name]
+    raise KeyError(f"No field matching: {names}. Available: {available}")
+
+
+def ply_to_splat(input_path: str, output_path: str):
+    """Convert a nerfstudio Gaussian Splatting PLY to .splat format."""
+    ply = PlyData.read(input_path)
+    v = ply["vertex"]
+    n = len(v)
+
+    xyz = np.column_stack([v["x"], v["y"], v["z"]]).astype(np.float32)
+
+    s0 = _ply_field(v, "f_scale_0", "scale_0", "sx")
+    s1 = _ply_field(v, "f_scale_1", "scale_1", "sy")
+    s2 = _ply_field(v, "f_scale_2", "scale_2", "sz")
+    scales = np.exp(np.column_stack([s0, s1, s2])).astype(np.float32)
+
+    raw_opacity = _ply_field(v, "opacity", "f_opacity")
+    opacity = (1.0 / (1.0 + np.exp(-raw_opacity.astype(np.float64)))).astype(np.float64)
+
+    dc0 = _ply_field(v, "f_dc_0", "f_rest_0", "red")
+    dc1 = _ply_field(v, "f_dc_1", "f_rest_1", "green")
+    dc2 = _ply_field(v, "f_dc_2", "f_rest_2", "blue")
+    if dc0.max() > 10:
+        r = np.clip(dc0, 0, 255).astype(np.uint8)
+        g = np.clip(dc1, 0, 255).astype(np.uint8)
+        b = np.clip(dc2, 0, 255).astype(np.uint8)
+    else:
+        r = np.clip((0.5 + SH_C0 * dc0) * 255, 0, 255).astype(np.uint8)
+        g = np.clip((0.5 + SH_C0 * dc1) * 255, 0, 255).astype(np.uint8)
+        b = np.clip((0.5 + SH_C0 * dc2) * 255, 0, 255).astype(np.uint8)
+    a = np.clip(opacity * 255, 0, 255).astype(np.uint8)
+
+    qw = _ply_field(v, "rot_0", "qw", "f_rot_0").astype(np.float64)
+    qx = _ply_field(v, "rot_1", "qx", "f_rot_1").astype(np.float64)
+    qy = _ply_field(v, "rot_2", "qy", "f_rot_2").astype(np.float64)
+    qz = _ply_field(v, "rot_3", "qz", "f_rot_3").astype(np.float64)
+    norm = np.sqrt(qw * qw + qx * qx + qy * qy + qz * qz)
+    qw /= norm; qx /= norm; qy /= norm; qz /= norm
+    rot_x = np.clip(qx * 128 + 128, 0, 255).astype(np.uint8)
+    rot_y = np.clip(qy * 128 + 128, 0, 255).astype(np.uint8)
+    rot_z = np.clip(qz * 128 + 128, 0, 255).astype(np.uint8)
+    rot_w = np.clip(qw * 128 + 128, 0, 255).astype(np.uint8)
+
+    order = np.argsort(-opacity)
+
+    buf = bytearray(n * 32)
+    for i in range(n):
+        idx = order[i]
+        off = i * 32
+        struct.pack_into("3f", buf, off, xyz[idx, 0], xyz[idx, 1], xyz[idx, 2])
+        struct.pack_into("3f", buf, off + 12, scales[idx, 0], scales[idx, 1], scales[idx, 2])
+        buf[off + 24] = r[idx]
+        buf[off + 25] = g[idx]
+        buf[off + 26] = b[idx]
+        buf[off + 27] = a[idx]
+        buf[off + 28] = rot_w[idx]
+        buf[off + 29] = rot_x[idx]
+        buf[off + 30] = rot_y[idx]
+        buf[off + 31] = rot_z[idx]
+
+    with open(output_path, "wb") as f:
+        f.write(buf)
+
+    ply_mb = os.path.getsize(input_path) / 1e6
+    splat_mb = len(buf) / 1e6
+    return n, ply_mb, splat_mb
+
+
+# ── Nerfstudio helpers ───────────────────────────────────────────────────
+
+def find_latest_config(output_base: str, experiment_name: str):
+    """Find the most recent config.yml from nerfstudio outputs."""
+    pattern = os.path.join(output_base, experiment_name, "splatfacto", "*", "config.yml")
+    configs = sorted(glob.glob(pattern))
+    if not configs:
+        return None
+    return configs[-1]  # latest timestamp
+
+
+def train_splatfacto(data_dir: str, experiment_name: str, output_base: str,
+                     max_iterations: int):
+    """Run ns-train splatfacto for a single dataset."""
+    cmd = [
+        "ns-train", "splatfacto",
+        "--data", data_dir,
+        "--output-dir", output_base,
+        "--experiment-name", experiment_name,
+        "--max-num-iterations", str(max_iterations),
+        *TRAIN_PARAMS,
+    ]
+    print(f"  Command: {' '.join(cmd)}")
+    result = subprocess.run(cmd)
+    if result.returncode != 0:
+        raise RuntimeError(f"ns-train failed with exit code {result.returncode}")
+
+
+def export_ply(config_path: str, export_dir: str):
+    """Run ns-export gaussian-splat to get the PLY file."""
+    os.makedirs(export_dir, exist_ok=True)
+    cmd = [
+        "ns-export", "gaussian-splat",
+        "--load-config", config_path,
+        "--output-dir", export_dir,
+    ]
+    print(f"  Export command: {' '.join(cmd)}")
+    result = subprocess.run(cmd)
+    if result.returncode != 0:
+        raise RuntimeError(f"ns-export failed with exit code {result.returncode}")
+
+    # ns-export writes splat.ply in the output dir
+    ply_path = os.path.join(export_dir, "splat.ply")
+    if not os.path.exists(ply_path):
+        # Some versions write point_cloud.ply
+        alt = os.path.join(export_dir, "point_cloud.ply")
+        if os.path.exists(alt):
+            return alt
+        raise FileNotFoundError(f"No PLY found in {export_dir}")
+    return ply_path
+
+
+# ── Main ─────────────────────────────────────────────────────────────────
+
+def load_manifest():
+    if os.path.exists(MANIFEST_LOCAL):
+        with open(MANIFEST_LOCAL) as f:
+            return json.load(f)
+    try:
+        import requests
+        url = "https://huggingface.co/datasets/dxgl/multiview-datasets/resolve/main/manifest.json"
+        print(f"Downloading manifest from {url} ...")
+        resp = requests.get(url)
+        resp.raise_for_status()
+        return resp.json()
+    except ImportError:
+        print("manifest.json not found locally and requests not installed.")
+        sys.exit(1)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Train 3DGS splats for all DX.GL multi-view datasets"
+    )
+    parser.add_argument("--object", default=None,
+                        help="Train only a specific object (by name, case-insensitive)")
+    parser.add_argument("--data-dir", default="./dxgl-datasets",
+                        help="Directory containing extracted datasets (default: ./dxgl-datasets)")
+    parser.add_argument("--output", default="./dxgl-splats",
+                        help="Output directory for .ply and .splat files (default: ./dxgl-splats)")
+    parser.add_argument("--ns-output", default="./ns-outputs",
+                        help="Nerfstudio outputs/checkpoints directory (default: ./ns-outputs)")
+    parser.add_argument("--iterations", type=int, default=DEFAULT_ITERATIONS,
+                        help=f"Max training iterations (default: {DEFAULT_ITERATIONS})")
+    parser.add_argument("--dry-run", action="store_true",
+                        help="Show what would be trained without running")
+    parser.add_argument("--export-only", action="store_true",
+                        help="Skip training, only export/convert from existing ns-outputs")
+    args = parser.parse_args()
+
+    manifest = load_manifest()
+    objects = manifest["objects"]
+
+    if args.object:
+        objects = [o for o in objects if args.object.lower() in o["name"].lower()]
+        if not objects:
+            print(f"No object matching '{args.object}' found in manifest.")
+            sys.exit(1)
+
+    os.makedirs(args.output, exist_ok=True)
+    os.makedirs(args.ns_output, exist_ok=True)
+
+    results = []
+    total_time = 0
+
+    for i, obj in enumerate(objects, 1):
+        name = obj["name"]
+        slug = name.lower().replace(" ", "_")
+        splat_out = os.path.join(args.output, f"{slug}.splat")
+        ply_out = os.path.join(args.output, f"{slug}.ply")
+
+        print(f"\n{'='*60}")
+        print(f"[{i}/{len(objects)}] {name}")
+        print(f"{'='*60}")
+
+        # Check if already done
+        if os.path.exists(splat_out) and not args.export_only:
+            size_mb = os.path.getsize(splat_out) / 1e6
+            print(f"  ✓ Already done ({size_mb:.1f} MB .splat) — skipping")
+            results.append({"name": name, "status": "skipped"})
+            continue
+
+        # Find dataset
+        data_dir = os.path.join(args.data_dir, slug)
+        transforms = os.path.join(data_dir, "transforms.json")
+        if not os.path.exists(transforms):
+            # Try nested: dataset might be inside a subdirectory
+            nested = os.path.join(data_dir, "dataset", "transforms.json")
+            if os.path.exists(nested):
+                data_dir = os.path.join(data_dir, "dataset")
+            else:
+                print(f"  ✗ Dataset not found at {data_dir}")
+                print(f"    Run download_all.py first, or specify --data-dir")
+                results.append({"name": name, "status": "missing_data"})
+                continue
+
+        if args.dry_run:
+            print(f"  Would train: {data_dir}")
+            print(f"  Iterations:  {args.iterations}")
+            print(f"  Output:      {splat_out}")
+            results.append({"name": name, "status": "dry_run"})
+            continue
+
+        t0 = time.time()
+        experiment = slug
+
+        # Step 1: Train (unless export-only)
+        if not args.export_only:
+            print(f"  Training splatfacto ({args.iterations} iterations) ...")
+            try:
+                train_splatfacto(data_dir, experiment, args.ns_output, args.iterations)
+            except RuntimeError as e:
+                print(f"  ✗ Training failed: {e}")
+                results.append({"name": name, "status": "train_error", "error": str(e)})
+                continue
+
+        # Step 2: Find config and export PLY
+        config_path = find_latest_config(args.ns_output, experiment)
+        if not config_path:
+            print(f"  ✗ No config.yml found in {args.ns_output}/{experiment}/")
+            results.append({"name": name, "status": "no_config"})
+            continue
+
+        print(f"  Exporting PLY from {config_path} ...")
+        export_dir = os.path.join(args.ns_output, experiment, "export")
+        try:
+            exported_ply = export_ply(config_path, export_dir)
+        except (RuntimeError, FileNotFoundError) as e:
+            print(f"  ✗ Export failed: {e}")
+            results.append({"name": name, "status": "export_error", "error": str(e)})
+            continue
+
+        # Step 3: Copy PLY to output
+        import shutil
+        shutil.copy2(exported_ply, ply_out)
+        ply_mb = os.path.getsize(ply_out) / 1e6
+        print(f"  PLY: {ply_mb:.1f} MB → {ply_out}")
+
+        # Step 4: Convert to .splat
+        print(f"  Converting to .splat ...")
+        try:
+            n_gaussians, _, splat_mb = ply_to_splat(ply_out, splat_out)
+        except Exception as e:
+            print(f"  ✗ Conversion failed: {e}")
+            results.append({"name": name, "status": "convert_error", "error": str(e)})
+            continue
+
+        elapsed = time.time() - t0
+        total_time += elapsed
+        print(f"  ✓ Done: {n_gaussians:,} gaussians, {splat_mb:.1f} MB .splat ({elapsed:.0f}s)")
+        results.append({
+            "name": name, "status": "done",
+            "gaussians": n_gaussians, "ply_mb": round(ply_mb, 1),
+            "splat_mb": round(splat_mb, 1), "seconds": round(elapsed),
+        })
+
+    # Summary
+    print(f"\n{'='*60}")
+    print("SUMMARY")
+    print(f"{'='*60}")
+    done = [r for r in results if r["status"] == "done"]
+    skipped = [r for r in results if r["status"] == "skipped"]
+    errors = [r for r in results if r["status"] not in ("done", "skipped", "dry_run")]
+
+    if done:
+        print(f"\n  Trained: {len(done)}")
+        for r in done:
+            print(f"    {r['name']}: {r['gaussians']:,} gaussians, "
+                  f"{r['splat_mb']} MB, {r['seconds']}s")
+    if skipped:
+        print(f"\n  Skipped (already done): {len(skipped)}")
+    if errors:
+        print(f"\n  Errors: {len(errors)}")
+        for r in errors:
+            print(f"    {r['name']}: {r['status']} — {r.get('error', '')}")
+
+    if total_time > 0:
+        print(f"\n  Total training time: {total_time/60:.1f} minutes")
+    print(f"  Output: {os.path.abspath(args.output)}")
+
+
+if __name__ == "__main__":
+    main()