def test_copy_weights_vert_order_same_skeleton(self):
     source_cube, source_joints, source_skincluster = self.create_skinned_cube(
     )
     target_cube = self.create_cube()
     target_skincluster = skinutils.bind_mesh_to_joints(
         target_cube, source_joints)
     transform_values = dict(
         itertools.zip_longest(source_joints[:4], [0.25], fillvalue=0.25))
     transform_values[source_joints[-1]] = 0.0
     pm.skinPercent(source_skincluster,
                    source_cube.vtx[0],
                    transformValue=transform_values.items())
     source_weightedinfs = skinutils.get_weighted_influences(
         target_cube.vtx[0], target_skincluster)
     transform_values = dict(
         itertools.zip_longest(source_joints[1:], [0.25], fillvalue=0.25))
     transform_values[source_joints[0]] = 0.0
     pm.skinPercent(target_skincluster,
                    target_cube.vtx[0],
                    transformValue=transform_values.items())
     target_weightedinfs = skinutils.get_weighted_influences(
         target_cube.vtx[0], target_skincluster)
     self.assertNotEqual(source_weightedinfs, target_weightedinfs)
     skinutils.copy_weights_vert_order_inf_order(source_cube, target_cube,
                                                 source_skincluster,
                                                 target_skincluster)
     expected = skinutils.get_weighted_influences(source_cube.vtx[0],
                                                  source_skincluster)
     result = skinutils.get_weighted_influences(target_cube.vtx[0],
                                                target_skincluster)
     self.assertDictEqual(expected, result)
 def test_modifies_skinning(self):
     test_cube = self.create_cube()
     test_joints = [self.create_joint() for _ in range(5)]
     [pm.move(j, (1, 0, 0)) for j in test_joints]
     skinutils.bind_mesh_to_joints(test_cube,
                                   test_joints,
                                   maximumInfluences=1)
     start_infs = skinutils.get_weighted_influences(test_cube.vtx[0])
     self.assertEqual(1, len(start_infs))
     skinutils.apply_delta_mush_skinning(test_cube, cleanup=True)
     after_infs = skinutils.get_weighted_influences(test_cube.vtx[0])
     self.assertEqual(4, len(after_infs))
 def test_prune_exceeding_influences(self):
     test_cube = self.create_cube()
     test_joints = [self.create_joint() for _ in range(5)]
     skincl = skinutils.bind_mesh_to_joints(test_cube,
                                            test_joints,
                                            maximumInfluences=5)
     influences_to_weights = skinutils.get_weighted_influences(
         test_cube.vtx[0], skincl)
     skinutils.prune_exceeding_influences(test_cube.vtx[0], skincl,
                                          influences_to_weights)
     result = skinutils.get_weighted_influences(test_cube.vtx[0], skincl)
     self.assertEqual(4, len(result))
Esempio n. 4
0
 def test_export_referenced_mesh(self):
     ref_cube, ref_joints, ref_skincluster = self.create_skinned_cube()
     ref_cube_name = ref_cube.nodeName()
     pm.skinPercent(ref_skincluster,
                    ref_cube.vtx,
                    transformValue=(ref_joints[2], 1.0))
     with tempfile.TemporaryDirectory() as tempdir_name:
         # skin a cube and export it to a separate file
         ref_filename = os.path.join(tempdir_name, 'ref_test.ma')
         stuff = [ref_cube] + ref_joints
         pm.select(stuff, r=True)
         pm.exportSelected(ref_filename,
                           type='mayaAscii',
                           constructionHistory=True,
                           force=True)
         # clean scene then reference in the file just exported
         self._clean_scene()
         file_reference = pm.createReference(ref_filename)
         ref_nodes = file_reference.nodes()
         ref_cube = [
             r for r in ref_nodes if r.nodeName().endswith(ref_cube_name)
         ][0]
         # export the skin weights
         dest_filename = os.path.join(tempdir_name, 'test_weights.ma')
         skinio.export_skinned_mesh(ref_cube, dest_filename)
         # open the exported skin file
         pm.openFile(dest_filename, force=True)
         result_cube = skinutils.get_skinned_meshes_from_scene()[0]
         result_skincl = skinutils.get_skincluster(result_cube)
         result_joints = result_skincl.influenceObjects()
         result = skinutils.get_weighted_influences(result_cube.vtx[0])
         expected = {result_joints[2]: 1.0}
         self.assertEqual(expected, result)
 def test_get_non_zero_influences_from_vert(self):
     test_cube = self.create_cube()
     test_joints = [self.create_joint() for _ in range(5)]
     skincl = skinutils.bind_mesh_to_joints(test_cube,
                                            test_joints,
                                            maximumInfluences=5)
     non_zero_infs = skinutils.get_weighted_influences(
         test_cube.vtx[0], skincl)
     self.assertEqual(5, len(non_zero_infs))
 def test_prune_exceeding_skinned_mesh(self):
     test_cube = self.create_cube()
     test_joints = [self.create_joint() for _ in range(5)]
     skincl = skinutils.bind_mesh_to_joints(test_cube,
                                            test_joints,
                                            maximumInfluences=5)
     initial_influences = []
     for vert in test_cube.vtx:
         initial_inf = skinutils.get_weighted_influences(vert, skincl)
         initial_influences.append(len(initial_inf))
     expected_initial = [5, 5, 5, 5, 5, 5, 5, 5]
     self.assertListEqual(expected_initial, initial_influences)
     skinutils.prune_exceeding_skinned_mesh(test_cube, skincluster=skincl)
     results = []
     for vert in test_cube.vtx:
         result = skinutils.get_weighted_influences(vert, skincl)
         results.append(len(result))
     expected = [4, 4, 4, 4, 4, 4, 4, 4]
     self.assertListEqual(expected, results)
 def test_moves_weights_to_parent(self):
     test_cube, test_joints, skin_cluster = self.create_skinned_cube()
     values = [0, 0.25, 0.25, 0.25, 0.25]
     infs_to_wts = dict(zip(test_joints, values))
     with skinutils.max_influences_normalize_weights_disabled(skin_cluster):
         for vertex in test_cube.vtx:
             pm.skinPercent(skin_cluster,
                            vertex,
                            transformValue=infs_to_wts.items())
     skinutils.move_weight_and_remove_influence(test_joints[-1],
                                                test_joints[-2],
                                                skin_cluster)
     result = skinutils.get_weighted_influences(test_cube.vtx[0],
                                                skin_cluster)
     expected_values = [0.25, 0.25, 0.5]
     expected = dict(zip(test_joints[1:-1], expected_values))
     self.assertDictEqual(expected, result)
 def test_simple(self):
     source_test_cube, source_test_joints, source_skin_cluster = self.create_skinned_cube(
     )
     target_test_cube, target_test_joints, target_skin_cluster = self.create_skinned_cube(
     )
     inf_map = dict([
         (sj, [tj])
         for sj, tj in zip(source_test_joints, target_test_joints)
     ])
     for vertex in source_test_cube.vtx:
         pm.skinPercent(source_skin_cluster,
                        vertex,
                        transformValue=(source_test_joints[0], 1.0))
     skinutils.copy_weights_vert_order(source_test_cube, target_test_cube,
                                       inf_map)
     result = skinutils.get_weighted_influences(target_test_cube.vtx[0])
     expected = {target_test_joints[0]: 1.0}
     self.assertDictEqual(expected, result)
Esempio n. 9
0
 def test_copies_weights(self):
     test_cube, test_joints, test_skincluster = self.create_skinned_cube()
     skinio.import_skinning(test_cube, self.skin_path)
     result = skinutils.get_weighted_influences(test_cube.vtx[0])
     expected = {test_joints[2]: 1.0}
     self.assertEqual(expected, result)