Add files using upload-large-folder tool

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/.github/CODE_OF_CONDUCT.md

@@ -0,0 +1,76 @@
+# Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to make participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+  advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies within all project spaces, and it also applies when
+an individual is representing the project or its community in public spaces.
+Examples of representing a project or community include using an official
+project e-mail address, posting via an official social media account, or acting
+as an appointed representative at an online or offline event. Representation of
+a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at <opensource-conduct@fb.com>. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/.github/CONTRIBUTING.md

@@ -0,0 +1,53 @@
+# Contributing to PyTorch3D
+We want to make contributing to this project as easy and transparent as
+possible.
+
+## Pull Requests
+We actively welcome your pull requests.
+
+However, if you're adding any significant features, please make sure to have a corresponding issue to outline your proposal and motivation and allow time for us to give feedback, *before* you send a PR.
+We do not always accept new features, and we take the following factors into consideration:
+
+- Whether the same feature can be achieved without modifying PyTorch3D directly. If any aspect of the API is not extensible, please highlight this in an issue so we can work on making this more extensible.
+- Whether the feature is potentially useful to a large audience, or only to a small portion of users.
+- Whether the proposed solution has a good design and interface.
+- Whether the proposed solution adds extra mental/practical overhead to users who don't need such feature.
+- Whether the proposed solution breaks existing APIs.
+
+When sending a PR, please ensure you complete the following steps:
+
+1. Fork the repo and create your branch from `main`. Follow the instructions
+   in [INSTALL.md](../INSTALL.md) to build the repo.
+2. If you've added code that should be tested, add tests.
+3. If you've changed any APIs, please update the documentation.
+4. Ensure the test suite passes, by running this from the project root:
+    ```
+    python -m unittest discover -v -s tests -t .
+    ```
+5. Make sure your code lints by running `dev/linter.sh` from  the project root.
+6. If a PR contains multiple orthogonal changes, split it into multiple separate PRs.
+7. If you haven't already, complete the Contributor License Agreement ("CLA").
+
+## Contributor License Agreement ("CLA")
+In order to accept your pull request, we need you to submit a CLA. You only need
+to do this once to work on any of Facebook's open source projects.
+
+Complete your CLA here: <https://code.facebook.com/cla>
+
+## Issues
+We use GitHub issues to track public bugs. Please ensure your description is
+clear and has sufficient instructions to be able to reproduce the issue.
+
+Facebook has a [bounty program](https://www.facebook.com/whitehat/) for the safe
+disclosure of security bugs. In those cases, please go through the process
+outlined on that page and do not file a public issue.
+
+## Coding Style
+We follow these [python](http://google.github.io/styleguide/pyguide.html) and [C++](https://google.github.io/styleguide/cppguide.html) style guides.
+
+For the linter to work, you will need to install `black`, `flake`, `usort` and `clang-format`, and
+they need to be fairly up to date.
+
+## License
+By contributing to PyTorch3D, you agree that your contributions will be licensed
+under the LICENSE file in the root directory of this source tree.

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/.github/ISSUE_TEMPLATE/bugs.md

@@ -0,0 +1,30 @@
+---
+name: "🐛 Bugs / Unexpected behaviors"
+about: Please report unexpected behaviors or bugs in PyTorch3D.
+
+---
+
+If you do not know the root cause of the problem / bug, and wish someone to help you, please
+post according to this template:
+
+## 🐛 Bugs / Unexpected behaviors
+<!-- A clear and concise description of the issue -->
+
+NOTE: Please look at the existing list of Issues tagged with the label ['bug`](https://github.com/facebookresearch/pytorch3d/issues?q=label%3Abug). **Only open a new issue if this bug has not already been reported. If an issue already exists, please comment there instead.**.
+
+## Instructions To Reproduce the Issue:
+
+Please include the following (depending on what the issue is):
+
+1. Any changes you made (`git diff`) or code you wrote
+```
+<put diff or code here>
+```
+2. The exact command(s) you ran:
+3. What you observed (including the full logs):
+```
+<put logs here>
+```
+
+Please also simplify the steps as much as possible so they do not require additional resources to
+   run, such as a private dataset.

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,21 @@
+---
+name: "\U0001F680 Feature Request"
+about: Submit a proposal/request for a new PyTorch3D feature
+
+---
+
+## 🚀 Feature
+<!-- A clear and concise description of the feature proposal -->
+
+NOTE: Please look at the existing list of Issues tagged with the label ['enhancement`](https://github.com/facebookresearch/pytorch3d/issues?q=label%3Aenhancement). **Only open a new issue if you do not see your feature request there**.
+
+## Motivation
+
+<!-- Please outline the motivation for the proposal.
+e.g. It would be great if I could do [...], I'm always frustrated when [...]. If this is related to another GitHub issue, please link here too -->
+
+## Pitch
+
+<!-- A clear and concise description, optionally with code examples showing the functionality you want. -->
+
+NOTE: we only consider adding new features if they are useful for many users.

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/.github/ISSUE_TEMPLATE/questions-help.md

@@ -0,0 +1,21 @@
+---
+name: "❓ Questions"
+about: How do I do X with PyTorch3D? How does PyTorch3D do X?
+
+---
+
+## ❓ Questions on how to use PyTorch3D
+
+<!-- A clear and concise description of the question you need help with. -->
+
+
+NOTE: Please look at the existing list of Issues tagged with the label ['question`](https://github.com/facebookresearch/pytorch3d/issues?q=label%3Aquestion) or ['how-to`](https://github.com/facebookresearch/pytorch3d/issues?q=label%3A%22how+to%22). **Only open a new issue if you cannot find an answer there**.
+
+Also note the following:
+
+1. If you encountered any errors or unexpected issues while using PyTorch3D and need help resolving them,
+   please use the "Bugs / Unexpected behaviors" issue template.
+
+2. We do not answer general machine learning / computer vision questions that are not specific to
+   PyTorch3D, such as how a model works or what algorithm/methods can be
+   used to achieve X.

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/.github/workflows/build.yml

@@ -0,0 +1,23 @@
+name: facebookresearch/pytorch3d/build_and_test
+on:
+  pull_request:
+    branches:
+      - main
+  push:
+    branches:
+      - main
+jobs:
+  binary_linux_conda_cuda:
+    runs-on: 4-core-ubuntu-gpu-t4
+    env:
+      PYTHON_VERSION: "3.12"
+      BUILD_VERSION: "${{ github.run_number }}"
+      PYTORCH_VERSION: "2.4.1"
+      CU_VERSION: "cu121"
+      JUST_TESTRUN: 1
+    steps:
+    - uses: actions/checkout@v4
+    - name: Build and run tests
+      run: |-
+        conda create --name env --yes --quiet conda-build
+        conda run --no-capture-output --name env python3 ./packaging/build_conda.py --use-conda-cuda

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/dev/linter.sh

@@ -0,0 +1,40 @@
+#!/bin/bash -e
+# 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.
+
+# Run this script at project root by "./dev/linter.sh" before you commit
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+DIR=$(dirname "${DIR}")
+
+if [[ -f "${DIR}/BUCK" ]]
+then
+  pyfmt "${DIR}"
+else
+# run usort externally only
+  echo "Running usort..."
+  usort  "${DIR}"
+fi
+
+echo "Running black..."
+black "${DIR}"
+
+echo "Running flake..."
+flake8 "${DIR}" || true
+
+echo "Running clang-format ..."
+clangformat=$(command -v clang-format-8 || echo clang-format)
+find "${DIR}" -regex ".*\.\(cpp\|c\|cc\|cu\|cuh\|cxx\|h\|hh\|hpp\|hxx\|tcc\|mm\|m\)" -print0 | xargs -0 "${clangformat}" -i
+
+# Run arc and pyre internally only.
+if [[ -f "${DIR}/TARGETS" ]]
+then
+  (cd "${DIR}"; command -v arc > /dev/null && arc lint) || true
+
+  echo "Running pyre..."
+  echo "To restart/kill pyre server, run 'pyre restart' or 'pyre kill' in fbcode/"
+  ( cd ~/fbsource/fbcode; arc pyre check //vision/fair/pytorch3d/... )
+fi

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/dev/run_tutorials.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/bash
+# 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.
+
+# This script is for running some of the tutorials using the nightly build in
+# an isolated environment. It is designed to be run in docker.
+
+# If you run this script in this directory with
+#   sudo docker run --runtime=nvidia -it --rm -v $PWD/../docs/tutorials:/notebooks -v $PWD:/loc pytorch/conda-cuda bash /loc/run_tutorials.sh | tee log.txt
+# it should execute some tutorials with the nightly build and resave them, and
+# save a log in the current directory.
+
+# We use nbconvert. runipy would be an alternative but it currently doesn't
+# work well with plotly.
+
+set -e
+
+conda init bash
+# shellcheck source=/dev/null
+source ~/.bashrc
+conda create -y -n myenv python=3.8 matplotlib ipython ipywidgets nbconvert
+conda activate myenv
+conda install -y -c iopath iopath
+conda install -y -c pytorch pytorch=1.6.0 cudatoolkit=10.1 torchvision
+conda install -y -c pytorch3d-nightly pytorch3d
+pip install plotly scikit-image
+
+for notebook in /notebooks/*.ipynb
+do
+    name=$(basename "$notebook")
+
+    if [[ "$name" == "dataloaders_ShapeNetCore_R2N2.ipynb" ]]
+    then
+        #skip as data not easily available
+        continue
+    fi
+    if [[ "$name" == "render_densepose.ipynb" ]]
+    then
+        #skip as data not easily available
+        continue
+    fi
+
+    #comment the lines which install torch, torchvision and pytorch3d
+    sed -Ei '/(torchvision)|(pytorch3d)/ s/!pip/!#pip/' "$notebook"
+    #Don't let tqdm use widgets
+    sed -i 's/from tqdm.notebook import tqdm/from tqdm import tqdm/' "$notebook"
+
+    echo
+    echo "###   ###   ###"
+    echo "starting $name"
+    time jupyter nbconvert --to notebook --inplace --ExecutePreprocessor.kernel_name=python3 --execute "$notebook" || true
+    echo "ending $name"
+done

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/dev/test_list.py

@@ -0,0 +1,65 @@
+# 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 ast
+from pathlib import Path
+from typing import List
+
+
+"""
+This module outputs a list of tests for completion.
+It has no dependencies.
+"""
+
+
+def get_test_files() -> List[Path]:
+    root = Path(__file__).parent.parent
+    dirs = ["tests", "projects/implicitron_trainer"]
+    return [i for dir in dirs for i in (root / dir).glob("**/test*.py")]
+
+
+def tests_from_file(path: Path, base: str) -> List[str]:
+    """
+    Returns all the tests in the given file, in format
+    expected as arguments when running the tests.
+    e.g.
+        file_stem
+        file_stem.TestFunctionality
+        file_stem.TestFunctionality.test_f
+        file_stem.TestFunctionality.test_g
+    """
+    with open(path) as f:
+        node = ast.parse(f.read())
+    out = [base]
+    for cls in node.body:
+        if not isinstance(cls, ast.ClassDef):
+            continue
+        if not cls.name.startswith("Test"):
+            continue
+        class_base = base + "." + cls.name
+        out.append(class_base)
+        for method in cls.body:
+            if not isinstance(method, ast.FunctionDef):
+                continue
+            if not method.name.startswith("test"):
+                continue
+            out.append(class_base + "." + method.name)
+    return out
+
+
+def main() -> None:
+    files = get_test_files()
+    test_root = Path(__file__).parent.parent
+    all_tests = []
+    for f in files:
+        file_base = str(f.relative_to(test_root))[:-3].replace("/", ".")
+        all_tests.extend(tests_from_file(f, file_base))
+    for test in sorted(all_tests):
+        print(test)
+
+
+if __name__ == "__main__":
+    main()

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/feature_extractor/feature_extractor.rst

@@ -0,0 +1,9 @@
+pytorch3d.implicitron.models.feature_extractor.feature_extractor
+================================================================
+
+feature_extractor
+
+.. automodule:: pytorch3d.implicitron.models.feature_extractor.feature_extractor
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/feature_extractor/index.rst

@@ -0,0 +1,7 @@
+pytorch3d.implicitron.models.feature_extractor
+==============================================
+
+.. toctree::
+
+    feature_extractor
+    resnet_feature_extractor

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/feature_extractor/resnet_feature_extractor.rst

@@ -0,0 +1,9 @@
+pytorch3d.implicitron.models.feature_extractor.resnet_feature_extractor
+=======================================================================
+
+resnet_feature_extractor
+
+.. automodule:: pytorch3d.implicitron.models.feature_extractor.resnet_feature_extractor
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/global_encoder/autodecoder.rst

@@ -0,0 +1,9 @@
+pytorch3d.implicitron.models.global_encoder.autodecoder
+=======================================================
+
+autodecoder
+
+.. automodule:: pytorch3d.implicitron.models.global_encoder.autodecoder
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/global_encoder/index.rst

@@ -0,0 +1,7 @@
+pytorch3d.implicitron.models.global_encoder
+===========================================
+
+.. toctree::
+
+    autodecoder
+    global_encoder

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/implicit_function/base.rst

@@ -0,0 +1,9 @@
+pytorch3d.implicitron.models.implicit_function.base
+===================================================
+
+base
+
+.. automodule:: pytorch3d.implicitron.models.implicit_function.base
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/implicit_function/decoding_functions.rst

@@ -0,0 +1,9 @@
+pytorch3d.implicitron.models.implicit_function.decoding_functions
+=================================================================
+
+decoding_functions
+
+.. automodule:: pytorch3d.implicitron.models.implicit_function.decoding_functions
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/implicit_function/idr_feature_field.rst

@@ -0,0 +1,9 @@
+pytorch3d.implicitron.models.implicit_function.idr_feature_field
+================================================================
+
+idr_feature_field
+
+.. automodule:: pytorch3d.implicitron.models.implicit_function.idr_feature_field
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/implicit_function/index.rst

@@ -0,0 +1,13 @@
+pytorch3d.implicitron.models.implicit_function
+==============================================
+
+.. toctree::
+
+    base
+    decoding_functions
+    idr_feature_field
+    neural_radiance_field
+    scene_representation_networks
+    utils
+    voxel_grid
+    voxel_grid_implicit_function

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/implicit_function/neural_radiance_field.rst

@@ -0,0 +1,9 @@
+pytorch3d.implicitron.models.implicit_function.neural_radiance_field
+====================================================================
+
+neural_radiance_field
+
+.. automodule:: pytorch3d.implicitron.models.implicit_function.neural_radiance_field
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/implicit_function/scene_representation_networks.rst

@@ -0,0 +1,9 @@
+pytorch3d.implicitron.models.implicit_function.scene_representation_networks
+============================================================================
+
+scene_representation_networks
+
+.. automodule:: pytorch3d.implicitron.models.implicit_function.scene_representation_networks
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/implicit_function/utils.rst

@@ -0,0 +1,9 @@
+pytorch3d.implicitron.models.implicit_function.utils
+====================================================
+
+utils
+
+.. automodule:: pytorch3d.implicitron.models.implicit_function.utils
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/implicit_function/voxel_grid.rst

@@ -0,0 +1,9 @@
+pytorch3d.implicitron.models.implicit_function.voxel_grid
+=========================================================
+
+voxel_grid
+
+.. automodule:: pytorch3d.implicitron.models.implicit_function.voxel_grid
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/implicit_function/voxel_grid_implicit_function.rst

@@ -0,0 +1,9 @@
+pytorch3d.implicitron.models.implicit_function.voxel_grid_implicit_function
+===========================================================================
+
+voxel_grid_implicit_function
+
+.. automodule:: pytorch3d.implicitron.models.implicit_function.voxel_grid_implicit_function
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/renderer/base.rst

@@ -0,0 +1,9 @@
+pytorch3d.implicitron.models.renderer.base
+==========================================
+
+base
+
+.. automodule:: pytorch3d.implicitron.models.renderer.base
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/renderer/index.rst

@@ -0,0 +1,14 @@
+pytorch3d.implicitron.models.renderer
+=====================================
+
+.. toctree::
+
+    base
+    lstm_renderer
+    multipass_ea
+    ray_point_refiner
+    ray_sampler
+    ray_tracing
+    raymarcher
+    rgb_net
+    sdf_renderer

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/renderer/lstm_renderer.rst

@@ -0,0 +1,9 @@
+pytorch3d.implicitron.models.renderer.lstm_renderer
+===================================================
+
+lstm_renderer
+
+.. automodule:: pytorch3d.implicitron.models.renderer.lstm_renderer
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/renderer/multipass_ea.rst

@@ -0,0 +1,9 @@
+pytorch3d.implicitron.models.renderer.multipass_ea
+==================================================
+
+multipass_ea
+
+.. automodule:: pytorch3d.implicitron.models.renderer.multipass_ea
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/renderer/ray_point_refiner.rst

@@ -0,0 +1,9 @@
+pytorch3d.implicitron.models.renderer.ray_point_refiner
+=======================================================
+
+ray_point_refiner
+
+.. automodule:: pytorch3d.implicitron.models.renderer.ray_point_refiner
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/renderer/ray_sampler.rst

@@ -0,0 +1,9 @@
+pytorch3d.implicitron.models.renderer.ray_sampler
+=================================================
+
+ray_sampler
+
+.. automodule:: pytorch3d.implicitron.models.renderer.ray_sampler
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/renderer/ray_tracing.rst

@@ -0,0 +1,9 @@
+pytorch3d.implicitron.models.renderer.ray_tracing
+=================================================
+
+ray_tracing
+
+.. automodule:: pytorch3d.implicitron.models.renderer.ray_tracing
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/renderer/raymarcher.rst

@@ -0,0 +1,9 @@
+pytorch3d.implicitron.models.renderer.raymarcher
+================================================
+
+raymarcher
+
+.. automodule:: pytorch3d.implicitron.models.renderer.raymarcher
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/renderer/rgb_net.rst

@@ -0,0 +1,9 @@
+pytorch3d.implicitron.models.renderer.rgb_net
+=============================================
+
+rgb_net
+
+.. automodule:: pytorch3d.implicitron.models.renderer.rgb_net
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/renderer/sdf_renderer.rst

@@ -0,0 +1,9 @@
+pytorch3d.implicitron.models.renderer.sdf_renderer
+==================================================
+
+sdf_renderer
+
+.. automodule:: pytorch3d.implicitron.models.renderer.sdf_renderer
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/visualization/index.rst

@@ -0,0 +1,6 @@
+pytorch3d.implicitron.models.visualization
+==========================================
+
+.. toctree::
+
+    render_flyaround

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/modules/implicitron/models/visualization/render_flyaround.rst

@@ -0,0 +1,9 @@
+pytorch3d.implicitron.models.visualization.render_flyaround
+===========================================================
+
+render_flyaround
+
+.. automodule:: pytorch3d.implicitron.models.visualization.render_flyaround
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/notes/batching.md

@@ -0,0 +1,32 @@
+---
+hide_title: true
+sidebar_label: Batching
+---
+
+# Batching
+
+In deep learning, every optimization step operates on multiple input examples for robust training. Thus, efficient batching is crucial. For image inputs, batching is straightforward; N images are resized to the same height and width and stacked as a 4 dimensional tensor of shape `N x 3 x H x W`. For meshes, batching is less straightforward.
+
+<img src="assets/batch_intro.png" alt="batch_intro" align="middle"/>
+
+## Batch modes for meshes
+
+Assume you want to construct a batch containing two meshes, with `mesh1 = (v1: V1 x 3, f1: F1 x 3)` containing `V1` vertices and `F1` faces, and `mesh2 = (v2: V2 x 3, f2: F2 x 3)` with `V2 (!= V1)` vertices and `F2 (!= F1)` faces. The [Meshes][meshes] data structure provides three different ways to batch *heterogeneous* meshes. If `meshes = Meshes(verts = [v1, v2], faces = [f1, f2])` is an instantiation of the data structure, then
+
+* List: Returns the examples in the batch as a list of tensors. Specifically, `meshes.verts_list()` returns the list of vertices `[v1, v2]`. Similarly, `meshes.faces_list()` returns the list of faces `[f1, f2]`.
+* Padded: The padded representation constructs a tensor by padding the extra values. Specifically, `meshes.verts_padded()` returns a tensor of shape `2 x max(V1, V2) x 3` and pads the extra vertices with `0`s. Similarly, `meshes.faces_padded()` returns a tensor of shape `2 x max(F1, F2) x 3` and pads the extra faces with `-1`s.
+* Packed: The packed representation concatenates the examples in the batch into a tensor. In particular, `meshes.verts_packed()` returns a tensor of shape `(V1 + V2) x 3`. Similarly, `meshes.faces_packed()` returns a tensor of shape `(F1 + F2) x 3` for the faces. In the packed mode, auxiliary variables are computed that enable efficient conversion between packed and padded or list modes.
+
+<img src="assets/batch_modes.gif" alt="batch_modes" height="450" align="middle" />
+
+## Use cases for batch modes
+
+The need for different mesh batch modes is inherent to the way PyTorch operators are implemented. To fully utilize the optimized PyTorch ops, the [Meshes][meshes] data structure allows for efficient conversion between the different batch modes. This is crucial when aiming for a fast and efficient training cycle. An example of this is [Mesh R-CNN][meshrcnn]. Here, in the same forward pass different parts of the network assume different inputs, which are computed by converting between the different batch modes. In particular, [vert_align][vert_align] assumes a *padded* input tensor while immediately after [graph_conv][graphconv] assumes a *packed* input tensor.
+
+<img src="assets/meshrcnn.png" alt="meshrcnn" width="700" align="middle" />
+
+
+[meshes]: https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/structures/meshes.py
+[graphconv]: https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/ops/graph_conv.py
+[vert_align]: https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/ops/vert_align.py
+[meshrcnn]: https://github.com/facebookresearch/meshrcnn

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/notes/cameras.md

@@ -0,0 +1,101 @@
+---
+hide_title: true
+sidebar_label: Cameras
+---
+
+# Cameras
+
+## Camera Coordinate Systems
+
+When working with 3D data, there are 4 coordinate systems users need to know
+* **World coordinate system**
+This is the system the object/scene lives - the world.
+* **Camera view coordinate system**
+This is the system that has its origin on the image plane and the `Z`-axis perpendicular to the image plane. In PyTorch3D, we assume that `+X` points left, and `+Y` points up and `+Z` points out from the image plane. The transformation from world to view happens after applying a rotation (`R`) and translation (`T`).
+* **NDC coordinate system**
+This is the normalized coordinate system that confines in a volume the rendered part of the object/scene. Also known as view volume. For square images, under the PyTorch3D convention, `(+1, +1, znear)` is the top left near corner, and `(-1, -1, zfar)` is the bottom right far corner of the volume. For non-square images, the side of the volume in `XY` with the smallest length ranges from `[-1, 1]` while the larger side from `[-s, s]`, where `s` is the aspect ratio and `s > 1` (larger divided by smaller side).
+The transformation from view to NDC happens after applying the camera projection matrix (`P`).
+* **Screen coordinate system**
+This is another representation of the view volume with the `XY` coordinates defined in pixel space instead of a normalized space. (0,0) is the top left corner of the top left pixel
+and (W,H) is the bottom right corner of the bottom right pixel.
+
+An illustration of the 4 coordinate systems is shown below
+![cameras](https://user-images.githubusercontent.com/669761/145090051-67b506d7-6d73-4826-a677-5873b7cb92ba.png)
+
+## Defining Cameras in PyTorch3D
+
+Cameras in PyTorch3D transform an object/scene from world to view by first transforming the object/scene to view (via transforms `R` and `T`) and then projecting the 3D object/scene to a normalized space via the projection matrix `P = K[R | T]`, where `K` is the intrinsic matrix. The camera parameters in `K` define the normalized space. If users define the camera parameters in NDC space, then the transform projects points to NDC. If the camera parameters are defined in screen space, the transformed points are in screen space.
+
+Note that the base `CamerasBase` class makes no assumptions about the coordinate systems. All the above transforms are geometric transforms defined purely by `R`, `T` and `K`. This means that users can define cameras  in any coordinate system and for any transforms. The method `transform_points` will apply `K` , `R` and `T` to the input points as a simple matrix transformation. However, if users wish to use cameras with the PyTorch3D renderer, they need to abide to PyTorch3D's coordinate system assumptions (read below).
+
+We provide instantiations of common camera types in PyTorch3D and how users can flexibly define the projection space below.
+
+## Interfacing with the PyTorch3D Renderer
+
+The PyTorch3D renderer for both meshes and point clouds assumes that the camera transformed points, meaning the points passed as input to the rasterizer, are in PyTorch3D's NDC space. So to get the expected rendering outcome, users need to make sure that their 3D input data and cameras abide by these PyTorch3D coordinate system assumptions. The PyTorch3D coordinate system assumes `+X:left`, `+Y: up` and `+Z: from us to scene` (right-handed) . Confusions regarding coordinate systems are common so we advise that you spend some time understanding your data and the coordinate system they live in and transform them accordingly before using the PyTorch3D renderer.
+
+Examples of cameras and how they interface with the PyTorch3D renderer can be found in our tutorials.
+
+### Camera Types
+
+All cameras inherit from `CamerasBase` which is a base class for all cameras. PyTorch3D provides four different camera types. The `CamerasBase` defines methods that are common to all camera models:
+* `get_camera_center` that returns the optical center of the camera in world coordinates
+* `get_world_to_view_transform` which returns a 3D transform from world coordinates to the camera view coordinates `(R, T)`
+* `get_full_projection_transform` which composes the projection transform (`K`) with the world-to-view transform `(R, T)`
+* `transform_points` which takes a set of input points in world coordinates and projects to NDC coordinates ranging from [-1, -1, znear] to  [+1, +1, zfar].
+* `get_ndc_camera_transform` which defines the conversion to PyTorch3D's NDC space and is called when interfacing with the PyTorch3D renderer. If the camera is defined in NDC space, then the identity transform is returned. If the cameras is defined in screen space, the conversion from screen to NDC is returned. If users define their own camera in screen space, they need to think of the screen to NDC conversion. We provide examples for the `PerspectiveCameras` and `OrthographicCameras`.
+* `transform_points_ndc` which takes a set of points in world coordinates and projects them to PyTorch3D's NDC space
+* `transform_points_screen` which takes a set of input points in world coordinates and projects them to the screen coordinates ranging from [0, 0, znear] to [W, H, zfar]
+
+Users can easily customize their own cameras. For each new camera, users should implement the `get_projection_transform` routine that returns the mapping `P` from camera view coordinates to NDC coordinates.
+
+#### FoVPerspectiveCameras, FoVOrthographicCameras
+These two cameras follow the OpenGL convention for perspective and orthographic cameras respectively. The user provides the near `znear` and far `zfar` field which confines the view volume in the `Z` axis. The view volume in the `XY` plane is defined by field of view angle (`fov`) in the case of `FoVPerspectiveCameras` and by `min_x, min_y, max_x, max_y` in the case of `FoVOrthographicCameras`.
+These cameras are by default in NDC space.
+
+#### PerspectiveCameras, OrthographicCameras
+These two cameras follow the Multi-View Geometry convention for cameras. The user provides the focal length (`fx`, `fy`) and the principal point (`px`, `py`). For example, `camera = PerspectiveCameras(focal_length=((fx, fy),), principal_point=((px, py),))`
+
+The camera projection of a 3D point `(X, Y, Z)` in view coordinates to a point `(x, y, z)` in projection space (either NDC or screen) is
+
+```
+# for perspective camera
+x = fx * X / Z + px
+y = fy * Y / Z + py
+z = 1 / Z
+
+# for orthographic camera
+x = fx * X + px
+y = fy * Y + py
+z = Z
+```
+
+The user can define the camera parameters in NDC or in screen space. Screen space camera parameters are common and for that case the user needs to set `in_ndc` to `False` and also provide the `image_size=(height, width)` of the screen, aka the image.
+
+The `get_ndc_camera_transform` provides the transform from screen to NDC space in PyTorch3D. Note that the screen space assumes that the principal point is provided in the space with `+X left`, `+Y down` and origin at the top left corner of the image. To convert to NDC we need to account for the scaling of the normalized space as well as the change in `XY` direction.
+
+Below are example of equivalent `PerspectiveCameras` instantiations in NDC and screen space, respectively.
+
+```python
+# NDC space camera
+fcl_ndc = (1.2,)
+prp_ndc = ((0.2, 0.5),)
+cameras_ndc = PerspectiveCameras(focal_length=fcl_ndc, principal_point=prp_ndc)
+
+# Screen space camera
+image_size = ((128, 256),)    # (h, w)
+fcl_screen = (76.8,)          # fcl_ndc * min(image_size) / 2
+prp_screen = ((115.2, 32), )  # w / 2 - px_ndc * min(image_size) / 2, h / 2 - py_ndc * min(image_size) / 2
+cameras_screen = PerspectiveCameras(focal_length=fcl_screen, principal_point=prp_screen, in_ndc=False, image_size=image_size)
+```
+
+The relationship between screen and NDC specifications of a camera's `focal_length` and `principal_point` is given by the following equations, where `s = min(image_width, image_height)`.
+The transformation of x and y coordinates between screen and NDC is exactly the same as for px and py.
+
+```
+fx_ndc = fx_screen * 2.0 / s
+fy_ndc = fy_screen * 2.0 / s
+
+px_ndc = - (px_screen - image_width / 2.0) * 2.0 / s
+py_ndc = - (py_screen - image_height / 2.0) * 2.0 / s
+```

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/notes/cubify.md

@@ -0,0 +1,12 @@
+---
+hide_title: true
+sidebar_label: Cubify
+---
+
+# Cubify
+
+The [cubify operator](https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/ops/cubify.py) converts an 3D occupancy grid of shape `BxDxHxW`, where `B` is the batch size, into a mesh instantiated as a [Meshes](https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/structures/meshes.py) data structure of `B` elements. The operator replaces every occupied voxel (if its occupancy probability is greater than a user defined threshold) with a cuboid of 12 faces and 8 vertices. Shared vertices are merged, and internal faces are removed resulting in a **watertight** mesh.
+
+The operator provides three alignment modes {*topleft*, *corner*, *center*} which define the span of the mesh vertices with respect to the voxel grid. The alignment modes are described in the figure below for a 2D grid.
+
+![input](https://user-images.githubusercontent.com/4369065/81032959-af697380-8e46-11ea-91a8-fae89597f988.png)

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/notes/datasets.md

@@ -0,0 +1,20 @@
+---
+hide_title: true
+sidebar_label: Data loaders
+---
+
+# Data loaders for common 3D Datasets
+
+### ShapetNetCore
+
+ShapeNet is a dataset of 3D CAD models. ShapeNetCore is a subset of the ShapeNet dataset and can be downloaded from https://www.shapenet.org/. There are two versions ShapeNetCore: v1 (55 categories) and v2 (57 categories).
+
+The PyTorch3D [ShapeNetCore data loader](https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/datasets/shapenet/shapenet_core.py) inherits from `torch.utils.data.Dataset`. It takes the path where the ShapeNetCore dataset is stored locally and loads models in the dataset. The ShapeNetCore class loads and returns models with their `categories`, `model_ids`, `vertices` and `faces`. The `ShapeNetCore` data loader also has a customized `render` function that renders models by the specified `model_ids (List[int])`, `categories (List[str])` or `indices (List[int])` with PyTorch3D's differentiable renderer.
+
+The loaded dataset can be passed to `torch.utils.data.DataLoader` with PyTorch3D's customized collate_fn: `collate_batched_meshes` from the `pytorch3d.dataset.utils` module. The `vertices` and `faces` of the models are used to construct a [Meshes](https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/structures/meshes.py) object representing the batched meshes. This `Meshes` representation can be easily used with other ops and rendering in PyTorch3D.
+
+### R2N2
+
+The R2N2 dataset contains 13 categories that are a subset of the ShapeNetCore v.1 dataset. The R2N2 dataset also contains its own 24 renderings of each object and voxelized models. The R2N2 Dataset can be downloaded following the instructions [here](http://3d-r2n2.stanford.edu/).
+
+The PyTorch3D [R2N2 data loader](https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/datasets/r2n2/r2n2.py) is initialized with the paths to the ShapeNet dataset, the R2N2 dataset and the splits file for R2N2. Just like `ShapeNetCore`, it can be passed to `torch.utils.data.DataLoader` with a customized collate_fn: `collate_batched_R2N2` from the `pytorch3d.dataset.r2n2.utils` module. It returns all the data that `ShapeNetCore` returns, and in addition, it returns the R2N2 renderings (24 views for each model) along with the camera calibration matrices and a voxel representation for each model. Similar to `ShapeNetCore`, it has a customized `render` function that supports rendering specified models with the PyTorch3D differentiable renderer. In addition, it supports rendering models with the same orientations as R2N2's original renderings.

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/notes/io.md

@@ -0,0 +1,34 @@
+---
+hide_title: true
+sidebar_label: File IO
+---
+
+# File IO
+There is a flexible interface for loading and saving point clouds and meshes from different formats.
+
+The main usage is via the `pytorch3d.io.IO` object, and its methods
+`load_mesh`, `save_mesh`, `load_pointcloud` and `save_pointcloud`.
+
+For example, to load a mesh you might do
+```
+from pytorch3d.io import IO
+
+device=torch.device("cuda:0")
+mesh = IO().load_mesh("mymesh.obj", device=device)
+```
+
+and to save a pointcloud you might do
+```
+pcl = Pointclouds(...)
+IO().save_pointcloud(pcl, "output_pointcloud.ply")
+```
+
+For meshes, this supports OBJ, PLY and OFF files.
+
+For pointclouds, this supports PLY files.
+
+In addition, there is experimental support for loading meshes from
+[glTF 2 assets](https://github.com/KhronosGroup/glTF/tree/master/specification/2.0)
+stored either in a GLB container file or a glTF JSON file with embedded binary data.
+This must be enabled explicitly, as described in
+`pytorch3d/io/experimental_gltf_io.py`.

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/notes/iou3d.md

@@ -0,0 +1,93 @@
+---
+hide_title: true
+sidebar_label: IoU3D
+---
+
+# Intersection Over Union of Oriented 3D Boxes: A New Algorithm
+
+Author: Georgia Gkioxari
+
+Implementation: Georgia Gkioxari and Nikhila Ravi
+
+## Description
+
+Intersection over union (IoU) of boxes is widely used as an evaluation metric in object detection ([1][pascalvoc], [2][coco]).
+In 2D, IoU is commonly applied to axis-aligned boxes, namely boxes with edges parallel to the image axis.
+In 3D, boxes are usually not axis aligned and can be oriented in any way in the world.
+We introduce a new algorithm which computes the *exact* IoU of two *oriented 3D boxes*.
+
+Our algorithm is based on the simple observation that the intersection of two oriented 3D boxes, `box1` and `box2`, is a convex polyhedron (convex n-gon in 2D) with `n > 2` comprised of connected *planar units*.
+In 3D, these planar units are 3D triangular faces.
+In 2D, they are 2D edges.
+Each planar unit belongs strictly to either `box1` or `box2`.
+Our algorithm finds these units by iterating through the sides of each box.
+
+1. For each 3D triangular face `e` in `box1` we check wether `e` is *inside* `box2`.
+2. If `e` is not *inside*, then we discard it.
+3. If `e` is *inside* or *partially inside*, then the part of `e` *inside* `box2` is added to the units that comprise the final intersection shape.
+4. We repeat for `box2`.
+
+Below, we show a visualization of our algorithm for the case of 2D oriented boxes.
+
+<p align="center">
+<img src="assets/iou3d.gif" alt="drawing" width="400"/>
+</p>
+
+Note that when a box's unit `e` is *partially inside* a `box` then `e` breaks into smaller units. In 2D, `e` is an edge and breaks into smaller edges. In 3D, `e` is a 3D triangular face and is clipped to more and smaller faces by the plane of the `box` it intersects with.
+This is the sole fundamental difference between the algorithms for 2D and 3D.
+
+## Comparison With Other Algorithms
+
+Current algorithms for 3D box IoU rely on crude approximations or make box assumptions, for example they restrict the orientation of the 3D boxes.
+[Objectron][objectron] provides a nice discussion on the limitations of prior works.
+[Objectron][objectron] introduces a great algorithm for exact IoU computation of oriented 3D boxes.
+Objectron's algorithm computes the intersection points of two boxes using the [Sutherland-Hodgman algorithm][clipalgo].
+The intersection shape is formed by the convex hull from the intersection points, using the [Qhull library][qhull].
+
+Our algorithm has several advantages over Objectron's:
+
+* Our algorithm also computes the points of intersection, similar to Objectron, but in addition stores the *planar units* the points belong to. This eliminates the need for convex hull computation which is `O(nlogn)` and relies on a third party library which often crashes with nondescript error messages.
+* Objectron's implementation assumes that boxes are a rotation away from axis aligned. Our algorithm and implementation make no such assumption and work for any 3D boxes.
+* Our implementation supports batching, unlike Objectron which assumes single element inputs for `box1` and `box2`.
+* Our implementation is easily parallelizable and in fact we provide a custom C++/CUDA implementation which is **450 times faster than Objectron**.
+
+Below we compare the performance for Objectron (in C++) and our algorithm, in C++ and CUDA. We benchmark for a common use case in object detection where `boxes1` hold M predictions and `boxes2` hold N ground truth 3D boxes in an image and compute the `MxN` IoU matrix. We report the time in ms for `M=N=16`.
+
+<p align="center">
+<img src="assets/iou3d_comp.png" alt="drawing" width="400"/>
+</p>
+
+## Usage and Code
+
+```python
+from pytorch3d.ops import box3d_overlap
+# Assume inputs: boxes1 (M, 8, 3) and boxes2 (N, 8, 3)
+intersection_vol, iou_3d = box3d_overlap(boxes1, boxes2)
+```
+
+For more details, read [iou_box3d.py](https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/ops/iou_box3d.py).
+
+Note that our implementation is not differentiable as of now. We plan to add gradient support soon.
+
+We also include have extensive [tests](https://github.com/facebookresearch/pytorch3d/blob/main/tests/test_iou_box3d.py) comparing our implementation with Objectron and MeshLab.
+
+
+## Cite
+
+If you use our 3D IoU algorithm, please cite PyTorch3D
+
+```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},
+}
+```
+
+[pascalvoc]: http://host.robots.ox.ac.uk/pascal/VOC/
+[coco]: https://cocodataset.org/
+[objectron]: https://arxiv.org/abs/2012.09988
+[qhull]: http://www.qhull.org/
+[clipalgo]: https://en.wikipedia.org/wiki/Sutherland%E2%80%93Hodgman_algorithm

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/notes/meshes_io.md

@@ -0,0 +1,75 @@
+---
+sidebar_label: Loading from file
+hide_title: true
+---
+
+# Meshes and IO
+
+The Meshes object represents a batch of triangulated meshes, and is central to
+much of the functionality of PyTorch3D. There is no insistence that each mesh in
+the batch has the same number of vertices or faces. When available, it can store
+other data which pertains to the mesh, for example face normals, face areas
+and textures.
+
+Two common file formats for storing single meshes are ".obj" and ".ply" files,
+and PyTorch3D has functions for reading these.
+
+## OBJ
+
+Obj files have a standard way to store extra information about a mesh. Given an
+obj file, it can be read with
+
+```
+  verts, faces, aux = load_obj(filename)
+```
+
+which sets `verts` to be a (V,3)-tensor of vertices and `faces.verts_idx` to be
+an (F,3)- tensor of the vertex-indices of each of the corners of the faces.
+Faces which are not triangles will be split into triangles. `aux` is an object
+which may contain normals, uv coordinates, material colors and textures if they
+are present, and `faces` may additionally contain indices into these normals,
+textures and materials in its NamedTuple structure. A Meshes object containing a
+single mesh can be created from just the vertices and faces using
+```
+    meshes = Meshes(verts=[verts], faces=[faces.verts_idx])
+```
+
+If there is texture information in the `.obj` it can be used to initialize a
+`Textures` class which is passed into the `Meshes` constructor.  Currently we
+support loading of texture maps for meshes which have one texture map for the
+entire mesh e.g.
+
+```
+verts_uvs = aux.verts_uvs[None, ...]  # (1, V, 2)
+faces_uvs = faces.textures_idx[None, ...]  # (1, F, 3)
+tex_maps = aux.texture_images
+
+# tex_maps is a dictionary of {material name: texture image}.
+# Take the first image:
+texture_image = list(tex_maps.values())[0]
+texture_image = texture_image[None, ...]  # (1, H, W, 3)
+
+# Create a textures object
+tex = Textures(verts_uvs=verts_uvs, faces_uvs=faces_uvs, maps=texture_image)
+
+# Initialise the mesh with textures
+meshes = Meshes(verts=[verts], faces=[faces.verts_idx], textures=tex)
+```
+
+The `load_objs_as_meshes` function provides this procedure.
+
+## PLY
+
+Ply files are flexible in the way they store additional information. PyTorch3D
+provides a function just to read the vertices and faces from a ply file.
+The call
+```
+    verts, faces = load_ply(filename)
+```
+sets `verts` to be a (V,3)-tensor of vertices and `faces` to be an (F,3)-
+tensor of the vertex-indices of each of the corners of the faces. Faces which
+are not triangles will be split into triangles. A Meshes object containing a
+single mesh can be created from this data using
+```
+    meshes = Meshes(verts=[verts], faces=[faces])
+```

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/notes/renderer.md

@@ -0,0 +1,76 @@
+---
+hide_title: true
+sidebar_label:  Overview
+---
+
+# Rendering Overview
+
+Differentiable rendering is a relatively new and exciting research area in computer vision, bridging the gap between 2D and 3D by allowing 2D image pixels to be related back to 3D properties of a scene.
+
+For example, by rendering an image from a 3D shape predicted by a neural network, it is possible to compute a 2D loss with a reference image. Inverting the rendering step means we can relate the 2D loss from the pixels back to the 3D properties of the shape such as the positions of mesh vertices, enabling 3D shapes to be learnt without any explicit 3D supervision.
+
+We extensively researched existing codebases for differentiable rendering and found that:
+- the rendering pipeline is complex with more than 7 separate components which need to interoperate and be differentiable
+- popular existing approaches [[1](#1), [2](#2)] are based on the same core implementation which bundles many of the key components into large CUDA kernels which require significant expertise to understand, and has limited scope for extensions
+- existing methods either do not support batching or assume that meshes in a batch have the same number of vertices and faces
+- existing projects only provide CUDA implementations so they cannot be used without GPUs
+
+In order to experiment with different approaches, we wanted a modular implementation that is easy to use and extend, and supports [heterogeneous batching](batching.md). Taking inspiration from existing work [[1](#1), [2](#2)], we have created a new, modular, differentiable renderer with **parallel implementations in PyTorch, C++ and CUDA**, as well as comprehensive documentation and tests, with the aim of helping to further research in this field.
+
+Our implementation decouples the rasterization and shading steps of rendering. The core rasterization step (based on [[2]](#2)) returns several intermediate variables and has an optimized implementation in CUDA. The rest of the pipeline is implemented purely in PyTorch, and is designed to be customized and extended. With this approach, the PyTorch3D differentiable renderer can be imported as a library.
+
+## <u>Get started</u>
+
+To learn about more the implementation and start using the renderer refer to [getting started with renderer](renderer_getting_started.md), which also contains the [architecture overview](assets/architecture_renderer.jpg) and [coordinate transformation conventions](assets/transforms_overview.jpg).
+
+## <u>Tech Report</u>
+
+For an in depth explanation of the renderer design, key features and benchmarks please refer to the PyTorch3D Technical Report on ArXiv: [Accelerating 3D Deep Learning with PyTorch3D](https://arxiv.org/abs/2007.08501), for the pulsar backend see here: [Fast Differentiable Raycasting for Neural Rendering using Sphere-based Representations](https://arxiv.org/abs/2004.07484).
+
+---
+
+**NOTE: CUDA Memory usage**
+
+The main comparison in the Technical Report is with SoftRasterizer [[2](#2)]. The SoftRasterizer forward CUDA kernel only outputs one `(N, H, W, 4)` FloatTensor compared with the PyTorch3D rasterizer forward CUDA kernel which outputs 4 tensors:
+
+  - `pix_to_face`, LongTensor `(N, H, W, K)`
+  - `zbuf`, FloatTensor `(N, H, W, K)`
+  - `dist`, FloatTensor `(N, H, W, K)`
+  - `bary_coords`, FloatTensor `(N, H, W, K, 3)`
+
+where **N** = batch size, **H/W** are image height/width, **K** is the faces per pixel. The PyTorch3D backward pass returns gradients for `zbuf`, `dist` and `bary_coords`.
+
+Returning intermediate variables from rasterization has an associated memory cost. We can calculate the theoretical lower bound on the memory usage for the forward and backward pass as follows:
+
+```
+# Assume 4 bytes per float, and 8 bytes for long
+
+memory_forward_pass = ((N * H * W * K) * 2 + (N * H * W * K * 3)) * 4 + (N * H * W * K) * 8
+memory_backward_pass = ((N * H * W * K) * 2 + (N * H * W * K * 3)) * 4
+
+total_memory = memory_forward_pass + memory_backward_pass
+             = (N * H * W * K) * (5 * 4 * 2 + 8)
+             = (N * H * W * K) * 48
+```
+
+We need 48 bytes per face per pixel of the rasterized output. In order to remain within bounds for memory usage we can vary the batch size (**N**), image size (**H/W**) and faces per pixel (**K**).  For example, for a fixed batch size, if using a larger image size, try reducing the faces per pixel.
+
+---
+
+### References
+
+<a id="1">[1]</a> Kato et al, 'Neural 3D Mesh Renderer', CVPR 2018
+
+<a id="2">[2]</a> Liu et al, 'Soft Rasterizer: A Differentiable Renderer for Image-based 3D Reasoning', ICCV 2019
+
+<a id="3">[3]</a> Loper et al, 'OpenDR: An Approximate Differentiable Renderer', ECCV 2014
+
+<a id="4">[4]</a> De La Gorce et al, 'Model-based 3D Hand Pose Estimation from Monocular Video', PAMI 2011
+
+<a id="5">[5]</a> Li et al, 'Differentiable Monte Carlo Ray Tracing through Edge Sampling', SIGGRAPH Asia 2018
+
+<a id="6">[6]</a> Yifan et al, 'Differentiable Surface Splatting for Point-based Geometry Processing', SIGGRAPH Asia 2019
+
+<a id="7">[7]</a> Loubet et al, 'Reparameterizing Discontinuous Integrands for Differentiable Rendering', SIGGRAPH Asia 2019
+
+<a id="8">[8]</a> Chen et al, 'Learning to Predict 3D Objects with an Interpolation-based Differentiable Renderer', NeurIPS 2019

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/notes/renderer_getting_started.md

@@ -0,0 +1,147 @@
+---
+hide_title: true
+sidebar_label: Getting Started
+---
+
+# Getting Started With Renderer
+
+### Architecture Overview
+
+The renderer is designed to be modular, extensible and support batching and gradients for all inputs. The following figure describes all the components of the rendering pipeline.
+
+<img src="assets/architecture_renderer.jpg" width="1000">
+
+##### Fragments
+
+The **rasterizer** returns 4 output tensors in a named tuple.
+
+- **`pix_to_face`**: LongTensor of shape `(N, image_size, image_size, faces_per_pixel)` specifying the indices of the faces (in the packed faces) which overlap each pixel in the image.
+- **`zbuf`**: FloatTensor of shape `(N, image_size, image_size, faces_per_pixel)` giving the z-coordinates of the nearest faces at each pixel in world coordinates, sorted in ascending z-order.
+- **`bary_coords`**: FloatTensor of shape `(N, image_size, image_size, faces_per_pixel, 3)`
+  giving the barycentric coordinates in NDC units of the nearest faces at each pixel, sorted in ascending z-order.
+- **`pix_dists`**: FloatTensor of shape `(N, image_size, image_size, faces_per_pixel)` giving the signed Euclidean distance (in NDC units) in the x/y plane of each point closest to the pixel.
+
+
+See the renderer API reference for more details about each component in the pipeline.
+
+---
+
+**NOTE:**
+
+The differentiable renderer API is experimental and subject to change!.
+
+---
+
+### Coordinate transformation conventions
+
+Rendering requires transformations between several different coordinate frames: world space, view/camera space, NDC space and screen space. At each step it is important to know where the camera is located, how the +X, +Y, +Z axes are aligned and the possible range of values. The following figure outlines the conventions used PyTorch3D.
+
+<img src="assets/transforms_overview.jpg" width="1000">
+
+
+For example, given a teapot mesh, the world coordinate frame, camera coordinate frame and image are shown in the figure below. Note that the world and camera coordinate frames have the +z direction pointing in to the page.
+
+<img src="assets/world_camera_image.jpg" width="1000">
+
+---
+
+**NOTE: PyTorch3D vs OpenGL**
+
+While we tried to emulate several aspects of OpenGL, there are differences in the coordinate frame conventions.
+- The default world coordinate frame in PyTorch3D has +Z pointing in to the screen whereas in OpenGL, +Z is pointing out of the screen.  Both are right handed.
+- The NDC coordinate system in PyTorch3D is **right-handed** compared with a **left-handed** NDC coordinate system in OpenGL (the projection matrix switches the handedness).
+
+<img align="center" src="assets/opengl_coordframes.png" width="300">
+
+---
+
+### Rasterizing Non Square Images
+
+To rasterize an image where H != W, you can specify the `image_size` in the `RasterizationSettings` as a tuple of (H, W).
+
+The aspect ratio needs special consideration. There are two aspect ratios to be aware of:
+    - the aspect ratio of each pixel
+    - the aspect ratio of the output image
+In the cameras e.g. `FoVPerspectiveCameras`, the `aspect_ratio` argument can be used to set the pixel aspect ratio. In the rasterizer, we assume square pixels, but variable image aspect ratio (i.e rectangle images).
+
+In most cases you will want to set the camera aspect ratio to 1.0 (i.e. square pixels) and only vary the `image_size` in the `RasterizationSettings`(i.e. the output image dimensions in pixels).
+
+---
+
+### The pulsar backend
+
+Since v0.3, [pulsar](https://arxiv.org/abs/2004.07484) can be used as a backend for point-rendering. It has a focus on efficiency, which comes with pros and cons: it is highly optimized and all rendering stages are integrated in the CUDA kernels. This leads to significantly higher speed and better scaling behavior. We use it at Facebook Reality Labs to render and optimize scenes with millions of spheres in resolutions up to 4K. You can find a runtime comparison plot below (settings: `bin_size=None`, `points_per_pixel=5`, `image_size=1024`, `radius=1e-2`, `composite_params.radius=1e-4`; benchmarked on an RTX 2070 GPU).
+
+<img align="center" src="assets/pulsar_bm.png" width="300">
+
+Pulsar's processing steps are tightly integrated CUDA kernels and do not work with custom `rasterizer` and `compositor` components. We provide two ways to use Pulsar: (1) there is a unified interface to match the PyTorch3D calling convention seamlessly. This is, for example, illustrated in the [point cloud tutorial](https://github.com/facebookresearch/pytorch3d/blob/main/docs/tutorials/render_colored_points.ipynb). (2) There is a direct interface available to the pulsar backend, which exposes the full functionality of the backend (including opacity, which is not yet available in PyTorch3D). Examples showing its use as well as the matching PyTorch3D interface code are available in [this folder](https://github.com/facebookresearch/pytorch3d/tree/master/docs/examples).
+
+---
+
+### Texturing options
+
+For mesh texturing we offer several options (in `pytorch3d/renderer/mesh/texturing.py`):
+
+1. **Vertex Textures**: D dimensional textures for each vertex (for example an RGB color) which can be interpolated across the face. This can be represented as an `(N, V, D)` tensor. This is a fairly simple representation though and cannot model complex textures if the mesh faces are large.
+2. **UV Textures**: vertex UV coordinates and **one** texture map for the whole mesh. For a point on a face with given barycentric coordinates, the face color can be computed by interpolating the vertex uv coordinates and then sampling from the texture map. This representation requires two tensors (UVs: `(N, V, 2), Texture map: `(N, H, W, 3)`), and is limited to only support one texture map per mesh.
+3. **Face Textures**: In more complex cases such as ShapeNet meshes, there are multiple texture maps per mesh and some faces have texture while other do not. For these cases, a more flexible representation is a texture atlas, where each face is represented as an `(RxR)` texture map where R is the texture resolution. For a given point on the face, the texture value can be sampled from the per face texture map using the barycentric coordinates of the point. This representation requires one tensor of shape `(N, F, R, R, 3)`. This texturing method is inspired by the SoftRasterizer implementation. For more details refer to the [`make_material_atlas`](https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/io/mtl_io.py#L123) and [`sample_textures`](https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/renderer/mesh/textures.py#L452) functions. **NOTE:**: The `TexturesAtlas` texture sampling is only differentiable with respect to the texture atlas but not differentiable with respect to the barycentric coordinates.
+
+
+<img src="assets/texturing.jpg" width="1000">
+
+---
+
+### A simple renderer
+
+A renderer in PyTorch3D is composed of a **rasterizer** and a **shader**. Create a renderer in a few simple steps:
+
+```
+# Imports
+from pytorch3d.renderer import (
+    FoVPerspectiveCameras, look_at_view_transform,
+    RasterizationSettings, BlendParams,
+    MeshRenderer, MeshRasterizer, HardPhongShader
+)
+
+# Initialize an OpenGL perspective camera.
+R, T = look_at_view_transform(2.7, 10, 20)
+cameras = FoVPerspectiveCameras(device=device, R=R, T=T)
+
+# Define the settings for rasterization and shading. Here we set the output image to be of size
+# 512x512. As we are rendering images for visualization purposes only we will set faces_per_pixel=1
+# and blur_radius=0.0. Refer to rasterize_meshes.py for explanations of these parameters.
+raster_settings = RasterizationSettings(
+    image_size=512,
+    blur_radius=0.0,
+    faces_per_pixel=1,
+)
+
+# Create a Phong renderer by composing a rasterizer and a shader. Here we can use a predefined
+# PhongShader, passing in the device on which to initialize the default parameters
+renderer = MeshRenderer(
+    rasterizer=MeshRasterizer(cameras=cameras, raster_settings=raster_settings),
+    shader=HardPhongShader(device=device, cameras=cameras)
+)
+```
+
+---
+
+### A custom shader
+
+Shaders are the most flexible part of the PyTorch3D rendering API. We have created some examples of shaders in `shaders.py` but this is a non exhaustive set.
+
+A shader can incorporate several steps:
+- **texturing** (e.g interpolation of vertex RGB colors or interpolation of vertex UV coordinates followed by sampling from a texture map (interpolation uses barycentric coordinates output from rasterization))
+- **lighting/shading** (e.g. ambient, diffuse, specular lighting, Phong, Gouraud, Flat)
+- **blending** (e.g. hard blending using only the closest face for each pixel, or soft blending using a weighted sum of the top K faces per pixel)
+
+ We have examples of several combinations of these functions based on the texturing/shading/blending support we have currently. These are summarised in this table below. Many other combinations are possible and we plan to expand the options available for texturing, shading and blending.
+
+|Example Shaders  | Vertex Textures| UV Textures | Textures Atlas | Flat Shading| Gouraud Shading| Phong Shading | Hard blending | Soft Blending |
+| ------------- |:-------------:  | :--------------:| :--------------:| :--------------:| :--------------:| :--------------:|:--------------:|:--------------:|
+| HardPhongShader |  ✔️ |✔️|✔️|||  ✔️ |  ✔️||
+| SoftPhongShader |  ✔️ |✔️|✔️|||  ✔️ | | ✔️|
+| HardGouraudShader |  ✔️ |✔️|✔️||  ✔️ ||  ✔️||
+| SoftGouraudShader |  ✔️ |✔️|✔️||  ✔️ |||  ✔️|
+| HardFlatShader |  ✔️ |✔️|✔️|  ✔️ |||  ✔️||
+| SoftSilhouetteShader ||||||||  ✔️|

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/notes/visualization.md

@@ -0,0 +1,27 @@
+---
+hide_title: true
+sidebar_label: Plotly Visualization
+---
+
+# Overview
+
+PyTorch3D provides a modular differentiable renderer, but for instances where we want interactive plots or are not concerned with the differentiability of the rendering process, we provide [functions to render meshes and pointclouds in plotly](https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/vis/plotly_vis.py). These plotly figures allow you to rotate and zoom the rendered images and support plotting batched data as multiple traces in a singular plot or divided into individual subplots.
+
+
+# Examples
+
+These rendering functions accept plotly x,y, and z axis arguments as `kwargs`, allowing us to customize the plots. Here are two plots with colored axes, a [Pointclouds plot](assets/plotly_pointclouds.png), a [batched Meshes plot in subplots](assets/plotly_meshes_batch.png), and a [batched Meshes plot with multiple traces](assets/plotly_meshes_trace.png). Refer to the [render textured meshes](https://pytorch3d.org/tutorials/render_textured_meshes) and [render colored pointclouds](https://pytorch3d.org/tutorials/render_colored_points) tutorials for code examples.
+
+# Saving plots to images
+
+If you want to save these plotly plots, you will need to install a separate library such as [Kaleido](https://plotly.com/python/static-image-export/).
+
+Install Kaleido
+```
+$ pip install Kaleido
+```
+Export a figure as a .png image. The image will be saved in the current working directory.
+```
+fig = ...
+fig.write_image("image_name.png")
+```

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/docs/notes/why_pytorch3d.md

@@ -0,0 +1,12 @@
+---
+hide_title: true
+sidebar_label: Why PyTorch3D
+---
+
+
+# Why PyTorch3D
+
+
+Our goal with PyTorch3D is to help accelerate research at the intersection of deep learning and 3D. 3D data is more complex than 2D images and while working on projects such as [Mesh R-CNN](https://github.com/facebookresearch/meshrcnn) and [C3DPO](https://github.com/facebookresearch/c3dpo_nrsfm), we encountered several challenges including 3D data representation, batching, and speed. We have developed many useful operators and abstractions for working on 3D deep learning and want to share this with the community to drive novel research in this area.
+
+In PyTorch3D we have included efficient 3D operators, heterogeneous batching capabilities, and a modular differentiable rendering API, to equip researchers in this field with a much needed toolkit to implement cutting-edge research with complex 3D inputs.

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/pytorch3d/ops/marching_cubes.py

@@ -0,0 +1,305 @@
+# 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.
+
+# pyre-unsafe
+
+from typing import List, Optional, Tuple
+
+import torch
+from pytorch3d import _C
+from pytorch3d.ops.marching_cubes_data import EDGE_TO_VERTICES, FACE_TABLE, INDEX
+from pytorch3d.transforms import Translate
+from torch.autograd import Function
+
+
+EPS = 0.00001
+
+
+class Cube:
+    def __init__(
+        self,
+        bfl_v: Tuple[int, int, int],
+        volume: torch.Tensor,
+        isolevel: float,
+    ) -> None:
+        """
+        Initializes a cube given the bottom front left vertex coordinate
+        and computes the cube configuration given vertex values and isolevel.
+
+        Edge and vertex convention:
+
+                    v4_______e4____________v5
+                    /|                    /|
+                   / |                   / |
+                e7/  |                e5/  |
+                 /___|______e6_________/   |
+              v7|    |                 |v6 |e9
+                |    |                 |   |
+                |    |e8               |e10|
+             e11|    |                 |   |
+                |    |______e0_________|___|
+                |   / v0(bfl_v)        |   |v1
+                |  /                   |  /
+                | /e3                  | /e1
+                |/_____________________|/
+                v3         e2          v2
+
+        Args:
+            bfl_vertex: a tuple of size 3 corresponding to the bottom front left vertex
+                of the cube in (x, y, z) format
+            volume: the 3D scalar data
+            isolevel: the isosurface value used as a threshold for determining whether a point
+                is inside/outside the volume
+        """
+        x, y, z = bfl_v
+        self.x, self.y, self.z = x, y, z
+        self.bfl_v = bfl_v
+        self.verts = [
+            [x + (v & 1), y + (v >> 1 & 1), z + (v >> 2 & 1)] for v in range(8)
+        ]  # vertex position (x, y, z) for v0-v1-v4-v5-v3-v2-v7-v6
+
+        # Calculates cube configuration index given values of the cube vertices
+        self.cube_index = 0
+        for i in range(8):
+            v = self.verts[INDEX[i]]
+            value = volume[v[2]][v[1]][v[0]]
+            if value < isolevel:
+                self.cube_index |= 1 << i
+
+    def get_vpair_from_edge(self, edge: int, W: int, H: int) -> Tuple[int, int]:
+        """
+        Get a tuple of global vertex ID from a local edge ID
+        Global vertex ID is calculated as (x + dx) + (y + dy) * W + (z + dz) * W * H
+
+        Args:
+            edge: local edge ID in the cube
+            bfl_vertex: bottom-front-left coordinate of the cube
+
+        Returns:
+            a pair of global vertex ID
+        """
+        v1, v2 = EDGE_TO_VERTICES[edge]  # two end-points on the edge
+        v1_id = self.verts[v1][0] + self.verts[v1][1] * W + self.verts[v1][2] * W * H
+        v2_id = self.verts[v2][0] + self.verts[v2][1] * W + self.verts[v2][2] * W * H
+        return (v1_id, v2_id)
+
+    def vert_interp(
+        self,
+        isolevel: float,
+        edge: int,
+        vol: torch.Tensor,
+    ) -> List:
+        """
+        Linearly interpolate a vertex where an isosurface cuts an edge
+        between the two endpoint vertices, based on their values
+
+        Args:
+            isolevel: the isosurface value to use as the threshold to determine
+                whether points are within a volume.
+            edge: edge (ID) to interpolate
+            cube: current cube vertices
+            vol: 3D scalar field
+
+        Returns:
+            interpolated vertex: position of the interpolated vertex on the edge
+        """
+        v1, v2 = EDGE_TO_VERTICES[edge]
+        p1, p2 = self.verts[v1], self.verts[v2]
+        val1, val2 = (
+            vol[p1[2]][p1[1]][p1[0]],
+            vol[p2[2]][p2[1]][p2[0]],
+        )
+        point = None
+        if abs(isolevel - val1) < EPS:
+            point = p1
+        elif abs(isolevel - val2) < EPS:
+            point = p2
+        elif abs(val1 - val2) < EPS:
+            point = p1
+
+        if point is None:
+            mu = (isolevel - val1) / (val2 - val1)
+            x1, y1, z1 = p1
+            x2, y2, z2 = p2
+            x = x1 + mu * (x2 - x1)
+            y = y1 + mu * (y2 - y1)
+            z = z1 + mu * (z2 - z1)
+        else:
+            x, y, z = point
+        return [x, y, z]
+
+
+def marching_cubes_naive(
+    vol_batch: torch.Tensor,
+    isolevel: Optional[float] = None,
+    return_local_coords: bool = True,
+) -> Tuple[List[torch.Tensor], List[torch.Tensor]]:
+    """
+    Runs the classic marching cubes algorithm, iterating over
+    the coordinates of the volume and using a given isolevel
+    for determining intersected edges of cubes.
+    Returns vertices and faces of the obtained mesh.
+    This operation is non-differentiable.
+
+    Args:
+        vol_batch: a Tensor of size (N, D, H, W) corresponding to
+            a batch of 3D scalar fields
+        isolevel: the isosurface value to use as the threshold to determine
+            whether points are within a volume. If None, then the average of the
+            maximum and minimum value of the scalar field will be used.
+        return_local_coords: bool. If True the output vertices will be in local coordinates in
+        the range [-1, 1] x [-1, 1] x [-1, 1]. If False they will be in the range
+        [0, W-1] x [0, H-1] x [0, D-1]
+    Returns:
+        verts: [{V_0}, {V_1}, ...] List of N sets of vertices of shape (|V_i|, 3) in FloatTensor
+        faces: [{F_0}, {F_1}, ...] List of N sets of faces of shape (|F_i|, 3) in LongTensors
+    """
+    batched_verts, batched_faces = [], []
+    D, H, W = vol_batch.shape[1:]
+
+    # each edge is represented with its two endpoints (represented with global id)
+    for i in range(len(vol_batch)):
+        vol = vol_batch[i]
+        thresh = ((vol.max() + vol.min()) / 2).item() if isolevel is None else isolevel
+        vpair_to_edge = {}  # maps from tuple of edge endpoints to edge_id
+        edge_id_to_v = {}  # maps from edge ID to vertex position
+        uniq_edge_id = {}  # unique edge IDs
+        verts = []  # store vertex positions
+        faces = []  # store face indices
+        # enumerate each cell in the 3d grid
+        for z in range(0, D - 1):
+            for y in range(0, H - 1):
+                for x in range(0, W - 1):
+                    cube = Cube((x, y, z), vol, thresh)
+                    edge_indices = FACE_TABLE[cube.cube_index]
+                    # cube is entirely in/out of the surface
+                    if len(edge_indices) == 0:
+                        continue
+
+                    # gather mesh vertices/faces by processing each cube
+                    interp_points = [[0.0, 0.0, 0.0]] * 12
+                    # triangle vertex IDs and positions
+                    tri = []
+                    ps = []
+                    for i, edge in enumerate(edge_indices):
+                        interp_points[edge] = cube.vert_interp(thresh, edge, vol)
+
+                        # Bind interpolated vertex with a global edge_id, which
+                        # is represented by a pair of vertex ids (v1_id, v2_id)
+                        # corresponding to a local edge.
+                        (v1_id, v2_id) = cube.get_vpair_from_edge(edge, W, H)
+                        edge_id = vpair_to_edge.setdefault(
+                            (v1_id, v2_id), len(vpair_to_edge)
+                        )
+                        tri.append(edge_id)
+                        ps.append(interp_points[edge])
+                        # when the isolevel are the same as the edge endpoints, the interploated
+                        # vertices can share the same values, and lead to degenerate triangles.
+                        if (
+                            (i + 1) % 3 == 0
+                            and ps[0] != ps[1]
+                            and ps[1] != ps[2]
+                            and ps[2] != ps[0]
+                        ):
+                            for j, edge_id in enumerate(tri):
+                                edge_id_to_v[edge_id] = ps[j]
+                                if edge_id not in uniq_edge_id:
+                                    uniq_edge_id[edge_id] = len(verts)
+                                    verts.append(edge_id_to_v[edge_id])
+                            faces.append([uniq_edge_id[tri[j]] for j in range(3)])
+                            tri = []
+                            ps = []
+
+        if len(faces) > 0 and len(verts) > 0:
+            verts = torch.tensor(verts, dtype=vol.dtype)
+            # Convert from world coordinates ([0, D-1], [0, H-1], [0, W-1]) to
+            # local coordinates in the range [-1, 1]
+            if return_local_coords:
+                verts = (
+                    Translate(x=+1.0, y=+1.0, z=+1.0, device=vol_batch.device)
+                    .scale((vol_batch.new_tensor([W, H, D])[None] - 1) * 0.5)
+                    .inverse()
+                ).transform_points(verts[None])[0]
+            batched_verts.append(verts)
+            batched_faces.append(torch.tensor(faces, dtype=torch.int64))
+        else:
+            batched_verts.append([])
+            batched_faces.append([])
+    return batched_verts, batched_faces
+
+
+########################################
+# Marching Cubes Implementation in C++/Cuda
+########################################
+class _marching_cubes(Function):
+    """
+    Torch Function wrapper for marching_cubes implementation.
+    This function is not differentiable. An autograd wrapper is used
+    to ensure an error if user tries to get gradients.
+    """
+
+    @staticmethod
+    def forward(ctx, vol, isolevel):
+        verts, faces, ids = _C.marching_cubes(vol, isolevel)
+        return verts, faces, ids
+
+    @staticmethod
+    def backward(ctx, grad_verts, grad_faces):
+        raise ValueError("marching_cubes backward is not supported")
+
+
+def marching_cubes(
+    vol_batch: torch.Tensor,
+    isolevel: Optional[float] = None,
+    return_local_coords: bool = True,
+) -> Tuple[List[torch.Tensor], List[torch.Tensor]]:
+    """
+    Run marching cubes over a volume scalar field with a designated isolevel.
+    Returns vertices and faces of the obtained mesh.
+    This operation is non-differentiable.
+
+    Args:
+        vol_batch: a Tensor of size (N, D, H, W) corresponding to
+            a batch of 3D scalar fields
+        isolevel: float used as threshold to determine if a point is inside/outside
+            the volume.  If None, then the average of the maximum and minimum value
+            of the scalar field is used.
+        return_local_coords: bool. If True the output vertices will be in local coordinates in
+            the range [-1, 1] x [-1, 1] x [-1, 1]. If False they will be in the range
+            [0, W-1] x [0, H-1] x [0, D-1]
+
+    Returns:
+        verts: [{V_0}, {V_1}, ...] List of N sets of vertices of shape (|V_i|, 3) in FloatTensor
+        faces: [{F_0}, {F_1}, ...] List of N sets of faces of shape (|F_i|, 3) in LongTensors
+    """
+    batched_verts, batched_faces = [], []
+    D, H, W = vol_batch.shape[1:]
+    for i in range(len(vol_batch)):
+        vol = vol_batch[i]
+        thresh = ((vol.max() + vol.min()) / 2).item() if isolevel is None else isolevel
+        verts, faces, ids = _marching_cubes.apply(vol, thresh)
+        if len(faces) > 0 and len(verts) > 0:
+            # Convert from world coordinates ([0, D-1], [0, H-1], [0, W-1]) to
+            # local coordinates in the range [-1, 1]
+            if return_local_coords:
+                verts = (
+                    Translate(x=+1.0, y=+1.0, z=+1.0, device=vol.device)
+                    .scale((vol.new_tensor([W, H, D])[None] - 1) * 0.5)
+                    .inverse()
+                ).transform_points(verts[None])[0]
+            # deduplication for cuda
+            if vol.is_cuda:
+                unique_ids, inverse_idx = torch.unique(ids, return_inverse=True)
+                verts_ = verts.new_zeros(unique_ids.shape[0], 3)
+                verts_[inverse_idx] = verts
+                verts = verts_
+                faces = inverse_idx[faces]
+            batched_verts.append(verts)
+            batched_faces.append(faces)
+        else:
+            batched_verts.append([])
+            batched_faces.append([])
+    return batched_verts, batched_faces

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/pytorch3d/ops/marching_cubes_data.py

@@ -0,0 +1,291 @@
+# 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.
+
+# pyre-unsafe
+
+
+# Maps each edge (by index) to the corresponding cube vertices
+EDGE_TO_VERTICES = [
+    [0, 1],
+    [1, 5],
+    [4, 5],
+    [0, 4],
+    [2, 3],
+    [3, 7],
+    [6, 7],
+    [2, 6],
+    [0, 2],
+    [1, 3],
+    [5, 7],
+    [4, 6],
+]
+
+# A list of lists mapping a cube_index (a given configuration)
+# to a list of faces corresponding to that configuration. Each face is represented
+# by 3 consecutive numbers. A configuration will at most have 5 faces.
+#
+# Table taken from http://paulbourke.net/geometry/polygonise/
+FACE_TABLE = [
+    [],
+    [0, 8, 3],
+    [0, 1, 9],
+    [1, 8, 3, 9, 8, 1],
+    [1, 2, 10],
+    [0, 8, 3, 1, 2, 10],
+    [9, 2, 10, 0, 2, 9],
+    [2, 8, 3, 2, 10, 8, 10, 9, 8],
+    [3, 11, 2],
+    [0, 11, 2, 8, 11, 0],
+    [1, 9, 0, 2, 3, 11],
+    [1, 11, 2, 1, 9, 11, 9, 8, 11],
+    [3, 10, 1, 11, 10, 3],
+    [0, 10, 1, 0, 8, 10, 8, 11, 10],
+    [3, 9, 0, 3, 11, 9, 11, 10, 9],
+    [9, 8, 10, 10, 8, 11],
+    [4, 7, 8],
+    [4, 3, 0, 7, 3, 4],
+    [0, 1, 9, 8, 4, 7],
+    [4, 1, 9, 4, 7, 1, 7, 3, 1],
+    [1, 2, 10, 8, 4, 7],
+    [3, 4, 7, 3, 0, 4, 1, 2, 10],
+    [9, 2, 10, 9, 0, 2, 8, 4, 7],
+    [2, 10, 9, 2, 9, 7, 2, 7, 3, 7, 9, 4],
+    [8, 4, 7, 3, 11, 2],
+    [11, 4, 7, 11, 2, 4, 2, 0, 4],
+    [9, 0, 1, 8, 4, 7, 2, 3, 11],
+    [4, 7, 11, 9, 4, 11, 9, 11, 2, 9, 2, 1],
+    [3, 10, 1, 3, 11, 10, 7, 8, 4],
+    [1, 11, 10, 1, 4, 11, 1, 0, 4, 7, 11, 4],
+    [4, 7, 8, 9, 0, 11, 9, 11, 10, 11, 0, 3],
+    [4, 7, 11, 4, 11, 9, 9, 11, 10],
+    [9, 5, 4],
+    [9, 5, 4, 0, 8, 3],
+    [0, 5, 4, 1, 5, 0],
+    [8, 5, 4, 8, 3, 5, 3, 1, 5],
+    [1, 2, 10, 9, 5, 4],
+    [3, 0, 8, 1, 2, 10, 4, 9, 5],
+    [5, 2, 10, 5, 4, 2, 4, 0, 2],
+    [2, 10, 5, 3, 2, 5, 3, 5, 4, 3, 4, 8],
+    [9, 5, 4, 2, 3, 11],
+    [0, 11, 2, 0, 8, 11, 4, 9, 5],
+    [0, 5, 4, 0, 1, 5, 2, 3, 11],
+    [2, 1, 5, 2, 5, 8, 2, 8, 11, 4, 8, 5],
+    [10, 3, 11, 10, 1, 3, 9, 5, 4],
+    [4, 9, 5, 0, 8, 1, 8, 10, 1, 8, 11, 10],
+    [5, 4, 0, 5, 0, 11, 5, 11, 10, 11, 0, 3],
+    [5, 4, 8, 5, 8, 10, 10, 8, 11],
+    [9, 7, 8, 5, 7, 9],
+    [9, 3, 0, 9, 5, 3, 5, 7, 3],
+    [0, 7, 8, 0, 1, 7, 1, 5, 7],
+    [1, 5, 3, 3, 5, 7],
+    [9, 7, 8, 9, 5, 7, 10, 1, 2],
+    [10, 1, 2, 9, 5, 0, 5, 3, 0, 5, 7, 3],
+    [8, 0, 2, 8, 2, 5, 8, 5, 7, 10, 5, 2],
+    [2, 10, 5, 2, 5, 3, 3, 5, 7],
+    [7, 9, 5, 7, 8, 9, 3, 11, 2],
+    [9, 5, 7, 9, 7, 2, 9, 2, 0, 2, 7, 11],
+    [2, 3, 11, 0, 1, 8, 1, 7, 8, 1, 5, 7],
+    [11, 2, 1, 11, 1, 7, 7, 1, 5],
+    [9, 5, 8, 8, 5, 7, 10, 1, 3, 10, 3, 11],
+    [5, 7, 0, 5, 0, 9, 7, 11, 0, 1, 0, 10, 11, 10, 0],
+    [11, 10, 0, 11, 0, 3, 10, 5, 0, 8, 0, 7, 5, 7, 0],
+    [11, 10, 5, 7, 11, 5],
+    [10, 6, 5],
+    [0, 8, 3, 5, 10, 6],
+    [9, 0, 1, 5, 10, 6],
+    [1, 8, 3, 1, 9, 8, 5, 10, 6],
+    [1, 6, 5, 2, 6, 1],
+    [1, 6, 5, 1, 2, 6, 3, 0, 8],
+    [9, 6, 5, 9, 0, 6, 0, 2, 6],
+    [5, 9, 8, 5, 8, 2, 5, 2, 6, 3, 2, 8],
+    [2, 3, 11, 10, 6, 5],
+    [11, 0, 8, 11, 2, 0, 10, 6, 5],
+    [0, 1, 9, 2, 3, 11, 5, 10, 6],
+    [5, 10, 6, 1, 9, 2, 9, 11, 2, 9, 8, 11],
+    [6, 3, 11, 6, 5, 3, 5, 1, 3],
+    [0, 8, 11, 0, 11, 5, 0, 5, 1, 5, 11, 6],
+    [3, 11, 6, 0, 3, 6, 0, 6, 5, 0, 5, 9],
+    [6, 5, 9, 6, 9, 11, 11, 9, 8],
+    [5, 10, 6, 4, 7, 8],
+    [4, 3, 0, 4, 7, 3, 6, 5, 10],
+    [1, 9, 0, 5, 10, 6, 8, 4, 7],
+    [10, 6, 5, 1, 9, 7, 1, 7, 3, 7, 9, 4],
+    [6, 1, 2, 6, 5, 1, 4, 7, 8],
+    [1, 2, 5, 5, 2, 6, 3, 0, 4, 3, 4, 7],
+    [8, 4, 7, 9, 0, 5, 0, 6, 5, 0, 2, 6],
+    [7, 3, 9, 7, 9, 4, 3, 2, 9, 5, 9, 6, 2, 6, 9],
+    [3, 11, 2, 7, 8, 4, 10, 6, 5],
+    [5, 10, 6, 4, 7, 2, 4, 2, 0, 2, 7, 11],
+    [0, 1, 9, 4, 7, 8, 2, 3, 11, 5, 10, 6],
+    [9, 2, 1, 9, 11, 2, 9, 4, 11, 7, 11, 4, 5, 10, 6],
+    [8, 4, 7, 3, 11, 5, 3, 5, 1, 5, 11, 6],
+    [5, 1, 11, 5, 11, 6, 1, 0, 11, 7, 11, 4, 0, 4, 11],
+    [0, 5, 9, 0, 6, 5, 0, 3, 6, 11, 6, 3, 8, 4, 7],
+    [6, 5, 9, 6, 9, 11, 4, 7, 9, 7, 11, 9],
+    [10, 4, 9, 6, 4, 10],
+    [4, 10, 6, 4, 9, 10, 0, 8, 3],
+    [10, 0, 1, 10, 6, 0, 6, 4, 0],
+    [8, 3, 1, 8, 1, 6, 8, 6, 4, 6, 1, 10],
+    [1, 4, 9, 1, 2, 4, 2, 6, 4],
+    [3, 0, 8, 1, 2, 9, 2, 4, 9, 2, 6, 4],
+    [0, 2, 4, 4, 2, 6],
+    [8, 3, 2, 8, 2, 4, 4, 2, 6],
+    [10, 4, 9, 10, 6, 4, 11, 2, 3],
+    [0, 8, 2, 2, 8, 11, 4, 9, 10, 4, 10, 6],
+    [3, 11, 2, 0, 1, 6, 0, 6, 4, 6, 1, 10],
+    [6, 4, 1, 6, 1, 10, 4, 8, 1, 2, 1, 11, 8, 11, 1],
+    [9, 6, 4, 9, 3, 6, 9, 1, 3, 11, 6, 3],
+    [8, 11, 1, 8, 1, 0, 11, 6, 1, 9, 1, 4, 6, 4, 1],
+    [3, 11, 6, 3, 6, 0, 0, 6, 4],
+    [6, 4, 8, 11, 6, 8],
+    [7, 10, 6, 7, 8, 10, 8, 9, 10],
+    [0, 7, 3, 0, 10, 7, 0, 9, 10, 6, 7, 10],
+    [10, 6, 7, 1, 10, 7, 1, 7, 8, 1, 8, 0],
+    [10, 6, 7, 10, 7, 1, 1, 7, 3],
+    [1, 2, 6, 1, 6, 8, 1, 8, 9, 8, 6, 7],
+    [2, 6, 9, 2, 9, 1, 6, 7, 9, 0, 9, 3, 7, 3, 9],
+    [7, 8, 0, 7, 0, 6, 6, 0, 2],
+    [7, 3, 2, 6, 7, 2],
+    [2, 3, 11, 10, 6, 8, 10, 8, 9, 8, 6, 7],
+    [2, 0, 7, 2, 7, 11, 0, 9, 7, 6, 7, 10, 9, 10, 7],
+    [1, 8, 0, 1, 7, 8, 1, 10, 7, 6, 7, 10, 2, 3, 11],
+    [11, 2, 1, 11, 1, 7, 10, 6, 1, 6, 7, 1],
+    [8, 9, 6, 8, 6, 7, 9, 1, 6, 11, 6, 3, 1, 3, 6],
+    [0, 9, 1, 11, 6, 7],
+    [7, 8, 0, 7, 0, 6, 3, 11, 0, 11, 6, 0],
+    [7, 11, 6],
+    [7, 6, 11],
+    [3, 0, 8, 11, 7, 6],
+    [0, 1, 9, 11, 7, 6],
+    [8, 1, 9, 8, 3, 1, 11, 7, 6],
+    [10, 1, 2, 6, 11, 7],
+    [1, 2, 10, 3, 0, 8, 6, 11, 7],
+    [2, 9, 0, 2, 10, 9, 6, 11, 7],
+    [6, 11, 7, 2, 10, 3, 10, 8, 3, 10, 9, 8],
+    [7, 2, 3, 6, 2, 7],
+    [7, 0, 8, 7, 6, 0, 6, 2, 0],
+    [2, 7, 6, 2, 3, 7, 0, 1, 9],
+    [1, 6, 2, 1, 8, 6, 1, 9, 8, 8, 7, 6],
+    [10, 7, 6, 10, 1, 7, 1, 3, 7],
+    [10, 7, 6, 1, 7, 10, 1, 8, 7, 1, 0, 8],
+    [0, 3, 7, 0, 7, 10, 0, 10, 9, 6, 10, 7],
+    [7, 6, 10, 7, 10, 8, 8, 10, 9],
+    [6, 8, 4, 11, 8, 6],
+    [3, 6, 11, 3, 0, 6, 0, 4, 6],
+    [8, 6, 11, 8, 4, 6, 9, 0, 1],
+    [9, 4, 6, 9, 6, 3, 9, 3, 1, 11, 3, 6],
+    [6, 8, 4, 6, 11, 8, 2, 10, 1],
+    [1, 2, 10, 3, 0, 11, 0, 6, 11, 0, 4, 6],
+    [4, 11, 8, 4, 6, 11, 0, 2, 9, 2, 10, 9],
+    [10, 9, 3, 10, 3, 2, 9, 4, 3, 11, 3, 6, 4, 6, 3],
+    [8, 2, 3, 8, 4, 2, 4, 6, 2],
+    [0, 4, 2, 4, 6, 2],
+    [1, 9, 0, 2, 3, 4, 2, 4, 6, 4, 3, 8],
+    [1, 9, 4, 1, 4, 2, 2, 4, 6],
+    [8, 1, 3, 8, 6, 1, 8, 4, 6, 6, 10, 1],
+    [10, 1, 0, 10, 0, 6, 6, 0, 4],
+    [4, 6, 3, 4, 3, 8, 6, 10, 3, 0, 3, 9, 10, 9, 3],
+    [10, 9, 4, 6, 10, 4],
+    [4, 9, 5, 7, 6, 11],
+    [0, 8, 3, 4, 9, 5, 11, 7, 6],
+    [5, 0, 1, 5, 4, 0, 7, 6, 11],
+    [11, 7, 6, 8, 3, 4, 3, 5, 4, 3, 1, 5],
+    [9, 5, 4, 10, 1, 2, 7, 6, 11],
+    [6, 11, 7, 1, 2, 10, 0, 8, 3, 4, 9, 5],
+    [7, 6, 11, 5, 4, 10, 4, 2, 10, 4, 0, 2],
+    [3, 4, 8, 3, 5, 4, 3, 2, 5, 10, 5, 2, 11, 7, 6],
+    [7, 2, 3, 7, 6, 2, 5, 4, 9],
+    [9, 5, 4, 0, 8, 6, 0, 6, 2, 6, 8, 7],
+    [3, 6, 2, 3, 7, 6, 1, 5, 0, 5, 4, 0],
+    [6, 2, 8, 6, 8, 7, 2, 1, 8, 4, 8, 5, 1, 5, 8],
+    [9, 5, 4, 10, 1, 6, 1, 7, 6, 1, 3, 7],
+    [1, 6, 10, 1, 7, 6, 1, 0, 7, 8, 7, 0, 9, 5, 4],
+    [4, 0, 10, 4, 10, 5, 0, 3, 10, 6, 10, 7, 3, 7, 10],
+    [7, 6, 10, 7, 10, 8, 5, 4, 10, 4, 8, 10],
+    [6, 9, 5, 6, 11, 9, 11, 8, 9],
+    [3, 6, 11, 0, 6, 3, 0, 5, 6, 0, 9, 5],
+    [0, 11, 8, 0, 5, 11, 0, 1, 5, 5, 6, 11],
+    [6, 11, 3, 6, 3, 5, 5, 3, 1],
+    [1, 2, 10, 9, 5, 11, 9, 11, 8, 11, 5, 6],
+    [0, 11, 3, 0, 6, 11, 0, 9, 6, 5, 6, 9, 1, 2, 10],
+    [11, 8, 5, 11, 5, 6, 8, 0, 5, 10, 5, 2, 0, 2, 5],
+    [6, 11, 3, 6, 3, 5, 2, 10, 3, 10, 5, 3],
+    [5, 8, 9, 5, 2, 8, 5, 6, 2, 3, 8, 2],
+    [9, 5, 6, 9, 6, 0, 0, 6, 2],
+    [1, 5, 8, 1, 8, 0, 5, 6, 8, 3, 8, 2, 6, 2, 8],
+    [1, 5, 6, 2, 1, 6],
+    [1, 3, 6, 1, 6, 10, 3, 8, 6, 5, 6, 9, 8, 9, 6],
+    [10, 1, 0, 10, 0, 6, 9, 5, 0, 5, 6, 0],
+    [0, 3, 8, 5, 6, 10],
+    [10, 5, 6],
+    [11, 5, 10, 7, 5, 11],
+    [11, 5, 10, 11, 7, 5, 8, 3, 0],
+    [5, 11, 7, 5, 10, 11, 1, 9, 0],
+    [10, 7, 5, 10, 11, 7, 9, 8, 1, 8, 3, 1],
+    [11, 1, 2, 11, 7, 1, 7, 5, 1],
+    [0, 8, 3, 1, 2, 7, 1, 7, 5, 7, 2, 11],
+    [9, 7, 5, 9, 2, 7, 9, 0, 2, 2, 11, 7],
+    [7, 5, 2, 7, 2, 11, 5, 9, 2, 3, 2, 8, 9, 8, 2],
+    [2, 5, 10, 2, 3, 5, 3, 7, 5],
+    [8, 2, 0, 8, 5, 2, 8, 7, 5, 10, 2, 5],
+    [9, 0, 1, 5, 10, 3, 5, 3, 7, 3, 10, 2],
+    [9, 8, 2, 9, 2, 1, 8, 7, 2, 10, 2, 5, 7, 5, 2],
+    [1, 3, 5, 3, 7, 5],
+    [0, 8, 7, 0, 7, 1, 1, 7, 5],
+    [9, 0, 3, 9, 3, 5, 5, 3, 7],
+    [9, 8, 7, 5, 9, 7],
+    [5, 8, 4, 5, 10, 8, 10, 11, 8],
+    [5, 0, 4, 5, 11, 0, 5, 10, 11, 11, 3, 0],
+    [0, 1, 9, 8, 4, 10, 8, 10, 11, 10, 4, 5],
+    [10, 11, 4, 10, 4, 5, 11, 3, 4, 9, 4, 1, 3, 1, 4],
+    [2, 5, 1, 2, 8, 5, 2, 11, 8, 4, 5, 8],
+    [0, 4, 11, 0, 11, 3, 4, 5, 11, 2, 11, 1, 5, 1, 11],
+    [0, 2, 5, 0, 5, 9, 2, 11, 5, 4, 5, 8, 11, 8, 5],
+    [9, 4, 5, 2, 11, 3],
+    [2, 5, 10, 3, 5, 2, 3, 4, 5, 3, 8, 4],
+    [5, 10, 2, 5, 2, 4, 4, 2, 0],
+    [3, 10, 2, 3, 5, 10, 3, 8, 5, 4, 5, 8, 0, 1, 9],
+    [5, 10, 2, 5, 2, 4, 1, 9, 2, 9, 4, 2],
+    [8, 4, 5, 8, 5, 3, 3, 5, 1],
+    [0, 4, 5, 1, 0, 5],
+    [8, 4, 5, 8, 5, 3, 9, 0, 5, 0, 3, 5],
+    [9, 4, 5],
+    [4, 11, 7, 4, 9, 11, 9, 10, 11],
+    [0, 8, 3, 4, 9, 7, 9, 11, 7, 9, 10, 11],
+    [1, 10, 11, 1, 11, 4, 1, 4, 0, 7, 4, 11],
+    [3, 1, 4, 3, 4, 8, 1, 10, 4, 7, 4, 11, 10, 11, 4],
+    [4, 11, 7, 9, 11, 4, 9, 2, 11, 9, 1, 2],
+    [9, 7, 4, 9, 11, 7, 9, 1, 11, 2, 11, 1, 0, 8, 3],
+    [11, 7, 4, 11, 4, 2, 2, 4, 0],
+    [11, 7, 4, 11, 4, 2, 8, 3, 4, 3, 2, 4],
+    [2, 9, 10, 2, 7, 9, 2, 3, 7, 7, 4, 9],
+    [9, 10, 7, 9, 7, 4, 10, 2, 7, 8, 7, 0, 2, 0, 7],
+    [3, 7, 10, 3, 10, 2, 7, 4, 10, 1, 10, 0, 4, 0, 10],
+    [1, 10, 2, 8, 7, 4],
+    [4, 9, 1, 4, 1, 7, 7, 1, 3],
+    [4, 9, 1, 4, 1, 7, 0, 8, 1, 8, 7, 1],
+    [4, 0, 3, 7, 4, 3],
+    [4, 8, 7],
+    [9, 10, 8, 10, 11, 8],
+    [3, 0, 9, 3, 9, 11, 11, 9, 10],
+    [0, 1, 10, 0, 10, 8, 8, 10, 11],
+    [3, 1, 10, 11, 3, 10],
+    [1, 2, 11, 1, 11, 9, 9, 11, 8],
+    [3, 0, 9, 3, 9, 11, 1, 2, 9, 2, 11, 9],
+    [0, 2, 11, 8, 0, 11],
+    [3, 2, 11],
+    [2, 3, 8, 2, 8, 10, 10, 8, 9],
+    [9, 10, 2, 0, 9, 2],
+    [2, 3, 8, 2, 8, 10, 0, 1, 8, 1, 10, 8],
+    [1, 10, 2],
+    [1, 3, 8, 9, 1, 8],
+    [0, 9, 1],
+    [0, 3, 8],
+    [],
+]
+
+# mapping from 0-7 to v0-v7 in cube.vertices
+INDEX = [0, 1, 5, 4, 2, 3, 7, 6]

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/pytorch3d/tests/implicitron/common_resources.py

@@ -0,0 +1,161 @@
+# 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 contextlib
+import logging
+import os
+import tempfile
+import unittest
+from pathlib import Path
+from typing import Generator, Tuple
+from zipfile import ZipFile
+
+from iopath.common.file_io import PathManager
+
+
+CO3D_MANIFOLD_PATH: str = "manifold://co3d/tree/extracted"
+CO3DV2_MANIFOLD_PATH: str = "manifold://co3d/tree/v2/extracted"
+
+INSIDE_RE_WORKER: bool = os.environ.get("INSIDE_RE_WORKER", False)
+
+
+def get_path_manager(silence_logs: bool = False) -> PathManager:
+    """
+    Returns a path manager which can access manifold internally.
+
+    Args:
+        silence_logs: Whether to reduce log output from iopath library.
+    """
+    if silence_logs:
+        logging.getLogger("iopath.fb.manifold").setLevel(logging.CRITICAL)
+        logging.getLogger("iopath.common.file_io").setLevel(logging.CRITICAL)
+
+    if INSIDE_RE_WORKER:
+        raise ValueError("Cannot get to manifold from RE")
+
+    path_manager = PathManager()
+
+    if os.environ.get("FB_TEST", False):
+        from iopath.fb.manifold import ManifoldPathHandler
+
+        path_manager.register_handler(ManifoldPathHandler())
+
+    return path_manager
+
+
+@contextlib.contextmanager
+def get_skateboard_data(
+    avoid_manifold: bool = False, silence_logs: bool = False
+) -> Generator[Tuple[str, PathManager], None, None]:
+    """
+    Context manager for accessing Co3D dataset by tests, at least for
+    the first 5 skateboards. Internally, we want this to exercise the
+    normal way to access the data directly manifold, but on an RE
+    worker this is impossible so we use a workaround.
+
+    Args:
+        avoid_manifold: Use the method used by RE workers even locally.
+        silence_logs: Whether to reduce log output from iopath library.
+
+    Yields:
+        dataset_root: (str) path to dataset root.
+        path_manager: path_manager to access it with.
+    """
+    if silence_logs:
+        logging.getLogger("iopath.fb.manifold").setLevel(logging.CRITICAL)
+        logging.getLogger("iopath.common.file_io").setLevel(logging.CRITICAL)
+
+    if not os.environ.get("FB_TEST", False):
+        if os.getenv("FAIR_ENV_CLUSTER", "") == "":
+            raise unittest.SkipTest("Unknown environment. Data not available.")
+        yield "/datasets01/co3d/081922", PathManager()
+
+    elif avoid_manifold or INSIDE_RE_WORKER:
+        from libfb.py.parutil import get_file_path
+
+        par_path = "skateboard_first_5"
+        source = get_file_path(par_path)
+        assert Path(source).is_file()
+        with tempfile.TemporaryDirectory() as dest:
+            with ZipFile(source) as f:
+                f.extractall(dest)
+            yield os.path.join(dest, "extracted"), PathManager()
+    else:
+        yield CO3D_MANIFOLD_PATH, get_path_manager()
+
+
+def _provide_torchvision_weights(par_path: str, filename: str) -> None:
+    """
+    Ensure the weights files are available for a torchvision model.
+    """
+    # In OSS, torchvision looks for vgg16 weights in
+    #   https://download.pytorch.org/models/vgg16-397923af.pth
+    # Inside fbcode, this is replaced by asking iopath for
+    #   manifold://torchvision/tree/models/vgg16-397923af.pth
+    # (the code for this replacement is in
+    #    fbcode/pytorch/vision/fb/_internally_replaced_utils.py )
+    #
+    # iopath does this by looking for the file at the cache location
+    # and if it is not there getting it from manifold.
+    # (the code for this is in
+    #    fbcode/fair_infra/data/iopath/iopath/fb/manifold.py )
+    #
+    # On the remote execution worker, manifold is inaccessible.
+    # We solve this by making the cached file available before iopath
+    # looks.
+    #
+    # By default the cache location is
+    #   ~/.torch/iopath_cache/manifold_cache/tree/models/vgg16-397923af.pth
+    # But we can't write to the home directory on the RE worker.
+    # We define FVCORE_CACHE to change the cache location to
+    #  iopath_cache/manifold_cache/tree/models/vgg16-397923af.pth
+    # (Without it, manifold caches in unstable temporary locations on RE.)
+    #
+    # The file we want has been copied from
+    #    tree/models/vgg16-397923af.pth in the torchvision bucket
+    # to
+    #    tree/testing/vgg16-397923af.pth in the co3d bucket
+    # and the TARGETS file copies it somewhere in the PAR which we
+    # recover with get_file_path.
+    # (It can't copy straight to a nested location, see
+    #    https://fb.workplace.com/groups/askbuck/posts/2644615728920359/)
+    # Here we symlink it to the new cache location.
+    if INSIDE_RE_WORKER:
+        from libfb.py.parutil import get_file_path
+
+        os.environ["FVCORE_CACHE"] = "iopath_cache"
+
+        source = Path(get_file_path(par_path))
+        assert source.is_file()
+
+        dest = Path("iopath_cache/manifold_cache/tree/models")
+        if not dest.exists():
+            dest.mkdir(parents=True)
+
+        if not (dest / filename).is_symlink():
+            try:
+                (dest / filename).symlink_to(source)
+            except FileExistsError:
+                print("FileExistsError: no symlink created.")
+
+
+def provide_lpips_vgg() -> None:
+    """
+    Ensure the weights files are available for lpips.LPIPS(net="vgg")
+    to be called. Specifically, torchvision's vgg16.
+    """
+    _provide_torchvision_weights("vgg_weights_for_lpips", "vgg16-397923af.pth")
+
+
+def provide_resnet34() -> None:
+    """
+    Ensure the weights files are available for
+
+        torchvision.models.resnet34(pretrained=True)
+
+    to be called.
+    """
+    _provide_torchvision_weights("resnet34_weights", "resnet34-b627a593.pth")