initial commit of map anything demo

.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-----

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025 Meta, Nikhil Keetha
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,8 +1,8 @@
 ---
-title: Map Anything
-emoji: 🏆
-colorFrom: yellow
-colorTo: pink
+title: Mapanything Gradio
+emoji: 🐠
+colorFrom: purple
+colorTo: green
 sdk: gradio
 sdk_version: 5.44.1
 app_file: app.py

README_grad.md

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

app.py

@@ -0,0 +1,1752 @@
+# 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.
+# conda activate hf3.10
+
+import base64
+import gc
+import os
+import shutil
+import sys
+import time
+from datetime import datetime
+
+import cv2
+import gradio as gr
+import numpy as np
+import spaces
+import torch
+from huggingface_hub import hf_hub_download
+
+sys.path.append("mapanything/")
+
+from hf_utils.css_and_html import (
+    get_acknowledgements_html,
+    get_description_html,
+    get_gradio_theme,
+    get_header_html,
+    GRADIO_CSS,
+    MEASURE_INSTRUCTIONS_HTML,
+)
+from hf_utils.vgg_geometry import unproject_depth_map_to_point_map
+from hf_utils.visual_util import predictions_to_glb
+from mapanything.models import init_model
+from mapanything.utils.geometry import depth_edge, normals_edge, points_to_normals
+from mapanything.utils.image import load_images, rgb
+from mapanything.utils.inference import loss_of_one_batch_multi_view
+
+
+def get_logo_base64():
+    """Convert WAI logo to base64 for embedding in HTML"""
+    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
+
+
+print("Initializing and loading MapAnything model...")
+
+
+def load_hf_token():
+    """Load HuggingFace access token from local file"""
+    token_file_paths = [
+        "~/hf_token.txt",
+    ]
+
+    for token_path in token_file_paths:
+        if os.path.exists(token_path):
+            try:
+                with open(token_path, "r") as f:
+                    token = f.read().strip()
+                print(f"Loaded HuggingFace token from: {token_path}")
+                return token
+            except Exception as e:
+                print(f"Error reading token from {token_path}: {e}")
+                continue
+
+    # Also try environment variable
+    # see https://huggingface.co/docs/hub/spaces-overview#managing-secrets on options
+    token = (
+        os.getenv("HF_TOKEN")
+        or os.getenv("HUGGING_FACE_HUB_TOKEN")
+        or os.getenv("HUGGING_FACE_MODEL_TOKEN")
+    )
+    if token:
+        print("Loaded HuggingFace token from environment variable")
+        return token
+
+    print(
+        "Warning: No HuggingFace token found. Model loading may fail for private repositories."
+    )
+    return None
+
+
+def init_hydra_config(config_path, overrides=None):
+    "Initialize Hydra config"
+    import hydra
+
+    config_dir = os.path.dirname(config_path)
+    config_name = os.path.basename(config_path).split(".")[0]
+    relative_path = os.path.relpath(config_dir, os.path.dirname(__file__))
+    hydra.core.global_hydra.GlobalHydra.instance().clear()
+    hydra.initialize(version_base=None, config_path=relative_path)
+    if overrides is not None:
+        cfg = hydra.compose(config_name=config_name, overrides=overrides)
+    else:
+        cfg = hydra.compose(config_name=config_name)
+    return cfg
+
+
+def init_inference_model(config, ckpt_path, device):
+    "Initialize the model for inference"
+    if isinstance(config, dict):
+        config_path = config["path"]
+        overrrides = config["config_overrides"]
+        model_args = init_hydra_config(config_path, overrides=overrrides)
+        model = init_model(model_args.model.model_str, model_args.model.model_config)
+    else:
+        config_path = config
+        model_args = init_hydra_config(config_path)
+        model = init_model(model_args.model_str, model_args.model_config)
+    model.to(device)
+    if ckpt_path is not None:
+        print("Loading model from: ", ckpt_path)
+
+        # Load HuggingFace token for private repositories
+        hf_token = load_hf_token()
+
+        # Try to download from HuggingFace Hub first if it's a HF URL
+        if "huggingface.co" in ckpt_path:
+            try:
+                # Extract repo_id and filename from URL
+                # URL format: https://huggingface.co/facebook/MapAnything/resolve/main/mapa_curri_24v_13d_48ipg_64g.pth
+                parts = ckpt_path.replace("https://huggingface.co/", "").split("/")
+                repo_id = f"{parts[0]}/{parts[1]}"  # e.g., "facebook/MapAnything"
+                filename = "/".join(
+                    parts[4:]
+                )  # e.g., "mapa_curri_24v_13d_48ipg_64g.pth"
+
+                print(f"Downloading from HuggingFace Hub: {repo_id}/{filename}")
+                local_file = hf_hub_download(
+                    repo_id=repo_id,
+                    filename=filename,
+                    token=hf_token,
+                    cache_dir=None,  # Use default cache
+                )
+                ckpt = torch.load(local_file, map_location=device, weights_only=False)
+            except Exception as e:
+                print(f"HuggingFace Hub download failed: {e}")
+                print("Falling back to torch.hub.load_state_dict_from_url...")
+                # Fallback to original method
+                ckpt = torch.hub.load_state_dict_from_url(
+                    ckpt_path, map_location=device
+                )
+        else:
+            # Use original method for non-HF URLs
+            ckpt = torch.hub.load_state_dict_from_url(ckpt_path, map_location=device)
+
+        print(model.load_state_dict(ckpt["model"], strict=False))
+    model.eval()
+    return model
+
+
+# MapAnything Configuration
+high_level_config = {
+    "path": "configs/train.yaml",
+    "config_overrides": [
+        "machine=aws",
+        "model=mapanything",
+        "model/task=images_only",
+        "model.encoder.uses_torch_hub=false",
+    ],
+    "checkpoint_path": "https://huggingface.co/facebook/MapAnything/resolve/main/mapa_curri_24v_13d_48ipg_64g.pth",
+    "trained_with_amp": True,
+    "trained_with_amp_dtype": "fp16",
+    "data_norm_type": "dinov2",
+    "patch_size": 14,
+    "resolution": 518,
+}
+
+# Initialize model - this will be done on GPU when needed
+model = None
+
+
+# -------------------------------------------------------------------------
+# 1) Core model inference
+# -------------------------------------------------------------------------
+@spaces.GPU(duration=120)
+def run_model(target_dir, model_placeholder):
+    """
+    Run the MapAnything model on images in the 'target_dir/images' folder and return predictions.
+    """
+    global model
+    print(f"Processing images from {target_dir}")
+
+    # Device check
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    device = torch.device(device)
+    # if not torch.cuda.is_available():
+    #     raise ValueError("CUDA is not available. Check your environment.")
+
+    # Initialize model if not already done
+    if model is None:
+        print("Initializing MapAnything model...")
+        model = init_inference_model(
+            high_level_config, high_level_config["checkpoint_path"], device
+        )
+    else:
+        model = model.to(device)
+
+    model.eval()
+
+    # Load images using MapAnything's load_images function
+    print("Loading images...")
+    image_folder_path = os.path.join(target_dir, "images")
+    views = load_images(
+        image_folder_path,
+        resolution_set=high_level_config["resolution"],
+        verbose=False,
+        norm_type=high_level_config["data_norm_type"],
+        patch_size=high_level_config["patch_size"],
+        stride=1,
+    )
+
+    print(f"Loaded {len(views)} images")
+    if len(views) == 0:
+        raise ValueError("No images found. Check your upload.")
+
+    # Run inference using MapAnything's inference function
+    print("Running MapAnything inference...")
+    with torch.no_grad():
+        pred_result = loss_of_one_batch_multi_view(
+            views,
+            model,
+            None,
+            device,
+            use_amp=high_level_config["trained_with_amp"],
+            amp_dtype=high_level_config["trained_with_amp_dtype"],
+        )
+
+    # Convert predictions to format expected by visualization
+    predictions = {}
+
+    # Initialize lists for the required keys
+    extrinsic_list = []
+    intrinsic_list = []
+    world_points_list = []
+    depth_maps_list = []
+    images_list = []
+    confidence_list = []
+    final_mask_list = []
+
+    # Check if confidence data is available
+    has_confidence = False
+    for view_idx, view in enumerate(views):
+        view_key = f"pred{view_idx + 1}"
+        if view_key in pred_result and "conf" in pred_result[view_key]:
+            has_confidence = True
+            break
+
+    # Extract predictions for each view
+    for view_idx, view in enumerate(views):
+        # Get image for colors
+        image = rgb(view["img"], norm_type=high_level_config["data_norm_type"])
+
+        view_key = f"pred{view_idx + 1}"
+        if view_key in pred_result:
+            pred_pts3d = pred_result[view_key]["pts3d"][0].cpu().numpy()
+
+            # Get confidence data if available
+            confidence_map = None
+            if "conf" in pred_result[view_key]:
+                confidence_map = pred_result[view_key]["conf"][0].cpu().numpy()
+
+            # Compute final_mask just like in visualize_raw_inference_output function
+            # Create the prediction mask based on parameters
+            pred_mask = None
+            use_gt_mask_on_pred = False  # Set based on your requirements
+            use_pred_mask = True  # Set based on your requirements
+            use_non_ambi_mask = True  # Set based on your requirements
+            use_conf_mask = False  # Set based on your requirements
+            conf_percentile = 10  # Set based on your requirements
+            use_edge_mask = True  # Set based on your requirements
+            pts_edge_tol = 5  # Set based on your requirements
+            depth_edge_rtol = 0.03  # Set based on your requirements
+
+            if use_pred_mask:
+                # Get non ambiguous mask if available and requested
+                has_non_ambiguous_mask = (
+                    "non_ambiguous_mask" in pred_result[view_key] and use_non_ambi_mask
+                )
+                if has_non_ambiguous_mask:
+                    non_ambiguous_mask = (
+                        pred_result[view_key]["non_ambiguous_mask"][0].cpu().numpy()
+                    )
+                    pred_mask = non_ambiguous_mask
+
+                # Get confidence mask if available and requested
+                has_conf = "conf" in pred_result[view_key] and use_conf_mask
+                if has_conf:
+                    confidences = pred_result[view_key]["conf"][0].cpu()
+                    percentile_threshold = torch.quantile(
+                        confidences, conf_percentile / 100.0
+                    )
+                    conf_mask = confidences > percentile_threshold
+                    conf_mask = conf_mask.numpy()
+                    if pred_mask is not None:
+                        pred_mask = pred_mask & conf_mask
+                    else:
+                        pred_mask = conf_mask
+
+                # Apply edge mask if requested
+                if use_edge_mask and pred_mask is not None:
+                    if "cam_quats" not in pred_result[view_key]:
+                        # For direct point prediction
+                        # Compute normals and edge mask
+                        normals, normals_mask = points_to_normals(
+                            pred_pts3d, mask=pred_mask
+                        )
+                        edge_mask = ~(
+                            normals_edge(normals, tol=pts_edge_tol, mask=normals_mask)
+                        )
+                    else:
+                        # For ray-based prediction
+                        ray_depth = pred_result[view_key]["depth_along_ray"][0].cpu()
+                        local_pts3d = (
+                            pred_result[view_key]["ray_directions"][0].cpu() * ray_depth
+                        )
+                        depth_z = local_pts3d[..., 2].numpy()
+
+                        # Compute normals and edge mask
+                        normals, normals_mask = points_to_normals(
+                            pred_pts3d, mask=pred_mask
+                        )
+                        edge_mask = ~(
+                            depth_edge(depth_z, rtol=depth_edge_rtol, mask=pred_mask)
+                            & normals_edge(normals, tol=pts_edge_tol, mask=normals_mask)
+                        )
+                    if pred_mask is not None:
+                        pred_mask = pred_mask & edge_mask
+
+            # Determine final mask to use (like in visualize_raw_inference_output)
+            final_mask = None
+            valid_mask = np.ones_like(
+                pred_pts3d[..., 0], dtype=bool
+            )  # Create dummy valid_mask for app.py context
+
+            if use_gt_mask_on_pred:
+                final_mask = valid_mask
+                if use_pred_mask and pred_mask is not None:
+                    final_mask = final_mask & pred_mask
+            elif use_pred_mask and pred_mask is not None:
+                final_mask = pred_mask
+            else:
+                final_mask = np.ones_like(valid_mask, dtype=bool)
+
+            # Check if we have camera pose and intrinsics data
+            if "cam_quats" in pred_result[view_key]:
+                # Get decoupled quantities (like in visualize_raw_custom_data_inference_output)
+                cam_quats = pred_result[view_key]["cam_quats"][0].cpu()
+                cam_trans = pred_result[view_key]["cam_trans"][0].cpu()
+                ray_directions = pred_result[view_key]["ray_directions"][0].cpu()
+                ray_depth = pred_result[view_key]["depth_along_ray"][0].cpu()
+
+                # Convert the quantities
+                from mapanything.utils.geometry import (
+                    quaternion_to_rotation_matrix,
+                    recover_pinhole_intrinsics_from_ray_directions,
+                )
+
+                cam_rot = quaternion_to_rotation_matrix(cam_quats)
+                cam_pose = torch.eye(4)
+                cam_pose[:3, :3] = cam_rot
+                cam_pose[:3, 3] = cam_trans
+                cam_pose = np.linalg.inv(cam_pose)
+                cam_intrinsics = recover_pinhole_intrinsics_from_ray_directions(
+                    ray_directions, use_geometric_calculation=True
+                )
+
+                # Compute depth as in app_map.py
+                local_pts3d = ray_directions * ray_depth
+                depth_z = local_pts3d[..., 2]
+
+                # Convert to numpy and extract 3x4 extrinsic (remove bottom row)
+                extrinsic = cam_pose[:3, :4].numpy()  # Shape: (3, 4)
+                intrinsic = cam_intrinsics.numpy()  # Shape: (3, 3)
+                depth_z = depth_z.numpy()  # Shape: (H, W)
+            else:
+                # Use dummy values if camera info not available
+                # extrinsic: (3, 4) - [R|t] matrix
+                extrinsic = np.eye(3, 4)  # Identity rotation, zero translation
+                # intrinsic: (3, 3) - camera intrinsic matrix
+                intrinsic = np.eye(3)
+                # depth_z: (H, W) - dummy depth values
+                depth_z = np.zeros_like(pred_pts3d[..., 0])
+
+            # Append to lists
+            extrinsic_list.append(extrinsic)
+            intrinsic_list.append(intrinsic)
+            world_points_list.append(pred_pts3d)
+            depth_maps_list.append(depth_z)
+            images_list.append(image[0])  # Add image to list
+            final_mask_list.append(final_mask)  # Add final_mask to list
+
+            # Add confidence data (or None if not available)
+            if confidence_map is not None:
+                confidence_list.append(confidence_map)
+            elif has_confidence:
+                # If some views have confidence but this one doesn't, add dummy confidence
+                confidence_list.append(np.ones_like(depth_z))
+
+    # Convert lists to numpy arrays with required shapes
+    # extrinsic: (S, 3, 4) - batch of camera extrinsic matrices
+    predictions["extrinsic"] = np.stack(extrinsic_list, axis=0)
+
+    # intrinsic: (S, 3, 3) - batch of camera intrinsic matrices
+    predictions["intrinsic"] = np.stack(intrinsic_list, axis=0)
+
+    # world_points: (S, H, W, 3) - batch of 3D world points
+    predictions["world_points"] = np.stack(world_points_list, axis=0)
+
+    # depth: (S, H, W, 1) or (S, H, W) - batch of depth maps
+    depth_maps = np.stack(depth_maps_list, axis=0)
+    # Add channel dimension if needed to match (S, H, W, 1) format
+    if len(depth_maps.shape) == 3:
+        depth_maps = depth_maps[..., np.newaxis]
+    predictions["depth"] = depth_maps
+
+    # images: (S, H, W, 3) - batch of input images
+    predictions["images"] = np.stack(images_list, axis=0)
+
+    # confidence: (S, H, W) - batch of confidence maps (only if available)
+    if confidence_list:
+        predictions["confidence"] = np.stack(confidence_list, axis=0)
+
+    # final_mask: (S, H, W) - batch of final masks for filtering
+    predictions["final_mask"] = np.stack(final_mask_list, axis=0)
+
+    world_points = unproject_depth_map_to_point_map(
+        depth_maps, predictions["extrinsic"], predictions["intrinsic"]
+    )
+    predictions["world_points_from_depth"] = world_points
+
+    # Process data for visualization tabs (depth, normal, measure)
+    processed_data = process_predictions_for_visualization(
+        pred_result, views, high_level_config
+    )
+
+    # Clean up
+    torch.cuda.empty_cache()
+
+    return predictions, processed_data
+
+
+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]),  # depth_view_selector
+        gr.Dropdown(choices=choices, value=choices[0]),  # normal_view_selector
+        gr.Dropdown(choices=choices, value=choices[0]),  # measure_view_selector
+    )
+
+
+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, conf_thres=None):
+    """Update depth view for a specific view index with optional confidence filtering"""
+    view_data = get_view_data_by_index(processed_data, view_index)
+    if view_data is None or view_data["depth"] is None:
+        return None
+
+    # Use confidence filtering if available
+    confidence = view_data.get("confidence")
+    return colorize_depth(
+        view_data["depth"], confidence=confidence, conf_thres=conf_thres
+    )
+
+
+def update_normal_view(processed_data, view_index, conf_thres=None):
+    """Update normal view for a specific view index with optional confidence filtering"""
+    view_data = get_view_data_by_index(processed_data, view_index)
+    if view_data is None or view_data["normal"] is None:
+        return None
+
+    # Use confidence filtering if available
+    confidence = view_data.get("confidence")
+    return colorize_normal(
+        view_data["normal"], confidence=confidence, conf_thres=conf_thres
+    )
+
+
+def update_measure_view(processed_data, view_index):
+    """Update measure view for a specific view index"""
+    view_data = get_view_data_by_index(processed_data, view_index)
+    if view_data is None:
+        return None, []  # image, measure_points
+    return view_data["image"], []
+
+
+def navigate_depth_view(
+    processed_data, current_selector_value, direction, conf_thres=None
+):
+    """Navigate depth view (direction: -1 for previous, +1 for next)"""
+    if processed_data is None or len(processed_data) == 0:
+        return "View 1", None
+
+    # Parse current view number
+    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, conf_thres=conf_thres)
+
+    return new_selector_value, depth_vis
+
+
+def navigate_normal_view(
+    processed_data, current_selector_value, direction, conf_thres=None
+):
+    """Navigate normal view (direction: -1 for previous, +1 for next)"""
+    if processed_data is None or len(processed_data) == 0:
+        return "View 1", None
+
+    # Parse current view number
+    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, conf_thres=conf_thres)
+
+    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, []
+
+    # Parse current view number
+    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, conf_thres=None):
+    """Populate the depth, normal, and measure tabs with processed data"""
+    if processed_data is None or len(processed_data) == 0:
+        return None, None, None, []
+
+    # Use update functions to ensure confidence filtering is applied from the start
+    depth_vis = update_depth_view(processed_data, 0, conf_thres=conf_thres)
+    normal_vis = update_normal_view(processed_data, 0, conf_thres=conf_thres)
+    measure_img, _ = update_measure_view(processed_data, 0)
+
+    return depth_vis, normal_vis, measure_img, []
+
+
+# -------------------------------------------------------------------------
+# 2) Handle uploaded video/images --> produce target_dir + images
+# -------------------------------------------------------------------------
+def handle_uploads(input_video, input_images, 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()
+
+    # Create a unique folder name
+    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")
+
+    # Clean up if somehow that folder already exists
+    if os.path.exists(target_dir):
+        shutil.rmtree(target_dir)
+    os.makedirs(target_dir)
+    os.makedirs(target_dir_images)
+
+    image_paths = []
+
+    # --- Handle images ---
+    if input_images is not None:
+        for file_data in input_images:
+            if isinstance(file_data, dict) and "name" in file_data:
+                file_path = file_data["name"]
+            else:
+                file_path = file_data
+            dst_path = os.path.join(target_dir_images, os.path.basename(file_path))
+            shutil.copy(file_path, dst_path)
+            image_paths.append(dst_path)
+
+    # --- Handle video ---
+    if input_video is not None:
+        if isinstance(input_video, dict) and "name" in input_video:
+            video_path = input_video["name"]
+        else:
+            video_path = input_video
+
+        vs = cv2.VideoCapture(video_path)
+        fps = vs.get(cv2.CAP_PROP_FPS)
+        frame_interval = int(fps * s_time_interval)  # 1 frame/sec
+
+        count = 0
+        video_frame_num = 0
+        while True:
+            gotit, frame = vs.read()
+            if not gotit:
+                break
+            count += 1
+            if count % frame_interval == 0:
+                image_path = os.path.join(
+                    target_dir_images, f"{video_frame_num:06}.png"
+                )
+                cv2.imwrite(image_path, frame)
+                image_paths.append(image_path)
+                video_frame_num += 1
+
+    # Sort final images for gallery
+    image_paths = sorted(image_paths)
+
+    end_time = time.time()
+    print(
+        f"Files copied to {target_dir_images}; took {end_time - start_time:.3f} seconds"
+    )
+    return target_dir, image_paths
+
+
+# -------------------------------------------------------------------------
+# 3) Update gallery on upload
+# -------------------------------------------------------------------------
+def update_gallery_on_upload(input_video, input_images, s_time_interval=1.0):
+    """
+    Whenever user uploads or changes files, immediately handle them
+    and show in the gallery. Return (target_dir, image_paths).
+    If nothing is uploaded, returns "None" and empty list.
+    """
+    if not input_video and not input_images:
+        return None, None, None, None
+    target_dir, image_paths = handle_uploads(input_video, input_images, s_time_interval)
+    return (
+        None,
+        target_dir,
+        image_paths,
+        "Upload complete. Click 'Reconstruct' to begin 3D processing.",
+    )
+
+
+# -------------------------------------------------------------------------
+# 4) Reconstruction: uses the target_dir plus any viz parameters
+# -------------------------------------------------------------------------
+@spaces.GPU(duration=120)
+def gradio_demo(
+    target_dir,
+    conf_thres=3.0,
+    frame_filter="All",
+    show_cam=True,
+    filter_sky=False,
+    filter_black_bg=False,
+    filter_white_bg=False,
+    mask_ambiguous=False,
+):
+    """
+    Perform reconstruction using the already-created target_dir/images.
+    """
+    if not os.path.isdir(target_dir) or target_dir == "None":
+        return None, "No valid target directory found. Please upload first.", None, None
+
+    start_time = time.time()
+    gc.collect()
+    torch.cuda.empty_cache()
+
+    # Always use Pointmap Branch for MapAnything
+    prediction_mode = "Pointmap Branch"
+
+    # Prepare frame_filter dropdown
+    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("Running MapAnything model...")
+    with torch.no_grad():
+        predictions, processed_data = run_model(target_dir, None)
+
+    # Save predictions
+    prediction_save_path = os.path.join(target_dir, "predictions.npz")
+    np.savez(prediction_save_path, **predictions)
+
+    # Handle None frame_filter
+    if frame_filter is None:
+        frame_filter = "All"
+
+    # Build a GLB file name
+    glbfile = os.path.join(
+        target_dir,
+        f"glbscene_{conf_thres}_{frame_filter.replace('.', '_').replace(':', '').replace(' ', '_')}_cam{show_cam}_sky{filter_sky}_black{filter_black_bg}_white{filter_white_bg}_mask{mask_ambiguous}_pred{prediction_mode.replace(' ', '_')}.glb",
+    )
+
+    # Convert predictions to GLB
+    glbscene = predictions_to_glb(
+        predictions,
+        conf_thres=conf_thres,
+        filter_by_frames=frame_filter,
+        show_cam=show_cam,
+        target_dir=target_dir,
+        prediction_mode=prediction_mode,
+        mask_sky=filter_sky,
+        mask_black_bg=filter_black_bg,
+        mask_white_bg=filter_white_bg,
+        mask_ambiguous=mask_ambiguous,
+    )
+    glbscene.export(file_obj=glbfile)
+
+    # Cleanup
+    del predictions
+    gc.collect()
+    torch.cuda.empty_cache()
+
+    end_time = time.time()
+    print(f"Total time: {end_time - start_time:.2f} seconds")
+    log_msg = (
+        f"Reconstruction Success ({len(all_files)} frames). Waiting for visualization."
+    )
+
+    # Populate visualization tabs with processed data
+    depth_vis, normal_vis, measure_img, measure_pts = populate_visualization_tabs(
+        processed_data, conf_thres=conf_thres
+    )
+
+    # Update view selectors based on available views
+    depth_selector, normal_selector, measure_selector = update_view_selectors(
+        processed_data
+    )
+
+    return (
+        glbfile,
+        log_msg,
+        gr.Dropdown(choices=frame_filter_choices, value=frame_filter, interactive=True),
+        processed_data,
+        depth_vis,
+        normal_vis,
+        measure_img,
+        "",  # measure_text (empty initially)
+        depth_selector,
+        normal_selector,
+        measure_selector,
+    )
+
+
+# -------------------------------------------------------------------------
+# 5) Helper functions for UI resets + re-visualization
+# -------------------------------------------------------------------------
+def apply_confidence_filtering(data, confidence, conf_thres):
+    """Apply confidence filtering to data arrays"""
+    if confidence is None or data is None:
+        return data
+
+    # Convert confidence threshold from percentage to confidence value
+    conf_threshold = np.percentile(confidence, conf_thres)
+    conf_mask = (confidence >= conf_threshold) & (confidence > 1e-5)
+
+    # conf_mask = confidence >= (conf_thres)
+
+    # Apply mask to data
+    if len(data.shape) == 3:  # 3D data (H, W, C)
+        filtered_data = data.copy()
+        for c in range(data.shape[2]):
+            filtered_data[:, :, c] = np.where(conf_mask, data[:, :, c], 0)
+    elif len(data.shape) == 2:  # 2D data (H, W)
+        filtered_data = np.where(conf_mask, data, 0)
+    else:
+        filtered_data = data
+
+    return filtered_data
+
+
+def colorize_depth(depth_map, confidence=None, conf_thres=None):
+    """Convert depth map to colorized visualization with optional confidence filtering"""
+    if depth_map is None:
+        return None
+
+    # Apply confidence filtering if available
+    if confidence is not None and conf_thres is not None:
+        depth_map = apply_confidence_filtering(depth_map, confidence, conf_thres)
+
+    # Normalize depth to 0-1 range
+    depth_normalized = depth_map.copy()
+    valid_mask = depth_normalized > 0
+    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)
+
+    # Apply colormap
+    import matplotlib.pyplot as plt
+
+    colormap = plt.cm.turbo_r
+    # colormap = plt.cm.plasma
+    # colormap = plt.cm.viridis
+    colored = colormap(depth_normalized)
+    colored = (colored[:, :, :3] * 255).astype(np.uint8)
+
+    # Set invalid pixels to white
+    colored[~valid_mask] = [255, 255, 255]
+
+    return colored
+
+
+def colorize_normal(normal_map, confidence=None, conf_thres=None):
+    """Convert normal map to colorized visualization with optional confidence filtering"""
+    if normal_map is None:
+        return None
+
+    # Apply confidence filtering if available
+    if confidence is not None and conf_thres is not None:
+        normal_map = apply_confidence_filtering(normal_map, confidence, conf_thres)
+
+    # Normalize normals to [0, 1] range for visualization
+    normal_vis = (normal_map + 1.0) / 2.0
+    normal_vis = (normal_vis * 255).astype(np.uint8)
+
+    return normal_vis
+
+
+def process_predictions_for_visualization(pred_result, views, high_level_config):
+    """Extract depth, normal, and 3D points from predictions for visualization"""
+    processed_data = {}
+
+    # Check if confidence data is available in any view
+    has_confidence_data = False
+    for view_idx, view in enumerate(views):
+        view_key = f"pred{view_idx + 1}"
+        if view_key in pred_result and "conf" in pred_result[view_key]:
+            has_confidence_data = True
+            break
+
+    # Process each view
+    for view_idx, view in enumerate(views):
+        view_key = f"pred{view_idx + 1}"
+        if view_key not in pred_result:
+            continue
+
+        # Get image
+        image = rgb(view["img"], norm_type=high_level_config["data_norm_type"])
+
+        # Get predicted points
+        pred_pts3d = pred_result[view_key]["pts3d"][0].cpu().numpy()
+
+        # Initialize data for this view
+        view_data = {
+            "image": image[0],
+            "points3d": pred_pts3d,
+            "depth": None,
+            "normal": None,
+            "mask": None,
+            "confidence": None,
+            "has_confidence": has_confidence_data,
+        }
+
+        # Get confidence data if available
+        if "conf" in pred_result[view_key]:
+            confidence = pred_result[view_key]["conf"][0].cpu().numpy()
+            view_data["confidence"] = confidence
+
+        # Get masks if available
+        has_non_ambiguous_mask = "non_ambiguous_mask" in pred_result[view_key]
+        if has_non_ambiguous_mask:
+            view_data["mask"] = (
+                pred_result[view_key]["non_ambiguous_mask"][0].cpu().numpy()
+            )
+
+        # Extract depth and camera info if available
+        if "cam_quats" in pred_result[view_key]:
+            ray_directions = pred_result[view_key]["ray_directions"][0].cpu()
+            ray_depth = pred_result[view_key]["depth_along_ray"][0].cpu()
+
+            # Compute depth
+            local_pts3d = ray_directions * ray_depth
+            depth_z = local_pts3d[..., 2].numpy()
+            view_data["depth"] = depth_z
+
+            # Compute normals if we have valid points
+            if has_non_ambiguous_mask:
+                try:
+                    normals, _ = points_to_normals(pred_pts3d, mask=view_data["mask"])
+                    view_data["normal"] = normals
+                except:
+                    # If normal computation fails, skip it
+                    pass
+
+        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, [], ""
+
+    # Return the first view image
+    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"Measure function called with selector: {current_view_selector}")
+
+        if processed_data is None or len(processed_data) == 0:
+            return None, [], "No data available"
+
+        # Use the currently selected view instead of always using the first view
+        try:
+            current_view_index = int(current_view_selector.split()[1]) - 1
+        except:
+            current_view_index = 0
+
+        print(f"Using view index: {current_view_index}")
+
+        # Get view data safely
+        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, [], "No view data available"
+
+        point2d = event.index[0], event.index[1]
+        print(f"Clicked point: {point2d}")
+
+        measure_points.append(point2d)
+
+        # Get image and ensure it's valid
+        image = current_view["image"]
+        if image is None:
+            return None, [], "No image available"
+
+        image = image.copy()
+        points3d = current_view["points3d"]
+
+        # Ensure image is in uint8 format for proper cv2 operations
+        try:
+            if image.dtype != np.uint8:
+                if image.max() <= 1.0:
+                    # Image is in [0, 1] range, convert to [0, 255]
+                    image = (image * 255).astype(np.uint8)
+                else:
+                    # Image is already in [0, 255] range
+                    image = image.astype(np.uint8)
+        except Exception as e:
+            print(f"Image conversion error: {e}")
+            return None, [], f"Image conversion error: {e}"
+
+        # Draw circles for points
+        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"Drawing error: {e}")
+            return None, [], f"Drawing error: {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} depth: {d:.2f}m.**\n"
+                else:
+                    # Use Z coordinate of 3D points if depth not available
+                    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-coord: {z:.2f}m.**\n"
+        except Exception as e:
+            print(f"Depth text error: {e}")
+            depth_text = f"Error computing depth: {e}\n"
+
+        if len(measure_points) == 2:
+            try:
+                point1, point2 = measure_points
+                # Draw line
+                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
+                    )
+
+                # Compute 3D distance
+                distance_text = "- **Distance: Unable to compute**"
+                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: {distance:.2f}m**"
+                    except Exception as e:
+                        print(f"Distance computation error: {e}")
+                        distance_text = f"- **Distance computation error: {e}**"
+
+                measure_points = []
+                text = depth_text + distance_text
+                print(f"Measurement complete: {text}")
+                return [image, measure_points, text]
+            except Exception as e:
+                print(f"Final measurement error: {e}")
+                return None, [], f"Measurement error: {e}"
+        else:
+            print(f"Single point measurement: {depth_text}")
+            return [image, measure_points, depth_text]
+
+    except Exception as e:
+        print(f"Overall measure function error: {e}")
+        return None, [], f"Measure function error: {e}"
+
+
+def clear_fields():
+    """
+    Clears the 3D viewer, the stored target_dir, and empties the gallery.
+    """
+    return None
+
+
+def update_log():
+    """
+    Display a quick log message while waiting.
+    """
+    return "Loading and Reconstructing..."
+
+
+def update_visualization(
+    target_dir,
+    conf_thres,
+    frame_filter,
+    show_cam,
+    is_example,
+    filter_sky=False,
+    filter_black_bg=False,
+    filter_white_bg=False,
+    mask_ambiguous=False,
+):
+    """
+    Reload saved predictions from npz, create (or reuse) the GLB for new parameters,
+    and return it for the 3D viewer. If is_example == "True", skip.
+    """
+
+    # If it's an example click, skip as requested
+    if is_example == "True":
+        return (
+            gr.update(),
+            "No reconstruction available. Please click the Reconstruct button first.",
+        )
+
+    if not target_dir or target_dir == "None" or not os.path.isdir(target_dir):
+        return (
+            gr.update(),
+            "No reconstruction available. Please click the Reconstruct button first.",
+        )
+
+    predictions_path = os.path.join(target_dir, "predictions.npz")
+    if not os.path.exists(predictions_path):
+        return (
+            gr.update(),
+            f"No reconstruction available at {predictions_path}. Please run 'Reconstruct' first.",
+        )
+
+    loaded = np.load(predictions_path, allow_pickle=True)
+    predictions = {key: loaded[key] for key in loaded.keys()}
+
+    # Always use Pointmap Branch for MapAnything
+    prediction_mode = "Pointmap Branch"
+
+    glbfile = os.path.join(
+        target_dir,
+        f"glbscene_{conf_thres}_{frame_filter.replace('.', '_').replace(':', '').replace(' ', '_')}_cam{show_cam}_sky{filter_sky}_black{filter_black_bg}_white{filter_white_bg}_pred{prediction_mode.replace(' ', '_')}.glb",
+    )
+
+    if not os.path.exists(glbfile):
+        glbscene = predictions_to_glb(
+            predictions,
+            conf_thres=conf_thres,
+            filter_by_frames=frame_filter,
+            show_cam=show_cam,
+            target_dir=target_dir,
+            prediction_mode=prediction_mode,
+            mask_sky=filter_sky,
+            mask_black_bg=filter_black_bg,
+            mask_white_bg=filter_white_bg,
+            mask_ambiguous=mask_ambiguous,
+        )
+        glbscene.export(file_obj=glbfile)
+
+    return (
+        glbfile,
+        "Visualization updated.",
+    )
+
+
+# -------------------------------------------------------------------------
+# 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):
+            # Find all image files in the scene folder
+            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:
+                # Sort images and get the first one for thumbnail
+                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"):
+    """Load a scene from examples directory"""
+    scenes = get_scene_info(examples_dir)
+
+    # Find the selected scene
+    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, "Scene not found"
+
+    # Create target directory and copy images
+    target_dir, image_paths = handle_uploads(None, selected_scene["image_files"])
+
+    return (
+        None,  # Clear reconstruction output
+        target_dir,  # Set target directory
+        image_paths,  # Set gallery
+        f"Loaded scene '{scene_name}' with {selected_scene['num_images']} images. Click 'Reconstruct' to begin 3D processing.",
+    )
+
+
+# -------------------------------------------------------------------------
+# 6) Build Gradio UI
+# -------------------------------------------------------------------------
+theme = get_gradio_theme()
+
+with gr.Blocks(theme=theme, css=GRADIO_CSS) as demo:
+    # State variables for the tabbed interface
+    is_example = gr.Textbox(label="is_example", visible=False, value="None")
+    num_images = gr.Textbox(label="num_images", visible=False, value="None")
+    processed_data_state = gr.State(value=None)
+    measure_points_state = gr.State(value=[])
+    current_view_index = gr.State(value=0)  # Track current view index for navigation
+
+    gr.HTML(get_header_html(get_logo_base64()))
+    gr.HTML(get_description_html())
+
+    target_dir_output = gr.Textbox(label="Target Dir", visible=False, value="None")
+
+    with gr.Row():
+        with gr.Column(scale=2):
+            input_video = gr.Video(label="Upload Video", interactive=True)
+            s_time_interval = gr.Slider(
+                minimum=0.1,
+                maximum=5.0,
+                value=1.0,
+                step=0.1,
+                label="Sample time interval (take a sample every x sec.)",
+                interactive=True,
+                visible=True,
+            )
+            input_images = gr.File(
+                file_count="multiple", label="Upload Images", interactive=True
+            )
+
+            image_gallery = gr.Gallery(
+                label="Preview",
+                columns=4,
+                height="300px",
+                show_download_button=True,
+                object_fit="contain",
+                preview=True,
+            )
+
+        with gr.Column(scale=4):
+            with gr.Column():
+                gr.Markdown("**3D Reconstruction (Point Cloud and Camera Poses)**")
+                log_output = gr.Markdown(
+                    "Please upload a video or images, then click Reconstruct.",
+                    elem_classes=["custom-log"],
+                )
+
+                # Add tabbed interface similar to MoGe
+                with gr.Tabs():
+                    with gr.Tab("3D View"):
+                        reconstruction_output = gr.Model3D(
+                            height=520,
+                            zoom_speed=0.5,
+                            pan_speed=0.5,
+                            clear_color=[0.0, 0.0, 0.0, 0.0],
+                            key="persistent_3d_viewer",
+                            elem_id="reconstruction_3d_viewer",
+                        )
+                    with gr.Tab("Depth"):
+                        with gr.Row(elem_classes=["navigation-row"]):
+                            prev_depth_btn = gr.Button("◀ Previous", size="sm", scale=1)
+                            depth_view_selector = gr.Dropdown(
+                                choices=["View 1"],
+                                value="View 1",
+                                label="Select View",
+                                scale=2,
+                                interactive=True,
+                                allow_custom_value=True,
+                            )
+                            next_depth_btn = gr.Button("Next ▶", size="sm", scale=1)
+                        depth_map = gr.Image(
+                            type="numpy",
+                            label="Colorized Depth Map",
+                            format="png",
+                            interactive=False,
+                        )
+                    with gr.Tab("Normal"):
+                        with gr.Row(elem_classes=["navigation-row"]):
+                            prev_normal_btn = gr.Button(
+                                "◀ Previous", size="sm", scale=1
+                            )
+                            normal_view_selector = gr.Dropdown(
+                                choices=["View 1"],
+                                value="View 1",
+                                label="Select View",
+                                scale=2,
+                                interactive=True,
+                                allow_custom_value=True,
+                            )
+                            next_normal_btn = gr.Button("Next ▶", size="sm", scale=1)
+                        normal_map = gr.Image(
+                            type="numpy",
+                            label="Normal Map",
+                            format="png",
+                            interactive=False,
+                        )
+                    with gr.Tab("Measure"):
+                        gr.Markdown(MEASURE_INSTRUCTIONS_HTML)
+                        with gr.Row(elem_classes=["navigation-row"]):
+                            prev_measure_btn = gr.Button(
+                                "◀ Previous", size="sm", scale=1
+                            )
+                            measure_view_selector = gr.Dropdown(
+                                choices=["View 1"],
+                                value="View 1",
+                                label="Select View",
+                                scale=2,
+                                interactive=True,
+                                allow_custom_value=True,
+                            )
+                            next_measure_btn = gr.Button("Next ▶", size="sm", scale=1)
+                        measure_image = gr.Image(
+                            type="numpy",
+                            show_label=False,
+                            format="webp",
+                            interactive=False,
+                            sources=[],
+                        )
+                        measure_text = gr.Markdown("")
+
+            with gr.Row():
+                submit_btn = gr.Button("Reconstruct", scale=1, variant="primary")
+                clear_btn = gr.ClearButton(
+                    [
+                        input_video,
+                        input_images,
+                        reconstruction_output,
+                        log_output,
+                        target_dir_output,
+                        image_gallery,
+                    ],
+                    scale=1,
+                )
+
+            with gr.Row():
+                conf_thres = gr.Slider(
+                    minimum=0,
+                    maximum=100,
+                    value=0,
+                    step=0.1,
+                    label="Confidence Threshold (%), only shown in depth and normals",
+                )
+                frame_filter = gr.Dropdown(
+                    choices=["All"], value="All", label="Show Points from Frame"
+                )
+                with gr.Column():
+                    show_cam = gr.Checkbox(label="Show Camera", value=True)
+                    filter_sky = gr.Checkbox(
+                        label="Filter Sky (using skyseg.onnx)", value=False
+                    )
+                    filter_black_bg = gr.Checkbox(
+                        label="Filter Black Background", value=False
+                    )
+                    filter_white_bg = gr.Checkbox(
+                        label="Filter White Background", value=False
+                    )
+                    mask_ambiguous = gr.Checkbox(label="Mask Ambiguous", value=True)
+
+    # ---------------------- Example Scenes Section ----------------------
+    gr.Markdown("## Example Scenes")
+    gr.Markdown("Click any thumbnail to load the scene for reconstruction.")
+
+    # Get scene information
+    scenes = get_scene_info("examples")
+
+    # Create thumbnail grid (4 columns, N rows)
+    if scenes:
+        for i in range(0, len(scenes), 4):  # Process 4 scenes per row
+            with gr.Row():
+                for j in range(4):
+                    scene_idx = i + j
+                    if scene_idx < len(scenes):
+                        scene = scenes[scene_idx]
+                        with gr.Column(scale=1, elem_classes=["clickable-thumbnail"]):
+                            # Clickable thumbnail
+                            scene_img = gr.Image(
+                                value=scene["thumbnail"],
+                                height=150,
+                                interactive=False,
+                                show_label=False,
+                                elem_id=f"scene_thumb_{scene['name']}",
+                                sources=[],
+                            )
+
+                            # Scene name and image count as text below thumbnail
+                            gr.Markdown(
+                                f"**{scene['name']}** \n {scene['num_images']} images",
+                                elem_classes=["scene-info"],
+                            )
+
+                            # Connect thumbnail click to load scene
+                            scene_img.select(
+                                fn=lambda name=scene["name"]: load_example_scene(name),
+                                outputs=[
+                                    reconstruction_output,
+                                    target_dir_output,
+                                    image_gallery,
+                                    log_output,
+                                ],
+                            )
+                    else:
+                        # Empty column to maintain grid structure
+                        with gr.Column(scale=1):
+                            pass
+
+    # -------------------------------------------------------------------------
+    # "Reconstruct" button logic:
+    #  - Clear fields
+    #  - Update log
+    #  - gradio_demo(...) with the existing target_dir
+    #  - Then set is_example = "False"
+    # -------------------------------------------------------------------------
+    submit_btn.click(fn=clear_fields, inputs=[], outputs=[reconstruction_output]).then(
+        fn=update_log, inputs=[], outputs=[log_output]
+    ).then(
+        fn=gradio_demo,
+        inputs=[
+            target_dir_output,
+            conf_thres,
+            frame_filter,
+            show_cam,
+            filter_sky,
+            filter_black_bg,
+            filter_white_bg,
+            mask_ambiguous,
+        ],
+        outputs=[
+            reconstruction_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",
+        inputs=[],
+        outputs=[is_example],  # set is_example to "False"
+    )
+
+    # -------------------------------------------------------------------------
+    # Real-time Visualization Updates
+    # -------------------------------------------------------------------------
+    def update_all_visualizations_on_conf_change(
+        processed_data,
+        depth_selector,
+        normal_selector,
+        conf_thres_val,
+        target_dir,
+        frame_filter,
+        show_cam,
+        is_example,
+    ):
+        """Update 3D view and all tabs when confidence threshold changes"""
+
+        # Update 3D pointcloud visualization
+        glb_file, log_msg = update_visualization(
+            target_dir,
+            conf_thres_val,
+            frame_filter,
+            show_cam,
+            is_example,
+        )
+
+        # Update depth and normal tabs with new confidence threshold
+        depth_vis = None
+        normal_vis = None
+
+        if processed_data is not None:
+            # Get current view indices from selectors
+            try:
+                depth_view_idx = (
+                    int(depth_selector.split()[1]) - 1 if depth_selector else 0
+                )
+            except:
+                depth_view_idx = 0
+
+            try:
+                normal_view_idx = (
+                    int(normal_selector.split()[1]) - 1 if normal_selector else 0
+                )
+            except:
+                normal_view_idx = 0
+
+            # Update visualizations with new confidence threshold
+            depth_vis = update_depth_view(
+                processed_data, depth_view_idx, conf_thres=conf_thres_val
+            )
+            normal_vis = update_normal_view(
+                processed_data, normal_view_idx, conf_thres=conf_thres_val
+            )
+
+        return glb_file, log_msg, depth_vis, normal_vis
+
+    conf_thres.change(
+        fn=update_all_visualizations_on_conf_change,
+        inputs=[
+            processed_data_state,
+            depth_view_selector,
+            normal_view_selector,
+            conf_thres,
+            target_dir_output,
+            frame_filter,
+            show_cam,
+            is_example,
+        ],
+        outputs=[reconstruction_output, log_output, depth_map, normal_map],
+    )
+    frame_filter.change(
+        update_visualization,
+        [
+            target_dir_output,
+            conf_thres,
+            frame_filter,
+            show_cam,
+            is_example,
+        ],
+        [reconstruction_output, log_output],
+    )
+    show_cam.change(
+        update_visualization,
+        [
+            target_dir_output,
+            conf_thres,
+            frame_filter,
+            show_cam,
+            is_example,
+        ],
+        [reconstruction_output, log_output],
+    )
+    filter_sky.change(
+        update_visualization,
+        [
+            target_dir_output,
+            conf_thres,
+            frame_filter,
+            show_cam,
+            is_example,
+            filter_sky,
+            filter_black_bg,
+            filter_white_bg,
+            mask_ambiguous,
+        ],
+        [reconstruction_output, log_output],
+    )
+    filter_black_bg.change(
+        update_visualization,
+        [
+            target_dir_output,
+            conf_thres,
+            frame_filter,
+            show_cam,
+            is_example,
+            filter_sky,
+            filter_black_bg,
+            filter_white_bg,
+            mask_ambiguous,
+        ],
+        [reconstruction_output, log_output],
+    )
+    filter_white_bg.change(
+        update_visualization,
+        [
+            target_dir_output,
+            conf_thres,
+            frame_filter,
+            show_cam,
+            is_example,
+            filter_sky,
+            filter_black_bg,
+            filter_white_bg,
+            mask_ambiguous,
+        ],
+        [reconstruction_output, log_output],
+    )
+    mask_ambiguous.change(
+        update_visualization,
+        [
+            target_dir_output,
+            conf_thres,
+            frame_filter,
+            show_cam,
+            is_example,
+            filter_sky,
+            filter_black_bg,
+            filter_white_bg,
+            mask_ambiguous,
+        ],
+        [reconstruction_output, log_output],
+    )
+
+    # -------------------------------------------------------------------------
+    # Auto-update gallery whenever user uploads or changes their files
+    # -------------------------------------------------------------------------
+    input_video.change(
+        fn=update_gallery_on_upload,
+        inputs=[input_video, input_images, s_time_interval],
+        outputs=[reconstruction_output, target_dir_output, image_gallery, log_output],
+    )
+    input_images.change(
+        fn=update_gallery_on_upload,
+        inputs=[input_video, input_images, s_time_interval],
+        outputs=[reconstruction_output, target_dir_output, image_gallery, log_output],
+    )
+
+    # -------------------------------------------------------------------------
+    # Measure tab functionality
+    # -------------------------------------------------------------------------
+    measure_image.select(
+        fn=measure,
+        inputs=[processed_data_state, measure_points_state, measure_view_selector],
+        outputs=[measure_image, measure_points_state, measure_text],
+    )
+
+    # -------------------------------------------------------------------------
+    # Navigation functionality for Depth, Normal, and Measure tabs
+    # -------------------------------------------------------------------------
+
+    # Depth tab navigation
+    prev_depth_btn.click(
+        fn=lambda processed_data, current_selector, conf_thres_val: navigate_depth_view(
+            processed_data, current_selector, -1, conf_thres=conf_thres_val
+        ),
+        inputs=[processed_data_state, depth_view_selector, conf_thres],
+        outputs=[depth_view_selector, depth_map],
+    )
+
+    next_depth_btn.click(
+        fn=lambda processed_data, current_selector, conf_thres_val: navigate_depth_view(
+            processed_data, current_selector, 1, conf_thres=conf_thres_val
+        ),
+        inputs=[processed_data_state, depth_view_selector, conf_thres],
+        outputs=[depth_view_selector, depth_map],
+    )
+
+    depth_view_selector.change(
+        fn=lambda processed_data, selector_value, conf_thres_val: (
+            update_depth_view(
+                processed_data,
+                int(selector_value.split()[1]) - 1,
+                conf_thres=conf_thres_val,
+            )
+            if selector_value
+            else None
+        ),
+        inputs=[processed_data_state, depth_view_selector, conf_thres],
+        outputs=[depth_map],
+    )
+
+    # Normal tab navigation
+    prev_normal_btn.click(
+        fn=lambda processed_data,
+        current_selector,
+        conf_thres_val: navigate_normal_view(
+            processed_data, current_selector, -1, conf_thres=conf_thres_val
+        ),
+        inputs=[processed_data_state, normal_view_selector, conf_thres],
+        outputs=[normal_view_selector, normal_map],
+    )
+
+    next_normal_btn.click(
+        fn=lambda processed_data,
+        current_selector,
+        conf_thres_val: navigate_normal_view(
+            processed_data, current_selector, 1, conf_thres=conf_thres_val
+        ),
+        inputs=[processed_data_state, normal_view_selector, conf_thres],
+        outputs=[normal_view_selector, normal_map],
+    )
+
+    normal_view_selector.change(
+        fn=lambda processed_data, selector_value, conf_thres_val: (
+            update_normal_view(
+                processed_data,
+                int(selector_value.split()[1]) - 1,
+                conf_thres=conf_thres_val,
+            )
+            if selector_value
+            else None
+        ),
+        inputs=[processed_data_state, normal_view_selector, conf_thres],
+        outputs=[normal_map],
+    )
+
+    # Measure tab navigation
+    prev_measure_btn.click(
+        fn=lambda processed_data, current_selector: navigate_measure_view(
+            processed_data, current_selector, -1
+        ),
+        inputs=[processed_data_state, measure_view_selector],
+        outputs=[measure_view_selector, measure_image, measure_points_state],
+    )
+
+    next_measure_btn.click(
+        fn=lambda processed_data, current_selector: navigate_measure_view(
+            processed_data, current_selector, 1
+        ),
+        inputs=[processed_data_state, measure_view_selector],
+        outputs=[measure_view_selector, measure_image, measure_points_state],
+    )
+
+    measure_view_selector.change(
+        fn=lambda processed_data, selector_value: (
+            update_measure_view(processed_data, int(selector_value.split()[1]) - 1)
+            if selector_value
+            else (None, [])
+        ),
+        inputs=[processed_data_state, measure_view_selector],
+        outputs=[measure_image, measure_points_state],
+    )
+
+    # -------------------------------------------------------------------------
+    # Acknowledgement section
+    # -------------------------------------------------------------------------
+    gr.HTML(get_acknowledgements_html())
+
+    demo.queue(max_size=20).launch(show_error=True, share=True, ssr_mode=False)

app_interactive.py

@@ -0,0 +1,9 @@
+import gradio as gr
+
+
+def greet(name):
+    return "Hello " + name + "!!"
+
+
+demo = gr.Interface(fn=greet, inputs="text", outputs="text")
+demo.launch()

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}"