Merge branch 'master' of https://github.com/libigl/libigl-python-bindings

Author: skoch9

setup.py

@@ -70,7 +70,7 @@ def build_extension(self, ext):
 
 setup(
     name="igl",
-    version="0.5",
+    version="2.2.0",
     author="libigl",
     author_email="",
     description="libigl Python Bindings",

src/cotmatrix_intrinsic.cpp

@@ -0,0 +1,55 @@
+#include <npe.h>
+#include <common.h>
+#include <typedefs.h>
+#include <igl/cotmatrix_intrinsic.h>
+
+const char *ds_cotmatrix_intrinsic = R"igl_Qu8mg5v7(
+
+Constructs the cotangent stiffness matrix (discrete laplacian) for a given
+   mesh with faces F and edge lengths l.
+
+Parameters
+----------
+
+l  #F by 3 list of (half-)edge lengths
+F  #F by 3 list of face indices into some (not necessarily
+  determined/embedable) list of vertex positions V. It is assumed #V ==
+  F.maxCoeff()+1
+
+Returns
+-------
+
+L  #V by #V sparse Laplacian matrix
+
+See also
+--------
+
+cotmatrix, intrinsic_delaunay_cotmatrix
+
+Notes
+-----
+
+Examples
+--------
+
+)igl_Qu8mg5v7";
+
+npe_function(cotmatrix_intrinsic)
+npe_doc(ds_cotmatrix_intrinsic)
+
+npe_arg(l, dense_float, dense_double)
+npe_arg(f, dense_int, dense_long, dense_longlong)
+
+
+npe_begin_code()
+  assert_rows_match(l, f, "l", "f");
+  assert_cols_equals(l, 3, "l");
+  assert_valid_tri_mesh_faces(f);
+
+  Eigen::SparseMatrix<npe_Scalar_l> mat;
+  igl::cotmatrix_intrinsic(l, f, mat);
+  return npe::move(mat);
+
+npe_end_code()
+
+

src/cut_to_disk.cpp

@@ -0,0 +1,63 @@
+#include <npe.h>
+#include <common.h>
+#include <typedefs.h>
+#include <igl/cut_to_disk.h>
+
+const char *ds_cut_to_disk = R"igl_Qu8mg5v7(
+
+Given a triangle mesh, computes a set of edge cuts sufficient to carve the
+mesh into a topological disk, without disconnecting any connected components.
+Nothing else about the cuts (including number, total length, or smoothness)
+is guaranteed to be optimal.
+
+Simply-connected components without boundary (topological spheres) are left
+untouched (delete any edge if you really want a disk).
+All other connected components are cut into disks. Meshes with boundary are
+supported; boundary edges will be included as cuts.
+
+The cut mesh itself can be materialized using cut_mesh().
+
+Implements the triangle-deletion approach described by Gu et al's
+"Geometry Images."
+
+Parameters
+----------
+
+F  #F by 3 list of the faces (must be triangles)
+
+Returns
+-------
+
+cuts  List of cuts. Each cut is a sequence of vertex indices (where
+       pairs of consecutive vertices share a face), is simple, and is either
+       a closed loop (in which the first and last indices are identical) or
+       an open curve. Cuts are edge-disjoint.
+
+See also
+--------
+
+
+Notes
+-----
+None
+
+Examples
+--------
+
+
+)igl_Qu8mg5v7";
+
+npe_function(cut_to_disk)
+npe_doc(ds_cut_to_disk)
+
+npe_arg(f, dense_int, dense_long, dense_longlong)
+
+
+npe_begin_code()
+  assert_valid_tri_mesh_faces(f);
+
+  std::vector<std::vector<int> > cuts;
+  igl::cut_to_disk(f, cuts);
+  return cuts;
+
+npe_end_code()

src/grad_intrinsic.cpp

@@ -0,0 +1,61 @@
+#include <common.h>
+#include <npe.h>
+#include <typedefs.h>
+
+
+
+
+
+
+#include <igl/grad_intrinsic.h>
+
+const char *ds_grad_intrinsic = R"igl_Qu8mg5v7(
+
+GRAD_INTRINSIC Construct an intrinsic gradient operator.
+
+
+Parameters
+----------
+
+l  #F by 3 list of edge lengths
+F  #F by 3 list of triangle indices into some vertex list V
+
+Returns
+-------
+G  #F*2 by #V gradient matrix: G=[Gx;Gy] where x runs along the 23 edge and
+      y runs in the counter-clockwise 90° rotation.
+
+See also
+--------
+
+
+Notes
+-----
+None
+
+Examples
+--------
+
+)igl_Qu8mg5v7";
+
+npe_function(grad_intrinsic)
+npe_doc(ds_grad_intrinsic)
+
+npe_arg(l, dense_float, dense_double)
+npe_arg(f, dense_int, dense_long, dense_longlong)
+
+
+npe_begin_code()
+  assert_rows_match(l, f, "l", "f");
+  assert_cols_equals(l, 3, "l");
+  assert_valid_tri_mesh_faces(f);
+
+  EigenDense<npe_Scalar_f> f_copy = f;
+
+  Eigen::SparseMatrix<npe_Scalar_l> g;
+  igl::grad_intrinsic(l, f_copy, g);
+  return npe::move(g);
+
+npe_end_code()
+
+

src/heat_geodesic.cpp

@@ -0,0 +1,56 @@
+#include <common.h>
+#include <npe.h>
+#include <typedefs.h>
+#include <igl/heat_geodesics.h>
+
+const char *ds_heat_geodesic = R"igl_Qu8mg5v7xxx(
+Compute fast approximate geodesic distances using precomputed data from a set of selected source vertices (gamma)
+
+Parameters
+----------
+V  #V by dim list of mesh vertex positions
+F  #F by 3 list of mesh face indices into V
+t  "heat" parameter (smaller --> more accurate, less stable)
+gamma  #gamma list of indices into V of source vertices
+
+Returns
+-------
+D  #V list of distances to gamma
+
+See also
+--------
+
+
+Notes
+-----
+
+Examples
+--------
+
+)igl_Qu8mg5v7xxx";
+
+npe_function(heat_geodesic)
+npe_doc(ds_heat_geodesic)
+npe_arg(v, dense_float, dense_double)
+npe_arg(f, dense_int, dense_long, dense_longlong)
+npe_arg(t, double)
+npe_arg(gamma, npe_matches(f))
+
+npe_begin_code()
+  assert_valid_3d_tri_mesh(v, f);
+
+  EigenDenseLike<npe_Matrix_v> v_copy = v;
+  EigenDenseLike<npe_Matrix_f> f_copy = f;
+  EigenDenseLike<npe_Matrix_f> gamma_copy = gamma;
+
+  Eigen::Matrix<npe_Scalar_v, Eigen::Dynamic, 1> d_copy;
+  igl::HeatGeodesicsData<npe_Scalar_v> data;
+  igl::heat_geodesics_precompute(v_copy, f_copy, npe_Scalar_v(t), data);
+  igl::heat_geodesics_solve(data, gamma_copy, d_copy);
+  EigenDenseLike<npe_Matrix_v> d = d_copy;
+
+  return npe::move(d);
+
+npe_end_code()
+
+

src/intrinsic_delaunay_cotmatrix.cpp

@@ -0,0 +1,54 @@
+#include <common.h>
+#include <npe.h>
+#include <typedefs.h>
+#include <igl/intrinsic_delaunay_cotmatrix.h>
+
+const char *ds_intrinsic_delaunay_cotmatrix = R"igl_Qu8mg5v7(
+
+INTRINSIC_DELAUNAY_COTMATRIX Computes the discrete cotangent Laplacian of a
+mesh after converting it into its intrinsic Delaunay triangulation (see,
+e.g., [Fisher et al. 2007].
+
+Parameters
+----------
+
+V  #V by dim list of mesh vertex positions
+F  #F by 3 list of mesh elements (triangles or tetrahedra)
+
+Returns
+-------
+
+L  #V by #V cotangent matrix, each row i corresponding to V(i,:)
+l_intrinsic  #F by 3 list of intrinsic edge-lengths used to compute L
+F_intrinsic  #F by 3 list of intrinsic face indices used to compute L
+
+See also
+--------
+intrinsic_delaunay_triangulation, cotmatrix, cotmatrix_intrinsic
+
+Notes
+-----
+
+Examples
+--------
+
+)igl_Qu8mg5v7";
+
+npe_function(intrinsic_delaunay_cotmatrix)
+npe_doc(ds_intrinsic_delaunay_cotmatrix)
+
+npe_arg(v, dense_float, dense_double)
+npe_arg(f, dense_int, dense_long, dense_longlong)
+
+
+npe_begin_code()
+  assert_valid_3d_tri_mesh(v, f);
+
+  Eigen::SparseMatrix<npe_Scalar_v> l;
+  EigenDense<npe_Scalar_v> l_intrinsic;
+  EigenDense<npe_Scalar_f> f_intrinsic;
+  igl::intrinsic_delaunay_cotmatrix(v, f, l, l_intrinsic, f_intrinsic);
+  return std::make_tuple(npe::move(l), npe::move(l_intrinsic), npe::move(f_intrinsic));
+
+npe_end_code()
+