conquer3d 0.3.1__tar.gz → 0.3.3__tar.gz

{conquer3d-0.3.1/conquer3d.egg-info → conquer3d-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conquer3d
-Version: 0.3.1
+Version: 0.3.3
 Summary: Geometric Cuda Tool Box
 Author-email: Do Hoang Khoi <khoido8899@gmail.com>
 License-Expression: MIT
@@ -63,6 +63,8 @@ pip install pybind11-stubgen
 pip install git+https://github.com/KhoiDOO/geocutool.git --no-build-isolation
 
 pip install plotly open3d jupyter trimesh point-cloud-utils meshlib
+
+pip install rectified-flow-pytorch
 ```
 
 # Development
@@ -129,6 +131,24 @@ twine upload dist/* --verbose
 }
 ```
 
+```bibtex
+@InProceedings{10.1007/978-3-662-05105-4_2,
+author="Meyer, Mark
+and Desbrun, Mathieu
+and Schr{\"o}der, Peter
+and Barr, Alan H.",
+editor="Hege, Hans-Christian
+and Polthier, Konrad",
+title="Discrete Differential-Geometry Operators for Triangulated 2-Manifolds",
+booktitle="Visualization and Mathematics III",
+year="2003",
+publisher="Springer Berlin Heidelberg",
+address="Berlin, Heidelberg",
+pages="35--57",
+isbn="978-3-662-05105-4"
+}
+```
+
 ## Blog Post
 - [Thinking Parallel, Part I: Collision Detection on the GPU](https://developer.nvidia.com/blog/thinking-parallel-part-i-collision-detection-gpu/)
 - [Thinking Parallel, Part II: Tree Traversal on the GPU](https://developer.nvidia.com/blog/thinking-parallel-part-ii-tree-traversal-gpu/)

{conquer3d-0.3.1 → conquer3d-0.3.3}/README.md

@@ -34,6 +34,8 @@ pip install pybind11-stubgen
 pip install git+https://github.com/KhoiDOO/geocutool.git --no-build-isolation
 
 pip install plotly open3d jupyter trimesh point-cloud-utils meshlib
+
+pip install rectified-flow-pytorch
 ```
 
 # Development
@@ -100,6 +102,24 @@ twine upload dist/* --verbose
 }
 ```
 
+```bibtex
+@InProceedings{10.1007/978-3-662-05105-4_2,
+author="Meyer, Mark
+and Desbrun, Mathieu
+and Schr{\"o}der, Peter
+and Barr, Alan H.",
+editor="Hege, Hans-Christian
+and Polthier, Konrad",
+title="Discrete Differential-Geometry Operators for Triangulated 2-Manifolds",
+booktitle="Visualization and Mathematics III",
+year="2003",
+publisher="Springer Berlin Heidelberg",
+address="Berlin, Heidelberg",
+pages="35--57",
+isbn="978-3-662-05105-4"
+}
+```
+
 ## Blog Post
 - [Thinking Parallel, Part I: Collision Detection on the GPU](https://developer.nvidia.com/blog/thinking-parallel-part-i-collision-detection-gpu/)
 - [Thinking Parallel, Part II: Tree Traversal on the GPU](https://developer.nvidia.com/blog/thinking-parallel-part-ii-tree-traversal-gpu/)

{conquer3d-0.3.1 → conquer3d-0.3.3}/conquer3d/__init__.py

@@ -5,5 +5,8 @@ from . import creation
 from . import data_structure
 from . import primitive
 from . import ops
+from . import conversion
 
-__all__ = ['_C', 'creation', 'data_structure', 'primitive', 'ops']
+from .primitive import Triangle, Ray
+
+__all__ = ['_C', 'creation', 'data_structure', 'primitive', 'ops', 'conversion', 'Triangle', 'Ray']

conquer3d-0.3.3/conquer3d/conversion/__init__.py

@@ -0,0 +1,13 @@
+from .grid import (
+    voxel2sparse,
+    sparse2voxel,
+    sparse_coo2dense_occ,
+    dense_occ2sparse_coo
+)
+
+__all__ = [
+    "voxel2sparse",
+    "sparse2voxel",
+    "sparse_coo2dense_occ",
+    "dense_occ2sparse_coo"
+]

{conquer3d-0.3.1/conquer3d/data_structure → conquer3d-0.3.3/conquer3d/conversion}/grid.py

@@ -1,68 +1,5 @@
 import torch
 from typing import Tuple, List, Union
-from .. import _C
-
-def create_voxel_grid(
-    grid_min: Union[List[float], Tuple[float, float, float]],
-    grid_max: Union[List[float], Tuple[float, float, float]],
-    res: Union[List[int], Tuple[int, int, int]],
-    device: str = "cuda"
-) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
-    """
-    Creates a structured 3D voxel grid efficiently.
-    
-    Args:
-        grid_min (List[float] | Tuple[float, float, float]): The minimum (x, y, z) bounding box coordinates.
-        grid_max (List[float] | Tuple[float, float, float]): The maximum (x, y, z) bounding box coordinates.
-        res (List[int] | Tuple[int, int, int]): The number of vertices along each axis (rx, ry, rz).
-        device (str, optional): Target device for the tensors (e.g., "cuda" or "cpu"). Defaults to "cuda".
-        
-    Returns:
-        Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
-            - grid_vertices (torch.Tensor): A float32 tensor of shape (N, 3) containing all grid coordinates.
-            - voxels (torch.Tensor): An int32 tensor of shape (V, 8) containing corner indices 
-                                     for each voxel, mapped identically to the Marching Cubes convention.
-            - idx_grids (torch.Tensor): An int64 tensor of shape (N, 3) containing the (i, j, k) 3D coordinate indices for each vertex.
-    """
-    return _C.create_voxel_grid(list(grid_min), list(grid_max), list(res), device)
-
-def compute_grid_normal(
-    sdf: torch.Tensor,
-    grid_vertices: torch.Tensor,
-    idx_grids: torch.Tensor,
-    res: Union[List[int], Tuple[int, int, int]]
-) -> torch.Tensor:
-    """
-    Computes smooth normals (gradients) for a voxel grid using central differences.
-    
-    Args:
-        sdf (torch.Tensor): A float32 tensor of shape (N,) containing the SDF values.
-        grid_vertices (torch.Tensor): A float32 tensor of shape (N, 3) containing the grid coordinates.
-        idx_grids (torch.Tensor): An int64 tensor of shape (N, 3) containing the (i, j, k) indices, returned by create_voxel_grid.
-        res (List[int] | Tuple[int, int, int]): The number of vertices along each axis (rx, ry, rz).
-        
-    Returns:
-        torch.Tensor: A float32 tensor of shape (N, 3) containing the normalized gradient vectors.
-    """
-    return _C.compute_grid_normal(sdf.contiguous(), grid_vertices.contiguous(), idx_grids.contiguous(), list(res))
-
-def compute_active_voxels(
-    voxels: torch.Tensor,
-    sdf: torch.Tensor,
-    iso: float = 0.0
-) -> torch.Tensor:
-    """
-    Computes the indices of active voxels that intersect the isosurface.
-    
-    Args:
-        voxels (torch.Tensor): An int32 tensor of shape (V, 8) containing corner indices for each voxel.
-        sdf (torch.Tensor): A float32 tensor of shape (N,) containing the SDF values.
-        iso (float): The isosurface value. Defaults to 0.0.
-        
-    Returns:
-        torch.Tensor: An int64 tensor containing the indices of the active voxels.
-    """
-    return _C.compute_active_voxels(voxels.contiguous(), sdf.contiguous(), iso)
 
 def voxel2sparse(
     active_indices: torch.Tensor,
@@ -104,28 +41,6 @@ def voxel2sparse(
     return sparse_coords
 
 def sparse2voxel(
-    sparse_coords: torch.Tensor,
-    res: Union[List[int], Tuple[int, int, int]]
-) -> torch.Tensor:
-    """
-    Converts a [N, 4] sparse coordinates tensor back to 1D active voxel indices.
-    
-    Args:
-        sparse_coords (torch.Tensor): An int32 tensor of shape (N, 4) in the format [batch_idx, x, y, z].
-        res (List[int] | Tuple[int, int, int]): The number of vertices along each axis (rx, ry, rz).
-        
-    Returns:
-        torch.Tensor: An int64 tensor containing the indices of the active voxels.
-    """
-    x = sparse_coords[:, 1].to(torch.int64)
-    y = sparse_coords[:, 2].to(torch.int64)
-    z = sparse_coords[:, 3].to(torch.int64)
-    
-    rx, ry, rz = res
-    active_indices = x * (ry - 1) * (rz - 1) + y * (rz - 1) + z
-    return active_indices
-
-def sparse2mesh_topology(
     sparse_coords: torch.Tensor,
     sparse_sdfs: torch.Tensor,
     grid_min: Union[List[float], Tuple[float, float, float]],
@@ -182,9 +97,9 @@ def sparse2mesh_topology(
     
     # 6. Convert integer coordinates back to global float positions
     rx, ry, rz = res
-    x_coords = torch.linspace(grid_min[0], grid_max[0], rx, device=device, dtype=torch.float32)
-    y_coords = torch.linspace(grid_min[1], grid_max[1], ry, device=device, dtype=torch.float32)
-    z_coords = torch.linspace(grid_min[2], grid_max[2], rz, device=device, dtype=torch.float32)
+    x_coords = torch.linspace(grid_min[0], grid_max[0], rx + 1, device=device, dtype=torch.float32)
+    y_coords = torch.linspace(grid_min[1], grid_max[1], ry + 1, device=device, dtype=torch.float32)
+    z_coords = torch.linspace(grid_min[2], grid_max[2], rz + 1, device=device, dtype=torch.float32)
     
     ux = x_coords[unique_corners_int[:, 0]]
     uy = y_coords[unique_corners_int[:, 1]]
@@ -193,3 +108,49 @@ def sparse2mesh_topology(
     unique_vertices = torch.stack([ux, uy, uz], dim=1)
     
     return unique_vertices, local_voxels, merged_sdfs
+
+def sparse_coo2dense_occ(
+    sparse_coords: torch.Tensor,
+    batch_size: int,
+    res: Union[List[int], Tuple[int, int, int]]
+) -> torch.Tensor:
+    """
+    Converts a [N, 4] sparse coordinates tensor into a [B, 1, rx, ry, rz] dense occupancy grid.
+    
+    Args:
+        sparse_coords (torch.Tensor): An int32 tensor of shape (N, 4) in the format [batch_idx, x, y, z].
+        batch_size (int): The batch size B.
+        res (List[int] | Tuple[int, int, int]): The grid resolution (rx, ry, rz).
+        
+    Returns:
+        torch.Tensor: A float32 tensor of shape [B, 1, rx, ry, rz] containing 1.0 at active voxels and 0.0 otherwise.
+    """
+    rx, ry, rz = res
+    dense_occ = torch.zeros((batch_size, 1, rx, ry, rz), dtype=torch.float32, device=sparse_coords.device)
+    
+    b = sparse_coords[:, 0].to(torch.int64)
+    x = sparse_coords[:, 1].to(torch.int64)
+    y = sparse_coords[:, 2].to(torch.int64)
+    z = sparse_coords[:, 3].to(torch.int64)
+    
+    dense_occ[b, 0, x, y, z] = 1.0
+    return dense_occ
+
+def dense_occ2sparse_coo(
+    dense_occ: torch.Tensor,
+    threshold: float = 0.0
+) -> torch.Tensor:
+    """
+    Converts a [B, C, rx, ry, rz] dense occupancy grid back to a [N, 4] sparse coordinates tensor.
+    
+    Args:
+        dense_occ (torch.Tensor): A tensor of shape [B, C, rx, ry, rz].
+        
+    Returns:
+        torch.Tensor: An int32 tensor of shape (N, 4) in the format [batch_idx, x, y, z].
+    """
+    active_mask = dense_occ > threshold
+    indices = torch.argwhere(active_mask)
+    # indices has shape [N, 5] for [b, c, x, y, z]. We want [batch_idx, x, y, z]
+    sparse_coords = indices[:, [0, 2, 3, 4]].to(torch.int32)
+    return sparse_coords

conquer3d-0.3.3/conquer3d/conversion/mesh.py

@@ -0,0 +1,120 @@
+import torch
+from conquer3d.data_structure.grid import create_voxel_grid, compute_active_voxels
+from conquer3d.conversion.grid import voxel2sparse
+from conquer3d.data_structure import TriangleMesh
+from conquer3d.data_structure.bmesh import BTriangleMesh
+from typing import Union, List, Tuple
+
+def mesh2voxel(vertices: torch.Tensor, res: Union[List[int], Tuple[int, int, int]], grid_bound: float = None):
+    """
+    Computes bounding box of mesh and returns a structured voxel grid.
+    """
+    if grid_bound is None:
+        grid_min = vertices.min(dim=0)[0].tolist()
+        grid_max = vertices.max(dim=0)[0].tolist()
+    else:
+        grid_min = [-grid_bound, -grid_bound, -grid_bound]
+        grid_max = [grid_bound, grid_bound, grid_bound]
+        
+    device_str = str(vertices.device)
+    if device_str.startswith('cuda'):
+        # Fix format if there's an index like cuda:0
+        device_str = "cuda"
+        
+    grid_vertices, voxels, idx_grids = create_voxel_grid(grid_min, grid_max, res, device=device_str)
+    
+    # Ensure they are on the exact same device as vertices (especially if multiple GPUs)
+    grid_vertices = grid_vertices.to(vertices.device)
+    voxels = voxels.to(vertices.device)
+    idx_grids = idx_grids.to(vertices.device)
+    
+    return grid_vertices, voxels, idx_grids, grid_min, grid_max
+
+def mesh2voxel_sdf(vertices: torch.Tensor, faces: torch.Tensor, grid_vertices: torch.Tensor):
+    """
+    Computes SDF for grid vertices against the mesh using C++ TriangleMesh fast winding numbers.
+    """
+    mesh = TriangleMesh(vertices, faces.to(torch.int32))
+    
+    # query_points returns: q_ids, tri_ids, prj_pts, sdf
+    _, _, _, sdf = mesh.query_points(
+        grid_vertices,
+        return_sdf=True,
+        return_prj_pts=False,
+        sign_mode=0,
+        distance_mode=0
+    )
+    return sdf
+
+def mesh2sparse(bmesh: BTriangleMesh, res: Union[List[int], Tuple[int, int, int]], grid_bound: float = 1.2, iso: float = 0.0):
+    """
+    Batched processing of BTriangleMesh into sparse tensors.
+    """
+    all_coords = []
+    all_sdfs = []
+    
+    for b in range(bmesh.batch_size):
+        # Extract individual mesh
+        v_mask = bmesh.vertbids == b
+        f_mask = bmesh.facebids == b
+        
+        v = bmesh.vertices[v_mask]
+        f = bmesh.faces[f_mask]
+        
+        if len(v) == 0:
+            continue
+            
+        # Voxelize and Compute SDF
+        grid_vertices, voxels, idx_grids, _, _ = mesh2voxel(v, res, grid_bound)
+        sdf = mesh2voxel_sdf(v, f, grid_vertices)
+        
+        # Sparse conversion
+        active_voxels = compute_active_voxels(voxels, sdf, iso)
+        sparse_coords, sparse_sdfs = voxel2sparse(active_voxels, voxels, idx_grids, sdf=sdf, batch_idx=b)
+        
+        all_coords.append(sparse_coords)
+        all_sdfs.append(sparse_sdfs)
+        
+    if len(all_coords) > 0:
+        return torch.cat(all_coords, dim=0), torch.cat(all_sdfs, dim=0)
+    else:
+        # Fallback for empty batch
+        device = bmesh.vertices.device
+        return torch.empty((0, 4), dtype=torch.int32, device=device), torch.empty((0, 8), dtype=torch.float32, device=device)
+
+def mesh2sparse_with_dense(bmesh: BTriangleMesh, res: Union[List[int], Tuple[int, int, int]], grid_bound: float = 1.2, iso: float = 0.0):
+    """
+    Batched processing of BTriangleMesh into sparse tensors, also returning full dense coords.
+    """
+    all_coords = []
+    all_sdfs = []
+    all_dense_coords = []
+    all_dense_sdfs = []
+    
+    for b in range(bmesh.batch_size):
+        v_mask = bmesh.vertbids == b
+        f_mask = bmesh.facebids == b
+        
+        v = bmesh.vertices[v_mask]
+        f = bmesh.faces[f_mask]
+        
+        if len(v) == 0:
+            continue
+            
+        grid_vertices, voxels, idx_grids, _, _ = mesh2voxel(v, res, grid_bound)
+        sdf = mesh2voxel_sdf(v, f, grid_vertices)
+        
+        active_voxels = compute_active_voxels(voxels, sdf, iso)
+        sparse_coords, sparse_sdfs = voxel2sparse(active_voxels, voxels, idx_grids, sdf=sdf, batch_idx=b)
+        dense_coords, dense_sdfs = voxel2sparse(torch.ones_like(voxels[:, 0], dtype=torch.bool), voxels, idx_grids, sdf=sdf, batch_idx=b)
+        
+        all_coords.append(sparse_coords)
+        all_sdfs.append(sparse_sdfs)
+        all_dense_coords.append(dense_coords)
+        all_dense_sdfs.append(dense_sdfs)
+        
+    if len(all_coords) > 0:
+        return torch.cat(all_coords, dim=0), torch.cat(all_sdfs, dim=0), torch.cat(all_dense_coords, dim=0), torch.cat(all_dense_sdfs, dim=0)
+    else:
+        device = bmesh.vertices.device
+        return torch.empty((0, 4), dtype=torch.int32, device=device), torch.empty((0, 8), dtype=torch.float32, device=device), torch.empty((0, 4), dtype=torch.int32, device=device), torch.empty((0, 8), dtype=torch.float32, device=device)