ADD cpp header declarations.

Author: petrasvestartas

docs/examples/example_geodistance_multiple.py

@@ -50,6 +50,6 @@
 # Highlight boundary vertices
 for vertex in boundary_vertices:
     point = Point(*mesh.vertex_attributes(vertex, "xyz"))
-    viewer.scene.add(point, pointsize=20, pointcolor=Color.red())
+    viewer.scene.add(point, pointsize=20, pointcolor=Color.black())
 
 viewer.show()

src/boundaries.hpp

@@ -2,4 +2,14 @@
 
 #include "compas.hpp"
 #include <igl/boundary_loop.h>
-#include <Eigen/StdVector>
+
+/**
+ * Compute all ordered boundary loops of a manifold triangle mesh.
+ *
+ * @param F The face matrix of the triangle mesh (n x 3).
+ * @return A vector of vectors containing vertex indices for each boundary loop.
+ *
+ * @note The input mesh should be manifold for correct results.
+ */
+std::vector<std::vector<int>> trimesh_boundaries(
+    const compas::RowMatrixXi& F);

src/curvature.hpp

@@ -2,4 +2,39 @@
 
 #include "compas.hpp"
 #include <igl/gaussian_curvature.h>
-#include <igl/principal_curvature.h>
+#include <igl/principal_curvature.h>
+
+namespace compas_libigl {
+
+/**
+ * Compute the discrete gaussian curvature of a triangle mesh.
+ *
+ * @param V The vertex matrix of the triangle mesh (n x 3).
+ * @param F The face matrix of the triangle mesh (m x 3).
+ * @return A vector of gaussian curvature values per vertex.
+ */
+Eigen::VectorXd trimesh_gaussian_curvature(
+    compas::RowMatrixXd V,
+    compas::RowMatrixXi F
+);
+
+/**
+ * Compute the principal curvatures and directions of a triangle mesh.
+ *
+ * @param V The vertex matrix of the triangle mesh (n x 3).
+ * @param F The face matrix of the triangle mesh (m x 3).
+ * @param[out] PD1 Principal direction 1 per vertex (normalized vectors).
+ * @param[out] PD2 Principal direction 2 per vertex (normalized vectors).
+ * @param[out] PV1 Principal curvature value 1 per vertex (maximum curvature).
+ * @param[out] PV2 Principal curvature value 2 per vertex (minimum curvature).
+ */
+void trimesh_principal_curvature(
+    compas::RowMatrixXd V,
+    compas::RowMatrixXi F,
+    Eigen::MatrixXd& PD1,
+    Eigen::MatrixXd& PD2,
+    Eigen::VectorXd& PV1,
+    Eigen::VectorXd& PV2
+);
+
+} // namespace compas_libigl

src/geodistance.hpp

@@ -3,4 +3,36 @@
 #include "compas.hpp"
 #include <igl/avg_edge_length.h>
 #include <igl/exact_geodesic.h>
-#include <igl/heat_geodesics.h>
+#include <igl/heat_geodesics.h>
+
+/**
+ * Compute geodesic distance from a source vertex to all other vertices.
+ *
+ * @param V The vertex matrix of the triangle mesh (n x 3).
+ * @param F The face matrix of the triangle mesh (m x 3).
+ * @param source Index of the source vertex.
+ * @param method Method to use: "exact" or "heat".
+ * @return Vector of geodesic distances from source to all vertices.
+ */
+Eigen::VectorXd trimesh_geodistance(
+    compas::RowMatrixXd V,
+    compas::RowMatrixXi F,
+    int source,
+    const std::string& method
+);
+
+/**
+ * Compute geodesic distance from multiple source vertices.
+ *
+ * @param V The vertex matrix of the triangle mesh (n x 3).
+ * @param F The face matrix of the triangle mesh (m x 3).
+ * @param sources Vector of source vertex indices.
+ * @param method Method to use: "exact" or "heat".
+ * @return Vector of minimum geodesic distances from any source to all vertices.
+ */
+Eigen::VectorXd trimesh_geodistance_multiple(
+    compas::RowMatrixXd V,
+    compas::RowMatrixXi F,
+    Eigen::VectorXi sources,
+    const std::string& method
+);

src/intersections.hpp

@@ -1,6 +1,37 @@
 #pragma once
 
 #include "compas.hpp"
-#include <igl/Hit.h>
 #include <igl/ray_mesh_intersect.h>
-#include <igl/readOFF.h>
+#include <igl/Hit.h>
+#include <Eigen/Core>
+
+/**
+ * Compute intersection between a single ray and a mesh.
+ * 
+ * @param point Origin point of the ray
+ * @param direction Direction vector of the ray
+ * @param V #V x 3 matrix of vertex coordinates
+ * @param F #F x 3 matrix of triangle indices
+ * @return Vector of intersection hits, each containing (face_id, u, v, t) where:
+ *         - face_id: index of intersected face
+ *         - u, v: barycentric coordinates of hit point
+ *         - t: ray parameter at intersection
+ */
+std::vector<std::tuple<int, float, float, float>>
+intersection_ray_mesh(const Eigen::Vector3d& point, const Eigen::Vector3d& direction,
+                     const compas::RowMatrixXd& V, const compas::RowMatrixXi& F);
+
+/**
+ * Compute intersections between multiple rays and a mesh.
+ * 
+ * @param points #R x 3 matrix of ray origin points
+ * @param directions #R x 3 matrix of ray direction vectors
+ * @param V #V x 3 matrix of vertex coordinates
+ * @param F #F x 3 matrix of triangle indices
+ * @return Vector of intersection hits per ray, each hit containing (face_id, u, v, t)
+ */
+std::vector<std::vector<std::tuple<int, float, float, float>>>
+intersection_rays_mesh(const compas::RowMatrixXd& points,
+                      const compas::RowMatrixXd& directions,
+                      const compas::RowMatrixXd& V, 
+                      const compas::RowMatrixXi& F);

src/isolines.hpp

@@ -2,4 +2,21 @@
 
 #include "compas.hpp"
 #include <igl/isolines.h>
-#include <Eigen/Core>
+#include <Eigen/Core>
+
+/**
+ * Compute isolines on a triangle mesh.
+ *
+ * @param V The vertex matrix of the triangle mesh (n x 3).
+ * @param F The face matrix of the triangle mesh (m x 3).
+ * @param isovalues The scalar values per vertex (n x 1).
+ * @param vals The isovalues at which to compute isolines.
+ * @return Tuple of (vertices, edges, indices) defining the isolines.
+ */
+std::tuple<compas::RowMatrixXd, compas::RowMatrixXi, compas::RowMatrixXi>
+trimesh_isolines(
+    const compas::RowMatrixXd V,
+    const compas::RowMatrixXi F,
+    const Eigen::VectorXd isovalues,
+    const Eigen::VectorXd vals
+);

src/massmatrix.hpp

@@ -2,4 +2,16 @@
 
 #include "compas.hpp"
 #include <igl/massmatrix.h>
-#include <Eigen/Core>
+#include <Eigen/Core>
+
+/**
+ * Compute the mass matrix of a triangle mesh.
+ *
+ * @param V The vertex matrix of the triangle mesh (n x 3).
+ * @param F The face matrix of the triangle mesh (m x 3).
+ * @return Vector of mass values per vertex.
+ */
+Eigen::VectorXd trimesh_massmatrix(
+    compas::RowMatrixXd V,
+    compas::RowMatrixXi F
+);

src/meshing.hpp

@@ -5,7 +5,6 @@
 #include <igl/facet_components.h>
 #include <Eigen/Sparse>
 
-// Function to remesh along a single isoline
 std::tuple<
     compas::RowMatrixXd,
     compas::RowMatrixXi,
@@ -16,7 +15,6 @@ trimesh_remesh_along_isoline(
     Eigen::VectorXd S1,
     double s);
 
-// Function to remesh along multiple isolines
 std::tuple<
     compas::RowMatrixXd,
     compas::RowMatrixXi,

src/parametrisation.hpp

@@ -5,4 +5,22 @@
 #include <igl/harmonic.h>
 #include <igl/lscm.h>
 #include <igl/map_vertices_to_circle.h>
-#include <Eigen/Core>
+#include <Eigen/Core>
+
+/**
+ * Compute harmonic parametrization of a triangle mesh.
+ *
+ * @param V The vertex matrix of the triangle mesh (n x 3).
+ * @param F The face matrix of the triangle mesh (m x 3).
+ * @param bnd The boundary vertex indices.
+ * @param bnd_uv The UV coordinates for boundary vertices.
+ * @param harmonic_order The order of harmonic weights (1: harmonic, 2: biharmonic).
+ * @return Matrix of UV coordinates for all vertices.
+ */
+Eigen::MatrixXd trimesh_harmonic_parametrisation(
+    const Eigen::MatrixXd& V,
+    const Eigen::MatrixXi& F,
+    const Eigen::VectorXi& bnd,
+    const Eigen::MatrixXd& bnd_uv,
+    const int harmonic_order
+);

src/planarize.hpp

@@ -2,4 +2,23 @@
 
 #include "compas.hpp"
 #include <igl/planarize_quad_mesh.h>
-#include <Eigen/Core>
+#include <Eigen/Core>
+
+/**
+ * Planarize a quad mesh by iteratively projecting faces onto their best-fit planes.
+ *
+ * @param V The vertex matrix of the quad mesh (n x 3).
+ * @param F The face matrix of the quad mesh (m x 4).
+ * @param maxiter Maximum number of iterations.
+ * @param threshold Convergence threshold for planarity.
+ * @return Tuple of (vertices, planarity error).
+ */
+std::tuple<
+    compas::RowMatrixXd,
+    double>
+quadmesh_planarize(
+    compas::RowMatrixXd V,
+    compas::RowMatrixXi F,
+    int maxiter,
+    double threshold
+);