Add files using upload-large-folder tool

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/examples/pulsar_basic.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+# 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 example demonstrates the most trivial, direct interface of the pulsar
+sphere renderer. It renders and saves an image with 10 random spheres.
+Output: basic.png.
+"""
+import logging
+import math
+from os import path
+
+import imageio
+import torch
+from pytorch3d.renderer.points.pulsar import Renderer
+
+
+LOGGER = logging.getLogger(__name__)
+
+
+def cli():
+    """
+    Basic example for the pulsar sphere renderer.
+
+    Writes to `basic.png`.
+    """
+    LOGGER.info("Rendering on GPU...")
+    torch.manual_seed(1)
+    n_points = 10
+    width = 1_000
+    height = 1_000
+    device = torch.device("cuda")
+    # The PyTorch3D system is right handed; in pulsar you can choose the handedness.
+    # For easy reproducibility we use a right handed coordinate system here.
+    renderer = Renderer(width, height, n_points, right_handed_system=True).to(device)
+    # Generate sample data.
+    vert_pos = torch.rand(n_points, 3, dtype=torch.float32, device=device) * 10.0
+    vert_pos[:, 2] += 25.0
+    vert_pos[:, :2] -= 5.0
+    vert_col = torch.rand(n_points, 3, dtype=torch.float32, device=device)
+    vert_rad = torch.rand(n_points, dtype=torch.float32, device=device)
+    cam_params = torch.tensor(
+        [
+            0.0,
+            0.0,
+            0.0,  # Position 0, 0, 0 (x, y, z).
+            0.0,
+            math.pi,  # Because of the right handed system, the camera must look 'back'.
+            0.0,  # Rotation 0, 0, 0 (in axis-angle format).
+            5.0,  # Focal length in world size.
+            2.0,  # Sensor size in world size.
+        ],
+        dtype=torch.float32,
+        device=device,
+    )
+    # Render.
+    image = renderer(
+        vert_pos,
+        vert_col,
+        vert_rad,
+        cam_params,
+        1.0e-1,  # Renderer blending parameter gamma, in [1., 1e-5].
+        45.0,  # Maximum depth.
+    )
+    LOGGER.info("Writing image to `%s`.", path.abspath("basic.png"))
+    imageio.imsave("basic.png", (image.cpu().detach() * 255.0).to(torch.uint8).numpy())
+    LOGGER.info("Done.")
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    cli()

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/examples/pulsar_basic_unified.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+# 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 example demonstrates the most trivial use of the pulsar PyTorch3D
+interface for sphere renderering. It renders and saves an image with
+10 random spheres.
+Output: basic-pt3d.png.
+"""
+import logging
+from os import path
+
+import imageio
+import torch
+from pytorch3d.renderer import (
+    PerspectiveCameras,
+    PointsRasterizationSettings,
+    PointsRasterizer,
+    PulsarPointsRenderer,
+)
+from pytorch3d.structures import Pointclouds
+
+
+LOGGER = logging.getLogger(__name__)
+
+
+def cli():
+    """
+    Basic example for the pulsar sphere renderer using the PyTorch3D interface.
+
+    Writes to `basic-pt3d.png`.
+    """
+    LOGGER.info("Rendering on GPU...")
+    torch.manual_seed(1)
+    n_points = 10
+    width = 1_000
+    height = 1_000
+    device = torch.device("cuda")
+    # Generate sample data.
+    vert_pos = torch.rand(n_points, 3, dtype=torch.float32, device=device) * 10.0
+    vert_pos[:, 2] += 25.0
+    vert_pos[:, :2] -= 5.0
+    vert_col = torch.rand(n_points, 3, dtype=torch.float32, device=device)
+    pcl = Pointclouds(points=vert_pos[None, ...], features=vert_col[None, ...])
+    # Alternatively, you can also use the look_at_view_transform to get R and T:
+    # R, T = look_at_view_transform(
+    #     dist=30.0, elev=0.0, azim=180.0, at=((0.0, 0.0, 30.0),), up=((0, 1, 0),),
+    # )
+    cameras = PerspectiveCameras(
+        # The focal length must be double the size for PyTorch3D because of the NDC
+        # coordinates spanning a range of two - and they must be normalized by the
+        # sensor width (see the pulsar example). This means we need here
+        # 5.0 * 2.0 / 2.0 to get the equivalent results as in pulsar.
+        focal_length=(5.0 * 2.0 / 2.0,),
+        R=torch.eye(3, dtype=torch.float32, device=device)[None, ...],
+        T=torch.zeros((1, 3), dtype=torch.float32, device=device),
+        image_size=((height, width),),
+        device=device,
+    )
+    vert_rad = torch.rand(n_points, dtype=torch.float32, device=device)
+    raster_settings = PointsRasterizationSettings(
+        image_size=(height, width),
+        radius=vert_rad,
+    )
+    rasterizer = PointsRasterizer(cameras=cameras, raster_settings=raster_settings)
+    renderer = PulsarPointsRenderer(rasterizer=rasterizer).to(device)
+    # Render.
+    image = renderer(
+        pcl,
+        gamma=(1.0e-1,),  # Renderer blending parameter gamma, in [1., 1e-5].
+        znear=(1.0,),
+        zfar=(45.0,),
+        radius_world=True,
+        bg_col=torch.ones((3,), dtype=torch.float32, device=device),
+    )[0]
+    LOGGER.info("Writing image to `%s`.", path.abspath("basic-pt3d.png"))
+    imageio.imsave(
+        "basic-pt3d.png", (image.cpu().detach() * 255.0).to(torch.uint8).numpy()
+    )
+    LOGGER.info("Done.")
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    cli()

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/examples/pulsar_cam_unified.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+# 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 example demonstrates camera parameter optimization with the pulsar
+PyTorch3D interface. For this, a reference image has been pre-generated
+(you can find it at `../../tests/pulsar/reference/examples_TestRenderer_test_cam.png`).
+The same scene parameterization is loaded and the camera parameters
+distorted. Gradient-based optimization is used to converge towards the
+original camera parameters.
+Output: cam-pt3d.gif
+"""
+import logging
+from os import path
+
+import cv2
+import imageio
+import numpy as np
+import torch
+from pytorch3d.renderer.cameras import PerspectiveCameras
+from pytorch3d.renderer.points import (
+    PointsRasterizationSettings,
+    PointsRasterizer,
+    PulsarPointsRenderer,
+)
+from pytorch3d.structures.pointclouds import Pointclouds
+from pytorch3d.transforms import axis_angle_to_matrix
+from torch import nn, optim
+
+
+LOGGER = logging.getLogger(__name__)
+N_POINTS = 20
+WIDTH = 1_000
+HEIGHT = 1_000
+DEVICE = torch.device("cuda")
+
+
+class SceneModel(nn.Module):
+    """
+    A simple scene model to demonstrate use of pulsar in PyTorch modules.
+
+    The scene model is parameterized with sphere locations (vert_pos),
+    channel content (vert_col), radiuses (vert_rad), camera position (cam_pos),
+    camera rotation (cam_rot) and sensor focal length and width (cam_sensor).
+
+    The forward method of the model renders this scene description. Any
+    of these parameters could instead be passed as inputs to the forward
+    method and come from a different model.
+    """
+
+    def __init__(self):
+        super(SceneModel, self).__init__()
+        self.gamma = 0.1
+        # Points.
+        torch.manual_seed(1)
+        vert_pos = torch.rand(N_POINTS, 3, dtype=torch.float32) * 10.0
+        vert_pos[:, 2] += 25.0
+        vert_pos[:, :2] -= 5.0
+        self.register_parameter("vert_pos", nn.Parameter(vert_pos, requires_grad=False))
+        self.register_parameter(
+            "vert_col",
+            nn.Parameter(
+                torch.rand(N_POINTS, 3, dtype=torch.float32),
+                requires_grad=False,
+            ),
+        )
+        self.register_parameter(
+            "vert_rad",
+            nn.Parameter(
+                torch.rand(N_POINTS, dtype=torch.float32),
+                requires_grad=False,
+            ),
+        )
+        self.register_parameter(
+            "cam_pos",
+            nn.Parameter(
+                torch.tensor([0.1, 0.1, 0.0], dtype=torch.float32),
+                requires_grad=True,
+            ),
+        )
+        self.register_parameter(
+            "cam_rot",
+            # We're using the 6D rot. representation for better gradients.
+            nn.Parameter(
+                axis_angle_to_matrix(
+                    torch.tensor(
+                        [
+                            [0.02, 0.02, 0.01],
+                        ],
+                        dtype=torch.float32,
+                    )
+                )[0],
+                requires_grad=True,
+            ),
+        )
+        self.register_parameter(
+            "focal_length",
+            nn.Parameter(
+                torch.tensor(
+                    [
+                        4.8 * 2.0 / 2.0,
+                    ],
+                    dtype=torch.float32,
+                ),
+                requires_grad=True,
+            ),
+        )
+        self.cameras = PerspectiveCameras(
+            # The focal length must be double the size for PyTorch3D because of the NDC
+            # coordinates spanning a range of two - and they must be normalized by the
+            # sensor width (see the pulsar example). This means we need here
+            # 5.0 * 2.0 / 2.0 to get the equivalent results as in pulsar.
+            #
+            # R, T and f are provided here, but will be provided again
+            # at every call to the forward method. The reason are problems
+            # with PyTorch which makes device placement for gradients problematic
+            # for tensors which are themselves on a 'gradient path' but not
+            # leafs in the calculation tree. This will be addressed by an architectural
+            # change in PyTorch3D in the future. Until then, this workaround is
+            # recommended.
+            focal_length=self.focal_length,
+            R=self.cam_rot[None, ...],
+            T=self.cam_pos[None, ...],
+            image_size=((HEIGHT, WIDTH),),
+            device=DEVICE,
+        )
+        raster_settings = PointsRasterizationSettings(
+            image_size=(HEIGHT, WIDTH),
+            radius=self.vert_rad,
+        )
+        rasterizer = PointsRasterizer(
+            cameras=self.cameras, raster_settings=raster_settings
+        )
+        self.renderer = PulsarPointsRenderer(rasterizer=rasterizer)
+
+    def forward(self):
+        # The Pointclouds object creates copies of it's arguments - that's why
+        # we have to create a new object in every forward step.
+        pcl = Pointclouds(
+            points=self.vert_pos[None, ...], features=self.vert_col[None, ...]
+        )
+        return self.renderer(
+            pcl,
+            gamma=(self.gamma,),
+            zfar=(45.0,),
+            znear=(1.0,),
+            radius_world=True,
+            bg_col=torch.ones((3,), dtype=torch.float32, device=DEVICE),
+            # As mentioned above: workaround for device placement of gradients for
+            # camera parameters.
+            focal_length=self.focal_length,
+            R=self.cam_rot[None, ...],
+            T=self.cam_pos[None, ...],
+        )[0]
+
+
+def cli():
+    """
+    Camera optimization example using pulsar.
+
+    Writes to `cam.gif`.
+    """
+    LOGGER.info("Loading reference...")
+    # Load reference.
+    ref = (
+        torch.from_numpy(
+            imageio.imread(
+                "../../tests/pulsar/reference/examples_TestRenderer_test_cam.png"
+            )[:, ::-1, :].copy()
+        ).to(torch.float32)
+        / 255.0
+    ).to(DEVICE)
+    # Set up model.
+    model = SceneModel().to(DEVICE)
+    # Optimizer.
+    optimizer = optim.SGD(
+        [
+            {"params": [model.cam_pos], "lr": 1e-4},
+            {"params": [model.cam_rot], "lr": 5e-6},
+            # Using a higher lr for the focal length here, because
+            # the sensor width can not be optimized directly.
+            {"params": [model.focal_length], "lr": 1e-3},
+        ]
+    )
+
+    LOGGER.info("Writing video to `%s`.", path.abspath("cam-pt3d.gif"))
+    writer = imageio.get_writer("cam-pt3d.gif", format="gif", fps=25)
+
+    # Optimize.
+    for i in range(300):
+        optimizer.zero_grad()
+        result = model()
+        # Visualize.
+        result_im = (result.cpu().detach().numpy() * 255).astype(np.uint8)
+        cv2.imshow("opt", result_im[:, :, ::-1])
+        writer.append_data(result_im)
+        overlay_img = np.ascontiguousarray(
+            ((result * 0.5 + ref * 0.5).cpu().detach().numpy() * 255).astype(np.uint8)[
+                :, :, ::-1
+            ]
+        )
+        overlay_img = cv2.putText(
+            overlay_img,
+            "Step %d" % (i),
+            (10, 40),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            1,
+            (0, 0, 0),
+            2,
+            cv2.LINE_AA,
+            False,
+        )
+        cv2.imshow("overlay", overlay_img)
+        cv2.waitKey(1)
+        # Update.
+        loss = ((result - ref) ** 2).sum()
+        LOGGER.info("loss %d: %f", i, loss.item())
+        loss.backward()
+        optimizer.step()
+    writer.close()
+    LOGGER.info("Done.")
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    cli()

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/modules/datasets.rst

@@ -0,0 +1,9 @@
+pytorch3d.datasets
+===========================
+
+Dataset loaders for datasets including ShapeNetCore.
+
+.. automodule:: pytorch3d.datasets
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/modules/loss.rst

@@ -0,0 +1,9 @@
+pytorch3d.loss
+====================
+
+Loss functions for meshes and point clouds.
+
+.. automodule:: pytorch3d.loss
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/modules/ops.rst

@@ -0,0 +1,6 @@
+pytorch3d.ops 
+===========================
+
+.. automodule:: pytorch3d.ops
+    :members:
+    :undoc-members:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/modules/renderer/camera_utils.rst

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

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/modules/renderer/fisheyecameras.rst

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

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/modules/renderer/implicit/index.rst

@@ -0,0 +1,11 @@
+pytorch3d.renderer.implicit
+===========================
+
+.. toctree::
+
+    harmonic_embedding
+    raymarching
+    raysampling
+    renderer
+    sample_pdf
+    utils

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/modules/renderer/implicit/raysampling.rst

@@ -0,0 +1,9 @@
+pytorch3d.renderer.implicit.raysampling
+=======================================
+
+raysampling
+
+.. automodule:: pytorch3d.renderer.implicit.raysampling
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/modules/renderer/implicit/renderer.rst

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

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/modules/renderer/implicit/sample_pdf.rst

@@ -0,0 +1,9 @@
+pytorch3d.renderer.implicit.sample_pdf
+======================================
+
+sample_pdf
+
+.. automodule:: pytorch3d.renderer.implicit.sample_pdf
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/modules/renderer/implicit/utils.rst

@@ -0,0 +1,9 @@
+pytorch3d.renderer.implicit.utils
+=================================
+
+utils
+
+.. automodule:: pytorch3d.renderer.implicit.utils
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/modules/renderer/opengl/index.rst

@@ -0,0 +1,7 @@
+pytorch3d.renderer.opengl
+=========================
+
+.. toctree::
+
+    opengl_utils
+    rasterizer_opengl

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/modules/renderer/opengl/opengl_utils.rst

@@ -0,0 +1,9 @@
+pytorch3d.renderer.opengl.opengl_utils
+======================================
+
+opengl_utils
+
+.. automodule:: pytorch3d.renderer.opengl.opengl_utils
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/modules/renderer/opengl/rasterizer_opengl.rst

@@ -0,0 +1,9 @@
+pytorch3d.renderer.opengl.rasterizer_opengl
+===========================================
+
+rasterizer_opengl
+
+.. automodule:: pytorch3d.renderer.opengl.rasterizer_opengl
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/modules/renderer/points/pulsar/index.rst

@@ -0,0 +1,7 @@
+pytorch3d.renderer.points.pulsar
+================================
+
+.. toctree::
+
+    renderer
+    unified

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/modules/renderer/points/pulsar/renderer.rst

@@ -0,0 +1,9 @@
+pytorch3d.renderer.points.pulsar.renderer
+=========================================
+
+renderer
+
+.. automodule:: pytorch3d.renderer.points.pulsar.renderer
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/modules/renderer/points/pulsar/unified.rst

@@ -0,0 +1,9 @@
+pytorch3d.renderer.points.pulsar.unified
+========================================
+
+unified
+
+.. automodule:: pytorch3d.renderer.points.pulsar.unified
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/modules/renderer/splatter_blend.rst

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

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/modules/structures.rst

@@ -0,0 +1,8 @@
+pytorch3d.structures 
+====================
+
+.. automodule:: pytorch3d.structures
+    :members:
+    :undoc-members:
+
+

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/modules/transforms.rst

@@ -0,0 +1,7 @@
+pytorch3d.transforms 
+===========================
+
+.. automodule:: pytorch3d.transforms
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/modules/utils.rst

@@ -0,0 +1,7 @@
+pytorch3d.utils
+====================
+
+.. automodule:: pytorch3d.utils
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/modules/vis/index.rst

@@ -0,0 +1,7 @@
+pytorch3d.vis
+=============
+
+.. toctree::
+
+    plotly_vis
+    texture_vis

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/modules/vis/plotly_vis.rst

@@ -0,0 +1,9 @@
+pytorch3d.vis.plotly_vis
+========================
+
+plotly_vis
+
+.. automodule:: pytorch3d.vis.plotly_vis
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/modules/vis/texture_vis.rst

@@ -0,0 +1,9 @@
+pytorch3d.vis.texture_vis
+=========================
+
+texture_vis
+
+.. automodule:: pytorch3d.vis.texture_vis
+    :members:
+    :undoc-members:
+    :show-inheritance:

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/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/extern/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/extern/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/extern/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/extern/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/extern/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/extern/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/extern/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/extern/pytorch3d/docs/tutorials/implicitron_config_system.ipynb

@@ -0,0 +1,1247 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "customInput": null,
+        "customOutput": null,
+        "originalKey": "f0af2d90-cb21-4ab4-b4cb-0fd00dbfb77b",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "# Copyright (c) Meta Platforms, Inc. and affiliates. All rights reserved."
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "customInput": null,
+        "originalKey": "4e15bfa2-5404-40d0-98b6-eb2732c8b72b",
+        "showInput": false
+      },
+      "source": [
+        "# Implicitron's config system"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "customInput": null,
+        "originalKey": "287be985-423d-42e0-a2af-1e8c585e723c",
+        "showInput": false
+      },
+      "source": [
+        "Implicitron's components are all based on a unified hierarchical configuration system. \n",
+        "This allows configurable variables and all defaults to be defined separately for each new component.\n",
+        "All configs relevant to an experiment are then automatically composed into a single configuration file that fully specifies the experiment.\n",
+        "An especially important feature is extension points where users can insert their own sub-classes of Implicitron's base components.\n",
+        "\n",
+        "The file which defines this system is [here](https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/implicitron/tools/config.py) in the PyTorch3D repo.\n",
+        "The Implicitron volumes tutorial contains a simple example of using the config system.\n",
+        "This tutorial provides detailed hands-on experience in using and modifying Implicitron's configurable components.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "customInput": null,
+        "originalKey": "fde300a2-99cb-4d52-9d5b-4464a2083e0b",
+        "showInput": false
+      },
+      "source": [
+        "## 0. Install and import modules\n",
+        "\n",
+        "Ensure `torch` and `torchvision` are installed. If `pytorch3d` is not installed, install it using the following cell:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "customInput": null,
+        "customOutput": null,
+        "originalKey": "ad6e94a7-e114-43d3-b038-a5210c7d34c9",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "import sys\n",
+        "import torch\n",
+        "import subprocess\n",
+        "need_pytorch3d=False\n",
+        "try:\n",
+        "    import pytorch3d\n",
+        "except ModuleNotFoundError:\n",
+        "    need_pytorch3d=True\n",
+        "if need_pytorch3d:\n",
+        "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+        "    version_str=\"\".join([\n",
+        "        f\"py3{sys.version_info.minor}_cu\",\n",
+        "        torch.version.cuda.replace(\".\",\"\"),\n",
+        "        f\"_pyt{pyt_version_str}\"\n",
+        "    ])\n",
+        "    !pip install iopath\n",
+        "    if sys.platform.startswith(\"linux\"):\n",
+        "        print(\"Trying to install wheel for PyTorch3D\")\n",
+        "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
+        "        pip_list = !pip freeze\n",
+        "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+        "    if need_pytorch3d:\n",
+        "        print(f\"failed to find/install wheel for {version_str}\")\n",
+        "if need_pytorch3d:\n",
+        "    print(\"Installing PyTorch3D from source\")\n",
+        "    !pip install ninja\n",
+        "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "customInput": null,
+        "originalKey": "609896c0-9e2e-4716-b074-b565f0170e32",
+        "showInput": false
+      },
+      "source": [
+        "Ensure omegaconf is installed. If not, run this cell. (It should not be necessary to restart the runtime.)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "customInput": null,
+        "customOutput": null,
+        "originalKey": "d1c1851e-b9f2-4236-93c3-19aa4d63041c",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "!pip install omegaconf"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "code_folding": [],
+        "collapsed": false,
+        "customOutput": null,
+        "executionStartTime": 1659465468717,
+        "executionStopTime": 1659465468738,
+        "hidden_ranges": [],
+        "originalKey": "5ac7ef23-b74c-46b2-b8d3-799524d7ba4f",
+        "requestMsgId": "5ac7ef23-b74c-46b2-b8d3-799524d7ba4f"
+      },
+      "outputs": [],
+      "source": [
+        "from dataclasses import dataclass\n",
+        "from typing import Optional, Tuple\n",
+        "\n",
+        "import torch\n",
+        "from omegaconf import DictConfig, OmegaConf\n",
+        "from pytorch3d.implicitron.tools.config import (\n",
+        "    Configurable,\n",
+        "    ReplaceableBase,\n",
+        "    expand_args_fields,\n",
+        "    get_default_args,\n",
+        "    registry,\n",
+        "    run_auto_creation,\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "customInput": null,
+        "originalKey": "a638bf90-eb6b-424d-b53d-eae11954a717",
+        "showInput": false
+      },
+      "source": [
+        "## 1. Introducing dataclasses \n",
+        "\n",
+        "[Type hints](https://docs.python.org/3/library/typing.html) give a taxonomy of types in Python. [Dataclasses](https://docs.python.org/3/library/dataclasses.html) let you create a class based on a list of members which have names, types and possibly default values. The `__init__` function is created automatically, and calls a `__post_init__` function if present as a final step. For example"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659454972732,
+        "executionStopTime": 1659454972739,
+        "originalKey": "71eaad5e-e198-492e-8610-24b0da9dd4ae",
+        "requestMsgId": "71eaad5e-e198-492e-8610-24b0da9dd4ae",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "@dataclass\n",
+        "class MyDataclass:\n",
+        "    a: int\n",
+        "    b: int = 8\n",
+        "    c: Optional[Tuple[int, ...]] = None\n",
+        "\n",
+        "    def __post_init__(self):\n",
+        "        print(f\"created with a = {self.a}\")\n",
+        "        self.d = 2 * self.b"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659454973051,
+        "executionStopTime": 1659454973077,
+        "originalKey": "83202a18-a3d3-44ec-a62d-b3360a302645",
+        "requestMsgId": "83202a18-a3d3-44ec-a62d-b3360a302645",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "my_dataclass_instance = MyDataclass(a=18)\n",
+        "assert my_dataclass_instance.d == 16"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "customInput": null,
+        "originalKey": "b67ccb9f-dc6c-4994-9b99-b5a1bcfebd70",
+        "showInput": false
+      },
+      "source": [
+        "👷 Note that the `dataclass` decorator here is function which modifies the definition of the class itself.\n",
+        "It runs immediately after the definition.\n",
+        "Our config system requires that implicitron library code contains classes whose modified versions need to be aware of user-defined implementations.\n",
+        "Therefore we need the modification of the class to be delayed. We don't use a decorator.\n"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "customInput": null,
+        "originalKey": "3e90f664-99df-4387-9c45-a1ad7939ef3a",
+        "showInput": false
+      },
+      "source": [
+        "## 2. Introducing omegaconf and OmegaConf.structured\n",
+        "\n",
+        "The [omegaconf](https://github.com/omry/omegaconf/) library provides a DictConfig class which is like a `dict` with str keys, but with extra features for ease-of-use as a configuration system."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659451341683,
+        "executionStopTime": 1659451341690,
+        "originalKey": "81c73c9b-27ee-4aab-b55e-fb0dd67fe174",
+        "requestMsgId": "81c73c9b-27ee-4aab-b55e-fb0dd67fe174",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "dc = DictConfig({\"a\": 2, \"b\": True, \"c\": None, \"d\": \"hello\"})\n",
+        "assert dc.a == dc[\"a\"] == 2"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "customInput": null,
+        "originalKey": "3b5b76a9-4b76-4784-96ff-2a1212e48e48",
+        "showInput": false
+      },
+      "source": [
+        "OmegaConf has a serialization to and from yaml. The [Hydra](https://hydra.cc/) library relies on this for its configuration files."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659451411835,
+        "executionStopTime": 1659451411936,
+        "originalKey": "d7a25ec1-caea-46bc-a1da-4b1f040c4b61",
+        "requestMsgId": "d7a25ec1-caea-46bc-a1da-4b1f040c4b61",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "print(OmegaConf.to_yaml(dc))\n",
+        "assert OmegaConf.create(OmegaConf.to_yaml(dc)) == dc"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "customInput": null,
+        "originalKey": "777fecdd-8bf6-4fd8-827b-cb8af5477fa8",
+        "showInput": false
+      },
+      "source": [
+        "OmegaConf.structured provides a DictConfig from a dataclass or instance of a dataclass. Unlike a normal DictConfig, it is type-checked and only known keys can be added."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659455098879,
+        "executionStopTime": 1659455098900,
+        "originalKey": "de36efb4-0b08-4fb8-bb3a-be1b2c0cd162",
+        "requestMsgId": "de36efb4-0b08-4fb8-bb3a-be1b2c0cd162",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "structured = OmegaConf.structured(MyDataclass)\n",
+        "assert isinstance(structured, DictConfig)\n",
+        "print(structured)\n",
+        "print()\n",
+        "print(OmegaConf.to_yaml(structured))"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "customInput": null,
+        "originalKey": "be4446da-e536-4139-9ba3-37669a5b5e61",
+        "showInput": false
+      },
+      "source": [
+        "`structured` knows it is missing a value for `a`."
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "customInput": null,
+        "originalKey": "864811e8-1a75-4932-a85e-f681b0541ae9",
+        "showInput": false
+      },
+      "source": [
+        "Such an object has members compatible with the dataclass, so an initialisation can be performed as follows."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659455580491,
+        "executionStopTime": 1659455580501,
+        "originalKey": "eb88aaa0-c22f-4ffb-813a-ca957b490acb",
+        "requestMsgId": "eb88aaa0-c22f-4ffb-813a-ca957b490acb",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "structured.a = 21\n",
+        "my_dataclass_instance2 = MyDataclass(**structured)\n",
+        "print(my_dataclass_instance2)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "customInput": null,
+        "originalKey": "2d08c81c-9d18-4de9-8464-0da2d89f94f3",
+        "showInput": false
+      },
+      "source": [
+        "You can also call OmegaConf.structured on an instance."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659455594700,
+        "executionStopTime": 1659455594737,
+        "originalKey": "5e469bac-32a4-475d-9c09-8b64ba3f2155",
+        "requestMsgId": "5e469bac-32a4-475d-9c09-8b64ba3f2155",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "structured_from_instance = OmegaConf.structured(my_dataclass_instance)\n",
+        "my_dataclass_instance3 = MyDataclass(**structured_from_instance)\n",
+        "print(my_dataclass_instance3)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659452594203,
+        "executionStopTime": 1659452594333,
+        "originalKey": "2ed559e3-8552-465a-938f-30c72a321184",
+        "requestMsgId": "2ed559e3-8552-465a-938f-30c72a321184",
+        "showInput": false
+      },
+      "source": [
+        "## 3. Our approach to OmegaConf.structured\n",
+        "\n",
+        "We provide functions which are equivalent to `OmegaConf.structured` but support more features. \n",
+        "To achieve the above using our functions, the following is used.\n",
+        "Note that we indicate configurable classes using a special base class `Configurable`, not a decorator."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659454053323,
+        "executionStopTime": 1659454061629,
+        "originalKey": "9888afbd-e617-4596-ab7a-fc1073f58656",
+        "requestMsgId": "9888afbd-e617-4596-ab7a-fc1073f58656",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "class MyConfigurable(Configurable):\n",
+        "    a: int\n",
+        "    b: int = 8\n",
+        "    c: Optional[Tuple[int, ...]] = None\n",
+        "\n",
+        "    def __post_init__(self):\n",
+        "        print(f\"created with a = {self.a}\")\n",
+        "        self.d = 2 * self.b"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659454784912,
+        "executionStopTime": 1659454784928,
+        "originalKey": "e43155b4-3da5-4df1-a2f5-da1d0369eec9",
+        "requestMsgId": "e43155b4-3da5-4df1-a2f5-da1d0369eec9",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "# The expand_args_fields function modifies the class like @dataclasses.dataclass.\n",
+        "# If it has not been called on a Configurable object before it has been instantiated, it will\n",
+        "# be called automatically.\n",
+        "expand_args_fields(MyConfigurable)\n",
+        "my_configurable_instance = MyConfigurable(a=18)\n",
+        "assert my_configurable_instance.d == 16"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659460669541,
+        "executionStopTime": 1659460669566,
+        "originalKey": "96eaae18-dce4-4ee1-b451-1466fea51b9f",
+        "requestMsgId": "96eaae18-dce4-4ee1-b451-1466fea51b9f",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "# get_default_args also calls expand_args_fields automatically\n",
+        "our_structured = get_default_args(MyConfigurable)\n",
+        "assert isinstance(our_structured, DictConfig)\n",
+        "print(OmegaConf.to_yaml(our_structured))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659460454020,
+        "executionStopTime": 1659460454032,
+        "originalKey": "359f7925-68de-42cd-bd34-79a099b1c210",
+        "requestMsgId": "359f7925-68de-42cd-bd34-79a099b1c210",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "our_structured.a = 21\n",
+        "print(MyConfigurable(**our_structured))"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659460599142,
+        "executionStopTime": 1659460599149,
+        "originalKey": "eac7d385-9365-4098-acf9-4f0a0dbdcb85",
+        "requestMsgId": "eac7d385-9365-4098-acf9-4f0a0dbdcb85",
+        "showInput": false
+      },
+      "source": [
+        "## 4. First enhancement: nested types 🪺\n",
+        "\n",
+        "Our system allows Configurable classes to contain each other. \n",
+        "One thing to remember: add a call to `run_auto_creation` in `__post_init__`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659465752418,
+        "executionStopTime": 1659465752976,
+        "originalKey": "9bd70ee5-4ec1-4021-bce5-9638b5088c0a",
+        "requestMsgId": "9bd70ee5-4ec1-4021-bce5-9638b5088c0a",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "class Inner(Configurable):\n",
+        "    a: int = 8\n",
+        "    b: bool = True\n",
+        "    c: Tuple[int, ...] = (2, 3, 4, 6)\n",
+        "\n",
+        "\n",
+        "class Outer(Configurable):\n",
+        "    inner: Inner\n",
+        "    x: str = \"hello\"\n",
+        "    xx: bool = False\n",
+        "\n",
+        "    def __post_init__(self):\n",
+        "        run_auto_creation(self)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659465762326,
+        "executionStopTime": 1659465762339,
+        "originalKey": "9f2b9f98-b54b-46cc-9b02-9e902cb279e7",
+        "requestMsgId": "9f2b9f98-b54b-46cc-9b02-9e902cb279e7",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "outer_dc = get_default_args(Outer)\n",
+        "print(OmegaConf.to_yaml(outer_dc))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659465772894,
+        "executionStopTime": 1659465772911,
+        "originalKey": "0254204b-8c7a-4d40-bba6-5132185f63d7",
+        "requestMsgId": "0254204b-8c7a-4d40-bba6-5132185f63d7",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "outer = Outer(**outer_dc)\n",
+        "assert isinstance(outer, Outer)\n",
+        "assert isinstance(outer.inner, Inner)\n",
+        "print(vars(outer))\n",
+        "print(outer.inner)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "customInput": null,
+        "originalKey": "44a78c13-ec92-4a87-808a-c4674b320c22",
+        "showInput": false
+      },
+      "source": [
+        "Note how inner_args is an extra member of outer. `run_auto_creation(self)` is equivalent to\n",
+        "```\n",
+        "    self.inner = Inner(**self.inner_args)\n",
+        "```"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659461071129,
+        "executionStopTime": 1659461071137,
+        "originalKey": "af0ec78b-7888-4b0d-9346-63d970d43293",
+        "requestMsgId": "af0ec78b-7888-4b0d-9346-63d970d43293",
+        "showInput": false
+      },
+      "source": [
+        "## 5. Second enhancement: pluggable/replaceable components 🔌\n",
+        "\n",
+        "If a class uses `ReplaceableBase` as a base class instead of `Configurable`, we call it a replaceable.\n",
+        "It indicates that it is designed for child classes to use in its place.\n",
+        "We might use `NotImplementedError` to indicate functionality which subclasses are expected to implement.\n",
+        "The system maintains a global `registry` containing subclasses of each ReplaceableBase.\n",
+        "The subclasses register themselves with it with a decorator.\n",
+        "\n",
+        "A configurable class (i.e. a class which uses our system, i.e. a child of `Configurable` or `ReplaceableBase`) which contains a ReplaceableBase must also \n",
+        "contain a corresponding class_type field of type `str` which indicates which concrete child class to use."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659463453457,
+        "executionStopTime": 1659463453467,
+        "originalKey": "f2898703-d147-4394-978e-fc7f1f559395",
+        "requestMsgId": "f2898703-d147-4394-978e-fc7f1f559395",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "class InnerBase(ReplaceableBase):\n",
+        "    def say_something(self):\n",
+        "        raise NotImplementedError\n",
+        "\n",
+        "\n",
+        "@registry.register\n",
+        "class Inner1(InnerBase):\n",
+        "    a: int = 1\n",
+        "    b: str = \"h\"\n",
+        "\n",
+        "    def say_something(self):\n",
+        "        print(\"hello from an Inner1\")\n",
+        "\n",
+        "\n",
+        "@registry.register\n",
+        "class Inner2(InnerBase):\n",
+        "    a: int = 2\n",
+        "\n",
+        "    def say_something(self):\n",
+        "        print(\"hello from an Inner2\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659463453514,
+        "executionStopTime": 1659463453592,
+        "originalKey": "6f171599-51ee-440f-82d7-a59f84d24624",
+        "requestMsgId": "6f171599-51ee-440f-82d7-a59f84d24624",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "class Out(Configurable):\n",
+        "    inner: InnerBase\n",
+        "    inner_class_type: str = \"Inner1\"\n",
+        "    x: int = 19\n",
+        "\n",
+        "    def __post_init__(self):\n",
+        "        run_auto_creation(self)\n",
+        "\n",
+        "    def talk(self):\n",
+        "        self.inner.say_something()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659463191360,
+        "executionStopTime": 1659463191428,
+        "originalKey": "7abaecec-96e6-44df-8c8d-69c36a14b913",
+        "requestMsgId": "7abaecec-96e6-44df-8c8d-69c36a14b913",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "Out_dc = get_default_args(Out)\n",
+        "print(OmegaConf.to_yaml(Out_dc))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659463192717,
+        "executionStopTime": 1659463192754,
+        "originalKey": "c82dc2ca-ba8f-4a44-aed3-43f6b52ec28c",
+        "requestMsgId": "c82dc2ca-ba8f-4a44-aed3-43f6b52ec28c",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "Out_dc.inner_class_type = \"Inner2\"\n",
+        "out = Out(**Out_dc)\n",
+        "print(out.inner)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659463193751,
+        "executionStopTime": 1659463193791,
+        "originalKey": "aa0e1b04-963a-4724-81b7-5748b598b541",
+        "requestMsgId": "aa0e1b04-963a-4724-81b7-5748b598b541",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "out.talk()"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "customInput": null,
+        "originalKey": "4f78a56c-39cd-4563-a97e-041e5f360f6b",
+        "showInput": false
+      },
+      "source": [
+        "Note in this case there are many `args` members. It is usually fine to ignore them in the code. They are needed for the config."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659462145294,
+        "executionStopTime": 1659462145307,
+        "originalKey": "ce7069d5-a813-4286-a7cd-6ff40362105a",
+        "requestMsgId": "ce7069d5-a813-4286-a7cd-6ff40362105a",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "print(vars(out))"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659462231114,
+        "executionStopTime": 1659462231130,
+        "originalKey": "c7f051ff-c264-4b89-80dc-36cf179aafaf",
+        "requestMsgId": "c7f051ff-c264-4b89-80dc-36cf179aafaf",
+        "showInput": false
+      },
+      "source": [
+        "## 6. Example with torch.nn.Module  🔥\n",
+        "Typically in implicitron, we use this system in combination with [`Module`](https://pytorch.org/docs/stable/generated/torch.nn.Module.html)s. \n",
+        "Note in this case it is necessary to call `Module.__init__` explicitly in `__post_init__`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659462645018,
+        "executionStopTime": 1659462645037,
+        "originalKey": "42d210d6-09e0-4daf-8ccb-411d30f268f4",
+        "requestMsgId": "42d210d6-09e0-4daf-8ccb-411d30f268f4",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "class MyLinear(torch.nn.Module, Configurable):\n",
+        "    d_in: int = 2\n",
+        "    d_out: int = 200\n",
+        "\n",
+        "    def __post_init__(self):\n",
+        "        super().__init__()\n",
+        "        self.linear = torch.nn.Linear(in_features=self.d_in, out_features=self.d_out)\n",
+        "\n",
+        "    def forward(self, x):\n",
+        "        return self.linear.forward(x)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659462692309,
+        "executionStopTime": 1659462692346,
+        "originalKey": "546781fe-5b95-4e48-9cb5-34a634a31313",
+        "requestMsgId": "546781fe-5b95-4e48-9cb5-34a634a31313",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "my_linear = MyLinear()\n",
+        "input = torch.zeros(2)\n",
+        "output = my_linear(input)\n",
+        "print(\"output shape:\", output.shape)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659462738302,
+        "executionStopTime": 1659462738419,
+        "originalKey": "b6cb71e1-1d54-4e89-a422-0a70772c5c03",
+        "requestMsgId": "b6cb71e1-1d54-4e89-a422-0a70772c5c03",
+        "showInput": false
+      },
+      "source": [
+        "`my_linear` has all the usual features of a Module.\n",
+        "E.g. it can be saved and loaded with `torch.save` and `torch.load`.\n",
+        "It has parameters:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659462821485,
+        "executionStopTime": 1659462821501,
+        "originalKey": "47e8c53e-2d2c-4b41-8aa3-65aa3ea8a7d3",
+        "requestMsgId": "47e8c53e-2d2c-4b41-8aa3-65aa3ea8a7d3",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "for name, value in my_linear.named_parameters():\n",
+        "    print(name, value.shape)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659463222379,
+        "executionStopTime": 1659463222409,
+        "originalKey": "a01f0ea7-55f2-4af9-8e81-45dddf40f13b",
+        "requestMsgId": "a01f0ea7-55f2-4af9-8e81-45dddf40f13b",
+        "showInput": false
+      },
+      "source": [
+        "## 7. Example of implementing your own pluggable component \n",
+        "Let's say I am using a library with `Out` like in section **5** but I want to implement my own child of InnerBase. \n",
+        "All I need to do is register its definition, but I need to do this before expand_args_fields is explicitly or implicitly called on Out."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659463694644,
+        "executionStopTime": 1659463694653,
+        "originalKey": "d9635511-a52b-43d5-8dae-d5c1a3dd9157",
+        "requestMsgId": "d9635511-a52b-43d5-8dae-d5c1a3dd9157",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "@registry.register\n",
+        "class UserImplementedInner(InnerBase):\n",
+        "    a: int = 200\n",
+        "\n",
+        "    def say_something(self):\n",
+        "        print(\"hello from the user\")"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "customInput": null,
+        "originalKey": "f1511aa2-56b8-4ed0-a453-17e2bbfeefe7",
+        "showInput": false
+      },
+      "source": [
+        "At this point, we need to redefine the class Out. \n",
+        "Otherwise if it has already been expanded without UserImplementedInner, then the following would not work,\n",
+        "because the implementations known to a class are fixed when it is expanded.\n",
+        "\n",
+        "If you are running experiments from a script, the thing to remember here is that you must import your own modules, which register your own implementations,\n",
+        "before you *use* the library classes."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659463745967,
+        "executionStopTime": 1659463745986,
+        "originalKey": "c7bb5a6e-682b-4eb0-a214-e0f5990b9406",
+        "requestMsgId": "c7bb5a6e-682b-4eb0-a214-e0f5990b9406",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "class Out(Configurable):\n",
+        "    inner: InnerBase\n",
+        "    inner_class_type: str = \"Inner1\"\n",
+        "    x: int = 19\n",
+        "\n",
+        "    def __post_init__(self):\n",
+        "        run_auto_creation(self)\n",
+        "\n",
+        "    def talk(self):\n",
+        "        self.inner.say_something()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659463747398,
+        "executionStopTime": 1659463747431,
+        "originalKey": "b6ecdc86-4b7b-47c6-9f45-a7e557c94979",
+        "requestMsgId": "b6ecdc86-4b7b-47c6-9f45-a7e557c94979",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "out2 = Out(inner_class_type=\"UserImplementedInner\")\n",
+        "print(out2.inner)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659464033633,
+        "executionStopTime": 1659464033643,
+        "originalKey": "c7fe0df3-da13-40b8-9b06-6b1f37f37bb9",
+        "requestMsgId": "c7fe0df3-da13-40b8-9b06-6b1f37f37bb9",
+        "showInput": false
+      },
+      "source": [
+        "## 8: Example of making a subcomponent pluggable\n",
+        "\n",
+        "Let's look what needs to happen if we have a subcomponent which we make pluggable, to allow users to supply their own."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659464709922,
+        "executionStopTime": 1659464709933,
+        "originalKey": "e37227b2-6897-4033-8560-9f2040abdeeb",
+        "requestMsgId": "e37227b2-6897-4033-8560-9f2040abdeeb",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "class SubComponent(Configurable):\n",
+        "    x: float = 0.25\n",
+        "\n",
+        "    def apply(self, a: float) -> float:\n",
+        "        return a + self.x\n",
+        "\n",
+        "\n",
+        "class LargeComponent(Configurable):\n",
+        "    repeats: int = 4\n",
+        "    subcomponent: SubComponent\n",
+        "\n",
+        "    def __post_init__(self):\n",
+        "        run_auto_creation(self)\n",
+        "\n",
+        "    def apply(self, a: float) -> float:\n",
+        "        for _ in range(self.repeats):\n",
+        "            a = self.subcomponent.apply(a)\n",
+        "        return a"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659464710339,
+        "executionStopTime": 1659464710459,
+        "originalKey": "cab4c121-350e-443f-9a49-bd542a9735a2",
+        "requestMsgId": "cab4c121-350e-443f-9a49-bd542a9735a2",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "large_component = LargeComponent()\n",
+        "assert large_component.apply(3) == 4\n",
+        "print(OmegaConf.to_yaml(LargeComponent))"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "customInput": null,
+        "originalKey": "be60323a-badf-46e4-a259-72cae1391028",
+        "showInput": false
+      },
+      "source": [
+        "Made generic:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659464717226,
+        "executionStopTime": 1659464717261,
+        "originalKey": "fc0d8cdb-4627-4427-b92a-17ac1c1b37b8",
+        "requestMsgId": "fc0d8cdb-4627-4427-b92a-17ac1c1b37b8",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "class SubComponentBase(ReplaceableBase):\n",
+        "    def apply(self, a: float) -> float:\n",
+        "        raise NotImplementedError\n",
+        "\n",
+        "\n",
+        "@registry.register\n",
+        "class SubComponent(SubComponentBase):\n",
+        "    x: float = 0.25\n",
+        "\n",
+        "    def apply(self, a: float) -> float:\n",
+        "        return a + self.x\n",
+        "\n",
+        "\n",
+        "class LargeComponent(Configurable):\n",
+        "    repeats: int = 4\n",
+        "    subcomponent: SubComponentBase\n",
+        "    subcomponent_class_type: str = \"SubComponent\"\n",
+        "\n",
+        "    def __post_init__(self):\n",
+        "        run_auto_creation(self)\n",
+        "\n",
+        "    def apply(self, a: float) -> float:\n",
+        "        for _ in range(self.repeats):\n",
+        "            a = self.subcomponent.apply(a)\n",
+        "        return a"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659464725473,
+        "executionStopTime": 1659464725587,
+        "originalKey": "bbc3d321-6b49-4356-be75-1a173b1fc3a5",
+        "requestMsgId": "bbc3d321-6b49-4356-be75-1a173b1fc3a5",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "large_component = LargeComponent()\n",
+        "assert large_component.apply(3) == 4\n",
+        "print(OmegaConf.to_yaml(LargeComponent))"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659464672680,
+        "executionStopTime": 1659464673231,
+        "originalKey": "5115453a-1d96-4022-97e7-46433e6dcf60",
+        "requestMsgId": "5115453a-1d96-4022-97e7-46433e6dcf60",
+        "showInput": false
+      },
+      "source": [
+        "The following things had to change:\n",
+        "* The base class SubComponentBase was defined.\n",
+        "* SubComponent gained a `@registry.register` decoration and had its base class changed to the new one.\n",
+        "* `subcomponent_class_type` was added as a member of the outer class.\n",
+        "* In any saved configuration yaml files, the key `subcomponent_args` had to be changed to `subcomponent_SubComponent_args`."
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659462041307,
+        "executionStopTime": 1659462041637,
+        "originalKey": "0739269e-5c0e-4551-b06f-f4aab386ba54",
+        "requestMsgId": "0739269e-5c0e-4551-b06f-f4aab386ba54",
+        "showInput": false
+      },
+      "source": [
+        "## Appendix: gotchas ⚠️\n",
+        "\n",
+        "* Omitting to define `__post_init__` or not calling `run_auto_creation` in it.\n",
+        "* Omitting a type annotation on a field. For example, writing \n",
+        "```\n",
+        "    subcomponent_class_type = \"SubComponent\"\n",
+        "```\n",
+        "instead of \n",
+        "```\n",
+        "    subcomponent_class_type: str = \"SubComponent\"\n",
+        "```\n",
+        "\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "bento_stylesheets": {
+      "bento/extensions/flow/main.css": true,
+      "bento/extensions/kernel_selector/main.css": true,
+      "bento/extensions/kernel_ui/main.css": true,
+      "bento/extensions/new_kernel/main.css": true,
+      "bento/extensions/system_usage/main.css": true,
+      "bento/extensions/theme/main.css": true
+    },
+    "captumWidgetMessage": {},
+    "dataExplorerConfig": {},
+    "kernelspec": {
+      "display_name": "pytorch3d",
+      "language": "python",
+      "metadata": {
+        "cinder_runtime": false,
+        "fbpkg_supported": true,
+        "is_prebuilt": true,
+        "kernel_name": "bento_kernel_pytorch3d",
+        "nightly_builds": true
+      },
+      "name": "bento_kernel_pytorch3d"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3"
+    },
+    "last_base_url": "https://9177.od.fbinfra.net:443/",
+    "last_kernel_id": "90755407-3729-46f4-ab67-ff2cb1daa5cb",
+    "last_msg_id": "f61034eb-826226915ad9548ffbe495ba_6317",
+    "last_server_session_id": "d6b46f14-cee7-44c1-8c51-39a38a4ea4c2",
+    "outputWidgetContext": {}
+  },
+  "nbformat": 4,
+  "nbformat_minor": 2
+}

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/tutorials/implicitron_volumes.ipynb

@@ -0,0 +1,902 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659619824914,
+        "executionStopTime": 1659619825485,
+        "originalKey": "d38652e8-200a-413c-a36a-f4d349b78a9d",
+        "requestMsgId": "641de8aa-0e42-4446-9304-c160a2d226bf",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "# Copyright (c) Meta Platforms, Inc. and affiliates. All rights reserved."
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "customInput": null,
+        "originalKey": "a48a9dcf-e80f-474b-a0c4-2c9a765b15c5",
+        "showInput": false
+      },
+      "source": [
+        "# A simple model using Implicitron\n",
+        "\n",
+        "In this demo, we use the VolumeRenderer from PyTorch3D as a custom implicit function in Implicitron. We will see\n",
+        "* some of the main objects in Implicitron\n",
+        "* how to plug in a custom part of a model"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "customInput": null,
+        "originalKey": "51337c0e-ad27-4b75-ad6a-737dca5d7b95",
+        "showInput": false
+      },
+      "source": [
+        "## 0. Install and import modules\n",
+        "\n",
+        "Ensure `torch` and `torchvision` are installed. If `pytorch3d` is not installed, install it using the following cell:\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659619898147,
+        "executionStopTime": 1659619898274,
+        "originalKey": "76f1ecd4-6b73-4214-81b0-118ef8d86872",
+        "requestMsgId": "deb6a860-6923-4227-abef-d31388b5142d",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "import sys\n",
+        "import torch\n",
+        "import subprocess\n",
+        "need_pytorch3d=False\n",
+        "try:\n",
+        "    import pytorch3d\n",
+        "except ModuleNotFoundError:\n",
+        "    need_pytorch3d=True\n",
+        "if need_pytorch3d:\n",
+        "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+        "    version_str=\"\".join([\n",
+        "        f\"py3{sys.version_info.minor}_cu\",\n",
+        "        torch.version.cuda.replace(\".\",\"\"),\n",
+        "        f\"_pyt{pyt_version_str}\"\n",
+        "    ])\n",
+        "    !pip install iopath\n",
+        "    if sys.platform.startswith(\"linux\"):\n",
+        "        print(\"Trying to install wheel for PyTorch3D\")\n",
+        "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
+        "        pip_list = !pip freeze\n",
+        "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+        "    if need_pytorch3d:\n",
+        "        print(f\"failed to find/install wheel for {version_str}\")\n",
+        "if need_pytorch3d:\n",
+        "    print(\"Installing PyTorch3D from source\")\n",
+        "    !pip install ninja\n",
+        "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "customInput": null,
+        "originalKey": "2c1020e6-eb4a-4644-9719-9147500d8e4f",
+        "showInput": false
+      },
+      "source": [
+        "Ensure omegaconf and visdom are installed. If not, run this cell. (It should not be necessary to restart the runtime.)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "customInput": null,
+        "customOutput": null,
+        "originalKey": "9e751931-a38d-44c9-9ff1-ac2f7d3a3f99",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "!pip install omegaconf visdom"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "code_folding": [],
+        "collapsed": false,
+        "customOutput": null,
+        "executionStartTime": 1659612480556,
+        "executionStopTime": 1659612480644,
+        "hidden_ranges": [],
+        "originalKey": "86807e4a-1675-4520-a033-c7af85b233ec",
+        "requestMsgId": "880a7e20-4a90-4b37-a5eb-bccc0b23cac6"
+      },
+      "outputs": [],
+      "source": [
+        "import logging\n",
+        "from typing import Tuple\n",
+        "\n",
+        "import matplotlib.animation as animation\n",
+        "import matplotlib.pyplot as plt\n",
+        "import numpy as np\n",
+        "import torch\n",
+        "import tqdm\n",
+        "from IPython.display import HTML\n",
+        "from omegaconf import OmegaConf\n",
+        "from PIL import Image\n",
+        "from pytorch3d.implicitron.dataset.dataset_base import FrameData\n",
+        "from pytorch3d.implicitron.dataset.rendered_mesh_dataset_map_provider import RenderedMeshDatasetMapProvider\n",
+        "from pytorch3d.implicitron.models.generic_model import GenericModel\n",
+        "from pytorch3d.implicitron.models.implicit_function.base import ImplicitFunctionBase, ImplicitronRayBundle\n",
+        "from pytorch3d.implicitron.models.renderer.base import EvaluationMode\n",
+        "from pytorch3d.implicitron.tools.config import get_default_args, registry, remove_unused_components\n",
+        "from pytorch3d.renderer.implicit.renderer import VolumeSampler\n",
+        "from pytorch3d.structures import Volumes\n",
+        "from pytorch3d.vis.plotly_vis import plot_batch_individually, plot_scene"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "code_folding": [],
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659610929375,
+        "executionStopTime": 1659610929383,
+        "hidden_ranges": [],
+        "originalKey": "b2d9f5bd-a9d4-4f78-b21e-92f2658e0fe9",
+        "requestMsgId": "7e43e623-4030-438b-af4e-b96170c9a052",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "output_resolution = 80"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "code_folding": [],
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659610930042,
+        "executionStopTime": 1659610930050,
+        "hidden_ranges": [],
+        "originalKey": "0b0c2087-4c86-4c57-b0ee-6f48a70a9c78",
+        "requestMsgId": "46883aad-f00b-4fd4-ac17-eec0b2ac272a",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "torch.set_printoptions(sci_mode=False)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "customInput": null,
+        "originalKey": "37809d0d-b02e-42df-85b6-cdd038373653",
+        "showInput": false
+      },
+      "source": [
+        "## 1. Load renders of a mesh (the cow mesh) as a dataset\n",
+        "\n",
+        "A dataset's train, val and test parts in Implicitron are represented as a `dataset_map`, and provided by an implementation of `DatasetMapProvider`. \n",
+        "`RenderedMeshDatasetMapProvider` is one which generates a single-scene dataset with only a train component by taking a mesh and rendering it.\n",
+        "We use it with the cow mesh."
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659620739780,
+        "executionStopTime": 1659620739914,
+        "originalKey": "cc68cb9c-b8bf-4e9e-bef1-2cfafdf6caa2",
+        "requestMsgId": "398cfcae-5d43-4b6f-9c75-db3d297364d4",
+        "showInput": false
+      },
+      "source": [
+        "If running this notebook using **Google Colab**, run the following cell to fetch the mesh obj and texture files and save it at the path data/cow_mesh.\n",
+        "If running locally, the data is already available at the correct path."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "customInput": null,
+        "customOutput": null,
+        "originalKey": "2c55e002-a885-4169-8fdc-af9078b05968",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "!mkdir -p data/cow_mesh\n",
+        "!wget -P data/cow_mesh https://dl.fbaipublicfiles.com/pytorch3d/data/cow_mesh/cow.obj\n",
+        "!wget -P data/cow_mesh https://dl.fbaipublicfiles.com/pytorch3d/data/cow_mesh/cow.mtl\n",
+        "!wget -P data/cow_mesh https://dl.fbaipublicfiles.com/pytorch3d/data/cow_mesh/cow_texture.png"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "code_folding": [],
+        "collapsed": false,
+        "customOutput": null,
+        "executionStartTime": 1659621652237,
+        "executionStopTime": 1659621652903,
+        "hidden_ranges": [],
+        "originalKey": "eb77aaec-048c-40bd-bd69-0e66b6ab60b1",
+        "requestMsgId": "09b9975c-ff86-41c9-b4a9-975d23afc562",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "cow_provider = RenderedMeshDatasetMapProvider(\n",
+        "    data_file=\"data/cow_mesh/cow.obj\",\n",
+        "    use_point_light=False,\n",
+        "    resolution=output_resolution,\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "code_folding": [],
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659610966145,
+        "executionStopTime": 1659610966255,
+        "hidden_ranges": [],
+        "originalKey": "8210e15b-da48-4306-a49a-41c4e7e7d42f",
+        "requestMsgId": "c243edd2-a106-4fba-8471-dfa4f99a2088",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "dataset_map = cow_provider.get_dataset_map()\n",
+        "tr_cameras = [training_frame.camera for training_frame in dataset_map.train]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "code_folding": [],
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659610967703,
+        "executionStopTime": 1659610967848,
+        "hidden_ranges": [],
+        "originalKey": "458d72ad-d9a7-4f13-b5b7-90d2aec61c16",
+        "requestMsgId": "7f9431f3-8717-4d89-a7fe-1420dd0e00c4",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "# The cameras are all in the XZ plane, in a circle about 2.7 from the origin\n",
+        "centers = torch.cat([i.get_camera_center() for i in tr_cameras])\n",
+        "print(centers.min(0).values)\n",
+        "print(centers.max(0).values)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "code_folding": [],
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659552920194,
+        "executionStopTime": 1659552923122,
+        "hidden_ranges": [],
+        "originalKey": "931e712b-b141-437a-97fb-dc2a07ce3458",
+        "requestMsgId": "931e712b-b141-437a-97fb-dc2a07ce3458",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "# visualization of the cameras\n",
+        "plot = plot_scene({\"k\": {i: camera for i, camera in enumerate(tr_cameras)}}, camera_scale=0.25)\n",
+        "plot.layout.scene.aspectmode = \"data\"\n",
+        "plot"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "customInput": null,
+        "originalKey": "afa9c02d-f76b-4f68-83e9-9733c615406b",
+        "showInput": false
+      },
+      "source": [
+        "## 2. Custom implicit function 🧊\n",
+        "\n",
+        "At the core of neural rendering methods are functions of spatial coordinates called implicit functions, which are used in some kind of rendering process.\n",
+        "(Often those functions can additionally take other data as well, such as view direction.)\n",
+        "A common rendering process is ray marching over densities and colors provided by an implicit function.\n",
+        "In our case, taking samples from a 3D volume grid is a very simple function of spatial coordinates. \n",
+        "\n",
+        "Here we define our own implicit function, which uses PyTorch3D's existing functionality for sampling from a volume grid.\n",
+        "We do this by subclassing `ImplicitFunctionBase`.\n",
+        "We need to register our subclass with a special decorator.\n",
+        "We use Python's dataclass annotations for configuring the module."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "code_folding": [],
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659613575850,
+        "executionStopTime": 1659613575940,
+        "hidden_ranges": [],
+        "originalKey": "61b55043-dc52-4de7-992e-e2195edd2123",
+        "requestMsgId": "dfaace3c-098c-4ffe-9240-6a7ae0ff271e",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "@registry.register\n",
+        "class MyVolumes(ImplicitFunctionBase, torch.nn.Module):\n",
+        "    grid_resolution: int = 50  # common HWD of volumes, the number of voxels in each direction\n",
+        "    extent: float = 1.0  # In world coordinates, the volume occupies is [-extent, extent] along each axis\n",
+        "\n",
+        "    def __post_init__(self):\n",
+        "        # We have to call this explicitly if there are other base classes like Module\n",
+        "        super().__init__()\n",
+        "\n",
+        "        # We define parameters like other torch.nn.Module objects.\n",
+        "        # In this case, both our parameter tensors are trainable; they govern the contents of the volume grid.\n",
+        "        density = torch.full((self.grid_resolution, self.grid_resolution, self.grid_resolution), -2.0)\n",
+        "        self.density = torch.nn.Parameter(density)\n",
+        "        color = torch.full((3, self.grid_resolution, self.grid_resolution, self.grid_resolution), 0.0)\n",
+        "        self.color = torch.nn.Parameter(color)\n",
+        "        self.density_activation = torch.nn.Softplus()\n",
+        "\n",
+        "    def forward(\n",
+        "        self,\n",
+        "        ray_bundle: ImplicitronRayBundle,\n",
+        "        fun_viewpool=None,\n",
+        "        global_code=None,\n",
+        "    ):\n",
+        "        densities = self.density_activation(self.density[None, None])\n",
+        "        voxel_size = 2.0 * float(self.extent) / self.grid_resolution\n",
+        "        features = self.color.sigmoid()[None]\n",
+        "\n",
+        "        # Like other PyTorch3D structures, the actual Volumes object should only exist as long\n",
+        "        # as one iteration of training. It is local to this function.\n",
+        "\n",
+        "        volume = Volumes(densities=densities, features=features, voxel_size=voxel_size)\n",
+        "        sampler = VolumeSampler(volumes=volume)\n",
+        "        densities, features = sampler(ray_bundle)\n",
+        "\n",
+        "        # When an implicit function is used for raymarching, i.e. for MultiPassEmissionAbsorptionRenderer,\n",
+        "        # it must return (densities, features, an auxiliary tuple)\n",
+        "        return densities, features, {}\n"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "customInput": null,
+        "originalKey": "abaf2cd6-1b68-400e-a142-8fb9f49953f3",
+        "showInput": false
+      },
+      "source": [
+        "## 3. Construct the model object.\n",
+        "\n",
+        "The main model object in PyTorch3D is `GenericModel`, which has pluggable components for the major steps, including the renderer and the implicit function(s).\n",
+        "There are two ways to construct it which are equivalent here."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659621267561,
+        "executionStopTime": 1659621267938,
+        "originalKey": "f26c3dce-fbae-4592-bd0e-e4a8abc57c2c",
+        "requestMsgId": "9213687e-1caf-46a8-a4e5-a9c531530092",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "CONSTRUCT_MODEL_FROM_CONFIG = True\n",
+        "if CONSTRUCT_MODEL_FROM_CONFIG:\n",
+        "    # Via a DictConfig - this is how our training loop with hydra works\n",
+        "    cfg = get_default_args(GenericModel)\n",
+        "    cfg.implicit_function_class_type = \"MyVolumes\"\n",
+        "    cfg.render_image_height=output_resolution\n",
+        "    cfg.render_image_width=output_resolution\n",
+        "    cfg.loss_weights={\"loss_rgb_huber\": 1.0}\n",
+        "    cfg.tqdm_trigger_threshold=19000\n",
+        "    cfg.raysampler_AdaptiveRaySampler_args.scene_extent= 4.0\n",
+        "    gm = GenericModel(**cfg)\n",
+        "else:\n",
+        "    # constructing GenericModel directly\n",
+        "    gm = GenericModel(\n",
+        "        implicit_function_class_type=\"MyVolumes\",\n",
+        "        render_image_height=output_resolution,\n",
+        "        render_image_width=output_resolution,\n",
+        "        loss_weights={\"loss_rgb_huber\": 1.0},\n",
+        "        tqdm_trigger_threshold=19000,\n",
+        "        raysampler_AdaptiveRaySampler_args = {\"scene_extent\": 4.0}\n",
+        "    )\n",
+        "\n",
+        "    # In this case we can get the equivalent DictConfig cfg object to the way gm is configured as follows\n",
+        "    cfg = OmegaConf.structured(gm)\n"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "code_folding": [],
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659611214689,
+        "executionStopTime": 1659611214748,
+        "hidden_ranges": [],
+        "originalKey": "4e659f7d-ce66-4999-83de-005eb09d7705",
+        "requestMsgId": "7b815b2b-cf19-44d0-ae89-76fde6df35ec",
+        "showInput": false
+      },
+      "source": [
+        " The default renderer is an emission-absorbtion raymarcher. We keep that default."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "code_folding": [],
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659621268007,
+        "executionStopTime": 1659621268190,
+        "hidden_ranges": [],
+        "originalKey": "d37ae488-c57c-44d3-9def-825dc1a6495b",
+        "requestMsgId": "71143ec1-730f-4876-8a14-e46eea9d6dd1",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "# We can display the configuration in use as follows.\n",
+        "remove_unused_components(cfg)\n",
+        "yaml = OmegaConf.to_yaml(cfg, sort_keys=False)\n",
+        "%page -r yaml"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "code_folding": [],
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659621268727,
+        "executionStopTime": 1659621268776,
+        "hidden_ranges": [],
+        "originalKey": "52e53179-3c6e-4c1f-a38a-3a6d803687bb",
+        "requestMsgId": "05de9bc3-3f74-4a6f-851c-9ec919b59506",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "device = torch.device(\"cuda:0\")\n",
+        "gm.to(device)\n",
+        "assert next(gm.parameters()).is_cuda"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "customInput": null,
+        "originalKey": "528a7d53-c645-49c2-9021-09adbb18cd23",
+        "showInput": false
+      },
+      "source": [
+        "## 4. train the model "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "code_folding": [],
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659621270236,
+        "executionStopTime": 1659621270446,
+        "hidden_ranges": [],
+        "originalKey": "953280bd-3161-42ba-8dcb-0c8ef2d5cc25",
+        "requestMsgId": "9bba424b-7bfd-4e5a-9d79-ae316e20bab0",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "train_data_collated = [FrameData.collate([frame.to(device)]) for frame in dataset_map.train]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "code_folding": [],
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659621270815,
+        "executionStopTime": 1659621270948,
+        "hidden_ranges": [],
+        "originalKey": "2fcf07f0-0c28-49c7-8c76-1c9a9d810167",
+        "requestMsgId": "821deb43-6084-4ece-83c3-dee214562c47",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "gm.train()\n",
+        "optimizer = torch.optim.Adam(gm.parameters(), lr=0.1)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "code_folding": [],
+        "collapsed": false,
+        "customOutput": null,
+        "executionStartTime": 1659621271875,
+        "executionStopTime": 1659621298146,
+        "hidden_ranges": [],
+        "originalKey": "105099f7-ed0c-4e7f-a976-61a93fd0a8fe",
+        "requestMsgId": "0c87c108-83e3-4129-ad02-85e0140f1368",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "iterator = tqdm.tqdm(range(2000))\n",
+        "for n_batch in iterator:\n",
+        "    optimizer.zero_grad()\n",
+        "\n",
+        "    frame = train_data_collated[n_batch % len(dataset_map.train)]\n",
+        "    out = gm(**frame, evaluation_mode=EvaluationMode.TRAINING)\n",
+        "    out[\"objective\"].backward()\n",
+        "    if n_batch % 100 == 0:\n",
+        "        iterator.set_postfix_str(f\"loss: {float(out['objective']):.5f}\")\n",
+        "    optimizer.step()"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659535024768,
+        "executionStopTime": 1659535024906,
+        "originalKey": "e3cd494a-536b-48bc-8290-c048118c82eb",
+        "requestMsgId": "e3cd494a-536b-48bc-8290-c048118c82eb",
+        "showInput": false
+      },
+      "source": [
+        "## 5. Evaluate the module\n",
+        "\n",
+        "We generate complete images from all the viewpoints to see how they look."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "code_folding": [],
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659621299859,
+        "executionStopTime": 1659621311133,
+        "hidden_ranges": [],
+        "originalKey": "fbe1b2ea-cc24-4b20-a2d7-0249185e34a5",
+        "requestMsgId": "771ef1f8-5eee-4932-9e81-33604bf0512a",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "def to_numpy_image(image):\n",
+        "    # Takes an image of shape (C, H, W) in [0,1], where C=3 or 1\n",
+        "    # to a numpy uint image of shape (H, W, 3)\n",
+        "    return (image * 255).to(torch.uint8).permute(1, 2, 0).detach().cpu().expand(-1, -1, 3).numpy()\n",
+        "def resize_image(image):\n",
+        "    # Takes images of shape (B, C, H, W) to (B, C, output_resolution, output_resolution)\n",
+        "    return torch.nn.functional.interpolate(image, size=(output_resolution, output_resolution))\n",
+        "\n",
+        "gm.eval()\n",
+        "images = []\n",
+        "expected = []\n",
+        "masks = []\n",
+        "masks_expected = []\n",
+        "for frame in tqdm.tqdm(train_data_collated):\n",
+        "    with torch.no_grad():\n",
+        "        out = gm(**frame, evaluation_mode=EvaluationMode.EVALUATION)\n",
+        "\n",
+        "    image_rgb = to_numpy_image(out[\"images_render\"][0])\n",
+        "    mask = to_numpy_image(out[\"masks_render\"][0])\n",
+        "    expd = to_numpy_image(resize_image(frame.image_rgb)[0])\n",
+        "    mask_expected = to_numpy_image(resize_image(frame.fg_probability)[0])\n",
+        "\n",
+        "    images.append(image_rgb)\n",
+        "    masks.append(mask)\n",
+        "    expected.append(expd)\n",
+        "    masks_expected.append(mask_expected)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659614622542,
+        "executionStopTime": 1659614622757,
+        "originalKey": "24953039-9780-40fd-bd81-5d63e9f40069",
+        "requestMsgId": "7af895a3-dfe4-4c28-ac3b-4ff0fbb40c7f",
+        "showInput": false
+      },
+      "source": [
+        "We draw a grid showing predicted image and expected image, followed by predicted mask and expected mask, from each viewpoint. \n",
+        "This is a grid of four rows of images, wrapped in to several large rows, i.e..\n",
+        "<small><center>\n",
+        "```\n",
+        "┌────────┬────────┐           ┌────────┐\n",
+        "│pred    │pred    │           │pred    │\n",
+        "│image   │image   │           │image   │\n",
+        "│1       │2       │           │n       │\n",
+        "├────────┼────────┤           ├────────┤\n",
+        "│expected│expected│           │expected│\n",
+        "│image   │image   │  ...      │image   │\n",
+        "│1       │2       │           │n       │\n",
+        "├────────┼────────┤           ├────────┤\n",
+        "│pred    │pred    │           │pred    │\n",
+        "│mask    │mask    │           │mask    │\n",
+        "│1       │2       │           │n       │\n",
+        "├────────┼────────┤           ├────────┤\n",
+        "│expected│expected│           │expected│\n",
+        "│mask    │mask    │           │mask    │\n",
+        "│1       │2       │           │n       │\n",
+        "├────────┼────────┤           ├────────┤\n",
+        "│pred    │pred    │           │pred    │\n",
+        "│image   │image   │           │image   │\n",
+        "│n+1     │n+1     │           │2n      │\n",
+        "├────────┼────────┤           ├────────┤\n",
+        "│expected│expected│           │expected│\n",
+        "│image   │image   │  ...      │image   │\n",
+        "│n+1     │n+2     │           │2n      │\n",
+        "├────────┼────────┤           ├────────┤\n",
+        "│pred    │pred    │           │pred    │\n",
+        "│mask    │mask    │           │mask    │\n",
+        "│n+1     │n+2     │           │2n      │\n",
+        "├────────┼────────┤           ├────────┤\n",
+        "│expected│expected│           │expected│\n",
+        "│mask    │mask    │           │mask    │\n",
+        "│n+1     │n+2     │           │2n      │\n",
+        "└────────┴────────┘           └────────┘\n",
+        "           ...\n",
+        "```\n",
+        "</center></small>"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "code_folding": [],
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659621313894,
+        "executionStopTime": 1659621314042,
+        "hidden_ranges": [],
+        "originalKey": "c488a34a-e46d-4649-93fb-4b1bb5a0e439",
+        "requestMsgId": "4221e632-fca1-4fe5-b2e3-f92c37aa40e4",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "images_to_display = [images.copy(), expected.copy(), masks.copy(), masks_expected.copy()]\n",
+        "n_rows = 4\n",
+        "n_images = len(images)\n",
+        "blank_image = images[0] * 0\n",
+        "n_per_row = 1+(n_images-1)//n_rows\n",
+        "for _ in range(n_per_row*n_rows - n_images):\n",
+        "    for group in images_to_display:\n",
+        "        group.append(blank_image)\n",
+        "\n",
+        "images_to_display_listed = [[[i] for i in j] for j in images_to_display]\n",
+        "split = []\n",
+        "for row in range(n_rows):\n",
+        "    for group in images_to_display_listed:\n",
+        "        split.append(group[row*n_per_row:(row+1)*n_per_row])  \n",
+        "\n",
+        "Image.fromarray(np.block(split))\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "code_folding": [],
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659621323795,
+        "executionStopTime": 1659621323820,
+        "hidden_ranges": [],
+        "originalKey": "49eab9e1-4fe2-4fbe-b4f3-7b6953340170",
+        "requestMsgId": "85b402ad-f903-431f-a13e-c2d697e869bb",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "# Print the maximum channel intensity in the first image.\n",
+        "print(images[1].max()/255)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "code_folding": [],
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659621408642,
+        "executionStopTime": 1659621409559,
+        "hidden_ranges": [],
+        "originalKey": "137d2c43-d39d-4266-ac5e-2b714da5e0ee",
+        "requestMsgId": "8e27ec57-c2d6-4ae0-be69-b63b6af929ff",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "plt.ioff()\n",
+        "fig, ax = plt.subplots(figsize=(3,3))\n",
+        "\n",
+        "ax.grid(None)\n",
+        "ims = [[ax.imshow(im, animated=True)] for im in images]\n",
+        "ani = animation.ArtistAnimation(fig, ims, interval=80, blit=True)\n",
+        "ani_html = ani.to_jshtml()\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659621409620,
+        "executionStopTime": 1659621409725,
+        "originalKey": "783e70d6-7cf1-4d76-a126-ba11ffc2f5be",
+        "requestMsgId": "b6843506-c5fa-4508-80fc-8ecae51a934a",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "HTML(ani_html)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1659614670081,
+        "executionStopTime": 1659614670168,
+        "originalKey": "0286c350-2362-4f47-8181-2fc2ba51cfcf",
+        "requestMsgId": "976f4db9-d4c7-466c-bcfd-218234400226",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "# If you want to see the output of the model with the volume forced to opaque white, run this and re-evaluate\n",
+        "# with torch.no_grad():\n",
+        "#      gm._implicit_functions[0]._fn.density.fill_(9.0)\n",
+        "#      gm._implicit_functions[0]._fn.color.fill_(9.0)\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "bento_stylesheets": {
+      "bento/extensions/flow/main.css": true,
+      "bento/extensions/kernel_selector/main.css": true,
+      "bento/extensions/kernel_ui/main.css": true,
+      "bento/extensions/new_kernel/main.css": true,
+      "bento/extensions/system_usage/main.css": true,
+      "bento/extensions/theme/main.css": true
+    },
+    "captumWidgetMessage": {},
+    "dataExplorerConfig": {},
+    "kernelspec": {
+      "display_name": "pytorch3d",
+      "language": "python",
+      "metadata": {
+        "cinder_runtime": false,
+        "fbpkg_supported": true,
+        "is_prebuilt": true,
+        "kernel_name": "bento_kernel_pytorch3d",
+        "nightly_builds": true
+      },
+      "name": "bento_kernel_pytorch3d"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3"
+    },
+    "last_base_url": "https://9177.od.fbinfra.net:443/",
+    "last_kernel_id": "bb33cd83-7924-489a-8bd8-2d9d62eb0126",
+    "last_msg_id": "99f7088e-d22b355b859660479ef0574e_5743",
+    "last_server_session_id": "2944b203-9ea8-4c0e-9634-645dfea5f26b",
+    "outputWidgetContext": {}
+  },
+  "nbformat": 4,
+  "nbformat_minor": 2
+}

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/tutorials/render_colored_points.ipynb

@@ -0,0 +1,485 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Copyright (c) Meta Platforms, Inc. and affiliates. All rights reserved."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Render a colored point cloud\n",
+    "\n",
+    "This tutorial shows how to:\n",
+    "- set up a renderer \n",
+    "- render the point cloud \n",
+    "- vary the rendering settings such as compositing and camera position"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Import modules"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Ensure `torch` and `torchvision` are installed. If `pytorch3d` is not installed, install it using the following cell:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import sys\n",
+    "import torch\n",
+    "import subprocess\n",
+    "need_pytorch3d=False\n",
+    "try:\n",
+    "    import pytorch3d\n",
+    "except ModuleNotFoundError:\n",
+    "    need_pytorch3d=True\n",
+    "if need_pytorch3d:\n",
+    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    version_str=\"\".join([\n",
+    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        f\"_pyt{pyt_version_str}\"\n",
+    "    ])\n",
+    "    !pip install iopath\n",
+    "    if sys.platform.startswith(\"linux\"):\n",
+    "        print(\"Trying to install wheel for PyTorch3D\")\n",
+    "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
+    "        pip_list = !pip freeze\n",
+    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "    if need_pytorch3d:\n",
+    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "if need_pytorch3d:\n",
+    "    print(\"Installing PyTorch3D from source\")\n",
+    "    !pip install ninja\n",
+    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import torch\n",
+    "import torch.nn.functional as F\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Util function for loading point clouds|\n",
+    "import numpy as np\n",
+    "\n",
+    "# Data structures and functions for rendering\n",
+    "from pytorch3d.structures import Pointclouds\n",
+    "from pytorch3d.vis.plotly_vis import AxisArgs, plot_batch_individually, plot_scene\n",
+    "from pytorch3d.renderer import (\n",
+    "    look_at_view_transform,\n",
+    "    FoVOrthographicCameras, \n",
+    "    PointsRasterizationSettings,\n",
+    "    PointsRenderer,\n",
+    "    PulsarPointsRenderer,\n",
+    "    PointsRasterizer,\n",
+    "    AlphaCompositor,\n",
+    "    NormWeightedCompositor\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Load a point cloud and corresponding colors\n",
+    "\n",
+    "Load and create a **Point Cloud** object. \n",
+    "\n",
+    "**Pointclouds** is a unique datastructure provided in PyTorch3D for working with batches of point clouds of different sizes. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If running this notebook using **Google Colab**, run the following cell to fetch the pointcloud data and save it at the path `data/PittsburghBridge`:\n",
+    "If running locally, the data is already available at the correct path. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!mkdir -p data/PittsburghBridge\n",
+    "!wget -P data/PittsburghBridge https://dl.fbaipublicfiles.com/pytorch3d/data/PittsburghBridge/pointcloud.npz"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Setup\n",
+    "if torch.cuda.is_available():\n",
+    "    device = torch.device(\"cuda:0\")\n",
+    "    torch.cuda.set_device(device)\n",
+    "else:\n",
+    "    device = torch.device(\"cpu\")\n",
+    "\n",
+    "# Set paths\n",
+    "DATA_DIR = \"./data\"\n",
+    "obj_filename = os.path.join(DATA_DIR, \"PittsburghBridge/pointcloud.npz\")\n",
+    "\n",
+    "# Load point cloud\n",
+    "pointcloud = np.load(obj_filename)\n",
+    "verts = torch.Tensor(pointcloud['verts']).to(device)\n",
+    "        \n",
+    "rgb = torch.Tensor(pointcloud['rgb']).to(device)\n",
+    "\n",
+    "point_cloud = Pointclouds(points=[verts], features=[rgb])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create a renderer\n",
+    "\n",
+    "A renderer in PyTorch3D is composed of a **rasterizer** and a **shader** which each have a number of subcomponents such as a **camera** (orthographic/perspective). Here we initialize some of these components and use default values for the rest.\n",
+    "\n",
+    "In this example we will first create a **renderer** which uses an **orthographic camera**, and applies **alpha compositing**. Then we learn how to vary different components using the modular API.  \n",
+    "\n",
+    "[1] <a href=\"https://arxiv.org/abs/1912.08804\">SynSin: End to end View Synthesis from a Single Image.</a> Olivia Wiles, Georgia Gkioxari, Richard Szeliski, Justin Johnson. CVPR 2020."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Initialize a camera.\n",
+    "R, T = look_at_view_transform(20, 10, 0)\n",
+    "cameras = FoVOrthographicCameras(device=device, R=R, T=T, znear=0.01)\n",
+    "\n",
+    "# Define the settings for rasterization and shading. Here we set the output image to be of size\n",
+    "# 512x512. As we are rendering images for visualization purposes only we will set faces_per_pixel=1\n",
+    "# and blur_radius=0.0. Refer to raster_points.py for explanations of these parameters. \n",
+    "raster_settings = PointsRasterizationSettings(\n",
+    "    image_size=512, \n",
+    "    radius = 0.003,\n",
+    "    points_per_pixel = 10\n",
+    ")\n",
+    "\n",
+    "\n",
+    "# Create a points renderer by compositing points using an alpha compositor (nearer points\n",
+    "# are weighted more heavily). See [1] for an explanation.\n",
+    "rasterizer = PointsRasterizer(cameras=cameras, raster_settings=raster_settings)\n",
+    "renderer = PointsRenderer(\n",
+    "    rasterizer=rasterizer,\n",
+    "    compositor=AlphaCompositor()\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "images = renderer(point_cloud)\n",
+    "plt.figure(figsize=(10, 10))\n",
+    "plt.imshow(images[0, ..., :3].cpu().numpy())\n",
+    "plt.axis(\"off\");"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will now modify the **renderer** to use **alpha compositing** with a set background color. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "renderer = PointsRenderer(\n",
+    "    rasterizer=rasterizer,\n",
+    "    # Pass in background_color to the alpha compositor, setting the background color \n",
+    "    # to the 3 item tuple, representing rgb on a scale of 0 -> 1, in this case blue\n",
+    "    compositor=AlphaCompositor(background_color=(0, 0, 1))\n",
+    ")\n",
+    "images = renderer(point_cloud)\n",
+    "\n",
+    "plt.figure(figsize=(10, 10))\n",
+    "plt.imshow(images[0, ..., :3].cpu().numpy())\n",
+    "plt.axis(\"off\");"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this example we will first create a **renderer** which uses an **orthographic camera**, and applies **weighted compositing**. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Initialize a camera.\n",
+    "R, T = look_at_view_transform(20, 10, 0)\n",
+    "cameras = FoVOrthographicCameras(device=device, R=R, T=T, znear=0.01)\n",
+    "\n",
+    "# Define the settings for rasterization and shading. Here we set the output image to be of size\n",
+    "# 512x512. As we are rendering images for visualization purposes only we will set faces_per_pixel=1\n",
+    "# and blur_radius=0.0. Refer to rasterize_points.py for explanations of these parameters. \n",
+    "raster_settings = PointsRasterizationSettings(\n",
+    "    image_size=512, \n",
+    "    radius = 0.003,\n",
+    "    points_per_pixel = 10\n",
+    ")\n",
+    "\n",
+    "\n",
+    "# Create a points renderer by compositing points using an weighted compositor (3D points are\n",
+    "# weighted according to their distance to a pixel and accumulated using a weighted sum)\n",
+    "renderer = PointsRenderer(\n",
+    "    rasterizer=PointsRasterizer(cameras=cameras, raster_settings=raster_settings),\n",
+    "    compositor=NormWeightedCompositor()\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "images = renderer(point_cloud)\n",
+    "plt.figure(figsize=(10, 10))\n",
+    "plt.imshow(images[0, ..., :3].cpu().numpy())\n",
+    "plt.axis(\"off\");"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will now modify the **renderer** to use **weighted compositing** with a set background color. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "renderer = PointsRenderer(\n",
+    "    rasterizer=PointsRasterizer(cameras=cameras, raster_settings=raster_settings),\n",
+    "    # Pass in background_color to the norm weighted compositor, setting the background color \n",
+    "    # to the 3 item tuple, representing rgb on a scale of 0 -> 1, in this case red\n",
+    "    compositor=NormWeightedCompositor(background_color=(1,0,0))\n",
+    ")\n",
+    "images = renderer(point_cloud)\n",
+    "plt.figure(figsize=(10, 10))\n",
+    "plt.imshow(images[0, ..., :3].cpu().numpy())\n",
+    "plt.axis(\"off\");"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Using the pulsar backend\n",
+    "\n",
+    "Switching to the pulsar backend is easy! The pulsar backend has a compositor built-in, so the `compositor` argument is not required when creating it (a warning will be displayed if you provide it nevertheless). It pre-allocates memory on the rendering device, that's why it needs the `n_channels` at construction time.\n",
+    "\n",
+    "All parameters for the renderer forward function are batch-wise except the background color (in this example, `gamma`) and you have to provide as many values as you have examples in your batch. The background color is optional and by default set to all zeros. You can find a detailed explanation of how gamma influences the rendering function here in the paper [Fast Differentiable Raycasting for Neural Rendering using\n",
+    "Sphere-based Representations](https://arxiv.org/pdf/2004.07484.pdf).\n",
+    "\n",
+    "You can also use the `native` backend for the pulsar backend which already provides access to point opacity. The native backend can be imported from `pytorch3d.renderer.points.pulsar`; you can find examples for this in the folder `docs/examples`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "renderer = PulsarPointsRenderer(\n",
+    "    rasterizer=PointsRasterizer(cameras=cameras, raster_settings=raster_settings),\n",
+    "    n_channels=4\n",
+    ").to(device)\n",
+    "\n",
+    "images = renderer(point_cloud, gamma=(1e-4,),\n",
+    "                  bg_col=torch.tensor([0.0, 1.0, 0.0, 1.0], dtype=torch.float32, device=device))\n",
+    "plt.figure(figsize=(10, 10))\n",
+    "plt.imshow(images[0, ..., :3].cpu().numpy())\n",
+    "plt.axis(\"off\");"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### View pointclouds in Plotly figures\n",
+    "\n",
+    "Here we use the PyTorch3D function `plot_scene` to render the pointcloud in a Plotly figure. `plot_scene` returns a plotly figure with trace and subplots defined by the input."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plot_scene({\n",
+    "    \"Pointcloud\": {\n",
+    "        \"person\": point_cloud\n",
+    "    }\n",
+    "})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will now render a batch of pointclouds. The first pointcloud is the same as above, and the second is all-black and offset by 2 in all dimensions so we can see them on the same plot. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "point_cloud_batch = Pointclouds(points=[verts, verts + 2], features=[rgb, torch.zeros_like(rgb)])\n",
+    "# render both in the same plot in different traces\n",
+    "fig = plot_scene({\n",
+    "    \"Pointcloud\": {\n",
+    "        \"person\": point_cloud_batch[0],\n",
+    "        \"person2\": point_cloud_batch[1]\n",
+    "    }\n",
+    "})\n",
+    "fig.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# render both in the same plot in one trace\n",
+    "fig = plot_scene({\n",
+    "    \"Pointcloud\": {\n",
+    "        \"2 people\": point_cloud_batch\n",
+    "    }\n",
+    "})\n",
+    "fig.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For batches, we can also use `plot_batch_individually` to avoid constructing the scene dictionary ourselves."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# render both in 1 row in different subplots\n",
+    "fig2 = plot_batch_individually(point_cloud_batch, ncols=2)\n",
+    "fig2.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# modify the plotly figure height and width\n",
+    "fig2.update_layout(height=500, width=500)\n",
+    "fig2.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also modify the axis arguments and axis backgrounds for either function, and title our plots in `plot_batch_individually`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig3 = plot_batch_individually(\n",
+    "    point_cloud_batch, \n",
+    "    xaxis={\"backgroundcolor\":\"rgb(200, 200, 230)\"},\n",
+    "    yaxis={\"backgroundcolor\":\"rgb(230, 200, 200)\"},\n",
+    "    zaxis={\"backgroundcolor\":\"rgb(200, 230, 200)\"}, \n",
+    "    subplot_titles=[\"Pointcloud1\", \"Pointcloud2\"], # this should have a title for each subplot, titles can be \"\"\n",
+    "    axis_args=AxisArgs(showgrid=True))\n",
+    "fig3.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "bento_stylesheets": {
+   "bento/extensions/flow/main.css": true,
+   "bento/extensions/kernel_selector/main.css": true,
+   "bento/extensions/kernel_ui/main.css": true,
+   "bento/extensions/new_kernel/main.css": true,
+   "bento/extensions/system_usage/main.css": true,
+   "bento/extensions/theme/main.css": true
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/docs/tutorials/render_densepose.ipynb

@@ -0,0 +1,441 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Copyright (c) Meta Platforms, Inc. and affiliates. All rights reserved."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Render DensePose \n",
+    "\n",
+    "DensePose refers to dense human pose representation: https://github.com/facebookresearch/DensePose. \n",
+    "In this tutorial, we provide an example of using DensePose data in PyTorch3D.\n",
+    "\n",
+    "This tutorial shows how to:\n",
+    "- load a mesh and textures from densepose `.mat` and `.pkl` files\n",
+    "- set up a renderer \n",
+    "- render the mesh \n",
+    "- vary the rendering settings such as lighting and camera position"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "Bnj3THhzfBLf"
+   },
+   "source": [
+    "## Import modules"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Ensure `torch` and `torchvision` are installed. If `pytorch3d` is not installed, install it using the following cell:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import sys\n",
+    "import torch\n",
+    "import subprocess\n",
+    "need_pytorch3d=False\n",
+    "try:\n",
+    "    import pytorch3d\n",
+    "except ModuleNotFoundError:\n",
+    "    need_pytorch3d=True\n",
+    "if need_pytorch3d:\n",
+    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    version_str=\"\".join([\n",
+    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        f\"_pyt{pyt_version_str}\"\n",
+    "    ])\n",
+    "    !pip install iopath\n",
+    "    if sys.platform.startswith(\"linux\"):\n",
+    "        print(\"Trying to install wheel for PyTorch3D\")\n",
+    "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
+    "        pip_list = !pip freeze\n",
+    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "    if need_pytorch3d:\n",
+    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "if need_pytorch3d:\n",
+    "    print(\"Installing PyTorch3D from source\")\n",
+    "    !pip install ninja\n",
+    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# We also install chumpy as it is needed to load the SMPL model pickle file.\n",
+    "!pip install chumpy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import torch\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "# libraries for reading data from files\n",
+    "from scipy.io import loadmat\n",
+    "from PIL import Image\n",
+    "import pickle\n",
+    "\n",
+    "# Data structures and functions for rendering\n",
+    "from pytorch3d.structures import Meshes\n",
+    "from pytorch3d.renderer import (\n",
+    "    look_at_view_transform,\n",
+    "    FoVPerspectiveCameras, \n",
+    "    PointLights, \n",
+    "    DirectionalLights, \n",
+    "    Materials, \n",
+    "    RasterizationSettings, \n",
+    "    MeshRenderer, \n",
+    "    MeshRasterizer,  \n",
+    "    SoftPhongShader,\n",
+    "    TexturesUV\n",
+    ")\n",
+    "\n",
+    "# add path for demo utils functions \n",
+    "import sys\n",
+    "import os\n",
+    "sys.path.append(os.path.abspath(''))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load the SMPL model\n",
+    "\n",
+    "#### Download the SMPL model\n",
+    "- Go to https://smpl.is.tue.mpg.de/download.php and sign up.\n",
+    "- Download SMPL for Python Users and unzip.\n",
+    "- Copy the file male template file **'models/basicModel_m_lbs_10_207_0_v1.0.0.pkl'** to the data/DensePose/ folder.\n",
+    "   - rename the file to **'smpl_model.pkl'** or rename the string where it's commented below\n",
+    "   \n",
+    "If running this notebook using Google Colab, run the following cell to fetch the texture and UV values and save it at the correct path."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Texture image\n",
+    "!wget -P data/DensePose https://raw.githubusercontent.com/facebookresearch/DensePose/master/DensePoseData/demo_data/texture_from_SURREAL.png\n",
+    "\n",
+    "# UV_processed.mat\n",
+    "!wget https://dl.fbaipublicfiles.com/densepose/densepose_uv_data.tar.gz\n",
+    "!tar xvf densepose_uv_data.tar.gz -C data/DensePose\n",
+    "!rm densepose_uv_data.tar.gz"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Load our texture UV data and our SMPL data, with some processing to correct data values and format."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Setup\n",
+    "if torch.cuda.is_available():\n",
+    "    device = torch.device(\"cuda:0\")\n",
+    "    torch.cuda.set_device(device)\n",
+    "else:\n",
+    "    device = torch.device(\"cpu\")\n",
+    "    \n",
+    "# Set paths\n",
+    "DATA_DIR = \"./data\"\n",
+    "data_filename = os.path.join(DATA_DIR, \"DensePose/UV_Processed.mat\")\n",
+    "tex_filename = os.path.join(DATA_DIR,\"DensePose/texture_from_SURREAL.png\")\n",
+    "# rename your .pkl file or change this string\n",
+    "verts_filename = os.path.join(DATA_DIR, \"DensePose/smpl_model.pkl\")\n",
+    "\n",
+    "\n",
+    "# Load SMPL and texture data\n",
+    "with open(verts_filename, 'rb') as f:\n",
+    "    data = pickle.load(f, encoding='latin1') \n",
+    "    v_template = torch.Tensor(data['v_template']).to(device) # (6890, 3)\n",
+    "ALP_UV = loadmat(data_filename)\n",
+    "with Image.open(tex_filename) as image:\n",
+    "    np_image = np.asarray(image.convert(\"RGB\")).astype(np.float32)\n",
+    "tex = torch.from_numpy(np_image / 255.)[None].to(device)\n",
+    "\n",
+    "verts = torch.from_numpy((ALP_UV[\"All_vertices\"]).astype(int)).squeeze().to(device) # (7829,)\n",
+    "U = torch.Tensor(ALP_UV['All_U_norm']).to(device) # (7829, 1)\n",
+    "V = torch.Tensor(ALP_UV['All_V_norm']).to(device) # (7829, 1)\n",
+    "faces = torch.from_numpy((ALP_UV['All_Faces'] - 1).astype(int)).to(device)  # (13774, 3)\n",
+    "face_indices = torch.Tensor(ALP_UV['All_FaceIndices']).squeeze()  # (13774,)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Display the texture image\n",
+    "plt.figure(figsize=(10, 10))\n",
+    "plt.imshow(tex.squeeze(0).cpu())\n",
+    "plt.axis(\"off\");"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In DensePose, the body mesh is split into 24 parts. In the texture image, we can see the 24 parts are separated out into individual (200, 200) images per body part.  The convention in DensePose is that each face in the mesh is associated with a body part (given by the face_indices tensor above). The vertex UV values (in the range [0, 1]) for each face are specific to the (200, 200) size texture map for the part of the body that the mesh face corresponds to. We cannot use them directly with the entire texture map. We have to offset the vertex UV values depending on what body part the associated face corresponds to."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Map each face to a (u, v) offset\n",
+    "offset_per_part = {}\n",
+    "already_offset = set()\n",
+    "cols, rows = 4, 6\n",
+    "for i, u in enumerate(np.linspace(0, 1, cols, endpoint=False)):\n",
+    "    for j, v in enumerate(np.linspace(0, 1, rows, endpoint=False)):\n",
+    "        part = rows * i + j + 1  # parts are 1-indexed in face_indices\n",
+    "        offset_per_part[part] = (u, v)\n",
+    "\n",
+    "U_norm = U.clone()\n",
+    "V_norm = V.clone()\n",
+    "\n",
+    "# iterate over faces and offset the corresponding vertex u and v values\n",
+    "for i in range(len(faces)):\n",
+    "    face_vert_idxs = faces[i]\n",
+    "    part = face_indices[i]\n",
+    "    offset_u, offset_v = offset_per_part[int(part.item())]\n",
+    "    \n",
+    "    for vert_idx in face_vert_idxs:   \n",
+    "        # vertices are reused, but we don't want to offset multiple times\n",
+    "        if vert_idx.item() not in already_offset:\n",
+    "            # offset u value\n",
+    "            U_norm[vert_idx] = U[vert_idx] / cols + offset_u\n",
+    "            # offset v value\n",
+    "            # this also flips each part locally, as each part is upside down\n",
+    "            V_norm[vert_idx] = (1 - V[vert_idx]) / rows + offset_v\n",
+    "            # add vertex to our set tracking offsetted vertices\n",
+    "            already_offset.add(vert_idx.item())\n",
+    "\n",
+    "# invert V values\n",
+    "V_norm = 1 - V_norm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# create our verts_uv values\n",
+    "verts_uv = torch.cat([U_norm[None],V_norm[None]], dim=2) # (1, 7829, 2)\n",
+    "\n",
+    "# There are 6890 xyz vertex coordinates but 7829 vertex uv coordinates. \n",
+    "# This is because the same vertex can be shared by multiple faces where each face may correspond to a different body part.  \n",
+    "# Therefore when initializing the Meshes class,\n",
+    "# we need to map each of the vertices referenced by the DensePose faces (in verts, which is the \"All_vertices\" field)\n",
+    "# to the correct xyz coordinate in the SMPL template mesh.\n",
+    "v_template_extended = v_template[verts-1][None] # (1, 7829, 3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Create our textured mesh \n",
+    "\n",
+    "**Meshes** is a unique datastructure provided in PyTorch3D for working with batches of meshes of different sizes.\n",
+    "\n",
+    "**TexturesUV** is an auxiliary datastructure for storing vertex uv and texture maps for meshes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "texture = TexturesUV(maps=tex, faces_uvs=faces[None], verts_uvs=verts_uv)\n",
+    "mesh = Meshes(v_template_extended, faces[None], texture)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create a renderer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Initialize a camera.\n",
+    "# World coordinates +Y up, +X left and +Z in.\n",
+    "R, T = look_at_view_transform(2.7, 0, 0) \n",
+    "cameras = FoVPerspectiveCameras(device=device, R=R, T=T)\n",
+    "\n",
+    "# Define the settings for rasterization and shading. Here we set the output image to be of size\n",
+    "# 512x512. As we are rendering images for visualization purposes only we will set faces_per_pixel=1\n",
+    "# and blur_radius=0.0. \n",
+    "raster_settings = RasterizationSettings(\n",
+    "    image_size=512, \n",
+    "    blur_radius=0.0, \n",
+    "    faces_per_pixel=1, \n",
+    ")\n",
+    "\n",
+    "# Place a point light in front of the person. \n",
+    "lights = PointLights(device=device, location=[[0.0, 0.0, 2.0]])\n",
+    "\n",
+    "# Create a Phong renderer by composing a rasterizer and a shader. The textured Phong shader will \n",
+    "# interpolate the texture uv coordinates for each vertex, sample from a texture image and \n",
+    "# apply the Phong lighting model\n",
+    "renderer = MeshRenderer(\n",
+    "    rasterizer=MeshRasterizer(\n",
+    "        cameras=cameras, \n",
+    "        raster_settings=raster_settings\n",
+    "    ),\n",
+    "    shader=SoftPhongShader(\n",
+    "        device=device, \n",
+    "        cameras=cameras,\n",
+    "        lights=lights\n",
+    "    )\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Render the textured mesh we created from the SMPL model and texture map."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "images = renderer(mesh)\n",
+    "plt.figure(figsize=(10, 10))\n",
+    "plt.imshow(images[0, ..., :3].cpu().numpy())\n",
+    "plt.axis(\"off\");"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Different view and lighting of the body\n",
+    "\n",
+    "We can also change many other settings in the rendering pipeline. Here we:\n",
+    "\n",
+    "- change the **viewing angle** of the camera\n",
+    "- change the **position** of the point light"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Rotate the person by increasing the elevation and azimuth angles to view the back of the person from above. \n",
+    "R, T = look_at_view_transform(2.7, 10, 180)\n",
+    "cameras = FoVPerspectiveCameras(device=device, R=R, T=T)\n",
+    "\n",
+    "# Move the light location so the light is shining on the person's back.  \n",
+    "lights.location = torch.tensor([[2.0, 2.0, -2.0]], device=device)\n",
+    "\n",
+    "# Re render the mesh, passing in keyword arguments for the modified components.\n",
+    "images = renderer(mesh, lights=lights, cameras=cameras)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure(figsize=(10, 10))\n",
+    "plt.imshow(images[0, ..., :3].cpu().numpy())\n",
+    "plt.axis(\"off\");"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Conclusion\n",
+    "In this tutorial, we've learned how to construct a **textured mesh** from **DensePose model and uv data**, as well as initialize a **Renderer** and change the viewing angle and lighting of our rendered mesh."
+   ]
+  }
+ ],
+ "metadata": {
+  "bento_stylesheets": {
+   "bento/extensions/flow/main.css": true,
+   "bento/extensions/kernel_selector/main.css": true,
+   "bento/extensions/kernel_ui/main.css": true,
+   "bento/extensions/new_kernel/main.css": true,
+   "bento/extensions/system_usage/main.css": true,
+   "bento/extensions/theme/main.css": true
+  },
+  "kernelspec": {
+   "display_name": "pytorch3d_etc (local)",
+   "language": "python",
+   "name": "pytorch3d_etc_local"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.5+"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/common/__init__.py

@@ -0,0 +1,12 @@
+# 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 .datatypes import Device, get_device, make_device
+
+
+__all__ = [k for k in globals().keys() if not k.startswith("_")]

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/common/compat.py

@@ -0,0 +1,45 @@
+# 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 Sequence, Tuple, Union
+
+import torch
+
+
+"""
+Some functions which depend on PyTorch or Python versions.
+"""
+
+
+def meshgrid_ij(
+    *A: Union[torch.Tensor, Sequence[torch.Tensor]]
+) -> Tuple[torch.Tensor, ...]:  # pragma: no cover
+    """
+    Like torch.meshgrid was before PyTorch 1.10.0, i.e. with indexing set to ij
+    """
+    if (
+        # pyre-fixme[16]: Callable `meshgrid` has no attribute `__kwdefaults__`.
+        torch.meshgrid.__kwdefaults__ is not None
+        and "indexing" in torch.meshgrid.__kwdefaults__
+    ):
+        # PyTorch >= 1.10.0
+        # pyre-fixme[6]: For 1st param expected `Union[List[Tensor], Tensor]` but
+        #  got `Union[Sequence[Tensor], Tensor]`.
+        return torch.meshgrid(*A, indexing="ij")
+    # pyre-fixme[6]: For 1st param expected `Union[List[Tensor], Tensor]` but got
+    #  `Union[Sequence[Tensor], Tensor]`.
+    return torch.meshgrid(*A)
+
+
+def prod(iterable, *, start=1):
+    """
+    Like math.prod in Python 3.8 and later.
+    """
+    for i in iterable:
+        start *= i
+    return start

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/common/datatypes.py

@@ -0,0 +1,60 @@
+# 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 Optional, Union
+
+import torch
+
+
+Device = Union[str, torch.device]
+
+
+def make_device(device: Device) -> torch.device:
+    """
+    Makes an actual torch.device object from the device specified as
+    either a string or torch.device object. If the device is `cuda` without
+    a specific index, the index of the current device is assigned.
+
+    Args:
+        device: Device (as str or torch.device)
+
+    Returns:
+        A matching torch.device object
+    """
+    device = torch.device(device) if isinstance(device, str) else device
+    if device.type == "cuda" and device.index is None:
+        # If cuda but with no index, then the current cuda device is indicated.
+        # In that case, we fix to that device
+        device = torch.device(f"cuda:{torch.cuda.current_device()}")
+    return device
+
+
+def get_device(x, device: Optional[Device] = None) -> torch.device:
+    """
+    Gets the device of the specified variable x if it is a tensor, or
+    falls back to a default CPU device otherwise. Allows overriding by
+    providing an explicit device.
+
+    Args:
+        x: a torch.Tensor to get the device from or another type
+        device: Device (as str or torch.device) to fall back to
+
+    Returns:
+        A matching torch.device object
+    """
+
+    # User overrides device
+    if device is not None:
+        return make_device(device)
+
+    # Set device based on input tensor
+    if torch.is_tensor(x):
+        return x.device
+
+    # Default device is cpu
+    return torch.device("cpu")

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/common/linear_with_repeat.py

@@ -0,0 +1,95 @@
+# 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
+
+import math
+from typing import Tuple
+
+import torch
+import torch.nn.functional as F
+from torch.nn import init, Parameter
+
+
+class LinearWithRepeat(torch.nn.Module):
+    """
+    if x has shape (..., k, n1)
+    and y has shape (..., n2)
+    then
+    LinearWithRepeat(n1 + n2, out_features).forward((x,y))
+    is equivalent to
+    Linear(n1 + n2, out_features).forward(
+        torch.cat([x, y.unsqueeze(-2).expand(..., k, n2)], dim=-1)
+    )
+
+    Or visually:
+    Given the following, for each ray,
+
+                feature   ->
+
+    ray         xxxxxxxx
+    position    xxxxxxxx
+      |         xxxxxxxx
+      v         xxxxxxxx
+
+
+    and
+                            yyyyyyyy
+
+    where the y's do not depend on the position
+    but only on the ray,
+    we want to evaluate a Linear layer on both
+    types of data at every position.
+
+    It's as if we constructed
+
+                xxxxxxxxyyyyyyyy
+                xxxxxxxxyyyyyyyy
+                xxxxxxxxyyyyyyyy
+                xxxxxxxxyyyyyyyy
+
+    and sent that through the Linear.
+    """
+
+    def __init__(
+        self,
+        in_features: int,
+        out_features: int,
+        bias: bool = True,
+        device=None,
+        dtype=None,
+    ) -> None:
+        """
+        Copied from torch.nn.Linear.
+        """
+        factory_kwargs = {"device": device, "dtype": dtype}
+        super().__init__()
+        self.in_features = in_features
+        self.out_features = out_features
+        self.weight = Parameter(
+            torch.empty((out_features, in_features), **factory_kwargs)
+        )
+        if bias:
+            self.bias = Parameter(torch.empty(out_features, **factory_kwargs))
+        else:
+            self.register_parameter("bias", None)
+        self.reset_parameters()
+
+    def reset_parameters(self) -> None:
+        """
+        Copied from torch.nn.Linear.
+        """
+        init.kaiming_uniform_(self.weight, a=math.sqrt(5))
+        if self.bias is not None:
+            fan_in, _ = init._calculate_fan_in_and_fan_out(self.weight)
+            bound = 1 / math.sqrt(fan_in) if fan_in > 0 else 0
+            init.uniform_(self.bias, -bound, bound)
+
+    def forward(self, input: Tuple[torch.Tensor, torch.Tensor]) -> torch.Tensor:
+        n1 = input[0].shape[-1]
+        output1 = F.linear(input[0], self.weight[:, :n1], self.bias)
+        output2 = F.linear(input[1], self.weight[:, n1:], None)
+        return output1 + output2.unsqueeze(-2)

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/common/workaround/__init__.py

@@ -0,0 +1,10 @@
+# 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 .symeig3x3 import symeig3x3
+from .utils import _safe_det_3x3

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/common/workaround/utils.py

@@ -0,0 +1,33 @@
+# 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
+
+
+import torch
+
+
+def _safe_det_3x3(t: torch.Tensor):
+    """
+    Fast determinant calculation for a batch of 3x3 matrices.
+
+    Note, result of this function might not be the same as `torch.det()`.
+    The differences might be in the last significant digit.
+
+    Args:
+        t: Tensor of shape (N, 3, 3).
+
+    Returns:
+        Tensor of shape (N) with determinants.
+    """
+
+    det = (
+        t[..., 0, 0] * (t[..., 1, 1] * t[..., 2, 2] - t[..., 1, 2] * t[..., 2, 1])
+        - t[..., 0, 1] * (t[..., 1, 0] * t[..., 2, 2] - t[..., 2, 0] * t[..., 1, 2])
+        + t[..., 0, 2] * (t[..., 1, 0] * t[..., 2, 1] - t[..., 2, 0] * t[..., 1, 1])
+    )
+
+    return det

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/compositing/alpha_composite.cu

@@ -0,0 +1,235 @@
+/*
+ * 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.
+ */
+
+#include <ATen/ATen.h>
+#include <ATen/core/TensorAccessor.h>
+#include <ATen/cuda/CUDAContext.h>
+#include <c10/cuda/CUDAGuard.h>
+
+#include <cuda.h>
+#include <cuda_runtime.h>
+
+#include <stdio.h>
+#include <vector>
+
+__constant__ const float kEpsilon = 1e-9;
+
+// TODO(gkioxari) support all data types once AtomicAdd supports doubles.
+// Currently, support is for floats only.
+__global__ void alphaCompositeCudaForwardKernel(
+    // clang-format off
+    at::PackedTensorAccessor64<float, 4, at::RestrictPtrTraits> result,
+    const at::PackedTensorAccessor64<float, 2, at::RestrictPtrTraits> features,
+    const at::PackedTensorAccessor64<float, 4, at::RestrictPtrTraits> alphas,
+    const at::PackedTensorAccessor64<int64_t, 4, at::RestrictPtrTraits> points_idx) {
+  // clang-format on
+  const int64_t batch_size = result.size(0);
+  const int64_t C = features.size(0);
+  const int64_t H = points_idx.size(2);
+  const int64_t W = points_idx.size(3);
+
+  // Get the batch and index
+  const int batch = blockIdx.x;
+
+  const int num_pixels = C * H * W;
+  const int num_threads = gridDim.y * blockDim.x;
+  const int tid = blockIdx.y * blockDim.x + threadIdx.x;
+
+  // Iterate over each feature in each pixel
+  for (int pid = tid; pid < num_pixels; pid += num_threads) {
+    int ch = pid / (H * W);
+    int j = (pid % (H * W)) / W;
+    int i = (pid % (H * W)) % W;
+
+    // alphacomposite the different values
+    float cum_alpha = 1.;
+    // Iterate through the closest K points for this pixel
+    for (int k = 0; k < points_idx.size(1); ++k) {
+      int n_idx = points_idx[batch][k][j][i];
+
+      // Sentinel value is -1 indicating no point overlaps the pixel
+      if (n_idx < 0) {
+        continue;
+      }
+
+      float alpha = alphas[batch][k][j][i];
+      // TODO(gkioxari) It might be more efficient to have threads write in a
+      // local variable, and move atomicAdd outside of the loop such that
+      // atomicAdd is executed once per thread.
+      atomicAdd(
+          &result[batch][ch][j][i], features[ch][n_idx] * cum_alpha * alpha);
+      cum_alpha = cum_alpha * (1 - alpha);
+    }
+  }
+}
+
+// TODO(gkioxari) support all data types once AtomicAdd supports doubles.
+// Currently, support is for floats only.
+__global__ void alphaCompositeCudaBackwardKernel(
+    // clang-format off
+    at::PackedTensorAccessor64<float, 2, at::RestrictPtrTraits> grad_features,
+    at::PackedTensorAccessor64<float, 4, at::RestrictPtrTraits> grad_alphas,
+    const at::PackedTensorAccessor64<float, 4, at::RestrictPtrTraits> grad_outputs,
+    const at::PackedTensorAccessor64<float, 2, at::RestrictPtrTraits> features,
+    const at::PackedTensorAccessor64<float, 4, at::RestrictPtrTraits> alphas,
+    const at::PackedTensorAccessor64<int64_t, 4, at::RestrictPtrTraits> points_idx) {
+  // clang-format on
+  const int64_t batch_size = points_idx.size(0);
+  const int64_t C = features.size(0);
+  const int64_t H = points_idx.size(2);
+  const int64_t W = points_idx.size(3);
+
+  // Get the batch and index
+  const int batch = blockIdx.x;
+
+  const int num_pixels = C * H * W;
+  const int num_threads = gridDim.y * blockDim.x;
+  const int tid = blockIdx.y * blockDim.x + threadIdx.x;
+
+  // Parallelize over each feature in each pixel in images of size H * W,
+  // for each image in the batch of size batch_size
+  for (int pid = tid; pid < num_pixels; pid += num_threads) {
+    int ch = pid / (H * W);
+    int j = (pid % (H * W)) / W;
+    int i = (pid % (H * W)) % W;
+
+    // alphacomposite the different values
+    float cum_alpha = 1.;
+    // Iterate through the closest K points for this pixel
+    for (int k = 0; k < points_idx.size(1); ++k) {
+      int n_idx = points_idx[batch][k][j][i];
+
+      // Sentinel value is -1 indicating no point overlaps the pixel
+      if (n_idx < 0) {
+        continue;
+      }
+      float alpha = alphas[batch][k][j][i];
+
+      // TODO(gkioxari) It might be more efficient to have threads write in a
+      // local variable, and move atomicAdd outside of the loop such that
+      // atomicAdd is executed once per thread.
+      atomicAdd(
+          &grad_alphas[batch][k][j][i],
+          cum_alpha * features[ch][n_idx] * grad_outputs[batch][ch][j][i]);
+      atomicAdd(
+          &grad_features[ch][n_idx],
+          cum_alpha * alpha * grad_outputs[batch][ch][j][i]);
+
+      // Iterate over all (K-1) nearest points to update gradient
+      for (int t = 0; t < k; ++t) {
+        int t_idx = points_idx[batch][t][j][i];
+        // Sentinel value is -1, indicating no point overlaps this pixel
+        if (t_idx < 0) {
+          continue;
+        }
+        float alpha_tvalue = alphas[batch][t][j][i];
+        // TODO(gkioxari) It might be more efficient to have threads write in a
+        // local variable, and move atomicAdd outside of the loop such that
+        // atomicAdd is executed once per thread.
+        atomicAdd(
+            &grad_alphas[batch][t][j][i],
+            -grad_outputs[batch][ch][j][i] * features[ch][n_idx] * cum_alpha *
+                alpha / (1 - alpha_tvalue + kEpsilon));
+      }
+
+      cum_alpha = cum_alpha * (1 - alphas[batch][k][j][i]);
+    }
+  }
+}
+
+at::Tensor alphaCompositeCudaForward(
+    const at::Tensor& features,
+    const at::Tensor& alphas,
+    const at::Tensor& points_idx) {
+  // Check inputs are on the same device
+  at::TensorArg features_t{features, "features", 1},
+      alphas_t{alphas, "alphas", 2}, points_idx_t{points_idx, "points_idx", 3};
+  at::CheckedFrom c = "alphaCompositeCudaForward";
+  at::checkAllSameGPU(c, {features_t, alphas_t, points_idx_t});
+  at::checkAllSameType(c, {features_t, alphas_t});
+
+  // Set the device for the kernel launch based on the device of the input
+  at::cuda::CUDAGuard device_guard(features.device());
+  cudaStream_t stream = at::cuda::getCurrentCUDAStream();
+
+  const int64_t batch_size = points_idx.size(0);
+  const int64_t C = features.size(0);
+  const int64_t H = points_idx.size(2);
+  const int64_t W = points_idx.size(3);
+
+  auto result = at::zeros({batch_size, C, H, W}, features.options());
+
+  if (result.numel() == 0) {
+    AT_CUDA_CHECK(cudaGetLastError());
+    return result;
+  }
+
+  const dim3 threadsPerBlock(64);
+  const dim3 numBlocks(batch_size, 1024 / batch_size + 1);
+
+  // TODO(gkioxari) add AT_DISPATCH_FLOATING_TYPES once atomicAdd supports
+  // doubles. Currently, support is for floats only.
+  alphaCompositeCudaForwardKernel<<<numBlocks, threadsPerBlock, 0, stream>>>(
+      // clang-format off
+      // As we are using packed accessors here the tensors
+      // do not need to be made contiguous.
+      result.packed_accessor64<float, 4, at::RestrictPtrTraits>(),
+      features.packed_accessor64<float, 2, at::RestrictPtrTraits>(),
+      alphas.packed_accessor64<float, 4, at::RestrictPtrTraits>(),
+      points_idx.packed_accessor64<int64_t, 4, at::RestrictPtrTraits>());
+  // clang-format on
+  AT_CUDA_CHECK(cudaGetLastError());
+  return result;
+}
+
+std::tuple<at::Tensor, at::Tensor> alphaCompositeCudaBackward(
+    const at::Tensor& grad_outputs,
+    const at::Tensor& features,
+    const at::Tensor& alphas,
+    const at::Tensor& points_idx) {
+  // Check inputs are on the same device
+  at::TensorArg grad_outputs_t{grad_outputs, "grad_outputs", 1},
+      features_t{features, "features", 2}, alphas_t{alphas, "alphas", 3},
+      points_idx_t{points_idx, "points_idx", 4};
+  at::CheckedFrom c = "alphaCompositeCudaBackward";
+  at::checkAllSameGPU(c, {grad_outputs_t, features_t, alphas_t, points_idx_t});
+  at::checkAllSameType(c, {grad_outputs_t, features_t, alphas_t});
+
+  // Set the device for the kernel launch based on the device of the input
+  at::cuda::CUDAGuard device_guard(features.device());
+  cudaStream_t stream = at::cuda::getCurrentCUDAStream();
+
+  auto grad_features = at::zeros_like(features);
+  auto grad_alphas = at::zeros_like(alphas);
+
+  if (grad_features.numel() == 0 || grad_alphas.numel() == 0) {
+    AT_CUDA_CHECK(cudaGetLastError());
+    return std::make_tuple(grad_features, grad_alphas);
+  }
+
+  const int64_t bs = alphas.size(0);
+
+  const dim3 threadsPerBlock(64);
+  const dim3 numBlocks(bs, 1024 / bs + 1);
+
+  // TODO(gkioxari) add AT_DISPATCH_FLOATING_TYPES once atomicAdd supports
+  // doubles. Currently, support is for floats only.
+  alphaCompositeCudaBackwardKernel<<<numBlocks, threadsPerBlock, 0, stream>>>(
+      // clang-format off
+      // As we are using packed accessors here the tensors
+      // do not need to be made contiguous.
+      grad_features.packed_accessor64<float, 2, at::RestrictPtrTraits>(),
+      grad_alphas.packed_accessor64<float, 4, at::RestrictPtrTraits>(),
+      grad_outputs.packed_accessor64<float, 4, at::RestrictPtrTraits>(),
+      features.packed_accessor64<float, 2, at::RestrictPtrTraits>(),
+      alphas.packed_accessor64<float, 4, at::RestrictPtrTraits>(),
+      points_idx.packed_accessor64<int64_t, 4, at::RestrictPtrTraits>());
+  // clang-format on
+  AT_CUDA_CHECK(cudaGetLastError());
+  return std::make_tuple(grad_features, grad_alphas);
+}

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/csrc/compositing/alpha_composite.h

@@ -0,0 +1,107 @@
+/*
+ * 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.
+ */
+
+#include <torch/extension.h>
+#include "utils/pytorch3d_cutils.h"
+
+#include <vector>
+
+// Perform alpha compositing of points in a z-buffer.
+//
+// Inputs:
+//    features: FloatTensor of shape (C, P) which gives the features
+//            of each point where C is the size of the feature and
+//            P the number of points.
+//    alphas: FloatTensor of shape (N, points_per_pixel, H, W) where
+//            points_per_pixel is the number of points in the z-buffer
+//            sorted in z-order, and (H, W) is the image size.
+//    points_idx: IntTensor of shape (N, points_per_pixel, H, W) giving the
+//            indices of the nearest points at each pixel, sorted in z-order.
+// Returns:
+//    weighted_fs: FloatTensor of shape (N, C, H, W) giving the accumulated
+//            feature for each point. Concretely, it gives:
+//                 weighted_fs[b,c,i,j] = sum_k cum_alpha_k *
+//                   features[c,points_idx[b,k,i,j]]
+//                 where cum_alpha_k =
+//                    alphas[b,k,i,j] * prod_l=0..k-1 (1 - alphas[b,l,i,j])
+
+// CUDA declarations
+#ifdef WITH_CUDA
+torch::Tensor alphaCompositeCudaForward(
+    const torch::Tensor& features,
+    const torch::Tensor& alphas,
+    const torch::Tensor& points_idx);
+
+std::tuple<torch::Tensor, torch::Tensor> alphaCompositeCudaBackward(
+    const torch::Tensor& grad_outputs,
+    const torch::Tensor& features,
+    const torch::Tensor& alphas,
+    const torch::Tensor& points_idx);
+#endif
+
+// C++ declarations
+torch::Tensor alphaCompositeCpuForward(
+    const torch::Tensor& features,
+    const torch::Tensor& alphas,
+    const torch::Tensor& points_idx);
+
+std::tuple<torch::Tensor, torch::Tensor> alphaCompositeCpuBackward(
+    const torch::Tensor& grad_outputs,
+    const torch::Tensor& features,
+    const torch::Tensor& alphas,
+    const torch::Tensor& points_idx);
+
+torch::Tensor alphaCompositeForward(
+    torch::Tensor& features,
+    torch::Tensor& alphas,
+    torch::Tensor& points_idx) {
+  features = features.contiguous();
+  alphas = alphas.contiguous();
+  points_idx = points_idx.contiguous();
+
+  if (features.is_cuda()) {
+#ifdef WITH_CUDA
+    CHECK_CUDA(features);
+    CHECK_CUDA(alphas);
+    CHECK_CUDA(points_idx);
+    return alphaCompositeCudaForward(features, alphas, points_idx);
+#else
+    AT_ERROR("Not compiled with GPU support");
+#endif
+  } else {
+    return alphaCompositeCpuForward(features, alphas, points_idx);
+  }
+}
+
+std::tuple<torch::Tensor, torch::Tensor> alphaCompositeBackward(
+    torch::Tensor& grad_outputs,
+    torch::Tensor& features,
+    torch::Tensor& alphas,
+    torch::Tensor& points_idx) {
+  grad_outputs = grad_outputs.contiguous();
+  features = features.contiguous();
+  alphas = alphas.contiguous();
+  points_idx = points_idx.contiguous();
+
+  if (grad_outputs.is_cuda()) {
+#ifdef WITH_CUDA
+    CHECK_CUDA(grad_outputs);
+    CHECK_CUDA(features);
+    CHECK_CUDA(alphas);
+    CHECK_CUDA(points_idx);
+
+    return alphaCompositeCudaBackward(
+        grad_outputs, features, alphas, points_idx);
+#else
+    AT_ERROR("Not compiled with GPU support");
+#endif
+  } else {
+    return alphaCompositeCpuBackward(
+        grad_outputs, features, alphas, points_idx);
+  }
+}