Add files using upload-large-folder tool

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/.clang-format

@@ -0,0 +1,85 @@
+AccessModifierOffset: -1
+AlignAfterOpenBracket: AlwaysBreak
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlinesLeft: true
+AlignOperands:   false
+AlignTrailingComments: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: true
+AlwaysBreakTemplateDeclarations: true
+BinPackArguments: false
+BinPackParameters: false
+BraceWrapping:
+  AfterClass:      false
+  AfterControlStatement: false
+  AfterEnum:       false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  BeforeCatch:     false
+  BeforeElse:      false
+  IndentBraces:    false
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Attach
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: false
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat:   false
+ForEachMacros:   [ FOR_EACH, FOR_EACH_R, FOR_EACH_RANGE, ]
+IncludeCategories:
+  - Regex:           '^<.*\.h(pp)?>'
+    Priority:        1
+  - Regex:           '^<.*'
+    Priority:        2
+  - Regex:           '.*'
+    Priority:        3
+IndentCaseLabels: true
+IndentWidth:     2
+IndentWrappedFunctionNames: false
+KeepEmptyLinesAtTheStartOfBlocks: false
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: false
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 200
+PointerAlignment: Left
+ReflowComments:  true
+SortIncludes:    true
+SpaceAfterCStyleCast: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard:        Cpp11
+TabWidth:        8
+UseTab:          Never

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/.flake8

@@ -0,0 +1,9 @@
+[flake8]
+# B028 No explicit stacklevel argument found.
+# B907 'foo' is manually surrounded by quotes, consider using the `!r` conversion flag.
+# B905 `zip()` without an explicit `strict=` parameter.
+ignore = E203, E266, E501, W503, E221, B028, B905, B907
+max-line-length = 88
+max-complexity = 18
+select = B,C,E,F,W,T4,B9
+exclude = build,__init__.py

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/.gitignore

@@ -0,0 +1,21 @@
+build/
+dist/
+*.egg-info/
+**/__pycache__/
+*-checkpoint.ipynb
+**/.ipynb_checkpoints
+**/.ipynb_checkpoints/**
+
+
+# Docusaurus site
+website/yarn.lock
+website/build/
+website/i18n/
+website/node_modules/*
+website/npm-debug.log
+
+## Generated for tutorials
+website/_tutorials/
+website/static/files/
+website/pages/tutorials/*
+!website/pages/tutorials/index.js

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/INSTALL.md

@@ -0,0 +1,157 @@
+# Installation
+
+
+## Requirements
+
+### Core library
+
+The core library is written in PyTorch. Several components have underlying implementation in CUDA for improved performance. A subset of these components have CPU implementations in C++/PyTorch. It is advised to use PyTorch3D with GPU support in order to use all the features.
+
+- Linux or macOS or Windows
+- Python
+- PyTorch 2.1.0, 2.1.1, 2.1.2, 2.2.0, 2.2.1, 2.2.2, 2.3.0, 2.3.1, 2.4.0 or 2.4.1.
+- torchvision that matches the PyTorch installation. You can install them together as explained at pytorch.org to make sure of this.
+- gcc & g++ ≥ 4.9
+- [ioPath](https://github.com/facebookresearch/iopath)
+- If CUDA is to be used, use a version which is supported by the corresponding pytorch version and at least version 9.2.
+- If CUDA older than 11.7 is to be used and you are building from source, the CUB library must be available. We recommend version 1.10.0.
+
+The runtime dependencies can be installed by running:
+```
+conda create -n pytorch3d python=3.9
+conda activate pytorch3d
+conda install pytorch=1.13.0 torchvision pytorch-cuda=11.6 -c pytorch -c nvidia
+conda install -c iopath iopath
+```
+
+For the CUB build time dependency, which you only need if you have CUDA older than 11.7, if you are using conda, you can continue with
+```
+conda install -c bottler nvidiacub
+```
+Otherwise download the CUB library from https://github.com/NVIDIA/cub/releases and unpack it to a folder of your choice.
+Define the environment variable CUB_HOME before building and point it to the directory that contains `CMakeLists.txt` for CUB.
+For example on Linux/Mac,
+```
+curl -LO https://github.com/NVIDIA/cub/archive/1.10.0.tar.gz
+tar xzf 1.10.0.tar.gz
+export CUB_HOME=$PWD/cub-1.10.0
+```
+
+### Tests/Linting and Demos
+
+For developing on top of PyTorch3D or contributing, you will need to run the linter and tests. If you want to run any of the notebook tutorials as `docs/tutorials` or the examples in `docs/examples` you will also need matplotlib and OpenCV.
+- scikit-image
+- black
+- usort
+- flake8
+- matplotlib
+- tdqm
+- jupyter
+- imageio
+- fvcore
+- plotly
+- opencv-python
+
+These can be installed by running:
+```
+# Demos and examples
+conda install jupyter
+pip install scikit-image matplotlib imageio plotly opencv-python
+
+# Tests/Linting
+conda install -c fvcore -c conda-forge fvcore
+pip install black usort flake8 flake8-bugbear flake8-comprehensions
+```
+
+## Installing prebuilt binaries for PyTorch3D
+After installing the above dependencies, run one of the following commands:
+
+### 1. Install with CUDA support from Anaconda Cloud, on Linux only
+
+```
+# Anaconda Cloud
+conda install pytorch3d -c pytorch3d
+```
+
+Or, to install a nightly (non-official, alpha) build:
+```
+# Anaconda Cloud
+conda install pytorch3d -c pytorch3d-nightly
+```
+
+### 2. Install wheels for Linux
+We have prebuilt wheels with CUDA for Linux for PyTorch 1.11.0, for each of the supported CUDA versions,
+for Python 3.8 and 3.9. This is for ease of use on Google Colab.
+These are installed in a special way.
+For example, to install for Python 3.8, PyTorch 1.11.0 and CUDA 11.3
+```
+pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/py38_cu113_pyt1110/download.html
+```
+
+In general, from inside IPython, or in Google Colab or a jupyter notebook, you can install with
+```
+import sys
+import torch
+pyt_version_str=torch.__version__.split("+")[0].replace(".", "")
+version_str="".join([
+    f"py3{sys.version_info.minor}_cu",
+    torch.version.cuda.replace(".",""),
+    f"_pyt{pyt_version_str}"
+])
+!pip install iopath
+!pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html
+```
+
+## Building / installing from source.
+CUDA support will be included if CUDA is available in pytorch or if the environment variable
+`FORCE_CUDA` is set to `1`.
+
+### 1. Install from GitHub
+```
+pip install "git+https://github.com/facebookresearch/pytorch3d.git"
+```
+To install using the code of the released version instead of from the main branch, use the following instead.
+```
+pip install "git+https://github.com/facebookresearch/pytorch3d.git@stable"
+```
+
+For CUDA builds with versions earlier than CUDA 11, set `CUB_HOME` before building as described above.
+
+**Install from Github on macOS:**
+Some environment variables should be provided, like this.
+```
+MACOSX_DEPLOYMENT_TARGET=10.14 CC=clang CXX=clang++ pip install "git+https://github.com/facebookresearch/pytorch3d.git"
+```
+
+### 2. Install from a local clone
+```
+git clone https://github.com/facebookresearch/pytorch3d.git
+cd pytorch3d && pip install -e .
+```
+To rebuild after installing from a local clone run, `rm -rf build/ **/*.so` then `pip install -e .`. You often need to rebuild pytorch3d after reinstalling PyTorch. For CUDA builds with versions earlier than CUDA 11, set `CUB_HOME` before building as described above.
+
+**Install from local clone on macOS:**
+```
+MACOSX_DEPLOYMENT_TARGET=10.14 CC=clang CXX=clang++ pip install -e .
+```
+
+**Install from local clone on Windows:**
+
+Depending on the version of PyTorch, changes to some PyTorch headers may be needed before compilation. These are often discussed in issues in this repository.
+
+After any necessary patching, you can go to "x64 Native Tools Command Prompt for VS 2019" to compile and install
+```
+cd pytorch3d
+python3 setup.py install
+```
+
+After installing, you can run **unit tests**
+```
+python3 -m unittest discover -v -s tests -t .
+```
+
+# FAQ
+
+### Can I use Docker?
+
+We don't provide a docker file but see [#113](https://github.com/facebookresearch/pytorch3d/issues/113) for a docker file shared by a user (NOTE: this has not been tested by the PyTorch3D team).

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/LICENSE

@@ -0,0 +1,30 @@
+BSD License
+
+For PyTorch3D software
+
+Copyright (c) Meta Platforms, Inc. and affiliates. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+ * Neither the name Meta nor the names of its contributors may be used to
+   endorse or promote products derived from this software without specific
+   prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/README.md

@@ -0,0 +1,183 @@
+<img src="https://raw.githubusercontent.com/facebookresearch/pytorch3d/main/.github/pytorch3dlogo.png" width="900"/>
+
+[![CircleCI](https://circleci.com/gh/facebookresearch/pytorch3d.svg?style=svg)](https://circleci.com/gh/facebookresearch/pytorch3d)
+[![Anaconda-Server Badge](https://anaconda.org/pytorch3d/pytorch3d/badges/version.svg)](https://anaconda.org/pytorch3d/pytorch3d)
+
+# Introduction
+
+PyTorch3D provides efficient, reusable components for 3D Computer Vision research with [PyTorch](https://pytorch.org).
+
+Key features include:
+
+- Data structure for storing and manipulating triangle meshes
+- Efficient operations on triangle meshes (projective transformations, graph convolution, sampling, loss functions)
+- A differentiable mesh renderer
+- Implicitron, see [its README](projects/implicitron_trainer), a framework for new-view synthesis via implicit representations. ([blog post](https://ai.facebook.com/blog/implicitron-a-new-modular-extensible-framework-for-neural-implicit-representations-in-pytorch3d/))
+
+PyTorch3D is designed to integrate smoothly with deep learning methods for predicting and manipulating 3D data.
+For this reason, all operators in PyTorch3D:
+
+- Are implemented using PyTorch tensors
+- Can handle minibatches of hetereogenous data
+- Can be differentiated
+- Can utilize GPUs for acceleration
+
+Within FAIR, PyTorch3D has been used to power research projects such as [Mesh R-CNN](https://arxiv.org/abs/1906.02739).
+
+See our [blog post](https://ai.facebook.com/blog/-introducing-pytorch3d-an-open-source-library-for-3d-deep-learning/) to see more demos and learn about PyTorch3D.
+
+## Installation
+
+For detailed instructions refer to [INSTALL.md](INSTALL.md).
+
+## License
+
+PyTorch3D is released under the [BSD License](LICENSE).
+
+## Tutorials
+
+Get started with PyTorch3D by trying one of the tutorial notebooks.
+
+|<img src="https://raw.githubusercontent.com/facebookresearch/pytorch3d/main/.github/dolphin_deform.gif" width="310"/>|<img src="https://raw.githubusercontent.com/facebookresearch/pytorch3d/main/.github/bundle_adjust.gif" width="310"/>|
+|:-----------------------------------------------------------------------------------------------------------:|:--------------------------------------------------:|
+| [Deform a sphere mesh to dolphin](https://github.com/facebookresearch/pytorch3d/blob/main/docs/tutorials/deform_source_mesh_to_target_mesh.ipynb)| [Bundle adjustment](https://github.com/facebookresearch/pytorch3d/blob/main/docs/tutorials/bundle_adjustment.ipynb) |
+
+| <img src="https://raw.githubusercontent.com/facebookresearch/pytorch3d/main/.github/render_textured_mesh.gif" width="310"/> | <img src="https://raw.githubusercontent.com/facebookresearch/pytorch3d/main/.github/camera_position_teapot.gif" width="310" height="310"/>
+|:------------------------------------------------------------:|:--------------------------------------------------:|
+| [Render textured meshes](https://github.com/facebookresearch/pytorch3d/blob/main/docs/tutorials/render_textured_meshes.ipynb)| [Camera position optimization](https://github.com/facebookresearch/pytorch3d/blob/main/docs/tutorials/camera_position_optimization_with_differentiable_rendering.ipynb)|
+
+| <img src="https://raw.githubusercontent.com/facebookresearch/pytorch3d/main/.github/pointcloud_render.png" width="310"/> | <img src="https://raw.githubusercontent.com/facebookresearch/pytorch3d/main/.github/cow_deform.gif" width="310" height="310"/>
+|:------------------------------------------------------------:|:--------------------------------------------------:|
+| [Render textured pointclouds](https://github.com/facebookresearch/pytorch3d/blob/main/docs/tutorials/render_colored_points.ipynb)| [Fit a mesh with texture](https://github.com/facebookresearch/pytorch3d/blob/main/docs/tutorials/fit_textured_mesh.ipynb)|
+
+| <img src="https://raw.githubusercontent.com/facebookresearch/pytorch3d/main/.github/densepose_render.png" width="310"/> | <img src="https://raw.githubusercontent.com/facebookresearch/pytorch3d/main/.github/shapenet_render.png" width="310" height="310"/>
+|:------------------------------------------------------------:|:--------------------------------------------------:|
+| [Render DensePose data](https://github.com/facebookresearch/pytorch3d/blob/main/docs/tutorials/render_densepose.ipynb)| [Load & Render ShapeNet data](https://github.com/facebookresearch/pytorch3d/blob/main/docs/tutorials/dataloaders_ShapeNetCore_R2N2.ipynb)|
+
+| <img src="https://raw.githubusercontent.com/facebookresearch/pytorch3d/main/.github/fit_textured_volume.gif" width="310"/> | <img src="https://raw.githubusercontent.com/facebookresearch/pytorch3d/main/.github/fit_nerf.gif" width="310" height="310"/>
+|:------------------------------------------------------------:|:--------------------------------------------------:|
+| [Fit Textured Volume](https://github.com/facebookresearch/pytorch3d/blob/main/docs/tutorials/fit_textured_volume.ipynb)| [Fit A Simple Neural Radiance Field](https://github.com/facebookresearch/pytorch3d/blob/main/docs/tutorials/fit_simple_neural_radiance_field.ipynb)|
+
+| <img src="https://raw.githubusercontent.com/facebookresearch/pytorch3d/main/.github/fit_textured_volume.gif" width="310"/> | <img src="https://raw.githubusercontent.com/facebookresearch/pytorch3d/main/.github/implicitron_config.gif" width="310" height="310"/>
+|:------------------------------------------------------------:|:--------------------------------------------------:|
+| [Fit Textured Volume in Implicitron](https://github.com/facebookresearch/pytorch3d/blob/main/docs/tutorials/implicitron_volumes.ipynb)| [Implicitron Config System](https://github.com/facebookresearch/pytorch3d/blob/main/docs/tutorials/implicitron_config_system.ipynb)|
+
+
+
+
+
+## Documentation
+
+Learn more about the API by reading the PyTorch3D [documentation](https://pytorch3d.readthedocs.org/).
+
+We also have deep dive notes on several API components:
+
+- [Heterogeneous Batching](https://github.com/facebookresearch/pytorch3d/tree/main/docs/notes/batching.md)
+- [Mesh IO](https://github.com/facebookresearch/pytorch3d/tree/main/docs/notes/meshes_io.md)
+- [Differentiable Rendering](https://github.com/facebookresearch/pytorch3d/tree/main/docs/notes/renderer_getting_started.md)
+
+### Overview Video
+
+We have created a short (~14 min) video tutorial providing an overview of the PyTorch3D codebase including several code examples. Click on the image below to watch the video on YouTube:
+
+<a href="http://www.youtube.com/watch?v=Pph1r-x9nyY"><img src="http://img.youtube.com/vi/Pph1r-x9nyY/0.jpg" height="225" ></a>
+
+## Development
+
+We welcome new contributions to PyTorch3D and we will be actively maintaining this library! Please refer to [CONTRIBUTING.md](./.github/CONTRIBUTING.md) for full instructions on how to run the code, tests and linter, and submit your pull requests.
+
+## Development and Compatibility
+
+- `main` branch: actively developed, without any guarantee, Anything can be broken at any time
+  - REMARK: this includes nightly builds which are built from `main`
+  - HINT: the commit history can help locate regressions or changes
+- backward-compatibility between releases: no guarantee. Best efforts to communicate breaking changes and facilitate migration of code or data (incl. models).
+
+## Contributors
+
+PyTorch3D is written and maintained by the Facebook AI Research Computer Vision Team.
+
+In alphabetical order:
+
+* Amitav Baruah
+* Steve Branson
+* Krzysztof Chalupka
+* Jiali Duan
+* Luya Gao
+* Georgia Gkioxari
+* Taylor Gordon
+* Justin Johnson
+* Patrick Labatut
+* Christoph Lassner
+* Wan-Yen Lo
+* David Novotny
+* Nikhila Ravi
+* Jeremy Reizenstein
+* Dave Schnizlein
+* Roman Shapovalov
+* Olivia Wiles
+
+## Citation
+
+If you find PyTorch3D useful in your research, please cite our tech report:
+
+```bibtex
+@article{ravi2020pytorch3d,
+    author = {Nikhila Ravi and Jeremy Reizenstein and David Novotny and Taylor Gordon
+                  and Wan-Yen Lo and Justin Johnson and Georgia Gkioxari},
+    title = {Accelerating 3D Deep Learning with PyTorch3D},
+    journal = {arXiv:2007.08501},
+    year = {2020},
+}
+```
+
+If you are using the pulsar backend for sphere-rendering (the `PulsarPointRenderer` or `pytorch3d.renderer.points.pulsar.Renderer`), please cite the tech report:
+
+```bibtex
+@article{lassner2020pulsar,
+    author = {Christoph Lassner and Michael Zollh\"ofer},
+    title = {Pulsar: Efficient Sphere-based Neural Rendering},
+    journal = {arXiv:2004.07484},
+    year = {2020},
+}
+```
+
+## News
+
+Please see below for a timeline of the codebase updates in reverse chronological order. We are sharing updates on the releases as well as research projects which are built with PyTorch3D. The changelogs for the releases are available under [`Releases`](https://github.com/facebookresearch/pytorch3d/releases),  and the builds can be installed using `conda` as per the instructions in [INSTALL.md](INSTALL.md).
+
+**[Oct 31st 2023]:**   PyTorch3D [v0.7.5](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.7.5) released.
+
+**[May 10th 2023]:**   PyTorch3D [v0.7.4](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.7.4) released.
+
+**[Apr 5th 2023]:**   PyTorch3D [v0.7.3](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.7.3) released.
+
+**[Dec 19th 2022]:**   PyTorch3D [v0.7.2](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.7.2) released.
+
+**[Oct 23rd 2022]:**   PyTorch3D [v0.7.1](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.7.1) released.
+
+**[Aug 10th 2022]:**   PyTorch3D [v0.7.0](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.7.0) released with Implicitron and MeshRasterizerOpenGL.
+
+**[Apr 28th 2022]:**   PyTorch3D [v0.6.2](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.6.2) released
+
+**[Dec 16th 2021]:**   PyTorch3D [v0.6.1](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.6.1) released
+
+**[Oct 6th 2021]:**   PyTorch3D [v0.6.0](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.6.0) released
+
+**[Aug 5th 2021]:**   PyTorch3D [v0.5.0](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.5.0) released
+
+**[Feb 9th 2021]:** PyTorch3D [v0.4.0](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.4.0) released with support for implicit functions, volume rendering and a [reimplementation of NeRF](https://github.com/facebookresearch/pytorch3d/tree/main/projects/nerf).
+
+**[November 2nd 2020]:** PyTorch3D [v0.3.0](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.3.0) released, integrating the pulsar backend.
+
+**[Aug 28th 2020]:**   PyTorch3D [v0.2.5](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.2.5) released
+
+**[July 17th 2020]:**   PyTorch3D tech report published on ArXiv: https://arxiv.org/abs/2007.08501
+
+**[April 24th 2020]:**   PyTorch3D [v0.2.0](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.2.0) released
+
+**[March 25th 2020]:**   [SynSin](https://arxiv.org/abs/1912.08804) codebase released using PyTorch3D: https://github.com/facebookresearch/synsin
+
+**[March 8th 2020]:**   PyTorch3D [v0.1.1](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.1.1) bug fix release
+
+**[Jan 23rd 2020]:**   PyTorch3D [v0.1.0](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.1.0) released. [Mesh R-CNN](https://arxiv.org/abs/1906.02739) codebase released: https://github.com/facebookresearch/meshrcnn

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/setup.cfg

@@ -0,0 +1,14 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+[isort]
+line_length = 88
+multi_line_output = 3
+include_trailing_comma = True
+force_grid_warp = 0
+default_section = THIRDPARTY
+lines_after_imports = 2
+combine_as_imports = True

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/setup.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+import glob
+import os
+import runpy
+import sys
+import warnings
+from typing import List, Optional
+
+import torch
+from setuptools import find_packages, setup
+from torch.utils.cpp_extension import CppExtension, CUDA_HOME, CUDAExtension
+
+
+def get_existing_ccbin(nvcc_args: List[str]) -> Optional[str]:
+    """
+    Given a list of nvcc arguments, return the compiler if specified.
+
+    Note from CUDA doc: Single value options and list options must have
+    arguments, which must follow the name of the option itself by either
+    one of more spaces or an equals character.
+    """
+    last_arg = None
+    for arg in reversed(nvcc_args):
+        if arg == "-ccbin":
+            return last_arg
+        if arg.startswith("-ccbin="):
+            return arg[7:]
+        last_arg = arg
+    return None
+
+
+def get_extensions():
+    no_extension = os.getenv("PYTORCH3D_NO_EXTENSION", "0") == "1"
+    if no_extension:
+        msg = "SKIPPING EXTENSION BUILD. PYTORCH3D WILL NOT WORK!"
+        print(msg, file=sys.stderr)
+        warnings.warn(msg)
+        return []
+
+    this_dir = os.path.dirname(os.path.abspath(__file__))
+    extensions_dir = os.path.join(this_dir, "pytorch3d", "csrc")
+    sources = glob.glob(os.path.join(extensions_dir, "**", "*.cpp"), recursive=True)
+    source_cuda = glob.glob(os.path.join(extensions_dir, "**", "*.cu"), recursive=True)
+    extension = CppExtension
+
+    extra_compile_args = {"cxx": ["-std=c++17"]}
+    define_macros = []
+    include_dirs = [extensions_dir]
+
+    force_cuda = os.getenv("FORCE_CUDA", "0") == "1"
+    force_no_cuda = os.getenv("PYTORCH3D_FORCE_NO_CUDA", "0") == "1"
+    if (
+        not force_no_cuda and torch.cuda.is_available() and CUDA_HOME is not None
+    ) or force_cuda:
+        extension = CUDAExtension
+        sources += source_cuda
+        define_macros += [("WITH_CUDA", None)]
+        # Thrust is only used for its tuple objects.
+        # With CUDA 11.0 we can't use the cudatoolkit's version of cub.
+        # We take the risk that CUB and Thrust are incompatible, because
+        # we aren't using parts of Thrust which actually use CUB.
+        define_macros += [("THRUST_IGNORE_CUB_VERSION_CHECK", None)]
+        cub_home = os.environ.get("CUB_HOME", None)
+        nvcc_args = [
+            "-DCUDA_HAS_FP16=1",
+            "-D__CUDA_NO_HALF_OPERATORS__",
+            "-D__CUDA_NO_HALF_CONVERSIONS__",
+            "-D__CUDA_NO_HALF2_OPERATORS__",
+        ]
+        if os.name != "nt":
+            nvcc_args.append("-std=c++17")
+        if cub_home is None:
+            prefix = os.environ.get("CONDA_PREFIX", None)
+            if prefix is not None and os.path.isdir(prefix + "/include/cub"):
+                cub_home = prefix + "/include"
+
+        if cub_home is None:
+            warnings.warn(
+                "The environment variable `CUB_HOME` was not found. "
+                "NVIDIA CUB is required for compilation and can be downloaded "
+                "from `https://github.com/NVIDIA/cub/releases`. You can unpack "
+                "it to a location of your choice and set the environment variable "
+                "`CUB_HOME` to the folder containing the `CMakeListst.txt` file."
+            )
+        else:
+            include_dirs.append(os.path.realpath(cub_home).replace("\\ ", " "))
+        nvcc_flags_env = os.getenv("NVCC_FLAGS", "")
+        if nvcc_flags_env != "":
+            nvcc_args.extend(nvcc_flags_env.split(" "))
+
+        # This is needed for pytorch 1.6 and earlier. See e.g.
+        # https://github.com/facebookresearch/pytorch3d/issues/436
+        # It is harmless after https://github.com/pytorch/pytorch/pull/47404 .
+        # But it can be problematic in torch 1.7.0 and 1.7.1
+        if torch.__version__[:4] != "1.7.":
+            CC = os.environ.get("CC", None)
+            if CC is not None:
+                existing_CC = get_existing_ccbin(nvcc_args)
+                if existing_CC is None:
+                    CC_arg = "-ccbin={}".format(CC)
+                    nvcc_args.append(CC_arg)
+                elif existing_CC != CC:
+                    msg = f"Inconsistent ccbins: {CC} and {existing_CC}"
+                    raise ValueError(msg)
+
+        extra_compile_args["nvcc"] = nvcc_args
+
+    sources = [os.path.join(extensions_dir, s) for s in sources]
+
+    ext_modules = [
+        extension(
+            "pytorch3d._C",
+            sources,
+            include_dirs=include_dirs,
+            define_macros=define_macros,
+            extra_compile_args=extra_compile_args,
+        )
+    ]
+
+    return ext_modules
+
+
+# Retrieve __version__ from the package.
+__version__ = runpy.run_path("pytorch3d/__init__.py")["__version__"]
+
+
+if os.getenv("PYTORCH3D_NO_NINJA", "0") == "1":
+
+    class BuildExtension(torch.utils.cpp_extension.BuildExtension):
+        def __init__(self, *args, **kwargs):
+            super().__init__(use_ninja=False, *args, **kwargs)
+
+else:
+    BuildExtension = torch.utils.cpp_extension.BuildExtension
+
+trainer = "pytorch3d.implicitron_trainer"
+
+setup(
+    name="pytorch3d",
+    version=__version__,
+    author="FAIR",
+    url="https://github.com/facebookresearch/pytorch3d",
+    description="PyTorch3D is FAIR's library of reusable components "
+    "for deep Learning with 3D data.",
+    packages=find_packages(
+        exclude=("configs", "tests", "tests.*", "docs.*", "projects.*")
+    )
+    + [trainer],
+    package_dir={trainer: "projects/implicitron_trainer"},
+    install_requires=["iopath"],
+    extras_require={
+        "all": ["matplotlib", "tqdm>4.29.0", "imageio", "ipywidgets"],
+        "dev": ["flake8", "usort"],
+        "implicitron": [
+            "hydra-core>=1.1",
+            "visdom",
+            "lpips",
+            "tqdm>4.29.0",
+            "matplotlib",
+            "accelerate",
+            "sqlalchemy>=2.0",
+        ],
+    },
+    entry_points={
+        "console_scripts": [
+            f"pytorch3d_implicitron_runner={trainer}.experiment:experiment",
+            f"pytorch3d_implicitron_visualizer={trainer}.visualize_reconstruction:main",
+        ]
+    },
+    ext_modules=get_extensions(),
+    cmdclass={"build_ext": BuildExtension},
+    package_data={
+        "": ["*.json"],
+    },
+)

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/utils/advanced_kinematics_solver.py

@@ -0,0 +1,277 @@
+from dataclasses import dataclass
+from typing import Dict, List, Sequence
+import numpy as np
+import sapien.core as sapien
+import warnings
+# from sapien import Articulation #for maniskill 2 only
+from mani_skill.utils.structs.articulation import Articulation #for maniskill 3 only
+
+@dataclass
+class CollisionSphere:
+    """Represents a collision sphere on a robot link."""
+    link_name: str
+    local_pose: sapien.Pose
+    radius: float
+class AdvancedKinematicsSolver:
+    """A wrapper class that extends basic kinematics to handle arbitrary points on robot links.
+    This class provides methods to:
+    1. Calculate kinematics for arbitrary points on links (not just link centers)
+    2. Compute Jacobians for these points
+    """
+    # def __init__(self, robot: sapien.Articulation) -> None:
+    def __init__(self, robot: Articulation) -> None:
+        self.robot = robot #be careful, when environment been reconfigured, this will become a null pointer...
+        self._collision_spheres: Dict[str, List[CollisionSphere]] = {}
+        self._link_name_to_id_map: Dict[str, int] = {}
+        self._kinematics_model = self.robot.create_pinocchio_model()
+
+        joint_names = [x.name for x in self.robot.get_active_joints()]
+        print("active joint names:", joint_names)
+        self.joint_indices = self.get_active_joint_indices(
+                self.robot, joint_names)
+        
+        self.qmask = np.zeros(self.robot.dof, dtype=bool)
+        self.qmask[self.joint_indices] = 1  
+            
+        # Initialize spheres and link id map
+        self._initialize_collision_spheres()
+        self._initialize_link_id_map()
+        # Store base transform for correction
+        self._base_transform = None
+        self._initialize_base_transform()
+
+        print("link name to id map:", self._link_name_to_id_map)
+        self.ee_link_idx = self._link_name_to_id_map["panda_hand"]
+    
+    def get_active_joint_indices(self,
+        articulation: Articulation, joint_names: Sequence[str]
+    ) -> List[int]:
+        all_joint_names = [x.name for x in articulation.get_active_joints()]
+        joint_indices = [all_joint_names.index(x) for x in joint_names]
+        return joint_indices
+    
+    def _initialize_collision_spheres(self) -> None:
+        """Initialize collision spheres from the robot model."""
+        for link in self.robot.get_links():
+            link_name = link.get_name()
+            if link_name == "panda_hand_tcp":
+                continue
+            self._collision_spheres[link_name] = []
+            print("link type:", type(link))
+            for collision in link.get_collision_shapes():
+                # geometry = collision.geometry
+                if isinstance(collision, sapien.pysapien.physx.PhysxCollisionShapeSphere ):
+                    radius = collision.get_radius()
+                    local_pose = collision.get_local_pose()
+                    self._collision_spheres[link_name].append(CollisionSphere(
+                        link_name, local_pose, radius))
+
+    def _initialize_base_transform(self) -> None:
+        """Initialize the base transform correction between Pinocchio and SAPIEN."""
+        # Get the base link pose from both systems
+        base_link = self.robot.get_links()[0]  # panda_link0
+        sapien_pose = base_link.pose
+        
+        # The base transform should align Pinocchio's panda_link0 with SAPIEN's panda_link0
+        # We need to:
+        # 1. Move the base link to the origin
+        # 2. Align the rotation with SAPIEN's base frame
+        self._base_transform = sapien.Pose(
+            p=np.array([0.0, 0.0, 0]),  # Move base link to origin
+            q=np.array([1.0, 0.0, 0.0, 0.0])  # Identity rotation
+        )
+
+    def _initialize_link_id_map(self) -> None:
+        """Initialize mapping between link names and their IDs."""
+        # Use the actual link IDs from the robot
+        for link in self.robot.get_links(): # THIS ID IS NOT FROM PINOCCHIO, IT IS FROM SAPIEN
+            link_name = link.get_name()
+            if link_name == "panda_hand_tcp":
+                continue
+            # Get the actual link ID from the robot
+            link_index = link.get_index() #get index in cpp library
+            self._link_name_to_id_map[link_name] = link_index
+            print(f"Mapping {link_name} to ID {link_index}")  # Debug print
+
+    def calculate_forward_kinematics(self, qpos: np.ndarray) -> None:
+        """Calculate forward kinematics for the robot, reseult will be cached in self._kinematics_model"""
+        """cpp library check link: https://github.com/haosulab/SAPIEN/blob/ab1d9a9fa1428484a918e61185ae9df2beb7cb30/include/sapien/articulation/pinocchio_model.h"""
+        self._kinematics_model.compute_forward_kinematics(qpos)
+    
+    def calculate_full_jacobian(self, qpos: np.ndarray) -> None:
+        """Calculate full jacobian for the robot, result will be cached in self._kinematics_model"""
+        """cpp library is same as calculate_forward_kinematics"""
+        """pybinding link: https://github.com/haosulab/SAPIEN/blob/ab1d9a9fa1428484a918e61185ae9df2beb7cb30/python/py_package/core/pysapien/__init__.pyi#L105 """
+        self._kinematics_model.compute_full_jacobian(qpos)
+    
+    def compute_ik(self, target_pose, initial_qpos, max_iterations=100):
+        # if initial_qpos is not None:
+        #     initial_qpos = np.array(initial_qpos)
+        # else:
+        #     initial_qpos = self.get_qpos()
+        # print("initial qpos: ", self.articulation.get_qpos())
+        # print("initial qpos type: ", type(self.articulation.get_qpos()))
+        # Assume the target pose is defined in the base frame
+        if isinstance(target_pose, np.ndarray):
+            if target_pose.shape == (7,):  # [x, y, z, qw, qx, qy, qz]
+                target_pose = sapien.Pose(p=target_pose[:3], q=target_pose[3:])
+            else:
+                raise ValueError(f"target_pose numpy shape should be (7,), got {target_pose.shape}")
+        elif not isinstance(target_pose, sapien.Pose):
+            raise TypeError("target_pose must be either numpy.ndarray or sapien.Pose")
+        
+        result, success, error = self._kinematics_model.compute_inverse_kinematics(
+            self.ee_link_idx,
+            target_pose,
+            initial_qpos=initial_qpos,
+            active_qmask=self.qmask,
+            max_iterations=max_iterations,
+        )
+        if success:
+            return result[self.joint_indices]
+        else:
+            return None
+
+    def calculate_all_sphere_poses(self, qpos: np.ndarray = None) -> Dict[str, List[np.ndarray]]:
+        """Get all sphere poses for all links"""
+        if qpos is not None:
+            self.calculate_forward_kinematics(qpos)
+        else:
+            warnings.warn("qpos is not provided, using last qpos in kinematics solver", UserWarning)
+        # 1. get all link poses
+        link_poses = self.get_all_link_pose()
+        # 2. get all sphere poses based on the link poses and local transform
+        sphere_poses: Dict[str, List[sapien.Pose]] = {} # link name, list of sphere poses
+        for link_name, spheres in self._collision_spheres.items():
+            link_pose = link_poses[link_name]
+            sphere_poses[link_name] = []
+            for sphere in spheres:
+                sphere_pose = link_pose * sphere.local_pose
+                sphere_poses[link_name].append(sphere_pose)
+        return sphere_poses
+    
+    def calculate_all_sphere_positions_and_radii(self, qpos: np.ndarray = None) -> Dict[str, List[np.ndarray]]:
+        """Get all sphere positions and radius for all links"""
+        if qpos is not None:
+            self.calculate_forward_kinematics(qpos)
+        else:
+            warnings.warn("qpos is not provided, using last qpos in kinematics solver", UserWarning)
+        # 1. get all link poses
+        link_poses = self.get_all_link_pose()
+        self._link_poses_debug = link_poses
+
+        # 2. get all sphere poses based on the link poses and local transform
+        sphere_poses: Dict[str, List[sapien.Pose]] = {} # link name, list of sphere poses
+        sphere_radii: Dict[str, List[float]] = {} # link name, list of sphere radii
+        for link_name, spheres in self._collision_spheres.items():
+            link_pose = link_poses[link_name]
+            sphere_poses[link_name] = []
+            sphere_radii[link_name] = []
+            for sphere in spheres:
+                sphere_pose = link_pose * sphere.local_pose
+                sphere_poses[link_name].append(sphere_pose.p)
+                sphere_radii[link_name].append(sphere.radius)
+        return sphere_poses, sphere_radii
+        
+    def get_all_link_pose(self) -> Dict[str, sapien.Pose]:
+        """Get all link poses for all links with base transform correction."""
+        link_poses = {}
+        for link_name, link_id in self._link_name_to_id_map.items():
+            # Get the raw pose from Pinocchio
+            raw_pose = self._kinematics_model.get_link_pose(link_id)
+            # Apply the base transform correction
+            corrected_pose = self._base_transform * raw_pose
+            link_poses[link_name] = corrected_pose
+        return link_poses
+    
+    def calculate_all_sphere_jacobian(self, qpos: np.ndarray = None) -> np.ndarray:
+        """Calculate jacobian of all spheres for all links"""
+        """⚠️ CRITICAL: sphere_poses MUST be generated using the same qpos as this function call to ensure correct Jacobian calculations"""
+        if qpos is not None:
+            self._kinematics_model.compute_full_jacobian(qpos)
+        else:
+            warnings.warn("qpos is not provided, using last qpos in kinematics solver", UserWarning)
+        
+        link_poses = self.get_all_link_pose()
+
+        sphere_jacobians: Dict[str, List[np.ndarray]] = {}
+        for link_name, spheres in self._collision_spheres.items():
+            link_id = self._link_name_to_id_map[link_name]
+            link_jacobian = self._kinematics_model.get_link_jacobian(link_id, local = False)
+            sphere_jacobians[link_name] = []
+            for sphere in spheres:
+                link_pose = link_poses[link_name]
+                sphere_jacobian = self._transform_jacobian_to_point(link_jacobian, link_pose, sphere.local_pose)
+                sphere_jacobians[link_name].append(sphere_jacobian)
+                # print("sphere_jacobian shape: ", sphere_jacobian.shape)
+        return sphere_jacobians
+            
+    def _transform_jacobian_to_point(self, link_jacobian: np.ndarray, link_pose: sapien.Pose, local_pose: sapien.Pose) -> np.ndarray:
+        """Transform link center Jacobian to a point offset from the link center.
+        Args:
+            link_jacobian: 6 x n_joints Jacobian at link center
+            link_pose: World pose of the link center
+            local_pose: Pose of the target point relative to the link center
+        Returns:
+            6 x n_joints Jacobian at the offset point
+        """
+        # Get rotation and translation from local pose
+        R = link_pose.to_transformation_matrix()[:3, :3] #rotation of the link origin to world frame
+        p_local = local_pose.p #position of the sphere in the link frame
+        
+        # Rotate the offset from local frame to world frame. 
+        # it is the offset from the link origin to the sphere in the world frame
+        p_world = R @ p_local
+        
+        # Create skew-symmetric matrix of the world offset
+        p_skew = np.array([
+            [0, -p_world[2], p_world[1]],
+            [p_world[2], 0, -p_world[0]],
+            [-p_world[1], p_world[0], 0]
+        ])
+        
+        # Build transformation matrix
+        transform = np.block([
+            [np.eye(3), np.zeros((3, 3))],
+            [-p_skew, np.eye(3)]
+        ])
+        
+        return transform @ link_jacobian
+
+    def print_link_info(self, qpos: np.ndarray = None) -> None:
+        """Print detailed information about all links in the robot model."""
+        if qpos is not None:
+            self.calculate_forward_kinematics(qpos)
+        
+        print("\n=== Robot Link Information ===")
+        print("Link ID to Name mapping:")
+        for link_name, link_id in self._link_name_to_id_map.items():
+            print(f"Link ID {link_id}: {link_name}")
+        
+        print("\nLink Poses (from Pinocchio):")
+        for link_name, link_id in self._link_name_to_id_map.items():
+            try:
+                pose = self._kinematics_model.get_link_pose(link_id)
+                print(f"\n{link_name} (ID: {link_id}):")
+                print(f"  Position: {pose.p}")
+                print(f"  Quaternion: {pose.q}")
+            except RuntimeError as e:
+                print(f"\nError getting pose for {link_name} (ID: {link_id}): {e}")
+            
+        print("\nLink Poses (from SAPIEN):")
+        for link in self.robot.get_links():
+            if link.get_name() == "panda_hand_tcp":
+                continue
+            pose = link.get_pose()
+            print(f"\n{link.get_name()}:")
+            print(f"  Position: {pose.p}")
+            print(f"  Quaternion: {pose.q}")
+
+    
+    
+
+
+
+
+
+

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/utils/plot_utils.py

@@ -0,0 +1,868 @@
+#plot trajectory
+import matplotlib.pyplot as plt
+import matplotlib as mpl
+import numpy as np
+from cfdp.utils.data_utils import transform_ortho6d_to_quat
+from cfdp.utils.angle_utils import quaternion_to_euler
+from typing import Dict, Any, Optional
+import torch
+from typing import Union, List
+from mpl_toolkits.mplot3d import Axes3D
+from mpl_toolkits.mplot3d.art3d import Line3DCollection  # Add this import at the top
+import os
+import time
+import math
+
+# TODO: should extract more abstract methods from visualizer...
+# such as fixed 3d scene with customized shape API
+class TrajectoryVisualizer:
+    def __init__(self, normalizer):
+        self.fig = None
+        self.ax = None
+        self.normalizer = normalizer
+        # trajectory normalizer
+        self.normalizer = normalizer.normalizers['traj']
+
+    def unnormalize_numpy(self, x, eps=1e-4):
+        '''
+        Numpy version of unnormalize function. Performs same operations as torch version.
+        Args:
+            x: numpy array in range [-1, 1]
+            eps: tolerance for clipping check
+        Returns:
+            unnormalized numpy array
+        '''
+        if np.max(x) > 1 + eps or np.min(x) < -1 - eps:
+            x = np.clip(x, -1, 1)
+
+        # [ -1, 1 ] --> [ 0, 1 ]
+        x = (x + 1) / 2.
+        
+        # Get mins and maxs from normalizer as numpy arrays
+        mins = self.normalizer.mins.cpu().numpy()
+        maxs = self.normalizer.maxs.cpu().numpy()
+        
+        # Scale to original range
+        return x * (maxs - mins) + mins
+
+    def plot_trajectory(self, 
+                    planned_paths: torch.Tensor,
+                    obs: Dict[str, Any],
+                    point_cloud: Optional[np.ndarray] = None,
+                    simplified_paths: torch.Tensor = None,
+                    robot_executed_path: Optional[np.ndarray] = None):
+        """Plot the planned trajectory in 3D space, colored by rank."""
+        if planned_paths is None:
+            return
+
+        self.fig = plt.figure(figsize=(8, 6))
+        self.ax = self.fig.add_subplot(111, projection='3d')
+
+        if planned_paths.dim() == 2:
+            planned_paths = planned_paths.unsqueeze(0)
+
+        B = planned_paths.shape[0]
+        current_tcp = obs['extra']['tcp_pose'][:3]
+        target_pos = obs['extra']['goal_pose'][:3]
+
+        # Use colormap for trajectory rank (0 = best, B-1 = worst)
+        colormap = plt.cm.get_cmap('viridis', B)
+        colors = colormap(np.linspace(0, 1, B))  # [B, 4] RGBA
+        sm = mpl.cm.ScalarMappable(cmap=colormap, norm=plt.Normalize(vmin=0, vmax=B-1))
+        self.fig.colorbar(sm, ax=self.ax, label='Trajectory Rank (0 = Best)')
+
+        for i, path in enumerate(planned_paths):
+            path = path.clone().cpu().numpy() if torch.is_tensor(path) else np.array(path)
+            tcp_points = path[:, :3]
+            color = colors[i]  # ranked color
+            self.ax.plot(tcp_points[:, 0], tcp_points[:, 1], tcp_points[:, 2], 
+                        color=color, linestyle='-', label=f'Rank {i}')
+            self.ax.scatter(tcp_points[:, 0], tcp_points[:, 1], tcp_points[:, 2], 
+                            color='black', marker='x', s=40, alpha=0.4)
+
+        self.ax.scatter(*current_tcp, color='g', marker='o', label='Current Position')
+        self.ax.scatter(*target_pos, color='r', marker='*', label='Target')
+
+        if point_cloud is not None:
+            self.ax.scatter(point_cloud[:, 0], point_cloud[:, 1], point_cloud[:, 2], 
+                            c='gray', alpha=0.3, s=1, label='Obstacles')
+    
+        if simplified_paths is not None:
+            simplified_paths = simplified_paths.clone().cpu().numpy() if torch.is_tensor(simplified_paths) else np.array(simplified_paths)
+            self.ax.plot(simplified_paths[:, 0], simplified_paths[:, 1], simplified_paths[:, 2],
+                color='purple', linestyle='-', linewidth=3.0, label='Simplified Path')
+
+        if robot_executed_path is not None and robot_executed_path.shape[0] > 0:
+            self.ax.plot(robot_executed_path[:, 0], robot_executed_path[:, 1], robot_executed_path[:, 2],
+                color='orange', linestyle='--', linewidth=3.0, label='Executed Path')
+
+        self.ax.set_xlabel('X')
+        self.ax.set_ylabel('Y')
+        self.ax.set_zlabel('Z')
+        self.ax.set_title('Planned Trajectories (Ranked)')
+        self.ax.legend()
+
+    def plot_joint_trajectory(self, joint_trajectories, title='Joint Trajectory', save_path=None):
+        """
+        Args:
+            joint_trajectories: numpy array or torch.Tensor of shape [N, length, joint_dim] where:
+                N: number of trajectories
+                length: number of points per trajectory
+                joint_dim: number of joint dimensions
+        """
+        # Convert to numpy if torch tensor
+        if hasattr(joint_trajectories, 'detach'):
+            joint_trajectories = joint_trajectories.detach().cpu().numpy()
+        else:
+            joint_trajectories = np.asarray(joint_trajectories)
+
+        N, length, joint_dim = joint_trajectories.shape
+        n_rows = 3
+        n_cols = math.ceil(joint_dim / n_rows)
+        fig, axes = plt.subplots(n_rows, n_cols, figsize=(6 * n_cols, 3 * n_rows), sharex=True)
+        axes = axes.flatten() if joint_dim > 1 else [axes]
+        time_steps = np.arange(length)
+
+        for j in range(joint_dim):
+            ax = axes[j]
+            ax.cla()  # Clear previous plot if reusing axes
+            for i in range(N):
+                ax.plot(time_steps, joint_trajectories[i, :, j], alpha=0.7)
+            ax.set_ylabel(f'Joint {j+1} Value')
+            ax.set_title(f'Joint {j+1}')
+            ax.grid(True)
+        axes[joint_dim-1].set_xlabel('Time Step')
+        fig.suptitle(title)
+        plt.tight_layout(rect=[0, 0, 1, 0.97])
+
+        if save_path is not None:
+            os.makedirs(os.path.dirname(save_path), exist_ok=True)
+            plt.savefig(save_path, dpi=300, bbox_inches='tight')
+            plt.close(fig)
+        else:
+            plt.draw()
+            plt.show()
+
+    def plot_path_with_guidance(self, diffusion_history, 
+                                guidance_history=None, 
+                                point_cloud=None, 
+                                save_path=None):
+        """Plot the diffusion path with guidance in 3D, showing dimensions 0, 1, and 2.
+        
+        Args:
+            diffusion_history: Dictionary containing the diffusion process history
+            guidance_history: Optional dictionary containing guidance history
+            save_path: Path where to save the plot. If None, will display plot instead
+        """
+        timesteps_to_plot = [-2, -1]  # Adjust these values as needed
+        n_plots = len(timesteps_to_plot)
+        fig = plt.figure(figsize=(6*n_plots, 6))
+
+        print("diffusion_history length: ", len(diffusion_history))
+        if guidance_history is not None:
+            print("guidance_history length: ", len(guidance_history))
+        
+        for idx, t in enumerate(timesteps_to_plot):
+            ax = fig.add_subplot(1, n_plots, idx+1, projection='3d')
+            history_t = diffusion_history[t]
+            
+            # Convert to numpy and reshape to (-1, 9)
+            x_t = history_t['x'].reshape(-1, 9)
+            noise_t = history_t['noise'].reshape(-1, 9)
+            
+            # Unnormalize the full 9D positions first
+            x_t = self.unnormalize_numpy(x_t)
+            noise_t = self.unnormalize_numpy(noise_t)
+            # Then extract first 3 dimensions
+            x_t = x_t[:, :3]
+            noise_t = noise_t[:, :3]  # Extract first 3 dims of noise
+            
+            # Plot diffusion positions in 3D
+            ax.scatter(x_t[:, 0], x_t[:, 1], x_t[:, 2],
+                      c='blue', alpha=0.5, label='Diffusion positions')
+            
+            # Plot diffusion directions using 3D quiver
+            # Scale the noise vectors to have appropriate lengths
+            scaled_noise = noise_t * 0.06  # Scale factor to make arrows visible
+            ax.quiver(x_t[:, 0], x_t[:, 1], x_t[:, 2],
+                     scaled_noise[:, 0], scaled_noise[:, 1], scaled_noise[:, 2],
+                     color='red', alpha=0.5, label='Diffusion direction',
+                     normalize=False)  # Don't normalize to preserve relative magnitudes
+            
+            # Plot guidance if available
+            if guidance_history is not None:
+                guidance_t = guidance_history[t]
+                # Convert and reshape full 9D data
+                g_x = guidance_t['x'].reshape(-1, 9)
+                g_noise = guidance_t['grad_scaled'].reshape(-1, 9)
+                
+                # Unnormalize full 9D guidance positions first
+                g_x = self.unnormalize_numpy(g_x)
+                # Then extract first 3 dimensions
+                g_x = g_x[:, :3]
+                g_noise = g_noise[:, :3]  # Extract first 3 dims of guidance
+                scaled_g_noise = g_noise * 1.0  # Scale factor to make arrows visible
+                
+                # Plot guidance positions and directions in 3D
+                ax.scatter(g_x[:, 0], g_x[:, 1], g_x[:, 2],
+                          c='green', alpha=0.5, label='Guidance positions')
+                ax.quiver(g_x[:, 0], g_x[:, 1], g_x[:, 2],
+                         scaled_g_noise[:, 0], scaled_g_noise[:, 1], scaled_g_noise[:, 2],
+                         color='orange', alpha=0.5, label='Guidance direction',
+                         normalize=False)  # Don't normalize to preserve relative magnitudes
+        
+            if point_cloud is not None:
+                ax.scatter(point_cloud[:, 0], point_cloud[:, 1], point_cloud[:, 2],
+                        c='gray', alpha=0.3, s=1, label='Obstacles')
+            
+            ax.set_title(f'Timestep {t}')
+            ax.set_xlabel('X')
+            ax.set_ylabel('Y')
+            ax.set_zlabel('Z')
+            ax.legend()
+            
+            # Optional: set consistent axis limits if needed
+            ax.set_xlim([0.0, 0.7])
+            ax.set_ylim([-0.5, 0.5])
+            ax.set_zlim([0.0, 0.5])
+            
+        plt.tight_layout()
+        
+        if save_path is not None:
+            # Create directory if it doesn't exist
+            os.makedirs(os.path.dirname(save_path), exist_ok=True)
+            # Generate a timestamp for the image name
+            timestamp = time.strftime("%Y%m%d_%H%M%S")
+            # Save the figure with the timestamp in the filename
+            plt.savefig(f"{os.path.splitext(save_path)[0]}_{timestamp}.png", dpi=300, bbox_inches='tight')
+        else:
+            plt.show()
+        # plt.show()
+        plt.close()
+    
+
+    def plot_trajectory_with_cost(self, sphere_trajectories, sdf_costs, 
+                                  spheres_after_guidance=None, sampled_spheres=None, point_cloud=None, sphere_idx=0, time_step=0):
+        """
+        Plot the trajectory of a single sphere (sphere_idx) for all batches, coloring by total cost at each timestep.
+        Args:
+            sphere_trajectories: [batch, seq_len, num_spheres, 3]
+            sdf_costs: [batch, seq_len, num_spheres]
+            spheres_after_guidance: [batch, seq_len, num_spheres, 3] or None
+            point_cloud: [N, 3] or None
+            sphere_idx: int, which sphere to plot
+        """
+        # Convert to numpy if torch tensor
+        if hasattr(sphere_trajectories, 'detach'):
+            sphere_trajectories = sphere_trajectories.detach().cpu().numpy()
+        if hasattr(sdf_costs, 'detach'):
+            sdf_costs = sdf_costs.detach().cpu().numpy()
+        if spheres_after_guidance is not None and hasattr(spheres_after_guidance, 'detach'):
+            spheres_after_guidance = spheres_after_guidance.detach().cpu().numpy()
+        if sampled_spheres is not None and hasattr(sampled_spheres, 'detach'):
+            sampled_spheres = sampled_spheres.detach().cpu().numpy()
+
+        batch, seq_len, num_spheres, _ = sphere_trajectories.shape
+
+        # Get the trajectory for the selected sphere across all batches
+        xyz = sphere_trajectories[:, :, sphere_idx, :]  # [batch, seq_len, 3]
+        # Get the total cost at each timestep for each batch
+        total_cost = sdf_costs.sum(axis=-1)  # [batch, seq_len]
+        # Get the total cost for each trajectory
+        trajectory_cost = total_cost.sum(axis=-1)  # [batch]
+
+        fig = plt.figure(figsize=(10, 8))
+        ax = fig.add_subplot(111, projection='3d')
+
+        # Normalize trajectory costs for colormap (for line color)
+        traj_norm = plt.Normalize(trajectory_cost.min(), trajectory_cost.max())
+        traj_cmap = plt.get_cmap('jet')
+
+        # Plot each batch as a separate trajectory
+        for b in range(batch):
+            # Color by total cost at each timestep (scatter)
+            p = ax.scatter(xyz[b, :, 0], xyz[b, :, 1], xyz[b, :, 2], 
+                            c=total_cost[b], cmap='jet', s=40, marker='o', 
+                            label='Before Guidance' if b == 0 else None)
+
+            # Line: color by total trajectory cost
+            line_color = traj_cmap(traj_norm(trajectory_cost[b]))
+            ax.plot(
+                xyz[b, :, 0], xyz[b, :, 1], xyz[b, :, 2],
+                color=line_color, linewidth=2, alpha=0.9,
+                label=f'Traj {b} (cost={trajectory_cost[b]:.2f})'
+            )
+
+            # Mark start and end
+            ax.scatter(xyz[b, 0, 0], xyz[b, 0, 1], xyz[b, 0, 2], color='green', s=80)
+            ax.scatter(xyz[b, -1, 0], xyz[b, -1, 1], xyz[b, -1, 2], color='red', s=80)
+
+            # Plot after guidance if provided
+            if spheres_after_guidance is not None:
+                xyz_after = spheres_after_guidance[:, :, sphere_idx, :]  # [batch, seq_len, 3]
+                ax.plot(xyz_after[b, :, 0], xyz_after[b, :, 1], xyz_after[b, :, 2], color='orange', alpha=0.7, linewidth=2, label='After Guidance' if b == 0 else None)
+                ax.scatter(xyz_after[b, :, 0], xyz_after[b, :, 1], xyz_after[b, :, 2], color='black', s=30)
+            
+            # if sampled_spheres is not None:
+            #     xyz_sampled = sampled_spheres[:, :, sphere_idx, :]  # [batch, seq_len, 3]
+            #     ax.scatter(xyz_sampled[b, :, 0], xyz_sampled[b, :, 1], xyz_sampled[b, :, 2], color='purple', s=5, alpha=0.5)
+        # Plot point cloud if available
+        if point_cloud is not None:
+            ax.scatter(point_cloud[:, 0], point_cloud[:, 1], point_cloud[:, 2], 
+                       c='gray', alpha=0.3, s=2, label='Obstacles')
+
+        fig.colorbar(p, ax=ax, label='Total SDF Cost (sum over spheres)')
+        ax.set_xlabel('X')
+        ax.set_ylabel('Y')
+        ax.set_zlabel('Z')
+        ax.set_title(f'Sphere index {sphere_idx} at time step {time_step} Trajectories (all batches) with Total SDF Cost')
+        ax.legend()
+        plt.tight_layout()
+        return fig
+    
+    def extract_diffusion_history(self, diffusion_history):
+        t = -1
+        history_t = diffusion_history[t]
+        print(history_t.keys())
+        # x_t = history_t['x'].reshape(-1, 4)
+
+        # return diffusion_history[0]['x'].detach().cpu().numpy()
+        return None
+    
+    def extract_guidance_history(self, guidance_history):
+        return None
+    
+    def plot_trajectories_list(self, trajectories_list, point_cloud=None, label_list=None):
+        """Plot multiple trajectories from a list.
+        Args:
+            trajectories_list: List of trajectory samples
+            point_cloud: Optional point cloud of obstacles
+        """
+        # Clear any existing figures to avoid accumulation
+        plt.close('all')
+        
+        # Create a new figure
+        fig = plt.figure(figsize=(10, 8))
+        ax = fig.add_subplot(111, projection='3d')
+        
+        colors = ['blue', 'orange', 'green', 'red']
+        # Create empty lists to store legend handles and labels
+        legend_handles = []
+        legend_labels = []
+
+        if label_list is not None:
+            if len(label_list) != len(trajectories_list):
+                raise ValueError(f"Length of label_list ({len(label_list)}) must equal length of trajectories_list ({len(trajectories_list)})")
+        
+        for i, all_samples in enumerate(trajectories_list):
+            # Unnormalize if the data is normalized
+            if torch.is_tensor(all_samples):
+                all_samples = all_samples.detach().cpu().numpy()
+                
+            # Use different colors for different trajectory sets
+            color = colors[i % len(colors)]
+            
+            # Plot the samples using the existing figure and axis
+            traj_line = self._plot_samples_xyz(all_samples, ax, color=color)
+            
+            # Add the trajectory line to legend handles
+            legend_handles.append(traj_line)
+            legend_labels.append(label_list[i])
+        
+        # Add start and end markers to legend
+        start_marker = ax.scatter([], [], color='green', s=30)
+        end_marker = ax.scatter([], [], color='red', s=30)
+        legend_handles.extend([start_marker, end_marker])
+        legend_labels.extend(['Start', 'End'])
+        
+        # Plot point cloud if available
+        if point_cloud is not None:
+            obstacles = ax.scatter(point_cloud[:, 0], point_cloud[:, 1], point_cloud[:, 2], 
+                                  c='gray', alpha=0.3, s=5)
+            legend_handles.append(obstacles)
+            legend_labels.append('Obstacles')
+        
+        # Set axis labels and add legend
+        ax.set_xlabel('X')
+        ax.set_ylabel('Y')
+        ax.set_zlabel('Z')
+        ax.set_title('Trajectory Comparison')
+        
+        # Set consistent axis limits
+        ax.set_xlim(0.1, 0.8)
+        ax.set_ylim(-0.5, 0.5)
+        ax.set_zlim(0.0, 0.4)
+        
+        # Add grid for better depth perception
+        ax.grid(True)
+        
+        # Adjust viewing angle for better visualization
+        # ax.view_init(elev=view_angle[0], azim=view_angle[1])
+        # ax.view_init(elev=30, azim=-60)  # Use matplotlib's default viewing angle
+        
+        # Add legend with custom handles and labels
+        ax.legend(legend_handles, legend_labels)
+        
+        plt.draw()
+        return fig
+
+    def _plot_samples_xyz(self, samples, ax, color='black', plot_waypoints=False):
+        """Plot the first 3 dimensions of each sample in a 3D plot.
+        
+        Args:
+            samples: Numpy array or tensor of shape [N, length, dim]
+            ax: Matplotlib axis to plot on
+            color: Color to use for plotting
+            
+        Returns:
+            Line artist for the first trajectory (for legend)
+        """
+        # Convert torch tensor to numpy if needed
+        if torch.is_tensor(samples):
+            samples = samples.detach().cpu().numpy()
+        
+        # Extract the xyz coordinates (first 3 dimensions)
+        xyz_samples = samples[:, :, :3]
+        
+        line_artist = None
+        # Plot each trajectory
+        for i in range(xyz_samples.shape[0]):
+            trajectory = xyz_samples[i]
+            line = ax.plot3D(trajectory[:, 0], trajectory[:, 1], trajectory[:, 2], color=color, alpha=0.5, linewidth=3.5)
+            if plot_waypoints:
+                ax.scatter(trajectory[:, 0], trajectory[:, 1], trajectory[:, 2], color='black', s=5, alpha = 0.3)
+            
+            # Store the first trajectory's line artist for legend
+            if i == 0:
+                line_artist = line[0]
+                
+            # Mark start and end points
+            ax.scatter(trajectory[0, 0], trajectory[0, 1], trajectory[0, 2], color='green', s=40)
+            ax.scatter(trajectory[-1, 0], trajectory[-1, 1], trajectory[-1, 2], color='red', s=40)
+        
+        return line_artist
+    
+    def _plot_samples_xy(self, samples, ax, color='black', plot_waypoints=False):
+        # Convert torch tensor to numpy if needed
+        if torch.is_tensor(samples):
+            samples = samples.detach().cpu().numpy()
+        
+        # Extract the xyz coordinates (first 3 dimensions)
+        xyz_samples = samples[:, :, :2]
+        
+        line_artist = None
+        # Plot each trajectory
+        for i in range(xyz_samples.shape[0]):
+            trajectory = xyz_samples[i]
+            # alpha_value = 0.2 + (0.4 * i / max(1, xyz_samples.shape[0] - 1))  # Scale from 0.2 to 0.6 based on i
+            # line = ax.plot(trajectory[:, 0], trajectory[:, 1], color=color, alpha=alpha_value, linewidth=3.5)
+            line = ax.plot(trajectory[:, 0], trajectory[:, 1], color=color, alpha=0.5, linewidth=3.5)
+            if plot_waypoints:
+                # Use a darker shade of the original color
+                darker_color = plt.cm.colors.to_rgba(color)
+                darker_color = [max(0, c * 0.7) for c in darker_color[:3]] + [darker_color[3]]
+                ax.scatter(trajectory[:, 0], trajectory[:, 1], color=darker_color, s=20, alpha = 0.4)
+            
+            # Store the first trajectory's line artist for legend
+            if i == 0:
+                line_artist = line[0]
+                
+            # Mark start and end points
+            ax.scatter(trajectory[0, 0], trajectory[0, 1], color='green', s=80)
+            ax.scatter(trajectory[-1, 0], trajectory[-1, 1], color='red', s=80)
+        
+        return line_artist
+
+    def plot_trajectories_dual_view(self, trajectories_list, 
+                                    point_cloud=None, 
+                                    label_list=None, 
+                                    color_list=None, 
+                                    title=['Left View', 'Right View'],
+                                    plot_2d=False,):
+        """Plot trajectories from two different viewing angles in a single figure.
+        
+        Args:
+            trajectories_list: List of trajectory samples
+            point_cloud: Optional point cloud of obstacles
+            label_list: Optional list of labels for the trajectories
+        
+        Returns:
+            matplotlib figure object
+        """
+        # Clear any existing figures
+        plt.close('all')
+        if color_list is None:
+            color_list = ['blue', 'orange', 'green', 'red']
+        
+        # Create a figure with two subplots
+        if not plot_2d:
+            # fig = plt.figure(figsize=(15, 6))
+            # # 3D plotting
+            # # Left view - side angle
+            # ax1 = fig.add_subplot(121, projection='3d')
+            # self._setup_trajectory_plot(ax1, trajectories_list, point_cloud, label_list, color_list, plot_2d)
+            # ax1.view_init(elev=90, azim=0)  # Left side view
+            # ax1.set_title(title[0], fontsize=20)
+            
+            # # Right view - different angle
+            # ax2 = fig.add_subplot(122, projection='3d')
+            # self._setup_trajectory_plot(ax2, trajectories_list, point_cloud, label_list, color_list, plot_2d)
+            # ax2.view_init(elev=5, azim=-20)  # Right side view
+            # ax2.set_title(title[1], fontsize=20)
+
+            fig = plt.figure(figsize=(10, 10))
+            # 3D plotting
+            # Right view - different angle
+            ax2 = fig.add_subplot(111, projection='3d')
+            self._setup_trajectory_plot(ax2, trajectories_list, point_cloud, label_list, color_list, plot_2d)
+            ax2.view_init(elev=10, azim=30)  # Right side view
+            # ax2.set_title(title[1], fontsize=20, pad=1)
+        else:
+            fig = plt.figure(figsize=(8, 8))
+            # 2D plotting - single view
+            ax1 = fig.add_subplot(111)
+            self._setup_trajectory_plot(ax1, trajectories_list, point_cloud, label_list, color_list, plot_2d)
+            # Split title into multiple lines if it's too long
+            if isinstance(title[0], str) and len(title[0]) > 30:
+                # Insert newline character every ~30 characters at space
+                words = title[0].split()
+                lines = []
+                current_line = []
+                current_length = 0
+                
+                for word in words:
+                    if current_length + len(word) > 30:
+                        lines.append(' '.join(current_line))
+                        current_line = [word]
+                        current_length = len(word)
+                    else:
+                        current_line.append(word)
+                        current_length += len(word) + 1  # +1 for space
+                
+                if current_line:
+                    lines.append(' '.join(current_line))
+                
+                formatted_title = '\n'.join(lines)
+                ax1.set_title(formatted_title, fontsize=28)
+            else:
+                ax1.set_title(title[0], fontsize=20)
+        
+        plt.tight_layout()
+        plt.draw()
+        return fig
+    
+    def _setup_trajectory_plot(self, ax, trajectories_list, point_cloud, label_list, color_list, plot_2d):
+        """Helper function to set up a trajectory plot on an axis.
+        
+        Args:
+            ax: Matplotlib 3D axis
+            trajectories_list: List of trajectory samples
+            point_cloud: Optional point cloud of obstacles
+            label_list: Optional list of labels for the trajectories
+        """
+        colors = color_list
+        # Create empty lists to store legend handles and labels
+        legend_handles = []
+        legend_labels = []
+
+        if label_list is not None:
+            if len(label_list) < len(trajectories_list):
+                raise ValueError(f"Length of label_list ({len(label_list)}) must equal or greater length of trajectories_list ({len(trajectories_list)})")
+        
+        for i, all_samples in enumerate(trajectories_list):
+            # Unnormalize if the data is normalized
+            if torch.is_tensor(all_samples):
+                all_samples = all_samples.detach().cpu().numpy()
+                
+            # Use different colors for different trajectory sets
+            color = colors[i % len(colors)]
+            
+            plot_waypoints = False
+            if label_list is not None and ('prior' in label_list[i] or ('guidance' in label_list[i] and i !=0)):
+                plot_waypoints = True
+                
+            # Check if we're plotting in 2D or 3D
+            if hasattr(ax, 'get_zlim'):  # 3D axis has get_zlim method
+                # Plot the samples using the existing figure and axis (3D)
+                traj_line = self._plot_samples_xyz(all_samples, ax, color=color, plot_waypoints=plot_waypoints)
+            else:
+                # Plot the samples in 2D (xy only)
+                traj_line = self._plot_samples_xy(all_samples, ax, color=color, plot_waypoints=plot_waypoints)
+            
+            # Add the trajectory line to legend handles
+            legend_handles.append(traj_line)
+            legend_labels.append(label_list[i] if label_list is not None else f"Trajectory {i+1}")
+        
+        # Add start and end markers to legend
+        start_marker = ax.scatter([], [], color='green', s=30)
+        end_marker = ax.scatter([], [], color='red', s=30)
+        legend_handles.extend([start_marker, end_marker])
+        legend_labels.extend(['Start', 'End'])
+        
+        # Plot point cloud if available
+        if point_cloud is not None:
+            if hasattr(ax, 'get_zlim'):  # 3D axis
+                obstacles = ax.scatter(point_cloud[:, 0], point_cloud[:, 1], point_cloud[:, 2], 
+                                      c='gray', alpha=0.3, s=2)
+            else:  # 2D axis - xy only
+                obstacles = ax.scatter(point_cloud[:, 0], point_cloud[:, 1], c='gray', alpha=0.3, s=2)
+            
+            legend_handles.append(obstacles)
+            legend_labels.append('Obstacles')
+        
+        # Set axis labels
+        if hasattr(ax, 'get_zlim'):  # 3D axis
+            ax.set_xlabel('X', fontsize=20)
+            ax.set_ylabel('Y', fontsize=20)
+            ax.set_zlabel('Z', fontsize=20)
+            
+            # Set consistent axis limits for 3D
+            ax.set_xlim(0.2, 0.6)
+            ax.set_ylim(-0.5, 0.5)
+            ax.set_zlim(0.0, 0.4)
+            # Increase tick size
+            ax.tick_params(axis='both', which='major', labelsize=14, width=2, length=6)
+            ax.legend(legend_handles, legend_labels, 
+                  bbox_to_anchor=(0.1, 0.8), loc='upper left', fontsize=14, prop={'size': 12})
+            
+        else:  # 2D axis - xy only
+            ax.set_xlabel('X', fontsize=20)
+            ax.set_ylabel('Y', fontsize=20)
+            ax.set_xlim(0.15, 0.75)
+            ax.set_ylim(-0.6, 0.6)
+            # Increase tick size
+            ax.tick_params(axis='both', which='major', labelsize=16, width=2, length=8)
+            ax.legend(legend_handles, legend_labels, 
+                  bbox_to_anchor=(0.3, 0.95), loc='upper center', fontsize=18, prop={'size': 18})
+        
+        # Add grid for better depth perception
+        ax.grid(False)
+        # Add legend with custom handles and labels
+        
+def create_trajectory_figure(trajectories, title='Trajectory'):
+    """Create a figure with trajectories showing both 3D position and euler angles.
+    Args:
+        trajectories: numpy array or torch.Tensor of shape [N * length * dim] where:
+            N: number of trajectories
+            length: number of points per trajectory
+            dim: dimensionality (7 for position+quaternion or 9 for position+rotation6d)
+    Returns:
+        matplotlib figure object
+    """
+    # # Convert torch tensor to numpy if needed
+    fig = plt.figure(figsize=(15, 10))
+    euler_labels = ['Roll', 'Pitch', 'Yaw']
+    
+    # Create 3D subplot for position - using a proper grid layout
+    ax_pos = fig.add_subplot(2, 3, (1, 3), projection='3d')  # Spans positions 1-3 in the top row
+    
+    # Add legend handles for trajectory colors
+    legend_handles = []
+    added_trajectory_to_legend = False
+    
+    # Create 3 subplots for euler angles
+    for i in range(3):
+        ax = fig.add_subplot(2, 3, i+4)  # Position them in the bottom row
+        
+        for traj_idx in range(trajectories.shape[0]):
+            if trajectories.shape[2] == 9:
+                trajectory = transform_ortho6d_to_quat(trajectories[traj_idx])
+            else:
+                trajectory = trajectories[traj_idx]
+            
+            if hasattr(trajectory, 'detach'):  # Check if it's a torch tensor
+                trajectory = trajectory.detach().cpu().numpy()
+            else:
+                trajectory = np.asarray(trajectory)
+            positions = trajectory[:, :3]
+            time_steps = np.arange(len(positions))
+            
+            color = 'black' if traj_idx == 0 else 'blue'
+            alpha = 1.0 if traj_idx == 0 else 0.2
+            
+            # Plot euler angles
+            euler_angles = np.array([quaternion_to_euler(q) for q in trajectory[:, 3:7]])
+            ax.plot(time_steps, np.rad2deg(euler_angles[:, i]), 
+                   color=color, alpha=alpha)
+            ax.set_xlabel('Time Step')
+            ax.set_ylabel(f'{euler_labels[i]} (degrees)')
+            ax.set_title(f'{euler_labels[i]} Angle')
+            ax.grid(True)
+            
+            # Plot 3D trajectory
+            line = ax_pos.plot3D(positions[:, 0], positions[:, 1], positions[:, 2],
+                         color=color, alpha=alpha)
+            
+            # Only add to legend once for reference and once for all other trajectories
+            if i == 0:
+                if traj_idx == 0:
+                    legend_handles.append((line[0], 'Reference'))
+                elif not added_trajectory_to_legend:
+                    legend_handles.append((line[0], 'Trajectories'))
+                    added_trajectory_to_legend = True
+            
+            # Add start/end markers for each trajectory
+            if i == 0:  # Only add markers once per trajectory
+                start = ax_pos.scatter(positions[0, 0], positions[0, 1], positions[0, 2],
+                             color='green', s=50)
+                end = ax_pos.scatter(positions[-1, 0], positions[-1, 1], positions[-1, 2],
+                             color='red', s=50)
+                
+                # Only add start/end to legend on the first trajectory
+                if traj_idx == 0:
+                    legend_handles.append((start, 'Start'))
+                    legend_handles.append((end, 'End'))
+    
+    ax_pos.set_xlabel('X Position')
+    ax_pos.set_ylabel('Y Position')
+    ax_pos.set_zlabel('Z Position')
+    ax_pos.set_title('3D Position Trajectory')
+    ax_pos.set_xlim(-1, 1)
+    ax_pos.set_ylim(-1, 1)
+    ax_pos.set_zlim(-1, 1)
+    
+    # Add the legend with all handles
+    ax_pos.legend(*zip(*legend_handles))
+    
+    plt.suptitle(title)
+    plt.tight_layout()
+    return fig
+
+def plot_trajectories(trajectories, title='Trajectory', save_path=None):
+    """Plot trajectories in 3D space.
+    Args:
+        trajectories: numpy array of shape [N * length * dim] where:
+            N: number of trajectories
+            length: number of points per trajectory
+            dim: dimensionality (3 for 3D space)
+    """
+    fig = create_trajectory_figure(trajectories, title)
+    if save_path is not None:
+        # Create directory if it doesn't exist
+        os.makedirs(os.path.dirname(save_path), exist_ok=True)
+        # Generate a timestamp for the image name
+        timestamp = time.strftime("%Y%m%d_%H%M%S")
+        # Save the figure with the timestamp in the filename
+        plt.savefig(f"{os.path.splitext(save_path)[0]}_{timestamp}.png", dpi=300, bbox_inches='tight')
+    else:
+        plt.show()
+    plt.close()
+
+
+# def create_joint_trajectory_figure(joint_trajectories, title='Joint Trajectory'):
+#     """
+#     Args:
+#         joint_trajectories: numpy array or torch.Tensor of shape [N, length, joint_dim] where:
+#             N: number of trajectories
+#             length: number of points per trajectory
+#             joint_dim: number of joint dimensions
+#     Returns:
+#         matplotlib figure object
+#     """
+#     # Convert to numpy if torch tensor
+#     if hasattr(joint_trajectories, 'detach'):
+#         joint_trajectories = joint_trajectories.detach().cpu().numpy()
+#     else:
+#         joint_trajectories = np.asarray(joint_trajectories)
+
+#     N, length, joint_dim = joint_trajectories.shape
+#     fig, axes = plt.subplots(joint_dim, 1, figsize=(8, 3 * joint_dim), sharex=True)
+#     if joint_dim == 1:
+#         axes = [axes]
+#     time_steps = np.arange(length)
+
+#     for j in range(joint_dim):
+#         ax = axes[j]
+#         for i in range(N):
+#             ax.plot(time_steps, joint_trajectories[i, :, j], alpha=0.7)
+#         ax.set_ylabel(f'Joint {j+1} Value')
+#         ax.set_title(f'Joint {j+1}')
+#         ax.grid(True)
+#     axes[-1].set_xlabel('Time Step')
+#     fig.suptitle(title)
+#     plt.tight_layout(rect=[0, 0, 1, 0.97])
+#     return fig
+
+# def plot_joint_trajectory(joint_trajectories, title='Joint Trajectory', save_path=None):
+#     """
+#     Args:
+#         joint_trajectories: numpy array of shape [N * length * dim] where:
+#             N: number of trajectories
+#             length: number of points per trajectory
+#             dim: dimensionality (joint dimensions)
+#     """
+#     fig = create_trajectory_figure(joint_trajectories, title)
+#     if save_path is not None:
+#         os.makedirs(os.path.dirname(save_path), exist_ok=True)
+#         plt.savefig(save_path, dpi=300, bbox_inches='tight')
+#     else:
+#         plt.show()
+#     plt.close()
+
+def visualize_point_cloud(points, colors, camera_type=""):
+    """
+    Visualize a point cloud using matplotlib.
+    
+    Args:
+        points (np.ndarray): Point cloud coordinates of shape (N, 3)
+        colors (np.ndarray): RGB colors for each point of shape (N, 3)
+        camera_type (str): Name of the camera view (optional)
+    """
+    # Create 3D scatter plot
+    fig = plt.figure(figsize=(10, 10))
+    ax = fig.add_subplot(111, projection='3d')
+    
+    # Plot points with their colors
+    scatter = ax.scatter(points[:, 0], points[:, 1], points[:, 2],
+                        c=colors,  # Use RGB colors
+                        s=1)  # Point size
+    
+    # Set labels and title
+    ax.set_xlabel('X')
+    ax.set_ylabel('Y')
+    ax.set_zlabel('Z')
+    ax.set_title(f'Point Cloud{" - " + camera_type if camera_type else ""}')
+    
+    # Adjust the view
+    ax.view_init(elev=30, azim=45)
+    
+    plt.show()
+
+def visualize_rgbd_and_pointcloud(rgb, depth, points, colors, camera_type=""):
+    """
+    Visualize RGB image, depth image, and point cloud in a single figure.
+    
+    Args:
+        rgb (np.ndarray): RGB image of shape (H, W, 3)
+        depth (np.ndarray): Depth image of shape (H, W)
+        points (np.ndarray): Point cloud coordinates of shape (N, 3)
+        colors (np.ndarray): RGB colors for each point of shape (N, 3)
+        camera_type (str): Name of the camera view (optional)
+    """
+    fig = plt.figure(figsize=(15, 5))
+    
+    # RGB image
+    ax1 = fig.add_subplot(131)
+    ax1.imshow(rgb)
+    ax1.set_title(f'RGB Image - {camera_type}')
+    ax1.axis('off')
+    
+    # Depth image
+    ax2 = fig.add_subplot(132)
+    depth_vis = ax2.imshow(depth, cmap='viridis')
+    ax2.set_title(f'Depth Image - {camera_type}')
+    ax2.axis('off')
+    plt.colorbar(depth_vis, ax=ax2)
+    
+    # Point cloud
+    ax3 = fig.add_subplot(133, projection='3d')
+    ax3.scatter(points[:, 0], points[:, 1], points[:, 2],
+                c=colors, s=1)
+    ax3.set_title(f'Point Cloud - {camera_type}')
+    ax3.set_xlabel('X')
+    ax3.set_ylabel('Y')
+    ax3.set_zlabel('Z')
+    ax3.view_init(elev=30, azim=45)
+    
+    plt.tight_layout()
+    plt.show()

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/utils/pointcloud_utils.py

@@ -0,0 +1,327 @@
+import numpy as np
+import open3d as o3d
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+from franka_robot_wrapper.camera_calibration import calibrate_external, computeT
+
+class CameraInfo():
+    """ 
+    Camera intrinsics for point cloud creation.
+    
+    Attributes:
+        width (int): The width of the camera image.
+        height (int): The height of the camera image.
+        fx (float): The focal length of the camera in the x direction.
+        fy (float): The focal length of the camera in the y direction.
+        cx (float): The optical center of the camera in the x direction.
+        cy (float): The optical center of the camera in the y direction.
+        scale (float): The scale factor for depth values.
+    """
+    def __init__(self, width, height, fx, fy, cx, cy, scale):
+        self.width = width
+        self.height = height
+        self.fx = fx
+        self.fy = fy
+        self.cx = cx
+        self.cy = cy
+        self.scale = scale
+
+def create_point_cloud_from_depth_image(depth, camera, organized=True):
+    """ Generate point cloud using depth image only.
+
+        Input:
+            depth: [numpy.ndarray, (H,W), numpy.float32]
+                depth image
+            camera: [CameraInfo]
+                camera intrinsics
+            organized: bool
+                whether to keep the cloud in image shape (H,W,3)
+
+        Output:
+            cloud: [numpy.ndarray, (H,W,3)/(H*W,3), numpy.float32]
+                generated cloud, (H,W,3) for organized=True, (H*W,3) for organized=False
+    """
+    assert(depth.shape[0] == camera.height and depth.shape[1] == camera.width)
+    xmap = np.arange(camera.width)
+    ymap = np.arange(camera.height)
+    xmap, ymap = np.meshgrid(xmap, ymap)
+    points_z = depth / camera.scale
+    points_x = (xmap - camera.cx) * points_z / camera.fx
+    points_y = (ymap - camera.cy) * points_z / camera.fy
+    cloud = np.stack([points_x, points_y, points_z], axis=-1)
+    if not organized:
+        cloud = cloud.reshape([-1, 3])
+    return cloud
+
+def visualize_point_cloud(points, colors, camera_type=""):
+    """
+    Visualize a point cloud using matplotlib.
+    
+    Args:
+        points (np.ndarray): Point cloud coordinates of shape (N, 3)
+        colors (np.ndarray): RGB colors for each point of shape (N, 3)
+        camera_type (str): Name of the camera view (optional)
+    """
+    # Create 3D scatter plot
+    fig = plt.figure(figsize=(10, 10))
+    ax = fig.add_subplot(111, projection='3d')
+    
+    # Plot points with their colors
+    scatter = ax.scatter(points[:, 0], points[:, 1], points[:, 2],
+                        c=colors,  # Use RGB colors
+                        s=1)  # Point size
+    
+    # Set labels and title
+    ax.set_xlabel('X')
+    ax.set_ylabel('Y')
+    ax.set_zlabel('Z')
+    ax.set_title(f'Point Cloud{" - " + camera_type if camera_type else ""}')
+    
+    # Adjust the view
+    ax.view_init(elev=30, azim=45)
+    
+    plt.show()
+
+def visualize_rgbd_and_pointcloud(rgb, depth, points, colors, camera_type=""):
+    """
+    Visualize RGB image, depth image, and point cloud in a single figure.
+    
+    Args:
+        rgb (np.ndarray): RGB image of shape (H, W, 3)
+        depth (np.ndarray): Depth image of shape (H, W)
+        points (np.ndarray): Point cloud coordinates of shape (N, 3)
+        colors (np.ndarray): RGB colors for each point of shape (N, 3)
+        camera_type (str): Name of the camera view (optional)
+    """
+    fig = plt.figure(figsize=(15, 5))
+    
+    # RGB image
+    ax1 = fig.add_subplot(131)
+    ax1.imshow(rgb)
+    ax1.set_title(f'RGB Image - {camera_type}')
+    ax1.axis('off')
+    
+    # Depth image
+    ax2 = fig.add_subplot(132)
+    depth_vis = ax2.imshow(depth, cmap='viridis')
+    ax2.set_title(f'Depth Image - {camera_type}')
+    ax2.axis('off')
+    plt.colorbar(depth_vis, ax=ax2)
+    
+    # Point cloud
+    ax3 = fig.add_subplot(133, projection='3d')
+    ax3.scatter(points[:, 0], points[:, 1], points[:, 2],
+                c=colors, s=1)
+    ax3.set_title(f'Point Cloud - {camera_type}')
+    ax3.set_xlabel('X')
+    ax3.set_ylabel('Y')
+    ax3.set_zlabel('Z')
+    ax3.view_init(elev=30, azim=45)
+    
+    plt.tight_layout()
+    plt.show()
+
+def convertRGBD2PCD(obs, n=5000, vis=False):
+    """
+    Convert RGB-D images to point cloud data for each camera.
+
+    This function:
+    1. Takes RGB and depth images from trajectory data
+    2. Converts them to 3D point clouds using camera parameters
+    3. Filters points based on depth thresholds
+    4. Samples n points from the cloud (with replacement if needed)
+    5. Stores color information for each point
+    6. Removes original image data to save memory
+
+    Args:
+        traj_data (dict): Trajectory data containing RGB-D images and camera parameters
+        n (int, optional): Number of points to sample from each point cloud. Defaults to 1000.
+        vis (bool, optional): Visualization flag (unused). Defaults to False.
+
+    Returns:
+        dict: Updated trajectory data with point clouds instead of images
+    """
+    obs_pointcloud = {'base_camera': None, 'hand_camera': None}
+    for camera_type in obs_pointcloud.keys():
+        pcd = []
+        # Do not use the last observation, following ManiSkill2 implementation
+        rgb = obs['image'][camera_type]['Color'][:,:,:3]
+        depth = obs['image'][camera_type]['Position'][:,:,3]
+        K = obs['camera_param'][camera_type]['intrinsic_cv']
+        fx, fy = K[0,0], K[1,1]
+        ppx, ppy = K[0,2], K[1,2]
+        
+        # TODO: Do not hardcode these values
+        width = 128
+        height = 128
+        factor_depth = 1000
+        camera = CameraInfo(width, height, fx, fy, ppx, ppy, factor_depth)
+
+        # Obtain masked cloud and color data for point cloud creation.
+        color = np.array(rgb, dtype=np.float32) / 255.0
+        cloud = create_point_cloud_from_depth_image(depth, camera, organized=True)
+        shape = color[:,:,0].shape
+        # mask = np.zeros(shape) # Creating Workspace Mask
+        # mask = mask.astype(bool)
+        # mask = ((depth > 0) & (depth < 1400)) # TODO: Do not hardcode this depth value. Somehow figure out how to do it with robot location.
+        
+        mask = np.ones(shape)
+        mask = mask.astype(bool)
+        cloud_masked = cloud[mask]
+        color_masked = color[mask]
+
+        # Sample n points from the point cloud, with replacement if needed
+        if len(cloud_masked) >= n:
+                idxs = np.random.choice(len(cloud_masked), n, replace=False)
+        else:
+            idxs1 = np.arange(len(cloud_masked))
+            idxs2 = np.random.choice(len(cloud_masked), n-len(cloud_masked), replace=True)
+            idxs = np.concatenate([idxs1, idxs2], axis=0)
+        cloud_sampled = cloud_masked[idxs]
+        color_sampled = color_masked[idxs]
+
+        if vis:  # Visualize RGB, depth, and point cloud if requested
+            visualize_rgbd_and_pointcloud(rgb, depth, cloud_sampled, color_sampled, camera_type)
+            
+        obs_pointcloud[camera_type] = np.array(cloud_sampled)
+
+    return obs_pointcloud
+
+
+########################################################
+# Real-Robot Stuff
+def visualize_cloud_with_axes(cloud_sampled):
+    """
+    Visualize a point cloud using Open3D and plot the coordinate axes.
+
+    Args:
+        cloud_sampled: A numpy array of shape (N, 3) containing 3D points to visualize
+
+    This function creates an Open3D point cloud object from the input points,
+    adds a coordinate frame (axes), and displays them in an interactive 3D viewer.
+    """
+    cloud = o3d.geometry.PointCloud()
+    cloud.points = o3d.utility.Vector3dVector(cloud_sampled)
+    # Create a coordinate frame at the origin with size 0.1 (can adjust as needed)
+    axis = o3d.geometry.TriangleMesh.create_coordinate_frame(size=0.1, origin=[0, 0, 0])
+    o3d.visualization.draw_geometries([cloud, axis])
+
+def visualize_cloud(cloud_sampled):
+    """
+    Visualize a point cloud using Open3D.
+    
+    Args:
+        cloud_sampled: A numpy array of shape (N, 3) containing 3D points to visualize
+    
+    This function creates an Open3D point cloud object from the input points
+    and displays it in an interactive 3D viewer.
+    """
+    cloud = o3d.geometry.PointCloud()
+    cloud.points = o3d.utility.Vector3dVector(cloud_sampled)
+    # cloud.colors = o3d.utility.Vector3dVector(color_sampled)
+    o3d.visualization.draw_geometries([cloud])
+
+def get_and_process_data_cam(rs, n = 20000, visualize = False):
+    """
+    Process data from a RealSense camera to create a point cloud.
+    
+    Args:
+        rs: RealSense camera object with get_intrinsics() and get_rgbd() methods
+        n (int): Number of points to sample from the point cloud (default: 20000)
+        visualize (bool): Whether to visualize the resulting point cloud (default: False)
+        
+    Returns:
+        np.ndarray: A sampled point cloud as a numpy array of shape (n, 3)
+    
+    This function:
+    1. Gets camera intrinsics from the RealSense camera
+    2. Captures RGBD data from the camera
+    3. Creates a point cloud from the depth image
+    4. Applies a depth mask to filter out invalid or distant points
+    5. Samples n points from the masked point cloud
+    6. Optionally visualizes the resulting point cloud
+    """
+    fx = rs.get_intrinsics()[0].fx
+    fy = rs.get_intrinsics()[0].fy
+    ppx = rs.get_intrinsics()[0].ppx
+    ppy = rs.get_intrinsics()[0].ppy
+    width = rs.get_intrinsics()[0].width
+    height = rs.get_intrinsics()[0].height
+    factor_depth = 1000
+
+    # load data
+    img = rs.get_rgbd()
+    # Image.fromarray(np.array(img[0][:,:,:3], dtype=np.uint8)).save("your_file.jpeg")
+    color = np.array(img[0][:,:,:3], dtype=np.float32) / 255.0 
+    depth = np.array(img[0][:,:,3]) 
+    # workspace_mask = np.array(Image.open(os.path.join(data_dir, 'workspace_mask.png'))) #(720, 1280) # True/False -- Choose where to segment
+    # generate cloud
+    # intrinsic[0][0] = fx, intrinsic[1][1] = fy, intrinsic[0][2] = ppx = cx, intrinsic[1][2] = ppy = cy
+    camera = CameraInfo(width, height, fx, fy, ppx, ppy, factor_depth)
+    cloud = create_point_cloud_from_depth_image(depth, camera, organized=True)
+
+    # Creating Workspace Mask
+    # shape = color[:,:,0].shape
+    # mask = np.ones(shape)
+    # mask = mask.astype(bool)
+    # get valid points
+    mask = ((depth > 1) & (depth < 2500)) # TODO: Do not hardcode this depth value. Somehow figure out how to do it with robot location.
+    cloud_masked = cloud[mask]
+    color_masked = color[mask]
+    
+
+    # sample points
+    if len(cloud_masked) >= n:
+        idxs = np.random.choice(len(cloud_masked), n, replace=False)
+    else:
+        idxs1 = np.arange(len(cloud_masked))
+        idxs2 = np.random.choice(len(cloud_masked), n-len(cloud_masked), replace=True)
+        idxs = np.concatenate([idxs1, idxs2], axis=0)
+    cloud_sampled = cloud_masked[idxs]
+    color_sampled = color_masked[idxs]
+    cloud_sampled = cloud_sampled.astype(np.float32)
+    color_sampled = color_sampled.astype(np.float32)
+
+    if visualize:
+        visualize_cloud(cloud_sampled)
+
+    return cloud_sampled
+
+def get_point_clouds(rs_list, n=20000, visualize=False):
+    """
+    Get point clouds from multiple RealSense cameras.
+    
+    Args:
+        rs_list: A list of RealsenseAPI() objects, each one corresponds to one RealSense camera
+        n: Number of points to sample from each point cloud (default: 20000)
+        visualize: Whether to visualize the point clouds (default: False)
+        
+    Returns:
+        clouds: A list of numpy arrays, each with shape (N, 3) representing a point cloud
+               from one of the cameras
+    """
+    clouds = []
+    for rs in rs_list:
+        clouds.append(get_and_process_data_cam(rs, n, visualize))
+    return clouds  # a list of (N, 3) numpy array
+
+def get_pcd_obs(rs_list, calibration_list, ee_pose):
+    clouds_list = get_point_clouds(rs_list, n=10000, visualize=False)
+
+    transformed_point_clouds = []
+    for cloud, calib in zip(clouds_list, calibration_list):
+        point_cloud_xyz = np.concatenate([cloud, np.ones((cloud.shape[0], 1))], axis=1)  # (N, 4)
+        if type(calib) is tuple:
+            ee_T_cam = calib[0]
+            r_T_ee, _ = computeT(ee_pose)
+            current_point_cloud = r_T_ee @ ee_T_cam @ point_cloud_xyz.T
+        else:
+            current_point_cloud = calib @ point_cloud_xyz.T
+        current_point_cloud = current_point_cloud.T[:, :3]
+        transformed_point_clouds.append(current_point_cloud)
+    # Merge all transformed point clouds into a single array
+    if len(transformed_point_clouds) > 0:
+        merged_cloud = np.vstack(transformed_point_clouds)
+    else:
+        merged_cloud = np.empty((0, 3))
+    return merged_cloud