Fix align libigl barycentrioc coordinates to compas.

Author: pv

CHANGELOG.md

@@ -12,6 +12,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 * Fixed `compas_libigl` plugins are not detected.
+* Align barycentric coordinates of libigl to COMPAS.
 
 ### Removed
 

docs/examples/example_intersections.py

@@ -7,6 +7,7 @@
 from compas_viewer import Viewer
 
 from compas_libigl.intersections import intersection_rays_mesh
+from compas_libigl.intersections import barycenter_to_point
 
 # ==============================================================================
 # Input geometry
@@ -56,11 +57,12 @@
 intersections = []
 for ray, hits in zip(rays, hits_per_ray):
     if hits:
-        base, vector = ray
-        index = hits[0][0]
-        distance = hits[0][3]
-        face = index_face[index]
-        point = base + vector * distance
+        idx, u, v, w = hits[0]
+        vertices = mesh.face_vertices(idx)
+        p1 = mesh.vertex_coordinates(vertices[0])
+        p2 = mesh.vertex_coordinates(vertices[1])
+        p3 = mesh.vertex_coordinates(vertices[2])
+        point = barycenter_to_point(u, v, w, p1, p2, p3)
         intersections.append(point)
 
 # ==============================================================================

docs/examples/example_intersections_barycentric.py

@@ -0,0 +1,46 @@
+import compas.geometry
+import compas.datastructures
+from compas_libigl.intersections import intersection_rays_mesh, intersection_ray_mesh
+from compas_libigl.intersections import barycenter_to_point
+from compas_viewer import Viewer
+from compas.colors import Color
+from compas.geometry import Line
+import compas
+
+
+p0 = compas.geometry.Point(2, 0, 0)
+p1 = compas.geometry.Point(3 + 2, 0 - 2, 13)
+p2 = compas.geometry.Point(0 - 2, 0 - 2, 10)
+p3 = compas.geometry.Point(0 - 2, 2 + 2, 10)
+
+mesh = compas.datastructures.Mesh.from_points([[p1.x, p1.y, p1.z], [p2.x, p2.y, p2.z], [p3.x, p3.y, p3.z]])
+
+ray = (p0, compas.geometry.Vector(0, 0, 1))
+hits_per_ray = intersection_ray_mesh(ray, mesh.to_vertices_and_faces())
+
+idx, u, v, w = hits_per_ray[0][0], hits_per_ray[0][1], hits_per_ray[0][2], hits_per_ray[0][3]
+
+index_face = {index: face for index, face in enumerate(mesh.faces())}
+
+intersections = []
+for hit in hits_per_ray:
+    idx, u, v, w = hit
+    point = barycenter_to_point(u, v, w, p1, p2, p3)
+    intersections.append(point)
+
+bary_coords = compas.geometry.barycentric_coordinates(intersections[0], [p1, p2, p3])
+print("libigl barycentric coordinates: ", u, v, w)
+print("compas barycentric coordinates: ", *bary_coords)
+
+# ==============================================================================
+# Visualisation
+# ==============================================================================
+
+viewer = Viewer(width=1600, height=900)
+
+viewer.scene.add(mesh, opacity=0.7, show_points=False)
+
+for intersection in intersections:
+    viewer.scene.add(Line(p0, intersection), linecolor=Color.blue(), linewidth=3)
+
+viewer.show()

docs/examples/example_mapping.py

@@ -61,8 +61,8 @@
 # Offset mesh by normals, normals are interpolated from the original mesh.
 # ==============================================================================
 mesh_mapped_offset = mesh_mapped.copy()
-for i in range(mesh_mapped.number_of_vertices()):   
-    mesh_mapped_offset.vertex_attributes(i, "xyz", mesh_mapped.vertex_attributes(i, "xyz") - mn[i]*0.001)
+for i in range(mesh_mapped.number_of_vertices()):
+    mesh_mapped_offset.vertex_attributes(i, "xyz", mesh_mapped.vertex_attributes(i, "xyz") - mn[i] * 0.001)
 
 # ==============================================================================
 # Get Boundary Polylines
@@ -74,7 +74,7 @@
     points = []
     for j in range(len(mf[i])):
         id = mf[i][j]
-        points.append(mesh_mapped.vertex_attributes(id, "xyz") + mn[id]*0.002)
+        points.append(mesh_mapped.vertex_attributes(id, "xyz") + mn[id] * 0.002)
     points.append(points[0])
     polyline = Polyline(points)
     boundaries.append(polyline)

docs/examples/example_mapping_patterns.py

@@ -9,15 +9,13 @@
 from compas_libigl.mapping import map_pattern_to_mesh
 
 
-
 # ==============================================================================
 # Input geometry: 3D Mesh
 # ==============================================================================
 
 mesh = Mesh.from_obj(Path(__file__).parent.parent.parent / "data" / "minimal_surface.obj")
 
 
-
 for vertex in mesh.vertices():
     x, y, z = mesh.vertex_attributes(vertex, "xyz")  # type: ignore
     mesh.vertex_attributes(vertex, "xyz", [x, -z, y])
@@ -32,7 +30,7 @@
 
 for vertex in mesh.vertices():
     x, y, z = mesh.vertex_attributes(vertex, "xyz")  # type: ignore
-    if abs(z-aabb.zmin) < 1e-3 or abs(z-aabb.zmax) < 1e-3:
+    if abs(z - aabb.zmin) < 1e-3 or abs(z - aabb.zmax) < 1e-3:
         fixed_vertices.append(vertex)
 
 # ==============================================================================

pyproject.toml

@@ -12,18 +12,31 @@ authors = [
     { name = "Petras Vestartas", email = "[email protected]" },
 ]
 classifiers = ["License :: OSI Approved :: BSD License"]
-dynamic = ['dependencies', 'optional-dependencies', 'version']
+dynamic = ['version']
+dependencies = [
+    "compas >=2.0.0",
+    "tessagon",
+]
 
 [project.urls]
 Homepage = "https://compas.dev/compas_libigl/latest/"
 
-# ============================================================================
-# setuptools config
-# ============================================================================
-
-[tool.setuptools.dynamic]
-dependencies = { file = "requirements.txt" }
-optional-dependencies = { dev = { file = "requirements-dev.txt" } }
+[dependency-groups]
+dev = [
+    "ruff",
+    "pre-commit",
+    "build",
+    { include-group = "tests" },
+    { include-group = "docs" },
+]
+tests = [
+    "pytest",
+    "numpy",
+]
+docs = [
+    "sphinx",
+    "sphinx-compas-theme",
+]
 
 # ============================================================================
 # pytest configuration
@@ -83,8 +96,8 @@ CMAKE_POLICY_DEFAULT_CMP0135 = "NEW"
 
 [tool.cibuildwheel]
 build-verbosity = 3
-test-requires = ["numpy", "compas", "pytest", "build", "tessagon"]
-test-command = "pip install numpy compas && pip list && pytest {project}/tests"
+test-groups = ["tests"]
+test-command = "pytest {project}/tests"
 build-frontend = "pip"
 manylinux-x86_64-image = "manylinux2014"
 skip = ["*_i686", "*-musllinux_*", "*-win32", "pp*"]
@@ -143,4 +156,4 @@ max-doc-length = 179
 
 [tool.ruff.format]
 docstring-code-format = true
-docstring-code-line-length = "dynamic"
+docstring-code-line-length = "dynamic"

src/compas_libigl/intersections.py

@@ -4,6 +4,69 @@
 from compas_libigl import _intersections
 
 
+def _conversion_libigl_to_compas(hits_per_ray):
+    """Convert libigl barycentric coordinates to COMPAS barycentric coordinates.
+
+    Parameters
+    ----------
+    hits_per_ray : list[tuple[int, float, float, float]]
+        Tuples of (face_index, u, v, distance) from libigl ray intersection
+
+    Returns
+    -------
+    list[tuple[int, float, float, float]]
+        Tuples of (face_index, w, u, v) in COMPAS barycentric coordinate ordering
+
+    Note
+    ----
+    libigl uses: P = (1-u-v)*v0 + u*v1 + v*v2
+    This function returns [w, u, v] = [1-u-v, u, v] to match COMPAS ordering
+    """
+
+    hits_compas = []
+    for h in hits_per_ray:
+        idx, u, v, _ = h
+        w = 1.0 - u - v
+        hits_compas.append([idx, w, v, u])
+    return hits_compas
+
+
+def barycenter_to_point(u, v, w, p1, p2, p3):
+    """Convert COMPAS barycentric coordinates to a point.
+
+    Parameters
+    ----------
+    u : float
+        The u coordinate
+    v : float
+        The v coordinate
+    w : float
+        The w coordinate
+    p1 : tuple[float, float, float]
+        The first point
+    p2 : tuple[float, float, float]
+        The second point
+    p3 : tuple[float, float, float]
+        The third point
+
+
+    Returns
+    -------
+    list[float]
+        The point at the intersection of the ray and the mesh
+
+    Note
+    ----
+    libigl uses: P = (1-u-v)*v0 + u*v1 + v*v2
+    This function returns [w, u, v] = [1-u-v, u, v] to match COMPAS ordering
+    """
+    w = 1 - u - v  # barycentric coordinates
+
+    phit = [u * p1[0] + v * p2[0] + w * p3[0], u * p1[1] + v * p2[1] + w * p3[1], u * p1[2] + v * p2[2] + w * p3[2]]
+
+    return phit
+
+
 @plugin(category="intersections")
 def intersection_ray_mesh(ray, M):
     """Compute the intersection(s) between a ray and a mesh.
@@ -24,16 +87,29 @@ def intersection_ray_mesh(ray, M):
 
         0. the index of the intersected face
         1. the u coordinate of the intersection in the barycentric coordinates of the face
-        2. the u coordinate of the intersection in the barycentric coordinates of the face
+        2. the v coordinate of the intersection in the barycentric coordinates of the face
         3. the distance between the ray origin and the hit
+
+        Note
+        ----
+        The barycentric coordinates (u, v) follow the libigl convention where:
+        - For a triangle with vertices (v0, v1, v2) at face indices F[face_id]
+        - The intersection point P = (1-u-v)*v0 + u*v1 + v*v2
+        - This differs from COMPAS barycentric_coordinates which uses a different vertex ordering
     """
     point, vector = ray
     vertices, faces = M
     P = np.asarray(point, dtype=np.float64)
     D = np.asarray(vector, dtype=np.float64)
     V = np.asarray(vertices, dtype=np.float64)
     F = np.asarray(faces, dtype=np.int32)
-    return _intersections.intersection_ray_mesh(P, D, V, F)
+
+    hits_per_ray = _intersections.intersection_ray_mesh(P, D, V, F)
+
+    # Convert libigl barycentric coordinates to COMPAS convention
+    hits_compas = _conversion_libigl_to_compas(hits_per_ray)
+
+    return hits_compas
 
 
 def intersection_rays_mesh(rays, M):
@@ -55,7 +131,7 @@ def intersection_rays_mesh(rays, M):
 
         0. the index of the intersected face
         1. the u coordinate of the intersection in the barycentric coordinates of the face
-        2. the u coordinate of the intersection in the barycentric coordinates of the face
+        2. the v coordinate of the intersection in the barycentric coordinates of the face
         3. the distance between the ray origin and the hit
     """
     points, vectors = zip(*rays)
@@ -64,4 +140,12 @@ def intersection_rays_mesh(rays, M):
     D = np.asarray(vectors, dtype=np.float64)
     V = np.asarray(vertices, dtype=np.float64)
     F = np.asarray(faces, dtype=np.int32)
-    return _intersections.intersection_rays_mesh(P, D, V, F)
+
+    hits_per_ray = _intersections.intersection_rays_mesh(P, D, V, F)
+
+    # Convert libigl barycentric coordinates to COMPAS convention
+    hits_per_ray_compas = []
+    for hit in hits_per_ray:
+        hits_per_ray_compas.append(_conversion_libigl_to_compas(hit))
+
+    return hits_per_ray_compas