Merge pull request #153 from kishoreVen/direct-delta-mush-python

Direct delta mush python binding

Author: alecjacobson

cmake/PyiglDownloadExternal.cmake

@@ -37,7 +37,7 @@ function(pyigl_download_test_data)
 	pyigl_download_project(test_data
 		SOURCE_DIR "${PYLIBIGL_EXTERNAL}/../data"
 		GIT_REPOSITORY https://github.com/libigl/libigl-tests-data
-		GIT_TAG        fa8ee953a64a560f24553dd8bda0c6cd4fbb5353
+		GIT_TAG        19cedf96d70702d8b3a83eb27934780c542356fe
 	)
 endfunction()
 
@@ -46,7 +46,7 @@ function(pyigl_download_tutorial_data)
 	pyigl_download_project(tutorial_data
 		SOURCE_DIR "${PYLIBIGL_EXTERNAL}/../tutorial/data"
 		GIT_REPOSITORY https://github.com/libigl/libigl-tutorial-data
-		GIT_TAG        38bbed76692710af038b90c69bf33d6d0f99476d
+		GIT_TAG        c1f9ede366d02e3531ecbaec5e3769312f31cccd
 	)
 endfunction()
 

src/direct_delta_mush.cpp

@@ -0,0 +1,109 @@
+#include <common.h>
+#include <npe.h>
+#include <typedefs.h>
+#include <igl/direct_delta_mush.h>
+
+const char* ds_direct_delta_mush = R"igl_Qu8mg5v7(
+Perform Direct Delta Mush Skinning. 
+Computes Direct Delta Mesh Skinning (Variant 0) from 
+"Direct Delta Mush Skinning and Variants"
+
+Parameters
+----------
+v  #V by 3 list of rest pose vertex positions
+t  #E*4 by 3 list of bone pose transformations
+omega #V by #E*10 list of precomputated matrix values
+
+Returns
+-------
+u  #V by 3 list of output vertex positions
+
+See also
+--------
+
+
+Notes
+-----
+None
+
+Examples
+--------
+)igl_Qu8mg5v7";
+
+npe_function(direct_delta_mush)
+npe_doc(ds_direct_delta_mush)
+
+npe_arg(v, dense_double)
+npe_arg(t, dense_double)
+npe_arg(omega, dense_double)
+
+npe_begin_code()
+  assert_cols_equals(v, 3, "v");
+  assert_valid_bone_transforms(t, "t");
+  assert_rows_equals(t, (omega.cols() * 4) / 10, "t");
+
+  std::vector<Eigen::Affine3d, Eigen::aligned_allocator<Eigen::Affine3d>> 
+      t_affine(t.rows() / 4);
+  
+  for(int bone = 0; bone < t_affine.size(); ++bone)
+  {
+    t_affine[bone] = Eigen::Affine3d::Identity();
+    t_affine[bone].matrix().block(0, 0, 3, 4) = t.block(bone * 4, 0, 4, 3).transpose();
+  }
+
+  EigenDenseLike<npe_Matrix_v> u;
+  igl::direct_delta_mush(v, t_affine, omega, u);
+  return npe::move(u);
+
+npe_end_code()
+
+const char* ds_direct_delta_mush_precomp = R"igl_Qu8mg5v7(
+Do the Omega precomputation necessary for Direct Delta Mush Skinning.
+
+Parameters
+----------
+v  #V by 3 list of rest pose vertex positions
+f  #F by 3 list of triangle indices into rows of V
+w  #V by #Edges list of weights
+p  number of smoothing iterations
+lambda  rotation smoothing step size
+kappa   translation smoothness step size
+alpha   translation smoothness blending weight
+
+Returns
+-------
+omega : #V by #E*10 list of precomputated matrix values
+
+See also
+--------
+
+
+Notes
+-----
+None
+
+Examples
+--------
+)igl_Qu8mg5v7";
+
+npe_function(direct_delta_mush_precomputation)
+npe_doc(ds_direct_delta_mush_precomp)
+
+npe_arg(v, dense_double)
+npe_arg(f, dense_int, dense_long, dense_longlong)
+npe_arg(w, npe_matches(v))
+npe_arg(p, int)
+npe_arg(lambda, double)
+npe_arg(kappa, double)
+npe_arg(alpha, double)
+
+npe_begin_code()
+  assert_valid_3d_tri_mesh(v, f);
+
+  Eigen::MatrixXd w_copy = w.template cast<double>();
+
+  EigenDenseLike<npe_Matrix_v> omega;
+  igl::direct_delta_mush_precomputation(v, f, w_copy, p, lambda, kappa, alpha, omega);
+  return npe::move(omega);
+  
+npe_end_code()

src/include/common.h

@@ -311,3 +311,21 @@ void assert_valid_2d_tri_mesh(const TV& v, const TF& f, std::string v_name="v",
                                     ".shape = [" + std::to_string(f.rows()) + ", " + std::to_string(f.cols()) + "]");
     }
 }
+
+template <typename TV>
+void assert_valid_bone_transforms(const TV& t, std::string t_name="t") {
+    if (t.rows() <= 0) {
+        throw pybind11::value_error("Invalid number of transforms, " + t_name + " has zero rows (" + t_name +
+                                    ".shape = [" + std::to_string(t.rows()) + ", " + std::to_string(t.cols()) + "]) ");
+    }
+    
+    if (t.cols() != 3) {
+        throw pybind11::value_error("Invalid number of cols in transforms, " + t_name + " must have shape [#bones * 4, 3] but got " + t_name +
+                                    ".shape = [" + std::to_string(t.rows()) + ", " + std::to_string(t.cols()) + "]");
+    }
+
+    if (t.rows() % 4 != 0) {
+        throw pybind11::value_error("Invalid number of rows in transforms, " + t_name + " must have shape [#bones * 4, 3] but got " + t_name +
+                                    ".shape = [" + std::to_string(t.rows()) + ", " + std::to_string(t.cols()) + "].");   
+    }
+}

tests/test_basic.py

@@ -1531,6 +1531,40 @@ def test_lbs_matrix(self):
         self.assertTrue(M.shape[0] == V.shape[0])
         self.assertTrue(M.shape[1] == W.shape[1]*4)
 
+    def test_direct_delta_mush(self):
+        V, F = igl.read_triangle_mesh(os.path.join(self.test_path, "arm.obj"))
+        W = igl.read_dmat(os.path.join(self.test_path, "arm-weights.dmat"))
+        _, BE, _, _, _, _ = igl.read_tgf(os.path.join(self.test_path, "arm.tgf"))
+
+        # Use same values as tutorial
+        # https://github.com/libigl/libigl/blob/main/tutorial/408_DirectDeltaMush/main.cpp
+        p = 20
+        l = 3
+        k = 1
+        a = 0.8
+        omega = igl.direct_delta_mush_precomputation(V, F,W, p, l, k, a)
+
+        self.assertTrue(omega.shape[0] == V.shape[0])
+        self.assertTrue(omega.shape[1] == BE.shape[0] * 10)
+        self.assertTrue(omega.dtype == np.double)
+
+        T = np.zeros((BE.shape[0]*4, 3))
+        I = np.eye(3)
+        for i in range(0, T.shape[0], 4):
+            T[i:i+3, :] = I
+
+        U = igl.direct_delta_mush(V, T, omega)
+
+        self.assertTrue(U.shape[0] == V.shape[0])
+        self.assertTrue(U.shape[1] == 3)
+        self.assertTrue(U.dtype == np.double)
+        self.assertFalse(np.isnan(U).any())
+    
+    def test_direct_delta_mush_precomputation(self):
+        # covered in test_direct_delta_mush
+        pass
+
+
     def test_point_mesh_squared_distance(self):
         dist, i, c = igl.point_mesh_squared_distance(
             np.array([0., 0., 0.]), self.v1, self.f1)