Trim demo to Space-essentials and refresh example panoramas

- Drop unused code paths from app.py (isolated-cluster removal, logger
setup, MODEL_TO_REPO alias table) — the Space only ever runs the
unified prs-eth/PaGeR checkpoint.
- Strip src/utils/utils.py and src/utils/geometry_utils.py down to the
helpers app.py actually imports.
- Swap the example set for the eleven panoramas shipped in the main
PaGeR repo (church / eth / library / medieval kitchen / quattro canti
/ zurich street corner / zurich tree intersection / etc.); drop the
legacy alice / fish_eagle_hill / library.png / little_paris / etc.

app.py

@@ -9,16 +9,15 @@ CLIP ViT-B/32 classifier on the cubemap or force one head explicitly.
 
 Run with::
 
-    python app.py --checkpoint_path <hf_repo_or_local_dir>
+    python app.py --checkpoint <hf_repo_or_local_dir>
 
-Requires ``pip install -e .[app]``.
+Requires ``pip install -r requirements.txt``.
 """
 
 from __future__ import annotations
 
 import argparse
 import gc
-import logging
 import sys
 from io import BytesIO
 from pathlib import Path
@@ -46,7 +45,6 @@ from src.utils.geometry_utils import (
     compute_edge_mask,
     erp_to_cubemap,
     erp_to_pointcloud,
-    remove_isolated_clusters_3d,
 )
 from src.utils.scene_classifier import get_classifier
 from src.utils.utils import (
@@ -55,11 +53,6 @@ from src.utils.utils import (
 )
 
 
-# ``remove_isolated_clusters_3d`` is the dominant cost in point-cloud building
-# (~75 %) but removes <0.1 % of points on a 2k x 4k panorama; the bulk of
-# flying points is already caught by ``compute_edge_mask``. Default to off for
-# interactive UX; flip to True for the cleanest possible cloud.
-POINTCLOUD_REMOVE_ISOLATED_CLUSTERS = False
 POINTCLOUD_DOWNSAMPLE_FACTOR = 2
 
 EXAMPLES_DIR = Path(__file__).parent / "examples"
@@ -73,23 +66,14 @@ MODE_AUTO, MODE_INDOOR, MODE_OUTDOOR = "Auto", "Indoor", "Outdoor"
 MODE_CHOICES = [MODE_AUTO, MODE_INDOOR, MODE_OUTDOOR]
 FORMAT_MAP, FORMAT_POINTCLOUD = "Map", "Point Cloud"
 
-# Short aliases for the released checkpoints; the demo only validates against
-# ``pager`` (the unified checkpoint), but the resolver below accepts any HF
-# repo id or local directory passed through ``--checkpoint``.
-MODEL_TO_REPO = {
-    "pager":              "prs-eth/PaGeR",
-    "pager-metric-depth": "prs-eth/PaGeR-metric-depth",
-    "pager-normals":      "prs-eth/PaGeR-normals",
-}
+DEFAULT_CHECKPOINT = "prs-eth/PaGeR"
 
 
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(description="PaGeR Gradio demo.")
-    parser.add_argument("--checkpoint", type=str, default="pager",
-                        help="Which checkpoint to run. Short alias "
-                             "(pager / pager-metric-depth / pager-normals), a "
-                             "HuggingFace Hub repo id, or a local directory. "
-                             "Default: pager (the unified prs-eth/PaGeR checkpoint).")
+    parser.add_argument("--checkpoint", type=str, default=DEFAULT_CHECKPOINT,
+                        help="HuggingFace Hub repo id or local directory holding "
+                             "config.yaml + model.safetensors. Default: prs-eth/PaGeR.")
     return parser.parse_args()
 
 
@@ -226,15 +210,8 @@ def _ensure_pointclouds(cache: dict) -> None:
     keep_2d = (depth > 0) & np.asarray(edge_mask, dtype=bool)
     points = xyz[keep_2d]
 
-    if POINTCLOUD_REMOVE_ISOLATED_CLUSTERS and len(points) > 0:
-        inlier = remove_isolated_clusters_3d(points)
-        points = points[inlier]
-    else:
-        inlier = None
-
     def _colors_from(color_image):
-        sub = (np.clip(color_image[keep_2d], 0.0, 1.0) * 255.0).astype(np.uint8)
-        return sub if inlier is None else sub[inlier]
+        return (np.clip(color_image[keep_2d], 0.0, 1.0) * 255.0).astype(np.uint8)
 
     cache["rgb_pc_path"] = _export_glb(points, _colors_from(rgb_color))
     cache["normals_pc_path"] = _export_glb(points, _colors_from(normals_color))
@@ -334,24 +311,15 @@ def on_image_or_scene_change():
 
 args = parse_args()
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-logger = logging.getLogger("simple")
-handler = logging.StreamHandler(sys.stdout)
-handler.setFormatter(logging.Formatter("%(message)s"))
-logger.addHandler(handler)
-logger.setLevel(logging.INFO)
-logger.propagate = False
 cmap = plt.get_cmap("Spectral")
 
-checkpoint_arg = MODEL_TO_REPO.get(args.checkpoint, args.checkpoint)
-
 try:
     checkpoint_config_path = hf_hub_download(
-        repo_id=checkpoint_arg, filename="config.yaml"
+        repo_id=args.checkpoint, filename="config.yaml"
     )
     checkpoint_path = Path(checkpoint_config_path).parent
 except Exception:
-    checkpoint_path = Path(checkpoint_arg)
+    checkpoint_path = Path(args.checkpoint)
     checkpoint_config_path = checkpoint_path / "config.yaml"
 
 cfg = OmegaConf.load(checkpoint_config_path)

src/utils/geometry_utils.py

@@ -1,7 +1,6 @@
 import math
 import torch
 import numpy as np
-import trimesh
 from pytorch360convert import e2c, c2e, e2p
 
 
@@ -120,44 +119,6 @@ def cubemap_to_erp(cube_tensor, erp_h=1024, erp_w=2048, fov=90.0, cube_format="s
         f"Unsupported cube_tensor shape {tuple(cube_tensor.shape)}. Expected (6, C, h, w) or (B, 6, C, h, w)."
     )
 
-def compute_scale_and_shift(pred_g, targ_g, mask_g=None, weights=None, eps=0.0, fit_shift=True):
-    if mask_g is None:
-        mask_g = torch.ones_like(pred_g, dtype=torch.bool)
-
-    # Flatten to (B, N): works for (B, 1, H, W) and (B, 6, 1, H, W).
-    # Use contiguous() before reshape to avoid returning a view of the caller's
-    # tensor storage — an in-place op on the original after this call would
-    # otherwise corrupt the autograd graph (AsStridedBackward version mismatch).
-    B = pred_g.shape[0]
-    pred_g  = pred_g.contiguous().reshape(B, -1)
-    targ_g  = targ_g.contiguous().reshape(B, -1)
-    mask_g  = mask_g.contiguous().reshape(B, -1).to(dtype=pred_g.dtype)
-    if weights is not None:
-        weights = weights.contiguous().reshape(B, -1)
-
-    # Apply weights to the mask
-    mask_w = mask_g * weights if weights is not None else mask_g
-
-    # Compute weighted summations → shape (B,)
-    a_00 = torch.sum(mask_w * pred_g * pred_g, dim=1)
-    a_01 = torch.sum(mask_w * pred_g,          dim=1)
-    a_11 = torch.sum(mask_w,                   dim=1)
-    b_0  = torch.sum(mask_w * pred_g * targ_g, dim=1)
-    b_1  = torch.sum(mask_w * targ_g,          dim=1)
-
-    if fit_shift:
-        det = a_00 * a_11 - a_01 * a_01 + eps
-        scale = torch.zeros_like(b_0)
-        shift = torch.zeros_like(b_1)
-        valid = det > 0
-        scale[valid] = (a_11[valid] * b_0[valid] - a_01[valid] * b_1[valid]) / det[valid]
-        shift[valid] = (-a_01[valid] * b_0[valid] + a_00[valid] * b_1[valid]) / det[valid]
-        return scale, shift
-    else:
-        scale = b_0 / (a_00 + eps)
-        return scale, torch.zeros_like(scale)
-
-
 def unit_normals(n, eps = 1e-6):
     assert n.dim() >= 3 and n.size(-3) == 3, "normals must have channel=3 at dim -3"
     denom = torch.clamp(torch.linalg.norm(n, dim=-3, keepdim=True), min=eps)
@@ -207,103 +168,6 @@ def z_depth_to_euclidean(z_depth, intrinsics):
     return out.squeeze(0) if squeeze_batch else out
 
 
-def remove_isolated_clusters_3d(points: np.ndarray,
-                                 max_cluster_size: int = 500,
-                                 connect_factor: float = 0.05,
-                                 isolation_factor: float = 0.2,
-                                 far_percentile: float = 90.0) -> np.ndarray:
-    """Remove small clusters of far points that are isolated from the rest of the cloud.
-
-    All distance thresholds are derived from the point cloud's own distance
-    distribution, making the filter scale-invariant across different depth
-    ranges (indoor, outdoor, different depth units, etc.).
-
-    The reference scale is ``r_far = percentile(‖p‖, far_percentile)``.  Both
-    radii are expressed as fractions of it:
-
-    * ``connect_radius   = connect_factor   * r_far``
-    * ``isolation_radius = isolation_factor * r_far``
-
-    Only points beyond ``far_percentile`` of the distance-from-origin
-    distribution are considered candidates — the filter never touches nearby
-    geometry.  Among those far points, spatial connected components are formed
-    using ``connect_radius``.  Any component with ≤ ``max_cluster_size`` points
-    whose closest distance to the *near* part of the cloud exceeds
-    ``isolation_radius`` is removed.
-
-    A cluster close to the main cloud (within ``isolation_radius``) is kept
-    regardless of its size — it is likely valid distant geometry.
-
-    Args:
-        points:           (N, 3) float32 XYZ array.
-        max_cluster_size: clusters larger than this are always kept.
-        connect_factor:   cluster connection radius as a fraction of r_far.
-                          E.g. 0.05 → points within 5 % of r_far are connected.
-        isolation_factor: isolation threshold as a fraction of r_far.
-                          E.g. 0.2 → cluster must be >20 % of r_far from the
-                          near cloud to be removed.
-        far_percentile:   distance percentile that separates "near" from "far".
-
-    Returns:
-        (N,) bool — True for points to keep.
-    """
-    from scipy.spatial import cKDTree
-    from scipy.sparse import csr_matrix
-    from scipy.sparse.csgraph import connected_components
-
-    N = len(points)
-    inlier = np.ones(N, dtype=bool)
-
-    r = np.linalg.norm(points, axis=1)
-    r_far = np.percentile(r, far_percentile)
-
-    connect_radius   = connect_factor   * r_far
-    isolation_radius = isolation_factor * r_far
-
-    far_mask  = r > r_far
-    near_mask = ~far_mask
-
-    far_points  = points[far_mask]
-    near_points = points[near_mask]
-    far_idx     = np.where(far_mask)[0]
-
-    if len(far_points) < 2 or len(near_points) == 0:
-        return inlier
-
-    # --- Connected components among far points --------------------------
-    far_tree = cKDTree(far_points)
-    pairs = far_tree.query_pairs(connect_radius, output_type='ndarray')
-
-    N_far = len(far_points)
-    if len(pairs) > 0:
-        rows = np.concatenate([pairs[:, 0], pairs[:, 1]])
-        cols = np.concatenate([pairs[:, 1], pairs[:, 0]])
-        adj  = csr_matrix((np.ones(len(rows), dtype=np.float32), (rows, cols)),
-                          shape=(N_far, N_far))
-    else:
-        adj = csr_matrix((N_far, N_far))
-
-    _, labels    = connected_components(adj, directed=False)
-    comp_sizes   = np.bincount(labels)
-    small_comp_ids = np.where(comp_sizes <= max_cluster_size)[0]
-
-    if len(small_comp_ids) == 0:
-        return inlier
-
-    # --- Isolation check against the near cloud -------------------------
-    near_tree = cKDTree(near_points)
-
-    for comp_id in small_comp_ids:
-        comp_local = labels == comp_id          # index into far_points
-        comp_pts   = far_points[comp_local]
-        # Distance from each cluster point to the nearest near-cloud point
-        dists, _ = near_tree.query(comp_pts, k=1, workers=-1)
-        if dists.min() > isolation_radius:
-            inlier[far_idx[comp_local]] = False
-
-    return inlier
-
-
 def compute_edge_mask(depth, abs_thresh = 0.1, rel_thresh = 0.1):
     assert depth.ndim == 2
     depth = depth.astype(np.float32, copy=False)
@@ -460,54 +324,3 @@ def get_cubemap_intrinsics_extrinsics(image_size=512, fov=90.0):
     extrinsics[:, 3, 3] = 1.0
 
     return extrinsics, intrinsics
-
-
-def erp_to_point_cloud_glb(rgb, depth, mask=None, export_path=None,
-                            remove_isolated_clusters: bool = True,
-                            cluster_max_size: int = 500,
-                            cluster_connect_factor: float = 0.05,
-                            cluster_isolation_factor: float = 0.2,
-                            cluster_far_percentile: float = 90.0):
-    """Build and optionally export a trimesh GLB from ERP rgb + depth.
-
-    rgb:   (H, W, 3) float32 in [0, 1]  (numpy or torch)
-    depth: (H, W) float32               (numpy or torch)
-    mask:  (H, W) bool-like             (numpy or torch), optional
-    remove_isolated_clusters: if True, apply :func:`remove_isolated_clusters_3d`
-        after projection to suppress flying/stranded far clusters.  The
-        ``cluster_*`` kwargs are forwarded to that function.
-    """
-    if isinstance(depth, torch.Tensor):
-        depth = depth.detach().cpu().float().numpy()
-    if isinstance(rgb, torch.Tensor):
-        rgb = rgb.detach().cpu().float().numpy()
-    if isinstance(mask, torch.Tensor):
-        mask = mask.detach().cpu().numpy()
-
-    depth = depth.astype(np.float32, copy=False)
-    H, W  = depth.shape
-
-    xyz_np = erp_to_pointcloud(torch.from_numpy(depth)).permute(1, 2, 0).numpy()  # (H, W, 3)
-
-    keep = depth > 0
-    if mask is not None:
-        keep = keep & np.asarray(mask, dtype=bool)
-
-    points = xyz_np[keep]
-    colors = (np.clip(rgb, 0.0, 1.0) * 255.0).astype(np.uint8)[keep]
-
-    if remove_isolated_clusters and len(points) > 0:
-        inlier = remove_isolated_clusters_3d(
-            points,
-            max_cluster_size=cluster_max_size,
-            connect_factor=cluster_connect_factor,
-            isolation_factor=cluster_isolation_factor,
-            far_percentile=cluster_far_percentile,
-        )
-        points = points[inlier]
-        colors = colors[inlier]
-
-    scene = trimesh.Scene()
-    scene.add_geometry(trimesh.PointCloud(vertices=points, colors=colors))
-    scene.export(export_path)
-    return scene

src/utils/utils.py

@@ -1,7 +1,5 @@
-"""Lightweight logging helpers shared by ``inference.py``, ``app.py``, and the
-evaluation scripts. The training utilities (param-group builders, EMA, loss
-calculators, ...) live in the development repository and are not part of the
-release distribution.
+"""Preview helpers consumed by ``app.py`` to turn raw pager outputs into
+uint8 images for the Gradio UI.
 """
 
 from __future__ import annotations
@@ -9,51 +7,9 @@ from __future__ import annotations
 from typing import Tuple
 
 import numpy as np
-import torch
-from omegaconf import DictConfig, OmegaConf
-from pathlib import Path
 from scipy.ndimage import median_filter
 
 
-def args_to_omegaconf(args, base_cfg):
-    """Overlay non-``None`` argparse values onto ``base_cfg`` in place.
-
-    Keys are matched recursively by name across every nesting level of the
-    config, so ``args.results_path`` will overwrite ``cfg.results_path`` no
-    matter where it lives in the tree.
-    """
-    cfg = OmegaConf.create(base_cfg)
-
-    def _override(container, key):
-        if hasattr(args, key):
-            value = getattr(args, key)
-            if value is not None:
-                container[key] = value
-
-    def _walk(container):
-        if not isinstance(container, DictConfig):
-            return
-        for key in container.keys():
-            node = container[key]
-            if isinstance(node, DictConfig):
-                _walk(node)
-            else:
-                _override(container, key)
-
-    _walk(cfg)
-    return cfg
-
-
-def convert_paths_to_pathlib(cfg):
-    """Cast any leaf key whose name contains ``"path"`` to ``pathlib.Path``."""
-    for key, value in cfg.items():
-        if isinstance(value, DictConfig):
-            cfg[key] = convert_paths_to_pathlib(value)
-        elif "path" in key.lower():
-            cfg[key] = Path(value) if value is not None else None
-    return cfg
-
-
 def prepare_image_for_logging(image: np.ndarray, apply_median: bool = False) -> np.ndarray:
     """Per-sample min/max stretch to ``uint8``, optionally median-filtered."""
     if apply_median: