conquer3d 0.3.3__tar.gz → 0.3.4__tar.gz

conquer3d-0.3.4/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include conquer3d/csrc *.h *.cuh *.cpp *.cu

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conquer3d
-Version: 0.3.3
+Version: 0.3.4
 Summary: Geometric Cuda Tool Box
 Author-email: Do Hoang Khoi <khoido8899@gmail.com>
 License-Expression: MIT
@@ -77,6 +77,9 @@ twine upload dist/* --verbose
 
 # Reference
 
+## Book
+
+
 ## Research Paper
 ```bibtex
 @inproceedings{2383795.2383801,
@@ -133,19 +136,19 @@ twine upload dist/* --verbose
 
 ```bibtex
 @InProceedings{10.1007/978-3-662-05105-4_2,
-author="Meyer, Mark
-and Desbrun, Mathieu
-and Schr{\"o}der, Peter
-and Barr, Alan H.",
-editor="Hege, Hans-Christian
-and Polthier, Konrad",
-title="Discrete Differential-Geometry Operators for Triangulated 2-Manifolds",
-booktitle="Visualization and Mathematics III",
-year="2003",
-publisher="Springer Berlin Heidelberg",
-address="Berlin, Heidelberg",
-pages="35--57",
-isbn="978-3-662-05105-4"
+    author="Meyer, Mark
+    and Desbrun, Mathieu
+    and Schr{\"o}der, Peter
+    and Barr, Alan H.",
+    editor="Hege, Hans-Christian
+    and Polthier, Konrad",
+    title="Discrete Differential-Geometry Operators for Triangulated 2-Manifolds",
+    booktitle="Visualization and Mathematics III",
+    year="2003",
+    publisher="Springer Berlin Heidelberg",
+    address="Berlin, Heidelberg",
+    pages="35--57",
+    isbn="978-3-662-05105-4"
 }
 ```
 
@@ -161,3 +164,4 @@ isbn="978-3-662-05105-4"
 - [Pytorch3D](https://github.com/facebookresearch/pytorch3d)
 - [Open3D](https://www.open3d.org/)
 - [trimesh](https://github.com/mikedh/trimesh)
+- [TetWeave](https://github.com/AlexandreBinninger/TetWeave/tree/main)

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

@@ -48,6 +48,9 @@ twine upload dist/* --verbose
 
 # Reference
 
+## Book
+
+
 ## Research Paper
 ```bibtex
 @inproceedings{2383795.2383801,
@@ -104,19 +107,19 @@ twine upload dist/* --verbose
 
 ```bibtex
 @InProceedings{10.1007/978-3-662-05105-4_2,
-author="Meyer, Mark
-and Desbrun, Mathieu
-and Schr{\"o}der, Peter
-and Barr, Alan H.",
-editor="Hege, Hans-Christian
-and Polthier, Konrad",
-title="Discrete Differential-Geometry Operators for Triangulated 2-Manifolds",
-booktitle="Visualization and Mathematics III",
-year="2003",
-publisher="Springer Berlin Heidelberg",
-address="Berlin, Heidelberg",
-pages="35--57",
-isbn="978-3-662-05105-4"
+    author="Meyer, Mark
+    and Desbrun, Mathieu
+    and Schr{\"o}der, Peter
+    and Barr, Alan H.",
+    editor="Hege, Hans-Christian
+    and Polthier, Konrad",
+    title="Discrete Differential-Geometry Operators for Triangulated 2-Manifolds",
+    booktitle="Visualization and Mathematics III",
+    year="2003",
+    publisher="Springer Berlin Heidelberg",
+    address="Berlin, Heidelberg",
+    pages="35--57",
+    isbn="978-3-662-05105-4"
 }
 ```
 
@@ -131,4 +134,5 @@ isbn="978-3-662-05105-4"
 - [Kaolin](https://github.com/NVIDIAGameWorks/kaolin)
 - [Pytorch3D](https://github.com/facebookresearch/pytorch3d)
 - [Open3D](https://www.open3d.org/)
-- [trimesh](https://github.com/mikedh/trimesh)
+- [trimesh](https://github.com/mikedh/trimesh)
+- [TetWeave](https://github.com/AlexandreBinninger/TetWeave/tree/main)

{conquer3d-0.3.3 → conquer3d-0.3.4}/conquer3d/csrc/ops/mc.cu

@@ -583,11 +583,9 @@ namespace mc
 
         float3 grad_p_out = adj_verts[v_idx];
 
-        float3 c0, c1, grad_c_out;
+        float3 grad_c_out;
         if (with_colors)
         {
-            c0 = grid_colors[v0_idx];
-            c1 = grid_colors[v1_idx];
             grad_c_out = adj_colors[v_idx];
         }
 
@@ -608,19 +606,14 @@ namespace mc
             float t0 = 1.0f - t;
             float t1 = t;
             
-            atomicAdd(&(adj_grid_colors[v0_idx].x), grad_c_out.x * t0);
-            atomicAdd(&(adj_grid_colors[v0_idx].y), grad_c_out.y * t0);
-            atomicAdd(&(adj_grid_colors[v0_idx].z), grad_c_out.z * t0);
-
-            atomicAdd(&(adj_grid_colors[v1_idx].x), grad_c_out.x * t1);
-            atomicAdd(&(adj_grid_colors[v1_idx].y), grad_c_out.y * t1);
-            atomicAdd(&(adj_grid_colors[v1_idx].z), grad_c_out.z * t1);
+            atomicAdd(&(adj_grid_colors[v0_idx]), grad_c_out * t0);
+            atomicAdd(&(adj_grid_colors[v1_idx]), grad_c_out * t1);
         }
 
         if (diff * diff < 1e-14f)
             return;
             
-        float dot_prod = (p1.x - p0.x) * grad_p_out.x + (p1.y - p0.y) * grad_p_out.y + (p1.z - p0.z) * grad_p_out.z;
+        float dot_prod = maths::dot(p1 - p0, grad_p_out);
         float common = dot_prod / (diff * diff);
         float grad_v0 = common * (iso - v1_val);
         float grad_v1 = common * (v0_val - iso);

{conquer3d-0.3.3 → conquer3d-0.3.4}/conquer3d/csrc/ops/mc.h

@@ -3,6 +3,7 @@
 
 #include <torch/extension.h>
 #include "mc_data.h"
+#include "../maths/maths.h"
 #include "../check.h"
 #include "../constants.h"
 #include "../primitive/edge.h"

conquer3d-0.3.4/conquer3d/data/assets/common.py

@@ -0,0 +1,132 @@
+import os
+import urllib.request
+import torch
+from conquer3d.io.obj import read_obj
+
+class Common3D:
+    """
+    Base class for models from the common-3d-test-models repository.
+    Downloads the specific .obj model directly via the Raw GitHub URL
+    and loads its vertices, faces, and optional colors.
+    """
+    def __init__(self, filename, download_dir="~/.conquer3d"):
+        self.filename = filename
+        self.url = f"https://raw.githubusercontent.com/KhoiDOO/common-3d-test-models/master/data/{self.filename}"
+        self.download_dir = os.path.expanduser(download_dir)
+        self.vertices = None
+        self.faces = None
+        self.colors = None
+        
+        self._load()
+
+    def _load(self):
+        os.makedirs(self.download_dir, exist_ok=True)
+        obj_path = os.path.join(self.download_dir, self.filename)
+        
+        if not os.path.exists(obj_path):
+            print(f"Downloading {self.filename} from {self.url}...")
+            req = urllib.request.Request(self.url, headers={'User-Agent': 'Mozilla/5.0'})
+            with urllib.request.urlopen(req) as response, open(obj_path, 'wb') as out_file:
+                out_file.write(response.read())
+            print("Download complete.")
+            
+        print(f"Reading {self.filename}...")
+        self.vertices, self.faces, self.colors = read_obj(obj_path)
+
+# --- Child Classes ---
+
+class Alligator(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("alligator.obj", download_dir)
+
+class Armadillo(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("armadillo.obj", download_dir)
+
+class Beast(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("beast.obj", download_dir)
+
+class BeetleAlt(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("beetle-alt.obj", download_dir)
+
+class Beetle(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("beetle.obj", download_dir)
+
+class Bimba(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("bimba.obj", download_dir)
+
+class Cheburashka(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("cheburashka.obj", download_dir)
+
+class Cow(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("cow.obj", download_dir)
+
+class Fandisk(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("fandisk.obj", download_dir)
+
+class HappyBuddha(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("happy.obj", download_dir)
+
+class Homer(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("homer.obj", download_dir)
+
+class Horse(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("horse.obj", download_dir)
+
+class Igea(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("igea.obj", download_dir)
+
+class Lucy(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("lucy.obj", download_dir)
+
+class MaxPlanck(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("max-planck.obj", download_dir)
+
+class Nefertiti(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("nefertiti.obj", download_dir)
+
+class Ogre(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("ogre.obj", download_dir)
+
+class RockerArm(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("rocker-arm.obj", download_dir)
+
+class Spot(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("spot.obj", download_dir)
+
+class StanfordBunny(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("stanford-bunny.obj", download_dir)
+
+class Suzanne(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("suzanne.obj", download_dir)
+
+class Teapot(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("teapot.obj", download_dir)
+
+class Woody(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("woody.obj", download_dir)
+
+class XYZRGBDragon(Common3D):
+    def __init__(self, download_dir="~/.conquer3d"):
+        super().__init__("xyzrgb_dragon.obj", download_dir)

conquer3d-0.3.4/conquer3d/data/assets/iphigenia.py

@@ -0,0 +1,43 @@
+import os
+import urllib.request
+import zipfile
+import torch
+from conquer3d.io.off import read_off
+
+class Iphiagenia:
+    """
+    Iphigenia asset mesh from pmp-book.org.
+    Downloads the full resolution Iphigenia mesh (zip), extracts the .off file,
+    and loads the vertices and faces into PyTorch tensors.
+    """
+    def __init__(self, download_dir="~/.conquer3d"):
+        self.url = "https://www.pmp-book.org/download/meshes/iphi_fullres.zip"
+        self.download_dir = os.path.expanduser(download_dir)
+        self.vertices = None
+        self.faces = None
+        
+        self._load()
+
+    def _load(self):
+        os.makedirs(self.download_dir, exist_ok=True)
+        zip_path = os.path.join(self.download_dir, "iphi_fullres.zip")
+        
+        if not os.path.exists(zip_path):
+            print(f"Downloading Iphigenia mesh from {self.url}...")
+            # We use a Request with a User-Agent to easily bypass basic checks
+            req = urllib.request.Request(self.url, headers={'User-Agent': 'Mozilla/5.0'})
+            with urllib.request.urlopen(req) as response, open(zip_path, 'wb') as out_file:
+                out_file.write(response.read())
+            print("Download complete.")
+            
+        print("Extracting and reading OFF file...")
+        with zipfile.ZipFile(zip_path, 'r') as z:
+            # Find the .off file in the zip
+            off_filename = next((name for name in z.namelist() if name.lower().endswith('.off')), None)
+            if not off_filename:
+                raise FileNotFoundError("Could not find an .off file in the downloaded zip.")
+                
+            with z.open(off_filename, 'r') as off_file:
+                # 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)

conquer3d-0.3.4/conquer3d/io/obj.py

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

@@ -0,0 +1,84 @@
+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/delaunay_triangulation.py

@@ -0,0 +1,71 @@
+import torch
+import numpy as np
+import tetgen
+
+def find_near_duplicates_sort(points, epsilon=1e-7):
+    """
+    Approximate detection of near-duplicate points in a point cloud using sorting.
+    
+    Args:
+    - points: Tensor of shape (N, 3), where N is the number of points.
+    - epsilon: Distance threshold for considering points as duplicates.
+    
+    Returns:
+    - duplicate_indices: A tensor of shape (M,) where M is the number of points who have a near-duplicate.
+    """
+    sorted_indices = torch.argsort(points[:, 0]) 
+    points_sorted = points[sorted_indices]
+    
+    diffs = points_sorted[1:] - points_sorted[:-1] 
+    distances = torch.norm(diffs, dim=-1)
+
+    close_mask = distances < epsilon
+    duplicate_indices_1, duplicate_indices_2 = sorted_indices[:-1][close_mask], sorted_indices[1:][close_mask]
+    duplicate_indices = torch.cat((duplicate_indices_1, duplicate_indices_2))
+    return duplicate_indices
+
+def tet_is_inside_oriented(vertices, tets):
+    """
+    Check if the tetrahedra are oriented correctly, i.e. if the normals of the faces point outwards. 
+    This is tested by checking if the dot product of the normals and the vector from the barycenter of the tetrahedron to the barycenter of the face is negative.
+    """
+    faces = torch.tensor([[0, 2, 1], [0, 1, 3], [0, 3, 2], [1, 2, 3]], dtype=torch.long)
+    tets_combinations = tets[:, faces]
+    normals_per_tets = torch.cross(vertices[tets_combinations[:, :, 1]] - vertices[tets_combinations[:, :, 0]], vertices[tets_combinations[:, :, 2]] - vertices[tets_combinations[:, :, 0]], dim=2)
+    tet_barycenter = vertices[tets].mean(dim=1)
+    faces_barycenter = vertices[tets_combinations].mean(dim=2)
+    faces_b_to_tet_b = faces_barycenter - tet_barycenter.unsqueeze(1)
+    dot = torch.sum(normals_per_tets * faces_b_to_tet_b, dim=2)
+    return dot < 0
+
+def reorient_tetrahedra(vertices, tets):
+    inside_oriented_triangles = tet_is_inside_oriented(vertices, tets)
+    to_flip = inside_oriented_triangles.all(dim=1)
+    tets[to_flip] = tets[to_flip][:, [0, 2, 1, 3]]
+    return tets
+
+import scipy.spatial
+
+@torch.no_grad()
+def delaunay_simplices_tetgen(points):
+    # PyVista's tetgen wrapper raises RuntimeError on point clouds without faces.
+    # We natively use scipy's Delaunay which perfectly tetrahedralizes 3D point clouds.
+    delaunay = scipy.spatial.Delaunay(points.detach().cpu().numpy())
+    return torch.tensor(delaunay.simplices.astype(np.int64), device=points.device)
+
+def tetrahedralize(points):
+    duplicates = find_near_duplicates_sort(points)
+    if duplicates.shape[0] > 0:
+        with torch.no_grad():
+            points[duplicates] += torch.randn_like(points[duplicates]) * 1e-6
+    tetrahedra = delaunay_simplices_tetgen(points)
+    tetrahedra = reorient_tetrahedra(points, tetrahedra)
+    return tetrahedra
+
+def get_edges(tetrahedra):
+    tet_edges = torch.tensor([
+        [0, 1], [0, 2], [0, 3],
+        [1, 2], [1, 3], [2, 3]
+    ], device=tetrahedra.device)
+    edges = tetrahedra[:, tet_edges]
+    return edges

conquer3d-0.3.4/conquer3d/ops/marching_tetrahedra.py

@@ -0,0 +1,125 @@
+import torch
+
+triangle_table = torch.tensor([
+    [-1, -1, -1, -1, -1, -1],
+    [1, 0, 2, -1, -1, -1],
+    [4, 0, 3, -1, -1, -1],
+    [1, 4, 2, 1, 3, 4],
+    [3, 1, 5, -1, -1, -1],
+    [2, 3, 0, 2, 5, 3],
+    [1, 4, 0, 1, 5, 4],
+    [4, 2, 5, -1, -1, -1],
+    [4, 5, 2, -1, -1, -1],
+    [4, 1, 0, 4, 5, 1],
+    [3, 2, 0, 3, 5, 2],
+    [1, 3, 5, -1, -1, -1],
+    [4, 1, 2, 4, 3, 1],
+    [3, 0, 4, -1, -1, -1],
+    [2, 0, 1, -1, -1, -1],
+    [-1, -1, -1, -1, -1, -1]
+], dtype=torch.long)
+
+num_triangles_table = torch.tensor([0, 1, 1, 2, 1, 2, 2, 1, 1, 2, 2, 1, 2, 1, 1, 0], dtype=torch.long)
+base_tet_edges = torch.tensor([0, 1, 0, 2, 0, 3, 1, 2, 1, 3, 2, 3], dtype=torch.long)
+v_id = torch.pow(2, torch.arange(4, dtype=torch.long))
+
+def _sort_edges(edges):
+    """sort last dimension of edges of shape (E, 2)"""
+    with torch.no_grad():
+        order = (edges[:, 0] > edges[:, 1]).long()
+        order = order.unsqueeze(dim=1)
+
+        a = torch.gather(input=edges, index=order, dim=1)
+        b = torch.gather(input=edges, index=1 - order, dim=1)
+
+    return torch.stack([a, b], -1)
+
+def marching_tetrahedra(vertices, tets, sdfs, colors=None, return_tet_idx=False):
+    """
+    Extracts a triangulated isosurface from a tetrahedral grid using the Marching Tetrahedra algorithm.
+    
+    This is a pure-PyTorch, fully vectorized implementation that is mathematically differentiable.
+    It identifies tetrahedra that intersect the zero-isosurface, finds the exact intersection points 
+    on the edges using linear interpolation based on SDF values, and generates the resulting triangles.
+    
+    Args:
+        vertices (torch.Tensor): A tensor of shape (N, 3) containing the 3D coordinates of the grid vertices.
+        tets (torch.Tensor): A tensor of shape (T, 4) containing the vertex indices for each tetrahedron.
+        sdfs (torch.Tensor): A tensor of shape (N,) containing the Signed Distance Field values at each vertex.
+        colors (torch.Tensor, optional): A tensor of shape (N, C) containing color or feature values at each vertex. 
+            If provided, these features are linearly interpolated to the isosurface exactly like the geometry. 
+            Defaults to None.
+        return_tet_idx (bool, optional): If True, also returns the indices of the tetrahedra that produced 
+            each generated face. Defaults to False.
+
+    Returns:
+        tuple: 
+            - verts (torch.Tensor): The extracted surface vertices of shape (V, 3). If `colors` was provided, 
+              the shape will be (V, 3 + C) where the interpolated colors are concatenated to the coordinates.
+            - faces (torch.Tensor): The triangular faces of the extracted surface of shape (F, 3).
+            - tet_idx (torch.Tensor, optional): The original tetrahedron index corresponding to each face.
+              Returned only if `return_tet_idx` is True.
+    """
+    device = vertices.device
+    with torch.no_grad():
+        occ_n = sdfs > 0
+        occ_fx4 = occ_n[tets.reshape(-1)].reshape(-1, 4)
+        occ_sum = torch.sum(occ_fx4, -1)
+        valid_tets = (occ_sum > 0) & (occ_sum < 4)
+        occ_sum = occ_sum[valid_tets]
+
+        # find all vertices
+        all_edges = tets[valid_tets][:, base_tet_edges.to(device)].reshape(-1, 2)
+        all_edges = _sort_edges(all_edges)
+        unique_edges, idx_map = torch.unique(all_edges, dim=0, return_inverse=True)
+
+        unique_edges = unique_edges.long()
+        mask_edges = occ_n[unique_edges.reshape(-1)].reshape(-1, 2).sum(-1) == 1
+        mapping = torch.ones((unique_edges.shape[0]), dtype=torch.long, device=device) * -1
+        mapping[mask_edges] = torch.arange(mask_edges.sum(), dtype=torch.long, device=device)
+        idx_map = mapping[idx_map]
+
+        interp_v = unique_edges[mask_edges].reshape(-1)
+
+    edges_to_interp = torch.index_select(vertices, 0, interp_v).reshape(-1, 2, 3)
+    edges_to_interp_sdfs = torch.index_select(sdfs, 0, interp_v).reshape(-1, 2, 1)
+
+    edges_to_interp0, edges_to_interp1 = edges_to_interp.unbind(dim=1)
+
+    edges_to_interp_sdfs0, edges_to_interp_sdfs1 = edges_to_interp_sdfs.unbind(dim=1)
+    edges_to_interp_sdfs1 = -edges_to_interp_sdfs1
+
+    verts = (edges_to_interp0 * edges_to_interp_sdfs1 + edges_to_interp1 * edges_to_interp_sdfs0)
+    verts = verts / (edges_to_interp_sdfs0 + edges_to_interp_sdfs1)
+    
+    if colors is not None:
+        edges_to_interp_colors = torch.index_select(colors, 0, interp_v).reshape(-1, 2, colors.shape[-1])
+        edges_to_interp_colors0, edges_to_interp_colors1 = edges_to_interp_colors.unbind(dim=1)
+        verts_colors = (edges_to_interp_colors0 * edges_to_interp_sdfs1 + edges_to_interp_colors1 * edges_to_interp_sdfs0)
+        verts_colors = verts_colors / (edges_to_interp_sdfs0 + edges_to_interp_sdfs1)
+
+    idx_map = idx_map.reshape(-1, 6)
+
+    tetindex = (occ_fx4[valid_tets] * v_id.to(device).unsqueeze(0)).sum(-1)
+    num_triangles = num_triangles_table.to(device)[tetindex]
+    triangle_table_device = triangle_table.to(device)
+
+    # Generate triangle indices
+    faces = torch.cat((
+        torch.gather(input=idx_map[num_triangles == 1], dim=1,
+                     index=triangle_table_device[tetindex[num_triangles == 1]][:, :3]).reshape(-1, 3),
+        torch.gather(input=idx_map[num_triangles == 2], dim=1,
+                     index=triangle_table_device[tetindex[num_triangles == 2]][:, :6]).reshape(-1, 3),
+    ), dim=0)
+
+    if return_tet_idx:
+        tet_idx = torch.arange(tets.shape[0], device=device)[valid_tets]
+        tet_idx = torch.cat((tet_idx[num_triangles == 1], tet_idx[num_triangles ==
+                            2].unsqueeze(-1).expand(-1, 2).reshape(-1)), dim=0)
+        if colors is not None:
+            return verts, faces, tet_idx, verts_colors
+        return verts, faces, tet_idx
+        
+    if colors is not None:
+        return verts, faces, verts_colors
+    return verts, faces

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conquer3d
-Version: 0.3.3
+Version: 0.3.4
 Summary: Geometric Cuda Tool Box
 Author-email: Do Hoang Khoi <khoido8899@gmail.com>
 License-Expression: MIT
@@ -77,6 +77,9 @@ twine upload dist/* --verbose
 
 # Reference
 
+## Book
+
+
 ## Research Paper
 ```bibtex
 @inproceedings{2383795.2383801,
@@ -133,19 +136,19 @@ twine upload dist/* --verbose
 
 ```bibtex
 @InProceedings{10.1007/978-3-662-05105-4_2,
-author="Meyer, Mark
-and Desbrun, Mathieu
-and Schr{\"o}der, Peter
-and Barr, Alan H.",
-editor="Hege, Hans-Christian
-and Polthier, Konrad",
-title="Discrete Differential-Geometry Operators for Triangulated 2-Manifolds",
-booktitle="Visualization and Mathematics III",
-year="2003",
-publisher="Springer Berlin Heidelberg",
-address="Berlin, Heidelberg",
-pages="35--57",
-isbn="978-3-662-05105-4"
+    author="Meyer, Mark
+    and Desbrun, Mathieu
+    and Schr{\"o}der, Peter
+    and Barr, Alan H.",
+    editor="Hege, Hans-Christian
+    and Polthier, Konrad",
+    title="Discrete Differential-Geometry Operators for Triangulated 2-Manifolds",
+    booktitle="Visualization and Mathematics III",
+    year="2003",
+    publisher="Springer Berlin Heidelberg",
+    address="Berlin, Heidelberg",
+    pages="35--57",
+    isbn="978-3-662-05105-4"
 }
 ```
 
@@ -161,3 +164,4 @@ isbn="978-3-662-05105-4"
 - [Pytorch3D](https://github.com/facebookresearch/pytorch3d)
 - [Open3D](https://www.open3d.org/)
 - [trimesh](https://github.com/mikedh/trimesh)
+- [TetWeave](https://github.com/AlexandreBinninger/TetWeave/tree/main)

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

@@ -72,6 +72,9 @@ conquer3d/csrc/primitive/pgs_math.cuh
 conquer3d/csrc/primitive/ray.h
 conquer3d/csrc/primitive/triangle.h
 conquer3d/data/__init__.py
+conquer3d/data/assets/__init__.py
+conquer3d/data/assets/common.py
+conquer3d/data/assets/iphigenia.py
 conquer3d/data/collate/__init__.py
 conquer3d/data/collate/mesh.py
 conquer3d/data/collate/sparse_tensor.py
@@ -85,10 +88,15 @@ conquer3d/data/transform/vertex.py
 conquer3d/data_structure/__init__.py
 conquer3d/data_structure/bmesh.py
 conquer3d/data_structure/grid.py
+conquer3d/io/__init__.py
+conquer3d/io/obj.py
+conquer3d/io/off.py
 conquer3d/ops/__init__.py
+conquer3d/ops/delaunay_triangulation.py
 conquer3d/ops/diff_marching_cubes.py
 conquer3d/ops/distance.py
 conquer3d/ops/marching_cubes.py
+conquer3d/ops/marching_tetrahedra.py
 conquer3d/primitive/__init__.py
 conquer3d/primitive/gs.py
 conquer3d/primitive/pgs.py

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

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

{conquer3d-0.3.3 → conquer3d-0.3.4}/setup.py

@@ -57,6 +57,10 @@ def get_extensions():
             # nvcc_flags += ['-DTORCH_INDUCTOR_CPP_WRAPPER']
         else:
             nvcc_flags = nvcc_flags.split(" ")
+        
+        # Suppress harmless nvcc warnings (like conda's compiler-bindir redefinition)
+        nvcc_flags.append("-w")
+        
         extra_compile_args = {
             "cxx": ["-O3", "-Wno-attributes"],
             "nvcc": nvcc_flags,

conquer3d-0.3.3/MANIFEST.in

@@ -1 +0,0 @@
-recursive-include conquer3d/csrc *.h *.hpp *.cuh *.cpp *.cu