Upload 243 files

.gitattributes

@@ -33,3 +33,10 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+examples/**/*.jpg filter=lfs diff=lfs merge=lfs -text
+examples/**/*.jpeg filter=lfs diff=lfs merge=lfs -text
+examples/**/*.png filter=lfs diff=lfs merge=lfs -text
+examples/**/*.bmp filter=lfs diff=lfs merge=lfs -text
+examples/**/*.tiff filter=lfs diff=lfs merge=lfs -text
+examples/**/*.tif filter=lfs diff=lfs merge=lfs -text
+examples/* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,276 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be added to the global gitignore or merged into this project gitignore.  For a PyCharm
+#  project, it is recommended to ignore the entire .idea directory, or at least the following:
+#  .idea/workspace.xml
+#  .idea/tasks.xml
+#  .idea/usage.statistics.xml
+#  .idea/dictionaries
+#  .idea/shelf
+
+# VS Code
+.vscode/
+*.code-workspace
+
+# Local History for Visual Studio Code
+.history/
+
+# Built Visual Studio Code Extensions
+*.vsix
+
+# Hugging Face specific
+# Model files (usually large binary files)
+*.bin
+*.safetensors
+*.h5
+*.onnx
+*.pkl
+*.pth
+*.pt
+*.ckpt
+*.pb
+*.tflite
+*.mlmodel
+
+# Hugging Face cache and tokens
+.cache/
+cache/
+**/cache/
+hf_token*
+.huggingface/
+transformers_cache/
+datasets_cache/
+input_images_*
+
+# Gradio temporary files
+gradio_cached_examples/
+flagged/
+
+# Data directories
+data/
+checkpoints/
+outputs/
+results/
+logs/
+tmp/
+temp/
+# examples/*/
+# /examples*.jpg
+# *.png
+# *.jpeg
+# examples/
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+desktop.ini
+
+# Backup files
+*.bak
+*.swp
+*.swo
+*~
+
+# Compressed files
+*.7z
+*.dmg
+*.gz
+*.iso
+*.jar
+*.rar
+*.tar
+*.zip
+
+# IDE and editor files
+.idea/
+*.sublime-project
+*.sublime-workspace
+.vscode/settings.json
+.vscode/tasks.json
+.vscode/launch.json
+.vscode/extensions.json
+
+# Node modules (if any frontend components)
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Docker
+Dockerfile*
+docker-compose*
+.dockerignore
+
+# MLOps and experiment tracking
+wandb/
+.neptune/
+mlruns/
+.mlflow/
+tensorboard_logs/
+
+# Secrets and configuration
+*.secret
+*.key
+config.ini
+.env.local
+.env.*.local
+secrets.json

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

README.md

@@ -1,12 +1,13 @@
 ---
-title: Colaman Segmap
-emoji: 📊
-colorFrom: pink
-colorTo: purple
+title: Mapanything Gradio
+emoji: 🐠
+colorFrom: purple
+colorTo: green
 sdk: gradio
-sdk_version: 5.49.1
+sdk_version: 5.44.1
 app_file: app.py
 pinned: false
+license: apache-2.0
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,1985 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+MapAnything V2: 3D Reconstruction with Object Segmentation
+- Multi-view 3D reconstruction
+- GroundingDINO object detection
+- SAM precise segmentation
+- DBSCAN clustering for cross-view object matching
+"""
+
+import gc
+import os
+import shutil
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+from collections import defaultdict
+
+os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True"
+
+import cv2
+import gradio as gr
+import numpy as np
+import spaces
+import torch
+import trimesh
+from PIL import Image
+from pillow_heif import register_heif_opener
+from sklearn.cluster import DBSCAN
+
+register_heif_opener()
+
+sys.path.append("mapanything/")
+
+from mapanything.utils.geometry import depthmap_to_world_frame, points_to_normals
+from mapanything.utils.hf_utils.css_and_html import (
+    GRADIO_CSS,
+    MEASURE_INSTRUCTIONS_HTML,
+    get_acknowledgements_html,
+    get_description_html,
+    get_gradio_theme,
+    get_header_html,
+)
+from mapanything.utils.hf_utils.hf_helpers import initialize_mapanything_model
+from mapanything.utils.hf_utils.visual_util import predictions_to_glb
+from mapanything.utils.image import load_images, rgb
+
+
+def get_logo_base64():
+    """Convert WAI logo to base64 for embedding in HTML"""
+    import base64
+
+    logo_path = "examples/WAI-Logo/wai_logo.png"
+    try:
+        with open(logo_path, "rb") as img_file:
+            img_data = img_file.read()
+            base64_str = base64.b64encode(img_data).decode()
+            return f"data:image/png;base64,{base64_str}"
+    except FileNotFoundError:
+        return None
+
+
+# ============================================================================
+# Configuration
+# ============================================================================
+
+# MapAnything Configuration
+high_level_config = {
+    "path": "configs/train.yaml",
+    "hf_model_name": "facebook/map-anything",
+    "model_str": "mapanything",
+    "config_overrides": [
+        "machine=aws",
+        "model=mapanything",
+        "model/task=images_only",
+        "model.encoder.uses_torch_hub=false",
+    ],
+    "checkpoint_name": "model.safetensors",
+    "config_name": "config.json",
+    "trained_with_amp": True,
+    "trained_with_amp_dtype": "bf16",
+    "data_norm_type": "dinov2",
+    "patch_size": 14,
+    "resolution": 518,
+}
+
+# GroundingDINO and SAM Configuration
+GROUNDING_DINO_MODEL_ID = "IDEA-Research/grounding-dino-tiny"
+GROUNDING_DINO_BOX_THRESHOLD = 0.25
+GROUNDING_DINO_TEXT_THRESHOLD = 0.2
+
+SAM_MODEL_ID = "facebook/sam-vit-huge"
+
+DEFAULT_TEXT_PROMPT = "chair . table . sofa . bed . desk . cabinet"
+
+# Common objects prompt for detection
+COMMON_OBJECTS_PROMPT = (
+    "person . face . hand . "
+    "chair . sofa . couch . bed . table . desk . cabinet . shelf . drawer . "
+    "door . window . wall . floor . ceiling . curtain . "
+    "tv . monitor . screen . computer . laptop . keyboard . mouse . "
+    "phone . tablet . remote . "
+    "lamp . light . chandelier . "
+    "book . magazine . paper . pen . pencil . "
+    "bottle . cup . glass . mug . plate . bowl . fork . knife . spoon . "
+    "vase . plant . flower . pot . "
+    "clock . picture . frame . mirror . "
+    "pillow . cushion . blanket . towel . "
+    "bag . backpack . suitcase . "
+    "box . basket . container . "
+    "shoe . hat . coat . "
+    "toy . ball . "
+    "car . bicycle . motorcycle . bus . truck . "
+    "tree . grass . sky . cloud . sun . "
+    "dog . cat . bird . "
+    "building . house . bridge . road . street . "
+    "sign . pole . bench"
+)
+
+# DBSCAN clustering configuration (eps in meters)
+DBSCAN_EPS_CONFIG = {
+    'sofa': 1.5,
+    'bed': 1.5,
+    'couch': 1.5,
+    'desk': 0.8,
+    'table': 0.8,
+    'chair': 0.6,
+    'cabinet': 0.8,
+    'window': 0.5,
+    'door': 0.6,
+    'tv': 0.6,
+    'default': 1.0
+}
+
+DBSCAN_MIN_SAMPLES = 1
+
+# Quality control
+MIN_DETECTION_CONFIDENCE = 0.35
+MIN_MASK_AREA = 100
+
+# Global model variables
+model = None
+grounding_dino_model = None
+grounding_dino_processor = None
+sam_predictor = None
+
+
+# ============================================================================
+# Model Loading Functions
+# ============================================================================
+
+def load_grounding_dino_model(device):
+    """Load GroundingDINO model from HuggingFace"""
+    global grounding_dino_model, grounding_dino_processor
+    
+    if grounding_dino_model is not None:
+        print("✅ GroundingDINO already loaded")
+        return
+    
+    try:
+        from transformers import AutoProcessor, AutoModelForZeroShotObjectDetection
+        
+        print(f"📥 Loading GroundingDINO from HuggingFace: {GROUNDING_DINO_MODEL_ID}")
+        grounding_dino_processor = AutoProcessor.from_pretrained(GROUNDING_DINO_MODEL_ID)
+        grounding_dino_model = AutoModelForZeroShotObjectDetection.from_pretrained(
+            GROUNDING_DINO_MODEL_ID
+        ).to(device).eval()
+        
+        print("✅ GroundingDINO loaded successfully")
+        
+    except Exception as e:
+        print(f"❌ GroundingDINO loading failed: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+def load_sam_model(device):
+    """Load SAM model from HuggingFace"""
+    global sam_predictor
+    
+    if sam_predictor is not None:
+        print("✅ SAM already loaded")
+        return
+    
+    try:
+        from transformers import SamModel, SamProcessor
+        
+        print(f"📥 Loading SAM from HuggingFace: {SAM_MODEL_ID}")
+        sam_model = SamModel.from_pretrained(SAM_MODEL_ID).to(device).eval()
+        sam_processor = SamProcessor.from_pretrained(SAM_MODEL_ID)
+        
+        # Wrap in a predictor-like interface
+        class SAMPredictor:
+            def __init__(self, model, processor, device):
+                self.model = model
+                self.processor = processor
+                self.device = device
+                self.image = None
+                
+            def set_image(self, image):
+                """Set image for prediction"""
+                if image.dtype == np.uint8:
+                    self.image = Image.fromarray(image)
+                else:
+                    self.image = Image.fromarray((image * 255).astype(np.uint8))
+            
+            def predict(self, box, multimask_output=False):
+                """Predict mask from box"""
+                inputs = self.processor(
+                    self.image, 
+                    input_boxes=[[[box]]], 
+                    return_tensors="pt"
+                ).to(self.device)
+                
+                with torch.no_grad():
+                    outputs = self.model(**inputs)
+                
+                masks = self.processor.image_processor.post_process_masks(
+                    outputs.pred_masks.cpu(),
+                    inputs["original_sizes"].cpu(),
+                    inputs["reshaped_input_sizes"].cpu()
+                )[0].squeeze().numpy()
+                
+                if len(masks.shape) == 2:
+                    masks = masks[np.newaxis, ...]
+                
+                return masks, None, None
+        
+        sam_predictor = SAMPredictor(sam_model, sam_processor, device)
+        print("✅ SAM loaded successfully")
+        
+    except Exception as e:
+        print(f"❌ SAM loading failed: {e}")
+        print("   Falling back to bbox-based masks")
+        import traceback
+        traceback.print_exc()
+
+
+# ============================================================================
+# Segmentation Functions
+# ============================================================================
+
+def generate_distinct_colors(n):
+    """Generate N visually distinct colors (RGB, 0-255)"""
+    import colorsys
+    if n == 0:
+        return []
+    
+    colors = []
+    for i in range(n):
+        hue = i / max(n, 1)
+        rgb = colorsys.hsv_to_rgb(hue, 0.9, 0.95)
+        rgb_color = tuple(int(c * 255) for c in rgb)
+        colors.append(rgb_color)
+    
+    return colors
+
+
+def run_grounding_dino_detection(image_np, text_prompt, device):
+    """Run GroundingDINO detection"""
+    if grounding_dino_model is None or grounding_dino_processor is None:
+        print("⚠️ GroundingDINO not loaded")
+        return []
+    
+    try:
+        print(f"🔍 GroundingDINO detection: {text_prompt}")
+        
+        # Convert to PIL Image
+        if image_np.dtype == np.uint8:
+            pil_image = Image.fromarray(image_np)
+        else:
+            pil_image = Image.fromarray((image_np * 255).astype(np.uint8))
+        
+        # Preprocess
+        inputs = grounding_dino_processor(images=pil_image, text=text_prompt, return_tensors="pt")
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+        
+        # Inference
+        with torch.no_grad():
+            outputs = grounding_dino_model(**inputs)
+        
+        # Post-process
+        results = grounding_dino_processor.post_process_grounded_object_detection(
+            outputs,
+            inputs["input_ids"],
+            threshold=GROUNDING_DINO_BOX_THRESHOLD,
+            text_threshold=GROUNDING_DINO_TEXT_THRESHOLD,
+            target_sizes=[pil_image.size[::-1]]
+        )[0]
+        
+        # Convert to unified format
+        detections = []
+        boxes = results["boxes"].cpu().numpy()
+        scores = results["scores"].cpu().numpy()
+        labels = results["labels"]
+        
+        print(f"✅ Detected {len(boxes)} objects")
+        
+        for box, score, label in zip(boxes, scores, labels):
+            detection = {
+                'bbox': box.tolist(),  # [x1, y1, x2, y2]
+                'label': label,
+                'confidence': float(score)
+            }
+            detections.append(detection)
+            print(f"   - {label}: {score:.2f}")
+        
+        return detections
+        
+    except Exception as e:
+        print(f"❌ GroundingDINO detection failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return []
+
+
+def run_sam_refinement(image_np, boxes):
+    """Run SAM precise segmentation"""
+    if sam_predictor is None:
+        print("⚠️ SAM not loaded, using bbox as mask")
+        # Use bbox to create simple rectangular mask
+        masks = []
+        h, w = image_np.shape[:2]
+        for box in boxes:
+            x1, y1, x2, y2 = map(int, box)
+            mask = np.zeros((h, w), dtype=bool)
+            mask[y1:y2, x1:x2] = True
+            masks.append(mask)
+        return masks
+    
+    try:
+        print(f"🎯 SAM precise segmentation for {len(boxes)} regions...")
+        sam_predictor.set_image(image_np)
+        
+        masks = []
+        for box in boxes:
+            x1, y1, x2, y2 = map(int, box)
+            box_array = np.array([x1, y1, x2, y2])
+            
+            mask_output, _, _ = sam_predictor.predict(
+                box=box_array,
+                multimask_output=False
+            )
+            masks.append(mask_output[0])
+        
+        print(f"✅ SAM segmentation complete")
+        return masks
+        
+    except Exception as e:
+        print(f"❌ SAM segmentation failed: {e}")
+        # Fallback to bbox masks
+        masks = []
+        h, w = image_np.shape[:2]
+        for box in boxes:
+            x1, y1, x2, y2 = map(int, box)
+            mask = np.zeros((h, w), dtype=bool)
+            mask[y1:y2, x1:x2] = True
+            masks.append(mask)
+        return masks
+
+
+def normalize_label(label):
+    """Normalize label to main category"""
+    label = label.strip().lower()
+    
+    priority_labels = ['sofa', 'bed', 'table', 'desk', 'chair', 'cabinet', 'window', 'door']
+    
+    for priority in priority_labels:
+        if priority in label:
+            return priority
+    
+    first_word = label.split()[0] if label else label
+    
+    # Handle plural forms
+    if first_word.endswith('s') and len(first_word) > 1:
+        singular = first_word[:-1]
+        if first_word.endswith('sses'):
+            singular = first_word[:-2]
+        elif first_word.endswith('ies'):
+            singular = first_word[:-3] + 'y'
+        elif first_word.endswith('ves'):
+            singular = first_word[:-3] + 'f'
+        return singular
+    
+    return first_word
+
+
+def compute_object_3d_center(points, mask):
+    """Compute 3D center of object"""
+    masked_points = points[mask]
+    if len(masked_points) == 0:
+        return None
+    return np.median(masked_points, axis=0)
+
+
+def compute_adaptive_eps(centers, base_eps):
+    """Adaptively compute eps value based on object distribution"""
+    if len(centers) <= 1:
+        return base_eps
+    
+    from scipy.spatial.distance import pdist
+    distances = pdist(centers)
+    
+    if len(distances) == 0:
+        return base_eps
+    
+    median_dist = np.median(distances)
+    
+    if median_dist > base_eps * 2:
+        adaptive_eps = min(median_dist * 0.6, base_eps * 2.5)
+    elif median_dist > base_eps:
+        adaptive_eps = median_dist * 0.5
+    else:
+        adaptive_eps = base_eps
+    
+    return adaptive_eps
+
+
+def match_objects_across_views(all_view_detections):
+    """Match objects across views using DBSCAN clustering"""
+    print("\n🔗 Matching objects across views using DBSCAN clustering...")
+    
+    objects_by_label = defaultdict(list)
+    
+    for view_idx, detections in enumerate(all_view_detections):
+        for det_idx, det in enumerate(detections):
+            if det.get('center_3d') is None:
+                continue
+            
+            norm_label = normalize_label(det['label'])
+            objects_by_label[norm_label].append({
+                'view_idx': view_idx,
+                'det_idx': det_idx,
+                'label': det['label'],
+                'norm_label': norm_label,
+                'center_3d': det['center_3d'],
+                'confidence': det['confidence'],
+            })
+    
+    if len(objects_by_label) == 0:
+        return {}, []
+    
+    object_id_map = defaultdict(dict)
+    unique_objects = []
+    next_global_id = 0
+    
+    for norm_label, objects in objects_by_label.items():
+        print(f"\n   📦 Processing {norm_label}: {len(objects)} detections")
+        
+        if len(objects) == 1:
+            obj = objects[0]
+            unique_objects.append({
+                'global_id': next_global_id,
+                'label': obj['label'],
+                'views': [(obj['view_idx'], obj['det_idx'])],
+                'center_3d': obj['center_3d'],
+            })
+            object_id_map[obj['view_idx']][obj['det_idx']] = next_global_id
+            next_global_id += 1
+            print(f"      → 1 cluster (single detection)")
+            continue
+        
+        centers = np.array([obj['center_3d'] for obj in objects])
+        
+        base_eps = DBSCAN_EPS_CONFIG.get(norm_label, DBSCAN_EPS_CONFIG.get('default', 1.0))
+        eps = compute_adaptive_eps(centers, base_eps)
+        
+        clustering = DBSCAN(eps=eps, min_samples=DBSCAN_MIN_SAMPLES, metric='euclidean')
+        cluster_labels = clustering.fit_predict(centers)
+        
+        n_clusters = len(set(cluster_labels)) - (1 if -1 in cluster_labels else 0)
+        n_noise = list(cluster_labels).count(-1)
+        
+        if eps != base_eps:
+            print(f"      → {n_clusters} clusters (base_eps={base_eps}m → adaptive_eps={eps:.2f}m)")
+        else:
+            print(f"      → {n_clusters} clusters (eps={eps}m)")
+        if n_noise > 0:
+            print(f"      ⚠️  {n_noise} noise points (isolated detections)")
+        
+        for cluster_id in set(cluster_labels):
+            if cluster_id == -1:
+                for i, label in enumerate(cluster_labels):
+                    if label == -1:
+                        obj = objects[i]
+                        unique_objects.append({
+                            'global_id': next_global_id,
+                            'label': obj['label'],
+                            'views': [(obj['view_idx'], obj['det_idx'])],
+                            'center_3d': obj['center_3d'],
+                        })
+                        object_id_map[obj['view_idx']][obj['det_idx']] = next_global_id
+                        next_global_id += 1
+            else:
+                cluster_objects = [objects[i] for i, label in enumerate(cluster_labels) if label == cluster_id]
+                
+                total_conf = sum(o['confidence'] for o in cluster_objects)
+                weighted_center = sum(o['center_3d'] * o['confidence'] for o in cluster_objects) / total_conf
+                
+                unique_objects.append({
+                    'global_id': next_global_id,
+                    'label': cluster_objects[0]['label'],
+                    'views': [(o['view_idx'], o['det_idx']) for o in cluster_objects],
+                    'center_3d': weighted_center,
+                })
+                
+                for obj in cluster_objects:
+                    object_id_map[obj['view_idx']][obj['det_idx']] = next_global_id
+                
+                next_global_id += 1
+    
+    print(f"\n   📊 Summary:")
+    print(f"      Total detections: {sum(len(objs) for objs in objects_by_label.values())}")
+    print(f"      Unique objects: {len(unique_objects)}")
+    
+    return object_id_map, unique_objects
+
+
+def create_multi_view_segmented_mesh(processed_data, all_view_detections, all_view_masks, 
+                                     object_id_map, unique_objects, target_dir):
+    """Create multi-view fused segmented mesh"""
+    try:
+        print("\n🎨 Generating multi-view segmented mesh...")
+        
+        unique_normalized_labels = sorted(set(normalize_label(obj['label']) for obj in unique_objects))
+        label_colors = {}
+        colors = generate_distinct_colors(len(unique_normalized_labels))
+        
+        for i, norm_label in enumerate(unique_normalized_labels):
+            label_colors[norm_label] = colors[i]
+        
+        for obj in unique_objects:
+            norm_label = normalize_label(obj['label'])
+            obj['color'] = label_colors[norm_label]
+            obj['normalized_label'] = norm_label
+        
+        print(f"   Object category color mapping:")
+        for norm_label, color in sorted(label_colors.items()):
+            count = sum(1 for obj in unique_objects if normalize_label(obj['label']) == norm_label)
+            print(f"   {norm_label} × {count} → RGB{color}")
+        
+        import utils3d
+        
+        all_meshes = []
+        
+        for view_idx in range(len(processed_data)):
+            view_data = processed_data[view_idx]
+            image = view_data["image"]
+            points3d = view_data["points3d"]
+            mask = view_data.get("mask")
+            normal = view_data.get("normal")
+            
+            detections = all_view_detections[view_idx]
+            masks = all_view_masks[view_idx]
+            
+            if len(detections) == 0:
+                continue
+            
+            if image.dtype != np.uint8:
+                if image.max() <= 1.0:
+                    image = (image * 255).astype(np.uint8)
+                else:
+                    image = image.astype(np.uint8)
+            
+            colored_image = image.copy()
+            confidence_map = np.zeros((image.shape[0], image.shape[1]), dtype=np.float32)
+            
+            detections_info = []
+            filtered_count = 0
+            for det_idx, (det, seg_mask) in enumerate(zip(detections, masks)):
+                if det['confidence'] < MIN_DETECTION_CONFIDENCE:
+                    filtered_count += 1
+                    continue
+                
+                mask_area = seg_mask.sum()
+                if mask_area < MIN_MASK_AREA:
+                    filtered_count += 1
+                    continue
+                
+                global_id = object_id_map[view_idx].get(det_idx)
+                if global_id is None:
+                    continue
+                
+                unique_obj = next((obj for obj in unique_objects if obj['global_id'] == global_id), None)
+                if unique_obj is None:
+                    continue
+                
+                detections_info.append({
+                    'mask': seg_mask,
+                    'color': unique_obj['color'],
+                    'confidence': det['confidence'],
+                })
+            
+            if filtered_count > 0:
+                print(f"   View {view_idx + 1}: filtered {filtered_count} low-quality detections")
+            
+            detections_info.sort(key=lambda x: x['confidence'])
+            
+            for info in detections_info:
+                seg_mask = info['mask']
+                color = info['color']
+                conf = info['confidence']
+                
+                update_mask = seg_mask & (conf > confidence_map)
+                colored_image[update_mask] = color
+                confidence_map[update_mask] = conf
+            
+            height, width = image.shape[:2]
+            
+            if normal is None:
+                faces, vertices, vertex_colors, vertex_uvs = utils3d.numpy.image_mesh(
+                    points3d,
+                    colored_image.astype(np.float32) / 255,
+                    utils3d.numpy.image_uv(width=width, height=height),
+                    mask=mask if mask is not None else np.ones((height, width), dtype=bool),
+                    tri=True
+                )
+                vertex_normals = None
+            else:
+                faces, vertices, vertex_colors, vertex_uvs, vertex_normals = utils3d.numpy.image_mesh(
+                    points3d,
+                    colored_image.astype(np.float32) / 255,
+                    utils3d.numpy.image_uv(width=width, height=height),
+                    normal,
+                    mask=mask if mask is not None else np.ones((height, width), dtype=bool),
+                    tri=True
+                )
+            
+            vertices = vertices * np.array([1, -1, -1], dtype=np.float32)
+            if vertex_normals is not None:
+                vertex_normals = vertex_normals * np.array([1, -1, -1], dtype=np.float32)
+            
+            view_mesh = trimesh.Trimesh(
+                vertices=vertices,
+                faces=faces,
+                vertex_normals=vertex_normals,
+                vertex_colors=(vertex_colors * 255).astype(np.uint8),
+                process=False
+            )
+            
+            all_meshes.append(view_mesh)
+            print(f"   View {view_idx + 1}: {len(vertices):,} vertices, {len(faces):,} faces")
+        
+        if len(all_meshes) == 0:
+            print("⚠️ No mesh generated")
+            return None
+        
+        print("   Fusing all views...")
+        combined_mesh = trimesh.util.concatenate(all_meshes)
+        
+        glb_path = os.path.join(target_dir, 'segmented_mesh.glb')
+        combined_mesh.export(glb_path)
+        
+        print(f"✅ Multi-view segmented mesh saved: {glb_path}")
+        print(f"   Total: {len(combined_mesh.vertices):,} vertices, {len(combined_mesh.faces):,} faces")
+        print(f"   {len(unique_objects)} unique objects")
+        
+        return glb_path
+        
+    except Exception as e:
+        print(f"❌ Failed to generate multi-view mesh: {e}")
+        import traceback
+        traceback.print_exc()
+        return None
+
+
+# ============================================================================
+# Core Model Inference
+# ============================================================================
+
+@spaces.GPU(duration=120)
+def run_model(
+    target_dir,
+    apply_mask=True,
+    mask_edges=True,
+    filter_black_bg=False,
+    filter_white_bg=False,
+    enable_segmentation=False,
+    text_prompt=DEFAULT_TEXT_PROMPT,
+):
+    """
+    Run the MapAnything model + optional segmentation
+    """
+    global model
+    import torch
+
+    print(f"Processing images from {target_dir}")
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    device = torch.device(device)
+
+    # Initialize MapAnything model
+    if model is None:
+        model = initialize_mapanything_model(high_level_config, device)
+    else:
+        model = model.to(device)
+
+    model.eval()
+
+    # Load segmentation models if enabled
+    if enable_segmentation:
+        load_grounding_dino_model(device)
+        load_sam_model(device)
+
+    # Load images
+    print("Loading images...")
+    image_folder_path = os.path.join(target_dir, "images")
+    views = load_images(image_folder_path)
+
+    print(f"Loaded {len(views)} images")
+    if len(views) == 0:
+        raise ValueError("No images found. Check your upload.")
+
+    # Run model inference
+    print("Running inference...")
+    outputs = model.infer(
+        views, apply_mask=apply_mask, mask_edges=True, memory_efficient_inference=False
+    )
+
+    # Convert predictions
+    predictions = {}
+    extrinsic_list = []
+    intrinsic_list = []
+    world_points_list = []
+    depth_maps_list = []
+    images_list = []
+    final_mask_list = []
+
+    for pred in outputs:
+        depthmap_torch = pred["depth_z"][0].squeeze(-1)
+        intrinsics_torch = pred["intrinsics"][0]
+        camera_pose_torch = pred["camera_poses"][0]
+
+        pts3d_computed, valid_mask = depthmap_to_world_frame(
+            depthmap_torch, intrinsics_torch, camera_pose_torch
+        )
+
+        if "mask" in pred:
+            mask = pred["mask"][0].squeeze(-1).cpu().numpy().astype(bool)
+        else:
+            mask = np.ones_like(depthmap_torch.cpu().numpy(), dtype=bool)
+
+        mask = mask & valid_mask.cpu().numpy()
+        image = pred["img_no_norm"][0].cpu().numpy()
+
+        extrinsic_list.append(camera_pose_torch.cpu().numpy())
+        intrinsic_list.append(intrinsics_torch.cpu().numpy())
+        world_points_list.append(pts3d_computed.cpu().numpy())
+        depth_maps_list.append(depthmap_torch.cpu().numpy())
+        images_list.append(image)
+        final_mask_list.append(mask)
+
+    predictions["extrinsic"] = np.stack(extrinsic_list, axis=0)
+    predictions["intrinsic"] = np.stack(intrinsic_list, axis=0)
+    predictions["world_points"] = np.stack(world_points_list, axis=0)
+
+    depth_maps = np.stack(depth_maps_list, axis=0)
+    if len(depth_maps.shape) == 3:
+        depth_maps = depth_maps[..., np.newaxis]
+    predictions["depth"] = depth_maps
+
+    predictions["images"] = np.stack(images_list, axis=0)
+    predictions["final_mask"] = np.stack(final_mask_list, axis=0)
+
+    # Process visualization data
+    processed_data = process_predictions_for_visualization(
+        predictions, views, high_level_config, filter_black_bg, filter_white_bg
+    )
+
+    # Segmentation processing
+    segmented_glb = None
+    if enable_segmentation and grounding_dino_model is not None:
+        print("\n🎯 Starting segmentation...")
+        print(f"🔍 Detection prompt: {text_prompt[:100]}...")
+
+        all_view_detections = []
+        all_view_masks = []
+
+        for view_idx, ref_image in enumerate(images_list):
+            print(f"\n📸 Processing view {view_idx + 1}/{len(images_list)}...")
+
+            if ref_image.dtype != np.uint8:
+                ref_image_np = (ref_image * 255).astype(np.uint8)
+            else:
+                ref_image_np = ref_image
+
+            detections = run_grounding_dino_detection(ref_image_np, text_prompt, device)
+
+            if len(detections) > 0:
+                boxes = [d['bbox'] for d in detections]
+                masks = run_sam_refinement(ref_image_np, boxes)
+
+                points3d = world_points_list[view_idx]
+
+                for det_idx, (det, mask) in enumerate(zip(detections, masks)):
+                    center_3d = compute_object_3d_center(points3d, mask)
+                    det['center_3d'] = center_3d
+                    det['mask_2d'] = mask
+
+                all_view_detections.append(detections)
+                all_view_masks.append(masks)
+            else:
+                all_view_detections.append([])
+                all_view_masks.append([])
+
+        # Match objects across views
+        if any(len(dets) > 0 for dets in all_view_detections):
+            object_id_map, unique_objects = match_objects_across_views(all_view_detections)
+
+            # Generate segmented mesh
+            segmented_glb = create_multi_view_segmented_mesh(
+                processed_data, all_view_detections, all_view_masks,
+                object_id_map, unique_objects, target_dir
+            )
+
+    # Cleanup
+    torch.cuda.empty_cache()
+
+    return predictions, processed_data, segmented_glb
+
+
+# ============================================================================
+# Helper Functions (from app.py)
+# ============================================================================
+
+def update_view_selectors(processed_data):
+    """Update view selector dropdowns based on available views"""
+    if processed_data is None or len(processed_data) == 0:
+        choices = ["View 1"]
+    else:
+        num_views = len(processed_data)
+        choices = [f"View {i + 1}" for i in range(num_views)]
+
+    return (
+        gr.Dropdown(choices=choices, value=choices[0]),
+        gr.Dropdown(choices=choices, value=choices[0]),
+        gr.Dropdown(choices=choices, value=choices[0]),
+    )
+
+
+def get_view_data_by_index(processed_data, view_index):
+    """Get view data by index, handling bounds"""
+    if processed_data is None or len(processed_data) == 0:
+        return None
+
+    view_keys = list(processed_data.keys())
+    if view_index < 0 or view_index >= len(view_keys):
+        view_index = 0
+
+    return processed_data[view_keys[view_index]]
+
+
+def update_depth_view(processed_data, view_index):
+    """Update depth view for a specific view index"""
+    view_data = get_view_data_by_index(processed_data, view_index)
+    if view_data is None or view_data["depth"] is None:
+        return None
+
+    return colorize_depth(view_data["depth"], mask=view_data.get("mask"))
+
+
+def update_normal_view(processed_data, view_index):
+    """Update normal view for a specific view index"""
+    view_data = get_view_data_by_index(processed_data, view_index)
+    if view_data is None or view_data["normal"] is None:
+        return None
+
+    return colorize_normal(view_data["normal"], mask=view_data.get("mask"))
+
+
+def update_measure_view(processed_data, view_index):
+    """Update measure view for a specific view index with mask overlay"""
+    view_data = get_view_data_by_index(processed_data, view_index)
+    if view_data is None:
+        return None, []
+
+    image = view_data["image"].copy()
+
+    if image.dtype != np.uint8:
+        if image.max() <= 1.0:
+            image = (image * 255).astype(np.uint8)
+        else:
+            image = image.astype(np.uint8)
+
+    if view_data["mask"] is not None:
+        mask = view_data["mask"]
+        invalid_mask = ~mask
+
+        if invalid_mask.any():
+            overlay_color = np.array([255, 220, 220], dtype=np.uint8)
+            alpha = 0.5
+            for c in range(3):
+                image[:, :, c] = np.where(
+                    invalid_mask,
+                    (1 - alpha) * image[:, :, c] + alpha * overlay_color[c],
+                    image[:, :, c],
+                ).astype(np.uint8)
+
+    return image, []
+
+
+def navigate_depth_view(processed_data, current_selector_value, direction):
+    """Navigate depth view (direction: -1 for previous, +1 for next)"""
+    if processed_data is None or len(processed_data) == 0:
+        return "View 1", None
+
+    try:
+        current_view = int(current_selector_value.split()[1]) - 1
+    except:
+        current_view = 0
+
+    num_views = len(processed_data)
+    new_view = (current_view + direction) % num_views
+
+    new_selector_value = f"View {new_view + 1}"
+    depth_vis = update_depth_view(processed_data, new_view)
+
+    return new_selector_value, depth_vis
+
+
+def navigate_normal_view(processed_data, current_selector_value, direction):
+    """Navigate normal view (direction: -1 for previous, +1 for next)"""
+    if processed_data is None or len(processed_data) == 0:
+        return "View 1", None
+
+    try:
+        current_view = int(current_selector_value.split()[1]) - 1
+    except:
+        current_view = 0
+
+    num_views = len(processed_data)
+    new_view = (current_view + direction) % num_views
+
+    new_selector_value = f"View {new_view + 1}"
+    normal_vis = update_normal_view(processed_data, new_view)
+
+    return new_selector_value, normal_vis
+
+
+def navigate_measure_view(processed_data, current_selector_value, direction):
+    """Navigate measure view (direction: -1 for previous, +1 for next)"""
+    if processed_data is None or len(processed_data) == 0:
+        return "View 1", None, []
+
+    try:
+        current_view = int(current_selector_value.split()[1]) - 1
+    except:
+        current_view = 0
+
+    num_views = len(processed_data)
+    new_view = (current_view + direction) % num_views
+
+    new_selector_value = f"View {new_view + 1}"
+    measure_image, measure_points = update_measure_view(processed_data, new_view)
+
+    return new_selector_value, measure_image, measure_points
+
+
+def populate_visualization_tabs(processed_data):
+    """Populate the depth, normal, and measure tabs with processed data"""
+    if processed_data is None or len(processed_data) == 0:
+        return None, None, None, []
+
+    depth_vis = update_depth_view(processed_data, 0)
+    normal_vis = update_normal_view(processed_data, 0)
+    measure_img, _ = update_measure_view(processed_data, 0)
+
+    return depth_vis, normal_vis, measure_img, []
+
+
+def handle_uploads(unified_upload, s_time_interval=1.0):
+    """
+    Create a new 'target_dir' + 'images' subfolder, and place user-uploaded
+    images or extracted frames from video into it. Return (target_dir, image_paths).
+    """
+    start_time = time.time()
+    gc.collect()
+    torch.cuda.empty_cache()
+
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+    target_dir = f"input_images_{timestamp}"
+    target_dir_images = os.path.join(target_dir, "images")
+
+    if os.path.exists(target_dir):
+        shutil.rmtree(target_dir)
+    os.makedirs(target_dir)
+    os.makedirs(target_dir_images)
+
+    image_paths = []
+
+    if unified_upload is not None:
+        for file_data in unified_upload:
+            if isinstance(file_data, dict) and "name" in file_data:
+                file_path = file_data["name"]
+            else:
+                file_path = str(file_data)
+
+            file_ext = os.path.splitext(file_path)[1].lower()
+
+            video_extensions = [
+                ".mp4", ".avi", ".mov", ".mkv", ".wmv", ".flv", ".webm", ".m4v", ".3gp",
+            ]
+            if file_ext in video_extensions:
+                vs = cv2.VideoCapture(file_path)
+                fps = vs.get(cv2.CAP_PROP_FPS)
+                frame_interval = int(fps * s_time_interval)
+
+                count = 0
+                video_frame_num = 0
+                while True:
+                    gotit, frame = vs.read()
+                    if not gotit:
+                        break
+                    count += 1
+                    if count % frame_interval == 0:
+                        base_name = os.path.splitext(os.path.basename(file_path))[0]
+                        image_path = os.path.join(
+                            target_dir_images, f"{base_name}_{video_frame_num:06}.png"
+                        )
+                        cv2.imwrite(image_path, frame)
+                        image_paths.append(image_path)
+                        video_frame_num += 1
+                vs.release()
+                print(f"Extracted {video_frame_num} frames from video: {os.path.basename(file_path)}")
+
+            else:
+                if file_ext in [".heic", ".heif"]:
+                    try:
+                        with Image.open(file_path) as img:
+                            if img.mode not in ("RGB", "L"):
+                                img = img.convert("RGB")
+
+                            base_name = os.path.splitext(os.path.basename(file_path))[0]
+                            dst_path = os.path.join(target_dir_images, f"{base_name}.jpg")
+
+                            img.save(dst_path, "JPEG", quality=95)
+                            image_paths.append(dst_path)
+                            print(f"Converted HEIC to JPEG: {os.path.basename(file_path)} -> {os.path.basename(dst_path)}")
+                    except Exception as e:
+                        print(f"Error converting HEIC file {file_path}: {e}")
+                        dst_path = os.path.join(target_dir_images, os.path.basename(file_path))
+                        shutil.copy(file_path, dst_path)
+                        image_paths.append(dst_path)
+                else:
+                    dst_path = os.path.join(target_dir_images, os.path.basename(file_path))
+                    shutil.copy(file_path, dst_path)
+                    image_paths.append(dst_path)
+
+    image_paths = sorted(image_paths)
+
+    end_time = time.time()
+    print(f"Files processed to {target_dir_images}; took {end_time - start_time:.3f} seconds")
+    return target_dir, image_paths
+
+
+def update_gallery_on_upload(input_video, input_images, s_time_interval=1.0):
+    """Update gallery on upload"""
+    if not input_video and not input_images:
+        return None, None, None, None, None
+    target_dir, image_paths = handle_uploads(input_video, input_images, s_time_interval)
+    return (
+        None,
+        None,
+        target_dir,
+        image_paths,
+        "Upload complete. Click 'Reconstruct' to begin 3D processing.",
+    )
+
+
+@spaces.GPU(duration=120)
+def gradio_demo(
+    target_dir,
+    frame_filter="All",
+    show_cam=True,
+    filter_black_bg=False,
+    filter_white_bg=False,
+    conf_thres=3.0,
+    apply_mask=True,
+    show_mesh=True,
+    enable_segmentation=False,
+    text_prompt=DEFAULT_TEXT_PROMPT,
+    use_sam=True,
+):
+    """执行重建"""
+    if not os.path.isdir(target_dir) or target_dir == "None":
+        return None, None, "❌ 未找到有效的目标目录，请先上传文件", None, None, None, None, None, None, None, None, None
+
+    start_time = time.time()
+    gc.collect()
+    torch.cuda.empty_cache()
+
+    target_dir_images = os.path.join(target_dir, "images")
+    all_files = (
+        sorted(os.listdir(target_dir_images))
+        if os.path.isdir(target_dir_images)
+        else []
+    )
+    all_files = [f"{i}: {filename}" for i, filename in enumerate(all_files)]
+    frame_filter_choices = ["All"] + all_files
+
+    print("运行 MapAnything 模型...")
+    with torch.no_grad():
+        predictions, processed_data, segmented_glb = run_model(
+            target_dir, apply_mask, True, filter_black_bg, filter_white_bg,
+            enable_segmentation, text_prompt
+        )
+
+    # 保存预测结果
+    prediction_save_path = os.path.join(target_dir, "predictions.npz")
+    np.savez(prediction_save_path, **predictions)
+
+    if frame_filter is None:
+        frame_filter = "All"
+
+    # 生成 GLB 文件名
+    glbfile = os.path.join(
+        target_dir,
+        f"glbscene_{frame_filter.replace('.', '_').replace(':', '').replace(' ', '_')}_cam{show_cam}_mesh{show_mesh}.glb",
+    )
+
+    # 转换预测结果为 GLB
+    glbscene = predictions_to_glb(
+        predictions,
+        filter_by_frames=frame_filter,
+        show_cam=show_cam,
+        mask_black_bg=filter_black_bg,
+        mask_white_bg=filter_white_bg,
+        as_mesh=show_mesh,
+        conf_percentile=conf_thres,
+    )
+    glbscene.export(file_obj=glbfile)
+
+    # 清理内存
+    del predictions
+    gc.collect()
+    torch.cuda.empty_cache()
+
+    end_time = time.time()
+    print(f"总耗时: {end_time - start_time:.2f}秒")
+    log_msg = f"✅ 重建成功 ({len(all_files)} 帧)"
+
+    # Populate visualization tabs
+    depth_vis, normal_vis, measure_img, measure_pts = populate_visualization_tabs(
+        processed_data
+    )
+
+    # Update view selectors
+    depth_selector, normal_selector, measure_selector = update_view_selectors(
+        processed_data
+    )
+
+    return (
+        glbfile,
+        segmented_glb,
+        log_msg,
+        gr.Dropdown(choices=frame_filter_choices, value=frame_filter, interactive=True),
+        processed_data,
+        depth_vis,
+        normal_vis,
+        measure_img,
+        "",
+        depth_selector,
+        normal_selector,
+        measure_selector,
+    )
+
+
+def colorize_depth(depth_map, mask=None):
+    """Convert depth map to colorized visualization with optional mask"""
+    if depth_map is None:
+        return None
+
+    depth_normalized = depth_map.copy()
+    valid_mask = depth_normalized > 0
+
+    if mask is not None:
+        valid_mask = valid_mask & mask
+
+    if valid_mask.sum() > 0:
+        valid_depths = depth_normalized[valid_mask]
+        p5 = np.percentile(valid_depths, 5)
+        p95 = np.percentile(valid_depths, 95)
+
+        depth_normalized[valid_mask] = (depth_normalized[valid_mask] - p5) / (p95 - p5)
+
+    import matplotlib.pyplot as plt
+
+    colormap = plt.cm.turbo_r
+    colored = colormap(depth_normalized)
+    colored = (colored[:, :, :3] * 255).astype(np.uint8)
+
+    colored[~valid_mask] = [255, 255, 255]
+
+    return colored
+
+
+def colorize_normal(normal_map, mask=None):
+    """Convert normal map to colorized visualization with optional mask"""
+    if normal_map is None:
+        return None
+
+    normal_vis = normal_map.copy()
+
+    if mask is not None:
+        invalid_mask = ~mask
+        normal_vis[invalid_mask] = [0, 0, 0]
+
+    normal_vis = (normal_vis + 1.0) / 2.0
+    normal_vis = (normal_vis * 255).astype(np.uint8)
+
+    return normal_vis
+
+
+def process_predictions_for_visualization(
+    predictions, views, high_level_config, filter_black_bg=False, filter_white_bg=False
+):
+    """Extract depth, normal, and 3D points from predictions for visualization"""
+    processed_data = {}
+
+    for view_idx, view in enumerate(views):
+        image = rgb(view["img"], norm_type=high_level_config["data_norm_type"])
+
+        pred_pts3d = predictions["world_points"][view_idx]
+
+        view_data = {
+            "image": image[0],
+            "points3d": pred_pts3d,
+            "depth": None,
+            "normal": None,
+            "mask": None,
+        }
+
+        mask = predictions["final_mask"][view_idx].copy()
+
+        if filter_black_bg:
+            view_colors = image[0] * 255 if image[0].max() <= 1.0 else image[0]
+            black_bg_mask = view_colors.sum(axis=2) >= 16
+            mask = mask & black_bg_mask
+
+        if filter_white_bg:
+            view_colors = image[0] * 255 if image[0].max() <= 1.0 else image[0]
+            white_bg_mask = ~(
+                (view_colors[:, :, 0] > 240)
+                & (view_colors[:, :, 1] > 240)
+                & (view_colors[:, :, 2] > 240)
+            )
+            mask = mask & white_bg_mask
+
+        view_data["mask"] = mask
+        view_data["depth"] = predictions["depth"][view_idx].squeeze()
+
+        normals, _ = points_to_normals(pred_pts3d, mask=view_data["mask"])
+        view_data["normal"] = normals
+
+        processed_data[view_idx] = view_data
+
+    return processed_data
+
+
+def reset_measure(processed_data):
+    """Reset measure points"""
+    if processed_data is None or len(processed_data) == 0:
+        return None, [], ""
+
+    first_view = list(processed_data.values())[0]
+    return first_view["image"], [], ""
+
+
+def measure(
+    processed_data, measure_points, current_view_selector, event: gr.SelectData
+):
+    """Handle measurement on images"""
+    try:
+        print(f"测量功能调用，选择器: {current_view_selector}")
+
+        if processed_data is None or len(processed_data) == 0:
+            return None, [], "❌ 没有可用数据"
+
+        try:
+            current_view_index = int(current_view_selector.split()[1]) - 1
+        except:
+            current_view_index = 0
+
+        print(f"使用视图索引: {current_view_index}")
+
+        if current_view_index < 0 or current_view_index >= len(processed_data):
+            current_view_index = 0
+
+        view_keys = list(processed_data.keys())
+        current_view = processed_data[view_keys[current_view_index]]
+
+        if current_view is None:
+            return None, [], "❌ 没有视图数据"
+
+        point2d = event.index[0], event.index[1]
+        print(f"点击点: {point2d}")
+
+        if (
+            current_view["mask"] is not None
+            and 0 <= point2d[1] < current_view["mask"].shape[0]
+            and 0 <= point2d[0] < current_view["mask"].shape[1]
+        ):
+            if not current_view["mask"][point2d[1], point2d[0]]:
+                print(f"点击点 {point2d} 在遮罩区域，忽略点击")
+                masked_image, _ = update_measure_view(
+                    processed_data, current_view_index
+                )
+                return (
+                    masked_image,
+                    measure_points,
+                    '<span style="color: red; font-weight: bold;">⚠️ 无法在遮罩区域测量（显示为灰色）</span>',
+                )
+
+        measure_points.append(point2d)
+
+        image, _ = update_measure_view(processed_data, current_view_index)
+        if image is None:
+            return None, [], "❌ 没有可用图像"
+
+        image = image.copy()
+        points3d = current_view["points3d"]
+
+        try:
+            if image.dtype != np.uint8:
+                if image.max() <= 1.0:
+                    image = (image * 255).astype(np.uint8)
+                else:
+                    image = image.astype(np.uint8)
+        except Exception as e:
+            print(f"图像转换错误: {e}")
+            return None, [], f"❌ 图像转换错误: {e}"
+
+        try:
+            for p in measure_points:
+                if 0 <= p[0] < image.shape[1] and 0 <= p[1] < image.shape[0]:
+                    image = cv2.circle(
+                        image, p, radius=5, color=(255, 0, 0), thickness=2
+                    )
+        except Exception as e:
+            print(f"绘制错误: {e}")
+            return None, [], f"❌ 绘制错误: {e}"
+
+        depth_text = ""
+        try:
+            for i, p in enumerate(measure_points):
+                if (
+                    current_view["depth"] is not None
+                    and 0 <= p[1] < current_view["depth"].shape[0]
+                    and 0 <= p[0] < current_view["depth"].shape[1]
+                ):
+                    d = current_view["depth"][p[1], p[0]]
+                    depth_text += f"- **P{i + 1} 深度: {d:.2f}m**\n"
+                else:
+                    if (
+                        points3d is not None
+                        and 0 <= p[1] < points3d.shape[0]
+                        and 0 <= p[0] < points3d.shape[1]
+                    ):
+                        z = points3d[p[1], p[0], 2]
+                        depth_text += f"- **P{i + 1} Z坐标: {z:.2f}m**\n"
+        except Exception as e:
+            print(f"深度文本错误: {e}")
+            depth_text = f"❌ 深度计算错误: {e}\n"
+
+        if len(measure_points) == 2:
+            try:
+                point1, point2 = measure_points
+                if (
+                    0 <= point1[0] < image.shape[1]
+                    and 0 <= point1[1] < image.shape[0]
+                    and 0 <= point2[0] < image.shape[1]
+                    and 0 <= point2[1] < image.shape[0]
+                ):
+                    image = cv2.line(
+                        image, point1, point2, color=(255, 0, 0), thickness=2
+                    )
+
+                distance_text = "- **距离: 无法计算**"
+                if (
+                    points3d is not None
+                    and 0 <= point1[1] < points3d.shape[0]
+                    and 0 <= point1[0] < points3d.shape[1]
+                    and 0 <= point2[1] < points3d.shape[0]
+                    and 0 <= point2[0] < points3d.shape[1]
+                ):
+                    try:
+                        p1_3d = points3d[point1[1], point1[0]]
+                        p2_3d = points3d[point2[1], point2[0]]
+                        distance = np.linalg.norm(p1_3d - p2_3d)
+                        distance_text = f"- **距离: {distance:.2f}m**"
+                    except Exception as e:
+                        print(f"距离计算错误: {e}")
+                        distance_text = f"- **距离计算错误: {e}**"
+
+                measure_points = []
+                text = depth_text + distance_text
+                print(f"测量完成: {text}")
+                return [image, measure_points, text]
+            except Exception as e:
+                print(f"最终测量错误: {e}")
+                return None, [], f"❌ 测量错误: {e}"
+        else:
+            print(f"单点测量: {depth_text}")
+            return [image, measure_points, depth_text]
+
+    except Exception as e:
+        print(f"整体测量功能错误: {e}")
+        return None, [], f"❌ 测量功能错误: {e}"
+
+
+def clear_fields():
+    """清空 3D 查看器"""
+    return None, None
+
+
+def update_log():
+    """显示日志消息"""
+    return "🔄 加载和重建中..."
+
+
+def update_visualization(
+    target_dir,
+    frame_filter,
+    show_cam,
+    is_example,
+    conf_thres=None,
+    filter_black_bg=False,
+    filter_white_bg=False,
+    show_mesh=True,
+):
+    """更新可视化"""
+    if is_example == "True":
+        return gr.update(), "❌ 没有可用的重建。请先点击重建按钮。"
+
+    if not target_dir or target_dir == "None" or not os.path.isdir(target_dir):
+        return gr.update(), "❌ 没有可用的重建。请先点击重建按钮。"
+
+    predictions_path = os.path.join(target_dir, "predictions.npz")
+    if not os.path.exists(predictions_path):
+        return gr.update(), f"❌ 没有可用的重建。请先运行「重建」。"
+
+    loaded = np.load(predictions_path, allow_pickle=True)
+    predictions = {key: loaded[key] for key in loaded.keys()}
+
+    glbfile = os.path.join(
+        target_dir,
+        f"glbscene_{frame_filter.replace('.', '_').replace(':', '').replace(' ', '_')}_cam{show_cam}_mesh{show_mesh}_black{filter_black_bg}_white{filter_white_bg}.glb",
+    )
+
+    glbscene = predictions_to_glb(
+        predictions,
+        filter_by_frames=frame_filter,
+        show_cam=show_cam,
+        mask_black_bg=filter_black_bg,
+        mask_white_bg=filter_white_bg,
+        as_mesh=show_mesh,
+        conf_percentile=conf_thres,
+    )
+    glbscene.export(file_obj=glbfile)
+
+    return glbfile, "✅ 可视化已更新。"
+
+
+def update_all_views_on_filter_change(
+    target_dir,
+    filter_black_bg,
+    filter_white_bg,
+    processed_data,
+    depth_view_selector,
+    normal_view_selector,
+    measure_view_selector,
+):
+    """Update all individual view tabs when background filtering checkboxes change"""
+    if not target_dir or target_dir == "None" or not os.path.isdir(target_dir):
+        return processed_data, None, None, None, []
+
+    predictions_path = os.path.join(target_dir, "predictions.npz")
+    if not os.path.exists(predictions_path):
+        return processed_data, None, None, None, []
+
+    try:
+        loaded = np.load(predictions_path, allow_pickle=True)
+        predictions = {key: loaded[key] for key in loaded.keys()}
+
+        image_folder_path = os.path.join(target_dir, "images")
+        views = load_images(image_folder_path)
+
+        new_processed_data = process_predictions_for_visualization(
+            predictions, views, high_level_config, filter_black_bg, filter_white_bg
+        )
+
+        try:
+            depth_view_idx = (
+                int(depth_view_selector.split()[1]) - 1 if depth_view_selector else 0
+            )
+        except:
+            depth_view_idx = 0
+
+        try:
+            normal_view_idx = (
+                int(normal_view_selector.split()[1]) - 1 if normal_view_selector else 0
+            )
+        except:
+            normal_view_idx = 0
+
+        try:
+            measure_view_idx = (
+                int(measure_view_selector.split()[1]) - 1
+                if measure_view_selector
+                else 0
+            )
+        except:
+            measure_view_idx = 0
+
+        depth_vis = update_depth_view(new_processed_data, depth_view_idx)
+        normal_vis = update_normal_view(new_processed_data, normal_view_idx)
+        measure_img, _ = update_measure_view(new_processed_data, measure_view_idx)
+
+        return new_processed_data, depth_vis, normal_vis, measure_img, []
+
+    except Exception as e:
+        print(f"Error updating views on filter change: {e}")
+        return processed_data, None, None, None, []
+
+
+# ============================================================================
+# Example Scene Functions
+# ============================================================================
+
+def get_scene_info(examples_dir):
+    """Get information about scenes in the examples directory"""
+    import glob
+
+    scenes = []
+    if not os.path.exists(examples_dir):
+        return scenes
+
+    for scene_folder in sorted(os.listdir(examples_dir)):
+        scene_path = os.path.join(examples_dir, scene_folder)
+        if os.path.isdir(scene_path):
+            image_extensions = ["*.jpg", "*.jpeg", "*.png", "*.bmp", "*.tiff", "*.tif"]
+            image_files = []
+            for ext in image_extensions:
+                image_files.extend(glob.glob(os.path.join(scene_path, ext)))
+                image_files.extend(glob.glob(os.path.join(scene_path, ext.upper())))
+
+            if image_files:
+                image_files = sorted(image_files)
+                first_image = image_files[0]
+                num_images = len(image_files)
+
+                scenes.append(
+                    {
+                        "name": scene_folder,
+                        "path": scene_path,
+                        "thumbnail": first_image,
+                        "num_images": num_images,
+                        "image_files": image_files,
+                    }
+                )
+
+    return scenes
+
+
+def load_example_scene(scene_name, examples_dir="examples"):
+    """从示例目录加载场景"""
+    scenes = get_scene_info(examples_dir)
+
+    selected_scene = None
+    for scene in scenes:
+        if scene["name"] == scene_name:
+            selected_scene = scene
+            break
+
+    if selected_scene is None:
+        return None, None, None, None, "❌ 场景未找到"
+
+    file_objects = []
+    for image_path in selected_scene["image_files"]:
+        file_objects.append(image_path)
+
+    target_dir, image_paths = handle_uploads(file_objects, 1.0)
+
+    return (
+        None,
+        None,
+        target_dir,
+        image_paths,
+        f"✅ 已加载场景 '{scene_name}' ({selected_scene['num_images']} 张图像)。点击「开始重建」进行 3D 处理。",
+    )
+
+
+# ============================================================================
+# Gradio UI
+# ============================================================================
+
+theme = get_gradio_theme()
+
+# 自定义CSS防止UI抖动
+CUSTOM_CSS = GRADIO_CSS + """
+/* 防止组件撑开布局 */
+.gradio-container {
+    max-width: 100% !important;
+}
+
+/* 固定Gallery高度 */
+.gallery-container {
+    max-height: 350px !important;
+    overflow-y: auto !important;
+}
+
+/* 固定File组件高度 */
+.file-preview {
+    max-height: 200px !important;
+    overflow-y: auto !important;
+}
+
+/* 固定Video组件高度 */
+.video-container {
+    max-height: 300px !important;
+}
+
+/* 防止Textbox无限扩展 */
+.textbox-container {
+    max-height: 100px !important;
+}
+
+/* 保持Tabs内容区域稳定 */
+.tab-content {
+    min-height: 550px !important;
+}
+"""
+
+with gr.Blocks(theme=theme, css=CUSTOM_CSS, title="MapAnything V2 - 3D重建与物体分割") as demo:
+    is_example = gr.Textbox(label="is_example", visible=False, value="None")
+    processed_data_state = gr.State(value=None)
+    measure_points_state = gr.State(value=[])
+
+    # 顶部标题
+    gr.HTML("""
+    <div style="text-align: center; margin: 20px 0;">
+        <h2 style="color: #1976D2; margin-bottom: 10px;">MapAnything V2 - 3D重建与物体分割</h2>
+        <p style="color: #666; font-size: 16px;">基于DBSCAN聚类的智能物体识别 | 多视图融合 | 自适应参数调整</p>
+    </div>
+    """)
+
+    target_dir_output = gr.Textbox(label="Target Dir", visible=False, value="None")
+
+    with gr.Row(equal_height=False):
+        # 左侧：输入区域
+        with gr.Column(scale=1, min_width=300):
+            gr.Markdown("### 📤 输入")
+            
+            with gr.Tabs():
+                with gr.Tab("📷 图片"):
+                    input_images = gr.File(
+                        file_count="multiple", 
+                        label="上传多张图片（推荐3-10张）", 
+                        interactive=True,
+                        height=200
+                    )
+                
+                with gr.Tab("🎥 视频"):
+                    input_video = gr.Video(
+                        label="上传视频", 
+                        interactive=True,
+                        height=300
+                    )
+                    s_time_interval = gr.Slider(
+                        minimum=0.1, maximum=5.0, value=1.0, step=0.1,
+                        label="帧采样间隔（秒）", interactive=True
+                    )
+            
+            image_gallery = gr.Gallery(
+                label="图片预览", columns=3, height=350,
+                show_download_button=True, object_fit="contain", preview=True
+            )
+            
+            with gr.Row():
+                submit_btn = gr.Button("🚀 开始重建", variant="primary", scale=2)
+                clear_btn = gr.ClearButton(
+                    [input_video, input_images, target_dir_output, image_gallery],
+                    value="🗑️ 清空", scale=1
+                )
+
+        # 右侧：输出区域
+        with gr.Column(scale=2, min_width=600):
+            gr.Markdown("### 🎯 输出")
+
+            with gr.Tabs():
+                with gr.Tab("🏗️ 原始3D"):
+                    reconstruction_output = gr.Model3D(
+                        height=550, zoom_speed=0.5, pan_speed=0.5,
+                        clear_color=[0.0, 0.0, 0.0, 0.0]
+                    )
+                
+                with gr.Tab("🎨 分割3D"):
+                    segmented_output = gr.Model3D(
+                        height=550, zoom_speed=0.5, pan_speed=0.5,
+                        clear_color=[0.0, 0.0, 0.0, 0.0]
+                    )
+                
+                with gr.Tab("📊 深度图"):
+                    with gr.Row(elem_classes=["navigation-row"]):
+                        prev_depth_btn = gr.Button("◀", size="sm", scale=1)
+                        depth_view_selector = gr.Dropdown(
+                            choices=["View 1"], value="View 1",
+                            label="视图", scale=3, interactive=True
+                        )
+                        next_depth_btn = gr.Button("▶", size="sm", scale=1)
+                    depth_map = gr.Image(
+                        type="numpy", label="", format="png", interactive=False,
+                        height=500
+                    )
+                
+                with gr.Tab("🧭 法线图"):
+                    with gr.Row(elem_classes=["navigation-row"]):
+                        prev_normal_btn = gr.Button("◀", size="sm", scale=1)
+                        normal_view_selector = gr.Dropdown(
+                            choices=["View 1"], value="View 1",
+                            label="视图", scale=3, interactive=True
+                        )
+                        next_normal_btn = gr.Button("▶", size="sm", scale=1)
+                    normal_map = gr.Image(
+                        type="numpy", label="", format="png", interactive=False,
+                        height=500
+                    )
+                
+                with gr.Tab("📏 测量"):
+                    gr.Markdown("**点击图片两次进行距离测量**")
+                    with gr.Row(elem_classes=["navigation-row"]):
+                        prev_measure_btn = gr.Button("◀", size="sm", scale=1)
+                        measure_view_selector = gr.Dropdown(
+                            choices=["View 1"], value="View 1",
+                            label="视图", scale=3, interactive=True
+                        )
+                        next_measure_btn = gr.Button("▶", size="sm", scale=1)
+                    measure_image = gr.Image(
+                        type="numpy", show_label=False,
+                        format="webp", interactive=False, sources=[],
+                        height=500
+                    )
+                    measure_text = gr.Markdown("")
+            
+            log_output = gr.Textbox(
+                value="📌 请上传图片或视频，然后点击「开始重建」",
+                label="状态信息",
+                interactive=False,
+                lines=1,
+                max_lines=1
+            )
+
+    # 高级选项（可折叠）
+    with gr.Accordion("⚙️ 高级选项", open=False):
+        with gr.Row(equal_height=False):
+            with gr.Column(scale=1, min_width=300):
+                gr.Markdown("#### 可视化参数")
+                frame_filter = gr.Dropdown(
+                    choices=["All"], value="All", label="显示帧"
+                )
+                conf_thres = gr.Slider(
+                    minimum=0, maximum=100, value=0, step=0.1,
+                    label="置信度阈值（百分位）"
+                )
+                show_cam = gr.Checkbox(label="显示相机", value=True)
+                show_mesh = gr.Checkbox(label="显示网格", value=True)
+                filter_black_bg = gr.Checkbox(label="过滤黑色背景", value=False)
+                filter_white_bg = gr.Checkbox(label="过滤白色背景", value=False)
+            
+            with gr.Column(scale=1, min_width=300):
+                gr.Markdown("#### 重建参数")
+                apply_mask_checkbox = gr.Checkbox(
+                    label="应用深度掩码", value=True
+                )
+                
+                gr.Markdown("#### 分割参数")
+                enable_segmentation = gr.Checkbox(
+                    label="启用语义分割", value=False
+                )
+                
+                text_prompt = gr.Textbox(
+                    value=DEFAULT_TEXT_PROMPT,
+                    label="检测物体（用 . 分隔）",
+                    placeholder="例如: chair . table . sofa",
+                    lines=2,
+                    max_lines=2
+                )
+                
+                with gr.Row():
+                    detect_all_btn = gr.Button("🔍 检测所有", size="sm")
+                    restore_default_btn = gr.Button("↻ 默认", size="sm")
+
+    # 示例场景（可折叠）
+    with gr.Accordion("🖼️ 示例场景", open=False):
+        scenes = get_scene_info("examples")
+        if scenes:
+            for i in range(0, len(scenes), 4):
+                with gr.Row(equal_height=True):
+                    for j in range(4):
+                        scene_idx = i + j
+                        if scene_idx < len(scenes):
+                            scene = scenes[scene_idx]
+                            with gr.Column(scale=1, min_width=150):
+                                scene_img = gr.Image(
+                                    value=scene["thumbnail"], 
+                                    height=150,
+                                    interactive=False, 
+                                    show_label=False, 
+                                    sources=[],
+                                    container=False
+                                )
+                                gr.Markdown(
+                                    f"**{scene['name']}** ({scene['num_images']}张)",
+                                    elem_classes=["text-center"]
+                                )
+                                scene_img.select(
+                                    fn=lambda name=scene["name"]: load_example_scene(name),
+                                    outputs=[
+                                        reconstruction_output, segmented_output,
+                                        target_dir_output, image_gallery, log_output
+                                    ]
+                                )
+
+    # === 事件绑定 ===
+    
+    # 分割选项按钮
+    detect_all_btn.click(
+        fn=lambda: COMMON_OBJECTS_PROMPT,
+        outputs=[text_prompt]
+    )
+    restore_default_btn.click(
+        fn=lambda: DEFAULT_TEXT_PROMPT,
+        outputs=[text_prompt]
+    )
+    
+    # 上传文件自动更新
+    def update_gallery_on_unified_upload(files_video, files_images, interval):
+        if not files_video and not files_images:
+            return None, None, None, None
+        # Combine both inputs
+        all_files = []
+        if files_video:
+            all_files.append(files_video)
+        if files_images:
+            all_files.extend(files_images)
+        target_dir, image_paths = handle_uploads(all_files, interval)
+        return (
+            None,
+            target_dir,
+            image_paths,
+            "✅ 上传完成，点击「开始重建」进行 3D 处理",
+        )
+    
+    input_video.change(
+        fn=update_gallery_on_unified_upload,
+        inputs=[input_video, input_images, s_time_interval],
+        outputs=[segmented_output, target_dir_output, image_gallery, log_output]
+    )
+    input_images.change(
+        fn=update_gallery_on_unified_upload,
+        inputs=[input_video, input_images, s_time_interval],
+        outputs=[segmented_output, target_dir_output, image_gallery, log_output]
+    )
+    
+    # 重建按钮
+    submit_btn.click(
+        fn=clear_fields,
+        outputs=[reconstruction_output, segmented_output]
+    ).then(
+        fn=update_log,
+        outputs=[log_output]
+    ).then(
+        fn=gradio_demo,
+        inputs=[
+            target_dir_output, frame_filter, show_cam,
+            filter_black_bg, filter_white_bg, conf_thres,
+            apply_mask_checkbox, show_mesh,
+            enable_segmentation, text_prompt
+        ],
+        outputs=[
+            reconstruction_output, segmented_output, log_output, frame_filter,
+            processed_data_state, depth_map, normal_map, measure_image,
+            measure_text, depth_view_selector, normal_view_selector, measure_view_selector
+        ]
+    ).then(
+        fn=lambda: "False",
+        outputs=[is_example]
+    )
+    
+    # 清空按钮
+    clear_btn.add([reconstruction_output, segmented_output, log_output])
+    
+    # 可视化参数实时更新
+    for component in [frame_filter, show_cam, conf_thres, show_mesh]:
+        component.change(
+            fn=update_visualization,
+            inputs=[
+                target_dir_output, frame_filter, show_cam, is_example,
+                conf_thres, filter_black_bg, filter_white_bg, show_mesh
+            ],
+            outputs=[reconstruction_output, log_output]
+        )
+    
+    # 背景过滤器更新所有视图
+    for bg_filter in [filter_black_bg, filter_white_bg]:
+        bg_filter.change(
+            fn=update_all_views_on_filter_change,
+            inputs=[
+                target_dir_output, filter_black_bg, filter_white_bg, processed_data_state,
+                depth_view_selector, normal_view_selector, measure_view_selector
+            ],
+            outputs=[processed_data_state, depth_map, normal_map, measure_image, measure_points_state]
+        )
+    
+    # 深度图导航
+    prev_depth_btn.click(
+        fn=lambda pd, cs: navigate_depth_view(pd, cs, -1),
+        inputs=[processed_data_state, depth_view_selector],
+        outputs=[depth_view_selector, depth_map]
+    )
+    next_depth_btn.click(
+        fn=lambda pd, cs: navigate_depth_view(pd, cs, 1),
+        inputs=[processed_data_state, depth_view_selector],
+        outputs=[depth_view_selector, depth_map]
+    )
+    depth_view_selector.change(
+        fn=lambda pd, sv: update_depth_view(pd, int(sv.split()[1]) - 1) if sv else None,
+        inputs=[processed_data_state, depth_view_selector],
+        outputs=[depth_map]
+    )
+    
+    # 法线图导航
+    prev_normal_btn.click(
+        fn=lambda pd, cs: navigate_normal_view(pd, cs, -1),
+        inputs=[processed_data_state, normal_view_selector],
+        outputs=[normal_view_selector, normal_map]
+    )
+    next_normal_btn.click(
+        fn=lambda pd, cs: navigate_normal_view(pd, cs, 1),
+        inputs=[processed_data_state, normal_view_selector],
+        outputs=[normal_view_selector, normal_map]
+    )
+    normal_view_selector.change(
+        fn=lambda pd, sv: update_normal_view(pd, int(sv.split()[1]) - 1) if sv else None,
+        inputs=[processed_data_state, normal_view_selector],
+        outputs=[normal_map]
+    )
+    
+    # 测量功能
+    measure_image.select(
+        fn=measure,
+        inputs=[processed_data_state, measure_points_state, measure_view_selector],
+        outputs=[measure_image, measure_points_state, measure_text]
+    )
+    prev_measure_btn.click(
+        fn=lambda pd, cs: navigate_measure_view(pd, cs, -1),
+        inputs=[processed_data_state, measure_view_selector],
+        outputs=[measure_view_selector, measure_image, measure_points_state]
+    )
+    next_measure_btn.click(
+        fn=lambda pd, cs: navigate_measure_view(pd, cs, 1),
+        inputs=[processed_data_state, measure_view_selector],
+        outputs=[measure_view_selector, measure_image, measure_points_state]
+    )
+    measure_view_selector.change(
+        fn=lambda pd, sv: update_measure_view(pd, int(sv.split()[1]) - 1) if sv else (None, []),
+        inputs=[processed_data_state, measure_view_selector],
+        outputs=[measure_image, measure_points_state]
+    )
+
+# 启动信息
+print("\n" + "="*60)
+print("🚀 MapAnything V2 - 3D重建与物体分割")
+print("="*60)
+print("📊 核心技术: 自适应DBSCAN聚类 + 多视图融合")
+print(f"🔧 质量控制: 置信度≥{MIN_DETECTION_CONFIDENCE} | 面积≥{MIN_MASK_AREA}px")
+print(f"🎯 聚类半径: 沙发{DBSCAN_EPS_CONFIG['sofa']}m | 桌子{DBSCAN_EPS_CONFIG['table']}m | 窗户{DBSCAN_EPS_CONFIG['window']}m | 默认{DBSCAN_EPS_CONFIG['default']}m")
+print("="*60 + "\n")
+
+demo.queue(max_size=20).launch(show_error=True, share=True, ssr_mode=False)

configs/calibration_benchmark.yaml

@@ -0,0 +1,23 @@
+defaults:
+  - machine: aws
+  - model: default
+  - dataset: default
+  - _self_
+
+output_dir: ${hydra:run.dir}
+root_data_dir: ${machine.root_data_dir}
+mapanything_dataset_metadata_dir: ${machine.mapanything_dataset_metadata_dir}
+root_pretrained_checkpoints_dir: ${machine.root_pretrained_checkpoints_dir}
+root_experiments_dir: ${machine.root_experiments_dir}
+root_uniception_pretrained_checkpoints_dir: ${machine.root_uniception_pretrained_checkpoints_dir}
+
+### Benchmarking args
+seed: 0
+# Disable CUDNN Benchmark (Disable for variable resolution & number of view training)
+disable_cudnn_benchmark: true
+# Batch size for inference (Metrics are computed per multi-view set and averaged, not per batch of multi-view sets)
+batch_size: 20
+# Use mixed precision for inference
+amp: 1
+# Floating point type to use for mixed precision
+amp_dtype: "bf16"

configs/dataset/ase_wai/default.yaml

@@ -0,0 +1,3 @@
+defaults:
+  - train: default
+  - val: default

configs/dataset/ase_wai/train/default.yaml

@@ -0,0 +1,26 @@
+dataset_str:
+  "ASEWAI(
+    split='${dataset.ase_wai.train.split}',
+    resolution=${dataset.ase_wai.train.dataset_resolution},
+    principal_point_centered=${dataset.ase_wai.train.principal_point_centered},
+    aug_crop=${dataset.ase_wai.train.aug_crop},
+    transform='${dataset.ase_wai.train.transform}',
+    data_norm_type='${dataset.ase_wai.train.data_norm_type}',
+    ROOT='${dataset.ase_wai.train.ROOT}',
+    dataset_metadata_dir='${dataset.ase_wai.train.dataset_metadata_dir}',
+    overfit_num_sets=${dataset.ase_wai.train.overfit_num_sets},
+    variable_num_views=${dataset.ase_wai.train.variable_num_views},
+    num_views=${dataset.ase_wai.train.num_views},
+    covisibility_thres=${dataset.ase_wai.train.covisibility_thres})"
+split: 'train'
+dataset_resolution: ${dataset.resolution_train}
+principal_point_centered: ${dataset.principal_point_centered}
+aug_crop: 16
+transform: 'colorjitter+grayscale+gaublur'
+data_norm_type: ${model.data_norm_type}
+ROOT: ${root_data_dir}/ase
+dataset_metadata_dir: ${mapanything_dataset_metadata_dir}
+overfit_num_sets: null
+variable_num_views: ${dataset.train.variable_num_views}
+num_views: ${dataset.num_views}
+covisibility_thres: 0.25

configs/dataset/ase_wai/val/default.yaml

@@ -0,0 +1,26 @@
+dataset_str:
+  "ASEWAI(
+    split='${dataset.ase_wai.val.split}',
+    resolution=${dataset.ase_wai.val.dataset_resolution},
+    principal_point_centered=${dataset.ase_wai.val.principal_point_centered},
+    seed=${dataset.ase_wai.val.seed},
+    transform='${dataset.ase_wai.val.transform}',
+    data_norm_type='${dataset.ase_wai.val.data_norm_type}',
+    ROOT='${dataset.ase_wai.val.ROOT}',
+    dataset_metadata_dir='${dataset.ase_wai.val.dataset_metadata_dir}',
+    overfit_num_sets=${dataset.ase_wai.val.overfit_num_sets},
+    variable_num_views=${dataset.ase_wai.val.variable_num_views},
+    num_views=${dataset.ase_wai.val.num_views},
+    covisibility_thres=${dataset.ase_wai.val.covisibility_thres})"
+split: 'val'
+dataset_resolution: ${dataset.resolution_val_ase}
+principal_point_centered: ${dataset.principal_point_centered}
+seed: 777
+transform: 'imgnorm'
+data_norm_type: ${model.data_norm_type}
+ROOT: ${root_data_dir}/ase
+dataset_metadata_dir: ${mapanything_dataset_metadata_dir}
+overfit_num_sets: null
+variable_num_views: ${dataset.val.variable_num_views}
+num_views: ${dataset.num_views}
+covisibility_thres: 0.25

configs/dataset/bedlam_wai/default.yaml

@@ -0,0 +1,3 @@
+defaults:
+  - train: default
+  - val: default

configs/dataset/bedlam_wai/train/default.yaml

@@ -0,0 +1,26 @@
+dataset_str:
+  "BedlamWAI(
+    split='${dataset.bedlam_wai.train.split}',
+    resolution=${dataset.bedlam_wai.train.dataset_resolution},
+    principal_point_centered=${dataset.bedlam_wai.train.principal_point_centered},
+    aug_crop=${dataset.bedlam_wai.train.aug_crop},
+    transform='${dataset.bedlam_wai.train.transform}',
+    data_norm_type='${dataset.bedlam_wai.train.data_norm_type}',
+    ROOT='${dataset.bedlam_wai.train.ROOT}',
+    dataset_metadata_dir='${dataset.bedlam_wai.train.dataset_metadata_dir}',
+    overfit_num_sets=${dataset.bedlam_wai.train.overfit_num_sets},
+    variable_num_views=${dataset.bedlam_wai.train.variable_num_views},
+    num_views=${dataset.bedlam_wai.train.num_views},
+    covisibility_thres=${dataset.bedlam_wai.train.covisibility_thres})"
+split: 'train'
+dataset_resolution: ${dataset.resolution_train}
+principal_point_centered: ${dataset.principal_point_centered}
+aug_crop: 16
+transform: 'colorjitter+grayscale+gaublur'
+data_norm_type: ${model.data_norm_type}
+ROOT: ${root_data_dir}/bedlam
+dataset_metadata_dir: ${mapanything_dataset_metadata_dir}
+overfit_num_sets: null
+variable_num_views: ${dataset.train.variable_num_views}
+num_views: ${dataset.num_views}
+covisibility_thres: 0.25

configs/dataset/bedlam_wai/val/default.yaml

@@ -0,0 +1,26 @@
+dataset_str:
+  "BedlamWAI(
+    split='${dataset.bedlam_wai.val.split}',
+    resolution=${dataset.bedlam_wai.val.dataset_resolution},
+    principal_point_centered=${dataset.bedlam_wai.val.principal_point_centered},
+    seed=${dataset.bedlam_wai.val.seed},
+    transform='${dataset.bedlam_wai.val.transform}',
+    data_norm_type='${dataset.bedlam_wai.val.data_norm_type}',
+    ROOT='${dataset.bedlam_wai.val.ROOT}',
+    dataset_metadata_dir='${dataset.bedlam_wai.val.dataset_metadata_dir}',
+    overfit_num_sets=${dataset.bedlam_wai.val.overfit_num_sets},
+    variable_num_views=${dataset.bedlam_wai.val.variable_num_views},
+    num_views=${dataset.bedlam_wai.val.num_views},
+    covisibility_thres=${dataset.bedlam_wai.val.covisibility_thres})"
+split: 'val'
+dataset_resolution: ${dataset.resolution_val_bedlam}
+principal_point_centered: ${dataset.principal_point_centered}
+seed: 777
+transform: 'imgnorm'
+data_norm_type: ${model.data_norm_type}
+ROOT: ${root_data_dir}/bedlam
+dataset_metadata_dir: ${mapanything_dataset_metadata_dir}
+overfit_num_sets: null
+variable_num_views: ${dataset.val.variable_num_views}
+num_views: ${dataset.num_views}
+covisibility_thres: 0.25

configs/dataset/benchmark_512_eth3d_snpp_tav2.yaml

@@ -0,0 +1,20 @@
+defaults:
+  - default
+
+# Number of views parameter for the multi-view datasets
+num_views: 2
+
+# Test Resolution
+resolution_test_eth3d: ${dataset.resolution_options.512_1_52_ar}
+resolution_test_scannetpp: ${dataset.resolution_options.512_1_52_ar}
+resolution_test_tav2_wb: ${dataset.resolution_options.512_1_00_ar}
+
+# Test Set
+# Sample 10 multi-view sets from each scene
+# ETH3D: 13 scenes
+# ScanNet++V2: 30 scenes
+# TartanAirV2-WB: 5 scenes
+test_dataset:
+  "+ 130 @ ${dataset.eth3d_wai.test.dataset_str}
+  + 300 @ ${dataset.scannetpp_wai.test.dataset_str}
+  + 50 @ ${dataset.tav2_wb_wai.test.dataset_str}"

configs/dataset/benchmark_512_snpp_tav2.yaml

@@ -0,0 +1,17 @@
+defaults:
+  - default
+
+# Number of views parameter for the multi-view datasets
+num_views: 2
+
+# Test Resolution
+resolution_test_scannetpp: ${dataset.resolution_options.512_1_52_ar}
+resolution_test_tav2_wb: ${dataset.resolution_options.512_1_00_ar}
+
+# Test Set
+# Sample 10 multi-view sets from each scene
+# ScanNet++V2: 30 scenes
+# TartanAirV2-WB: 5 scenes
+test_dataset:
+  "+ 300 @ ${dataset.scannetpp_wai.test.dataset_str}
+  + 50 @ ${dataset.tav2_wb_wai.test.dataset_str}"

configs/dataset/benchmark_518_eth3d_snpp_tav2.yaml

@@ -0,0 +1,20 @@
+defaults:
+  - default
+
+# Number of views parameter for the multi-view datasets
+num_views: 2
+
+# Test Resolution
+resolution_test_eth3d: ${dataset.resolution_options.518_1_52_ar}
+resolution_test_scannetpp: ${dataset.resolution_options.518_1_52_ar}
+resolution_test_tav2_wb: ${dataset.resolution_options.518_1_00_ar}
+
+# Test Set
+# Sample 10 multi-view sets from each scene
+# ETH3D: 13 scenes
+# ScanNet++V2: 30 scenes
+# TartanAirV2-WB: 5 scenes
+test_dataset:
+  "+ 130 @ ${dataset.eth3d_wai.test.dataset_str}
+  + 300 @ ${dataset.scannetpp_wai.test.dataset_str}
+  + 50 @ ${dataset.tav2_wb_wai.test.dataset_str}"

configs/dataset/benchmark_518_snpp_tav2.yaml

@@ -0,0 +1,17 @@
+defaults:
+  - default
+
+# Number of views parameter for the multi-view datasets
+num_views: 2
+
+# Test Resolution
+resolution_test_scannetpp: ${dataset.resolution_options.518_1_52_ar}
+resolution_test_tav2_wb: ${dataset.resolution_options.518_1_00_ar}
+
+# Test Set
+# Sample 10 multi-view sets from each scene
+# ScanNet++V2: 30 scenes
+# TartanAirV2-WB: 5 scenes
+test_dataset:
+  "+ 300 @ ${dataset.scannetpp_wai.test.dataset_str}
+  + 50 @ ${dataset.tav2_wb_wai.test.dataset_str}"

configs/dataset/benchmark_sv_calib_518_many_ar_eth3d_snpp_tav2.yaml

@@ -0,0 +1,20 @@
+defaults:
+  - default
+
+# Number of views parameter for the multi-view datasets
+num_views: 1
+
+# Test Resolution
+resolution_test_eth3d: ${dataset.resolution_options.518_many_ar}
+resolution_test_scannetpp: ${dataset.resolution_options.518_many_ar}
+resolution_test_tav2_wb: ${dataset.resolution_options.518_many_ar}
+
+# Test Set
+# Sample 20 frames from each scene
+# ETH3D: 13 scenes
+# ScanNet++V2: 30 scenes
+# TartanAirV2-WB: 5 scenes
+test_dataset:
+  "+ 260 @ ${dataset.eth3d_wai.test.dataset_str}
+  + 600 @ ${dataset.scannetpp_wai.test.dataset_str}
+  + 100 @ ${dataset.tav2_wb_wai.test.dataset_str}"

configs/dataset/blendedmvs_wai/default.yaml

@@ -0,0 +1,3 @@
+defaults:
+  - train: default
+  - val: default

configs/dataset/blendedmvs_wai/train/default.yaml

@@ -0,0 +1,26 @@
+dataset_str:
+  "BlendedMVSWAI(
+    split='${dataset.blendedmvs_wai.train.split}',
+    resolution=${dataset.blendedmvs_wai.train.dataset_resolution},
+    principal_point_centered=${dataset.blendedmvs_wai.train.principal_point_centered},
+    aug_crop=${dataset.blendedmvs_wai.train.aug_crop},
+    transform='${dataset.blendedmvs_wai.train.transform}',
+    data_norm_type='${dataset.blendedmvs_wai.train.data_norm_type}',
+    ROOT='${dataset.blendedmvs_wai.train.ROOT}',
+    dataset_metadata_dir='${dataset.blendedmvs_wai.train.dataset_metadata_dir}',
+    overfit_num_sets=${dataset.blendedmvs_wai.train.overfit_num_sets},
+    variable_num_views=${dataset.blendedmvs_wai.train.variable_num_views},
+    num_views=${dataset.blendedmvs_wai.train.num_views},
+    covisibility_thres=${dataset.blendedmvs_wai.train.covisibility_thres})"
+split: 'train'
+dataset_resolution: ${dataset.resolution_train}
+principal_point_centered: ${dataset.principal_point_centered}
+aug_crop: 16
+transform: 'colorjitter+grayscale+gaublur'
+data_norm_type: ${model.data_norm_type}
+ROOT: ${root_data_dir}/blendedmvs
+dataset_metadata_dir: ${mapanything_dataset_metadata_dir}
+overfit_num_sets: null
+variable_num_views: ${dataset.train.variable_num_views}
+num_views: ${dataset.num_views}
+covisibility_thres: 0.25

configs/dataset/blendedmvs_wai/val/default.yaml

@@ -0,0 +1,26 @@
+dataset_str:
+  "BlendedMVSWAI(
+    split='${dataset.blendedmvs_wai.val.split}',
+    resolution=${dataset.blendedmvs_wai.val.dataset_resolution},
+    principal_point_centered=${dataset.blendedmvs_wai.val.principal_point_centered},
+    seed=${dataset.blendedmvs_wai.val.seed},
+    transform='${dataset.blendedmvs_wai.val.transform}',
+    data_norm_type='${dataset.blendedmvs_wai.val.data_norm_type}',
+    ROOT='${dataset.blendedmvs_wai.val.ROOT}',
+    dataset_metadata_dir='${dataset.blendedmvs_wai.val.dataset_metadata_dir}',
+    overfit_num_sets=${dataset.blendedmvs_wai.val.overfit_num_sets},
+    variable_num_views=${dataset.blendedmvs_wai.val.variable_num_views},
+    num_views=${dataset.blendedmvs_wai.val.num_views},
+    covisibility_thres=${dataset.blendedmvs_wai.val.covisibility_thres})"
+split: 'val'
+dataset_resolution: ${dataset.resolution_val_blendedmvs}
+principal_point_centered: ${dataset.principal_point_centered}
+seed: 777
+transform: 'imgnorm'
+data_norm_type: ${model.data_norm_type}
+ROOT: ${root_data_dir}/blendedmvs
+dataset_metadata_dir: ${mapanything_dataset_metadata_dir}
+overfit_num_sets: null
+variable_num_views: ${dataset.val.variable_num_views}
+num_views: ${dataset.num_views}
+covisibility_thres: 0.25

configs/dataset/default.yaml

@@ -0,0 +1,45 @@
+defaults:
+  - resolution_options: default
+  - ase_wai: default
+  - bedlam_wai: default
+  - blendedmvs_wai: default
+  - dl3dv_wai: default
+  - dtu_wai: default
+  - dynamicreplica_wai: default
+  - eth3d_wai: default
+  - gta_sfm_wai: default
+  - matrixcity_wai: default
+  - megadepth_wai: default
+  - mpsd_wai: default
+  - mvs_synth_wai: default
+  - paralleldomain4d_wai: default
+  - sailvos3d_wai: default
+  - scannetpp_wai: default
+  - spring_wai: default
+  - structured3d_wai: default
+  - tav2_wb_wai: default
+  - unrealstereo4k_wai: default
+  - xrooms_wai: default
+
+# Training Set, For example: BlendedMVS(split='train', resolution=(512, 384), transform=...)
+train_dataset: ???
+# Validation Set
+test_dataset: "[null]"
+# Number of workers for dataloader
+num_workers: 12
+# Default resolution for training
+resolution_train: ???
+# Default resolution for validation
+resolution_val: ???
+# Number of views parameter for multi-view datasets
+num_views: 2
+# Use a centered principal point for all images
+principal_point_centered: false
+# Default config for multi-view datasets
+train:
+  # If True, the number of views can vary from batch to batch. The maximum number of views is num_views and minimum is 2. (On by default for N-view training)
+  variable_num_views: true
+val:
+  variable_num_views: false
+test:
+  variable_num_views: false

configs/dataset/dl3dv_wai/default.yaml

@@ -0,0 +1,3 @@
+defaults:
+  - train: default
+  - val: default

configs/dataset/dl3dv_wai/train/default.yaml

@@ -0,0 +1,28 @@
+dataset_str:
+  "DL3DVWAI(
+    split='${dataset.dl3dv_wai.train.split}',
+    resolution=${dataset.dl3dv_wai.train.dataset_resolution},
+    principal_point_centered=${dataset.dl3dv_wai.train.principal_point_centered},
+    aug_crop=${dataset.dl3dv_wai.train.aug_crop},
+    transform='${dataset.dl3dv_wai.train.transform}',
+    data_norm_type='${dataset.dl3dv_wai.train.data_norm_type}',
+    ROOT='${dataset.dl3dv_wai.train.ROOT}',
+    dataset_metadata_dir='${dataset.dl3dv_wai.train.dataset_metadata_dir}',
+    overfit_num_sets=${dataset.dl3dv_wai.train.overfit_num_sets},
+    variable_num_views=${dataset.dl3dv_wai.train.variable_num_views},
+    num_views=${dataset.dl3dv_wai.train.num_views},
+    covisibility_thres=${dataset.dl3dv_wai.train.covisibility_thres},
+    mvs_confidence_filter_thres=${dataset.dl3dv_wai.train.mvs_confidence_filter_thres})"
+split: 'train'
+dataset_resolution: ${dataset.resolution_train}
+principal_point_centered: ${dataset.principal_point_centered}
+aug_crop: 16
+transform: 'colorjitter+grayscale+gaublur'
+data_norm_type: ${model.data_norm_type}
+ROOT: ${root_data_dir}/dl3dv
+dataset_metadata_dir: ${mapanything_dataset_metadata_dir}
+overfit_num_sets: null
+variable_num_views: ${dataset.train.variable_num_views}
+num_views: ${dataset.num_views}
+covisibility_thres: 0.25
+mvs_confidence_filter_thres: 0.25

configs/dataset/dl3dv_wai/val/default.yaml

@@ -0,0 +1,28 @@
+dataset_str:
+  "DL3DVWAI(
+    split='${dataset.dl3dv_wai.val.split}',
+    resolution=${dataset.dl3dv_wai.val.dataset_resolution},
+    principal_point_centered=${dataset.dl3dv_wai.val.principal_point_centered},
+    seed=${dataset.dl3dv_wai.val.seed},
+    transform='${dataset.dl3dv_wai.val.transform}',
+    data_norm_type='${dataset.dl3dv_wai.val.data_norm_type}',
+    ROOT='${dataset.dl3dv_wai.val.ROOT}',
+    dataset_metadata_dir='${dataset.dl3dv_wai.val.dataset_metadata_dir}',
+    overfit_num_sets=${dataset.dl3dv_wai.val.overfit_num_sets},
+    variable_num_views=${dataset.dl3dv_wai.val.variable_num_views},
+    num_views=${dataset.dl3dv_wai.val.num_views},
+    covisibility_thres=${dataset.dl3dv_wai.val.covisibility_thres},
+    mvs_confidence_filter_thres=${dataset.dl3dv_wai.val.mvs_confidence_filter_thres})"
+split: 'val'
+dataset_resolution: ${dataset.resolution_val_dl3dv}
+principal_point_centered: ${dataset.principal_point_centered}
+seed: 777
+transform: 'imgnorm'
+data_norm_type: ${model.data_norm_type}
+ROOT: ${root_data_dir}/dl3dv
+dataset_metadata_dir: ${mapanything_dataset_metadata_dir}
+overfit_num_sets: null
+variable_num_views: ${dataset.val.variable_num_views}
+num_views: ${dataset.num_views}
+covisibility_thres: 0.25
+mvs_confidence_filter_thres: 0.25

configs/dataset/dtu_wai/default.yaml

@@ -0,0 +1,2 @@
+defaults:
+  - test: default

configs/dataset/dtu_wai/test/default.yaml

@@ -0,0 +1,22 @@
+dataset_str:
+  "DTUWAI(
+    resolution=${dataset.dtu_wai.test.dataset_resolution},
+    principal_point_centered=${dataset.dtu_wai.test.principal_point_centered},
+    seed=${dataset.dtu_wai.test.seed},
+    transform='${dataset.dtu_wai.test.transform}',
+    data_norm_type='${dataset.dtu_wai.test.data_norm_type}',
+    ROOT='${dataset.dtu_wai.test.ROOT}',
+    dataset_metadata_dir='${dataset.dtu_wai.test.dataset_metadata_dir}',
+    variable_num_views=${dataset.dtu_wai.test.variable_num_views},
+    num_views=${dataset.dtu_wai.test.num_views},
+    covisibility_thres=${dataset.dtu_wai.test.covisibility_thres})"
+dataset_resolution: ${dataset.resolution_test_dtu}
+principal_point_centered: ${dataset.principal_point_centered}
+seed: 777
+transform: 'imgnorm'
+data_norm_type: ${model.data_norm_type}
+ROOT: ${root_data_dir}/dtu
+dataset_metadata_dir: ${mapanything_dataset_metadata_dir}
+variable_num_views: ${dataset.test.variable_num_views}
+num_views: ${dataset.num_views}
+covisibility_thres: 0.25

configs/dataset/dynamicreplica_wai/default.yaml

@@ -0,0 +1,3 @@
+defaults:
+  - train: default
+  - val: default

configs/dataset/dynamicreplica_wai/train/default.yaml

@@ -0,0 +1,26 @@
+dataset_str:
+  "DynamicReplicaWAI(
+    split='${dataset.dynamicreplica_wai.train.split}',
+    resolution=${dataset.dynamicreplica_wai.train.dataset_resolution},
+    principal_point_centered=${dataset.dynamicreplica_wai.train.principal_point_centered},
+    aug_crop=${dataset.dynamicreplica_wai.train.aug_crop},
+    transform='${dataset.dynamicreplica_wai.train.transform}',
+    data_norm_type='${dataset.dynamicreplica_wai.train.data_norm_type}',
+    ROOT='${dataset.dynamicreplica_wai.train.ROOT}',
+    dataset_metadata_dir='${dataset.dynamicreplica_wai.train.dataset_metadata_dir}',
+    overfit_num_sets=${dataset.dynamicreplica_wai.train.overfit_num_sets},
+    variable_num_views=${dataset.dynamicreplica_wai.train.variable_num_views},
+    num_views=${dataset.dynamicreplica_wai.train.num_views},
+    covisibility_thres=${dataset.dynamicreplica_wai.train.covisibility_thres})"
+split: 'train'
+dataset_resolution: ${dataset.resolution_train}
+principal_point_centered: ${dataset.principal_point_centered}
+aug_crop: 16
+transform: 'colorjitter+grayscale+gaublur'
+data_norm_type: ${model.data_norm_type}
+ROOT: ${root_data_dir}/dynamicreplica
+dataset_metadata_dir: ${mapanything_dataset_metadata_dir}
+overfit_num_sets: null
+variable_num_views: ${dataset.train.variable_num_views}
+num_views: ${dataset.num_views}
+covisibility_thres: 0.25

configs/dataset/dynamicreplica_wai/val/default.yaml

@@ -0,0 +1,26 @@
+dataset_str:
+  "DynamicReplicaWAI(
+    split='${dataset.dynamicreplica_wai.val.split}',
+    resolution=${dataset.dynamicreplica_wai.val.dataset_resolution},
+    principal_point_centered=${dataset.dynamicreplica_wai.val.principal_point_centered},
+    seed=${dataset.dynamicreplica_wai.val.seed},
+    transform='${dataset.dynamicreplica_wai.val.transform}',
+    data_norm_type='${dataset.dynamicreplica_wai.val.data_norm_type}',
+    ROOT='${dataset.dynamicreplica_wai.val.ROOT}',
+    dataset_metadata_dir='${dataset.dynamicreplica_wai.val.dataset_metadata_dir}',
+    overfit_num_sets=${dataset.dynamicreplica_wai.val.overfit_num_sets},
+    variable_num_views=${dataset.dynamicreplica_wai.val.variable_num_views},
+    num_views=${dataset.dynamicreplica_wai.val.num_views},
+    covisibility_thres=${dataset.dynamicreplica_wai.val.covisibility_thres})"
+split: 'val'
+dataset_resolution: ${dataset.resolution_val_dynamicreplica}
+principal_point_centered: ${dataset.principal_point_centered}
+seed: 777
+transform: 'imgnorm'
+data_norm_type: ${model.data_norm_type}
+ROOT: ${root_data_dir}/dynamicreplica
+dataset_metadata_dir: ${mapanything_dataset_metadata_dir}
+overfit_num_sets: null
+variable_num_views: ${dataset.val.variable_num_views}
+num_views: ${dataset.num_views}
+covisibility_thres: 0.25

configs/dataset/eth3d_wai/default.yaml

@@ -0,0 +1,2 @@
+defaults:
+  - test: default

configs/dataset/eth3d_wai/test/default.yaml

@@ -0,0 +1,22 @@
+dataset_str:
+  "ETH3DWAI(
+    resolution=${dataset.eth3d_wai.test.dataset_resolution},
+    principal_point_centered=${dataset.eth3d_wai.test.principal_point_centered},
+    seed=${dataset.eth3d_wai.test.seed},
+    transform='${dataset.eth3d_wai.test.transform}',
+    data_norm_type='${dataset.eth3d_wai.test.data_norm_type}',
+    ROOT='${dataset.eth3d_wai.test.ROOT}',
+    dataset_metadata_dir='${dataset.eth3d_wai.test.dataset_metadata_dir}',
+    variable_num_views=${dataset.eth3d_wai.test.variable_num_views},
+    num_views=${dataset.eth3d_wai.test.num_views},
+    covisibility_thres=${dataset.eth3d_wai.test.covisibility_thres})"
+dataset_resolution: ${dataset.resolution_test_eth3d}
+principal_point_centered: ${dataset.principal_point_centered}
+seed: 777
+transform: 'imgnorm'
+data_norm_type: ${model.data_norm_type}
+ROOT: ${root_data_dir}/eth3d
+dataset_metadata_dir: ${mapanything_dataset_metadata_dir}
+variable_num_views: ${dataset.test.variable_num_views}
+num_views: ${dataset.num_views}
+covisibility_thres: 0.025

configs/dataset/gta_sfm_wai/default.yaml

@@ -0,0 +1,3 @@
+defaults:
+  - train: default
+  - val: default

configs/dataset/gta_sfm_wai/train/default.yaml

@@ -0,0 +1,26 @@
+dataset_str:
+  "GTASfMWAI(
+    split='${dataset.gta_sfm_wai.train.split}',
+    resolution=${dataset.gta_sfm_wai.train.dataset_resolution},
+    principal_point_centered=${dataset.gta_sfm_wai.train.principal_point_centered},
+    aug_crop=${dataset.gta_sfm_wai.train.aug_crop},
+    transform='${dataset.gta_sfm_wai.train.transform}',
+    data_norm_type='${dataset.gta_sfm_wai.train.data_norm_type}',
+    ROOT='${dataset.gta_sfm_wai.train.ROOT}',
+    dataset_metadata_dir='${dataset.gta_sfm_wai.train.dataset_metadata_dir}',
+    overfit_num_sets=${dataset.gta_sfm_wai.train.overfit_num_sets},
+    variable_num_views=${dataset.gta_sfm_wai.train.variable_num_views},
+    num_views=${dataset.gta_sfm_wai.train.num_views},
+    covisibility_thres=${dataset.gta_sfm_wai.train.covisibility_thres})"
+split: 'train'
+dataset_resolution: ${dataset.resolution_train}
+principal_point_centered: ${dataset.principal_point_centered}
+aug_crop: 16
+transform: 'colorjitter+grayscale+gaublur'
+data_norm_type: ${model.data_norm_type}
+ROOT: ${root_data_dir}/gta_sfm
+dataset_metadata_dir: ${mapanything_dataset_metadata_dir}
+overfit_num_sets: null
+variable_num_views: ${dataset.train.variable_num_views}
+num_views: ${dataset.num_views}
+covisibility_thres: 0.25

configs/dataset/gta_sfm_wai/val/default.yaml

@@ -0,0 +1,26 @@
+dataset_str:
+  "GTASfMWAI(
+    split='${dataset.gta_sfm_wai.val.split}',
+    resolution=${dataset.gta_sfm_wai.val.dataset_resolution},
+    principal_point_centered=${dataset.gta_sfm_wai.val.principal_point_centered},
+    seed=${dataset.gta_sfm_wai.val.seed},
+    transform='${dataset.gta_sfm_wai.val.transform}',
+    data_norm_type='${dataset.gta_sfm_wai.val.data_norm_type}',
+    ROOT='${dataset.gta_sfm_wai.val.ROOT}',
+    dataset_metadata_dir='${dataset.gta_sfm_wai.val.dataset_metadata_dir}',
+    overfit_num_sets=${dataset.gta_sfm_wai.val.overfit_num_sets},
+    variable_num_views=${dataset.gta_sfm_wai.val.variable_num_views},
+    num_views=${dataset.gta_sfm_wai.val.num_views},
+    covisibility_thres=${dataset.gta_sfm_wai.val.covisibility_thres})"
+split: 'val'
+dataset_resolution: ${dataset.resolution_val_gta_sfm}
+principal_point_centered: ${dataset.principal_point_centered}
+seed: 777
+transform: 'imgnorm'
+data_norm_type: ${model.data_norm_type}
+ROOT: ${root_data_dir}/gta_sfm
+dataset_metadata_dir: ${mapanything_dataset_metadata_dir}
+overfit_num_sets: null
+variable_num_views: ${dataset.val.variable_num_views}
+num_views: ${dataset.num_views}
+covisibility_thres: 0.25

configs/dataset/matrixcity_wai/default.yaml

@@ -0,0 +1,3 @@
+defaults:
+  - train: default
+  - val: default

configs/dataset/matrixcity_wai/train/default.yaml

@@ -0,0 +1,26 @@
+dataset_str:
+  "MatrixCityWAI(
+    split='${dataset.matrixcity_wai.train.split}',
+    resolution=${dataset.matrixcity_wai.train.dataset_resolution},
+    principal_point_centered=${dataset.matrixcity_wai.train.principal_point_centered},
+    aug_crop=${dataset.matrixcity_wai.train.aug_crop},
+    transform='${dataset.matrixcity_wai.train.transform}',
+    data_norm_type='${dataset.matrixcity_wai.train.data_norm_type}',
+    ROOT='${dataset.matrixcity_wai.train.ROOT}',
+    dataset_metadata_dir='${dataset.matrixcity_wai.train.dataset_metadata_dir}',
+    overfit_num_sets=${dataset.matrixcity_wai.train.overfit_num_sets},
+    variable_num_views=${dataset.matrixcity_wai.train.variable_num_views},
+    num_views=${dataset.matrixcity_wai.train.num_views},
+    covisibility_thres=${dataset.matrixcity_wai.train.covisibility_thres})"
+split: 'train'
+dataset_resolution: ${dataset.resolution_train}
+principal_point_centered: ${dataset.principal_point_centered}
+aug_crop: 16
+transform: 'colorjitter+grayscale+gaublur'
+data_norm_type: ${model.data_norm_type}
+ROOT: ${root_data_dir}/matrixcity
+dataset_metadata_dir: ${mapanything_dataset_metadata_dir}
+overfit_num_sets: null
+variable_num_views: ${dataset.train.variable_num_views}
+num_views: ${dataset.num_views}
+covisibility_thres: 0.25

configs/dataset/matrixcity_wai/val/default.yaml

@@ -0,0 +1,26 @@
+dataset_str:
+  "MatrixCityWAI(
+    split='${dataset.matrixcity_wai.val.split}',
+    resolution=${dataset.matrixcity_wai.val.dataset_resolution},
+    principal_point_centered=${dataset.matrixcity_wai.val.principal_point_centered},
+    seed=${dataset.matrixcity_wai.val.seed},
+    transform='${dataset.matrixcity_wai.val.transform}',
+    data_norm_type='${dataset.matrixcity_wai.val.data_norm_type}',
+    ROOT='${dataset.matrixcity_wai.val.ROOT}',
+    dataset_metadata_dir='${dataset.matrixcity_wai.val.dataset_metadata_dir}',
+    overfit_num_sets=${dataset.matrixcity_wai.val.overfit_num_sets},
+    variable_num_views=${dataset.matrixcity_wai.val.variable_num_views},
+    num_views=${dataset.matrixcity_wai.val.num_views},
+    covisibility_thres=${dataset.matrixcity_wai.val.covisibility_thres})"
+split: 'val'
+dataset_resolution: ${dataset.resolution_val_matrixcity}
+principal_point_centered: ${dataset.principal_point_centered}
+seed: 777
+transform: 'imgnorm'
+data_norm_type: ${model.data_norm_type}
+ROOT: ${root_data_dir}/matrixcity
+dataset_metadata_dir: ${mapanything_dataset_metadata_dir}
+overfit_num_sets: null
+variable_num_views: ${dataset.val.variable_num_views}
+num_views: ${dataset.num_views}
+covisibility_thres: 0.25

configs/dataset/megadepth_wai/default.yaml

@@ -0,0 +1,3 @@
+defaults:
+  - train: default
+  - val: default

configs/dataset/megadepth_wai/train/default.yaml

@@ -0,0 +1,26 @@
+dataset_str:
+  "MegaDepthWAI(
+    split='${dataset.megadepth_wai.train.split}',
+    resolution=${dataset.megadepth_wai.train.dataset_resolution},
+    principal_point_centered=${dataset.megadepth_wai.train.principal_point_centered},
+    aug_crop=${dataset.megadepth_wai.train.aug_crop},
+    transform='${dataset.megadepth_wai.train.transform}',
+    data_norm_type='${dataset.megadepth_wai.train.data_norm_type}',
+    ROOT='${dataset.megadepth_wai.train.ROOT}',
+    dataset_metadata_dir='${dataset.megadepth_wai.train.dataset_metadata_dir}',
+    overfit_num_sets=${dataset.megadepth_wai.train.overfit_num_sets},
+    variable_num_views=${dataset.megadepth_wai.train.variable_num_views},
+    num_views=${dataset.megadepth_wai.train.num_views},
+    covisibility_thres=${dataset.megadepth_wai.train.covisibility_thres})"
+split: 'train'
+dataset_resolution: ${dataset.resolution_train}
+principal_point_centered: ${dataset.principal_point_centered}
+aug_crop: 16
+transform: 'colorjitter+grayscale+gaublur'
+data_norm_type: ${model.data_norm_type}
+ROOT: ${root_data_dir}/megadepth
+dataset_metadata_dir: ${mapanything_dataset_metadata_dir}
+overfit_num_sets: null
+variable_num_views: ${dataset.train.variable_num_views}
+num_views: ${dataset.num_views}
+covisibility_thres: 0.25

configs/dataset/megadepth_wai/val/default.yaml

@@ -0,0 +1,26 @@
+dataset_str:
+  "MegaDepthWAI(
+    split='${dataset.megadepth_wai.val.split}',
+    resolution=${dataset.megadepth_wai.val.dataset_resolution},
+    principal_point_centered=${dataset.megadepth_wai.val.principal_point_centered},
+    seed=${dataset.megadepth_wai.val.seed},
+    transform='${dataset.megadepth_wai.val.transform}',
+    data_norm_type='${dataset.megadepth_wai.val.data_norm_type}',
+    ROOT='${dataset.megadepth_wai.val.ROOT}',
+    dataset_metadata_dir='${dataset.megadepth_wai.val.dataset_metadata_dir}',
+    overfit_num_sets=${dataset.megadepth_wai.val.overfit_num_sets},
+    variable_num_views=${dataset.megadepth_wai.val.variable_num_views},
+    num_views=${dataset.megadepth_wai.val.num_views},
+    covisibility_thres=${dataset.megadepth_wai.val.covisibility_thres})"
+split: 'val'
+dataset_resolution: ${dataset.resolution_val_megadepth}
+principal_point_centered: ${dataset.principal_point_centered}
+seed: 777
+transform: 'imgnorm'
+data_norm_type: ${model.data_norm_type}
+ROOT: ${root_data_dir}/megadepth
+dataset_metadata_dir: ${mapanything_dataset_metadata_dir}
+overfit_num_sets: null
+variable_num_views: ${dataset.val.variable_num_views}
+num_views: ${dataset.num_views}
+covisibility_thres: 0.25

configs/dataset/megatrain_11d_se_518_many_ar_48ipg_64g.yaml

@@ -0,0 +1,53 @@
+defaults:
+  - default
+
+# Number of views parameter for the multi-view datasets
+num_views: 4
+
+train:
+  # If True, the number of views can vary from batch to batch. The maximum number of views is num_views and minimum is 2. (On by default for N-view training)
+  variable_num_views: true
+
+# Train Resolution
+resolution_train: ${dataset.resolution_options.518_many_ar}
+
+# Validation Resolution
+resolution_val_ase: ${dataset.resolution_options.518_1_00_ar}
+resolution_val_dl3dv: ${dataset.resolution_options.518_1_77_ar}
+resolution_val_dynamicreplica: ${dataset.resolution_options.518_1_77_ar}
+resolution_val_mpsd: ${dataset.resolution_options.518_1_77_ar}
+resolution_val_mvs_synth: ${dataset.resolution_options.518_1_77_ar}
+resolution_val_paralleldomain4d: ${dataset.resolution_options.518_1_33_ar}
+resolution_val_sailvos3d: ${dataset.resolution_options.518_1_52_ar}
+resolution_val_scannetpp: ${dataset.resolution_options.518_1_52_ar}
+resolution_val_spring: ${dataset.resolution_options.518_1_77_ar}
+resolution_val_tav2_wb: ${dataset.resolution_options.518_1_00_ar}
+resolution_val_unrealstereo4k: ${dataset.resolution_options.518_1_77_ar}
+
+# Training Set
+train_dataset:
+  "+ 2_450_000 @ ${dataset.ase_wai.train.dataset_str}
+  + 250_000 @ ${dataset.dl3dv_wai.train.dataset_str}
+  + 12_400 @ ${dataset.dynamicreplica_wai.train.dataset_str}
+  + 1_675_000 @ ${dataset.mpsd_wai.train.dataset_str}
+  + 3_000 @ ${dataset.mvs_synth_wai.train.dataset_str}
+  + 36_000 @ ${dataset.paralleldomain4d_wai.train.dataset_str}
+  + 4_000 @ ${dataset.sailvos3d_wai.train.dataset_str}
+  + 22_600 @ ${dataset.scannetpp_wai.train.dataset_str}
+  + 800 @ ${dataset.spring_wai.train.dataset_str}
+  + 4_000 @ ${dataset.tav2_wb_wai.train.dataset_str}
+  + 200 @ ${dataset.unrealstereo4k_wai.train.dataset_str}"
+
+# Validation Set
+test_dataset:
+  "+ 4_000 @ ${dataset.ase_wai.val.dataset_str}
+  + 4_000 @ ${dataset.dl3dv_wai.val.dataset_str}
+  + 4_000 @ ${dataset.dynamicreplica_wai.val.dataset_str}
+  + 4_000 @ ${dataset.mpsd_wai.val.dataset_str}
+  + 4_000 @ ${dataset.mvs_synth_wai.val.dataset_str}
+  + 4_000 @ ${dataset.paralleldomain4d_wai.val.dataset_str}
+  + 4_000 @ ${dataset.sailvos3d_wai.val.dataset_str}
+  + 4_000 @ ${dataset.scannetpp_wai.val.dataset_str}
+  + 500 @ ${dataset.spring_wai.val.dataset_str}
+  + 4_000 @ ${dataset.tav2_wb_wai.val.dataset_str}
+  + 500 @ ${dataset.unrealstereo4k_wai.val.dataset_str}"

configs/dataset/megatrain_12d_518_many_ar_24ipg_16g.yaml

@@ -0,0 +1,56 @@
+defaults:
+  - default
+
+# Number of views parameter for the multi-view datasets
+num_views: 4
+
+train:
+  # If True, the number of views can vary from batch to batch. The maximum number of views is num_views and minimum is 2. (On by default for N-view training)
+  variable_num_views: true
+
+# Train Resolution
+resolution_train: ${dataset.resolution_options.518_many_ar}
+
+# Validation Resolution
+resolution_val_ase: ${dataset.resolution_options.518_1_00_ar}
+resolution_val_blendedmvs: ${dataset.resolution_options.518_1_33_ar}
+resolution_val_dynamicreplica: ${dataset.resolution_options.518_1_77_ar}
+resolution_val_megadepth: ${dataset.resolution_options.518_1_52_ar}
+resolution_val_mpsd: ${dataset.resolution_options.518_1_77_ar}
+resolution_val_mvs_synth: ${dataset.resolution_options.518_1_77_ar}
+resolution_val_paralleldomain4d: ${dataset.resolution_options.518_1_33_ar}
+resolution_val_sailvos3d: ${dataset.resolution_options.518_1_52_ar}
+resolution_val_scannetpp: ${dataset.resolution_options.518_1_52_ar}
+resolution_val_spring: ${dataset.resolution_options.518_1_77_ar}
+resolution_val_tav2_wb: ${dataset.resolution_options.518_1_00_ar}
+resolution_val_unrealstereo4k: ${dataset.resolution_options.518_1_77_ar}
+
+# Training Set
+train_dataset:
+  "+ 58_000 @ ${dataset.ase_wai.train.dataset_str}
+  + 58_000 @ ${dataset.blendedmvs_wai.train.dataset_str}
+  + 45_000 @ ${dataset.dynamicreplica_wai.train.dataset_str}
+  + 58_000 @ ${dataset.megadepth_wai.train.dataset_str}
+  + 58_000 @ ${dataset.mpsd_wai.train.dataset_str}
+  + 58_000 @ ${dataset.mvs_synth_wai.train.dataset_str}
+  + 58_000 @ ${dataset.paralleldomain4d_wai.train.dataset_str}
+  + 58_000 @ ${dataset.sailvos3d_wai.train.dataset_str}
+  + 58_000 @ ${dataset.scannetpp_wai.train.dataset_str}
+  + 2_000 @ ${dataset.spring_wai.train.dataset_str}
+  + 58_000 @ ${dataset.tav2_wb_wai.train.dataset_str}
+  + 5_500 @ ${dataset.unrealstereo4k_wai.train.dataset_str}"
+
+# Validation Set
+test_dataset:
+  "+ 4_000 @ ${dataset.ase_wai.val.dataset_str}
+  + 4_000 @ ${dataset.blendedmvs_wai.val.dataset_str}
+  + 4_000 @ ${dataset.dynamicreplica_wai.val.dataset_str}
+  + 4_000 @ ${dataset.megadepth_wai.val.dataset_str}
+  + 4_000 @ ${dataset.mpsd_wai.val.dataset_str}
+  + 4_000 @ ${dataset.mvs_synth_wai.val.dataset_str}
+  + 4_000 @ ${dataset.paralleldomain4d_wai.val.dataset_str}
+  + 4_000 @ ${dataset.sailvos3d_wai.val.dataset_str}
+  + 4_000 @ ${dataset.scannetpp_wai.val.dataset_str}
+  + 500 @ ${dataset.spring_wai.val.dataset_str}
+  + 4_000 @ ${dataset.tav2_wb_wai.val.dataset_str}
+  + 500 @ ${dataset.unrealstereo4k_wai.val.dataset_str}"

configs/dataset/megatrain_13d_512_many_ar_24ipg_16g.yaml

@@ -0,0 +1,59 @@
+defaults:
+  - default
+
+# Number of views parameter for the multi-view datasets
+num_views: 4
+
+train:
+  # If True, the number of views can vary from batch to batch. The maximum number of views is num_views and minimum is 2. (On by default for N-view training)
+  variable_num_views: true
+
+# Train Resolution
+resolution_train: ${dataset.resolution_options.512_many_ar}
+
+# Validation Resolution
+resolution_val_ase: ${dataset.resolution_options.512_1_00_ar}
+resolution_val_blendedmvs: ${dataset.resolution_options.512_1_33_ar}
+resolution_val_dl3dv: ${dataset.resolution_options.512_1_77_ar}
+resolution_val_dynamicreplica: ${dataset.resolution_options.512_1_77_ar}
+resolution_val_megadepth: ${dataset.resolution_options.512_1_52_ar}
+resolution_val_mpsd: ${dataset.resolution_options.512_1_77_ar}
+resolution_val_mvs_synth: ${dataset.resolution_options.512_1_77_ar}
+resolution_val_paralleldomain4d: ${dataset.resolution_options.512_1_33_ar}
+resolution_val_sailvos3d: ${dataset.resolution_options.512_1_52_ar}
+resolution_val_scannetpp: ${dataset.resolution_options.512_1_52_ar}
+resolution_val_spring: ${dataset.resolution_options.512_1_77_ar}
+resolution_val_tav2_wb: ${dataset.resolution_options.512_1_00_ar}
+resolution_val_unrealstereo4k: ${dataset.resolution_options.512_1_77_ar}
+
+# Training Set
+train_dataset:
+  "+ 52_500 @ ${dataset.ase_wai.train.dataset_str}
+  + 52_500 @ ${dataset.blendedmvs_wai.train.dataset_str}
+  + 52_500 @ ${dataset.dl3dv_wai.train.dataset_str}
+  + 40_000 @ ${dataset.dynamicreplica_wai.train.dataset_str}
+  + 52_500 @ ${dataset.megadepth_wai.train.dataset_str}
+  + 52_500 @ ${dataset.mpsd_wai.train.dataset_str}
+  + 52_500 @ ${dataset.mvs_synth_wai.train.dataset_str}
+  + 52_500 @ ${dataset.paralleldomain4d_wai.train.dataset_str}
+  + 52_500 @ ${dataset.sailvos3d_wai.train.dataset_str}
+  + 52_500 @ ${dataset.scannetpp_wai.train.dataset_str}
+  + 2_000 @ ${dataset.spring_wai.train.dataset_str}
+  + 52_500 @ ${dataset.tav2_wb_wai.train.dataset_str}
+  + 5_500 @ ${dataset.unrealstereo4k_wai.train.dataset_str}"
+
+# Validation Set
+test_dataset:
+  "+ 4_000 @ ${dataset.ase_wai.val.dataset_str}
+  + 4_000 @ ${dataset.blendedmvs_wai.val.dataset_str}
+  + 4_000 @ ${dataset.dl3dv_wai.val.dataset_str}
+  + 4_000 @ ${dataset.dynamicreplica_wai.val.dataset_str}
+  + 4_000 @ ${dataset.megadepth_wai.val.dataset_str}
+  + 4_000 @ ${dataset.mpsd_wai.val.dataset_str}
+  + 4_000 @ ${dataset.mvs_synth_wai.val.dataset_str}
+  + 4_000 @ ${dataset.paralleldomain4d_wai.val.dataset_str}
+  + 4_000 @ ${dataset.sailvos3d_wai.val.dataset_str}
+  + 4_000 @ ${dataset.scannetpp_wai.val.dataset_str}
+  + 500 @ ${dataset.spring_wai.val.dataset_str}
+  + 4_000 @ ${dataset.tav2_wb_wai.val.dataset_str}
+  + 500 @ ${dataset.unrealstereo4k_wai.val.dataset_str}"

configs/dataset/megatrain_13d_518_many_ar_24ipg_16g.yaml

@@ -0,0 +1,59 @@
+defaults:
+  - default
+
+# Number of views parameter for the multi-view datasets
+num_views: 4
+
+train:
+  # If True, the number of views can vary from batch to batch. The maximum number of views is num_views and minimum is 2. (On by default for N-view training)
+  variable_num_views: true
+
+# Train Resolution
+resolution_train: ${dataset.resolution_options.518_many_ar}
+
+# Validation Resolution
+resolution_val_ase: ${dataset.resolution_options.518_1_00_ar}
+resolution_val_blendedmvs: ${dataset.resolution_options.518_1_33_ar}
+resolution_val_dl3dv: ${dataset.resolution_options.518_1_77_ar}
+resolution_val_dynamicreplica: ${dataset.resolution_options.518_1_77_ar}
+resolution_val_megadepth: ${dataset.resolution_options.518_1_52_ar}
+resolution_val_mpsd: ${dataset.resolution_options.518_1_77_ar}
+resolution_val_mvs_synth: ${dataset.resolution_options.518_1_77_ar}
+resolution_val_paralleldomain4d: ${dataset.resolution_options.518_1_33_ar}
+resolution_val_sailvos3d: ${dataset.resolution_options.518_1_52_ar}
+resolution_val_scannetpp: ${dataset.resolution_options.518_1_52_ar}
+resolution_val_spring: ${dataset.resolution_options.518_1_77_ar}
+resolution_val_tav2_wb: ${dataset.resolution_options.518_1_00_ar}
+resolution_val_unrealstereo4k: ${dataset.resolution_options.518_1_77_ar}
+
+# Training Set
+train_dataset:
+  "+ 52_500 @ ${dataset.ase_wai.train.dataset_str}
+  + 52_500 @ ${dataset.blendedmvs_wai.train.dataset_str}
+  + 52_500 @ ${dataset.dl3dv_wai.train.dataset_str}
+  + 40_000 @ ${dataset.dynamicreplica_wai.train.dataset_str}
+  + 52_500 @ ${dataset.megadepth_wai.train.dataset_str}
+  + 52_500 @ ${dataset.mpsd_wai.train.dataset_str}
+  + 52_500 @ ${dataset.mvs_synth_wai.train.dataset_str}
+  + 52_500 @ ${dataset.paralleldomain4d_wai.train.dataset_str}
+  + 52_500 @ ${dataset.sailvos3d_wai.train.dataset_str}
+  + 52_500 @ ${dataset.scannetpp_wai.train.dataset_str}
+  + 2_000 @ ${dataset.spring_wai.train.dataset_str}
+  + 52_500 @ ${dataset.tav2_wb_wai.train.dataset_str}
+  + 5_500 @ ${dataset.unrealstereo4k_wai.train.dataset_str}"
+
+# Validation Set
+test_dataset:
+  "+ 4_000 @ ${dataset.ase_wai.val.dataset_str}
+  + 4_000 @ ${dataset.blendedmvs_wai.val.dataset_str}
+  + 4_000 @ ${dataset.dl3dv_wai.val.dataset_str}
+  + 4_000 @ ${dataset.dynamicreplica_wai.val.dataset_str}
+  + 4_000 @ ${dataset.megadepth_wai.val.dataset_str}
+  + 4_000 @ ${dataset.mpsd_wai.val.dataset_str}
+  + 4_000 @ ${dataset.mvs_synth_wai.val.dataset_str}
+  + 4_000 @ ${dataset.paralleldomain4d_wai.val.dataset_str}
+  + 4_000 @ ${dataset.sailvos3d_wai.val.dataset_str}
+  + 4_000 @ ${dataset.scannetpp_wai.val.dataset_str}
+  + 500 @ ${dataset.spring_wai.val.dataset_str}
+  + 4_000 @ ${dataset.tav2_wb_wai.val.dataset_str}
+  + 500 @ ${dataset.unrealstereo4k_wai.val.dataset_str}"

configs/dataset/megatrain_13d_518_many_ar_48ipg_64g.yaml

@@ -0,0 +1,59 @@
+defaults:
+  - default
+
+# Number of views parameter for the multi-view datasets
+num_views: 4
+
+train:
+  # If True, the number of views can vary from batch to batch. The maximum number of views is num_views and minimum is 2. (On by default for N-view training)
+  variable_num_views: true
+
+# Train Resolution
+resolution_train: ${dataset.resolution_options.518_many_ar}
+
+# Validation Resolution
+resolution_val_ase: ${dataset.resolution_options.518_1_00_ar}
+resolution_val_blendedmvs: ${dataset.resolution_options.518_1_33_ar}
+resolution_val_dl3dv: ${dataset.resolution_options.518_1_77_ar}
+resolution_val_dynamicreplica: ${dataset.resolution_options.518_1_77_ar}
+resolution_val_megadepth: ${dataset.resolution_options.518_1_52_ar}
+resolution_val_mpsd: ${dataset.resolution_options.518_1_77_ar}
+resolution_val_mvs_synth: ${dataset.resolution_options.518_1_77_ar}
+resolution_val_paralleldomain4d: ${dataset.resolution_options.518_1_33_ar}
+resolution_val_sailvos3d: ${dataset.resolution_options.518_1_52_ar}
+resolution_val_scannetpp: ${dataset.resolution_options.518_1_52_ar}
+resolution_val_spring: ${dataset.resolution_options.518_1_77_ar}
+resolution_val_tav2_wb: ${dataset.resolution_options.518_1_00_ar}
+resolution_val_unrealstereo4k: ${dataset.resolution_options.518_1_77_ar}
+
+# Training Set
+train_dataset:
+  "+ 420_000 @ ${dataset.ase_wai.train.dataset_str}
+  + 420_000 @ ${dataset.blendedmvs_wai.train.dataset_str}
+  + 420_000 @ ${dataset.dl3dv_wai.train.dataset_str}
+  + 320_000 @ ${dataset.dynamicreplica_wai.train.dataset_str}
+  + 420_000 @ ${dataset.megadepth_wai.train.dataset_str}
+  + 420_000 @ ${dataset.mpsd_wai.train.dataset_str}
+  + 420_000 @ ${dataset.mvs_synth_wai.train.dataset_str}
+  + 420_000 @ ${dataset.paralleldomain4d_wai.train.dataset_str}
+  + 420_000 @ ${dataset.sailvos3d_wai.train.dataset_str}
+  + 420_000 @ ${dataset.scannetpp_wai.train.dataset_str}
+  + 16_000 @ ${dataset.spring_wai.train.dataset_str}
+  + 420_000 @ ${dataset.tav2_wb_wai.train.dataset_str}
+  + 44_000 @ ${dataset.unrealstereo4k_wai.train.dataset_str}"
+
+# Validation Set
+test_dataset:
+  "+ 4_000 @ ${dataset.ase_wai.val.dataset_str}
+  + 4_000 @ ${dataset.blendedmvs_wai.val.dataset_str}
+  + 4_000 @ ${dataset.dl3dv_wai.val.dataset_str}
+  + 4_000 @ ${dataset.dynamicreplica_wai.val.dataset_str}
+  + 4_000 @ ${dataset.megadepth_wai.val.dataset_str}
+  + 4_000 @ ${dataset.mpsd_wai.val.dataset_str}
+  + 4_000 @ ${dataset.mvs_synth_wai.val.dataset_str}
+  + 4_000 @ ${dataset.paralleldomain4d_wai.val.dataset_str}
+  + 4_000 @ ${dataset.sailvos3d_wai.val.dataset_str}
+  + 4_000 @ ${dataset.scannetpp_wai.val.dataset_str}
+  + 500 @ ${dataset.spring_wai.val.dataset_str}
+  + 4_000 @ ${dataset.tav2_wb_wai.val.dataset_str}
+  + 500 @ ${dataset.unrealstereo4k_wai.val.dataset_str}"

configs/dataset/megatrain_6d_518_many_ar_48ipg_64g.yaml

@@ -0,0 +1,38 @@
+defaults:
+  - default
+
+# Number of views parameter for the multi-view datasets
+num_views: 4
+
+train:
+  # If True, the number of views can vary from batch to batch. The maximum number of views is num_views and minimum is 2. (On by default for N-view training)
+  variable_num_views: true
+
+# Train Resolution
+resolution_train: ${dataset.resolution_options.518_many_ar}
+
+# Validation Resolution
+resolution_val_blendedmvs: ${dataset.resolution_options.518_1_33_ar}
+resolution_val_mpsd: ${dataset.resolution_options.518_1_77_ar}
+resolution_val_scannetpp: ${dataset.resolution_options.518_1_52_ar}
+resolution_val_spring: ${dataset.resolution_options.518_1_77_ar}
+resolution_val_tav2_wb: ${dataset.resolution_options.518_1_00_ar}
+resolution_val_unrealstereo4k: ${dataset.resolution_options.518_1_77_ar}
+
+# Training Set
+train_dataset:
+  "+ 1_120_000 @ ${dataset.blendedmvs_wai.train.dataset_str}
+  + 1_120_000 @ ${dataset.mpsd_wai.train.dataset_str}
+  + 1_120_000 @ ${dataset.scannetpp_wai.train.dataset_str}
+  + 44_000 @ ${dataset.spring_wai.train.dataset_str}
+  + 1_120_000 @ ${dataset.tav2_wb_wai.train.dataset_str}
+  + 116_000 @ ${dataset.unrealstereo4k_wai.train.dataset_str}"
+
+# Validation Set
+test_dataset:
+  "+ 4_000 @ ${dataset.blendedmvs_wai.val.dataset_str}
+  + 4_000 @ ${dataset.mpsd_wai.val.dataset_str}
+  + 4_000 @ ${dataset.scannetpp_wai.val.dataset_str}
+  + 500 @ ${dataset.spring_wai.val.dataset_str}
+  + 4_000 @ ${dataset.tav2_wb_wai.val.dataset_str}
+  + 500 @ ${dataset.unrealstereo4k_wai.val.dataset_str}"

configs/dataset/megatrain_6d_518_many_ar_48ipg_8g.yaml

@@ -0,0 +1,38 @@
+defaults:
+  - default
+
+# Number of views parameter for the multi-view datasets
+num_views: 4
+
+train:
+  # If True, the number of views can vary from batch to batch. The maximum number of views is num_views and minimum is 2. (On by default for N-view training)
+  variable_num_views: true
+
+# Train Resolution
+resolution_train: ${dataset.resolution_options.518_many_ar}
+
+# Validation Resolution
+resolution_val_blendedmvs: ${dataset.resolution_options.518_1_33_ar}
+resolution_val_mpsd: ${dataset.resolution_options.518_1_77_ar}
+resolution_val_scannetpp: ${dataset.resolution_options.518_1_52_ar}
+resolution_val_spring: ${dataset.resolution_options.518_1_77_ar}
+resolution_val_tav2_wb: ${dataset.resolution_options.518_1_00_ar}
+resolution_val_unrealstereo4k: ${dataset.resolution_options.518_1_77_ar}
+
+# Training Set
+train_dataset:
+  "+ 140_000 @ ${dataset.blendedmvs_wai.train.dataset_str}
+  + 140_000 @ ${dataset.mpsd_wai.train.dataset_str}
+  + 140_000 @ ${dataset.scannetpp_wai.train.dataset_str}
+  + 5_500 @ ${dataset.spring_wai.train.dataset_str}
+  + 140_000 @ ${dataset.tav2_wb_wai.train.dataset_str}
+  + 14_500 @ ${dataset.unrealstereo4k_wai.train.dataset_str}"
+
+# Validation Set
+test_dataset:
+  "+ 4_000 @ ${dataset.blendedmvs_wai.val.dataset_str}
+  + 4_000 @ ${dataset.mpsd_wai.val.dataset_str}
+  + 4_000 @ ${dataset.scannetpp_wai.val.dataset_str}
+  + 500 @ ${dataset.spring_wai.val.dataset_str}
+  + 4_000 @ ${dataset.tav2_wb_wai.val.dataset_str}
+  + 500 @ ${dataset.unrealstereo4k_wai.val.dataset_str}"

configs/dataset/mpsd_wai/default.yaml

@@ -0,0 +1,3 @@
+defaults:
+  - train: default
+  - val: default

configs/dataset/mpsd_wai/train/default.yaml

@@ -0,0 +1,26 @@
+dataset_str:
+  "MPSDWAI(
+    split='${dataset.mpsd_wai.train.split}',
+    resolution=${dataset.mpsd_wai.train.dataset_resolution},
+    principal_point_centered=${dataset.mpsd_wai.train.principal_point_centered},
+    aug_crop=${dataset.mpsd_wai.train.aug_crop},
+    transform='${dataset.mpsd_wai.train.transform}',
+    data_norm_type='${dataset.mpsd_wai.train.data_norm_type}',
+    ROOT='${dataset.mpsd_wai.train.ROOT}',
+    dataset_metadata_dir='${dataset.mpsd_wai.train.dataset_metadata_dir}',
+    overfit_num_sets=${dataset.mpsd_wai.train.overfit_num_sets},
+    variable_num_views=${dataset.mpsd_wai.train.variable_num_views},
+    num_views=${dataset.mpsd_wai.train.num_views},
+    covisibility_thres=${dataset.mpsd_wai.train.covisibility_thres})"
+split: 'train'
+dataset_resolution: ${dataset.resolution_train}
+principal_point_centered: ${dataset.principal_point_centered}
+aug_crop: 16
+transform: 'colorjitter+grayscale+gaublur'
+data_norm_type: ${model.data_norm_type}
+ROOT: ${root_data_dir}/mpsd
+dataset_metadata_dir: ${mapanything_dataset_metadata_dir}
+overfit_num_sets: null
+variable_num_views: ${dataset.train.variable_num_views}
+num_views: ${dataset.num_views}
+covisibility_thres: 0.15

configs/dataset/mpsd_wai/val/default.yaml

@@ -0,0 +1,26 @@
+dataset_str:
+  "MPSDWAI(
+    split='${dataset.mpsd_wai.val.split}',
+    resolution=${dataset.mpsd_wai.val.dataset_resolution},
+    principal_point_centered=${dataset.mpsd_wai.val.principal_point_centered},
+    seed=${dataset.mpsd_wai.val.seed},
+    transform='${dataset.mpsd_wai.val.transform}',
+    data_norm_type='${dataset.mpsd_wai.val.data_norm_type}',
+    ROOT='${dataset.mpsd_wai.val.ROOT}',
+    dataset_metadata_dir='${dataset.mpsd_wai.val.dataset_metadata_dir}',
+    overfit_num_sets=${dataset.mpsd_wai.val.overfit_num_sets},
+    variable_num_views=${dataset.mpsd_wai.val.variable_num_views},
+    num_views=${dataset.mpsd_wai.val.num_views},
+    covisibility_thres=${dataset.mpsd_wai.val.covisibility_thres})"
+split: 'val'
+dataset_resolution: ${dataset.resolution_val_mpsd}
+principal_point_centered: ${dataset.principal_point_centered}
+seed: 777
+transform: 'imgnorm'
+data_norm_type: ${model.data_norm_type}
+ROOT: ${root_data_dir}/mpsd
+dataset_metadata_dir: ${mapanything_dataset_metadata_dir}
+overfit_num_sets: null
+variable_num_views: ${dataset.val.variable_num_views}
+num_views: ${dataset.num_views}
+covisibility_thres: 0.15