Merge pull request #289 from rubenwiersma/main

Add Hessian and Hessian energy functions to Python bindings

Author: alecjacobson

src/curved_hessian_energy.cpp

@@ -0,0 +1,46 @@
+#include "default_types.h"
+#include <igl/curved_hessian_energy.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/eigen/sparse.h>
+#include <nanobind/stl/tuple.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto curved_hessian_energy(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &F)
+  {
+    Eigen::SparseMatrixN Q;
+    igl::curved_hessian_energy(V,F,Q);
+    return Q;
+  }
+
+}
+
+// Bind the wrapper to the Python module
+void bind_curved_hessian_energy(nb::module_ &m)
+{
+  m.def(
+    "curved_hessian_energy",
+    &pyigl::curved_hessian_energy, 
+    "V"_a, 
+    "F"_a,
+R"(Computes the curved Hessian energy using the Crouzeix-Raviart discretization.
+   See Oded Stein, Alec Jacobson, Max Wardetzky, Eitan Grinspun, 2020.
+   "A Smoothness Energy without Boundary Distortion for Curved Surfaces"
+
+  @tparam DerivedV  derived type of eigen matrix for V (e.g. derived from
+    MatrixXd)
+  @tparam DerivedF  derived type of eigen matrix for F (e.g. derived from
+    MatrixXi)
+  @tparam Scalar  scalar type for eigen sparse matrix (e.g. double)
+  @param[in] V  #V by dim list of mesh vertex positions
+  @param[in] F  #F by 3 list of mesh elements (must be triangles)
+  @param[out] Q #V by #V Hessian energy matrix, each row/column i corresponding to V(i,:)");
+
+}

src/hessian.cpp

@@ -0,0 +1,48 @@
+#include "default_types.h"
+#include <igl/hessian.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/eigen/sparse.h>
+#include <nanobind/stl/tuple.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto hessian(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &F)
+  {
+    Eigen::SparseMatrixN H;
+    igl::hessian(V,F,H);
+    return H;
+  }
+
+}
+
+// Bind the wrapper to the Python module
+void bind_hessian(nb::module_ &m)
+{
+  m.def(
+    "hessian",
+    &pyigl::hessian, 
+    "V"_a, 
+    "F"_a,
+R"(Constructs the finite element Hessian matrix
+   as described in https://arxiv.org/abs/1707.04348,
+   Natural Boundary Conditions for Smoothing in Geometry Processing
+   (Oded Stein, Eitan Grinspun, Max Wardetzky, Alec Jacobson)
+   The interior vertices are NOT set to zero yet.
+
+  @tparam DerivedV  derived type of eigen matrix for V (e.g. derived from
+    MatrixXd)
+  @tparam DerivedF  derived type of eigen matrix for F (e.g. derived from
+    MatrixXi)
+  @tparam Scalar  scalar type for eigen sparse matrix (e.g. double)
+  @param[in] V  #V by dim list of mesh vertex positions
+  @param[in] F  #F by 3 list of mesh elements (must be triangles)
+  @param[out] H dim²⋅#V by #V Hessian matrix, each column i corresponding to V(i,:)");
+
+}

src/hessian_energy.cpp

@@ -0,0 +1,47 @@
+#include "default_types.h"
+#include <igl/hessian_energy.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/eigen/sparse.h>
+#include <nanobind/stl/tuple.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto hessian_energy(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &F)
+  {
+    Eigen::SparseMatrixN Q;
+    igl::hessian_energy(V,F,Q);
+    return Q;
+  }
+
+}
+
+// Bind the wrapper to the Python module
+void bind_hessian_energy(nb::module_ &m)
+{
+  m.def(
+    "hessian_energy",
+    &pyigl::hessian_energy, 
+    "V"_a, 
+    "F"_a,
+R"(Constructs the Hessian energy matrix using mixed FEM
+   as described in https://arxiv.org/abs/1707.04348
+   Natural Boundary Conditions for Smoothing in Geometry Processing
+   (Oded Stein, Eitan Grinspun, Max Wardetzky, Alec Jacobson)
+
+  @tparam DerivedV  derived type of eigen matrix for V (e.g. derived from
+    MatrixXd)
+  @tparam DerivedF  derived type of eigen matrix for F (e.g. derived from
+    MatrixXi)
+  @tparam Scalar  scalar type for eigen sparse matrix (e.g. double)
+  @param[in] V  #V by dim list of mesh vertex positions
+  @param[in] F  #F by 3 list of mesh elements (must be triangles)
+  @param[out] Q #V by #V Hessian energy matrix, each row/column i corresponding to V(i,:)");
+
+}

tests/test_all.py

@@ -109,6 +109,9 @@ def test_operators():
     K = igl.cotmatrix_entries(l=l)
     B1,B2,B3 = igl.local_basis(V,F)
     G = igl.grad(V,F)
+    H = igl.hessian(V, F)
+    QH = igl.hessian_energy(V, F)
+    cQH = igl.curved_hessian_energy(V, F)
 
     M = igl.massmatrix(V,F)
     M = igl.massmatrix(V,F,type=igl.MASSMATRIX_TYPE_BARYCENTRIC)