conquer3d 0.3.4__tar.gz → 0.3.9__tar.gz

{conquer3d-0.3.4/conquer3d.egg-info → conquer3d-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conquer3d
-Version: 0.3.4
+Version: 0.3.9
 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: meshio>=5.3.5
 Requires-Dist: gdown
 Provides-Extra: cuda
 Requires-Dist: cuda-toolkit==12.8.2; extra == "cuda"
@@ -49,6 +50,7 @@ pip install git+https://github.com/KhoiDOO/geocutool.git --no-build-isolation
 ```bash
 conda create -c conda-forge -n geocutool python=3.10 gxx_linux-64=13 gcc_linux-64=13 -y
 conda activate geocutool
+conda install -c conda-forge sparsehash -y
 
 conda install nvidia::cuda-toolkit==12.8.2 -y
 

{conquer3d-0.3.4 → conquer3d-0.3.9}/README.md

@@ -20,6 +20,7 @@ pip install git+https://github.com/KhoiDOO/geocutool.git --no-build-isolation
 ```bash
 conda create -c conda-forge -n geocutool python=3.10 gxx_linux-64=13 gcc_linux-64=13 -y
 conda activate geocutool
+conda install -c conda-forge sparsehash -y
 
 conda install nvidia::cuda-toolkit==12.8.2 -y
 

{conquer3d-0.3.4 → conquer3d-0.3.9}/conquer3d/creation/triangle_creation.py

@@ -2,6 +2,7 @@ import torch
 from typing import Tuple
 
 from .._C import create_sphere as create_sphere_c
+from .._C import create_tetrahedra as create_tetrahedra_c
 
 def create_sphere(
     sectors: int = 32,
@@ -21,3 +22,18 @@ def create_sphere(
         triangles: (M, 3) int32 tensor of triangle indices.
     """
     return create_sphere_c(sectors, stacks, radius)
+
+def create_tetrahedra(
+    radius: float = 1.0
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Creates a regular tetrahedron returning (vertices, triangles) tensors on the CPU.
+
+    Args:
+        radius (float, optional): Circumscribed radius of the tetrahedron. Defaults to 1.0.
+
+    Returns:
+        vertices: (4, 3) float32 tensor of vertex positions.
+        triangles: (4, 3) int32 tensor of triangle indices.
+    """
+    return create_tetrahedra_c(radius)

{conquer3d-0.3.4 → conquer3d-0.3.9}/conquer3d/csrc/binds/creation/triangle_creation.cpp

@@ -17,6 +17,17 @@ Args:
     stacks (int): The number of latitudinal stacks. Defaults to 16.
     radius (float): The radius of the sphere. Defaults to 1.0.
 
+Returns:
+    tuple: A tuple containing the vertices tensor and the triangles tensor.
+)doc");
+
+    m.def("create_tetrahedra", &triangle_creation::create_tetrahedra,
+          py::arg("radius") = 1.0f,
+          R"doc(Creates a regular tetrahedron returning (vertices, triangles) tensors on the CPU.
+
+Args:
+    radius (float): The circumscribed radius of the tetrahedron. Defaults to 1.0.
+
 Returns:
     tuple: A tuple containing the vertices tensor and the triangles tensor.
 )doc");

conquer3d-0.3.9/conquer3d/csrc/binds/data_structure/zcurve.cpp

@@ -0,0 +1,32 @@
+#include <torch/extension.h>
+#include <pybind11/pybind11.h>
+#include "../../data_structure/zcurve.h"
+#include "../../check.h"
+
+namespace py = pybind11;
+
+torch::Tensor compute_zcurve_wrapper(torch::Tensor points)
+{
+    CHECK_INPUT(points);
+
+    // We expect points to be [..., 3]
+    auto num_points = points.numel() / 3;
+    const float *p_points = points.data_ptr<float>();
+
+    // Output is same shape as points but without the last dim
+    auto sizes = points.sizes().vec();
+    sizes.pop_back();
+
+    torch::Tensor codes = torch::empty(sizes, points.options().dtype(torch::kInt64));
+    int64_t *p_codes = codes.data_ptr<int64_t>();
+
+    zcurve::compute_zcurve(p_points, num_points, p_codes);
+
+    return codes;
+}
+
+void bind_ds_zcurve(py::module_ &m)
+{
+    m.def("compute_zcurve", &compute_zcurve_wrapper, "Compute Z-curve codes for a batch of points",
+          py::arg("points"));
+}

{conquer3d-0.3.4 → conquer3d-0.3.9}/conquer3d/csrc/creation/triangle_creation.h

@@ -92,6 +92,31 @@ namespace triangle_creation
         return {V, F};
     }
 
+    inline std::tuple<torch::Tensor, torch::Tensor> create_tetrahedra(float radius = 1.0f) {
+        float a = radius / std::sqrt(3.0f);
+        std::vector<float> vertices = {
+             a,  a,  a,
+            -a, -a,  a,
+            -a,  a, -a,
+             a, -a, -a
+        };
+
+        std::vector<int> triangles = {
+            0, 2, 1,
+            0, 1, 3,
+            0, 3, 2,
+            1, 2, 3
+        };
+
+        auto opts_f32 = torch::TensorOptions().dtype(torch::kFloat32);
+        auto opts_i32 = torch::TensorOptions().dtype(torch::kInt32);
+
+        torch::Tensor V = torch::from_blob(vertices.data(), {4, 3}, opts_f32).clone();
+        torch::Tensor F = torch::from_blob(triangles.data(), {4, 3}, opts_i32).clone();
+
+        return {V, F};
+    }
+
 }
 
 #endif // TRIANGLE_CREATION_H

conquer3d-0.3.9/conquer3d/csrc/data_structure/zcurve.cu

@@ -0,0 +1,27 @@
+#include "zcurve.h"
+#include "../constants.h"
+#include <cuda_runtime.h>
+
+namespace zcurve
+{
+
+    __global__ void compute_zcurve_kernel(const float3 *__restrict__ points, uint32_t num_points, int64_t *__restrict__ codes)
+    {
+        uint32_t idx = blockIdx.x * blockDim.x + threadIdx.x;
+        if (idx >= num_points)
+            return;
+
+        float3 p = points[idx];
+        unsigned int code = morton3D(p.x, p.y, p.z);
+        codes[idx] = (int64_t)code;
+    }
+
+    void compute_zcurve(const float *points, uint32_t num_points, int64_t *codes)
+    {
+        uint32_t threads = NTHREADS;
+        uint32_t blocks = (num_points + threads - 1) / threads;
+
+        compute_zcurve_kernel<<<blocks, threads>>>((const float3 *)points, num_points, codes);
+    }
+
+}

{conquer3d-0.3.4 → conquer3d-0.3.9}/conquer3d/csrc/data_structure/zcurve.h

@@ -6,7 +6,7 @@
 
 namespace zcurve
 {
-    __device__ unsigned int expandBits(unsigned int v)
+    inline __device__ unsigned int expandBits(unsigned int v)
     {
         v = (v * 0x00010001u) & 0xFF0000FFu;
         v = (v * 0x00000101u) & 0x0F00F00Fu;
@@ -15,16 +15,21 @@ namespace zcurve
         return v;
     }
 
-    __device__ unsigned int morton3D(float x, float y, float z)
+    inline __device__ unsigned int morton3D(float x, float y, float z)
     {
-        x = min(max(x * 1024.0f, 0.0f), 1023.0f);
-        y = min(max(y * 1024.0f, 0.0f), 1023.0f);
-        z = min(max(z * 1024.0f, 0.0f), 1023.0f);
+        x = x * 1024.0f;
+        y = y * 1024.0f;
+        z = z * 1024.0f;
+        x = x < 0.0f ? 0.0f : (x > 1023.0f ? 1023.0f : x);
+        y = y < 0.0f ? 0.0f : (y > 1023.0f ? 1023.0f : y);
+        z = z < 0.0f ? 0.0f : (z > 1023.0f ? 1023.0f : z);
         unsigned int xx = expandBits((unsigned int)x);
         unsigned int yy = expandBits((unsigned int)y);
         unsigned int zz = expandBits((unsigned int)z);
         return xx * 4 + yy * 2 + zz;
     }
+
+    void compute_zcurve(const float *points, uint32_t num_points, int64_t *codes);
 }
 
 #endif // ZCURVE_H

{conquer3d-0.3.4 → conquer3d-0.3.9}/conquer3d/csrc/pybind.cpp

@@ -15,6 +15,7 @@ void bind_ds_pgs_bvh(py::module_& m);
 void bind_ds_mesh_bvh(py::module_& m);
 void bind_ds_triangle_mesh(py::module_& m);
 void bind_ds_grid(py::module_& m);
+void bind_ds_zcurve(py::module_& m);
 
 void bind_creation_triangle_creation(py::module_& m);
 
@@ -36,6 +37,7 @@ PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
     bind_ds_mesh_bvh(m);
     bind_ds_triangle_mesh(m);
     bind_ds_grid(m);
+    bind_ds_zcurve(m);
     
     bind_creation_triangle_creation(m);
     

conquer3d-0.3.9/conquer3d/data/assets/__init__.py

@@ -0,0 +1,2 @@
+from .common import *
+from .iphigenia import *

{conquer3d-0.3.4 → conquer3d-0.3.9}/conquer3d/data/assets/common.py

@@ -33,6 +33,13 @@ class Common3D:
         print(f"Reading {self.filename}...")
         self.vertices, self.faces, self.colors = read_obj(obj_path)
 
+    def get(self):
+        return (
+            self.vertices.clone(),
+            self.faces.clone(),
+            self.colors.clone() if self.colors is not None else None
+        )
+
 # --- Child Classes ---
 
 class Alligator(Common3D):

{conquer3d-0.3.4 → conquer3d-0.3.9}/conquer3d/data/assets/iphigenia.py

@@ -15,6 +15,7 @@ class Iphiagenia:
         self.download_dir = os.path.expanduser(download_dir)
         self.vertices = None
         self.faces = None
+        self.colors = None
         
         self._load()
 
@@ -41,3 +42,9 @@ class Iphiagenia:
                 # off_file is a file-like object of bytes.
                 # read_off will automatically decode and parse it.
                 self.vertices, self.faces = read_off(off_file)
+    def get(self):
+        return (
+            self.vertices.clone(),
+            self.faces.clone(),
+            self.colors.clone() if self.colors is not None else None
+        )

{conquer3d-0.3.4 → conquer3d-0.3.9}/conquer3d/data/dataset/digit3d.py

@@ -130,3 +130,32 @@ class SparseDigit3D(Digit3D):
         sparse_idx_grids = sparse_coords[:, 1:]
         
         return sparse_idx_grids, sparse_sdfs, label
+
+class PointDigit3D(Digit3D):
+    """
+    Digit3D Dataset that constructs a point cloud by sampling on the mesh.
+    """
+    def __init__(self, root: str = "~/.conquer3d/", train: bool = True, transform=None, download: bool = False, 
+                 cached: bool = False, num_points: int = 512):
+        super().__init__(root, train, transform, download, cached=cached)
+        self.num_points = num_points
+        
+    def __getitem__(self, idx: int):
+        # 1. Obtain vertices, faces, and label from Digit3D
+        vertices, faces, label = super().__getitem__(idx)
+        
+        import trimesh
+        # 2. Construct trimesh object (CPU safe for DataLoader workers)
+        mesh = trimesh.Trimesh(vertices=vertices.numpy(), faces=faces.numpy(), process=False)
+        
+        # 3. Sample points uniformly over the surface
+        points_np, face_indices = trimesh.sample.sample_surface(mesh, self.num_points)
+        normals_np = mesh.face_normals[face_indices]
+        
+        points = torch.tensor(points_np, dtype=torch.float32)
+        normals = torch.tensor(normals_np, dtype=torch.float32)
+        
+        # 4. Combine into features
+        features = torch.cat([points, normals], dim=-1)
+        
+        return points, features, label

{conquer3d-0.3.4 → conquer3d-0.3.9}/conquer3d/data_structure/__init__.py

@@ -11,6 +11,7 @@ from .grid import (
     compute_grid_normal, 
     compute_active_voxels, 
 )
+from .sort import z_curve_sort
 
 spatial_data_structures = ['KDTree', 'BVH', 'GSBVH', 'PGSBVH', 'MeshBVH']
 mesh_data_structures = ['TriangleMesh']
@@ -19,5 +20,6 @@ grid_data_structures = [
     'compute_grid_normal', 
     'compute_active_voxels', 
 ]
+sort_data_structures = ['z_curve_sort']
 
-__all__ = spatial_data_structures + mesh_data_structures + grid_data_structures
+__all__ = spatial_data_structures + mesh_data_structures + grid_data_structures + sort_data_structures

{conquer3d-0.3.4 → conquer3d-0.3.9}/conquer3d/data_structure/grid.py

@@ -62,4 +62,21 @@ 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)
+    return _C.compute_active_voxels(voxels.contiguous(), sdf.contiguous(), iso)
+
+def create_random_points_ball(n_points: int, radius: float = 1.0, device: str = 'cuda') -> torch.Tensor:
+    """
+    Creates a set of random points uniformly distributed inside a sphere.
+
+    Args:
+        n_points (int): Number of points to sample.
+        radius (float): Radius of the sphere. Defaults to 1.0.
+        device (str): Device to place the tensor on. Defaults to 'cuda'.
+
+    Returns:
+        torch.Tensor: Random points of shape (n_points, 3).
+    """
+    points = torch.randn(n_points, 3, device=device)
+    radii = torch.rand(n_points, 1, device=device) ** (1/3) * radius
+    points = (points / points.norm(dim=-1, keepdim=True)) * radii
+    return points

conquer3d-0.3.9/conquer3d/data_structure/sort.py

@@ -0,0 +1,37 @@
+import torch
+import conquer3d._C as _C
+
+def z_curve_sort(points: torch.Tensor):
+    """
+    Computes the Z-curve (Morton code) for a batch of points and sorts them.
+    Assumes points are normalized between [0, 1]. The function will clamp points outside this range.
+    
+    Args:
+        points (torch.Tensor): Tensor of shape (..., 3) containing the point coordinates.
+        
+    Returns:
+        sorted_points (torch.Tensor): Points sorted by their Z-curve value.
+        sorted_indices (torch.Tensor): The indices used to sort the points.
+        inverse_indices (torch.Tensor): The indices to reverse the sorting.
+    """
+    assert points.is_cuda, "Points must be on CUDA"
+    assert points.dtype == torch.float32, "Points must be float32"
+    assert points.shape[-1] == 3, "Points must be 3D"
+    
+    # Compute the Morton codes for each point
+    codes = _C.compute_zcurve(points.contiguous())
+    
+    # codes has shape (..., N). We always sort along the last dimension (dim=-1)
+    
+    sorted_codes, sorted_indices = torch.sort(codes, dim=-1)
+    
+    # Gather the points using the sorted indices
+    # We need to expand sorted_indices to match points: (..., N, 3)
+    dim = -2 if points.dim() > 1 else -1
+    expanded_indices = sorted_indices.unsqueeze(-1).expand_as(points)
+    sorted_points = torch.gather(points, dim=dim, index=expanded_indices)
+    
+    # Compute the inverse indices (scatter)
+    inverse_indices = torch.argsort(sorted_indices, dim=-1)
+    
+    return sorted_points, sorted_indices, inverse_indices

conquer3d-0.3.9/conquer3d/io/__init__.py

@@ -0,0 +1,2 @@
+from .obj import read_obj, write_obj
+from .off import read_off

conquer3d-0.3.9/conquer3d/io/obj.py

@@ -0,0 +1,38 @@
+import torch
+import trimesh
+import numpy as np
+
+def read_obj(file_obj):
+    """
+    Reads an OBJ file and returns vertices, faces, and optional vertex colors using trimesh.
+    
+    Args:
+        file_obj: A file-like object or a string path.
+    """
+    # trimesh safely handles UV seams and mismatched v/vt counts
+    mesh = trimesh.load(file_obj, process=False, force='mesh', skip_materials=True)
+    
+    vertices = torch.tensor(mesh.vertices, dtype=torch.float32)
+    faces = torch.tensor(mesh.faces, dtype=torch.long)
+    
+    colors = None
+    if hasattr(mesh.visual, 'vertex_colors') and mesh.visual.vertex_colors is not None and len(mesh.visual.vertex_colors) > 0:
+        colors = torch.tensor(mesh.visual.vertex_colors[:, :3], dtype=torch.float32) / 255.0
+        
+    return vertices, faces, colors
+
+def write_obj(filepath, vertices, faces, colors=None):
+    """
+    Writes vertices, faces, and optional vertex colors to an OBJ file using trimesh.
+    """
+    v = vertices.detach().cpu().numpy()
+    f = faces.detach().cpu().numpy()
+    
+    vc = None
+    if colors is not None:
+        vc = (colors.detach().cpu().numpy() * 255.0).clip(0, 255).astype(np.uint8)
+        
+    mesh = trimesh.Trimesh(vertices=v, faces=f, vertex_colors=vc, process=False)
+    mesh.export(filepath)
+
+

conquer3d-0.3.9/conquer3d/io/off.py

@@ -0,0 +1,20 @@
+import torch
+import trimesh
+
+def read_off(filepath_or_filelike):
+    """
+    Read an OFF (Object File Format) file and return vertices and faces as PyTorch tensors using trimesh.
+    
+    Args:
+        filepath_or_filelike: A string path or a file-like object (including binary streams).
+        
+    Returns:
+        tuple: (vertices, faces) as torch.Tensor
+    """
+    # trimesh handles both string paths and binary file streams natively
+    mesh = trimesh.load(filepath_or_filelike, file_type='off', process=False, force='mesh')
+    
+    vertices = torch.tensor(mesh.vertices, dtype=torch.float32)
+    faces = torch.tensor(mesh.faces, dtype=torch.long)
+        
+    return vertices, faces

conquer3d-0.3.9/conquer3d/ops/__init__.py

@@ -0,0 +1,19 @@
+from .marching_cubes import marching_cubes
+from .diff_marching_cubes import diff_marching_cubes
+
+from .delaunay_triangulation import tetrahedralize, get_edges
+from .marching_tetrahedra import marching_tetrahedra
+
+from .distance import one_sided_chamfer_distance, chamfer_distance, one_sided_hausdorff_distance, hausdorff_distance
+
+__all__ = [
+    "marching_cubes",
+    "diff_marching_cubes",
+    "one_sided_chamfer_distance",
+    "chamfer_distance",
+    "one_sided_hausdorff_distance",
+    "hausdorff_distance",
+    "tetrahedralize",
+    "get_edges",
+    "marching_tetrahedra"
+]

{conquer3d-0.3.4 → conquer3d-0.3.9}/conquer3d/ops/delaunay_triangulation.py

@@ -1,6 +1,5 @@
 import torch
 import numpy as np
-import tetgen
 
 def find_near_duplicates_sort(points, epsilon=1e-7):
     """

{conquer3d-0.3.4 → conquer3d-0.3.9}/conquer3d/ops/distance.py

@@ -26,3 +26,30 @@ def chamfer_distance(x: torch.Tensor, y: torch.Tensor, squared: bool = True, ret
     if return_indices:
         return loss, idx_x_to_y, idx_y_to_x
     return loss
+
+def one_sided_hausdorff_distance(query_points: torch.Tensor, reference_points: torch.Tensor, squared: bool = True, return_indices: bool = False):
+    distances, indices = one_sided_chamfer_distance(query_points, reference_points, squared=squared)
+    
+    max_dist, max_idx = torch.max(distances, dim=0)
+    
+    if return_indices:
+        return max_dist, max_idx, indices[max_idx]
+    return max_dist
+
+def hausdorff_distance(x: torch.Tensor, y: torch.Tensor, squared: bool = True, return_indices: bool = False):
+    if return_indices:
+        dist_x_to_y, idx_x1, idx_y1 = one_sided_hausdorff_distance(x, y, squared=squared, return_indices=True)
+        dist_y_to_x, idx_y2, idx_x2 = one_sided_hausdorff_distance(y, x, squared=squared, return_indices=True)
+        
+        if dist_x_to_y > dist_y_to_x:
+            return dist_x_to_y, idx_x1, idx_y1
+        else:
+            return dist_y_to_x, idx_x2, idx_y2
+    else:
+        dist_x_to_y = one_sided_hausdorff_distance(x, y, squared=squared, return_indices=False)
+        dist_y_to_x = one_sided_hausdorff_distance(y, x, squared=squared, return_indices=False)
+        
+        if dist_x_to_y > dist_y_to_x:
+            return dist_x_to_y
+        else:
+            return dist_y_to_x

{conquer3d-0.3.4 → conquer3d-0.3.9/conquer3d.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conquer3d
-Version: 0.3.4
+Version: 0.3.9
 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: meshio>=5.3.5
 Requires-Dist: gdown
 Provides-Extra: cuda
 Requires-Dist: cuda-toolkit==12.8.2; extra == "cuda"
@@ -49,6 +50,7 @@ pip install git+https://github.com/KhoiDOO/geocutool.git --no-build-isolation
 ```bash
 conda create -c conda-forge -n geocutool python=3.10 gxx_linux-64=13 gcc_linux-64=13 -y
 conda activate geocutool
+conda install -c conda-forge sparsehash -y
 
 conda install nvidia::cuda-toolkit==12.8.2 -y
 

{conquer3d-0.3.4 → conquer3d-0.3.9}/conquer3d.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ conquer3d/csrc/binds/data_structure/kdtree.cpp
 conquer3d/csrc/binds/data_structure/mesh_bvh.cpp
 conquer3d/csrc/binds/data_structure/pgs_bvh.cpp
 conquer3d/csrc/binds/data_structure/triangle_mesh.cpp
+conquer3d/csrc/binds/data_structure/zcurve.cpp
 conquer3d/csrc/binds/ops/chamfer.cpp
 conquer3d/csrc/binds/ops/mc.cpp
 conquer3d/csrc/binds/primitive/gs.cpp
@@ -45,6 +46,7 @@ conquer3d/csrc/data_structure/mesh_bvh.h
 conquer3d/csrc/data_structure/pgs_bvh.h
 conquer3d/csrc/data_structure/triangle_mesh.cu
 conquer3d/csrc/data_structure/triangle_mesh.h
+conquer3d/csrc/data_structure/zcurve.cu
 conquer3d/csrc/data_structure/zcurve.h
 conquer3d/csrc/maths/f2x2.h
 conquer3d/csrc/maths/f3x1.h
@@ -88,6 +90,7 @@ conquer3d/data/transform/vertex.py
 conquer3d/data_structure/__init__.py
 conquer3d/data_structure/bmesh.py
 conquer3d/data_structure/grid.py
+conquer3d/data_structure/sort.py
 conquer3d/io/__init__.py
 conquer3d/io/obj.py
 conquer3d/io/off.py

{conquer3d-0.3.4 → conquer3d-0.3.9}/conquer3d.egg-info/requires.txt

@@ -1,4 +1,5 @@
 torch>=2.0.0
+meshio>=5.3.5
 gdown
 
 [cuda]

{conquer3d-0.3.4 → conquer3d-0.3.9}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "conquer3d"
-version = "0.3.4"
+version = "0.3.9"
 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",
+    "meshio>=5.3.5",
     "gdown",
 ]
 

conquer3d-0.3.4/conquer3d/io/obj.py

@@ -1,46 +0,0 @@
-import torch
-
-def read_obj(file_obj):
-    """
-    Reads an OBJ file and returns vertices, faces, and optional vertex colors.
-    
-    Args:
-        file_obj: A file-like object or a string path.
-    """
-    vertices = []
-    faces = []
-    colors = []
-    
-    close_file = False
-    if isinstance(file_obj, str):
-        file_obj = open(file_obj, 'r', encoding='utf-8')
-        close_file = True
-
-    try:
-        for line in file_obj:
-            if isinstance(line, bytes):
-                line = line.decode('utf-8', errors='ignore')
-            line = line.strip()
-            if line.startswith('v '):
-                parts = line.split()
-                vertices.append([float(parts[1]), float(parts[2]), float(parts[3])])
-                if len(parts) >= 7:
-                    colors.append([float(parts[4]), float(parts[5]), float(parts[6])])
-            elif line.startswith('f '):
-                parts = line.split()
-                # Face elements can be v, v/vt, or v/vt/vn. We just want the first index (v).
-                face = [int(p.split('/')[0]) - 1 for p in parts[1:4]]
-                faces.append(face)
-    finally:
-        if close_file:
-            file_obj.close()
-            
-    vertices = torch.tensor(vertices, dtype=torch.float32)
-    faces = torch.tensor(faces, dtype=torch.long)
-    
-    if len(colors) == len(vertices):
-        colors = torch.tensor(colors, dtype=torch.float32)
-    else:
-        colors = None
-        
-    return vertices, faces, colors

conquer3d-0.3.4/conquer3d/io/off.py

@@ -1,84 +0,0 @@
-import torch
-import numpy as np
-import io
-
-def read_off(filepath_or_filelike):
-    """
-    Read an OFF (Object File Format) file and return vertices and faces as PyTorch tensors.
-    Supports reading from a file path or a file-like object.
-    
-    Args:
-        filepath_or_filelike: A string path or a file-like object.
-        
-    Returns:
-        tuple: (vertices, faces) as torch.Tensor
-    """
-    if isinstance(filepath_or_filelike, str):
-        with open(filepath_or_filelike, "r") as f:
-            lines = f.readlines()
-    else:
-        # Assuming text-based or bytes file-like object
-        lines = filepath_or_filelike.readlines()
-        if len(lines) > 0 and isinstance(lines[0], bytes):
-            lines = [line.decode('utf-8') for line in lines]
-
-    # Clean up empty lines and comments
-    lines = [line.strip() for line in lines if line.strip() and not line.startswith('#')]
-    
-    if not lines:
-        raise ValueError("Empty OFF file.")
-
-    first_line = lines[0].strip()
-    if first_line.upper().startswith("OFF"):
-        if len(first_line) > 3:
-            # Format: 'OFF 123 456 0'
-            parts = first_line[3:].strip().split()
-            # If the rest of the line doesn't contain counts, maybe they are on the next line
-            if parts:
-                lines = [parts] + lines[1:]
-            else:
-                lines = lines[1:]
-        else:
-            lines = lines[1:]
-            
-    # If the format parsing above resulted in a list of parts at index 0, handle it
-    if isinstance(lines[0], list):
-        counts = lines[0]
-    else:
-        counts = lines[0].split()
-        
-    num_verts, num_faces, num_edges = map(int, counts[:3])
-    
-    # Fast parsing with numpy
-    verts_lines = lines[1:num_verts + 1]
-    verts_str = '\n'.join(verts_lines)
-    verts = np.fromstring(verts_str, sep=' ').reshape(num_verts, -1)[:, :3]
-    
-    faces_lines = lines[num_verts + 1 : num_verts + 1 + num_faces]
-    faces_str = '\n'.join(faces_lines)
-    
-    # In an OFF file, face lines look like: `3 v1 v2 v3` for triangles.
-    # We parse the flat array and reshape based on the number of elements per line
-    faces_raw = np.fromstring(faces_str, sep=' ', dtype=int)
-    
-    # We assume all faces are triangles! 
-    # The first element of each chunk will be 3, followed by 3 indices.
-    # Total length should be num_faces * 4
-    if len(faces_raw) == num_faces * 4:
-        faces = faces_raw.reshape(num_faces, 4)[:, 1:4]
-    else:
-        # If faces are mixed (e.g. some quads), we fall back to a slower parsing
-        faces_list = []
-        idx = 0
-        for _ in range(num_faces):
-            n_v = faces_raw[idx]
-            if n_v == 3:
-                faces_list.append([faces_raw[idx+1], faces_raw[idx+2], faces_raw[idx+3]])
-            else:
-                # Naive triangulation for ngons (fan triangulation)
-                for i in range(1, n_v - 1):
-                    faces_list.append([faces_raw[idx+1], faces_raw[idx+i+1], faces_raw[idx+i+2]])
-            idx += n_v + 1
-        faces = np.array(faces_list, dtype=int)
-        
-    return torch.from_numpy(verts).float(), torch.from_numpy(faces).long()

conquer3d-0.3.4/conquer3d/ops/__init__.py

@@ -1,10 +0,0 @@
-from .marching_cubes import marching_cubes
-from .diff_marching_cubes import diff_marching_cubes
-from .distance import one_sided_chamfer_distance, chamfer_distance
-
-__all__ = [
-    "marching_cubes",
-    "diff_marching_cubes",
-    "one_sided_chamfer_distance",
-    "chamfer_distance"
-]