conquer3d 0.3.0__tar.gz → 0.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conquer3d
-Version: 0.3.0
+Version: 0.3.2
 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,9 @@ 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
+
+pip install rectified-flow-pytorch
 ```
 
 # Development

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

@@ -33,7 +33,9 @@ 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
+
+pip install rectified-flow-pytorch
 ```
 
 # Development

{conquer3d-0.3.0 → conquer3d-0.3.2}/conquer3d/__init__.py

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

conquer3d-0.3.2/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.2/conquer3d/conversion/grid.py

@@ -0,0 +1,156 @@
+import torch
+from typing import Tuple, List, Union
+
+def voxel2sparse(
+    active_indices: torch.Tensor,
+    voxels: torch.Tensor,
+    idx_grids: torch.Tensor,
+    sdf: torch.Tensor = None,
+    batch_idx: int = 0
+) -> 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).
+    
+    Args:
+        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:
+        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)
+    voxel_coords = idx_grids[base_vertex_indices]
+    
+    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(
+    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 + 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]]
+    uz = z_coords[unique_corners_int[:, 2]]
+    
+    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.2/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)

{conquer3d-0.3.0 → conquer3d-0.3.2}/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.2}/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.2/conquer3d/data/collate/mesh.py

@@ -0,0 +1,40 @@
+import torch
+from conquer3d.data_structure.bmesh import BTriangleMesh
+
+def bmesh_collate_fn(batch):
+    """
+    Collate function for a dataset returning (vertices, faces, label).
+    Returns a BTriangleMesh and a batched label tensor.
+    """
+    all_vertices = []
+    all_faces = []
+    all_vertbids = []
+    all_facebids = []
+    all_labels = []
+    
+    for b, (v, f, l) in enumerate(batch):
+        all_vertices.append(v)
+        
+        # We do not offset the face indices because we will process them per-mesh locally
+        all_faces.append(f)
+        
+        all_vertbids.append(torch.full((v.shape[0],), b, dtype=torch.int32))
+        all_facebids.append(torch.full((f.shape[0],), b, dtype=torch.int32))
+        all_labels.append(l)
+        
+    batched_vertices = torch.cat(all_vertices, dim=0)
+    batched_faces = torch.cat(all_faces, dim=0)
+    batched_vertbids = torch.cat(all_vertbids, dim=0)
+    batched_facebids = torch.cat(all_facebids, dim=0)
+    
+    batched_labels = torch.tensor(all_labels, dtype=torch.long)
+    
+    bmesh = BTriangleMesh(
+        vertices=batched_vertices,
+        faces=batched_faces,
+        vertbids=batched_vertbids,
+        facebids=batched_facebids,
+        batch_size=len(batch)
+    )
+    
+    return bmesh, batched_labels

conquer3d-0.3.2/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.2/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.2/conquer3d/data/dataset/digit3d.py

@@ -0,0 +1,132 @@
+import os
+import zipfile
+import torch
+import conquer3d as c3d
+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, faces_t = self.transform(vertices_t.clone(), faces_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()
+                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, faces_t = self.transform(vertices_t.clone(), faces_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.
+    """
+    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.conversion.grid.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.2/conquer3d/data/transform/base.py

@@ -0,0 +1,39 @@
+import random
+
+class BaseTransform(object):
+    def __init__(self, p=1.0):
+        self.p = p
+
+    def __call__(self, **data):
+        if random.random() <= self.p:
+            return self.apply(**data)
+        return data
+        
+    def apply(self, **data):
+        raise NotImplementedError("Transform must implement apply")
+
+class Sequence(BaseTransform):
+    def __init__(self, transforms, shuffle=False, p=1.0):
+        super().__init__(p=p)
+        self.transforms = transforms
+        self.shuffle = shuffle
+
+    def apply(self, **data):
+        transforms_to_apply = self.transforms.copy()
+        if self.shuffle:
+            random.shuffle(transforms_to_apply)
+            
+        for transform in transforms_to_apply:
+            data = transform(**data)
+            
+        return data
+
+class MeshSequence(Sequence):
+    def __call__(self, vertices, faces):
+        if random.random() <= self.p:
+            return self.apply(vertices, faces)
+        return vertices, faces
+
+    def apply(self, vertices, faces):
+        data = super().apply(vertices=vertices, faces=faces)
+        return data.get('vertices', vertices), data.get('faces', faces)

conquer3d-0.3.2/conquer3d/data/transform/ops.py

@@ -0,0 +1,62 @@
+import torch
+import math
+
+def rotation(vertices, rotation_axis, rotation_degree):
+    """
+    Rotates vertices around a given axis by a specific degree.
+    
+    Args:
+        vertices (torch.Tensor): Shape (N, 3) representing 3D coordinates.
+        rotation_axis (str): 'x', 'y', or 'z'.
+        rotation_degree (float): Degree to rotate by (in degrees).
+        
+    Returns:
+        torch.Tensor: The rotated vertices of the same type.
+    """
+    theta = math.radians(rotation_degree)
+    cos_t = math.cos(theta)
+    sin_t = math.sin(theta)
+    
+    device = vertices.device
+    dtype = vertices.dtype
+    
+    # Define rotation matrices based on the axis directly as PyTorch tensors
+    if rotation_axis == 'x':
+        rot_mat = torch.tensor([
+            [1.0, 0.0, 0.0],
+            [0.0, cos_t, -sin_t],
+            [0.0, sin_t, cos_t]
+        ], dtype=dtype, device=device)
+    elif rotation_axis == 'y':
+        rot_mat = torch.tensor([
+            [cos_t, 0.0, sin_t],
+            [0.0, 1.0, 0.0],
+            [-sin_t, 0.0, cos_t]
+        ], dtype=dtype, device=device)
+    elif rotation_axis == 'z':
+        rot_mat = torch.tensor([
+            [cos_t, -sin_t, 0.0],
+            [sin_t, cos_t, 0.0],
+            [0.0, 0.0, 1.0]
+        ], dtype=dtype, device=device)
+    else:
+        raise ValueError("rotation_axis must be 'x', 'y', or 'z'")
+        
+    # Compute dot product
+    return torch.matmul(vertices, rot_mat.T)
+
+def scale(vertices, scale_factor):
+    """
+    Scales vertices by a given factor.
+    
+    Args:
+        vertices (torch.Tensor): Shape (N, 3) representing 3D coordinates.
+        scale_factor (float, tuple, or list): The factor(s) to scale by.
+        
+    Returns:
+        torch.Tensor: The scaled vertices.
+    """
+    if isinstance(scale_factor, (list, tuple)):
+        scale_factor = torch.tensor(scale_factor, dtype=vertices.dtype, device=vertices.device)
+        
+    return vertices * scale_factor

conquer3d-0.3.2/conquer3d/data/transform/vertex.py

@@ -0,0 +1,55 @@
+import torch
+import random
+from .base import BaseTransform
+from .ops import rotation, scale
+
+class Rotation(BaseTransform):
+    def __init__(self, axis='z', degree_range=(-180, 180), p=1.0):
+        """
+        Args:
+            axis (str or list): The axis or list of axes to rotate around ('x', 'y', 'z').
+            degree_range (tuple): Range of degrees to randomly sample from (min, max).
+            p (float): Probability of applying the transform.
+        """
+        super().__init__(p=p)
+        self.axis = axis
+        self.degree_range = degree_range
+        
+    def apply(self, **data):
+        if 'vertices' not in data:
+            raise KeyError("Rotation transform requires 'vertices' in data")
+            
+        vertices = data['vertices']
+        
+        # Support multiple axes in sequence
+        axes = self.axis if isinstance(self.axis, (list, tuple)) else [self.axis]
+        
+        for ax in axes:
+            # Sample a random degree for each axis
+            degree = random.uniform(self.degree_range[0], self.degree_range[1])
+            vertices = rotation(vertices, ax, degree)
+            
+        data['vertices'] = vertices
+        return data
+
+class Scale(BaseTransform):
+    def __init__(self, scale_range=(0.8, 1.2), p=1.0):
+        """
+        Args:
+            scale_range (tuple): Range of scale factors to randomly sample from (min, max).
+            p (float): Probability of applying the transform.
+        """
+        super().__init__(p=p)
+        self.scale_range = scale_range
+        
+    def apply(self, **data):
+        if 'vertices' not in data:
+            raise KeyError("Scale transform requires 'vertices' in data")
+            
+        vertices = data['vertices']
+        
+        # Sample a uniform random scale factor
+        scale_factor = random.uniform(self.scale_range[0], self.scale_range[1])
+        
+        data['vertices'] = scale(vertices, scale_factor)
+        return data

{conquer3d-0.3.0 → conquer3d-0.3.2}/conquer3d/data_structure/__init__.py

@@ -6,10 +6,18 @@ from .._C import (
     MeshBVH,
     TriangleMesh
 )
-from .grid import create_voxel_grid, compute_grid_normal, compute_active_voxels, voxel2sparse, sparse2voxel
+from .grid import (
+    create_voxel_grid, 
+    compute_grid_normal, 
+    compute_active_voxels, 
+)
 
 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']
+grid_data_structures = [
+    'create_voxel_grid', 
+    'compute_grid_normal', 
+    'compute_active_voxels', 
+]
 
 __all__ = spatial_data_structures + mesh_data_structures + grid_data_structures

conquer3d-0.3.2/conquer3d/data_structure/bmesh.py

@@ -0,0 +1,23 @@
+import torch
+
+class BTriangleMesh:
+    def __init__(self, vertices: torch.Tensor, faces: torch.Tensor, vertbids: torch.Tensor, facebids: torch.Tensor, batch_size: int):
+        self.vertices = vertices
+        self.faces = faces
+        self.vertbids = vertbids
+        self.facebids = facebids
+        self.batch_size = batch_size
+
+    def to(self, device):
+        self.vertices = self.vertices.to(device)
+        self.faces = self.faces.to(device)
+        self.vertbids = self.vertbids.to(device)
+        self.facebids = self.facebids.to(device)
+        return self
+        
+    def cuda(self, non_blocking=False):
+        self.vertices = self.vertices.cuda(non_blocking=non_blocking)
+        self.faces = self.faces.cuda(non_blocking=non_blocking)
+        self.vertbids = self.vertbids.cuda(non_blocking=non_blocking)
+        self.facebids = self.facebids.cuda(non_blocking=non_blocking)
+        return self

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

@@ -62,53 +62,4 @@ def compute_active_voxels(
     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,
-    voxels: torch.Tensor,
-    idx_grids: torch.Tensor,
-    batch_idx: int = 0
-) -> torch.Tensor:
-    """
-    Converts 1D active voxel indices into the [N, 4] coordinates tensor 
-    expected by sparse neural networks (like spconv/torchsparse).
-    
-    Args:
-        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.
-        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].
-    """
-    active_corners = voxels[active_indices]
-    base_vertex_indices = active_corners[:, 0].to(torch.int64)
-    voxel_coords = idx_grids[base_vertex_indices]
-    
-    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)
-    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
+    return _C.compute_active_voxels(voxels.contiguous(), sdf.contiguous(), iso)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conquer3d
-Version: 0.3.0
+Version: 0.3.2
 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,9 @@ 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
+
+pip install rectified-flow-pytorch
 ```
 
 # Development

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

@@ -12,6 +12,9 @@ conquer3d.egg-info/dependency_links.txt
 conquer3d.egg-info/not-zip-safe
 conquer3d.egg-info/requires.txt
 conquer3d.egg-info/top_level.txt
+conquer3d/conversion/__init__.py
+conquer3d/conversion/grid.py
+conquer3d/conversion/mesh.py
 conquer3d/creation/__init__.py
 conquer3d/creation/triangle_creation.py
 conquer3d/csrc/check.h
@@ -66,7 +69,19 @@ 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/mesh.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/transform/base.py
+conquer3d/data/transform/ops.py
+conquer3d/data/transform/vertex.py
 conquer3d/data_structure/__init__.py
+conquer3d/data_structure/bmesh.py
 conquer3d/data_structure/grid.py
 conquer3d/ops/__init__.py
 conquer3d/ops/diff_marching_cubes.py

{conquer3d-0.3.0 → conquer3d-0.3.2}/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.2}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "conquer3d"
-version = "0.3.0"
+version = "0.3.2"
 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]