conquer3d 0.3.0__tar.gz → 0.3.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conquer3d
-Version: 0.3.0
+Version: 0.3.1
 Summary: Geometric Cuda Tool Box
 Author-email: Do Hoang Khoi <khoido8899@gmail.com>
 License-Expression: MIT
@@ -13,6 +13,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: torch>=2.0.0
+Requires-Dist: gdown
 Provides-Extra: cuda
 Requires-Dist: cuda-toolkit==12.8.2; extra == "cuda"
 Provides-Extra: dev
@@ -61,7 +62,7 @@ pip install kaolin==0.18.0 -f https://nvidia-kaolin.s3.us-east-2.amazonaws.com/t
 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
+pip install plotly open3d jupyter trimesh point-cloud-utils meshlib
 ```
 
 # Development

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

@@ -33,7 +33,7 @@ pip install kaolin==0.18.0 -f https://nvidia-kaolin.s3.us-east-2.amazonaws.com/t
 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
+pip install plotly open3d jupyter trimesh point-cloud-utils meshlib
 ```
 
 # Development

{conquer3d-0.3.0 → conquer3d-0.3.1}/conquer3d/csrc/binds/data_structure/grid.cpp

@@ -122,8 +122,7 @@ torch::Tensor compute_grid_normal(torch::Tensor sdf, torch::Tensor grid_vertices
 }
 
 torch::Tensor compute_active_voxels(torch::Tensor voxels, torch::Tensor sdf, float iso) {
-    TORCH_CHECK(voxels.is_cuda(), "voxels must be a CUDA tensor.");
-    TORCH_CHECK(sdf.is_cuda(), "sdf must be a CUDA tensor.");
+    TORCH_CHECK(voxels.device() == sdf.device(), "voxels and sdf must be on the same device.");
     TORCH_CHECK(voxels.dtype() == torch::kInt32, "voxels must be int32.");
     TORCH_CHECK(sdf.dtype() == torch::kFloat32, "sdf must be float32.");
     

{conquer3d-0.3.0 → conquer3d-0.3.1}/conquer3d/csrc/primitive/aabb.h

@@ -167,6 +167,21 @@ namespace aabb
             (target_aabb_max.y) >= query_aabb_max.y &&
             (target_aabb_max.z) >= query_aabb_max.z);
     }
+
+    __device__ __forceinline__ bool test_point_inside_aabb(
+        const float3 &point,
+        const float3 &aabb_min,
+        const float3 &aabb_max
+    )
+    {
+        return (
+            aabb_min.x <= point.x &&
+            aabb_min.y <= point.y &&
+            aabb_min.z <= point.z &&
+            (aabb_max.x) >= point.x &&
+            (aabb_max.y) >= point.y &&
+            (aabb_max.z) >= point.z);
+    }
 }
 
 #endif // AABB_H

conquer3d-0.3.1/conquer3d/data/collate/sparse_tensor.py

@@ -0,0 +1,43 @@
+import torch
+
+def sparse_collate_fn(batch):
+    """
+    Collate function for sparse tensor dataloaders (e.g., MinkowskiEngine, spconv, torchsparse).
+    Takes a batch of samples where each sample is (idx_grids, features, ...).
+    Appends the batch index to the idx_grids to create (batch_idx, x, y, z).
+    
+    Args:
+        batch (list): A list of tuples (idx_grids, features, label)
+        
+    Returns:
+        tuple: (batched_coords, batched_features, batched_labels)
+            batched_coords (torch.Tensor): Shape (Total_N, 4)
+            batched_features (torch.Tensor): Shape (Total_N, ...)
+            batched_labels (torch.Tensor): Shape (Batch_Size,)
+    """
+    batched_coords = []
+    batched_features = []
+    batched_labels = []
+
+    for batch_idx, item in enumerate(batch):
+        idx_grids, features, label = item
+        
+        # Create a batch index column of shape [N, 1]
+        b_col = torch.full((idx_grids.shape[0], 1), batch_idx, dtype=idx_grids.dtype, device=idx_grids.device)
+        
+        # Concatenate to get [N, 4] formatted as (batch_idx, x, y, z)
+        coords_with_batch = torch.cat([b_col, idx_grids], dim=1)
+        
+        batched_coords.append(coords_with_batch)
+        batched_features.append(features)
+        batched_labels.append(label)
+
+    batched_coords = torch.cat(batched_coords, dim=0)
+    batched_features = torch.cat(batched_features, dim=0)
+    
+    if isinstance(batched_labels[0], torch.Tensor):
+        batched_labels = torch.stack(batched_labels, dim=0)
+    else:
+        batched_labels = torch.tensor(batched_labels)
+
+    return batched_coords, batched_features, batched_labels

conquer3d-0.3.1/conquer3d/data/dataset/base_mesh.py

@@ -0,0 +1,17 @@
+from torch.utils.data import Dataset
+from typing import Callable, Optional
+
+class BaseMeshDataset(Dataset):
+    """
+    Base PyTorch Dataset class for Mesh datasets.
+    """
+    def __init__(self, root: str, transform: Optional[Callable] = None):
+        super().__init__()
+        self.root = root
+        self.transform = transform
+
+    def __len__(self) -> int:
+        raise NotImplementedError("Subclasses must implement __len__")
+
+    def __getitem__(self, idx: int):
+        raise NotImplementedError("Subclasses must implement __getitem__")

conquer3d-0.3.1/conquer3d/data/dataset/digit3d.py

@@ -0,0 +1,136 @@
+import os
+import zipfile
+import torch
+import numpy as np
+import conquer3d as c3d
+import trimesh
+import meshlib.mrmeshpy as mr
+import meshlib.mrmeshnumpy as mrnp
+
+from .base_mesh import BaseMeshDataset
+
+class Digit3D(BaseMeshDataset):
+    """
+    Digit3D Mesh Dataset containing 3D MNIST digits.
+    """
+    def __init__(self, root: str = "~/.conquer3d/", train: bool = True, transform=None, download: bool = False, cached: bool = False):
+        root = os.path.expanduser(root)
+        super().__init__(root, transform)
+        self.train = train
+        self.zip_path = os.path.join(root, "digit3d.zip")
+        self.split_dir = "src/train" if train else "src/test"
+        self.cached = cached
+        self._cache = {}
+        
+        if download:
+            self.download()
+            
+        if not os.path.exists(self.zip_path):
+            raise RuntimeError(f"Dataset not found at {self.zip_path}. You can use download=True to download it.")
+            
+        with zipfile.ZipFile(self.zip_path, 'r') as z:
+            self.all_files = [f for f in z.namelist() if f.startswith(self.split_dir) and f.endswith(".obj")]
+
+    def download(self):
+        if os.path.exists(self.zip_path):
+            return
+        os.makedirs(self.root, exist_ok=True)
+        url = "https://drive.google.com/uc?id=1Vry0-sflcSmpwZnjn8yBbF2vBfuW1T_W"
+        try:
+            import gdown
+        except ImportError:
+            raise ImportError("gdown is required to download the dataset. Please install it using 'pip install gdown'.")
+        print(f"Downloading Digit3D dataset to {self.zip_path}...")
+        gdown.download(url, self.zip_path, quiet=False)
+
+    def __len__(self) -> int:
+        return len(self.all_files)
+
+    def __getitem__(self, idx: int):
+        if self.cached and idx in self._cache:
+            vertices_t, faces_t, label = self._cache[idx]
+            if self.transform:
+                vertices_t = self.transform(vertices_t.clone())
+            return vertices_t, faces_t, label
+            
+        f_path = self.all_files[idx]
+        basename = os.path.basename(f_path)
+        label = int(basename.split("_")[0])
+        
+        # Read directly from zip stream to avoid file descriptor and extraction I/O overhead
+        if getattr(self, '_zip', None) is None:
+            self._zip = zipfile.ZipFile(self.zip_path, 'r')
+            
+        with self._zip.open(f_path, 'r') as f:
+            content = f.read().decode('utf-8')
+                
+        vertices = []
+        faces = []
+        for line in content.splitlines():
+            if line.startswith("v "):
+                parts = line.split()
+                vertices.append([float(parts[1]), float(parts[2]), float(parts[3])])
+            elif line.startswith("f "):
+                parts = line.split()
+                # Wavefront OBJ faces are 1-indexed, so we subtract 1 for 0-indexed tensors
+                faces.append([int(parts[1])-1, int(parts[2])-1, int(parts[3])-1])
+                
+        vertices_t = torch.tensor(vertices, dtype=torch.float32)
+        faces_t = torch.tensor(faces, dtype=torch.int32)
+        
+        if self.cached:
+            self._cache[idx] = (vertices_t, faces_t, label)
+        
+        if self.transform:
+            vertices_t = self.transform(vertices_t.clone())
+            
+        return vertices_t, faces_t, label
+
+
+class SparseDigit3D(Digit3D):
+    """
+    Digit3D Dataset that constructs a sparse SDF voxel grid from the mesh on-the-fly using CPU (Open3D).
+    This allows arbitrary geometric augmentations on the mesh before voxelization without CUDA IPC issues.
+    """
+    def __init__(self, root: str = "~/.conquer3d/", train: bool = True, transform=None, download: bool = False, 
+                 grid_res: int = 32, grid_bound: float = 1.2, cached: bool = False):
+        super().__init__(root, train, transform, download, cached=cached)
+        self.grid_res = grid_res
+        self.grid_bound = grid_bound
+        
+    def __getitem__(self, idx: int):
+        # 1. Obtain vertices, faces, and label from Digit3D
+        vertices, faces, label = super().__getitem__(idx)
+        
+        # 2. Construct voxel grid in CPU
+        grid_vertices, voxels, idx_grids = c3d.data_structure.create_voxel_grid(
+            grid_min=[-self.grid_bound] * 3, 
+            grid_max=[self.grid_bound] * 3, 
+            res=[self.grid_res] * 3, 
+            device="cpu"
+        )
+        
+        # Construct the mesh using meshlib's numpy interface
+        mesh_mr = mrnp.meshFromFacesVerts(faces.numpy(), vertices.numpy())
+        
+        # Construct point cloud from grid vertices for vectorized distance computation
+        pc = mrnp.pointCloudFromPoints(grid_vertices.numpy())
+        
+        # Compute the signed distance for all grid vertices at once
+        dist_scalars = mr.findSignedDistances(mesh_mr, pc.points)
+        
+        # Convert to tensor
+        sdf = torch.tensor(list(dist_scalars), dtype=torch.float32, device="cpu")
+        
+        # 4. Compute active voxels
+        active_voxel_indices = c3d.data_structure.compute_active_voxels(voxels, sdf, iso=0.0)
+        
+        # 5. Extract purely Voxel-Centric representations using voxel2sparse
+        sparse_coords, sparse_sdfs = c3d.data_structure.voxel2sparse(
+            active_voxel_indices, voxels, idx_grids, sdf=sdf, batch_idx=0
+        )
+        
+        # We only need the x, y, z for the dataset (collate_fn handles batch_idx)
+        sparse_idx_grids = sparse_coords[:, 1:]
+        
+        return sparse_idx_grids, sparse_sdfs, label

conquer3d-0.3.1/conquer3d/data_structure/__init__.py

@@ -0,0 +1,29 @@
+from .._C import (
+    KDTree,
+    BVH,
+    GSBVH,
+    PGSBVH,
+    MeshBVH,
+    TriangleMesh
+)
+from .grid import (
+    create_voxel_grid, 
+    compute_grid_normal, 
+    compute_active_voxels, 
+    voxel2sparse, 
+    sparse2voxel,
+    sparse2mesh_topology
+)
+
+spatial_data_structures = ['KDTree', 'BVH', 'GSBVH', 'PGSBVH', 'MeshBVH']
+mesh_data_structures = ['TriangleMesh']
+grid_data_structures = [
+    'create_voxel_grid', 
+    'compute_grid_normal', 
+    'compute_active_voxels', 
+    'voxel2sparse', 
+    'sparse2voxel', 
+    'sparse2mesh_topology'
+]
+
+__all__ = spatial_data_structures + mesh_data_structures + grid_data_structures

{conquer3d-0.3.0 → conquer3d-0.3.1}/conquer3d/data_structure/grid.py

@@ -68,8 +68,9 @@ def voxel2sparse(
     active_indices: torch.Tensor,
     voxels: torch.Tensor,
     idx_grids: torch.Tensor,
+    sdf: torch.Tensor = None,
     batch_idx: int = 0
-) -> torch.Tensor:
+) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:
     """
     Converts 1D active voxel indices into the [N, 4] coordinates tensor 
     expected by sparse neural networks (like spconv/torchsparse).
@@ -78,10 +79,16 @@ def voxel2sparse(
         active_indices (torch.Tensor): 1D tensor of active voxel indices.
         voxels (torch.Tensor): An int32 tensor of shape (V, 8) containing corner indices for each voxel.
         idx_grids (torch.Tensor): An int64 tensor of shape (N, 3) containing the (i, j, k) 3D coordinate indices for each vertex.
+        sdf (torch.Tensor, optional): A float32 tensor of shape (N,) containing the SDF values. If provided, the function will also extract the 8 corner SDFs for each active voxel. Defaults to None.
         batch_idx (int, optional): The batch index to prepend. Defaults to 0.
         
     Returns:
-        torch.Tensor: An int32 tensor of shape (N, 4) in the format [batch_idx, x, y, z].
+        If sdf is None:
+            torch.Tensor: An int32 tensor of shape (N, 4) in the format [batch_idx, x, y, z].
+        If sdf is provided:
+            Tuple[torch.Tensor, torch.Tensor]: 
+                - sparse_coords (torch.Tensor): [N, 4] tensor
+                - sparse_sdfs (torch.Tensor): [N, 8] tensor containing the 8 corner SDF values for each voxel.
     """
     active_corners = voxels[active_indices]
     base_vertex_indices = active_corners[:, 0].to(torch.int64)
@@ -89,6 +96,11 @@ def voxel2sparse(
     
     batch_col = torch.full((voxel_coords.shape[0], 1), batch_idx, device=voxel_coords.device, dtype=torch.int64)
     sparse_coords = torch.cat([batch_col, voxel_coords], dim=1).to(torch.int32)
+    
+    if sdf is not None:
+        sparse_sdfs = sdf[active_corners.to(torch.int64)]
+        return sparse_coords, sparse_sdfs
+    
     return sparse_coords
 
 def sparse2voxel(
@@ -112,3 +124,72 @@ def sparse2voxel(
     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]],
+    grid_max: Union[List[float], Tuple[float, float, float]],
+    res: Union[List[int], Tuple[int, int, int]]
+) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    """
+    Converts pure voxel-centric sparse representations back into a localized, 
+    dense-free mesh topology ready for marching cubes.
+    
+    Args:
+        sparse_coords (torch.Tensor): [N, 4] tensor of voxel coords [batch_idx, x, y, z].
+        sparse_sdfs (torch.Tensor): [N, 8] tensor of corner SDFs.
+        grid_min (List[float]): Global minimum (x, y, z) bounds.
+        grid_max (List[float]): Global maximum (x, y, z) bounds.
+        res (List[int]): Global resolution (rx, ry, rz).
+        
+    Returns:
+        Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+            - unique_vertices (torch.Tensor): [M, 3] float coordinates of all unique mesh vertices.
+            - local_voxels (torch.Tensor): [N, 8] int tensor of corner indices mapping to unique_vertices.
+            - merged_sdfs (torch.Tensor): [M,] float tensor of averaged SDF values at unique_vertices.
+    """
+    device = sparse_coords.device
+    
+    # 1. Base integer coordinates of the voxels
+    base_coords = sparse_coords[:, 1:] # [N, 3]
+    
+    # 2. Local offsets for the 8 corners of a cube
+    cube_corners = torch.tensor([
+        [0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0], 
+        [0, 0, 1], [1, 0, 1], [1, 1, 1], [0, 1, 1]
+    ], dtype=torch.int32, device=device)
+    
+    # 3. Compute all corner integer coordinates [N, 8, 3]
+    all_corners = base_coords.unsqueeze(1) + cube_corners.unsqueeze(0)
+    all_corners_flat = all_corners.reshape(-1, 3) # [N*8, 3]
+    
+    # 4. Find the unique vertices to form our local mesh graph
+    unique_corners_int, inverse_indices = torch.unique(all_corners_flat, dim=0, return_inverse=True)
+    local_voxels = inverse_indices.reshape(-1, 8).to(torch.int32) # [N, 8]
+    
+    # 5. Average the SDFs at the overlapping corners
+    num_unique = unique_corners_int.shape[0]
+    merged_sdfs = torch.zeros(num_unique, dtype=sparse_sdfs.dtype, device=device)
+    counts = torch.zeros(num_unique, dtype=sparse_sdfs.dtype, device=device)
+    
+    flat_inverse = inverse_indices # [N*8]
+    flat_sdfs = sparse_sdfs.flatten() # [N*8]
+    
+    merged_sdfs.scatter_add_(0, flat_inverse, flat_sdfs)
+    counts.scatter_add_(0, flat_inverse, torch.ones_like(flat_sdfs))
+    merged_sdfs = merged_sdfs / counts
+    
+    # 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)
+    
+    ux = x_coords[unique_corners_int[:, 0]]
+    uy = y_coords[unique_corners_int[:, 1]]
+    uz = z_coords[unique_corners_int[:, 2]]
+    
+    unique_vertices = torch.stack([ux, uy, uz], dim=1)
+    
+    return unique_vertices, local_voxels, merged_sdfs

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conquer3d
-Version: 0.3.0
+Version: 0.3.1
 Summary: Geometric Cuda Tool Box
 Author-email: Do Hoang Khoi <khoido8899@gmail.com>
 License-Expression: MIT
@@ -13,6 +13,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: torch>=2.0.0
+Requires-Dist: gdown
 Provides-Extra: cuda
 Requires-Dist: cuda-toolkit==12.8.2; extra == "cuda"
 Provides-Extra: dev
@@ -61,7 +62,7 @@ pip install kaolin==0.18.0 -f https://nvidia-kaolin.s3.us-east-2.amazonaws.com/t
 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
+pip install plotly open3d jupyter trimesh point-cloud-utils meshlib
 ```
 
 # Development

{conquer3d-0.3.0 → conquer3d-0.3.1}/conquer3d.egg-info/SOURCES.txt

@@ -66,6 +66,13 @@ conquer3d/csrc/primitive/pgs_aabb.cu
 conquer3d/csrc/primitive/pgs_math.cuh
 conquer3d/csrc/primitive/ray.h
 conquer3d/csrc/primitive/triangles.h
+conquer3d/data/__init__.py
+conquer3d/data/collate/__init__.py
+conquer3d/data/collate/sparse_tensor.py
+conquer3d/data/dataset/__init__.py
+conquer3d/data/dataset/base_mesh.py
+conquer3d/data/dataset/digit3d.py
+conquer3d/data/transform/__init__.py
 conquer3d/data_structure/__init__.py
 conquer3d/data_structure/grid.py
 conquer3d/ops/__init__.py

{conquer3d-0.3.0 → conquer3d-0.3.1}/conquer3d.egg-info/requires.txt

@@ -1,4 +1,5 @@
 torch>=2.0.0
+gdown
 
 [cuda]
 cuda-toolkit==12.8.2

{conquer3d-0.3.0 → conquer3d-0.3.1}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "conquer3d"
-version = "0.3.0"
+version = "0.3.1"
 description = "Geometric Cuda Tool Box"
 readme = "README.md"
 license = "MIT"
@@ -20,6 +20,7 @@ requires-python = ">=3.9"
 keywords = ["geometry"]
 dependencies = [
     "torch>=2.0.0",
+    "gdown",
 ]
 
 [project.optional-dependencies]

conquer3d-0.3.0/conquer3d/data_structure/__init__.py

@@ -1,15 +0,0 @@
-from .._C import (
-    KDTree,
-    BVH,
-    GSBVH,
-    PGSBVH,
-    MeshBVH,
-    TriangleMesh
-)
-from .grid import create_voxel_grid, compute_grid_normal, compute_active_voxels, voxel2sparse, sparse2voxel
-
-spatial_data_structures = ['KDTree', 'BVH', 'GSBVH', 'PGSBVH', 'MeshBVH']
-mesh_data_structures = ['TriangleMesh']
-grid_data_structures = ['create_voxel_grid', 'compute_grid_normal', 'compute_active_voxels', 'voxel2sparse', 'sparse2voxel']
-
-__all__ = spatial_data_structures + mesh_data_structures + grid_data_structures