Update project and repository links

Sync the latest Hugging Face demo branch and point the UI to the official zju3dv project page and GitHub repository.

.gitignore

@@ -14,7 +14,6 @@ __pycache__/
 
 # Runtime outputs
 /outputs/
-/wandb/
 /logs/
 /cache/
 /trash/

INSTALL.md

@@ -34,7 +34,7 @@ PLY export works without the dependencies in this section.
 Install `gsplat` only when novel-view video rendering is needed:
 
 ```bash
-uv pip install git+https://github.com/nerfstudio-project/gsplat.git
+uv pip install git+https://github.com/nerfstudio-project/gsplat.git --no-build-isolation
 ```
 
 Interactive HTML export requires Node.js and the PlayCanvas `splat-transform` CLI, but does not require `gsplat`:

README.md

@@ -19,35 +19,37 @@ preload_from_hub:
 
 <h1>🌌 InfiniSplat: Implicit Gaussian Decoding for Large-Baseline Monocular View Synthesis</h1>
 
+<p align="center"><strong>Conditionally accepted to SIGGRAPH Asia 2026 (Journal Track)</strong></p>
+
 <div align="center">
-  <a href="https://pluswave.top/InfiniSplat-page/">
+  <a href="https://zju3dv.github.io/InfiniSplat">
     <img src="https://img.shields.io/badge/Project-Page-red?logo=googlechrome&logoColor=red">
   </a>
   <a href="#">
     <img src="https://img.shields.io/badge/arXiv-Paper-blue?logo=arxiv&logoColor=blue">
   </a>
-  <a href="https://pluswave.top/InfiniSplat-page/#visualization">
+  <a href="https://zju3dv.github.io/InfiniSplat/#visualization">
     <img src="https://img.shields.io/badge/Gallery-Visualization-green?logo=googlephotos&logoColor=white">
   </a>
-  <a href="https://huggingface.co/PLUS-WAVE/InfiniSplat">
-    <img src="https://img.shields.io/badge/HuggingFace-Model-yellow?logo=huggingface&logoColor=yellow">
+  <a href="https://huggingface.co/spaces/PLUS-WAVE/InfiniSplat">
+    <img src="https://img.shields.io/badge/HuggingFace-Demo-yellow?logo=huggingface&logoColor=yellow">
   </a>
 </div>
 
 <p align="center">
-  <a href="https://plus-wave.github.io/">Jiawei Wang*</a> •
-  <a href="https://ritianyu.github.io/">Hao Yu*</a> •
+  <a href="https://plus-wave.github.io/">Jiawei Wang<sup>*</sup></a> •
+  <a href="https://ritianyu.github.io/">Hao Yu<sup>*</sup></a> •
   <a href="https://github.com/Edisoneh">Yongzhen Hu</a> •
   <a href="https://github.com/shmily768">Xinyi Yang</a> •
   <a href="#">Tao Ni</a> •
   <a href="#">Xin Zhan</a> •
-  <a href="#">Junbo Chen</a> <br>
+  <a href="#">Junbo Chen<sup>†</sup></a> <br>
   <a href="https://xzhou.me/">Xiaowei Zhou</a> •
   <a href="https://csse.szu.edu.cn/staff/ruizhenhu/">Ruizhen Hu</a> •
-  <a href="https://pengsida.net/">Sida Peng</a>
+  <a href="https://pengsida.net/">Sida Peng<sup>†</sup></a>
 </p>
 
-<!-- <p align="center"><sup>* Equal contribution.</sup></p> -->
+<p align="center"><sup>*</sup> Equal contribution. <sup>†</sup> Corresponding authors.</p>
 
 </div>
 
@@ -59,6 +61,8 @@ preload_from_hub:
 
 ## 📣 News
 
+> **[2026-07]** 🎉 InfiniSplat has been conditionally accepted to SIGGRAPH Asia 2026 (Journal Track)!
+
 > **[2026-07]** 🎉 Inference code for RGB-only and depth-sensor-guided 3D Gaussian reconstruction is available now!
 
 ## 🧩 What can InfiniSplat do?
@@ -108,30 +112,19 @@ python -m src.demo.infer_batch_images \
   --input examples/data/lidar_demo
 ```
 
-See [docs/inference.md](docs/inference.md) for camera parameters, recursive directory scanning, output control, and other optional arguments.
-
-## Hugging Face Space
+See [docs/inference.md](docs/inference.md) for camera parameters, output control, and other optional arguments.
 
-The root `app.py` exposes RGB reconstruction as a Gradio ZeroGPU Space. The encoder
-is loaded once at startup, GPU inference writes a temporary CPU artifact, and CPU
-post-processing filters spatial outliers before exporting the Gaussian PLY. The
-PLY download becomes available before the optimized SOG viewer is encoded. Browser
-viewer assets are prepared once at startup, and the standalone HTML is bundled
-after the interactive viewer starts loading.
-The app reuses `checkpoints/infinisplat_rgb.ckpt` when it exists locally and
-otherwise downloads the released RGB checkpoint from `PLUS-WAVE/InfiniSplat`.
-This RGB path does not require xFormers or any custom CUDA extension.
+## 🖥️ Web Demo
 
-Run the Space app locally from the prepared inference environment:
+The local Gradio demo provides RGB reconstruction, staged PLY and standalone HTML downloads, and an interactive Gaussian viewer. After preparing the inference environment, launch it with:
 
 ```bash
-pip install spaces
-python app.py
+python demo.py
 ```
 
-Set `INFINISPLAT_CHECKPOINT` only when using a checkpoint at another path.
+Open `http://127.0.0.1:7860` in a browser. The demo reuses `checkpoints/infinisplat_rgb.ckpt` when available and otherwise downloads the released RGB checkpoint from `PLUS-WAVE/InfiniSplat`. Set `INFINISPLAT_CHECKPOINT` to use a checkpoint at another path.
 
-Select ZeroGPU in the Space hardware settings after creating the Gradio Space.
+The hosted version is available on the [Hugging Face Space](https://huggingface.co/spaces/PLUS-WAVE/InfiniSplat).
 
 ## 🙏 Acknowledgments
 

app.py

@@ -20,7 +20,7 @@ if __name__ == "__main__":
         server_port=int(os.environ.get("PORT", "7860")),
         allowed_paths=[str(OUTPUT_ROOT)],
         max_file_size="20mb",
-        show_error=True,
+        show_error=False,
         ssr_mode=False,
         footer_links=[],
         theme=APP_THEME,

docs/inference.md

@@ -19,7 +19,7 @@ The selected checkpoint contains the full inference model. Encoder and decoder w
 
 `--input` accepts one image or a directory. Supported image extensions are `.jpg`, `.jpeg`, `.png`, `.bmp`, and `.webp`. Directory entries are sorted to make batch selection deterministic.
 
-By default, only the selected directory is scanned. Add `--recursive` to scan its subdirectories and `--limit N` to process only the first `N` selected images. A limit of `0` means no cap.
+Only files directly inside the selected directory are scanned. Use `--limit N` to process only the first `N` selected images. A limit of `0` means no cap.
 
 When `--input` is omitted, each mode uses its bundled example directory:
 
@@ -133,7 +133,6 @@ The HTML converter reads `config/viewer_settings.json` directly. It does not gen
 | `--checkpoint PATH` | Override the checkpoint selected by the mode. |
 | `--input PATH` | Process one image or a directory. |
 | `--output-dir PATH` | Override `outputs/demo/<mode>`. |
-| `--recursive` | Search input subdirectories. |
 | `--limit N` | Process at most `N` selected images; `0` means all. |
 | `--overwrite` | Recompute outputs that already exist. |
 | `--device DEVICE` | Override automatic device selection, for example `cuda:0`. |

src/demo/hf_ui.py

@@ -31,8 +31,8 @@ GPU_DURATION_SECONDS = 6
 REQUEST_CACHE_SECONDS = 3600
 CACHE_CLEANUP_INTERVAL_SECONDS = 3600
 FULL_TITLE = "Implicit Gaussian Decoding for Large-Baseline Monocular View Synthesis"
-GITHUB_URL = "https://github.com/PLUS-WAVE/InfiniSplat-oss"
-PROJECT_PAGE_URL = "https://pluswave.top/InfiniSplat-page/"
+GITHUB_URL = "https://github.com/zju3dv/InfiniSplat"
+PROJECT_PAGE_URL = "https://zju3dv.github.io/InfiniSplat"
 INPUT_IMAGE_HINT = "Better for indoor scenes due to HyperSim-only training"
 REPO_ROOT = Path(__file__).resolve().parents[2]
 RGB_EXAMPLE_DIR = REPO_ROOT / "examples/data/rgb_demo"
@@ -625,7 +625,7 @@ def _gradio_file_url(path: Path) -> str:
 
 
 def _log_timing(stage: str, request_dir: Path, started_at: float, **metrics) -> None:
-    """Emit one structured timing record for Space performance checks."""
+    """Emit one structured timing record for demo performance checks."""
     payload = {
         "stage": stage,
         "request": request_dir.name,

src/demo/infer_batch_images.py

@@ -189,6 +189,10 @@ def _resolve_prompt_depth_path(args: argparse.Namespace, image_path: Path) -> Pa
         Prompt depth path for this image, or None when prompt depth is disabled.
     """
     if args.prompt_depth is not None:
+        if not args.prompt_depth.exists():
+            raise FileNotFoundError(f"Prompt depth file not found: {args.prompt_depth}")
+        if not args.prompt_depth.is_file():
+            raise ValueError(f"Prompt depth path is not a file: {args.prompt_depth}")
         return args.prompt_depth
     prompt_depth_dir = args.prompt_depth_dir
     if prompt_depth_dir is None and args.mode == "lidar":
@@ -202,7 +206,7 @@ def _resolve_prompt_depth_path(args: argparse.Namespace, image_path: Path) -> Pa
         for ext in PROMPT_DEPTH_EXTENSIONS
     ]
     for candidate in candidates:
-        if candidate.exists() and candidate.resolve() != image_path.resolve():
+        if candidate.is_file() and candidate.resolve() != image_path.resolve():
             return candidate
     raise FileNotFoundError(
         "Prompt depth file not found for "

src/demo/infer_single_image.py

@@ -99,8 +99,16 @@ def _as_float(value: Any) -> float | None:
         return None
 
 
+def _validate_positive_finite(value: float, name: str) -> None:
+    if not math.isfinite(float(value)) or float(value) <= 0.0:
+        raise ValueError(f"{name} must be a positive finite value, got {value}.")
+
+
 def convert_focallength_mm_to_px(width: float, height: float, focal_mm: float) -> float:
     """Convert 35mm-equivalent focal length in millimeters to pixels."""
+    _validate_positive_finite(width, "Image width")
+    _validate_positive_finite(height, "Image height")
+    _validate_positive_finite(focal_mm, "Focal length in millimeters")
     return focal_mm * math.sqrt(width**2.0 + height**2.0) / math.sqrt(36.0**2 + 24.0**2)
 
 
@@ -110,6 +118,9 @@ def build_intrinsics_from_focal_px(
     height: int,
 ) -> torch.Tensor:
     """Create a pixel-space OpenCV intrinsics matrix."""
+    _validate_positive_finite(focal_length_px, "Focal length in pixels")
+    _validate_positive_finite(width, "Image width")
+    _validate_positive_finite(height, "Image height")
     return torch.tensor(
         [
             [focal_length_px, 0.0, (width - 1) / 2.0],
@@ -190,9 +201,18 @@ def _load_intrinsics_override(path: Path) -> torch.Tensor:
             )
     else:
         matrix = container
-    intrinsics_px = torch.tensor(matrix, dtype=torch.float32)
+    try:
+        intrinsics_px = torch.tensor(matrix, dtype=torch.float32)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(f"Intrinsics matrix in {path} must contain only numeric values.") from exc
     if intrinsics_px.shape != (3, 3):
         raise ValueError(f"Expected a 3x3 intrinsics matrix in {path}, got {tuple(intrinsics_px.shape)}.")
+    if not torch.isfinite(intrinsics_px).all():
+        raise ValueError(f"Intrinsics matrix in {path} must contain only finite values.")
+    if intrinsics_px[0, 0] <= 0.0 or intrinsics_px[1, 1] <= 0.0:
+        raise ValueError(f"Intrinsics matrix in {path} must have positive fx and fy.")
+    if abs(float(torch.linalg.det(intrinsics_px).item())) <= torch.finfo(intrinsics_px.dtype).eps:
+        raise ValueError(f"Intrinsics matrix in {path} must be non-singular.")
     return intrinsics_px
 
 
@@ -439,6 +459,8 @@ def load_prompt_depth_tensors(
     """Load one prompt depth file and build prompt tensors for InfiniDepth demo inference."""
     if not prompt_depth_path.exists():
         raise FileNotFoundError(f"Prompt depth file not found: {prompt_depth_path}")
+    if not prompt_depth_path.is_file():
+        raise ValueError(f"Prompt depth path is not a file: {prompt_depth_path}")
 
     _, prompt_depth_tensor, _ = load_depth(
         depth_path=prompt_depth_path,

src/model/encoder/depth/depthpro/depthpro_wrapper.py

@@ -1,32 +1,15 @@
 from __future__ import annotations
 
-from pathlib import Path
 from typing import Dict
 
 import torch
-from omegaconf import DictConfig
 from torch import nn
 
 from .depth_pro import DepthProConfig, create_model_and_transforms
 
 
-def _resolve_precision(precision: str | None, device: torch.device) -> torch.dtype:
-    precision_map = {
-        "float16": torch.float16,
-        "fp16": torch.float16,
-        "half": torch.float16,
-        "float32": torch.float32,
-        "fp32": torch.float32,
-        "float": torch.float32,
-        "bfloat16": torch.bfloat16,
-        "bf16": torch.bfloat16,
-    }
-    dtype = precision_map.get((precision or "float32").lower())
-    if dtype is None:
-        raise ValueError(f"Unsupported DepthPro precision: {precision}")
-    if device.type == "cpu" and dtype != torch.float32:
-        return torch.float32
-    return dtype
+def _inference_precision(device: torch.device) -> torch.dtype:
+    return torch.float16 if device.type == "cuda" else torch.float32
 
 
 def _as_depth_map(depth: torch.Tensor, batch_size: int) -> torch.Tensor:
@@ -67,27 +50,18 @@ def _as_normalized_intrinsics_batch(
 class DepthPro(nn.Module):
     """InfiniSplat wrapper around the vendored upstream DepthPro package."""
 
-    def __init__(self, config: DictConfig | None = None):
+    def __init__(self):
         super().__init__()
-        resolved_config = config if config is not None else {}
-        self.config = resolved_config
-        ckpt_path_value = resolved_config.get("ckpt_path")
-        ckpt_path = Path(ckpt_path_value) if ckpt_path_value else None
-        if ckpt_path is not None and not ckpt_path.is_file():
-            raise FileNotFoundError(f"DepthPro checkpoint not found: {ckpt_path}")
-
-        self.freeze_depthpro = bool(resolved_config.get("freeze_depthpro", True))
         self.device_hint = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        self.precision_name = resolved_config.get("precision", "float16")
-        self.precision = _resolve_precision(self.precision_name, self.device_hint)
+        self.precision = _inference_precision(self.device_hint)
 
         depthpro_cfg = DepthProConfig(
-            patch_encoder_preset=resolved_config.get("patch_encoder_preset", "dinov2l16_384"),
-            image_encoder_preset=resolved_config.get("image_encoder_preset", "dinov2l16_384"),
-            decoder_features=int(resolved_config.get("decoder_features", 256)),
-            checkpoint_uri=str(ckpt_path) if ckpt_path is not None else None,
-            fov_encoder_preset=resolved_config.get("fov_encoder_preset", "dinov2l16_384"),
-            use_fov_head=bool(resolved_config.get("use_fov_head", True)),
+            patch_encoder_preset="dinov2l16_384",
+            image_encoder_preset="dinov2l16_384",
+            decoder_features=256,
+            checkpoint_uri=None,
+            fov_encoder_preset="dinov2l16_384",
+            use_fov_head=True,
         )
         self.model, self.transform = create_model_and_transforms(
             config=depthpro_cfg,
@@ -95,16 +69,7 @@ class DepthPro(nn.Module):
             precision=self.precision,
         )
 
-        if self.freeze_depthpro:
-            for param in self.model.parameters():
-                param.requires_grad_(False)
-            self.model.eval()
-
-    def train(self, mode: bool = True):
-        super().train(mode)
-        if self.freeze_depthpro:
-            self.model.eval()
-        return self
+        self.model.eval()
 
     def _prepare_input(self, image: torch.Tensor) -> torch.Tensor:
         if image.ndim != 4:
@@ -118,7 +83,7 @@ class DepthPro(nn.Module):
 
     def _ensure_runtime_dtype(self) -> None:
         param = next(self.model.parameters())
-        desired_dtype = _resolve_precision(self.precision_name, param.device)
+        desired_dtype = _inference_precision(param.device)
         if param.dtype != desired_dtype:
             self.model.to(dtype=desired_dtype)
             self.precision = desired_dtype

src/model/encoder/depth/infinidepth/infinidepth_wrapper.py

@@ -11,7 +11,7 @@ from src.model.encoder.depth.infinidepth.sampling_utils import make_2d_uniform_c
 
 
 class InfiniDepth(nn.Module):
-    """Frozen prompt-conditioned InfiniDepth dense-depth predictor."""
+    """Prompt-conditioned InfiniDepth dense-depth predictor."""
 
     def __init__(self) -> None:
         super().__init__()
@@ -20,15 +20,8 @@ class InfiniDepth(nn.Module):
             geometry_type="disparity",
             use_prompt=True,
         )
-        for parameter in self.model.parameters():
-            parameter.requires_grad_(False)
         self.model.eval()
 
-    def train(self, mode: bool = True):
-        super().train(mode)
-        self.model.eval()
-        return self
-
     @torch.inference_mode()
     def forward(self, batch: dict[str, torch.Tensor]) -> torch.Tensor:
         """Predict a dense depth map from RGB and sparse disparity prompts."""

src/model/encoder/encoder_infinidepth_query.py

@@ -36,8 +36,6 @@ class EncoderInfiniDepthQuery(Encoder[EncoderInfiniDepthQueryCfg]):
 
         self.depth_predictor = InfiniDepth()
         self.depth_predictor.eval()
-        for param in self.depth_predictor.parameters():
-            param.requires_grad_(False)
 
         self.image_feature_branch = DinoBasicImageFeatureBranch(
             backbone_type=cfg.image_backbone_type,
@@ -51,11 +49,6 @@ class EncoderInfiniDepthQuery(Encoder[EncoderInfiniDepthQueryCfg]):
 
         self.gaussian_decoder = GaussianDecoder(cfg=cfg.gaussian_decoder)
 
-    def train(self, mode: bool = True):
-        super().train(mode)
-        self.depth_predictor.eval()
-        return self
-
     def _sample_map(
         self,
         feature_map: torch.Tensor,

src/model/encoder/encoder_infinisplat.py

@@ -111,8 +111,6 @@ class EncoderInfiniSplat(Encoder[EncoderInfiniSplatCfg]):
 
         self.depth_predictor = DepthPro()
         self.depth_predictor.eval()
-        for param in self.depth_predictor.parameters():
-            param.requires_grad_(False)
 
         self.image_feature_branch = DinoBasicImageFeatureBranch(
             backbone_type=cfg.image_backbone_type,
@@ -126,11 +124,6 @@ class EncoderInfiniSplat(Encoder[EncoderInfiniSplatCfg]):
 
         self.gaussian_decoder = GaussianDecoder(cfg=cfg.gaussian_decoder)
 
-    def train(self, mode: bool = True):
-        super().train(mode)
-        self.depth_predictor.eval()
-        return self
-
     def _sample_map(
         self,
         feature_map: torch.Tensor,
@@ -246,7 +239,6 @@ class EncoderInfiniSplat(Encoder[EncoderInfiniSplatCfg]):
                 "InfiniSplat expects the selected depth model to return a single dense depth layer."
             )
 
-        # Sample selection is discrete; keep gradients on sampled depths only.
         sampling_output_flat = self._sample_sparse_coords(
             dense_depthmap_flat=dense_depthmap_flat.detach(),
             intrinsics_flat=intrinsics_flat,