conquer3d 0.2.7__tar.gz → 0.2.8__tar.gz

{conquer3d-0.2.7/conquer3d.egg-info → conquer3d-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conquer3d
-Version: 0.2.7
+Version: 0.2.8
 Summary: Geometric Cuda Tool Box
 Author-email: Do Hoang Khoi <khoido8899@gmail.com>
 License-Expression: MIT
@@ -20,6 +20,10 @@ Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: black>=23.0; extra == "dev"
 Requires-Dist: ruff>=0.1.0; extra == "dev"
 Requires-Dist: mypy>=1.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs-material; extra == "docs"
+Requires-Dist: mkdocstrings[python]; extra == "docs"
+Requires-Dist: mkdocs-jupyter; extra == "docs"
 Dynamic: license-file
 
 # Conquer3D

conquer3d-0.2.8/conquer3d/_C.pyi

@@ -0,0 +1,592 @@
+"""
+Geocutool Python bindings
+"""
+from __future__ import annotations
+import torch
+import typing
+__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:
+    """
+    
+    A highly efficient Bounding Volume Hierarchy (LBVH) data structure natively backed by CUDA.
+    """
+    def __init__(self, in_aabb_mins: torch.Tensor, in_aabb_maxs: torch.Tensor) -> None:
+        """
+        Construct and build the Karras LBVH from Gaussian AABBs.
+        
+        Args:
+            in_aabb_mins (torch.Tensor): Shape (N, 3) float32 tensor of AABB minimum coordinates.
+            in_aabb_maxs (torch.Tensor): Shape (N, 3) float32 tensor of AABB maximum coordinates.
+        """
+    def query(self, query_aabb_mins: torch.Tensor, query_aabb_maxs: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Query the BVH with bounding boxes or segments.
+        
+        Args:
+            query_aabb_mins (torch.Tensor): Shape (M, 3) float32 tensor of query AABB minimum coordinates.
+            query_aabb_maxs (torch.Tensor): Shape (M, 3) float32 tensor of query AABB maximum coordinates.
+        
+        Returns:
+            tuple: (query_ids, object_ids)
+        """
+    def query_point(self, query_points: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        """
+        Find the closest leaf AABB to each query point.
+        
+        Args:
+            query_points (torch.Tensor): Shape (M, 3) float32 tensor of query points.
+        
+        Returns:
+            tuple: (query_ids, object_ids, distances)
+        """
+    def query_ray(self, ray_origins: torch.Tensor, ray_dirs: torch.Tensor, max_capacity: int = 10000000) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Find all ray-AABB intersections.
+        
+        Args:
+            ray_origins (torch.Tensor): Shape (M, 3) float32 tensor of ray origins.
+            ray_dirs (torch.Tensor): Shape (M, 3) float32 tensor of ray directions.
+            max_capacity (int): Maximum global capacity for recording intersections. Defaults to BVH_MAX_CAPACITY.
+        
+        Returns:
+            tuple: (ray_ids, object_ids)
+        """
+    def query_self(self) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Query the BVH against itself.
+        
+        Returns:
+            tuple: (query_ids, object_ids) representing unique overlapping pairs.
+        """
+class GSBVH(BVH):
+    """
+    
+    A specialized Bounding Volume Hierarchy for Gaussian Splatting operations.
+    Inherits from BVH.
+    """
+    def __init__(self, in_aabb_mins: torch.Tensor, in_aabb_maxs: torch.Tensor) -> None:
+        """
+        Construct and build the Karras LBVH for Gaussians.
+        
+        Args:
+            in_aabb_mins (torch.Tensor): Shape (N, 3) float32 tensor of Gaussian AABB minimums.
+            in_aabb_maxs (torch.Tensor): Shape (N, 3) float32 tensor of Gaussian AABB maximums.
+        """
+    def query_edge(self, edge_starts: torch.Tensor, edge_ends: torch.Tensor, means: torch.Tensor, opacities: torch.Tensor, covis: torch.Tensor, isos: float | torch.Tensor = 11.345) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Find the single highest-density Gaussian intersected by each line segment.
+        
+        Args:
+            edge_starts (torch.Tensor): Shape (E, 3) float32 tensor of edge start points.
+            edge_ends (torch.Tensor): Shape (E, 3) float32 tensor of edge end points.
+            means (torch.Tensor): Shape (N, 3) float32 tensor of Gaussian means.
+            opacities (torch.Tensor): Shape (N,) float32 tensor of Gaussian opacities.
+            covis (torch.Tensor): Shape (N, 6) float32 tensor of Gaussian inverse covariances.
+            isos (float | torch.Tensor): Iso-surface threshold. Defaults to ISO.
+        
+        Returns:
+            tuple: (hit_mask, gaussian_ids)
+        """
+    def query_edge_pair(self, edge_starts: torch.Tensor, edge_ends: torch.Tensor, means: torch.Tensor, covis: torch.Tensor, isos: float | torch.Tensor = 11.345, max_capacity: int = 10000000) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        """
+        Find all Gaussians intersected by each line segment.
+        
+        Args:
+            edge_starts (torch.Tensor): Shape (E, 3) float32 tensor of edge start points.
+            edge_ends (torch.Tensor): Shape (E, 3) float32 tensor of edge end points.
+            means (torch.Tensor): Shape (N, 3) float32 tensor of Gaussian means.
+            covis (torch.Tensor): Shape (N, 6) float32 tensor of Gaussian inverse covariances.
+            isos (float | torch.Tensor): Iso-surface threshold. Can be a float or (N,) tensor. Defaults to ISO.
+            max_capacity (int): Max global capacity for hits. Defaults to BVH_MAX_CAPACITY.
+        
+        Returns:
+            tuple: (hit_mask, edge_ids, gaussian_ids)
+        """
+    def query_voxel_pair(self, vx_aabb_mins: torch.Tensor, vx_aabb_maxs: torch.Tensor, means: torch.Tensor, covis: torch.Tensor, opacities: torch.Tensor, gs_aabb_mins: torch.Tensor, gs_aabb_maxs: torch.Tensor, contact_points: torch.Tensor, isos: float | torch.Tensor = 11.345, ar_threshold: float = 0.0, p_threshold: float = 0.0, return_centroids: bool = False, max_capacity: int = 10000000) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor | None, torch.Tensor | None]:
+        """
+        Perform exact Broad-to-Narrow phase intersection between Voxels and Gaussians.
+        
+        Args:
+            vx_aabb_mins (torch.Tensor): Shape (M, 3) float32 tensor of voxel AABB minimums.
+            vx_aabb_maxs (torch.Tensor): Shape (M, 3) float32 tensor of voxel AABB maximums.
+            means (torch.Tensor): Shape (N, 3) float32 tensor of Gaussian means.
+            covis (torch.Tensor): Shape (N, 6) float32 tensor of Gaussian inverse covariances.
+            opacities (torch.Tensor): Shape (N,) float32 tensor of Gaussian opacities.
+            gs_aabb_mins (torch.Tensor): Shape (N, 3) float32 tensor of Gaussian AABB minimums.
+            gs_aabb_maxs (torch.Tensor): Shape (N, 3) float32 tensor of Gaussian AABB maximums.
+            contact_points (torch.Tensor): Shape (N, 3) float32 tensor of contact points.
+            isos (float | torch.Tensor): Iso-surface threshold. Can be a float or (N,) float32 tensor. Defaults to ISO.
+            ar_threshold (float): Alpha scaling threshold. Defaults to 0.0.
+            p_threshold (float): Probability threshold. Defaults to 0.0.
+            return_centroids (bool): Whether to compute and return intersection centroids/densities. Defaults to false.
+            max_capacity (int): Max global capacity for hits. Defaults to BVH_MAX_CAPACITY.
+        
+        Returns:
+            tuple: (hit_mask, voxel_ids, gaussian_ids, centroids, densities)
+        """
+class KDTree:
+    """
+    
+    A highly efficient KDTree data structure natively backed by CUDA.
+    """
+    def __init__(self, points: torch.Tensor) -> None:
+        """
+        Initializes and builds the KDTree on the GPU.
+        
+        Args:
+            points (torch.Tensor): Shape (N, 3) float32 tensor of points to build the KDTree.
+        """
+    def query(self, query_points: torch.Tensor, k: int = 1, exclude_self: bool = False) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Queries the KDTree for the K nearest neighbors.
+        
+        Args:
+            query_points (torch.Tensor): Shape (M, 3) float32 tensor of query points.
+            k (int): Number of nearest neighbors to search for. Defaults to 1.
+            exclude_self (bool): Whether to exclude the exact query point (if it exists). Defaults to false.
+        
+        Returns:
+            tuple: (distances, indices)
+        """
+class MeshBVH(BVH):
+    """
+    
+    A specialized Bounding Volume Hierarchy for Triangle Meshes.
+    Inherits from BVH.
+    """
+    def __init__(self, in_aabb_mins: torch.Tensor, in_aabb_maxs: torch.Tensor) -> None:
+        """
+        Construct MeshBVH from Triangle AABBs.
+        
+        Args:
+            in_aabb_mins (torch.Tensor): Shape (M, 3) float32 tensor of triangle AABB minimums.
+            in_aabb_maxs (torch.Tensor): Shape (M, 3) float32 tensor of triangle AABB maximums.
+        """
+    def build_winding_data(self, vertices: torch.Tensor, triangles: torch.Tensor) -> None:
+        """
+        Computes the hierarchical area-weighted constants for Fast Winding Number queries.
+        
+        Args:
+            vertices (torch.Tensor): Shape (N, 3) float32 tensor of vertices.
+            triangles (torch.Tensor): Shape (M, 3) int32 tensor of triangles.
+        """
+    def get_ray_intersection(self, ray_origins: torch.Tensor, ray_dirs: torch.Tensor, vertices: torch.Tensor, triangles: torch.Tensor, return_distance: bool = False) -> typing.Any:
+        """
+        Find all ray-triangle intersections.
+        
+        Args:
+            ray_origins (torch.Tensor): Shape (R, 3) float32 tensor of ray origins.
+            ray_dirs (torch.Tensor): Shape (R, 3) float32 tensor of ray directions.
+            vertices (torch.Tensor): Shape (N, 3) float32 tensor of vertices.
+            triangles (torch.Tensor): Shape (M, 3) int32 tensor of triangles.
+            return_distance (bool): Whether to compute and return ray hit distances. Defaults to false.
+        
+        Returns:
+            tuple: (ray_ids, triangle_ids, intersect_points, [distances])
+        """
+    def get_self_intersection(self, vertices: torch.Tensor, triangles: torch.Tensor) -> torch.Tensor:
+        """
+        Find all self-intersecting triangle pairs.
+        
+        Args:
+            vertices (torch.Tensor): Shape (N, 3) float32 tensor of vertices.
+            triangles (torch.Tensor): Shape (M, 3) int32 tensor of triangles.
+        
+        Returns:
+            torch.Tensor: Shape (K, 2) int64 tensor of intersecting triangle index pairs.
+        """
+    def is_self_intersection(self, vertices: torch.Tensor, triangles: torch.Tensor) -> bool:
+        """
+        Check if there are any self-intersecting triangle pairs.
+        
+        Args:
+            vertices (torch.Tensor): Shape (N, 3) float32 tensor of vertices.
+            triangles (torch.Tensor): Shape (M, 3) int32 tensor of triangles.
+        
+        Returns:
+            bool: True if there is at least one self-intersection.
+        """
+    def query_point(self, query_points: torch.Tensor, vertices: torch.Tensor, triangles: torch.Tensor, return_sdf: bool = False, return_prj_pts: bool = True, sign_mode: int = 0) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        """
+        Find the closest triangle to each query point.
+        
+        Args:
+            query_points (torch.Tensor): Shape (Q, 3) float32 tensor of query points.
+            vertices (torch.Tensor): Shape (N, 3) float32 tensor of vertices.
+            triangles (torch.Tensor): Shape (M, 3) int32 tensor of triangles.
+            return_sdf (bool): Whether to compute signed distances instead of unsigned. Defaults to false.
+            return_prj_pts (bool): Whether to compute and return projected points. Defaults to true.
+            sign_mode (int): Winding number method (0 for ray casting, 1 for fast winding number). Defaults to 0.
+        
+        Returns:
+            tuple: (query_ids, triangle_ids, projected_points, distances)
+        """
+class PGSBVH(BVH):
+    """
+    
+    A specialized Bounding Volume Hierarchy for Planar Gaussian Splatting (PGS) operations.
+    Inherits from BVH.
+    """
+    def __init__(self, in_aabb_mins: torch.Tensor, in_aabb_maxs: torch.Tensor) -> None:
+        """
+        Construct and build the Karras LBVH for Planar Gaussians.
+        
+        Args:
+            in_aabb_mins (torch.Tensor): Shape (N, 3) float32 tensor of PGS AABB minimums.
+            in_aabb_maxs (torch.Tensor): Shape (N, 3) float32 tensor of PGS AABB maximums.
+        """
+    def query_edge(self, edge_starts: torch.Tensor, edge_ends: torch.Tensor, means: torch.Tensor, normals: torch.Tensor, opacities: torch.Tensor, covis: torch.Tensor, isos: float | torch.Tensor = 11.345) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Find the single highest-density PGS intersected by each line segment.
+        
+        Args:
+            edge_starts (torch.Tensor): Shape (E, 3) float32 tensor of edge start points.
+            edge_ends (torch.Tensor): Shape (E, 3) float32 tensor of edge end points.
+            means (torch.Tensor): Shape (N, 3) float32 tensor of PGS means.
+            normals (torch.Tensor): Shape (N, 3) float32 tensor of PGS normals.
+            opacities (torch.Tensor): Shape (N,) float32 tensor of PGS opacities.
+            covis (torch.Tensor): Shape (N, 3) float32 tensor of PGS inverse covariances.
+            isos (float | torch.Tensor): Iso-surface threshold. Defaults to ISO.
+        
+        Returns:
+            tuple: (hit_mask, gaussian_ids)
+        """
+    def query_voxel_pair(self, vx_aabb_mins: torch.Tensor, vx_aabb_maxs: torch.Tensor, means: torch.Tensor, normals: torch.Tensor, covis: torch.Tensor, gs_aabb_mins: torch.Tensor, gs_aabb_maxs: torch.Tensor, isos: float | torch.Tensor = 11.345, return_centroids: bool = False, return_centroid_densities: bool = False, max_capacity: int = 10000000) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor | None, torch.Tensor | None]:
+        """
+        Perform exact Broad-to-Narrow phase intersection between Voxels and PGS.
+        
+        Args:
+            vx_aabb_mins (torch.Tensor): Shape (M, 3) float32 tensor of voxel AABB minimums.
+            vx_aabb_maxs (torch.Tensor): Shape (M, 3) float32 tensor of voxel AABB maximums.
+            means (torch.Tensor): Shape (N, 3) float32 tensor of PGS means.
+            normals (torch.Tensor): Shape (N, 3) float32 tensor of PGS normals.
+            covis (torch.Tensor): Shape (N, 3) float32 tensor of PGS inverse covariances.
+            gs_aabb_mins (torch.Tensor): Shape (N, 3) float32 tensor of PGS AABB minimums.
+            gs_aabb_maxs (torch.Tensor): Shape (N, 3) float32 tensor of PGS AABB maximums.
+            isos (float | torch.Tensor): Iso-surface threshold. Can be a float or (N,) float32 tensor. Defaults to ISO.
+            return_centroids (bool): Whether to compute and return intersection centroids. Defaults to false.
+            return_centroid_densities (bool): Whether to return densities at centroids. Defaults to false.
+            max_capacity (int): Max global capacity for hits. Defaults to 10000000.
+        
+        Returns:
+            tuple: (hit_mask, voxel_ids, gaussian_ids, centroids, densities)
+        """
+class TriangleMesh:
+    """
+    
+    A highly efficient Triangle Mesh data structure natively backed by CUDA.
+    
+    Args:
+        in_vertices (torch.Tensor): A tensor of shape (N, 3) containing float32 vertex coordinates.
+        in_triangles (torch.Tensor): A tensor of shape (M, 3) containing int32 triangle indices.
+        in_vertex_normals (torch.Tensor, optional): A tensor of shape (N, 3) containing float32 vertex normals. Defaults to None.
+        in_vertex_colors (torch.Tensor, optional): A tensor of shape (N, 3) containing float32 vertex colors. Defaults to None.
+    """
+    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:
+        """
+        Builds and returns the Bounding Volume Hierarchy for the mesh.
+        
+        Returns:
+            MeshBVH: The constructed BVH object.
+        """
+    def compute_edges_to_triangle_map(self) -> None:
+        """
+        Computes the edge-to-triangle connectivity map.
+        """
+    def compute_triangle_areas(self) -> None:
+        """
+        Computes the areas of all triangles.
+        """
+    def compute_triangle_normals(self) -> None:
+        """
+        Computes the normals for all triangles.
+        """
+    def compute_vertex_normals(self) -> None:
+        """
+        Computes area-weighted vertex normals.
+        """
+    def compute_vertices_to_triangle_map(self) -> None:
+        """
+        Computes the vertex-to-triangle connectivity map.
+        """
+    def get_edges_to_triangle_map(self) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        """
+        Gets the edge to triangle connectivity mapping.
+        
+        Returns:
+            tuple: (edges, offsets, counts, indices)
+        """
+    def get_non_manifold_vertices(self) -> torch.Tensor:
+        """
+        Gets all non-manifold vertices.
+        
+        Returns:
+            torch.Tensor: Tensor of vertex indices that are non-manifold.
+        """
+    def get_ray_intersection(self, ray_origins: torch.Tensor, ray_dirs: torch.Tensor, return_distance: bool = False) -> typing.Any:
+        """
+        Computes intersections between a batch of rays and the mesh triangles.
+        
+        Args:
+            ray_origins (torch.Tensor): Shape (R, 3) float32 tensor of ray origins.
+            ray_dirs (torch.Tensor): Shape (R, 3) float32 tensor of ray directions.
+            return_distance (bool, optional): If True, returns intersection distances. Defaults to False.
+        
+        Returns:
+            tuple: (ray_ids, triangle_ids, intersect_points, [distances])
+        """
+    def get_self_intersection(self) -> torch.Tensor:
+        """
+        Finds all self-intersecting triangle pairs in the mesh.
+        
+        Returns:
+            torch.Tensor: A tensor of shape (K, 2) containing pairs of intersecting triangle indices.
+        """
+    def get_vertices_to_triangle_map(self) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        """
+        Gets the vertex to triangle connectivity mapping.
+        
+        Returns:
+            tuple: (offsets, counts, indices)
+        """
+    def is_edge_manifold(self, allow_boundary_edge: bool = True) -> bool:
+        """
+        Checks if the mesh is edge manifold.
+        
+        Args:
+            allow_boundary_edge (bool, optional): Whether to permit boundary edges (count <= 2). Defaults to True.
+        
+        Returns:
+            bool: True if the mesh is edge manifold.
+        """
+    def is_manifold(self, allow_boundary_edge: bool = True) -> bool:
+        """
+        Checks if the mesh is fully manifold (edge, vertex, and no self-intersections).
+        
+        Args:
+            allow_boundary_edge (bool, optional): Whether to permit boundary edges. Defaults to True.
+        
+        Returns:
+            bool: True if fully manifold.
+        """
+    def is_self_intersection(self) -> bool:
+        """
+        Checks whether the mesh contains any self-intersecting triangles.
+        
+        Returns:
+            bool: True if there is at least one self-intersection, False otherwise.
+        """
+    def is_vertex_manifold(self) -> bool:
+        """
+        Checks if the mesh is vertex manifold.
+        
+        Returns:
+            bool: True if all vertices are manifold.
+        """
+    def query_points(self, query_pts: torch.Tensor, return_sdf: bool = False, return_prj_pts: bool = True, sign_mode: int = 0, distance_mode: int = 0) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        """
+        Finds the closest triangles and computes distances/SDFs for query points.
+        
+        Args:
+            query_pts (torch.Tensor): Shape (Q, 3) float32 tensor of query points.
+            return_sdf (bool, optional): Whether to return Signed Distance Field values. Defaults to False.
+            return_prj_pts (bool, optional): Whether to return projected points on the mesh. Defaults to True.
+            sign_mode (int, optional): The method for computing signs. Defaults to 0.
+            distance_mode (int, optional): Distance computation mode. Defaults to 0.
+        
+        Returns:
+            tuple: (query_ids, triangle_ids, projected_points, distances)
+        """
+    def remove_triangles_by_mask(self, keep_mask: torch.Tensor) -> None:
+        """
+        Removes triangles from the mesh based on a boolean mask.
+        
+        Args:
+            keep_mask (torch.Tensor): Shape (M,) boolean tensor indicating which triangles to keep.
+        """
+    def sample_points(self, num_points: int, uniform: bool = False, return_normals: bool = False, return_colors: bool = False, use_triangle_normal: bool = True) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor | None, torch.Tensor | None]:
+        """
+        Samples random points on the surface of the mesh.
+        
+        Args:
+            num_points (int): The number of points to sample.
+            uniform (bool, optional): If True, samples uniformly by area. Defaults to False.
+            return_normals (bool, optional): If True, returns normals at sampled points. Defaults to False.
+            return_colors (bool, optional): If True, returns colors at sampled points. Defaults to False.
+            use_triangle_normal (bool, optional): If True, uses flat triangle normals instead of interpolated vertex normals. Defaults to True.
+        
+        Returns:
+            tuple: (points, triangle_indices, [normals], [colors])
+        """
+    @property
+    def bvh(self) -> MeshBVH:
+        """
+        The Bounding Volume Hierarchy built for this mesh.
+        
+        Returns:
+            MeshBVH - The Bounding Volume Hierarchy built for this mesh.
+        """
+    @property
+    def edge_to_triangle_counts(self) -> torch.Tensor:
+        """
+        Edge to triangle counts.
+        
+        Returns:
+            torch.Tensor - Edge to triangle counts.
+        """
+    @property
+    def edge_to_triangle_indices(self) -> torch.Tensor:
+        """
+        Edge to triangle indices.
+        
+        Returns:
+            torch.Tensor - Edge to triangle indices.
+        """
+    @property
+    def edge_to_triangle_offsets(self) -> torch.Tensor:
+        """
+        Edge to triangle offsets.
+        
+        Returns:
+            torch.Tensor - Edge to triangle offsets.
+        """
+    @property
+    def edges(self) -> torch.Tensor:
+        """
+        Unique edges of the mesh.
+        
+        Returns:
+            torch.Tensor - Shape (E, 2) int32 tensor of unique edges.
+        """
+    @property
+    def euler_characteristic(self) -> int:
+        """
+        The Euler characteristic (V - E + F) of the mesh.
+        
+        Returns:
+            int - The Euler characteristic (V - E + F) of the mesh.
+        """
+    @property
+    def genus(self) -> int:
+        """
+        The topological genus of the mesh.
+        
+        Returns:
+            int - The topological genus of the mesh.
+        """
+    @property
+    def num_triangles(self) -> int:
+        """
+        Total number of triangles.
+        
+        Returns:
+            int - Total number of triangles.
+        """
+    @property
+    def surface_area(self) -> torch.Tensor:
+        """
+        Total surface area of the mesh.
+        
+        Returns:
+            torch.Tensor - Total surface area of the mesh.
+        """
+    @property
+    def triangle_areas(self) -> torch.Tensor:
+        """
+        Areas of each triangle.
+        
+        Returns:
+            torch.Tensor - Shape (M,) float32 tensor of triangle areas.
+        """
+    @property
+    def triangle_normals(self) -> torch.Tensor:
+        """
+        Normals of each triangle.
+        
+        Returns:
+            torch.Tensor - Shape (M, 3) float32 tensor of triangle normals.
+        """
+    @property
+    def triangles(self) -> torch.Tensor:
+        """
+        Mesh triangles.
+        
+        Returns:
+            torch.Tensor - Shape (M, 3) int32 tensor of triangles.
+        """
+    @property
+    def vertex_colors(self) -> torch.Tensor:
+        """
+        Vertex colors.
+        
+        Returns:
+            torch.Tensor - Shape (N, 3) float32 tensor of vertex colors.
+        """
+    @property
+    def vertex_normals(self) -> torch.Tensor:
+        """
+        Area-weighted vertex normals.
+        
+        Returns:
+            torch.Tensor - Shape (N, 3) float32 tensor of vertex normals.
+        """
+    @property
+    def vertex_to_triangle_counts(self) -> torch.Tensor:
+        """
+        Vertex to triangle counts.
+        
+        Returns:
+            torch.Tensor - Vertex to triangle counts.
+        """
+    @property
+    def vertex_to_triangle_indices(self) -> torch.Tensor:
+        """
+        Vertex to triangle indices.
+        
+        Returns:
+            torch.Tensor - Vertex to triangle indices.
+        """
+    @property
+    def vertex_to_triangle_offsets(self) -> torch.Tensor:
+        """
+        Vertex to triangle offsets.
+        
+        Returns:
+            torch.Tensor - Vertex to triangle offsets.
+        """
+    @property
+    def vertices(self) -> torch.Tensor:
+        """
+        Mesh vertices coordinates.
+        
+        Returns:
+            torch.Tensor - Shape (N, 3) float32 tensor of vertices.
+        """
+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
+    """
+def compute_gs_covi_func(means: torch.Tensor, rotations: torch.Tensor, scales: torch.Tensor, rotnorm: bool, tol: float, level: int) -> torch.Tensor:
+    """
+    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.
+    
+    Args:
+        sectors (int): The number of longitudinal sectors. Defaults to 32.
+        stacks (int): The number of latitudinal stacks. Defaults to 16.
+        radius (float): The radius of the sphere. Defaults to 1.0.
+    
+    Returns:
+        tuple: A tuple containing the vertices tensor and the triangles tensor.
+    """
+def solve_gs_neighbor_mahalanobis_radius_func(means: torch.Tensor, covis: torch.Tensor, k: int) -> torch.Tensor:
+    """
+    Solve Gaussian Neighbor Mahalanobis Radius
+    """
+def solve_pgs_cluster_tangency_radius_func(means: torch.Tensor, normals: torch.Tensor, covis: torch.Tensor, k: int = 16) -> tuple[torch.Tensor, torch.Tensor]:
+    ...

{conquer3d-0.2.7 → conquer3d-0.2.8}/conquer3d/__init__.py

@@ -4,5 +4,6 @@ from . import _C
 from . import creation
 from . import data_structure
 from . import primitive
+from . import ops
 
-__all__ = ['_C', 'creation', 'data_structure', 'primitive']
+__all__ = ['_C', 'creation', 'data_structure', 'primitive', 'ops']

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

@@ -0,0 +1,23 @@
+#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,
+          R"doc(Creates a UV sphere returning (vertices, triangles) tensors on the CPU.
+
+Args:
+    sectors (int): The number of longitudinal sectors. Defaults to 32.
+    stacks (int): The number of latitudinal stacks. Defaults to 16.
+    radius (float): The radius of the sphere. Defaults to 1.0.
+
+Returns:
+    tuple: A tuple containing the vertices tensor and the triangles tensor.
+)doc");
+}