conquer3d 0.3.1__tar.gz → 0.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conquer3d
-Version: 0.3.1
+Version: 0.3.2
 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

{conquer3d-0.3.1 → conquer3d-0.3.2}/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

{conquer3d-0.3.1 → 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.1/conquer3d/data_structure → conquer3d-0.3.2/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.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.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.1 → conquer3d-0.3.2}/conquer3d/data/dataset/digit3d.py

@@ -1,9 +1,7 @@
 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
 
@@ -50,7 +48,7 @@ class Digit3D(BaseMeshDataset):
         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())
+                vertices_t, faces_t = self.transform(vertices_t.clone(), faces_t.clone())
             return vertices_t, faces_t, label
             
         f_path = self.all_files[idx]
@@ -72,7 +70,6 @@ class Digit3D(BaseMeshDataset):
                 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)
@@ -82,15 +79,14 @@ class Digit3D(BaseMeshDataset):
             self._cache[idx] = (vertices_t, faces_t, label)
         
         if self.transform:
-            vertices_t = self.transform(vertices_t.clone())
+            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 using CPU (Open3D).
-    This allows arbitrary geometric augmentations on the mesh before voxelization without CUDA IPC issues.
+    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):
@@ -126,7 +122,7 @@ class SparseDigit3D(Digit3D):
         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(
+        sparse_coords, sparse_sdfs = c3d.conversion.grid.voxel2sparse(
             active_voxel_indices, voxels, idx_grids, sdf=sdf, batch_idx=0
         )
         

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.1 → conquer3d-0.3.2}/conquer3d/data_structure/__init__.py

@@ -10,9 +10,6 @@ from .grid import (
     create_voxel_grid, 
     compute_grid_normal, 
     compute_active_voxels, 
-    voxel2sparse, 
-    sparse2voxel,
-    sparse2mesh_topology
 )
 
 spatial_data_structures = ['KDTree', 'BVH', 'GSBVH', 'PGSBVH', 'MeshBVH']
@@ -21,9 +18,6 @@ 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.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.2/conquer3d/data_structure/grid.py

@@ -0,0 +1,65 @@
+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)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conquer3d
-Version: 0.3.1
+Version: 0.3.2
 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

{conquer3d-0.3.1 → 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
@@ -68,12 +71,17 @@ 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.1 → conquer3d-0.3.2}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "conquer3d"
-version = "0.3.1"
+version = "0.3.2"
 description = "Geometric Cuda Tool Box"
 readme = "README.md"
 license = "MIT"