added 405

Former-commit-id: bff37c398745b7fc07eb0281db98397e5250760c

python/405_AsRigidAsPossible.py

@@ -0,0 +1,89 @@
+import igl
+from math import sin,cos,pi
+
+sea_green = igl.eigen.MatrixXd([[70./255.,252./255.,167./255.]])
+
+V = igl.eigen.MatrixXd()
+U = igl.eigen.MatrixXd()
+
+F = igl.eigen.MatrixXi()
+
+S = igl.eigen.MatrixXd()
+b = igl.eigen.MatrixXi()
+
+mid = igl.eigen.MatrixXd()
+
+anim_t = 0.0;
+anim_t_dir = 0.03;
+arap_data = igl.ARAPData()
+
+def pre_draw(viewer):
+    global anim_t
+
+    bc = igl.eigen.MatrixXd(b.size(),V.cols())
+    for i in range(0,b.size()):
+        bc.setRow(i,V.row(b[i]))
+        if S[b[i]] == 0:
+            r = mid[0]*0.25
+            bc[i,0] = bc[i,0] + r*sin(0.5*anim_t*2.*pi)
+            bc[i,1] = bc[i,1] - r+r*cos(pi+0.5*anim_t*2.*pi)
+        elif S[b[i]] == 1:
+            r = mid[1]*0.15
+            bc[i,1] = bc[i,1] + r + r*cos(pi + 0.15*anim_t*2.*pi)
+            bc[i,2] = bc[i,2] - r*sin(0.15*anim_t*2.*pi)
+        elif S[b[i]] == 2:
+            r = mid[1]*0.15
+            bc[i,2] = bc[i,2] + r+r*cos(pi+0.35*anim_t*2.*pi)
+            bc[i,0] = bc[i,0] + r*sin(0.35*anim_t*2.*pi)
+
+    igl.arap_solve(bc,arap_data,U)
+    viewer.data.set_vertices(U)
+    viewer.data.compute_normals()
+
+    if viewer.core.is_animating:
+        anim_t += anim_t_dir
+
+    return False
+
+def key_down(viewer, key, mods):
+    if key == ord(' '):
+        viewer.core.is_animating = not viewer.core.is_animating
+        return True
+    return False
+
+igl.readOFF("../tutorial/shared/decimated-knight.off",V,F)
+U = igl.eigen.MatrixXd(V)
+igl.readDMAT("../tutorial/shared/decimated-knight-selection.dmat",S)
+
+# Vertices in selection
+
+b = igl.eigen.MatrixXi([[t[0] for t in [(i,S[i]) for i in range(0,V.rows())] if t[1] >= 0]]).transpose()
+
+# Centroid
+mid = 0.5*(V.colwiseMaxCoeff() + V.colwiseMinCoeff())
+
+# Precomputation
+arap_data.max_iter = 100
+igl.arap_precomputation(V,F,V.cols(),b,arap_data)
+
+# Set color based on selection
+C = igl.eigen.MatrixXd(F.rows(),3)
+purple = igl.eigen.MatrixXd([[80.0/255.0,64.0/255.0,255.0/255.0]])
+gold   = igl.eigen.MatrixXd([[255.0/255.0,228.0/255.0,58.0/255.0]])
+
+for f in range(0,F.rows()):
+    if S[F[f,0]]>=0 and S[F[f,1]]>=0 and S[F[f,2]]>=0:
+        C.setRow(f,purple)
+    else:
+        C.setRow(f,gold)
+
+# Plot the mesh with pseudocolors
+viewer = igl.viewer.Viewer()
+viewer.data.set_mesh(U, F)
+viewer.data.set_colors(C)
+viewer.callback_pre_draw = pre_draw
+viewer.callback_key_down = key_down
+viewer.core.is_animating = True
+viewer.core.animation_max_fps = 30.
+print("Press [space] to toggle animation")
+viewer.launch()

python/py_igl.cpp

@@ -34,6 +34,8 @@
 #include <igl/eigs.h>
 #include <igl/readOBJ.h>
 #include <igl/harmonic.h>
+#include <igl/arap.h>
+#include <igl/ARAPEnergyType.h>
 
 void python_export_igl(py::module &m)
 {
@@ -69,4 +71,6 @@ void python_export_igl(py::module &m)
 #include "py_igl/py_eigs.cpp"
 #include "py_igl/py_readOBJ.cpp"
 #include "py_igl/py_harmonic.cpp"
+#include "py_igl/py_ARAPEnergyType.cpp"
+#include "py_igl/py_arap.cpp"
 }

python/py_igl/py_ARAPEnergyType.cpp

@@ -0,0 +1,7 @@
+py::enum_<igl::ARAPEnergyType>(m, "ARAPEnergyType")
+    .value("ARAP_ENERGY_TYPE_SPOKES", igl::ARAP_ENERGY_TYPE_SPOKES)
+    .value("ARAP_ENERGY_TYPE_SPOKES_AND_RIMS", igl::ARAP_ENERGY_TYPE_SPOKES_AND_RIMS)
+    .value("ARAP_ENERGY_TYPE_ELEMENTS", igl::ARAP_ENERGY_TYPE_ELEMENTS)
+    .value("ARAP_ENERGY_TYPE_DEFAULT", igl::ARAP_ENERGY_TYPE_DEFAULT)
+    .value("NUM_ARAP_ENERGY_TYPES", igl::NUM_ARAP_ENERGY_TYPES)
+    .export_values();

python/py_igl/py_arap.cpp

@@ -0,0 +1,56 @@
+py::class_<igl::ARAPData> ARAPData(m, "ARAPData");
+
+ARAPData
+.def(py::init<>())
+.def_readwrite("n", &igl::ARAPData::n)
+.def_readwrite("energy", &igl::ARAPData::energy)
+.def_property("G",
+[](const igl::ARAPData& data) {return Eigen::MatrixXi(data.G);},
+[](igl::ARAPData& data, const Eigen::MatrixXi& G)
+{
+  assert_is_VectorX("G",G);
+  data.G = Eigen::VectorXi(G.cast<int>());
+})
+.def_readwrite("with_dynamics", &igl::ARAPData::with_dynamics)
+.def_readwrite("f_ext", &igl::ARAPData::f_ext)
+.def_readwrite("h", &igl::ARAPData::h)
+.def_readwrite("vel", &igl::ARAPData::vel)
+.def_readwrite("ym", &igl::ARAPData::ym)
+.def_readwrite("max_iter", &igl::ARAPData::max_iter)
+.def_readwrite("K", &igl::ARAPData::K)
+.def_readwrite("M", &igl::ARAPData::M)
+.def_readwrite("CSM", &igl::ARAPData::CSM)
+// .def_readwrite("solver_data", &igl::ARAPData::solver_data)
+.def_readwrite("dim", &igl::ARAPData::dim)
+.def_property("b",
+[](const igl::ARAPData& data) {return Eigen::MatrixXi(data.b);},
+[](igl::ARAPData& data, const Eigen::MatrixXi& b)
+{
+  assert_is_VectorX("b",b);
+  data.b = Eigen::VectorXi(b.cast<int>());
+})
+;
+
+m.def("arap_precomputation", []
+(
+  const Eigen::MatrixXd & V,
+  const Eigen::MatrixXi & F,
+  const int dim,
+  const Eigen::MatrixXi& b,
+  igl::ARAPData & data
+)
+{
+  return igl::arap_precomputation(V,F,dim,b,data);
+}, __doc_igl_arap,
+py::arg("V"), py::arg("F"), py::arg("dim"), py::arg("b"), py::arg("data"));
+
+m.def("arap_solve", []
+(
+  const Eigen::MatrixXd & bc,
+  igl::ARAPData & data,
+  Eigen::MatrixXd& U
+)
+{
+  return igl::arap_solve(bc,data,U);
+}, __doc_igl_arap,
+py::arg("bc"), py::arg("data"), py::arg("U"));