add back files and tests

Author: Alec Jacobson

.github/workflows/wheels.yml

@@ -52,7 +52,7 @@ jobs:
       # This is very dubious... It *may* work because these are just cpp libraries that should not depend on the python version. Still, super-dubious.
       CIBW_BEFORE_BUILD_WINDOWS: "python -m pip install delvewheel"
       CIBW_REPAIR_WHEEL_COMMAND_WINDOWS: "python -m delvewheel repair --no-mangle-all --add-path build\\temp.win-amd64-3.6\\Release;build\\temp.win-amd64-3.6\\Release\\Release;build\\temp.win-amd64-3.6\\Release\\_deps\\gmp-src\\lib;build\\temp.win-amd64-3.6\\Release\\_deps\\mpfr-src\\lib -w {dest_dir} {wheel} "
-        #CIBW_TEST_COMMAND: "python {project}/tests/test_basic.py {project}/data/"
+      CIBW_TEST_COMMAND: "python {project}/tests/test_basic.py {project}/data/"
       CIBW_BUILD: "${{ matrix.cpversion }}-${{ matrix.os.cibw-arch }}"
       CIBW_TEST_SKIP: "*-macosx_arm64"
       CIBW_ENVIRONMENT: "MAX_JOBS=2"

src/active_set.cpp

@@ -0,0 +1,133 @@
+#include <common.h>
+#include <npe.h>
+#include <typedefs.h>
+#include <igl/active_set.h>
+
+const char *ds_active_set = R"igl_Qu8mg5v7(
+ACTIVE_SET Minimize quadratic energy
+
+0.5*Z'*A*Z + Z'*B + C with constraints
+that Z(known) = Y, optionally also subject to the constraints Aeq*Z = Beq,
+and further optionally subject to the linear inequality constraints that
+Aieq*Z <= Bieq and constant inequality constraints lx <= x <= ux
+
+Parameters
+----------
+A  n by n matrix of quadratic coefficients
+B  n by 1 column of linear coefficients
+known  list of indices to known rows in Z
+Y  list of fixed values corresponding to known rows in Z
+Aeq  meq by n list of linear equality constraint coefficients
+Beq  meq by 1 list of linear equality constraint constant values
+Aieq  mieq by n list of linear inequality constraint coefficients
+Bieq  mieq by 1 list of linear inequality constraint constant values
+lx  n by 1 list of lower bounds [] implies -Inf
+ux  n by 1 list of upper bounds [] implies Inf
+params  struct of additional parameters (see below)
+Z  if not empty, is taken to be an n by 1 list of initial guess values (see output)
+Returns
+-------
+Z n by 1 list of solution values
+Returns SOLVER_STATUS_CONVERGED = 0, SOLVER_STATUS_MAX_ITER = 1, SOLVER_STATUS_ERROR = 2,
+
+See also
+--------
+
+Notes
+-----
+For a harmonic solve on a mesh with 325K facets, matlab 2.2 secs, igl / min_quad_with_fixed.h 7.1 secs
+
+Known Bugs : rows of[Aeq; Aieq] **must **be linearly independent.Should be using QR decomposition otherwise : http : //www.okstate.edu/sas/v8/sashtml/ormp/chap5/sect32.htm
+
+
+Examples
+--------
+
+)igl_Qu8mg5v7";
+
+//NONe and dense_like
+npe_function(active_set)
+npe_doc(ds_active_set)
+npe_arg(A, sparse_float, sparse_double)
+npe_arg(B, dense_float, dense_double)
+npe_arg(known, dense_int, dense_long, dense_longlong)
+npe_arg(Y, npe_matches(B))
+npe_arg(Aeq, npe_matches(A))
+npe_arg(Beq, npe_matches(B))
+npe_arg(Aieq, npe_matches(A))
+npe_arg(Bieq, npe_matches(B))
+npe_arg(lx, npe_matches(B))
+npe_arg(ux, npe_matches(B))
+
+npe_default_arg(Auu_pd, bool, false)
+npe_default_arg(max_iter, int, 100)
+npe_default_arg(inactive_threshold, double, igl::DOUBLE_EPS)
+npe_default_arg(constraint_threshold, double, igl::DOUBLE_EPS)
+npe_default_arg(solution_diff_threshold, double, igl::DOUBLE_EPS)
+
+npe_begin_code()
+  assert_cols_equals(A, A.rows(), "A");
+  assert_rows_match(A, B, "A", "B");
+  assert_cols_equals(B, 1, "B");
+
+  assert_cols_match(A, Aeq, "A", "Aeq");
+  assert_rows_match(Aeq, Beq, "Aeq", "Beq");
+  assert_cols_equals(Beq, 1, "Beq");
+
+  assert_rows_match(Aieq, Bieq, "Aieq", "Bieq");
+
+  if(Aieq.size() > 0)
+  {
+    assert_cols_match(A, Aieq, "A", "Aieq");
+    assert_cols_equals(Bieq, 1, "Bieq");
+  }
+
+  if(lx.size() > 0)
+  {
+    assert_rows_match(A, lx, "A", "lx");
+    assert_cols_equals(lx, 1, "lx");
+  }
+
+  if (ux.size() > 0)
+  {
+    assert_rows_match(A, ux, "A", "ux");
+    assert_cols_equals(ux, 1, "ux");
+  }
+
+  Eigen::SparseMatrix<double> A_copy = A.template cast<double>();
+  Eigen::VectorXd B_copy = B.template cast<double>();
+  Eigen::VectorXi known_copy = known.template cast<int>();
+  Eigen::VectorXd Y_copy = Y.template cast<double>();
+  Eigen::SparseMatrix<double> Aeq_copy = Aeq.template cast<double>();
+  Eigen::VectorXd Beq_copy = Beq.template cast<double>();
+  Eigen::SparseMatrix<double> Aieq_copy;
+  Eigen::VectorXd Bieq_copy;
+
+  if(Aieq.size() > 0)
+  {
+    Aieq_copy = Aieq.template cast<double>();
+    Bieq_copy = Bieq.template cast<double>();
+  }
+
+  Eigen::VectorXd lx_copy;
+  if(lx.size() > 0)
+    lx_copy = lx.template cast<double>();
+  Eigen::VectorXd ux_copy;
+  if (ux.size() > 0)
+    ux_copy = ux.template cast<double>();
+
+  igl::active_set_params params;
+  params.Auu_pd = Auu_pd;
+  params.max_iter = max_iter;
+  params.inactive_threshold = inactive_threshold;
+  params.constraint_threshold = constraint_threshold;
+  params.solution_diff_threshold = solution_diff_threshold;
+
+  Eigen::VectorXd Z;
+
+  auto res = igl::active_set(A_copy, B_copy, known_copy, Y_copy, Aeq_copy, Beq_copy, Aieq_copy, Bieq_copy, lx_copy, ux_copy, params, Z);
+  EigenDenseLike<npe_Matrix_B> Z_row_major = Z.template cast<typename npe_Matrix_B::Scalar>();
+
+  return std::make_tuple(int(res), npe::move(Z_row_major));
+
+  npe_end_code()

src/adjacency_list.cpp

@@ -0,0 +1,40 @@
+#include <common.h>
+#include <npe.h>
+#include <igl/adjacency_list.h>
+#include <pybind11/stl.h>
+
+const char* ds_adjacency_list = R"igl_Qu8mg5v7(
+Constructs the graph adjacency list of a given mesh (v, f)
+
+Parameters
+----------
+f : #f by dim array of fixed dimensional (e.g. triangle (#f by 3),
+    tet (#f by 4), quad (#f by 4), etc...) mesh faces
+
+Returns
+-------
+list of lists containing at index i the adjacent vertices of vertex i
+
+See also
+--------
+adjacency_matrix
+
+Notes
+-----
+
+Examples
+--------
+# Mesh in (v, f)
+>>> a = mesh_adjacency_list(f)
+)igl_Qu8mg5v7";
+
+npe_function(adjacency_list)
+npe_doc(ds_adjacency_list)
+npe_arg(f, dense_int, dense_long, dense_longlong)
+npe_begin_code()
+  assert_valid_tet_or_tri_mesh_faces(f, "f");
+  std::vector<std::vector<npe_Scalar_f>> a;
+  igl::adjacency_list(f, a);
+  return pybind11::detail::type_caster<decltype(a)>::cast(a, pybind11::return_value_policy::move, pybind11::none());
+
+npe_end_code()

src/adjacency_matrix.cpp

@@ -0,0 +1,52 @@
+#include <common.h>
+#include <npe.h>
+#include <typedefs.h>
+#include <igl/adjacency_matrix.h>
+
+const char* ds_adjacency_matrix = R"igl_Qu8mg5v7(
+Constructs the graph adjacency matrix of a given mesh (v, f).
+
+Parameters
+----------
+f : #f by dim list of mesh simplices
+
+Returns
+-------
+a : max(f) by max(f) cotangent matrix, each row i corresponding to v(i, :)
+
+See also
+--------
+adjacency_list, edges, cotmatrix, diag
+
+Notes
+-----
+None
+
+Examples
+--------
+# Mesh in (v, f)
+>>> a = adjacency_matrix(f)
+
+# Sum each row 
+>>> a_sum = np.sum(a, axis=1)
+
+# Convert row sums into diagonal of sparse matrix
+>>> a_diag = diag(a_sum)
+
+# Build uniform laplacian
+>>> u = a - a_diag
+)igl_Qu8mg5v7";
+
+npe_function(adjacency_matrix)
+npe_doc(ds_adjacency_matrix)
+npe_arg(f, dense_int, dense_long, dense_longlong)
+npe_begin_code()
+
+  assert_valid_simplex_idxs(f, "f");
+  EigenSparseLike<npe_Matrix_f> a;
+  igl::adjacency_matrix(f, a);
+  return npe::move(a);
+
+npe_end_code()
+
+

src/all_pairs_distances.cpp

@@ -0,0 +1,56 @@
+#include <common.h>
+#include <npe.h>
+#include <typedefs.h>
+#include <igl/all_pairs_distances.h>
+
+const char *ds_all_pairs_distances = R"igl_Qu8mg5v7(
+compute distances between each point i in V and point j in U
+
+Parameters
+----------
+V  #V by dim list of points
+U  #U by dim list of points
+squared  whether to return squared distances
+
+Returns
+-------
+D  #V by #U matrix of distances, where D(i,j) gives the distance or squareed distance between V(i,:) and U(j,:)
+
+See also
+--------
+
+
+Notes
+-----
+
+
+Examples
+--------
+D = all_pairs_distances(u,v)
+
+
+)igl_Qu8mg5v7";
+
+npe_function(all_pairs_distances)
+npe_doc(ds_all_pairs_distances)
+
+npe_arg(u, dense_float, dense_double)
+npe_arg(v, npe_matches(u))
+npe_arg(squared, bool)
+
+
+npe_begin_code()
+  assert_cols_match(u, v, "u", "v");
+  assert_nonzero_rows(u, "u");
+  assert_nonzero_rows(v, "v");
+  //same input/output template
+  EigenDenseLike<npe_Matrix_u> u_copy = u;
+  EigenDenseLike<npe_Matrix_u> v_copy = v;
+
+  EigenDenseLike<npe_Matrix_u> D;
+  igl::all_pairs_distances(u_copy, v_copy, squared, D);
+  return npe::move(D);
+
+npe_end_code()
+
+

src/ambient_occlusion.cpp

@@ -0,0 +1,55 @@
+// TODO: __missing miss the rest two functions with AABB and shoot_ray. __example
+
+#include <common.h>
+#include <npe.h>
+#include <typedefs.h>
+#include <igl/ambient_occlusion.h>
+
+const char* ds_ambient_occlusion = R"igl_Qu8mg5v7(
+
+Parameters
+----------
+V  #V by 3 list of mesh vertex positions
+F  #F by 3 list of mesh face indices into V
+P  #P by 3 list of origin points
+N  #P by 3 list of origin normals
+
+Returns
+-------
+S  #P list of ambient occusion values between 1 (fully occluded) and 0 (not occluded)
+
+See also
+--------
+
+
+Notes
+-----
+None
+
+Examples
+--------
+
+)igl_Qu8mg5v7";
+
+npe_function(ambient_occlusion)
+npe_doc(ds_ambient_occlusion)
+
+npe_arg(v, dense_float, dense_double)
+npe_arg(f, dense_int, dense_long, dense_longlong)
+npe_arg(p, dense_float, dense_double)
+npe_arg(n, npe_matches(p))
+npe_arg(num_samples, int)
+npe_begin_code()
+
+  assert_valid_3d_tri_mesh(v, f);
+  assert_cols_equals(p, 3, "p");
+  assert_cols_equals(n, 3, "n");
+  assert_nonzero_rows(p, "p");
+  assert_nonzero_rows(n, "n");
+  assert_shapes_match(p, n, "p", "n");
+
+  EigenDenseLike<npe_Matrix_p> s;
+  igl::ambient_occlusion(v, f, p, n, num_samples, s);
+  return npe::move(s);
+
+npe_end_code()