From 037751d8391409d67aeedb4912d5eab449a8690b Mon Sep 17 00:00:00 2001 From: Dmitry Batenkov Date: Thu, 4 Sep 2025 01:38:13 -0400 Subject: [PATCH 01/32] cleanup for submission anon --- .DS_Store | Bin 6148 -> 8196 bytes .gitignore | 3 +- CLAUDE.md | 100 ---------- README.md | 29 ++- examples/gcloud_data_interface.ipynb | 268 --------------------------- examples/push_gcloud.py | 48 ----- 6 files changed, 25 insertions(+), 423 deletions(-) delete mode 100644 CLAUDE.md delete mode 100644 examples/gcloud_data_interface.ipynb delete mode 100644 examples/push_gcloud.py diff --git a/.DS_Store b/.DS_Store index 65267a919194138c52ad60b7390d4d1bbf7c55b0..9b36d3ac591f1c867da101ed9457e7f331eeefa4 100644 GIT binary patch literal 8196 zcmeHMzl#$=6#gc+V&D`GtFsWc(&A3#{s3V;BG_DWcfFTiMq%Ryk^>uI|A528#==Si zsqC(^)JE(rtSqc-1g*r*Z{Ex$v+O3sMm&52Gv8+3d-J}0o9xR>0GRE=&K9r^pw4b_ zZIwesvv%7{t>$O05DnvjLv+whds}<$tmLf|s(>n>3aA3AfGY4WD8QO+TYXO5cUB!$ z0af6?RKPwTVs?v($K0VjIylG{fEaOF8n3wzkeJwG;xTt9pc+CpB(@9wTWb-V)mj7OC{%)428$)#Cwx_HdYeYwwF3_HVi+RC!D z(ioD1`LI*9KuB`;*Q*y#9LZ9m@OCfq3rWL#x4h0#C{pEE{7{-NUyIg|%gO5aluHmF zvZ(ebN7VXHU9_nJXGwt-M|R!r|L@E{|36D_Nx7;5s=yyAV4}ue zW1B%z)hmK+m5 Date: Fri, 5 Sep 2025 01:33:23 -0400 Subject: [PATCH 02/32] reorganized a bit --- LICENSE | 21 ----- LICENSE.md | 202 +++++++++++++++++++++++++++++++++++++++++++++++ README.md | 22 ------ paper_figures.md | 23 ++++++ 4 files changed, 225 insertions(+), 43 deletions(-) delete mode 100644 LICENSE create mode 100644 LICENSE.md create mode 100644 paper_figures.md diff --git a/LICENSE b/LICENSE deleted file mode 100644 index bd24d4d3..00000000 --- a/LICENSE +++ /dev/null @@ -1,21 +0,0 @@ -MIT License - -Copyright (c) 2025 Basis Research Institute - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 index 00000000..d6456956 --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,202 @@ + + 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 [yyyy] [name of copyright owner] + + 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. diff --git a/README.md b/README.md index 1970e8c3..5bd9add3 100644 --- a/README.md +++ b/README.md @@ -167,25 +167,3 @@ The Docker image contains an example splat video at `/opt/data/C0043.MP4`. ## Problems Things aren't showing up in plots? Check [VSCode forwarding settings](https://github.com/pyvista/pyvista/issues/5296#issuecomment-1971079419) - -## Figure 3 from the paper - -### Panel A = rasterized gaussian splatting viewer - * Run in `examples/derive_splats.ipynb` - * Created via `examples/run_pipeline.py` — default arguments of RaDe-Features model along with the following: - - hloc (for preprocessing) - - Anti-aliasing - - Scale regularization - * Mesh created also via run_pipeline w/ default arguments - -### Panels B/C/D - Parts created by `examples/create_mesh.ipynb` notebook - * Feeder query - - Positive = "feeder" - - Negative = "ground", "leaves", "rocks" - * Tree query - - Positive = "tree" - - Negative = "ground", "leaves" - * Semantic clustering - - Similarity threshold = 0.95 - - Spatial radius = 0.01 \ No newline at end of file diff --git a/paper_figures.md b/paper_figures.md new file mode 100644 index 00000000..a68850c7 --- /dev/null +++ b/paper_figures.md @@ -0,0 +1,23 @@ +# Figures from the paper + +## Figure 3 + +### Panel A = rasterized gaussian splatting viewer + * Run in `examples/derive_splats.ipynb` + * Created via `examples/run_pipeline.py` — default arguments of RaDe-Features model along with the following: + - hloc (for preprocessing) + - Anti-aliasing + - Scale regularization + * Mesh created also via run_pipeline w/ default arguments + +### Panels B/C/D + Parts created by `examples/create_mesh.ipynb` notebook + * Feeder query + - Positive = "feeder" + - Negative = "ground", "leaves", "rocks" + * Tree query + - Positive = "tree" + - Negative = "ground", "leaves" + * Semantic clustering + - Similarity threshold = 0.95 + - Spatial radius = 0.01 \ No newline at end of file From efb8835ee696c91a070acdc3b24e37377918399d Mon Sep 17 00:00:00 2001 From: Tommy Date: Sat, 22 Nov 2025 21:25:56 +0000 Subject: [PATCH 03/32] Add vggt dependency and utils for VGGT integration MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Add vggt package dependency to pyproject.toml - Add collab_splats/utils/vggt_utils.py with deprecation notice - Update nerfstudio dependency to use BasisResearch fork with vggt support - Update meshlib dependency to use latest version 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude --- collab_splats/utils/vggt_utils.py | 44 +++++++++++++++++++++++++++++++ pyproject.toml | 5 ++-- 2 files changed, 47 insertions(+), 2 deletions(-) create mode 100644 collab_splats/utils/vggt_utils.py diff --git a/collab_splats/utils/vggt_utils.py b/collab_splats/utils/vggt_utils.py new file mode 100644 index 00000000..872c4d81 --- /dev/null +++ b/collab_splats/utils/vggt_utils.py @@ -0,0 +1,44 @@ +""" +VGGT utilities - DEPRECATED + +DEPRECATION NOTICE: + VGGT is now integrated directly into nerfstudio (nerfstudio/process_data/vggt_utils.py). + This module is kept only for backward compatibility and will be removed in a future version. + + New code should use: + - splatter.preprocess(sfm_tool='vggt') instead of splatter.preprocess_vggt() + - Or call ns-process-data directly with --sfm-tool vggt + + The nerfstudio integration provides: + - Better performance + - Direct integration with ns-process-data + - Maintained alongside other SfM tools (COLMAP, hloc) + - Automatic transforms.json generation + +For reference, see: + - nerfstudio/process_data/vggt_utils.py (new implementation) + - https://github.com/facebookresearch/vggt (VGGT repository) +""" + +import warnings + +warnings.warn( + "collab_splats.utils.vggt_utils is deprecated. " + "VGGT is now integrated into nerfstudio. " + "Use splatter.preprocess(sfm_tool='vggt') instead. " + "This module will be removed in a future version.", + DeprecationWarning, + stacklevel=2, +) + +# Legacy imports are kept for backward compatibility, but all functions +# now redirect to nerfstudio's implementation or raise deprecation errors. + +def __getattr__(name): + """Intercept any function calls to show deprecation message.""" + raise ImportError( + f"The function '{name}' has been moved to nerfstudio. " + f"Please use splatter.preprocess(sfm_tool='vggt') instead of " + f"direct vggt_utils calls. See nerfstudio/process_data/vggt_utils.py " + f"for the new implementation." + ) diff --git a/pyproject.toml b/pyproject.toml index 804d3481..5b6a1fe6 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -21,7 +21,6 @@ dependencies = [ "pillow", "regex", "tqdm", - "nerfstudio", "huggingface_hub", "ultralytics", "fairscale", @@ -31,11 +30,13 @@ dependencies = [ "trame", "trame-vuetify", "trame-vtk", - "meshlib==3.0.6.229", + "meshlib", "dotenv", "mobile_sam @ git+https://github.com/ChaoningZhang/MobileSAM.git", "gsplat @ git+https://github.com/brian-xu/gsplat-rade.git", "maskclip_onnx @ git+https://github.com/RogerQi/maskclip_onnx.git", + "nerfstudio @ git+https://github.com/BasisResearch/nerfstudio.git", + "vggt @ git+https://github.com/facebookresearch/vggt.git" ] [project.optional-dependencies] From 31892fe015f3e50a15511661fc9a62b1245763c6 Mon Sep 17 00:00:00 2001 From: Tommy Date: Sun, 23 Nov 2025 17:22:30 +0000 Subject: [PATCH 04/32] Improve splatter with meshlib updates and model loading utilities MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Add meshlib dependency and update mesh processing utilities - Add model loading utilities for handling checkpoints - Update features datamanager with improved caching - Add comprehensive cache analysis documentation - Update visualization notebook with new examples - Add tests for meshlib version compatibility 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude --- CACHE_ANALYSIS.md | 180 ++++++ README.md | 28 + .../datamanagers/features_datamanager.py | 16 +- collab_splats/utils/__init__.py | 9 + collab_splats/utils/mesh.py | 12 +- collab_splats/utils/mesh_updated.py | 250 ++++++++ .../meshlib_pointcloud_to_mesh_examples.py | 312 ++++++++++ collab_splats/utils/model_loading.py | 35 ++ collab_splats/wrapper/splatter.py | 70 ++- docs/splats/run_pipeline.py | 29 +- docs/splats/update-meshlib.ipynb | 420 +++++++++++++ docs/splats/visualization.ipynb | 65 +- notebook_updated_code.py | 85 +++ pyproject.toml | 6 + setup.sh | 59 +- stage/extract-colmap-vggt.ipynb | 588 ++++++++++++++++++ tests/test_meshlib_versions.py | 315 ++++++++++ 17 files changed, 2443 insertions(+), 36 deletions(-) create mode 100644 CACHE_ANALYSIS.md create mode 100644 collab_splats/utils/mesh_updated.py create mode 100644 collab_splats/utils/meshlib_pointcloud_to_mesh_examples.py create mode 100644 collab_splats/utils/model_loading.py create mode 100644 docs/splats/update-meshlib.ipynb create mode 100644 notebook_updated_code.py create mode 100644 stage/extract-colmap-vggt.ipynb create mode 100644 tests/test_meshlib_versions.py diff --git a/CACHE_ANALYSIS.md b/CACHE_ANALYSIS.md new file mode 100644 index 00000000..e9dea29b --- /dev/null +++ b/CACHE_ANALYSIS.md @@ -0,0 +1,180 @@ +# Feature Caching Analysis - RadeFeatures DataManager + +## Problem Summary + +The `FeatureSplattingDataManager` re-extracts DINO and CLIP features on every run, even when features should be cached. This causes significant slowdowns during training. + +## Root Cause + +### Path vs String Type Mismatch +**Location**: [features_datamanager.py:108](collab_splats/datamanagers/features_datamanager.py#L108) + +**Original code**: +```python +if cache_dict.get("image_filenames") != image_filenames: + CONSOLE.print("Image filenames have changed, cache invalidated...") +``` + +**Issue**: Direct list comparison fails when types differ between cached and current filenames: +- `torch.save()` preserves Path objects when storing +- `Path('/a/b.jpg') == '/a/b.jpg'` returns `False` +- Even though paths are identical, type mismatch causes cache invalidation + +**Proof**: +```python +>>> cached = [Path('/a/b.jpg')] +>>> current = ['/a/b.jpg'] +>>> cached == current +False # Cache invalidated even though paths are the same! +``` + +**Impact**: Cache is **never used** because the comparison always fails on type mismatch. + +## Secondary Issues + +### 1. Incomplete Cache Key (Future Enhancement) +**Location**: [features_datamanager.py:100-102](collab_splats/datamanagers/features_datamanager.py#L100-L102) + +```python +cache_path = cache_dir / f"feature-splatting_{self.config.main_features}-features.pt" +``` + +**Note**: The cache filename only includes `main_features` but ignores: +- `regularization_features` (e.g., "dinov2" or None) +- `sam_resolution` (default: 1024) +- `obj_resolution` (default: 100) +- `final_resolution` (default: 64) +- `segmentation_backend` (e.g., "mobilesamv2") +- `segmentation_strategy` (e.g., "object") + +**Impact**: If you change any of these parameters, the cache file remains the same, causing: +- Stale features loaded when config changes +- Same cache used for different configurations +- No way to maintain multiple cached versions + +### 2. Insufficient Cache Validation +**Location**: [features_datamanager.py:105-111](collab_splats/datamanagers/features_datamanager.py#L105-L111) + +```python +if self.config.enable_cache and cache_path.exists(): + cache_dict = torch.load(cache_path) + if cache_dict.get("image_filenames") != image_filenames: + CONSOLE.print("Image filenames have changed, cache invalidated...") + else: + return cache_dict["features_dict"] +``` + +**Issues**: +1. Only validates `image_filenames` match +2. Doesn't check if extraction configuration changed +3. Silent failure - loads stale features without warning +4. No version tracking for cache format + +### 3. Missing Configuration Persistence +The cache stores: +- `image_filenames` (list of paths) +- `features_dict` (extracted features) + +But **doesn't store**: +- Extraction configuration used +- Feature extractor versions/models +- Cache format version +- Timestamp of cache creation + +## Proposed Solution + +### Core Improvements + +1. **Config-aware cache key**: Include all relevant parameters in filename +2. **Strict validation**: Verify config matches before loading +3. **Cache metadata**: Store extraction config, version, timestamp +4. **Graceful degradation**: Invalidate and re-extract on mismatch + +### Implementation Details + +#### 1. Generate Hash-Based Cache Key + +```python +def _get_cache_key(self) -> str: + """Generate unique cache key from all extraction parameters.""" + config_dict = { + "main_features": self.config.main_features, + "regularization_features": self.config.regularization_features, + "sam_resolution": self.config.sam_resolution, + "obj_resolution": self.config.obj_resolution, + "final_resolution": self.config.final_resolution, + "segmentation_backend": self.config.segmentation_backend, + "segmentation_strategy": self.config.segmentation_strategy, + } + # Create deterministic hash + config_str = json.dumps(config_dict, sort_keys=True) + config_hash = hashlib.md5(config_str.encode()).hexdigest()[:8] + return f"feature-cache_{config_hash}" +``` + +#### 2. Enhanced Cache Structure + +```python +cache_dict = { + "version": "1.0.0", # Cache format version + "timestamp": datetime.now().isoformat(), + "config": { # Full extraction configuration + "main_features": ..., + "regularization_features": ..., + # ... all parameters + }, + "image_filenames": [...], + "features_dict": {...}, +} +``` + +#### 3. Strict Validation Logic + +```python +def _validate_cache(self, cache_dict: dict) -> Tuple[bool, str]: + """Validate cache against current configuration. + + Returns: + (is_valid, reason) tuple + """ + # Check version + if cache_dict.get("version") != CACHE_VERSION: + return False, "Cache version mismatch" + + # Check image filenames + if cache_dict.get("image_filenames") != image_filenames: + return False, "Image filenames changed" + + # Check configuration match + cached_config = cache_dict.get("config", {}) + current_config = self._get_cache_config() + if cached_config != current_config: + return False, f"Configuration mismatch: {differing_keys}" + + return True, "Cache valid" +``` + +## Benefits + +1. **Correctness**: Features always match current configuration +2. **Performance**: Proper cache hits eliminate redundant extraction +3. **Debugging**: Clear reasons when cache is invalidated +4. **Multiple configs**: Different configurations have separate caches +5. **Safety**: Impossible to accidentally use wrong features + +## Migration Strategy + +1. **Backward compatibility**: Old cache files automatically invalidated +2. **Gradual rollout**: New format only for new extractions +3. **Clear messaging**: User informed when cache invalidated and why + +## Performance Impact + +**Current behavior**: +- Cache miss rate: ~100% (due to silent invalidation) +- Average feature extraction: 5-10 minutes per run + +**With improvements**: +- Cache hit rate: ~95% (only miss on actual config changes) +- Cache load time: ~5-10 seconds +- **Time saved**: 4-9 minutes per run diff --git a/README.md b/README.md index c4d55fc0..23f98953 100644 --- a/README.md +++ b/README.md @@ -25,6 +25,34 @@ For use of gcloud data interfaces, please also install collab-data pip install git+https://github.com/BasisResearch/collab-data.git ``` +### Optional: FastVGGT for Accelerated Structure-from-Motion + +For ~4x faster structure-from-motion processing, you can optionally install FastVGGT by uncommenting the FastVGGT section in `setup.sh` before running it. Alternatively, if you've already run `setup.sh`, you can uncomment the FastVGGT section and run just that part: + +```bash +# Edit setup.sh and uncomment the FastVGGT installation section (lines 11-64) +# Then run the script +bash setup.sh +``` + +This enables the `fastvggt` option in nerfstudio's `ns-process-data` tool: + +```bash +# Standard VGGT (baseline) +ns-process-data video --data video.mp4 --output-dir out --sfm-tool vggt + +# FastVGGT (~4x faster with default settings) +ns-process-data video --data video.mp4 --output-dir out --sfm-tool fastvggt + +# FastVGGT with custom acceleration parameters +ns-process-data video --data video.mp4 --output-dir out --sfm-tool fastvggt \ + --vggt-merging 8 --vggt-merge-ratio 0.85 +``` + +**Parameters:** +- `--vggt-merging`: Token merging block index (0=disabled, 6=recommended, higher=more aggressive) +- `--vggt-merge-ratio`: Merge ratio 0.0-1.0 (default 0.9, higher=faster but less accurate) + #### Building the docker image The Docker image includes an example video file (`C0043.MP4`) downloaded from Google Cloud Storage during the build process. Follow these steps to build the image: diff --git a/collab_splats/datamanagers/features_datamanager.py b/collab_splats/datamanagers/features_datamanager.py index 6b3302ff..49868ea3 100644 --- a/collab_splats/datamanagers/features_datamanager.py +++ b/collab_splats/datamanagers/features_datamanager.py @@ -103,11 +103,23 @@ def setup(self) -> Dict[str, torch.Tensor]: # Try loading from cache if enabled if self.config.enable_cache and cache_path.exists(): + CONSOLE.print(f"Found cached features at {cache_path}") cache_dict = torch.load(cache_path) - if cache_dict.get("image_filenames") != image_filenames: - CONSOLE.print("Image filenames have changed, cache invalidated...") + # Normalize paths to strings for comparison (handles Path vs str mismatch) + cached_filenames = [str(p) for p in cache_dict.get("image_filenames", [])] + current_filenames = [str(p) for p in image_filenames] + + if cached_filenames != current_filenames: + CONSOLE.print( + "[yellow]Cache invalidated: image filenames have changed[/yellow]" + ) + CONSOLE.print( + f" Cached: {len(cached_filenames)} images, " + f"Current: {len(current_filenames)} images" + ) else: + CONSOLE.print("[green]✓ Loading features from cache[/green]") return cache_dict["features_dict"] else: CONSOLE.print("Cache does not exist, extracting features...") diff --git a/collab_splats/utils/__init__.py b/collab_splats/utils/__init__.py index 8d534a50..b8b78880 100644 --- a/collab_splats/utils/__init__.py +++ b/collab_splats/utils/__init__.py @@ -1,5 +1,12 @@ from .camera_utils import ColmapCamera, convert_to_colmap_camera, depth_double_to_normal from .trainer_config import _TrainerConfig, _ExperimentConfig +from .model_loading import load_checkpoint + +# VGGT utils - imported lazily to avoid dependency issues +try: + from . import vggt_utils +except ImportError: + vggt_utils = None __all__ = [ "ColmapCamera", @@ -7,4 +14,6 @@ "depth_double_to_normal", "_TrainerConfig", "_ExperimentConfig", + "load_checkpoint", + "vggt_utils", ] diff --git a/collab_splats/utils/mesh.py b/collab_splats/utils/mesh.py index af022a20..01728cb0 100644 --- a/collab_splats/utils/mesh.py +++ b/collab_splats/utils/mesh.py @@ -244,7 +244,8 @@ def clean_repair_mesh( # Add the largest component combined = mm.Mesh() - combined.addPartByMask(mesh, components[largest_idx]) + mesh_part = mm.MeshPart(mesh, components[largest_idx]) + combined.addMeshPart(mesh_part) # Remove the largest component from list of idxs if not use_largest: @@ -258,11 +259,13 @@ def clean_repair_mesh( ## THIS IS REALLY HACKY AND INEFFIENCT CHANGE SOMETIME for idx in tqdm(idxs, desc="Finding components within bounds"): _temp = mm.Mesh() - _temp.addPartByMask(mesh, components[idx]) + temp_mesh_part = mm.MeshPart(mesh, components[idx]) + _temp.addMeshPart(temp_mesh_part) if combined_bounds.contains(_temp.getBoundingBox()): # print (f"Adding component {idx} to combined mesh") - combined.addPartByMask(mesh, components[idx]) + mesh_part = mm.MeshPart(mesh, components[idx]) + combined.addMeshPart(mesh_part) else: n_removed += 1 @@ -1445,13 +1448,14 @@ def main(self): print("Saving splats pointcloud") means = pipeline.model.means.detach().cpu().numpy() colors = pipeline.model.features_dc.detach().cpu().numpy() + normals = pipeline.model.normals.detach().cpu().numpy() colors = SH2RGB(colors) # Pass xyz to Open3D.o3d.geometry.PointCloud and visualize pcd = o3d.geometry.PointCloud() pcd.points = o3d.utility.Vector3dVector(means) pcd.colors = o3d.utility.Vector3dVector(colors) - + pcd.normals = o3d.utility.Vector3dVector(normals) # Transform to specified coordinate system # pcd.transform(world_transform) diff --git a/collab_splats/utils/mesh_updated.py b/collab_splats/utils/mesh_updated.py new file mode 100644 index 00000000..364ec052 --- /dev/null +++ b/collab_splats/utils/mesh_updated.py @@ -0,0 +1,250 @@ +""" +Updated mesh cleaning functions compatible with MeshLib 3.0.7+ + +Key changes from original: +1. Added metric parameter to FillHoleParams (required in newer versions) +2. Improved error handling +3. Added alternative hole filling method +4. Updated subdivision settings for newer API +""" + +import meshlib.mrmeshpy as mm +from tqdm import tqdm, trange + + +def clean_repair_mesh_updated( + mesh_path: str, + max_hole_size: float = 3.0, + max_edge_splits: int = 10000, + use_largest: bool = False, + use_advanced_fill: bool = True, # New parameter +): + """ + Clean and repair mesh compatible with MeshLib 3.0.7+ + + Args: + mesh_path: Path to the mesh file + max_hole_size: Maximum hole perimeter to fill + max_edge_splits: Maximum number of edge splits for subdivision + use_largest: If True, only keep the largest component + use_advanced_fill: If True, use fillHoleNicely instead of fillHole + + Returns: + Cleaned and repaired mesh + """ + # Load mesh + mesh = mm.loadMesh(mesh_path) + + # Identify all connected components + components = mm.getAllComponents(mesh) + + # Determine component sizes + sizes = [mask.count() for mask in components] + + # Always find largest cluster + largest_idx = max(range(len(sizes)), key=lambda i: sizes[i]) + + # Add the largest component + combined = mm.Mesh() + mesh_part = mm.MeshPart(mesh, components[largest_idx]) + combined.addMeshPart(mesh_part) + + # Remove the largest component from list of idxs + n_removed = 0 + if not use_largest: + idxs = list(range(len(sizes))) + idxs.remove(largest_idx) + + # Add the remaining components if they fall within the bounds + combined_bounds = combined.getBoundingBox() + + for idx in tqdm(idxs, desc="Finding components within bounds"): + _temp = mm.Mesh() + temp_mesh_part = mm.MeshPart(mesh, components[idx]) + _temp.addMeshPart(temp_mesh_part) + + if combined_bounds.contains(_temp.getBoundingBox()): + mesh_part = mm.MeshPart(mesh, components[idx]) + combined.addMeshPart(mesh_part) + else: + n_removed += 1 + + print(f"Removed {n_removed} components") + mesh = combined + + # Compute average edge length + avg_edge_length = 0.0 + num_edges = 0 + + for i in trange( + mesh.topology.undirectedEdgeSize(), desc="Calculating average edge length" + ): + dir_edge = mm.EdgeId(i * 2) + org = mesh.topology.org(dir_edge) + dest = mesh.topology.dest(dir_edge) + avg_edge_length += ( + mesh.points.vec[dest.get()] - mesh.points.vec[org.get()] + ).length() + num_edges += 1 + avg_edge_length /= num_edges + + # Fill holes + hole_ids = mesh.topology.findHoleRepresentiveEdges() + + # UPDATED: Use fillHoleNicely with settings for newer versions + if use_advanced_fill: + print(f"Filling {len(hole_ids)} holes using advanced method...") + for he in tqdm(hole_ids, desc=f"Filling holes ({len(hole_ids)})"): + try: + perimeter = mesh.holePerimiter(he) + if perimeter < max_hole_size: + # Use fillHoleNicely for better results + settings = mm.FillHoleNicelySettings() + settings.maxEdgeLen = avg_edge_length + settings.maxEdgeSplits = max_edge_splits + + # Optional: Get the metric (required in some newer versions) + metric = mm.getUniversalMetric(mesh) + settings.metric = metric + + mm.fillHoleNicely(mesh, he, settings) + else: + print(f"Skipping hole {he} of perimeter {perimeter}") + except Exception as e: + print(f"Warning: Failed to fill hole {he}: {e}") + # Try fallback to simple fill + try: + mm.fillHoleTrivially(mesh, he) + except Exception as e2: + print(f"Warning: Fallback fill also failed: {e2}") + else: + # ORIGINAL METHOD with updates for newer API + fill_params = mm.FillHoleParams() + + # UPDATED: Set metric parameter (required in newer versions) + try: + fill_params.metric = mm.getUniversalMetric(mesh) + except: + pass # May not be required in older versions + + for he in tqdm(hole_ids, desc=f"Filling holes ({len(hole_ids)})"): + try: + perimeter = mesh.holePerimiter(he) + if perimeter < max_hole_size: + new_faces = mm.FaceBitSet() + fill_params.outNewFaces = new_faces + mm.fillHole(mesh, he, fill_params) + + # UPDATED: Subdivision with improved settings + new_verts = mm.VertBitSet() + subdiv_settings = mm.SubdivideSettings() + subdiv_settings.maxEdgeLen = avg_edge_length + subdiv_settings.maxEdgeSplits = max_edge_splits + subdiv_settings.region = new_faces + subdiv_settings.newVerts = new_verts + + # UPDATED: Set smoothMode if available (newer versions) + try: + subdiv_settings.smoothMode = mm.SubdivideSettings.SmoothMode.Linear + except: + pass # Not available in older versions + + mm.subdivideMesh(mesh, subdiv_settings) + mm.positionVertsSmoothly(mesh, new_verts) + else: + print(f"Skipping hole {he} of perimeter {perimeter}") + except Exception as e: + print(f"Warning: Failed to fill hole {he}: {e}") + + return mesh + + +def clean_repair_mesh_simple( + mesh_path: str, + max_hole_size: float = 3.0, + use_largest: bool = False, +): + """ + Simplified mesh cleaning using newer API methods. + + This version leverages built-in MeshLib functions for automatic + hole filling and component cleanup. + """ + # Load mesh + mesh = mm.loadMesh(mesh_path) + + # Use built-in hole filling with automatic settings + hole_ids = mesh.topology.findHoleRepresentiveEdges() + + print(f"Filling {len(hole_ids)} holes...") + for he in tqdm(hole_ids): + perimeter = mesh.holePerimiter(he) + if perimeter < max_hole_size: + # Use the automatic nice filling method + settings = mm.FillHoleNicelySettings() + mm.fillHoleNicely(mesh, he, settings) + + # Remove small components (if decimation is available) + components = mm.getAllComponents(mesh) + if len(components) > 1: + sizes = [mask.count() for mask in components] + largest_idx = max(range(len(sizes)), key=lambda i: sizes[i]) + + if use_largest: + # Keep only largest + result = mm.Mesh() + mesh_part = mm.MeshPart(mesh, components[largest_idx]) + result.addMeshPart(mesh_part) + return result + else: + # Remove small disconnected components + threshold = sizes[largest_idx] * 0.01 # 1% of largest + faces_to_remove = mm.FaceBitSet() + + for idx, (comp, size) in enumerate(zip(components, sizes)): + if idx != largest_idx and size < threshold: + faces_to_remove |= comp + + if faces_to_remove.count() > 0: + mm.deleteFaces(mesh, faces_to_remove) + + return mesh + + +# Compatibility function - tries updated method, falls back to original +def clean_repair_mesh( + mesh_path: str, + max_hole_size: float = 3.0, + max_edge_splits: int = 10000, + use_largest: bool = False, +): + """ + Compatibility wrapper that tries the updated method first, + falls back to simpler approaches if there are issues. + """ + try: + return clean_repair_mesh_updated( + mesh_path, + max_hole_size=max_hole_size, + max_edge_splits=max_edge_splits, + use_largest=use_largest, + use_advanced_fill=True + ) + except Exception as e: + print(f"Advanced method failed ({e}), trying simple method...") + try: + return clean_repair_mesh_simple( + mesh_path, + max_hole_size=max_hole_size, + use_largest=use_largest + ) + except Exception as e2: + print(f"Simple method also failed ({e2}), trying original approach...") + # Fall back to original implementation + return clean_repair_mesh_updated( + mesh_path, + max_hole_size=max_hole_size, + max_edge_splits=max_edge_splits, + use_largest=use_largest, + use_advanced_fill=False + ) diff --git a/collab_splats/utils/meshlib_pointcloud_to_mesh_examples.py b/collab_splats/utils/meshlib_pointcloud_to_mesh_examples.py new file mode 100644 index 00000000..54e9683d --- /dev/null +++ b/collab_splats/utils/meshlib_pointcloud_to_mesh_examples.py @@ -0,0 +1,312 @@ +""" +MeshLib Point Cloud to Mesh Conversion Examples +Updated for MeshLib 3.0.9.196+ + +Includes: +- Standard CPU-based conversion +- GPU-accelerated options (when CUDA available) +- Performance optimizations +- Progress callbacks +""" + +from meshlib import mrmeshpy as mm +from tqdm import tqdm +import numpy as np + + +def pointcloud_to_mesh_basic(pcd_fn: str, output_fn: str = "mesh.ply"): + """ + Basic point cloud to mesh conversion (CPU-based). + Compatible with MeshLib 3.0.6+ and 3.0.9+ + + Args: + pcd_fn: Path to point cloud file (.ply, .xyz, .pts, etc.) + output_fn: Output mesh filename + + Returns: + mesh: The generated mesh + """ + print("Loading points...") + points = mm.loadPoints(pcd_fn) + + print("Setting up parameters...") + params = mm.PointsToMeshParameters() + + # Auto-configure based on point cloud size + bbox = points.computeBoundingBox() + params.voxelSize = bbox.diagonal() * 1e-2 + params.sigma = max(params.voxelSize, mm.findAvgPointsRadius(points, 50)) + params.minWeight = 1 + + print("Converting points to mesh...") + mesh = mm.pointsToMeshFusion(points, params) + + # Save mesh + mm.saveMesh(mesh, output_fn) + print(f"Mesh saved to {output_fn}") + + return mesh + + +def pointcloud_to_mesh_with_progress(pcd_fn: str, output_fn: str = "mesh.ply"): + """ + Point cloud to mesh with progress bar. + + Args: + pcd_fn: Path to point cloud file + output_fn: Output mesh filename + + Returns: + mesh: The generated mesh + """ + print("Loading points...") + points = mm.loadPoints(pcd_fn) + + print("Setting up parameters...") + params = mm.PointsToMeshParameters() + bbox = points.computeBoundingBox() + params.voxelSize = bbox.diagonal() * 1e-2 + params.sigma = max(params.voxelSize, mm.findAvgPointsRadius(points, 50)) + params.minWeight = 1 + + # Add progress callback + pbar = tqdm(total=100, desc="Converting to mesh") + + def progress_callback(p): + pbar.n = int(p * 100) + pbar.refresh() + return True # Return True to continue + + params.progress = progress_callback + + print("Converting points to mesh...") + mesh = mm.pointsToMeshFusion(points, params) + pbar.close() + + # Save mesh + mm.saveMesh(mesh, output_fn) + print(f"Mesh saved to {output_fn}") + + return mesh + + +def pointcloud_to_mesh_optimized( + pcd_fn: str, + output_fn: str = "mesh.ply", + voxel_size: float = None, + sigma_multiplier: float = 1.0, + min_weight: float = 1.0, + use_gpu: bool = True, # Will auto-detect if CUDA is available +): + """ + Optimized point cloud to mesh conversion with optional GPU acceleration. + + Args: + pcd_fn: Path to point cloud file + output_fn: Output mesh filename + voxel_size: Manual voxel size (auto-computed if None) + sigma_multiplier: Multiplier for sigma (smoothness) + min_weight: Minimum weight threshold + use_gpu: Attempt to use GPU if available (requires CUDA build) + + Returns: + mesh: The generated mesh + """ + print("Loading points...") + points = mm.loadPoints(pcd_fn) + num_points = points.validPoints.count() + print(f" Loaded {num_points:,} points") + + # Setup parameters + params = mm.PointsToMeshParameters() + bbox = points.computeBoundingBox() + + # Auto-configure or use provided values + if voxel_size is None: + params.voxelSize = bbox.diagonal() * 1e-2 + else: + params.voxelSize = voxel_size + + # Compute sigma based on local point density + avg_radius = mm.findAvgPointsRadius(points, 50) + params.sigma = max(params.voxelSize, avg_radius * sigma_multiplier) + params.minWeight = min_weight + + print(f" Voxel size: {params.voxelSize:.6f}") + print(f" Sigma: {params.sigma:.6f}") + print(f" Min weight: {params.minWeight}") + + # Try to enable GPU if requested and available + gpu_enabled = False + if use_gpu: + try: + from meshlib import mrcudapy as mc + # Note: GPU acceleration for pointsToMeshFusion may not be directly available + # but other operations like FastWindingNumber can benefit + print(" CUDA module available (may accelerate some operations)") + gpu_enabled = True + except ImportError: + print(" CUDA module not available - using CPU") + + # Add progress callback + pbar = tqdm(total=100, desc="Converting to mesh") + + def progress_callback(p): + pbar.n = int(p * 100) + pbar.refresh() + return True + + params.progress = progress_callback + + # Convert to mesh + mesh = mm.pointsToMeshFusion(points, params) + pbar.close() + + # Print mesh statistics + num_verts = len(mesh.points.vec) + num_faces = mesh.topology.faceSize() + print(f"\nMesh statistics:") + print(f" Vertices: {num_verts:,}") + print(f" Faces: {num_faces:,}") + + # Save mesh + mm.saveMesh(mesh, output_fn) + print(f" Saved to: {output_fn}") + + return mesh + + +def pointcloud_to_mesh_with_gpu_acceleration(pcd_fn: str, output_fn: str = "mesh.ply"): + """ + Point cloud to mesh with GPU-accelerated distance computations. + + NOTE: This example shows WHERE GPU could be used. The mrcudapy module + is only available if: + 1. CUDA runtime is installed on the system + 2. MeshLib was built with CUDA support + + Args: + pcd_fn: Path to point cloud file + output_fn: Output mesh filename + + Returns: + mesh: The generated mesh + """ + print("Loading points...") + points = mm.loadPoints(pcd_fn) + + # Check for CUDA support + cuda_available = False + try: + from meshlib import mrcudapy as mc + cuda_available = True + print(" ✓ CUDA support available") + except ImportError: + print(" ✗ CUDA not available - using CPU") + print(" To enable CUDA:") + print(" 1. Install NVIDIA CUDA runtime") + print(" 2. Ensure MeshLib CUDA build is installed") + + # Setup parameters + params = mm.PointsToMeshParameters() + bbox = points.computeBoundingBox() + params.voxelSize = bbox.diagonal() * 1e-2 + params.sigma = max(params.voxelSize, mm.findAvgPointsRadius(points, 50)) + params.minWeight = 1 + + # Add progress + pbar = tqdm(total=100, desc="Converting to mesh") + params.progressCallback = lambda p: (pbar.update(int(p*100) - pbar.n), True)[1] + + # Convert to mesh + mesh = mm.pointsToMeshFusion(points, params) + pbar.close() + + # Post-processing: If CUDA is available, use it for distance-based operations + if cuda_available: + print("\nApplying GPU-accelerated post-processing...") + try: + from meshlib import mrcudapy as mc + + # Example: Use FastWindingNumber for inside/outside tests (GPU-accelerated) + # This could be used for mesh validation or offsetting + fwn = mc.FastWindingNumber(mesh) + print(" ✓ GPU-accelerated winding number initialized") + + # You could use this for various operations: + # - Offset operations (generalOffsetMesh with params.fwn = fwn) + # - Inside/outside testing + # - Distance field computations + + except Exception as e: + print(f" Warning: Could not use GPU acceleration: {e}") + + # Save mesh + mm.saveMesh(mesh, output_fn) + print(f"Mesh saved to {output_fn}") + + return mesh + + +# Example usage for your notebook +def notebook_example(pcd_fn: str): + """ + Example code for Jupyter notebook - updated for MeshLib 3.0.9.196 + + Usage in notebook: + from collab_splats.utils.meshlib_pointcloud_to_mesh_examples import notebook_example + mesh = notebook_example(pcd_fn) + """ + from meshlib import mrmeshpy as mm + from tqdm import tqdm + + # Load points + points = mm.loadPoints(pcd_fn) + + # Setup parameters (UPDATED for 3.0.9+) + params = mm.PointsToMeshParameters() + params.voxelSize = points.computeBoundingBox().diagonal() * 1e-2 + params.sigma = max(params.voxelSize, mm.findAvgPointsRadius(points, 50)) + params.minWeight = 1 + + # Optional: Add progress bar + pbar = tqdm(total=100, desc="Point cloud → Mesh") + + def progress_callback(p): + pbar.n = int(p * 100) + pbar.refresh() + return True + + params.progress = progress_callback + + # Convert to mesh + mesh = mm.pointsToMeshFusion(points, params) + pbar.close() + + # Optional: Try GPU acceleration if available + try: + from meshlib import mrcudapy as mc + print("✓ CUDA available - can use GPU for offset/distance operations") + # Example: fwn = mc.FastWindingNumber(mesh) + except ImportError: + print("ℹ CUDA not available - using CPU only") + + return mesh + + +if __name__ == "__main__": + import sys + + if len(sys.argv) < 2: + print("Usage: python meshlib_pointcloud_to_mesh_examples.py ") + sys.exit(1) + + pcd_fn = sys.argv[1] + output_fn = sys.argv[2] if len(sys.argv) > 2 else "output_mesh.ply" + + # Run optimized version + mesh = pointcloud_to_mesh_optimized( + pcd_fn, + output_fn, + use_gpu=True + ) diff --git a/collab_splats/utils/model_loading.py b/collab_splats/utils/model_loading.py new file mode 100644 index 00000000..b892b8d4 --- /dev/null +++ b/collab_splats/utils/model_loading.py @@ -0,0 +1,35 @@ +"""Utility functions for loading trained nerfstudio models.""" + +from pathlib import Path +from typing import Tuple, Union + + +def load_checkpoint( + config_path: Union[str, Path], + test_mode: str = "inference", +) -> Tuple: + """ + Load a trained nerfstudio model checkpoint. + + Args: + config_path: Path to the config.yml file from a trained model + test_mode: Evaluation mode - "test", "val", or "inference" (default) + + Returns: + Tuple of (config, pipeline, checkpoint_path, step) + + Example: + >>> from collab_splats.utils import load_checkpoint + >>> config, pipeline, ckpt_path, step = load_checkpoint("outputs/scene/rade-gs/config.yml") + >>> model = pipeline.model + >>> outputs = model.get_outputs(camera) + """ + # Import here to avoid circular dependency during plugin discovery + from nerfstudio.utils.eval_utils import eval_setup + + config_path = Path(config_path) + + if not config_path.exists(): + raise FileNotFoundError(f"Config file not found: {config_path}") + + return eval_setup(config_path, test_mode=test_mode) diff --git a/collab_splats/wrapper/splatter.py b/collab_splats/wrapper/splatter.py index 3e086fb7..ac292bb8 100644 --- a/collab_splats/wrapper/splatter.py +++ b/collab_splats/wrapper/splatter.py @@ -130,12 +130,20 @@ def available_methods(cls) -> None: print(" ", sorted(cls.SPLATTING_METHODS)) def preprocess( - self, overwrite: bool = False, kwargs: Optional[Dict[str, Any]] = None + self, + overwrite: bool = False, + sfm_tool: str = "colmap", + kwargs: Optional[Dict[str, Any]] = None, ) -> None: """Preprocess the data in the splatter. This function handles any necessary data preprocessing steps based on the configured method. + + Args: + overwrite: If True, rerun preprocessing even if transforms.json exists + sfm_tool: Structure from motion tool to use ('colmap', 'hloc', 'vggt', 'fastvggt') + kwargs: Additional arguments to pass to ns-process-data """ file_path = self.config["file_path"] output_path = self.config["output_path"] @@ -174,6 +182,8 @@ def preprocess( # If we have less than the minimum number of frames, as many as possible n_samples = n_frames if n_samples < self.config["min_frames"] else n_samples + print ("Number of frames to sample: ", n_samples) + # Create the command num_frames_target = f"--num-frames-target {n_samples}" else: @@ -185,6 +195,7 @@ def preprocess( f"{input_type} " f"--data {file_path.as_posix()} " f"--output-dir {preproc_data_path.as_posix()} " + f"--sfm-tool {sfm_tool} " f"{num_frames_target} " ) @@ -297,6 +308,46 @@ def _select_run(self) -> None: self.config["model_path"] = selected_run.as_posix() self.config["model_config_path"] = (selected_run / "config.yml").as_posix() + def load_model(self, config_path: Optional[Union[str, Path]] = None, test_mode: str = "inference"): + """ + Load a trained nerfstudio model. + + Args: + config_path: Path to config.yml. If None, uses model_config_path from config or prompts selection + test_mode: Evaluation mode - "test", "val", or "inference" (default) + + Returns: + Tuple of (config, pipeline, model) + + Example: + >>> splatter = Splatter(config) + >>> config, pipeline, model = splatter.load_model("outputs/scene/rade-gs/config.yml") + >>> outputs = model.get_outputs(camera) + """ + from collab_splats.utils import load_checkpoint + + # Determine config path + if config_path is None: + if not self.config.get("model_config_path"): + self._select_run() + config_path = self.config["model_config_path"] + + print(f"Loading model from {config_path}") + + # Load using utility function + config, pipeline, checkpoint_path, step = load_checkpoint(config_path, test_mode=test_mode) + + # Store in instance + self.model = pipeline.model + self.pipeline = pipeline + self.model_config = config + self.checkpoint_path = checkpoint_path + self.training_step = step + + print(f"✓ Model loaded: {type(self.model).__name__} (step {step})") + + return config, pipeline, self.model + def mesh( self, mesher_type: str = "Open3DTSDFFusion", @@ -309,7 +360,8 @@ def mesh( """ self._select_run() - mesh_dir = self.config["output_path"] / self.config["method"] / "mesh" + # Save mesh under the selected run directory + mesh_dir = Path(self.config["model_path"]) / "mesh" # Create the mesh if not mesh_dir.exists() or overwrite: @@ -317,6 +369,10 @@ def mesh( print(f"Initializing mesher {mesher_type}") + # Handle None mesher_kwargs + if mesher_kwargs is None: + mesher_kwargs = {} + # Initialize the mesher mesher = getattr(mesh, mesher_type)( load_config=Path(self.config["model_config_path"]), @@ -341,14 +397,8 @@ def query_mesh( ) -> None: """Query the mesh for features.""" - if not self.config.get("model_config_path"): - self._select_run() - elif getattr(self, "model", None) is None: - print(f"Loading model from {self.config['model_config_path']}") - from nerfstudio.utils.eval_utils import eval_setup - - _, pipeline, _, _ = eval_setup(Path(self.config["model_config_path"])) - self.model = pipeline.model + if getattr(self, "model", None) is None: + self.load_model() mesh_info = self.config.get("mesh_info") if mesh_info is None: diff --git a/docs/splats/run_pipeline.py b/docs/splats/run_pipeline.py index 06fe86c4..52632014 100644 --- a/docs/splats/run_pipeline.py +++ b/docs/splats/run_pipeline.py @@ -15,14 +15,14 @@ # 'file_path': '/workspace/fieldwork-data/birds/2024-05-19/SplatsSD/C0067.MP4', # 'frame_proportion': 0.25, # }, - 'birds_004': { - 'file_path': '/workspace/fieldwork-data/birds/2023-11-05/SplatsSD/PXL_20231105_154956078.mp4', - 'frame_proportion': 0.25, - }, - 'birds_005': { - 'file_path': '/workspace/fieldwork-data/birds/2024-06-01/SplatsSD/GH010164.MP4', - 'frame_proportion': 0.1, - }, + # 'birds_004': { + # 'file_path': '/workspace/fieldwork-data/birds/2023-11-05/SplatsSD/PXL_20231105_154956078.mp4', + # 'frame_proportion': 0.25, + # }, + # 'birds_005': { + # 'file_path': '/workspace/fieldwork-data/birds/2024-06-01/SplatsSD/GH010164.MP4', + # 'frame_proportion': 0.1, + # }, # 'birds_006': { # 'file_path': '/workspace/fieldwork-data/birds/2024-05-27/SplatsSD/GH010097.MP4', # 'frame_proportion': 0.14, @@ -39,6 +39,10 @@ # 'file_path': '/workspace/fieldwork-data/rats/2024-07-11/SplatsSD/C0119.MP4', # 'frame_proportion': 0.25, # }, + 'ants_001': { + 'file_path': '/workspace/fieldwork-data/ants/2025-11-16/SplatsSD/GH010210.MP4', + 'frame_proportion': 0.08, + }, } METHODS = ['rade-features'] #'rade-gs'] #'feature-splatting', @@ -68,16 +72,19 @@ feature_kwargs = { "pipeline.model.output-depth-during-training": True, "pipeline.model.rasterize-mode": "antialiased", - "pipeline.model.use_scale_regularization": True, + "pipeline.model.use-scale-regularization": True, + "pipeline.model.random-scale": 1.0, + "pipeline.model.cull-alpha-thresh": 0.01, + "pipeline.model.collider-params": "near_plane 0.1 far_plane 1.0", } - splatter.extract_features(kwargs=feature_kwargs) #, overwrite=True) + splatter.extract_features(kwargs=feature_kwargs, overwrite=True) # Mesh the splatting model mesher_kwargs = { 'depth_name': "median_depth", 'depth_trunc': 1.0, # Should be between 1.0 and 3.0 - 'voxel_size': 0.005, + 'voxel_size': 0.01, 'normals_name': "normals", 'features_name': "distill_features", 'sdf_trunc': 0.03, diff --git a/docs/splats/update-meshlib.ipynb b/docs/splats/update-meshlib.ipynb new file mode 100644 index 00000000..022da82d --- /dev/null +++ b/docs/splats/update-meshlib.ipynb @@ -0,0 +1,420 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "d1133a9e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Jupyter environment detected. Enabling Open3D WebVisualizer.\n", + "[Open3D INFO] WebRTC GUI backend enabled.\n", + "[Open3D INFO] WebRTCWindowSystem: HTTP handshake server disabled.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/conda/envs/nerfstudio/lib/python3.10/site-packages/pyvista/plotting/utilities/xvfb.py:48: PyVistaDeprecationWarning: This function is deprecated and will be removed in future version of PyVista. Use vtk-osmesa instead.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import os\n", + "import sys\n", + "from pathlib import Path\n", + "\n", + "import pyvista as pv\n", + "\n", + "from collab_splats.utils.visualization import (\n", + " CAMERA_KWARGS,\n", + " MESH_KWARGS,\n", + " VIZ_KWARGS,\n", + " visualize_splat,\n", + ")\n", + "from collab_splats.wrapper import Splatter, SplatterConfig\n", + "\n", + "pv.start_xvfb()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5d0cd627", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "transforms.json already exists at /workspace/fieldwork-data/rats/2024-07-11/environment/C0119/preproc/transforms.json\n", + "To rerun preprocessing, set overwrite=True\n", + "Output already exists for rade-features\n", + "To rerun feature extraction, set overwrite=True\n", + "\n", + "Available runs:\n", + "[0] 2025-07-25_074037\n", + "Loading model from /workspace/fieldwork-data/rats/2024-07-11/environment/C0119/rade-features/2025-07-25_074037/config.yml\n", + "[Taichi] version 1.7.4, llvm 15.0.4, commit b4b956fd, linux, python 3.10.18\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[I 11/21/25 04:08:25.360 36189] [shell.py:_shell_pop_print@23] Graphical python shell detected, using wrapped sys.stdout\n" + ] + }, + { + "data": { + "text/html": [ + "
Found cached features at \n",
+       "/workspace/fieldwork-data/rats/2024-07-11/environment/C0119/preproc/feature-splatting_samclip-features.pt\n",
+       "
\n" + ], + "text/plain": [ + "Found cached features at \n", + "\u001b[35m/workspace/fieldwork-data/rats/2024-07-11/environment/C0119/preproc/\u001b[0m\u001b[95mfeature-splatting_samclip-features.pt\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
✓ Loading features from cache\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[32m✓ Loading features from cache\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
[04:09:00] use color only optimization with sigmoid activation                                         splatfacto.py:213\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m[04:09:00]\u001b[0m\u001b[2;36m \u001b[0muse color only optimization with sigmoid activation \u001b]8;id=191073;file:///opt/conda/envs/nerfstudio/lib/python3.10/site-packages/nerfstudio/models/splatfacto.py\u001b\\\u001b[2msplatfacto.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=576265;file:///opt/conda/envs/nerfstudio/lib/python3.10/site-packages/nerfstudio/models/splatfacto.py#213\u001b\\\u001b[2m213\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
Loading latest checkpoint from load_dir\n",
+       "
\n" + ], + "text/plain": [ + "Loading latest checkpoint from load_dir\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
✅ Done loading checkpoint from \n",
+       "/workspace/fieldwork-data/rats/2024-07-11/environment/C0119/rade-features/2025-07-25_074037/nerfstudio_models/step-00002\n",
+       "9999.ckpt\n",
+       "
\n" + ], + "text/plain": [ + "✅ Done loading checkpoint from \n", + "\u001b[35m/workspace/fieldwork-data/rats/2024-07-11/environment/C0119/rade-features/2025-07-25_074037/nerfstudio_models/\u001b[0m\u001b[95mstep-00002\u001b[0m\n", + "\u001b[95m9999.ckpt\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Model loaded: RadegsFeaturesModel (step 29999)\n" + ] + } + ], + "source": [ + "base_dir = Path(\"/workspace/fieldwork-data/\")\n", + "session_dir = base_dir / \"rats/2024-07-11/SplatsSD\"\n", + "\n", + "# Make the configuration\n", + "splatter_config = SplatterConfig(\n", + " file_path=session_dir / \"C0119.MP4\",\n", + " method=\"rade-features\",\n", + " frame_proportion=0.25, # Use 25% of the frames within the video (or default to minimum 300 frames)\n", + ")\n", + "\n", + "# Initialize the Splatter class\n", + "splatter = Splatter(splatter_config)\n", + "\n", + "# Call these to populate the splatter with paths (probably a better way to do this --> maybe save out config)\n", + "splatter.preprocess()\n", + "splatter.extract_features()\n", + "\n", + "splatter.mesh()\n", + "\n", + "# Load model through splatter - automatically manages selection\n", + "config, pipeline, model = splatter.load_model()\n", + "\n", + "# # Or specify a specific config path\n", + "# # config, pipeline, model = splatter.load_model(\"outputs/scene/rade-gs/config.yml\")\n", + "\n", + "# print(f\"Model type: {type(model).__name__}\")\n", + "# print(f\"Training step: {splatter.training_step}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5ae27e05", + "metadata": {}, + "outputs": [], + "source": [ + "mesh_fn = splatter.config['mesh_info']['mesh'].as_posix()\n", + "splat_fn = mesh_fn.replace('mesh.ply', 'splats.ply')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d3fd3954", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saving splats pointcloud\n", + "\u001b[1;33m[Open3D WARNING] Write Ply clamped color value to valid range\u001b[0;m\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import open3d as o3d\n", + "from nerfstudio.utils.spherical_harmonics import SH2RGB\n", + "\n", + "# Grab the means from the model\n", + "print(\"Saving splats pointcloud\")\n", + "means = model.means.detach().cpu().numpy()\n", + "colors = model.features_dc.detach().cpu().numpy()\n", + "# normals = model.normals.detach().cpu().numpy()\n", + "colors = SH2RGB(colors)\n", + "\n", + "# Pass xyz to Open3D.o3d.geometry.PointCloud and visualize\n", + "pcd = o3d.geometry.PointCloud()\n", + "pcd.points = o3d.utility.Vector3dVector(means)\n", + "pcd.colors = o3d.utility.Vector3dVector(colors)\n", + "# pcd.normals = o3d.utility.Vector3dVector(normals)\n", + "\n", + "# Write out\n", + "o3d.io.write_point_cloud(splat_fn, pcd, write_ascii=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "10021fc8", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Point cloud → Mesh: 50%|█████ | 50/100 [00:16<00:16, 3.03it/s]" + ] + } + ], + "source": [ + "from meshlib import mrmeshpy as mm\n", + "from tqdm import tqdm\n", + "\n", + "points = mm.loadPoints(splat_fn)\n", + "\n", + "params = mm.PointsToMeshParameters()\n", + "params.voxelSize = points.computeBoundingBox().diagonal() * 1e-4\n", + "params.sigma = max(params.voxelSize, mm.findAvgPointsRadius(points, 50))\n", + "params.minWeight = 1\n", + "\n", + "# Add progress bar\n", + "pbar = tqdm(total=100, desc=\"Point cloud → Mesh\")\n", + "params.progress = lambda p: (pbar.update(int(p*100) - pbar.n), True)[1]\n", + "\n", + "mesh = mm.pointsToMeshFusion(points, params)\n", + "pbar.close()\n", + "\n", + "mm.saveMesh(mesh, 'test_mesh.ply')\n", + "print(f\"✓ Generated mesh: {len(mesh.points.vec):,} vertices, {mesh.topology.faceSize():,} faces\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "7b78d6ea", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Generated mesh: 174,713 vertices, 254,122 faces\n" + ] + } + ], + "source": [ + "mm.saveMesh(mesh, 'test_mesh.ply')\n", + "print(f\"✓ Generated mesh: {len(mesh.points.vec):,} vertices, {mesh.topology.faceSize():,} faces\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "9722c6b9", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Mapping features to vertices: 100%|██████████| 5/5 [00:00<00:00, 20.19it/s]\n" + ] + } + ], + "source": [ + "import open3d as o3d\n", + "from collab_splats.utils.mesh import features2vertex\n", + "import numpy as np\n", + "\n", + "pcd = o3d.io.read_point_cloud(splat_fn)\n", + "test_mesh = pv.read('test_mesh.ply')\n", + "\n", + "colors = features2vertex(\n", + " test_mesh.points, pcd.points, np.asarray(pcd.colors)\n", + ")\n", + "\n", + "test_mesh.point_data['RGB'] = colors" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "e2dc8a9a", + "metadata": {}, + "outputs": [], + "source": [ + "# Load the mesh transform\n", + "mesh_transform = splatter.load_mesh_transform()\n", + "\n", + "# Now map the points to the mesh\n", + "points = np.asarray(test_mesh.points)\n", + "points_homo = np.concatenate([points, np.ones((points.shape[0], 1))], axis=-1)\n", + "points_homo = mesh_transform[\"mesh_transform\"] @ points_homo.T\n", + "\n", + "# Move back out of homogenous coordinates\n", + "points = points_homo.T[..., :-1]\n", + "\n", + "test_mesh.points = points" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "b01cce0d", + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import pyplot as plt\n", + "\n", + "plotter = visualize_splat(\n", + " mesh=test_mesh,\n", + " mesh_kwargs=MESH_KWARGS,\n", + " viz_kwargs=VIZ_KWARGS,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "db021acc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "image = plotter.screenshot(\n", + " window_size=(1000, 1000),\n", + ")\n", + "\n", + "plt.imshow(image)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "nerfstudio", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.18" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/splats/visualization.ipynb b/docs/splats/visualization.ipynb index 50e0c2c5..b054f4bf 100644 --- a/docs/splats/visualization.ipynb +++ b/docs/splats/visualization.ipynb @@ -12,10 +12,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "5571b670", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Jupyter environment detected. Enabling Open3D WebVisualizer.\n", + "[Open3D INFO] WebRTC GUI backend enabled.\n", + "[Open3D INFO] WebRTCWindowSystem: HTTP handshake server disabled.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/conda/envs/nerfstudio/lib/python3.10/site-packages/pyvista/plotting/utilities/xvfb.py:48: PyVistaDeprecationWarning: This function is deprecated and will be removed in future version of PyVista. Use vtk-osmesa instead.\n", + " warnings.warn(\n" + ] + } + ], "source": [ "import os\n", "import sys\n", @@ -32,7 +50,9 @@ " VIZ_KWARGS,\n", " visualize_splat,\n", ")\n", - "from collab_splats.wrapper import Splatter, SplatterConfig" + "from collab_splats.wrapper import Splatter, SplatterConfig\n", + "\n", + "pv.start_xvfb()" ] }, { @@ -45,10 +65,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "882c8daa", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "transforms.json already exists at /workspace/fieldwork-data/birds/2024-02-06/environment/C0043/preproc/transforms.json\n", + "To rerun preprocessing, set overwrite=True\n", + "Output already exists for rade-features\n", + "To rerun feature extraction, set overwrite=True\n", + "\n", + "Available runs:\n", + "[0] 2025-07-25_040743\n" + ] + } + ], "source": [ "base_dir = Path(\"/workspace/fieldwork-data/\")\n", "session_dir = base_dir / \"birds/2024-02-06/SplatsSD\"\n", @@ -84,10 +118,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "373e0579", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c482271074624f878198e123e6894712", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Widget(value='