Add files using upload-large-folder tool

msx_assets/object/052_extra_large_clamp/textured.mtl

@@ -0,0 +1,3 @@
+newmtl material_0
+# shader_type beckmann
+map_Kd texture_map.png

msx_assets/object/073-e_lego_duplo/textured.mtl

@@ -0,0 +1,3 @@
+newmtl material_0
+# shader_type beckmann
+map_Kd texture_map.png

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

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

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

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

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

@@ -0,0 +1,15 @@
+pytorch3d.implicitron.models
+============================
+
+.. toctree::
+
+    base_model
+    generic_model
+    metrics
+    model_dbir
+    feature_extractor/index
+    global_encoder/index
+    implicit_function/index
+    renderer/index
+    view_pooler/index
+    visualization/index

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

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

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

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

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/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/pytorch3d/pytorch3d/ops/__init__.py

@@ -0,0 +1,49 @@
+# 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 .ball_query import ball_query
+from .cameras_alignment import corresponding_cameras_alignment
+
+from .cubify import cubify
+from .graph_conv import GraphConv
+from .interp_face_attrs import interpolate_face_attributes
+from .iou_box3d import box3d_overlap
+from .knn import knn_gather, knn_points
+from .laplacian_matrices import cot_laplacian, laplacian, norm_laplacian
+
+from .mesh_face_areas_normals import mesh_face_areas_normals
+from .mesh_filtering import taubin_smoothing
+
+from .packed_to_padded import packed_to_padded, padded_to_packed
+from .perspective_n_points import efficient_pnp
+from .points_alignment import corresponding_points_alignment, iterative_closest_point
+from .points_normals import (
+    estimate_pointcloud_local_coord_frames,
+    estimate_pointcloud_normals,
+)
+from .points_to_volumes import (
+    add_pointclouds_to_volumes,
+    add_points_features_to_volume_densities_features,
+)
+
+from .sample_farthest_points import sample_farthest_points
+
+from .sample_points_from_meshes import sample_points_from_meshes
+from .subdivide_meshes import SubdivideMeshes
+from .utils import (
+    convert_pointclouds_to_tensor,
+    eyes,
+    get_point_covariances,
+    is_pointclouds,
+    wmean,
+)
+
+from .vert_align import vert_align
+
+
+__all__ = [k for k in globals().keys() if not k.startswith("_")]

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

@@ -0,0 +1,142 @@
+# 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 Union
+
+import torch
+from pytorch3d import _C
+from torch.autograd import Function
+from torch.autograd.function import once_differentiable
+
+from .knn import _KNN
+from .utils import masked_gather
+
+
+class _ball_query(Function):
+    """
+    Torch autograd Function wrapper for Ball Query C++/CUDA implementations.
+    """
+
+    @staticmethod
+    def forward(ctx, p1, p2, lengths1, lengths2, K, radius):
+        """
+        Arguments defintions the same as in the ball_query function
+        """
+        idx, dists = _C.ball_query(p1, p2, lengths1, lengths2, K, radius)
+        ctx.save_for_backward(p1, p2, lengths1, lengths2, idx)
+        ctx.mark_non_differentiable(idx)
+        return dists, idx
+
+    @staticmethod
+    @once_differentiable
+    def backward(ctx, grad_dists, grad_idx):
+        p1, p2, lengths1, lengths2, idx = ctx.saved_tensors
+        # TODO(gkioxari) Change cast to floats once we add support for doubles.
+        if not (grad_dists.dtype == torch.float32):
+            grad_dists = grad_dists.float()
+        if not (p1.dtype == torch.float32):
+            p1 = p1.float()
+        if not (p2.dtype == torch.float32):
+            p2 = p2.float()
+
+        # Reuse the KNN backward function
+        # by default, norm is 2
+        grad_p1, grad_p2 = _C.knn_points_backward(
+            p1, p2, lengths1, lengths2, idx, 2, grad_dists
+        )
+        return grad_p1, grad_p2, None, None, None, None
+
+
+def ball_query(
+    p1: torch.Tensor,
+    p2: torch.Tensor,
+    lengths1: Union[torch.Tensor, None] = None,
+    lengths2: Union[torch.Tensor, None] = None,
+    K: int = 500,
+    radius: float = 0.2,
+    return_nn: bool = True,
+):
+    """
+    Ball Query is an alternative to KNN. It can be
+    used to find all points in p2 that are within a specified radius
+    to the query point in p1 (with an upper limit of K neighbors).
+
+    The neighbors returned are not necssarily the *nearest* to the
+    point in p1, just the first K values in p2 which are within the
+    specified radius.
+
+    This method is faster than kNN when there are large numbers of points
+    in p2 and the ordering of neighbors is not important compared to the
+    distance being within the radius threshold.
+
+    "Ball query’s local neighborhood guarantees a fixed region scale thus
+    making local region features more generalizable across space, which is
+    preferred for tasks requiring local pattern recognition
+    (e.g. semantic point labeling)" [1].
+
+    [1] Charles R. Qi et al, "PointNet++: Deep Hierarchical Feature Learning
+        on Point Sets in a Metric Space", NeurIPS 2017.
+
+    Args:
+        p1: Tensor of shape (N, P1, D) giving a batch of N point clouds, each
+            containing up to P1 points of dimension D. These represent the centers of
+            the ball queries.
+        p2: Tensor of shape (N, P2, D) giving a batch of N point clouds, each
+            containing up to P2 points of dimension D.
+        lengths1: LongTensor of shape (N,) of values in the range [0, P1], giving the
+            length of each pointcloud in p1. Or None to indicate that every cloud has
+            length P1.
+        lengths2: LongTensor of shape (N,) of values in the range [0, P2], giving the
+            length of each pointcloud in p2. Or None to indicate that every cloud has
+            length P2.
+        K: Integer giving the upper bound on the number of samples to take
+            within the radius
+        radius: the radius around each point within which the neighbors need to be located
+        return_nn: If set to True returns the K neighbor points in p2 for each point in p1.
+
+    Returns:
+        dists: Tensor of shape (N, P1, K) giving the squared distances to
+            the neighbors. This is padded with zeros both where a cloud in p2
+            has fewer than S points and where a cloud in p1 has fewer than P1 points
+            and also if there are fewer than K points which satisfy the radius threshold.
+
+        idx: LongTensor of shape (N, P1, K) giving the indices of the
+            S neighbors in p2 for points in p1.
+            Concretely, if `p1_idx[n, i, k] = j` then `p2[n, j]` is the k-th
+            neighbor to `p1[n, i]` in `p2[n]`. This is padded with -1 both where a cloud
+            in p2 has fewer than S points and where a cloud in p1 has fewer than P1
+            points and also if there are fewer than K points which satisfy the radius threshold.
+
+        nn: Tensor of shape (N, P1, K, D) giving the K neighbors in p2 for
+            each point in p1. Concretely, `p2_nn[n, i, k]` gives the k-th neighbor
+            for `p1[n, i]`. Returned if `return_nn` is True.  The output is a tensor
+            of shape (N, P1, K, U).
+
+    """
+    if p1.shape[0] != p2.shape[0]:
+        raise ValueError("pts1 and pts2 must have the same batch dimension.")
+    if p1.shape[2] != p2.shape[2]:
+        raise ValueError("pts1 and pts2 must have the same point dimension.")
+
+    p1 = p1.contiguous()
+    p2 = p2.contiguous()
+    P1 = p1.shape[1]
+    P2 = p2.shape[1]
+    N = p1.shape[0]
+
+    if lengths1 is None:
+        lengths1 = torch.full((N,), P1, dtype=torch.int64, device=p1.device)
+    if lengths2 is None:
+        lengths2 = torch.full((N,), P2, dtype=torch.int64, device=p1.device)
+
+    dists, idx = _ball_query.apply(p1, p2, lengths1, lengths2, K, radius)
+
+    # Gather the neighbors if needed
+    points_nn = masked_gather(p2, idx) if return_nn else None
+
+    return _KNN(dists=dists, idx=idx, knn=points_nn)

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

@@ -0,0 +1,275 @@
+# 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
+
+import torch
+import torch.nn.functional as F
+
+from pytorch3d.common.compat import meshgrid_ij
+
+from pytorch3d.structures import Meshes
+
+
+def unravel_index(idx, dims) -> torch.Tensor:
+    r"""
+    Equivalent to np.unravel_index
+    Args:
+      idx: A LongTensor whose elements are indices into the
+          flattened version of an array of dimensions dims.
+      dims: The shape of the array to be indexed.
+    Implemented only for dims=(N, H, W, D)
+    """
+    if len(dims) != 4:
+        raise ValueError("Expects a 4-element list.")
+    N, H, W, D = dims
+    n = idx // (H * W * D)
+    h = (idx - n * H * W * D) // (W * D)
+    w = (idx - n * H * W * D - h * W * D) // D
+    d = idx - n * H * W * D - h * W * D - w * D
+    return torch.stack((n, h, w, d), dim=1)
+
+
+def ravel_index(idx, dims) -> torch.Tensor:
+    """
+    Computes the linear index in an array of shape dims.
+    It performs the reverse functionality of unravel_index
+    Args:
+      idx: A LongTensor of shape (N, 3). Each row corresponds to indices into an
+          array of dimensions dims.
+      dims: The shape of the array to be indexed.
+    Implemented only for dims=(H, W, D)
+    """
+    if len(dims) != 3:
+        raise ValueError("Expects a 3-element list")
+    if idx.shape[1] != 3:
+        raise ValueError("Expects an index tensor of shape Nx3")
+    H, W, D = dims
+    linind = idx[:, 0] * W * D + idx[:, 1] * D + idx[:, 2]
+    return linind
+
+
+@torch.no_grad()
+def cubify(
+    voxels: torch.Tensor,
+    thresh: float,
+    *,
+    feats: Optional[torch.Tensor] = None,
+    device=None,
+    align: str = "topleft",
+) -> Meshes:
+    r"""
+    Converts a voxel to a mesh by replacing each occupied voxel with a cube
+    consisting of 12 faces and 8 vertices. Shared vertices are merged, and
+    internal faces are removed.
+    Args:
+      voxels: A FloatTensor of shape (N, D, H, W) containing occupancy probabilities.
+      thresh: A scalar threshold. If a voxel occupancy is larger than
+          thresh, the voxel is considered occupied.
+      feats: A FloatTensor of shape (N, K, D, H, W) containing the color information
+          of each voxel. K is the number of channels. This is supported only when
+          align == "center"
+      device: The device of the output meshes
+      align: Defines the alignment of the mesh vertices and the grid locations.
+          Has to be one of {"topleft", "corner", "center"}. See below for explanation.
+          Default is "topleft".
+    Returns:
+      meshes: A Meshes object of the corresponding meshes.
+
+
+    The alignment between the vertices of the cubified mesh and the voxel locations (or pixels)
+    is defined by the choice of `align`. We support three modes, as shown below for a 2x2 grid:
+
+                X---X----         X-------X        ---------
+                |   |   |         |   |   |        | X | X |
+                X---X----         ---------        ---------
+                |   |   |         |   |   |        | X | X |
+                ---------         X-------X        ---------
+
+                 topleft           corner            center
+
+    In the figure, X denote the grid locations and the squares represent the added cuboids.
+    When `align="topleft"`, then the top left corner of each cuboid corresponds to the
+    pixel coordinate of the input grid.
+    When `align="corner"`, then the corners of the output mesh span the whole grid.
+    When `align="center"`, then the grid locations form the center of the cuboids.
+    """
+
+    if device is None:
+        device = voxels.device
+
+    if align not in ["topleft", "corner", "center"]:
+        raise ValueError("Align mode must be one of (topleft, corner, center).")
+
+    if len(voxels) == 0:
+        return Meshes(verts=[], faces=[])
+
+    N, D, H, W = voxels.size()
+    # vertices corresponding to a unit cube: 8x3
+    cube_verts = torch.tensor(
+        [
+            [0, 0, 0],
+            [0, 0, 1],
+            [0, 1, 0],
+            [0, 1, 1],
+            [1, 0, 0],
+            [1, 0, 1],
+            [1, 1, 0],
+            [1, 1, 1],
+        ],
+        dtype=torch.int64,
+        device=device,
+    )
+
+    # faces corresponding to a unit cube: 12x3
+    cube_faces = torch.tensor(
+        [
+            [0, 1, 2],
+            [1, 3, 2],  # left face: 0, 1
+            [2, 3, 6],
+            [3, 7, 6],  # bottom face: 2, 3
+            [0, 2, 6],
+            [0, 6, 4],  # front face: 4, 5
+            [0, 5, 1],
+            [0, 4, 5],  # up face: 6, 7
+            [6, 7, 5],
+            [6, 5, 4],  # right face: 8, 9
+            [1, 7, 3],
+            [1, 5, 7],  # back face: 10, 11
+        ],
+        dtype=torch.int64,
+        device=device,
+    )
+
+    wx = torch.tensor([0.5, 0.5], device=device).view(1, 1, 1, 1, 2)
+    wy = torch.tensor([0.5, 0.5], device=device).view(1, 1, 1, 2, 1)
+    wz = torch.tensor([0.5, 0.5], device=device).view(1, 1, 2, 1, 1)
+
+    voxelt = voxels.ge(thresh).float()
+    # N x 1 x D x H x W
+    voxelt = voxelt.view(N, 1, D, H, W)
+
+    # N x 1 x (D-1) x (H-1) x (W-1)
+    voxelt_x = F.conv3d(voxelt, wx).gt(0.5).float()
+    voxelt_y = F.conv3d(voxelt, wy).gt(0.5).float()
+    voxelt_z = F.conv3d(voxelt, wz).gt(0.5).float()
+
+    # 12 x N x 1 x D x H x W
+    faces_idx = torch.ones((cube_faces.size(0), N, 1, D, H, W), device=device)
+
+    # add left face
+    faces_idx[0, :, :, :, :, 1:] = 1 - voxelt_x
+    faces_idx[1, :, :, :, :, 1:] = 1 - voxelt_x
+    # add bottom face
+    faces_idx[2, :, :, :, :-1, :] = 1 - voxelt_y
+    faces_idx[3, :, :, :, :-1, :] = 1 - voxelt_y
+    # add front face
+    faces_idx[4, :, :, 1:, :, :] = 1 - voxelt_z
+    faces_idx[5, :, :, 1:, :, :] = 1 - voxelt_z
+    # add up face
+    faces_idx[6, :, :, :, 1:, :] = 1 - voxelt_y
+    faces_idx[7, :, :, :, 1:, :] = 1 - voxelt_y
+    # add right face
+    faces_idx[8, :, :, :, :, :-1] = 1 - voxelt_x
+    faces_idx[9, :, :, :, :, :-1] = 1 - voxelt_x
+    # add back face
+    faces_idx[10, :, :, :-1, :, :] = 1 - voxelt_z
+    faces_idx[11, :, :, :-1, :, :] = 1 - voxelt_z
+
+    faces_idx *= voxelt
+
+    # N x H x W x D x 12
+    faces_idx = faces_idx.permute(1, 2, 4, 5, 3, 0).squeeze(1)
+    # (NHWD) x 12
+    faces_idx = faces_idx.contiguous()
+    faces_idx = faces_idx.view(-1, cube_faces.size(0))
+
+    # boolean to linear index
+    # NF x 2
+    linind = torch.nonzero(faces_idx, as_tuple=False)
+
+    # NF x 4
+    nyxz = unravel_index(linind[:, 0], (N, H, W, D))
+
+    # NF x 3: faces
+    faces = torch.index_select(cube_faces, 0, linind[:, 1])
+
+    grid_faces = []
+    for d in range(cube_faces.size(1)):
+        # NF x 3
+        xyz = torch.index_select(cube_verts, 0, faces[:, d])
+        permute_idx = torch.tensor([1, 0, 2], device=device)
+        yxz = torch.index_select(xyz, 1, permute_idx)
+        yxz += nyxz[:, 1:]
+        # NF x 1
+        temp = ravel_index(yxz, (H + 1, W + 1, D + 1))
+        grid_faces.append(temp)
+    # NF x 3
+    grid_faces = torch.stack(grid_faces, dim=1)
+
+    y, x, z = meshgrid_ij(torch.arange(H + 1), torch.arange(W + 1), torch.arange(D + 1))
+    y = y.to(device=device, dtype=torch.float32)
+    x = x.to(device=device, dtype=torch.float32)
+    z = z.to(device=device, dtype=torch.float32)
+
+    if align == "center":
+        x = x - 0.5
+        y = y - 0.5
+        z = z - 0.5
+
+    margin = 0.0 if align == "corner" else 1.0
+    y = y * 2.0 / (H - margin) - 1.0
+    x = x * 2.0 / (W - margin) - 1.0
+    z = z * 2.0 / (D - margin) - 1.0
+
+    # ((H+1)(W+1)(D+1)) x 3
+    grid_verts = torch.stack((x, y, z), dim=3).view(-1, 3)
+
+    if len(nyxz) == 0:
+        verts_list = [torch.tensor([], dtype=torch.float32, device=device)] * N
+        faces_list = [torch.tensor([], dtype=torch.int64, device=device)] * N
+        return Meshes(verts=verts_list, faces=faces_list)
+
+    num_verts = grid_verts.size(0)
+    grid_faces += nyxz[:, 0].view(-1, 1) * num_verts
+    idleverts = torch.ones(num_verts * N, dtype=torch.uint8, device=device)
+
+    indices = grid_faces.flatten()
+    if device.type == "cpu":
+        indices = torch.unique(indices)
+    idleverts.scatter_(0, indices, 0)
+    grid_faces -= nyxz[:, 0].view(-1, 1) * num_verts
+    split_size = torch.bincount(nyxz[:, 0], minlength=N)
+    faces_list = list(torch.split(grid_faces, split_size.tolist(), 0))
+
+    idleverts = idleverts.view(N, num_verts)
+    idlenum = idleverts.cumsum(1)
+
+    verts_list = [
+        grid_verts.index_select(0, (idleverts[n] == 0).nonzero(as_tuple=False)[:, 0])
+        for n in range(N)
+    ]
+
+    textures_list = None
+    if feats is not None and align == "center":
+        # We return a TexturesAtlas containing one color for each face
+        # N x K x D x H x W  -> N x H x W x D x K
+        feats = feats.permute(0, 3, 4, 2, 1)
+
+        # (NHWD) x K
+        feats = feats.reshape(-1, feats.size(4))
+        feats = torch.index_select(feats, 0, linind[:, 0])
+        feats = feats.reshape(-1, 1, 1, feats.size(1))
+        feats_list = list(torch.split(feats, split_size.tolist(), 0))
+        from pytorch3d.renderer.mesh.textures import TexturesAtlas
+
+        textures_list = TexturesAtlas(feats_list)
+
+    faces_list = [nface - idlenum[n][nface] for n, nface in enumerate(faces_list)]
+    return Meshes(verts=verts_list, faces=faces_list, textures=textures_list)

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

@@ -0,0 +1,176 @@
+# 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
+import torch.nn as nn
+from pytorch3d import _C
+from torch.autograd import Function
+from torch.autograd.function import once_differentiable
+
+
+class GraphConv(nn.Module):
+    """A single graph convolution layer."""
+
+    def __init__(
+        self,
+        input_dim: int,
+        output_dim: int,
+        init: str = "normal",
+        directed: bool = False,
+    ) -> None:
+        """
+        Args:
+            input_dim: Number of input features per vertex.
+            output_dim: Number of output features per vertex.
+            init: Weight initialization method. Can be one of ['zero', 'normal'].
+            directed: Bool indicating if edges in the graph are directed.
+        """
+        super().__init__()
+        self.input_dim = input_dim
+        self.output_dim = output_dim
+        self.directed = directed
+        self.w0 = nn.Linear(input_dim, output_dim)
+        self.w1 = nn.Linear(input_dim, output_dim)
+
+        if init == "normal":
+            nn.init.normal_(self.w0.weight, mean=0, std=0.01)
+            nn.init.normal_(self.w1.weight, mean=0, std=0.01)
+            self.w0.bias.data.zero_()
+            self.w1.bias.data.zero_()
+        elif init == "zero":
+            self.w0.weight.data.zero_()
+            self.w1.weight.data.zero_()
+        else:
+            raise ValueError('Invalid GraphConv initialization "%s"' % init)
+
+    def forward(self, verts, edges):
+        """
+        Args:
+            verts: FloatTensor of shape (V, input_dim) where V is the number of
+                vertices and input_dim is the number of input features
+                per vertex. input_dim has to match the input_dim specified
+                in __init__.
+            edges: LongTensor of shape (E, 2) where E is the number of edges
+                where each edge has the indices of the two vertices which
+                form the edge.
+
+        Returns:
+            out: FloatTensor of shape (V, output_dim) where output_dim is the
+            number of output features per vertex.
+        """
+        if verts.is_cuda != edges.is_cuda:
+            raise ValueError("verts and edges tensors must be on the same device.")
+        if verts.shape[0] == 0:
+            # empty graph.
+            return verts.new_zeros((0, self.output_dim)) * verts.sum()
+
+        verts_w0 = self.w0(verts)  # (V, output_dim)
+        verts_w1 = self.w1(verts)  # (V, output_dim)
+
+        if torch.cuda.is_available() and verts.is_cuda and edges.is_cuda:
+            neighbor_sums = gather_scatter(verts_w1, edges, self.directed)
+        else:
+            neighbor_sums = gather_scatter_python(
+                verts_w1, edges, self.directed
+            )  # (V, output_dim)
+
+        # Add neighbor features to each vertex's features.
+        out = verts_w0 + neighbor_sums
+        return out
+
+    def __repr__(self):
+        Din, Dout, directed = self.input_dim, self.output_dim, self.directed
+        return "GraphConv(%d -> %d, directed=%r)" % (Din, Dout, directed)
+
+
+def gather_scatter_python(input, edges, directed: bool = False):
+    """
+    Python implementation of gather_scatter for aggregating features of
+    neighbor nodes in a graph.
+
+    Given a directed graph: v0 -> v1 -> v2 the updated feature for v1 depends
+    on v2 in order to be consistent with Morris et al. AAAI 2019
+    (https://arxiv.org/abs/1810.02244). This only affects
+    directed graphs; for undirected graphs v1 will depend on both v0 and v2,
+    no matter which way the edges are physically stored.
+
+    Args:
+        input: Tensor of shape (num_vertices, input_dim).
+        edges: Tensor of edge indices of shape (num_edges, 2).
+        directed: bool indicating if edges are directed.
+
+    Returns:
+        output: Tensor of same shape as input.
+    """
+    if not (input.dim() == 2):
+        raise ValueError("input can only have 2 dimensions.")
+    if not (edges.dim() == 2):
+        raise ValueError("edges can only have 2 dimensions.")
+    if not (edges.shape[1] == 2):
+        raise ValueError("edges must be of shape (num_edges, 2).")
+
+    num_vertices, input_feature_dim = input.shape
+    num_edges = edges.shape[0]
+    output = torch.zeros_like(input)
+    idx0 = edges[:, 0].view(num_edges, 1).expand(num_edges, input_feature_dim)
+    idx1 = edges[:, 1].view(num_edges, 1).expand(num_edges, input_feature_dim)
+
+    output = output.scatter_add(0, idx0, input.gather(0, idx1))
+    if not directed:
+        output = output.scatter_add(0, idx1, input.gather(0, idx0))
+    return output
+
+
+class GatherScatter(Function):
+    """
+    Torch autograd Function wrapper for gather_scatter C++/CUDA implementations.
+    """
+
+    @staticmethod
+    def forward(ctx, input, edges, directed=False):
+        """
+        Args:
+            ctx: Context object used to calculate gradients.
+            input: Tensor of shape (num_vertices, input_dim)
+            edges: Tensor of edge indices of shape (num_edges, 2)
+            directed: Bool indicating if edges are directed.
+
+        Returns:
+            output: Tensor of same shape as input.
+        """
+        if not (input.dim() == 2):
+            raise ValueError("input can only have 2 dimensions.")
+        if not (edges.dim() == 2):
+            raise ValueError("edges can only have 2 dimensions.")
+        if not (edges.shape[1] == 2):
+            raise ValueError("edges must be of shape (num_edges, 2).")
+        if not (input.dtype == torch.float32):
+            raise ValueError("input has to be of type torch.float32.")
+
+        ctx.directed = directed
+        input, edges = input.contiguous(), edges.contiguous()
+        ctx.save_for_backward(edges)
+        backward = False
+        output = _C.gather_scatter(input, edges, directed, backward)
+        return output
+
+    @staticmethod
+    @once_differentiable
+    def backward(ctx, grad_output):
+        grad_output = grad_output.contiguous()
+        edges = ctx.saved_tensors[0]
+        directed = ctx.directed
+        backward = True
+        grad_input = _C.gather_scatter(grad_output, edges, directed, backward)
+        grad_edges = None
+        grad_directed = None
+        return grad_input, grad_edges, grad_directed
+
+
+gather_scatter = GatherScatter.apply

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

@@ -0,0 +1,101 @@
+# 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
+from pytorch3d import _C
+from torch.autograd import Function
+from torch.autograd.function import once_differentiable
+
+
+def interpolate_face_attributes(
+    pix_to_face: torch.Tensor,
+    barycentric_coords: torch.Tensor,
+    face_attributes: torch.Tensor,
+) -> torch.Tensor:
+    """
+    Interpolate arbitrary face attributes using the barycentric coordinates
+    for each pixel in the rasterized output.
+
+    Args:
+        pix_to_face: LongTensor of shape (...) specifying the indices
+            of the faces (in the packed representation) which overlap each
+            pixel in the image. A value < 0 indicates that the pixel does not
+            overlap any face and should be skipped.
+        barycentric_coords: FloatTensor of shape (N, H, W, K, 3) specifying
+            the barycentric coordinates of each pixel
+            relative to the faces (in the packed
+            representation) which overlap the pixel.
+        face_attributes: packed attributes of shape (total_faces, 3, D),
+            specifying the value of the attribute for each
+            vertex in the face.
+
+    Returns:
+        pixel_vals: tensor of shape (N, H, W, K, D) giving the interpolated
+        value of the face attribute for each pixel.
+    """
+    # Check shapes
+    F, FV, D = face_attributes.shape
+    if FV != 3:
+        raise ValueError("Faces can only have three vertices; got %r" % FV)
+    N, H, W, K, _ = barycentric_coords.shape
+    if pix_to_face.shape != (N, H, W, K):
+        msg = "pix_to_face must have shape (batch_size, H, W, K); got %r"
+        raise ValueError(msg % (pix_to_face.shape,))
+
+    # On CPU use the python version
+    # TODO: Implement a C++ version of this function
+    if not pix_to_face.is_cuda:
+        args = (pix_to_face, barycentric_coords, face_attributes)
+        return interpolate_face_attributes_python(*args)
+
+    # Otherwise flatten and call the custom autograd function
+    N, H, W, K = pix_to_face.shape
+    pix_to_face = pix_to_face.view(-1)
+    barycentric_coords = barycentric_coords.view(N * H * W * K, 3)
+    args = (pix_to_face, barycentric_coords, face_attributes)
+    out = _InterpFaceAttrs.apply(*args)
+    out = out.view(N, H, W, K, -1)
+    return out
+
+
+class _InterpFaceAttrs(Function):
+    @staticmethod
+    def forward(ctx, pix_to_face, barycentric_coords, face_attrs):
+        args = (pix_to_face, barycentric_coords, face_attrs)
+        ctx.save_for_backward(*args)
+        return _C.interp_face_attrs_forward(*args)
+
+    @staticmethod
+    @once_differentiable
+    def backward(ctx, grad_pix_attrs):
+        args = ctx.saved_tensors
+        args = args + (grad_pix_attrs,)
+        grads = _C.interp_face_attrs_backward(*args)
+        grad_pix_to_face = None
+        grad_barycentric_coords = grads[0]
+        grad_face_attrs = grads[1]
+        return grad_pix_to_face, grad_barycentric_coords, grad_face_attrs
+
+
+def interpolate_face_attributes_python(
+    pix_to_face: torch.Tensor,
+    barycentric_coords: torch.Tensor,
+    face_attributes: torch.Tensor,
+) -> torch.Tensor:
+    F, FV, D = face_attributes.shape
+    N, H, W, K, _ = barycentric_coords.shape
+
+    # Replace empty pixels in pix_to_face with 0 in order to interpolate.
+    mask = pix_to_face < 0
+    pix_to_face = pix_to_face.clone()
+    pix_to_face[mask] = 0
+    idx = pix_to_face.view(N * H * W * K, 1, 1).expand(N * H * W * K, 3, D)
+    pixel_face_vals = face_attributes.gather(0, idx).view(N, H, W, K, 3, D)
+    pixel_vals = (barycentric_coords[..., None] * pixel_face_vals).sum(dim=-2)
+    pixel_vals[mask] = 0  # Replace masked values in output.
+    return pixel_vals

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

@@ -0,0 +1,250 @@
+# 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 collections import namedtuple
+from typing import Union
+
+import torch
+from pytorch3d import _C
+from torch.autograd import Function
+from torch.autograd.function import once_differentiable
+
+
+_KNN = namedtuple("KNN", "dists idx knn")
+
+
+class _knn_points(Function):
+    """
+    Torch autograd Function wrapper for KNN C++/CUDA implementations.
+    """
+
+    @staticmethod
+    # pyre-fixme[14]: `forward` overrides method defined in `Function` inconsistently.
+    def forward(
+        ctx,
+        p1,
+        p2,
+        lengths1,
+        lengths2,
+        K,
+        version,
+        norm: int = 2,
+        return_sorted: bool = True,
+    ):
+        """
+        K-Nearest neighbors on point clouds.
+
+        Args:
+            p1: Tensor of shape (N, P1, D) giving a batch of N point clouds, each
+                containing up to P1 points of dimension D.
+            p2: Tensor of shape (N, P2, D) giving a batch of N point clouds, each
+                containing up to P2 points of dimension D.
+            lengths1: LongTensor of shape (N,) of values in the range [0, P1], giving the
+                length of each pointcloud in p1. Or None to indicate that every cloud has
+                length P1.
+            lengths2: LongTensor of shape (N,) of values in the range [0, P2], giving the
+                length of each pointcloud in p2. Or None to indicate that every cloud has
+                length P2.
+            K: Integer giving the number of nearest neighbors to return.
+            version: Which KNN implementation to use in the backend. If version=-1,
+                the correct implementation is selected based on the shapes of the inputs.
+            norm: (int) indicating the norm. Only supports 1 (for L1) and 2 (for L2).
+            return_sorted: (bool) whether to return the nearest neighbors sorted in
+                ascending order of distance.
+
+        Returns:
+            p1_dists: Tensor of shape (N, P1, K) giving the squared distances to
+                the nearest neighbors. This is padded with zeros both where a cloud in p2
+                has fewer than K points and where a cloud in p1 has fewer than P1 points.
+
+            p1_idx: LongTensor of shape (N, P1, K) giving the indices of the
+                K nearest neighbors from points in p1 to points in p2.
+                Concretely, if `p1_idx[n, i, k] = j` then `p2[n, j]` is the k-th nearest
+                neighbors to `p1[n, i]` in `p2[n]`. This is padded with zeros both where a cloud
+                in p2 has fewer than K points and where a cloud in p1 has fewer than P1 points.
+        """
+        if not ((norm == 1) or (norm == 2)):
+            raise ValueError("Support for 1 or 2 norm.")
+
+        idx, dists = _C.knn_points_idx(p1, p2, lengths1, lengths2, norm, K, version)
+
+        # sort KNN in ascending order if K > 1
+        if K > 1 and return_sorted:
+            if lengths2.min() < K:
+                P1 = p1.shape[1]
+                mask = lengths2[:, None] <= torch.arange(K, device=dists.device)[None]
+                # mask has shape [N, K], true where dists irrelevant
+                mask = mask[:, None].expand(-1, P1, -1)
+                # mask has shape [N, P1, K], true where dists irrelevant
+                dists[mask] = float("inf")
+                dists, sort_idx = dists.sort(dim=2)
+                dists[mask] = 0
+            else:
+                dists, sort_idx = dists.sort(dim=2)
+            idx = idx.gather(2, sort_idx)
+
+        ctx.save_for_backward(p1, p2, lengths1, lengths2, idx)
+        ctx.mark_non_differentiable(idx)
+        ctx.norm = norm
+        return dists, idx
+
+    @staticmethod
+    @once_differentiable
+    def backward(ctx, grad_dists, grad_idx):
+        p1, p2, lengths1, lengths2, idx = ctx.saved_tensors
+        norm = ctx.norm
+        # TODO(gkioxari) Change cast to floats once we add support for doubles.
+        if not (grad_dists.dtype == torch.float32):
+            grad_dists = grad_dists.float()
+        if not (p1.dtype == torch.float32):
+            p1 = p1.float()
+        if not (p2.dtype == torch.float32):
+            p2 = p2.float()
+        grad_p1, grad_p2 = _C.knn_points_backward(
+            p1, p2, lengths1, lengths2, idx, norm, grad_dists
+        )
+        return grad_p1, grad_p2, None, None, None, None, None, None
+
+
+def knn_points(
+    p1: torch.Tensor,
+    p2: torch.Tensor,
+    lengths1: Union[torch.Tensor, None] = None,
+    lengths2: Union[torch.Tensor, None] = None,
+    norm: int = 2,
+    K: int = 1,
+    version: int = -1,
+    return_nn: bool = False,
+    return_sorted: bool = True,
+) -> _KNN:
+    """
+    K-Nearest neighbors on point clouds.
+
+    Args:
+        p1: Tensor of shape (N, P1, D) giving a batch of N point clouds, each
+            containing up to P1 points of dimension D.
+        p2: Tensor of shape (N, P2, D) giving a batch of N point clouds, each
+            containing up to P2 points of dimension D.
+        lengths1: LongTensor of shape (N,) of values in the range [0, P1], giving the
+            length of each pointcloud in p1. Or None to indicate that every cloud has
+            length P1.
+        lengths2: LongTensor of shape (N,) of values in the range [0, P2], giving the
+            length of each pointcloud in p2. Or None to indicate that every cloud has
+            length P2.
+        norm: Integer indicating the norm of the distance. Supports only 1 for L1, 2 for L2.
+        K: Integer giving the number of nearest neighbors to return.
+        version: Which KNN implementation to use in the backend. If version=-1,
+            the correct implementation is selected based on the shapes of the inputs.
+        return_nn: If set to True returns the K nearest neighbors in p2 for each point in p1.
+        return_sorted: (bool) whether to return the nearest neighbors sorted in
+            ascending order of distance.
+
+    Returns:
+        dists: Tensor of shape (N, P1, K) giving the squared distances to
+            the nearest neighbors. This is padded with zeros both where a cloud in p2
+            has fewer than K points and where a cloud in p1 has fewer than P1 points.
+
+        idx: LongTensor of shape (N, P1, K) giving the indices of the
+            K nearest neighbors from points in p1 to points in p2.
+            Concretely, if `p1_idx[n, i, k] = j` then `p2[n, j]` is the k-th nearest
+            neighbors to `p1[n, i]` in `p2[n]`. This is padded with zeros both where a cloud
+            in p2 has fewer than K points and where a cloud in p1 has fewer than P1
+            points.
+
+        nn: Tensor of shape (N, P1, K, D) giving the K nearest neighbors in p2 for
+            each point in p1. Concretely, `p2_nn[n, i, k]` gives the k-th nearest neighbor
+            for `p1[n, i]`. Returned if `return_nn` is True.
+            The nearest neighbors are collected using `knn_gather`
+
+            .. code-block::
+
+                p2_nn = knn_gather(p2, p1_idx, lengths2)
+
+            which is a helper function that allows indexing any tensor of shape (N, P2, U) with
+            the indices `p1_idx` returned by `knn_points`. The output is a tensor
+            of shape (N, P1, K, U).
+
+    """
+    if p1.shape[0] != p2.shape[0]:
+        raise ValueError("pts1 and pts2 must have the same batch dimension.")
+    if p1.shape[2] != p2.shape[2]:
+        raise ValueError("pts1 and pts2 must have the same point dimension.")
+
+    p1 = p1.contiguous()
+    p2 = p2.contiguous()
+
+    P1 = p1.shape[1]
+    P2 = p2.shape[1]
+
+    if lengths1 is None:
+        lengths1 = torch.full((p1.shape[0],), P1, dtype=torch.int64, device=p1.device)
+    if lengths2 is None:
+        lengths2 = torch.full((p1.shape[0],), P2, dtype=torch.int64, device=p1.device)
+
+    p1_dists, p1_idx = _knn_points.apply(
+        p1, p2, lengths1, lengths2, K, version, norm, return_sorted
+    )
+
+    p2_nn = None
+    if return_nn:
+        p2_nn = knn_gather(p2, p1_idx, lengths2)
+
+    return _KNN(dists=p1_dists, idx=p1_idx, knn=p2_nn if return_nn else None)
+
+
+def knn_gather(
+    x: torch.Tensor, idx: torch.Tensor, lengths: Union[torch.Tensor, None] = None
+):
+    """
+    A helper function for knn that allows indexing a tensor x with the indices `idx`
+    returned by `knn_points`.
+
+    For example, if `dists, idx = knn_points(p, x, lengths_p, lengths, K)`
+    where p is a tensor of shape (N, L, D) and x a tensor of shape (N, M, D),
+    then one can compute the K nearest neighbors of p with `p_nn = knn_gather(x, idx, lengths)`.
+    It can also be applied for any tensor x of shape (N, M, U) where U != D.
+
+    Args:
+        x: Tensor of shape (N, M, U) containing U-dimensional features to
+            be gathered.
+        idx: LongTensor of shape (N, L, K) giving the indices returned by `knn_points`.
+        lengths: LongTensor of shape (N,) of values in the range [0, M], giving the
+            length of each example in the batch in x. Or None to indicate that every
+            example has length M.
+    Returns:
+        x_out: Tensor of shape (N, L, K, U) resulting from gathering the elements of x
+            with idx, s.t. `x_out[n, l, k] = x[n, idx[n, l, k]]`.
+            If `k > lengths[n]` then `x_out[n, l, k]` is filled with 0.0.
+    """
+    N, M, U = x.shape
+    _N, L, K = idx.shape
+
+    if N != _N:
+        raise ValueError("x and idx must have same batch dimension.")
+
+    if lengths is None:
+        lengths = torch.full((x.shape[0],), M, dtype=torch.int64, device=x.device)
+
+    idx_expanded = idx[:, :, :, None].expand(-1, -1, -1, U)
+    # idx_expanded has shape [N, L, K, U]
+
+    x_out = x[:, :, None].expand(-1, -1, K, -1).gather(1, idx_expanded)
+    # p2_nn has shape [N, L, K, U]
+
+    needs_mask = lengths.min() < K
+    if needs_mask:
+        # mask has shape [N, K], true where idx is irrelevant because
+        # there is less number of points in p2 than K
+        mask = lengths[:, None] <= torch.arange(K, device=x.device)[None]
+
+        # expand mask to shape [N, L, K, U]
+        mask = mask[:, None].expand(-1, L, -1)
+        mask = mask[:, :, :, None].expand(-1, -1, -1, U)
+        x_out[mask] = 0.0
+
+    return x_out

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

@@ -0,0 +1,198 @@
+# 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
+from pytorch3d import _C
+from torch.autograd import Function
+from torch.autograd.function import once_differentiable
+
+
+class _PackedToPadded(Function):
+    """
+    Torch autograd Function wrapper for packed_to_padded C++/CUDA implementations.
+    """
+
+    @staticmethod
+    def forward(ctx, inputs, first_idxs, max_size):
+        """
+        Args:
+            ctx: Context object used to calculate gradients.
+            inputs: FloatTensor of shape (F, D), representing the packed batch tensor.
+                e.g. areas for faces in a batch of meshes.
+            first_idxs: LongTensor of shape (N,) where N is the number of
+                elements in the batch and `first_idxs[i] = f`
+                means that the inputs for batch element i begin at `inputs[f]`.
+            max_size: Max length of an element in the batch.
+
+        Returns:
+            inputs_padded: FloatTensor of shape (N, max_size, D) where max_size is max
+                of `sizes`. The values for batch element i which start at
+                `inputs[first_idxs[i]]` will be copied to `inputs_padded[i, :]`,
+                with zeros padding out the extra inputs.
+        """
+        if not (inputs.dim() == 2):
+            raise ValueError("input can only be 2-dimensional.")
+        if not (first_idxs.dim() == 1):
+            raise ValueError("first_idxs can only be 1-dimensional.")
+        if not (inputs.dtype == torch.float32):
+            raise ValueError("input has to be of type torch.float32.")
+        if not (first_idxs.dtype == torch.int64):
+            raise ValueError("first_idxs has to be of type torch.int64.")
+        if not isinstance(max_size, int):
+            raise ValueError("max_size has to be int.")
+
+        ctx.save_for_backward(first_idxs)
+        ctx.num_inputs = int(inputs.shape[0])
+        inputs, first_idxs = inputs.contiguous(), first_idxs.contiguous()
+        inputs_padded = _C.packed_to_padded(inputs, first_idxs, max_size)
+        return inputs_padded
+
+    @staticmethod
+    @once_differentiable
+    def backward(ctx, grad_output):
+        grad_output = grad_output.contiguous()
+        first_idxs = ctx.saved_tensors[0]
+        num_inputs = ctx.num_inputs
+        grad_input = _C.padded_to_packed(grad_output, first_idxs, num_inputs)
+        return grad_input, None, None
+
+
+def packed_to_padded(
+    inputs: torch.Tensor, first_idxs: torch.LongTensor, max_size: int
+) -> torch.Tensor:
+    """
+    Torch wrapper that handles allowed input shapes. See description below.
+
+    Args:
+        inputs: FloatTensor of shape (F,) or (F, ...), representing the packed
+            batch tensor, e.g. areas for faces in a batch of meshes.
+        first_idxs: LongTensor of shape (N,) where N is the number of
+            elements in the batch and `first_idxs[i] = f`
+            means that the inputs for batch element i begin at `inputs[f]`.
+        max_size: Max length of an element in the batch.
+
+    Returns:
+        inputs_padded: FloatTensor of shape (N, max_size) or (N, max_size, ...)
+            where max_size is max of `sizes`. The values for batch element i
+            which start at `inputs[first_idxs[i]]` will be copied to
+            `inputs_padded[i, :]`, with zeros padding out the extra inputs.
+
+    To handle the allowed input shapes, we convert the inputs tensor of shape
+    (F,) to (F, 1). We reshape the output back to (N, max_size) from
+    (N, max_size, 1).
+    """
+    # if inputs is of shape (F,), reshape into (F, 1)
+    input_shape = inputs.shape
+    n_dims = inputs.dim()
+    if n_dims == 1:
+        inputs = inputs.unsqueeze(1)
+    else:
+        inputs = inputs.reshape(input_shape[0], -1)
+    inputs_padded = _PackedToPadded.apply(inputs, first_idxs, max_size)
+    # if flat is True, reshape output to (N, max_size) from (N, max_size, 1)
+    # else reshape output to (N, max_size, ...)
+    if n_dims == 1:
+        return inputs_padded.squeeze(2)
+    if n_dims == 2:
+        return inputs_padded
+    return inputs_padded.view(*inputs_padded.shape[:2], *input_shape[1:])
+
+
+class _PaddedToPacked(Function):
+    """
+    Torch autograd Function wrapper for padded_to_packed C++/CUDA implementations.
+    """
+
+    @staticmethod
+    def forward(ctx, inputs, first_idxs, num_inputs):
+        """
+        Args:
+            ctx: Context object used to calculate gradients.
+            inputs: FloatTensor of shape (N, max_size, D), representing
+            the padded tensor, e.g. areas for faces in a batch of meshes.
+            first_idxs: LongTensor of shape (N,) where N is the number of
+                elements in the batch and `first_idxs[i] = f`
+                means that the inputs for batch element i begin at `inputs_packed[f]`.
+            num_inputs: Number of packed entries (= F)
+
+        Returns:
+            inputs_packed: FloatTensor of shape (F, D) where
+                `inputs_packed[first_idx[i]:] = inputs[i, :]`.
+        """
+        if not (inputs.dim() == 3):
+            raise ValueError("input can only be 3-dimensional.")
+        if not (first_idxs.dim() == 1):
+            raise ValueError("first_idxs can only be 1-dimensional.")
+        if not (inputs.dtype == torch.float32):
+            raise ValueError("input has to be of type torch.float32.")
+        if not (first_idxs.dtype == torch.int64):
+            raise ValueError("first_idxs has to be of type torch.int64.")
+        if not isinstance(num_inputs, int):
+            raise ValueError("max_size has to be int.")
+
+        ctx.save_for_backward(first_idxs)
+        ctx.max_size = inputs.shape[1]
+        inputs, first_idxs = inputs.contiguous(), first_idxs.contiguous()
+        inputs_packed = _C.padded_to_packed(inputs, first_idxs, num_inputs)
+        return inputs_packed
+
+    @staticmethod
+    @once_differentiable
+    def backward(ctx, grad_output):
+        grad_output = grad_output.contiguous()
+        first_idxs = ctx.saved_tensors[0]
+        max_size = ctx.max_size
+        grad_input = _C.packed_to_padded(grad_output, first_idxs, max_size)
+        return grad_input, None, None
+
+
+def padded_to_packed(
+    inputs: torch.Tensor,
+    first_idxs: torch.LongTensor,
+    num_inputs: int,
+    max_size_dim: int = 1,
+) -> torch.Tensor:
+    """
+    Torch wrapper that handles allowed input shapes. See description below.
+
+    Args:
+        inputs: FloatTensor of shape (N, ..., max_size) or (N, ..., max_size, ...),
+            representing the padded tensor, e.g. areas for faces in a batch of
+            meshes, where max_size occurs on max_size_dim-th position.
+        first_idxs: LongTensor of shape (N,) where N is the number of
+            elements in the batch and `first_idxs[i] = f`
+            means that the inputs for batch element i begin at `inputs_packed[f]`.
+        num_inputs: Number of packed entries (= F)
+        max_size_dim: the dimension to be packed
+
+    Returns:
+        inputs_packed: FloatTensor of shape (F,) or (F, ...) where
+            `inputs_packed[first_idx[i]:first_idx[i+1]] = inputs[i, ..., :delta[i]]`,
+            where `delta[i] = first_idx[i+1] - first_idx[i]`.
+
+    To handle the allowed input shapes, we convert the inputs tensor of shape
+    (N, max_size) to (N, max_size, 1). We reshape the output back to (F,) from
+    (F, 1).
+    """
+    n_dims = inputs.dim()
+    # move the variable dim to position 1
+    inputs = inputs.movedim(max_size_dim, 1)
+
+    # if inputs is of shape (N, max_size), reshape into (N, max_size, 1))
+    input_shape = inputs.shape
+    if n_dims == 2:
+        inputs = inputs.unsqueeze(2)
+    else:
+        inputs = inputs.reshape(*input_shape[:2], -1)
+    inputs_packed = _PaddedToPacked.apply(inputs, first_idxs, num_inputs)
+    # if input is flat, reshape output to (F,) from (F, 1)
+    # else reshape output to (F, ...)
+    if n_dims == 2:
+        return inputs_packed.squeeze(1)
+
+    return inputs_packed.view(-1, *input_shape[2:])

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

@@ -0,0 +1,191 @@
+# 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 Tuple, TYPE_CHECKING, Union
+
+import torch
+from pytorch3d.common.workaround import symeig3x3
+
+from .utils import convert_pointclouds_to_tensor, get_point_covariances
+
+
+if TYPE_CHECKING:
+    from ..structures import Pointclouds
+
+
+def estimate_pointcloud_normals(
+    pointclouds: Union[torch.Tensor, "Pointclouds"],
+    neighborhood_size: int = 50,
+    disambiguate_directions: bool = True,
+    *,
+    use_symeig_workaround: bool = True,
+) -> torch.Tensor:
+    """
+    Estimates the normals of a batch of `pointclouds`.
+
+    The function uses `estimate_pointcloud_local_coord_frames` to estimate
+    the normals. Please refer to that function for more detailed information.
+
+    Args:
+      **pointclouds**: Batch of 3-dimensional points of shape
+        `(minibatch, num_point, 3)` or a `Pointclouds` object.
+      **neighborhood_size**: The size of the neighborhood used to estimate the
+        geometry around each point.
+      **disambiguate_directions**: If `True`, uses the algorithm from [1] to
+        ensure sign consistency of the normals of neighboring points.
+      **use_symeig_workaround**: If `True`, uses a custom eigenvalue
+        calculation.
+
+    Returns:
+      **normals**: A tensor of normals for each input point
+        of shape `(minibatch, num_point, 3)`.
+        If `pointclouds` are of `Pointclouds` class, returns a padded tensor.
+
+    References:
+      [1] Tombari, Salti, Di Stefano: Unique Signatures of Histograms for
+      Local Surface Description, ECCV 2010.
+    """
+
+    curvatures, local_coord_frames = estimate_pointcloud_local_coord_frames(
+        pointclouds,
+        neighborhood_size=neighborhood_size,
+        disambiguate_directions=disambiguate_directions,
+        use_symeig_workaround=use_symeig_workaround,
+    )
+
+    # the normals correspond to the first vector of each local coord frame
+    normals = local_coord_frames[:, :, :, 0]
+
+    return normals
+
+
+def estimate_pointcloud_local_coord_frames(
+    pointclouds: Union[torch.Tensor, "Pointclouds"],
+    neighborhood_size: int = 50,
+    disambiguate_directions: bool = True,
+    *,
+    use_symeig_workaround: bool = True,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Estimates the principal directions of curvature (which includes normals)
+    of a batch of `pointclouds`.
+
+    The algorithm first finds `neighborhood_size` nearest neighbors for each
+    point of the point clouds, followed by obtaining principal vectors of
+    covariance matrices of each of the point neighborhoods.
+    The main principal vector corresponds to the normals, while the
+    other 2 are the direction of the highest curvature and the 2nd highest
+    curvature.
+
+    Note that each principal direction is given up to a sign. Hence,
+    the function implements `disambiguate_directions` switch that allows
+    to ensure consistency of the sign of neighboring normals. The implementation
+    follows the sign disabiguation from SHOT descriptors [1].
+
+    The algorithm also returns the curvature values themselves.
+    These are the eigenvalues of the estimated covariance matrices
+    of each point neighborhood.
+
+    Args:
+      **pointclouds**: Batch of 3-dimensional points of shape
+        `(minibatch, num_point, 3)` or a `Pointclouds` object.
+      **neighborhood_size**: The size of the neighborhood used to estimate the
+        geometry around each point.
+      **disambiguate_directions**: If `True`, uses the algorithm from [1] to
+        ensure sign consistency of the normals of neighboring points.
+      **use_symeig_workaround**: If `True`, uses a custom eigenvalue
+        calculation.
+
+    Returns:
+      **curvatures**: The three principal curvatures of each point
+        of shape `(minibatch, num_point, 3)`.
+        If `pointclouds` are of `Pointclouds` class, returns a padded tensor.
+      **local_coord_frames**: The three principal directions of the curvature
+        around each point of shape `(minibatch, num_point, 3, 3)`.
+        The principal directions are stored in columns of the output.
+        E.g. `local_coord_frames[i, j, :, 0]` is the normal of
+        `j`-th point in the `i`-th pointcloud.
+        If `pointclouds` are of `Pointclouds` class, returns a padded tensor.
+
+    References:
+      [1] Tombari, Salti, Di Stefano: Unique Signatures of Histograms for
+      Local Surface Description, ECCV 2010.
+    """
+
+    points_padded, num_points = convert_pointclouds_to_tensor(pointclouds)
+
+    ba, N, dim = points_padded.shape
+    if dim != 3:
+        raise ValueError(
+            "The pointclouds argument has to be of shape (minibatch, N, 3)"
+        )
+
+    if (num_points <= neighborhood_size).any():
+        raise ValueError(
+            "The neighborhood_size argument has to be"
+            + " >= size of each of the point clouds."
+        )
+
+    # undo global mean for stability
+    # TODO: replace with tutil.wmean once landed
+    pcl_mean = points_padded.sum(1) / num_points[:, None]
+    points_centered = points_padded - pcl_mean[:, None, :]
+
+    # get the per-point covariance and nearest neighbors used to compute it
+    cov, knns = get_point_covariances(points_centered, num_points, neighborhood_size)
+
+    # get the local coord frames as principal directions of
+    # the per-point covariance
+    # this is done with torch.symeig / torch.linalg.eigh, which returns the
+    # eigenvectors (=principal directions) in an ascending order of their
+    # corresponding eigenvalues, and the smallest eigenvalue's eigenvector
+    # corresponds to the normal direction; or with a custom equivalent.
+    if use_symeig_workaround:
+        curvatures, local_coord_frames = symeig3x3(cov, eigenvectors=True)
+    else:
+        curvatures, local_coord_frames = torch.linalg.eigh(cov)
+
+    # disambiguate the directions of individual principal vectors
+    if disambiguate_directions:
+        # disambiguate normal
+        n = _disambiguate_vector_directions(
+            points_centered, knns, local_coord_frames[:, :, :, 0]
+        )
+        # disambiguate the main curvature
+        z = _disambiguate_vector_directions(
+            points_centered, knns, local_coord_frames[:, :, :, 2]
+        )
+        # the secondary curvature is just a cross between n and z
+        y = torch.cross(n, z, dim=2)
+        # cat to form the set of principal directions
+        local_coord_frames = torch.stack((n, y, z), dim=3)
+
+    return curvatures, local_coord_frames
+
+
+def _disambiguate_vector_directions(pcl, knns, vecs: torch.Tensor) -> torch.Tensor:
+    """
+    Disambiguates normal directions according to [1].
+
+    References:
+      [1] Tombari, Salti, Di Stefano: Unique Signatures of Histograms for
+      Local Surface Description, ECCV 2010.
+    """
+    # parse out K from the shape of knns
+    K = knns.shape[2]
+    # the difference between the mean of each neighborhood and
+    # each element of the neighborhood
+    df = knns - pcl[:, :, None]
+    # projection of the difference on the principal direction
+    proj = (vecs[:, :, None] * df).sum(3)
+    # check how many projections are positive
+    n_pos = (proj > 0).type_as(knns).sum(2, keepdim=True)
+    # flip the principal directions where number of positive correlations
+    flip = (n_pos < (0.5 * K)).type_as(knns)
+    vecs = (1.0 - 2.0 * flip) * vecs
+    return vecs

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

@@ -0,0 +1,202 @@
+# 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 random import randint
+from typing import List, Optional, Tuple, Union
+
+import torch
+from pytorch3d import _C
+
+from .utils import masked_gather
+
+
+def sample_farthest_points(
+    points: torch.Tensor,
+    lengths: Optional[torch.Tensor] = None,
+    K: Union[int, List, torch.Tensor] = 50,
+    random_start_point: bool = False,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Iterative farthest point sampling algorithm [1] to subsample a set of
+    K points from a given pointcloud. At each iteration, a point is selected
+    which has the largest nearest neighbor distance to any of the
+    already selected points.
+
+    Farthest point sampling provides more uniform coverage of the input
+    point cloud compared to uniform random sampling.
+
+    [1] Charles R. Qi et al, "PointNet++: Deep Hierarchical Feature Learning
+        on Point Sets in a Metric Space", NeurIPS 2017.
+
+    Args:
+        points: (N, P, D) array containing the batch of pointclouds
+        lengths: (N,) number of points in each pointcloud (to support heterogeneous
+            batches of pointclouds)
+        K: samples required in each sampled point cloud (this is typically << P). If
+            K is an int then the same number of samples are selected for each
+            pointcloud in the batch. If K is a tensor is should be length (N,)
+            giving the number of samples to select for each element in the batch
+        random_start_point: bool, if True, a random point is selected as the starting
+            point for iterative sampling.
+
+    Returns:
+        selected_points: (N, K, D), array of selected values from points. If the input
+            K is a tensor, then the shape will be (N, max(K), D), and padded with
+            0.0 for batch elements where k_i < max(K).
+        selected_indices: (N, K) array of selected indices. If the input
+            K is a tensor, then the shape will be (N, max(K), D), and padded with
+            -1 for batch elements where k_i < max(K).
+    """
+    N, P, D = points.shape
+    device = points.device
+
+    constant_length = lengths is None
+    # Validate inputs
+    if lengths is None:
+        lengths = torch.full((N,), P, dtype=torch.int64, device=device)
+    else:
+        if lengths.shape != (N,):
+            raise ValueError("points and lengths must have same batch dimension.")
+        if lengths.max() > P:
+            raise ValueError("A value in lengths was too large.")
+
+    # TODO: support providing K as a ratio of the total number of points instead of as an int
+    max_K = -1
+    if isinstance(K, int):
+        max_K = K
+        K = torch.full((N,), K, dtype=torch.int64, device=device)
+    elif isinstance(K, list):
+        K = torch.tensor(K, dtype=torch.int64, device=device)
+
+    if K.shape[0] != N:
+        raise ValueError("K and points must have the same batch dimension")
+
+    # Check dtypes are correct and convert if necessary
+    if not (points.dtype == torch.float32):
+        points = points.to(torch.float32)
+    if not (lengths.dtype == torch.int64):
+        lengths = lengths.to(torch.int64)
+    if not (K.dtype == torch.int64):
+        K = K.to(torch.int64)
+
+    # Generate the starting indices for sampling
+    if random_start_point:
+        if constant_length:
+            start_idxs = torch.randint(high=P, size=(N,), device=device)
+        else:
+            start_idxs = (lengths * torch.rand(lengths.size())).to(torch.int64)
+    else:
+        start_idxs = torch.zeros_like(lengths)
+
+    with torch.no_grad():
+        # pyre-fixme[16]: `pytorch3d_._C` has no attribute `sample_farthest_points`.
+        idx = _C.sample_farthest_points(points, lengths, K, start_idxs, max_K)
+    sampled_points = masked_gather(points, idx)
+
+    return sampled_points, idx
+
+
+def sample_farthest_points_naive(
+    points: torch.Tensor,
+    lengths: Optional[torch.Tensor] = None,
+    K: Union[int, List, torch.Tensor] = 50,
+    random_start_point: bool = False,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Same Args/Returns as sample_farthest_points
+    """
+    N, P, D = points.shape
+    device = points.device
+
+    # Validate inputs
+    if lengths is None:
+        lengths = torch.full((N,), P, dtype=torch.int64, device=device)
+    else:
+        if lengths.shape != (N,):
+            raise ValueError("points and lengths must have same batch dimension.")
+        if lengths.max() > P:
+            raise ValueError("Invalid lengths.")
+
+    # TODO: support providing K as a ratio of the total number of points instead of as an int
+    if isinstance(K, int):
+        K = torch.full((N,), K, dtype=torch.int64, device=device)
+    elif isinstance(K, list):
+        K = torch.tensor(K, dtype=torch.int64, device=device)
+
+    if K.shape[0] != N:
+        raise ValueError("K and points must have the same batch dimension")
+
+    # Find max value of K
+    max_K = torch.max(K)
+
+    # List of selected indices from each batch element
+    all_sampled_indices = []
+
+    for n in range(N):
+        # Initialize an array for the sampled indices, shape: (max_K,)
+        sample_idx_batch = torch.full(
+            # pyre-fixme[6]: For 1st param expected `Union[List[int], Size,
+            #  typing.Tuple[int, ...]]` but got `Tuple[Tensor]`.
+            (max_K,),
+            fill_value=-1,
+            dtype=torch.int64,
+            device=device,
+        )
+
+        # Initialize closest distances to inf, shape: (P,)
+        # This will be updated at each iteration to track the closest distance of the
+        # remaining points to any of the selected points
+        closest_dists = points.new_full(
+            # pyre-fixme[6]: For 1st param expected `Union[List[int], Size,
+            #  typing.Tuple[int, ...]]` but got `Tuple[Tensor]`.
+            (lengths[n],),
+            float("inf"),
+            dtype=torch.float32,
+        )
+
+        # Select a random point index and save it as the starting point
+        # pyre-fixme[6]: For 2nd argument expected `int` but got `Tensor`.
+        selected_idx = randint(0, lengths[n] - 1) if random_start_point else 0
+        sample_idx_batch[0] = selected_idx
+
+        # If the pointcloud has fewer than K points then only iterate over the min
+        # pyre-fixme[6]: For 1st param expected `SupportsRichComparisonT` but got
+        #  `Tensor`.
+        # pyre-fixme[6]: For 2nd param expected `SupportsRichComparisonT` but got
+        #  `Tensor`.
+        k_n = min(lengths[n], K[n])
+
+        # Iteratively select points for a maximum of k_n
+        for i in range(1, k_n):
+            # Find the distance between the last selected point
+            # and all the other points. If a point has already been selected
+            # it's distance will be 0.0 so it will not be selected again as the max.
+            dist = points[n, selected_idx, :] - points[n, : lengths[n], :]
+            # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and
+            #  `int`.
+            dist_to_last_selected = (dist**2).sum(-1)  # (P - i)
+
+            # If closer than currently saved distance to one of the selected
+            # points, then updated closest_dists
+            closest_dists = torch.min(dist_to_last_selected, closest_dists)  # (P - i)
+
+            # The aim is to pick the point that has the largest
+            # nearest neighbour distance to any of the already selected points
+            selected_idx = torch.argmax(closest_dists)
+            sample_idx_batch[i] = selected_idx
+
+        # Add the list of points for this batch to the final list
+        all_sampled_indices.append(sample_idx_batch)
+
+    all_sampled_indices = torch.stack(all_sampled_indices, dim=0)
+
+    # Gather the points
+    all_sampled_points = masked_gather(points, all_sampled_indices)
+
+    # Return (N, max_K, D) subsampled points and indices
+    return all_sampled_points, all_sampled_indices

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

@@ -0,0 +1,180 @@
+# 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
+
+
+"""
+This module implements utility functions for sampling points from
+batches of meshes.
+"""
+
+import sys
+from typing import Tuple, Union
+
+import torch
+
+from pytorch3d.ops.mesh_face_areas_normals import mesh_face_areas_normals
+
+from pytorch3d.ops.packed_to_padded import packed_to_padded
+from pytorch3d.renderer.mesh.rasterizer import Fragments as MeshFragments
+
+
+def sample_points_from_meshes(
+    meshes,
+    num_samples: int = 10000,
+    return_normals: bool = False,
+    return_textures: bool = False,
+) -> Union[
+    torch.Tensor,
+    Tuple[torch.Tensor, torch.Tensor],
+    Tuple[torch.Tensor, torch.Tensor, torch.Tensor],
+]:
+    """
+    Convert a batch of meshes to a batch of pointclouds by uniformly sampling
+    points on the surface of the mesh with probability proportional to the
+    face area.
+
+    Args:
+        meshes: A Meshes object with a batch of N meshes.
+        num_samples: Integer giving the number of point samples per mesh.
+        return_normals: If True, return normals for the sampled points.
+        return_textures: If True, return textures for the sampled points.
+
+    Returns:
+        3-element tuple containing
+
+        - **samples**: FloatTensor of shape (N, num_samples, 3) giving the
+          coordinates of sampled points for each mesh in the batch. For empty
+          meshes the corresponding row in the samples array will be filled with 0.
+        - **normals**: FloatTensor of shape (N, num_samples, 3) giving a normal vector
+          to each sampled point. Only returned if return_normals is True.
+          For empty meshes the corresponding row in the normals array will
+          be filled with 0.
+        - **textures**: FloatTensor of shape (N, num_samples, C) giving a C-dimensional
+          texture vector to each sampled point. Only returned if return_textures is True.
+          For empty meshes the corresponding row in the textures array will
+          be filled with 0.
+
+        Note that in a future releases, we will replace the 3-element tuple output
+        with a `Pointclouds` datastructure, as follows
+
+        .. code-block:: python
+
+            Pointclouds(samples, normals=normals, features=textures)
+    """
+    if meshes.isempty():
+        raise ValueError("Meshes are empty.")
+
+    verts = meshes.verts_packed()
+    if not torch.isfinite(verts).all():
+        raise ValueError("Meshes contain nan or inf.")
+
+    if return_textures and meshes.textures is None:
+        raise ValueError("Meshes do not contain textures.")
+
+    faces = meshes.faces_packed()
+    mesh_to_face = meshes.mesh_to_faces_packed_first_idx()
+    num_meshes = len(meshes)
+    num_valid_meshes = torch.sum(meshes.valid)  # Non empty meshes.
+
+    # Initialize samples tensor with fill value 0 for empty meshes.
+    samples = torch.zeros((num_meshes, num_samples, 3), device=meshes.device)
+
+    # Only compute samples for non empty meshes
+    with torch.no_grad():
+        areas, _ = mesh_face_areas_normals(verts, faces)  # Face areas can be zero.
+        max_faces = meshes.num_faces_per_mesh().max().item()
+        areas_padded = packed_to_padded(
+            areas, mesh_to_face[meshes.valid], max_faces
+        )  # (N, F)
+
+        # TODO (gkioxari) Confirm multinomial bug is not present with real data.
+        sample_face_idxs = areas_padded.multinomial(
+            num_samples, replacement=True
+        )  # (N, num_samples)
+        sample_face_idxs += mesh_to_face[meshes.valid].view(num_valid_meshes, 1)
+
+    # Get the vertex coordinates of the sampled faces.
+    face_verts = verts[faces]
+    v0, v1, v2 = face_verts[:, 0], face_verts[:, 1], face_verts[:, 2]
+
+    # Randomly generate barycentric coords.
+    w0, w1, w2 = _rand_barycentric_coords(
+        num_valid_meshes, num_samples, verts.dtype, verts.device
+    )
+
+    # Use the barycentric coords to get a point on each sampled face.
+    a = v0[sample_face_idxs]  # (N, num_samples, 3)
+    b = v1[sample_face_idxs]
+    c = v2[sample_face_idxs]
+    samples[meshes.valid] = w0[:, :, None] * a + w1[:, :, None] * b + w2[:, :, None] * c
+
+    if return_normals:
+        # Initialize normals tensor with fill value 0 for empty meshes.
+        # Normals for the sampled points are face normals computed from
+        # the vertices of the face in which the sampled point lies.
+        normals = torch.zeros((num_meshes, num_samples, 3), device=meshes.device)
+        vert_normals = (v1 - v0).cross(v2 - v1, dim=1)
+        vert_normals = vert_normals / vert_normals.norm(dim=1, p=2, keepdim=True).clamp(
+            min=sys.float_info.epsilon
+        )
+        vert_normals = vert_normals[sample_face_idxs]
+        normals[meshes.valid] = vert_normals
+
+    if return_textures:
+        # fragment data are of shape NxHxWxK. Here H=S, W=1 & K=1.
+        pix_to_face = sample_face_idxs.view(len(meshes), num_samples, 1, 1)  # NxSx1x1
+        bary = torch.stack((w0, w1, w2), dim=2).unsqueeze(2).unsqueeze(2)  # NxSx1x1x3
+        # zbuf and dists are not used in `sample_textures` so we initialize them with dummy
+        dummy = torch.zeros(
+            (len(meshes), num_samples, 1, 1), device=meshes.device, dtype=torch.float32
+        )  # NxSx1x1
+        fragments = MeshFragments(
+            pix_to_face=pix_to_face, zbuf=dummy, bary_coords=bary, dists=dummy
+        )
+        textures = meshes.sample_textures(fragments)  # NxSx1x1xC
+        textures = textures[:, :, 0, 0, :]  # NxSxC
+
+    # return
+    # TODO(gkioxari) consider returning a Pointclouds instance [breaking]
+    if return_normals and return_textures:
+        # pyre-fixme[61]: `normals` may not be initialized here.
+        # pyre-fixme[61]: `textures` may not be initialized here.
+        return samples, normals, textures
+    if return_normals:  # return_textures is False
+        # pyre-fixme[61]: `normals` may not be initialized here.
+        return samples, normals
+    if return_textures:  # return_normals is False
+        # pyre-fixme[61]: `textures` may not be initialized here.
+        return samples, textures
+    return samples
+
+
+def _rand_barycentric_coords(
+    size1, size2, dtype: torch.dtype, device: torch.device
+) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    """
+    Helper function to generate random barycentric coordinates which are uniformly
+    distributed over a triangle.
+
+    Args:
+        size1, size2: The number of coordinates generated will be size1*size2.
+                      Output tensors will each be of shape (size1, size2).
+        dtype: Datatype to generate.
+        device: A torch.device object on which the outputs will be allocated.
+
+    Returns:
+        w0, w1, w2: Tensors of shape (size1, size2) giving random barycentric
+            coordinates
+    """
+    uv = torch.rand(2, size1, size2, dtype=dtype, device=device)
+    u, v = uv[0], uv[1]
+    u_sqrt = u.sqrt()
+    w0 = 1.0 - u_sqrt
+    w1 = u_sqrt * (1.0 - v)
+    w2 = u_sqrt * v
+    return w0, w1, w2

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

@@ -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.
+
+# pyre-unsafe
+
+
+import torch
+import torch.nn.functional as F
+
+
+def vert_align(
+    feats,
+    verts,
+    return_packed: bool = False,
+    interp_mode: str = "bilinear",
+    padding_mode: str = "zeros",
+    align_corners: bool = True,
+) -> torch.Tensor:
+    """
+    Sample vertex features from a feature map. This operation is called
+    "perceptual feature pooling" in [1] or "vert align" in [2].
+
+    [1] Wang et al, "Pixel2Mesh: Generating 3D Mesh Models from Single
+        RGB Images", ECCV 2018.
+    [2] Gkioxari et al, "Mesh R-CNN", ICCV 2019
+
+    Args:
+        feats: FloatTensor of shape (N, C, H, W) representing image features
+            from which to sample or a list of features each with potentially
+            different C, H or W dimensions.
+        verts: FloatTensor of shape (N, V, 3) or an object (e.g. Meshes or Pointclouds)
+            with `verts_padded' or `points_padded' as an attribute giving the (x, y, z)
+            vertex positions for which to sample. (x, y) verts should be normalized such
+            that (-1, -1) corresponds to top-left and (+1, +1) to bottom-right
+            location in the input feature map.
+        return_packed: (bool) Indicates whether to return packed features
+        interp_mode: (str) Specifies how to interpolate features.
+            ('bilinear' or 'nearest')
+        padding_mode: (str) Specifies how to handle vertices outside of the
+            [-1, 1] range. ('zeros', 'reflection', or 'border')
+        align_corners (bool): Geometrically, we consider the pixels of the
+            input  as squares rather than points.
+            If set to ``True``, the extrema (``-1`` and ``1``) are considered as
+            referring to the center points of the input's corner pixels. If set
+            to ``False``, they are instead considered as referring to the corner
+            points of the input's corner pixels, making the sampling more
+            resolution agnostic. Default: ``True``
+
+    Returns:
+        feats_sampled: FloatTensor of shape (N, V, C) giving sampled features for each
+            vertex. If feats is a list, we return concatenated features in axis=2 of
+            shape (N, V, sum(C_n)) where C_n = feats[n].shape[1].
+            If return_packed = True, the features are transformed to a packed
+            representation of shape (sum(V), C)
+    """
+    if torch.is_tensor(verts):
+        if verts.dim() != 3:
+            raise ValueError("verts tensor should be 3 dimensional")
+        grid = verts
+    elif hasattr(verts, "verts_padded"):
+        grid = verts.verts_padded()
+    elif hasattr(verts, "points_padded"):
+        grid = verts.points_padded()
+    else:
+        raise ValueError(
+            "verts must be a tensor or have a "
+            + "`points_padded' or`verts_padded` attribute."
+        )
+
+    grid = grid[:, None, :, :2]  # (N, 1, V, 2)
+
+    if torch.is_tensor(feats):
+        feats = [feats]
+    for feat in feats:
+        if feat.dim() != 4:
+            raise ValueError("feats must have shape (N, C, H, W)")
+        if grid.shape[0] != feat.shape[0]:
+            raise ValueError("inconsistent batch dimension")
+
+    feats_sampled = []
+    for feat in feats:
+        feat_sampled = F.grid_sample(
+            feat,
+            grid,
+            mode=interp_mode,
+            padding_mode=padding_mode,
+            align_corners=align_corners,
+        )  # (N, C, 1, V)
+        feat_sampled = feat_sampled.squeeze(dim=2).transpose(1, 2)  # (N, V, C)
+        feats_sampled.append(feat_sampled)
+    feats_sampled = torch.cat(feats_sampled, dim=2)  # (N, V, sum(C))
+
+    if return_packed:
+        # flatten the first two dimensions: (N*V, C)
+        feats_sampled = feats_sampled.view(-1, feats_sampled.shape[-1])
+        if hasattr(verts, "verts_padded_to_packed_idx"):
+            idx = (
+                verts.verts_padded_to_packed_idx()
+                .view(-1, 1)
+                .expand(-1, feats_sampled.shape[-1])
+            )
+            feats_sampled = feats_sampled.gather(0, idx)  # (sum(V), C)
+
+    return feats_sampled