test: add tests for cotmatrix, grad, simplify, cut_mesh, face_components

Author: jf---

tests/test_cotmatrix.py

@@ -0,0 +1,23 @@
+import compas
+from compas_libigl.cotmatrix import trimesh_cotmatrix, trimesh_cotmatrix_entries
+from compas.datastructures import Mesh
+
+
+def test_trimesh_cotmatrix():
+    mesh = Mesh.from_off(compas.get("tubemesh.off"))
+    mesh.quads_to_triangles()
+    M = mesh.to_vertices_and_faces()
+    L = trimesh_cotmatrix(M)
+    # Cotmatrix is V x V sparse matrix
+    assert L.shape[0] == mesh.number_of_vertices()
+    assert L.shape[1] == mesh.number_of_vertices()
+
+
+def test_trimesh_cotmatrix_entries():
+    mesh = Mesh.from_off(compas.get("tubemesh.off"))
+    mesh.quads_to_triangles()
+    M = mesh.to_vertices_and_faces()
+    C = trimesh_cotmatrix_entries(M)
+    # Cotmatrix entries is F x 3 (one cotan per edge per face)
+    assert C.shape[0] == mesh.number_of_faces()
+    assert C.shape[1] == 3

tests/test_grad.py

@@ -0,0 +1,14 @@
+import compas
+from compas_libigl.grad import trimesh_grad
+from compas.datastructures import Mesh
+
+
+def test_trimesh_grad():
+    mesh = Mesh.from_off(compas.get("tubemesh.off"))
+    mesh.quads_to_triangles()
+    M = mesh.to_vertices_and_faces()
+    G = trimesh_grad(M)
+    # Gradient operator is (3*F) x V sparse matrix
+    # When multiplied by V-length scalar field, produces 3F gradient components
+    assert G.shape[0] == 3 * mesh.number_of_faces()
+    assert G.shape[1] == mesh.number_of_vertices()

tests/test_meshing.py

@@ -1,5 +1,10 @@
 import compas
-from compas_libigl.meshing import trimesh_remesh_along_isoline, trimesh_remesh_along_isolines
+from compas_libigl.meshing import (
+    trimesh_remesh_along_isoline,
+    trimesh_remesh_along_isolines,
+    trimesh_cut_mesh,
+    trimesh_face_components,
+)
 from compas.datastructures import Mesh
 
 
@@ -29,3 +34,27 @@ def test_trimesh_remesh_along_isolines():
     assert len(F2) > 0
     assert len(S2) == len(V2)
     assert len(G2) == len(F2)
+
+
+def test_trimesh_cut_mesh():
+    mesh = Mesh.from_off(compas.get("tubemesh.off"))
+    mesh.quads_to_triangles()
+    M = mesh.to_vertices_and_faces()
+    V, F = M
+    # Create cut flags: all ones means cut all edges
+    cuts = [[1, 1, 1] for _ in F]
+    Vn, Fn = trimesh_cut_mesh(M, cuts)
+    # After cutting all edges, we should have more vertices
+    assert len(Vn) >= len(V)
+    assert len(Fn) == len(F)
+
+
+def test_trimesh_face_components():
+    mesh = Mesh.from_off(compas.get("tubemesh.off"))
+    mesh.quads_to_triangles()
+    M = mesh.to_vertices_and_faces()
+    C = trimesh_face_components(M)
+    # Component IDs, one per face
+    assert len(C) == mesh.number_of_faces()
+    # Connected mesh should have single component (component 0)
+    assert max(C) == 0

tests/test_simplify.py

@@ -0,0 +1,34 @@
+from compas_libigl.simplify import ramer_douglas_peucker
+
+
+def test_ramer_douglas_peucker():
+    # Simple polyline: a zigzag that can be simplified
+    points = [
+        [0.0, 0.0, 0.0],
+        [1.0, 0.1, 0.0],  # slightly off the line
+        [2.0, 0.0, 0.0],
+        [3.0, 0.05, 0.0],  # slightly off the line
+        [4.0, 0.0, 0.0],
+    ]
+    # With high threshold, should simplify to just endpoints
+    S, J, Q = ramer_douglas_peucker(points, threshold=0.5)
+    assert len(S) <= len(points)
+    assert len(S) >= 2  # At least start and end points
+    # With zero threshold, should keep all points
+    S2, J2, Q2 = ramer_douglas_peucker(points, threshold=0.0)
+    assert len(S2) == len(points)
+
+
+def test_ramer_douglas_peucker_straight_line():
+    # Perfectly straight line should simplify to 2 points
+    points = [
+        [0.0, 0.0, 0.0],
+        [1.0, 0.0, 0.0],
+        [2.0, 0.0, 0.0],
+        [3.0, 0.0, 0.0],
+        [4.0, 0.0, 0.0],
+    ]
+    S, J, Q = ramer_douglas_peucker(points, threshold=0.01)
+    assert len(S) == 2
+    assert S[0] == [0.0, 0.0, 0.0]
+    assert S[1] == [4.0, 0.0, 0.0]