conquer3d 0.2.1__tar.gz → 0.2.4__tar.gz

{conquer3d-0.2.1/conquer3d.egg-info → conquer3d-0.2.4}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: conquer3d
-Version: 0.2.1
+Version: 0.2.4
 Summary: Geometric Cuda Tool Box
 Author-email: Do Hoang Khoi <khoido8899@gmail.com>
-License: MIT
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/KhoiDOO/conquer3d
 Project-URL: Repository, https://github.com/KhoiDOO/conquer3d.git
 Project-URL: Documentation, https://github.com/KhoiDOO/conquer3d#readme
@@ -90,5 +90,7 @@ series = {EGGH-HPG'12}
 ## Repository
 - [cuBQL](https://github.com/NVIDIA/cuBQL)
 - [cudaKDTree](https://github.com/ingowald/cudaKDTree)
-- [Kaolin] (https://github.com/NVIDIAGameWorks/kaolin)
-- [Pytorch3D] (https://github.com/facebookresearch/pytorch3d)
+- [Kaolin](https://github.com/NVIDIAGameWorks/kaolin)
+- [Pytorch3D](https://github.com/facebookresearch/pytorch3d)
+- [Open3D](https://www.open3d.org/)
+- [trimesh](https://github.com/mikedh/trimesh)

{conquer3d-0.2.1 → conquer3d-0.2.4}/README.md

@@ -66,5 +66,7 @@ series = {EGGH-HPG'12}
 ## Repository
 - [cuBQL](https://github.com/NVIDIA/cuBQL)
 - [cudaKDTree](https://github.com/ingowald/cudaKDTree)
-- [Kaolin] (https://github.com/NVIDIAGameWorks/kaolin)
-- [Pytorch3D] (https://github.com/facebookresearch/pytorch3d)
+- [Kaolin](https://github.com/NVIDIAGameWorks/kaolin)
+- [Pytorch3D](https://github.com/facebookresearch/pytorch3d)
+- [Open3D](https://www.open3d.org/)
+- [trimesh](https://github.com/mikedh/trimesh)

{conquer3d-0.2.1 → conquer3d-0.2.4}/conquer3d/_C.pyi

@@ -4,7 +4,7 @@ Geocutool Python bindings
 from __future__ import annotations
 import torch
 import typing
-__all__: list[str] = ['BVH', 'GSBVH', 'KDTree', 'PGSBVH', 'compute_gs_aabb_func', 'compute_gs_covi_func', 'solve_gs_neighbor_mahalanobis_radius_func', 'solve_pgs_cluster_tangency_radius_func']
+__all__: list[str] = ['BVH', 'GSBVH', 'KDTree', 'MeshBVH', 'PGSBVH', 'TriangleMesh', 'compute_gs_aabb_func', 'compute_gs_covi_func', 'create_sphere', 'solve_gs_neighbor_mahalanobis_radius_func', 'solve_pgs_cluster_tangency_radius_func']
 class BVH:
     def __init__(self, in_aabb_mins: torch.Tensor, in_aabb_maxs: torch.Tensor) -> None:
         """
@@ -14,6 +14,10 @@ class BVH:
         """
         Query the BVH with bounding boxes or segments. Returns (query_ids, object_ids).
         """
+    def query_self(self) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Query the BVH against itself. Returns unique overlapping (query_ids, object_ids).
+        """
 class GSBVH(BVH):
     def __init__(self, in_aabb_mins: torch.Tensor, in_aabb_maxs: torch.Tensor) -> None:
         """
@@ -40,6 +44,19 @@ class KDTree:
         """
         Queries the KDTree for the K nearest neighbors.
         """
+class MeshBVH(BVH):
+    def __init__(self, in_aabb_mins: torch.Tensor, in_aabb_maxs: torch.Tensor) -> None:
+        """
+        Construct MeshBVH from Triangle AABBs.
+        """
+    def get_self_intersection(self, vertices: torch.Tensor, triangles: torch.Tensor) -> torch.Tensor:
+        """
+        Find all self-intersecting triangle pairs
+        """
+    def is_self_intersection(self, vertices: torch.Tensor, triangles: torch.Tensor) -> bool:
+        """
+        Check if there are any self-intersecting triangle pairs
+        """
 class PGSBVH(BVH):
     def __init__(self, in_aabb_mins: torch.Tensor, in_aabb_maxs: torch.Tensor) -> None:
         """
@@ -53,6 +70,91 @@ class PGSBVH(BVH):
         """
         Perform exact Broad-to-Narrow phase intersection between Voxels and PGS.
         """
+class TriangleMesh:
+    def __init__(self, in_vertices: torch.Tensor, in_triangles: torch.Tensor, in_vertex_normals: torch.Tensor | None = None, in_vertex_colors: torch.Tensor | None = None) -> None:
+        ...
+    def build_bvh(self) -> MeshBVH:
+        ...
+    def compute_edges_to_triangle_map(self) -> None:
+        ...
+    def compute_triangle_areas(self) -> None:
+        ...
+    def compute_triangle_normals(self) -> None:
+        ...
+    def compute_vertices_to_triangle_map(self) -> None:
+        ...
+    def get_edges_to_triangle_map(self) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        ...
+    def get_non_manifold_vertices(self) -> torch.Tensor:
+        ...
+    def get_self_intersection(self) -> torch.Tensor:
+        ...
+    def get_vertices_to_triangle_map(self) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        ...
+    def is_edge_manifold(self, allow_boundary_edge: bool = True) -> bool:
+        ...
+    def is_manifold(self, allow_boundary_edge: bool = True) -> bool:
+        ...
+    def is_self_intersection(self) -> bool:
+        ...
+    def is_vertex_manifold(self) -> bool:
+        ...
+    def remove_triangles_by_mask(self, keep_mask: torch.Tensor) -> None:
+        ...
+    @property
+    def bvh(self) -> MeshBVH:
+        ...
+    @property
+    def edge_to_triangle_counts(self) -> torch.Tensor:
+        ...
+    @property
+    def edge_to_triangle_indices(self) -> torch.Tensor:
+        ...
+    @property
+    def edge_to_triangle_offsets(self) -> torch.Tensor:
+        ...
+    @property
+    def edges(self) -> torch.Tensor:
+        ...
+    @property
+    def euler_characteristic(self) -> int:
+        ...
+    @property
+    def genus(self) -> int:
+        ...
+    @property
+    def num_triangles(self) -> int:
+        ...
+    @property
+    def surface_area(self) -> torch.Tensor:
+        ...
+    @property
+    def triangle_areas(self) -> torch.Tensor:
+        ...
+    @property
+    def triangle_normals(self) -> torch.Tensor:
+        ...
+    @property
+    def triangles(self) -> torch.Tensor:
+        ...
+    @property
+    def vertex_colors(self) -> torch.Tensor:
+        ...
+    @property
+    def vertex_normals(self) -> torch.Tensor:
+        ...
+    @property
+    def vertex_to_triangle_counts(self) -> torch.Tensor:
+        ...
+    @property
+    def vertex_to_triangle_indices(self) -> torch.Tensor:
+        ...
+    @property
+    def vertex_to_triangle_offsets(self) -> torch.Tensor:
+        ...
+    @property
+    def vertices(self) -> torch.Tensor:
+        ...
 def compute_gs_aabb_func(means: torch.Tensor, scales: torch.Tensor, covis: torch.Tensor, isos: torch.Tensor | None, iso: float, tol: float, level: int) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
     """
     Compute AABB for 3D Gaussians
@@ -61,6 +163,10 @@ def compute_gs_covi_func(means: torch.Tensor, rotations: torch.Tensor, scales: t
     """
     Compute covariance matrices for 3D Gaussians
     """
+def create_sphere(sectors: int = 32, stacks: int = 16, radius: float = 1.0) -> tuple[torch.Tensor, torch.Tensor]:
+    """
+    Creates a UV sphere returning (vertices, triangles) tensors on the CPU.
+    """
 def solve_gs_neighbor_mahalanobis_radius_func(means: torch.Tensor, covis: torch.Tensor, k: int) -> torch.Tensor:
     """
     Solve Gaussian Neighbor Mahalanobis Radius

conquer3d-0.2.4/conquer3d/__init__.py

@@ -0,0 +1,8 @@
+import torch
+
+from . import _C
+from . import creation
+from . import data_structure
+from . import primitive
+
+__all__ = ['_C', 'creation', 'data_structure', 'primitive']

conquer3d-0.2.4/conquer3d/creation/__init__.py

@@ -0,0 +1,5 @@
+from .triangle_creation import create_sphere
+
+__all__ = [
+    "create_sphere",
+]

conquer3d-0.2.4/conquer3d/creation/triangle_creation.py

@@ -0,0 +1,23 @@
+import torch
+from typing import Tuple
+
+from .._C import create_sphere as create_sphere_c
+
+def create_sphere(
+    sectors: int = 32,
+    stacks: int = 16,
+    radius: float = 1.0
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Creates a UV sphere returning (vertices, triangles) tensors on the CPU.
+
+    Args:
+        sectors (int, optional): Number of longitudinal sectors. Defaults to 32.
+        stacks (int, optional): Number of latitudinal stacks. Defaults to 16.
+        radius (float, optional): Radius of the sphere. Defaults to 1.0.
+
+    Returns:
+        vertices: (N, 3) float32 tensor of vertex positions.
+        triangles: (M, 3) int32 tensor of triangle indices.
+    """
+    return create_sphere_c(sectors, stacks, radius)

conquer3d-0.2.4/conquer3d/csrc/binds/creation/triangle_creation.cpp

@@ -0,0 +1,13 @@
+#include <torch/extension.h>
+#include <pybind11/pybind11.h>
+#include "../../creation/triangle_creation.h"
+
+namespace py = pybind11;
+
+void bind_creation_triangle_creation(py::module_& m) {
+    m.def("create_sphere", &triangle_creation::create_sphere, 
+          py::arg("sectors") = 32, 
+          py::arg("stacks") = 16, 
+          py::arg("radius") = 1.0f,
+          "Creates a UV sphere returning (vertices, triangles) tensors on the CPU.");
+}

{conquer3d-0.2.1 → conquer3d-0.2.4}/conquer3d/csrc/binds/data_structure/bvh.cpp

@@ -120,7 +120,40 @@ std::tuple<torch::Tensor, torch::Tensor> BVH::query(
     );
 }
 
-void bind_ds_bvh(py::module &m)
+std::tuple<torch::Tensor, torch::Tensor> BVH::query_self()
+{
+    auto options_int64 = this->aabb_mins.options().dtype(torch::kInt64);
+    
+    if (this->num_objects == 0) {
+        throw std::runtime_error("Cannot query BVH with 0 objects.");
+    }
+    
+    torch::Tensor out_query_ids = torch::empty({BVH_MAX_CAPACITY}, options_int64);
+    torch::Tensor out_object_ids = torch::empty({BVH_MAX_CAPACITY}, options_int64);
+    torch::Tensor hit_counter = torch::zeros({1}, options_int64);
+
+    bvh::query_self(
+        this->num_objects,
+        reinterpret_cast<const float3 *>(this->aabb_mins.data_ptr<float>()),
+        reinterpret_cast<const float3 *>(this->aabb_maxs.data_ptr<float>()),
+        reinterpret_cast<const int2 *>(this->bvh_children.data_ptr<int>()),
+        reinterpret_cast<const int *>(this->object_ids.data_ptr<int>()),
+        reinterpret_cast<int64_t *>(out_query_ids.data_ptr<int64_t>()),
+        reinterpret_cast<int64_t *>(out_object_ids.data_ptr<int64_t>()),
+        reinterpret_cast<int64_t *>(hit_counter.data_ptr<int64_t>()),
+        static_cast<int64_t>(BVH_MAX_CAPACITY)
+    );
+
+    int64_t num_hits = hit_counter.item<int64_t>();
+    num_hits = std::min(num_hits, static_cast<int64_t>(BVH_MAX_CAPACITY));
+
+    return std::make_tuple(
+        out_query_ids.slice(0, 0, num_hits), 
+        out_object_ids.slice(0, 0, num_hits)
+    );
+}
+
+void bind_ds_bvh(py::module_& m)
 {
     py::class_<BVH>(m, "BVH")
         .def(py::init<const torch::Tensor &, const torch::Tensor &>(),
@@ -131,5 +164,8 @@ void bind_ds_bvh(py::module &m)
         .def("query", &BVH::query,
              py::arg("query_aabb_mins"), 
              py::arg("query_aabb_maxs"),
-             "Query the BVH with bounding boxes or segments. Returns (query_ids, object_ids).");
+             "Query the BVH with bounding boxes or segments. Returns (query_ids, object_ids).")
+             
+        .def("query_self", &BVH::query_self,
+             "Query the BVH against itself. Returns unique overlapping (query_ids, object_ids).");
 }

{conquer3d-0.2.1 → conquer3d-0.2.4}/conquer3d/csrc/binds/data_structure/gs_bvh.cpp

@@ -312,7 +312,7 @@ std::tuple<torch::Tensor, torch::Tensor> GSBVH::query_edge(
     return std::make_tuple(hit_mask, out_gaus_ids);
 }
 
-void bind_ds_gs_bvh(py::module &m)
+void bind_ds_gs_bvh(py::module_& m)
 {
     py::class_<GSBVH, BVH>(m, "GSBVH")
         .def(py::init<const torch::Tensor &, const torch::Tensor &>(),

conquer3d-0.2.4/conquer3d/csrc/binds/data_structure/mesh_bvh.cpp

@@ -0,0 +1,22 @@
+#include <torch/extension.h>
+#include "../../data_structure/mesh_bvh.h"
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+void bind_ds_mesh_bvh(py::module_& m)
+{
+    py::class_<MeshBVH, BVH>(m, "MeshBVH")
+        .def(py::init<const torch::Tensor &, const torch::Tensor &>(),
+             py::arg("in_aabb_mins"), 
+             py::arg("in_aabb_maxs"),
+             "Construct MeshBVH from Triangle AABBs.")
+        .def("get_self_intersection", &MeshBVH::get_self_intersection,
+             py::arg("vertices"), 
+             py::arg("triangles"),
+             "Find all self-intersecting triangle pairs")
+        .def("is_self_intersection", &MeshBVH::is_self_intersection,
+             py::arg("vertices"), 
+             py::arg("triangles"),
+             "Check if there are any self-intersecting triangle pairs");
+}

{conquer3d-0.2.1 → conquer3d-0.2.4}/conquer3d/csrc/binds/data_structure/pgs_bvh.cpp

@@ -222,7 +222,7 @@ std::tuple<torch::Tensor, torch::Tensor> PGSBVH::query_edge(
     return std::make_tuple(hit_mask, out_gaus_ids);
 }
 
-void bind_ds_pgs_bvh(py::module &m)
+void bind_ds_pgs_bvh(py::module_& m)
 {
     py::class_<PGSBVH, BVH>(m, "PGSBVH")
         .def(py::init<const torch::Tensor &, const torch::Tensor &>(),

conquer3d-0.2.4/conquer3d/csrc/binds/data_structure/triangle_mesh.cpp

@@ -0,0 +1,338 @@
+#include <torch/extension.h>
+#include "../../data_structure/triangle_mesh.h"
+#include "../../check.h"
+
+#include <pybind11/pybind11.h>
+#include <optional>
+#include <vector>
+
+namespace py = pybind11;
+
+#include <optional>
+
+TriangleMesh::TriangleMesh(
+    const torch::Tensor &in_vertices,
+    const torch::Tensor &in_triangles,
+    std::optional<torch::Tensor> in_vertex_normals,
+    std::optional<torch::Tensor> in_vertex_colors)
+{
+    CHECK_INPUT(in_vertices);
+    CHECK_INPUT(in_triangles);
+    TORCH_CHECK(in_vertices.scalar_type() == torch::kFloat32, "vertices must be float32");
+    TORCH_CHECK(in_triangles.scalar_type() == torch::kInt32, "triangles must be int32");
+    TORCH_CHECK(in_vertices.size(1) == 3, "vertices must have shape (N, 3)");
+    TORCH_CHECK(in_triangles.size(1) == 3, "triangles must have shape (M, 3)");
+
+    this->num_triangles = static_cast<uint32_t>(in_triangles.size(0));
+
+    this->vertices = in_vertices;
+    this->triangles = in_triangles;
+
+    if (in_vertex_normals.has_value() && in_vertex_normals->defined())
+    {
+        CHECK_INPUT(*in_vertex_normals);
+        TORCH_CHECK(in_vertex_normals->scalar_type() == torch::kFloat32, "vertex_normals must be float32");
+        TORCH_CHECK(in_vertex_normals->size(1) == 3, "vertex_normals must have shape (N, 3)");
+        this->vertex_normals = in_vertex_normals->clone();
+    }
+
+    if (in_vertex_colors.has_value() && in_vertex_colors->defined())
+    {
+        CHECK_INPUT(*in_vertex_colors);
+        TORCH_CHECK(in_vertex_colors->scalar_type() == torch::kFloat32, "vertex_colors must be float32");
+        TORCH_CHECK(in_vertex_colors->size(1) == 3, "vertex_colors must have shape (N, 3)");
+        this->vertex_colors = in_vertex_colors->clone();
+    }
+}
+
+void TriangleMesh::compute_triangle_normals()
+{
+    this->triangle_normals = torch::empty({static_cast<int64_t>(this->num_triangles), 3}, torch::dtype(torch::kFloat32).device(this->vertices.device()));
+    triangle_mesh::compute_triangle_normals(
+        this->num_triangles,
+        reinterpret_cast<float3 *>(this->vertices.data_ptr<float>()),
+        reinterpret_cast<int3 *>(this->triangles.data_ptr<int>()),
+        reinterpret_cast<float3 *>(this->triangle_normals.data_ptr<float>()));
+}
+
+void TriangleMesh::compute_triangle_areas()
+{
+    this->triangle_areas = torch::empty({static_cast<int64_t>(this->num_triangles)}, torch::dtype(torch::kFloat32).device(this->vertices.device()));
+    triangle_mesh::compute_triangle_areas(
+        this->num_triangles,
+        reinterpret_cast<float3 *>(this->vertices.data_ptr<float>()),
+        reinterpret_cast<int3 *>(this->triangles.data_ptr<int>()),
+        reinterpret_cast<float *>(this->triangle_areas.data_ptr<float>()));
+}
+
+MeshBVH TriangleMesh::build_bvh()
+{
+    if (!this->bvh.has_value())
+    {
+        auto options = torch::TensorOptions().dtype(torch::kFloat32).device(this->vertices.device());
+        torch::Tensor aabb_mins = torch::empty({static_cast<int64_t>(this->num_triangles), 3}, options);
+        torch::Tensor aabb_maxs = torch::empty({static_cast<int64_t>(this->num_triangles), 3}, options);
+        
+        triangle_mesh::compute_triangle_aabbs(
+            this->num_triangles,
+            reinterpret_cast<float3 *>(this->vertices.data_ptr<float>()),
+            reinterpret_cast<int3 *>(this->triangles.data_ptr<int>()),
+            reinterpret_cast<float3 *>(aabb_mins.data_ptr<float>()),
+            reinterpret_cast<float3 *>(aabb_maxs.data_ptr<float>()));
+            
+        this->bvh = MeshBVH(aabb_mins, aabb_maxs);
+    }
+    return this->bvh.value();
+}
+
+torch::Tensor TriangleMesh::get_self_intersection()
+{
+    this->build_bvh();
+    return this->bvh.value().get_self_intersection(this->vertices, this->triangles);
+}
+
+bool TriangleMesh::is_self_intersection()
+{
+    this->build_bvh();
+    return this->bvh.value().is_self_intersection(this->vertices, this->triangles);
+}
+
+torch::Tensor TriangleMesh::get_triangle_areas()
+{
+    if (!this->triangle_areas.defined())
+    {
+        this->compute_triangle_areas();
+    }
+    return this->triangle_areas;
+}
+
+torch::Tensor TriangleMesh::get_triangle_normals()
+{
+    if (!this->triangle_normals.defined())
+    {
+        this->compute_triangle_normals();
+    }
+    return this->triangle_normals;
+}
+
+torch::Tensor TriangleMesh::get_surface_area()
+{
+    if (!this->surface_area.defined())
+    {
+        this->surface_area = this->get_triangle_areas().sum();
+    }
+    return this->surface_area;
+}
+
+void TriangleMesh::compute_edges_to_triangle_map()
+{
+    if (this->num_triangles == 0)
+    {
+        auto options_i32 = torch::TensorOptions().dtype(torch::kInt32).device(this->triangles.device());
+        this->edges = torch::empty({0, 2}, options_i32);
+        this->edge_to_triangle_offsets = torch::empty({0}, options_i32);
+        this->edge_to_triangle_counts = torch::empty({0}, options_i32);
+        this->edge_to_triangle_indices = torch::empty({0}, options_i32);
+        return;
+    }
+
+    triangle_mesh::compute_edges_to_triangle_map(
+        this->num_triangles,
+        reinterpret_cast<int3 *>(this->triangles.data_ptr<int>()),
+        this->edges,
+        this->edge_to_triangle_offsets,
+        this->edge_to_triangle_counts,
+        this->edge_to_triangle_indices);
+}
+
+std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> TriangleMesh::get_edges_to_triangle_map()
+{
+    if (!this->edges.defined())
+    {
+        this->compute_edges_to_triangle_map();
+    }
+    return std::make_tuple(
+        this->edges,
+        this->edge_to_triangle_offsets,
+        this->edge_to_triangle_counts,
+        this->edge_to_triangle_indices);
+}
+
+torch::Tensor TriangleMesh::get_edges()
+{
+    if (!this->edges.defined())
+        this->compute_edges_to_triangle_map();
+    return this->edges;
+}
+torch::Tensor TriangleMesh::get_edge_to_triangle_offsets()
+{
+    if (!this->edge_to_triangle_offsets.defined())
+        this->compute_edges_to_triangle_map();
+    return this->edge_to_triangle_offsets;
+}
+torch::Tensor TriangleMesh::get_edge_to_triangle_counts()
+{
+    if (!this->edge_to_triangle_counts.defined())
+        this->compute_edges_to_triangle_map();
+    return this->edge_to_triangle_counts;
+}
+torch::Tensor TriangleMesh::get_edge_to_triangle_indices()
+{
+    if (!this->edge_to_triangle_indices.defined())
+        this->compute_edges_to_triangle_map();
+    return this->edge_to_triangle_indices;
+}
+
+bool TriangleMesh::is_edge_manifold(bool allow_boundary_edge)
+{
+    if (this->num_triangles == 0)
+        return true;
+    torch::Tensor counts = this->get_edge_to_triangle_counts();
+    if (allow_boundary_edge)
+    {
+        return (counts <= 2).all().item<bool>();
+    }
+    else
+    {
+        return (counts == 2).all().item<bool>();
+    }
+}
+
+void TriangleMesh::remove_triangles_by_mask(const torch::Tensor &keep_mask)
+{
+    CHECK_INPUT(keep_mask);
+    TORCH_CHECK(keep_mask.scalar_type() == torch::kBool, "keep_mask must be a boolean tensor");
+    TORCH_CHECK(keep_mask.dim() == 1 && keep_mask.size(0) == this->num_triangles, "keep_mask must have shape (num_triangles,)");
+
+    this->triangles = this->triangles.index({keep_mask});
+    this->num_triangles = this->triangles.size(0);
+
+    // Invalidate all caches
+    this->triangle_areas = torch::Tensor();
+    this->triangle_normals = torch::Tensor();
+    this->surface_area = torch::Tensor();
+    this->bvh.reset();
+    this->edges = torch::Tensor();
+    this->edge_to_triangle_offsets = torch::Tensor();
+    this->edge_to_triangle_counts = torch::Tensor();
+    this->edge_to_triangle_indices = torch::Tensor();
+
+    this->vertex_to_triangle_offsets = torch::Tensor();
+    this->vertex_to_triangle_counts = torch::Tensor();
+    this->vertex_to_triangle_indices = torch::Tensor();
+}
+
+int32_t TriangleMesh::get_euler_characteristic()
+{
+    int32_t V = this->vertices.size(0);
+    int32_t E = this->get_edges().size(0);
+    int32_t F = this->num_triangles;
+    return V - E + F;
+}
+
+int32_t TriangleMesh::get_genus()
+{
+    // For a single closed connected component, chi = 2 - 2g => g = (2 - chi) / 2
+    int32_t chi = this->get_euler_characteristic();
+    return (2 - chi) / 2;
+}
+
+void TriangleMesh::compute_vertices_to_triangle_map()
+{
+    if (this->vertex_to_triangle_offsets.defined())
+        return;
+
+    uint32_t num_vertices = this->vertices.size(0);
+    triangle_mesh::build_vertices_to_triangle_map(
+        num_vertices,
+        this->num_triangles,
+        this->triangles,
+        this->vertex_to_triangle_counts,
+        this->vertex_to_triangle_offsets,
+        this->vertex_to_triangle_indices);
+}
+
+std::tuple<torch::Tensor, torch::Tensor, torch::Tensor> TriangleMesh::get_vertices_to_triangle_map()
+{
+    this->compute_vertices_to_triangle_map();
+    return {this->vertex_to_triangle_offsets, this->vertex_to_triangle_counts, this->vertex_to_triangle_indices};
+}
+
+torch::Tensor TriangleMesh::get_vertex_to_triangle_offsets()
+{
+    this->compute_vertices_to_triangle_map();
+    return this->vertex_to_triangle_offsets;
+}
+
+torch::Tensor TriangleMesh::get_vertex_to_triangle_counts()
+{
+    this->compute_vertices_to_triangle_map();
+    return this->vertex_to_triangle_counts;
+}
+
+torch::Tensor TriangleMesh::get_vertex_to_triangle_indices() {
+    this->compute_vertices_to_triangle_map();
+    return this->vertex_to_triangle_indices;
+}
+
+torch::Tensor TriangleMesh::get_non_manifold_vertices() {
+    this->compute_vertices_to_triangle_map();
+    return triangle_mesh::get_non_manifold_vertices(
+        this->vertices.size(0),
+        this->triangles,
+        this->vertex_to_triangle_offsets,
+        this->vertex_to_triangle_counts,
+        this->vertex_to_triangle_indices
+    );
+}
+
+bool TriangleMesh::is_vertex_manifold() {
+    torch::Tensor nm_vertices = this->get_non_manifold_vertices();
+    return nm_vertices.size(0) == 0;
+}
+
+bool TriangleMesh::is_manifold(bool allow_boundary_edge) {
+    return this->is_edge_manifold(allow_boundary_edge) && this->is_vertex_manifold() && !this->is_self_intersection();
+}
+
+void bind_ds_triangle_mesh(py::module_ &m)
+{
+    py::class_<TriangleMesh>(m, "TriangleMesh")
+        .def(py::init<const torch::Tensor &, const torch::Tensor &, std::optional<torch::Tensor>, std::optional<torch::Tensor>>(),
+             py::arg("in_vertices"),
+             py::arg("in_triangles"),
+             py::arg("in_vertex_normals") = std::nullopt,
+             py::arg("in_vertex_colors") = std::nullopt)
+        .def_property_readonly("num_triangles", &TriangleMesh::get_num_triangles)
+        .def_property_readonly("vertices", &TriangleMesh::get_vertices)
+        .def_property_readonly("vertex_normals", &TriangleMesh::get_vertex_normals)
+        .def_property_readonly("vertex_colors", &TriangleMesh::get_vertex_colors)
+        .def_property_readonly("triangles", &TriangleMesh::get_triangles)
+        .def_property_readonly("triangle_areas", &TriangleMesh::get_triangle_areas)
+        .def_property_readonly("triangle_normals", &TriangleMesh::get_triangle_normals)
+        .def_property_readonly("surface_area", &TriangleMesh::get_surface_area)
+        .def_property_readonly("bvh", &TriangleMesh::build_bvh)
+        .def("build_bvh", &TriangleMesh::build_bvh)
+        .def("get_self_intersection", &TriangleMesh::get_self_intersection)
+        .def("is_self_intersection", &TriangleMesh::is_self_intersection)
+        .def_property_readonly("edges", &TriangleMesh::get_edges)
+        .def_property_readonly("edge_to_triangle_offsets", &TriangleMesh::get_edge_to_triangle_offsets)
+        .def_property_readonly("edge_to_triangle_counts", &TriangleMesh::get_edge_to_triangle_counts)
+        .def_property_readonly("edge_to_triangle_indices", &TriangleMesh::get_edge_to_triangle_indices)
+        .def("compute_triangle_areas", &TriangleMesh::compute_triangle_areas)
+        .def("compute_triangle_normals", &TriangleMesh::compute_triangle_normals)
+        .def("compute_edges_to_triangle_map", &TriangleMesh::compute_edges_to_triangle_map)
+        .def("get_edges_to_triangle_map", &TriangleMesh::get_edges_to_triangle_map)
+        .def("compute_vertices_to_triangle_map", &TriangleMesh::compute_vertices_to_triangle_map)
+        .def("get_vertices_to_triangle_map", &TriangleMesh::get_vertices_to_triangle_map)
+        .def_property_readonly("vertex_to_triangle_offsets", &TriangleMesh::get_vertex_to_triangle_offsets)
+        .def_property_readonly("vertex_to_triangle_counts", &TriangleMesh::get_vertex_to_triangle_counts)
+        .def_property_readonly("vertex_to_triangle_indices", &TriangleMesh::get_vertex_to_triangle_indices)
+        .def("is_edge_manifold", &TriangleMesh::is_edge_manifold, py::arg("allow_boundary_edge") = true)
+        .def("is_vertex_manifold", &TriangleMesh::is_vertex_manifold)
+        .def("is_manifold", &TriangleMesh::is_manifold, py::arg("allow_boundary_edge") = true)
+        .def("get_non_manifold_vertices", &TriangleMesh::get_non_manifold_vertices)
+        .def("remove_triangles_by_mask", &TriangleMesh::remove_triangles_by_mask, py::arg("keep_mask"))
+        .def_property_readonly("euler_characteristic", &TriangleMesh::get_euler_characteristic)
+        .def_property_readonly("genus", &TriangleMesh::get_genus);
+}