def test_simple(self):
source_cube = self.create_cube()
target_cube = self.create_cube()
source_joints = [self.create_joint() for _ in range(5)]
[pm.move(j, (0.1, 0.1, 0.1)) for j in source_joints]
source_skincl = skinutils.bind_mesh_to_joints(source_cube,
source_joints)
expected = [
pm.skinPercent(source_skincl, v, value=True, q=True)
for v in source_cube.vtx
]
pm.select(clear=True)
target_joints = [self.create_joint() for _ in range(5)]
[pm.move(j, (0.1, 0.1, 0.1)) for j in target_joints]
target_skincl = skinutils.bind_mesh_to_joints(target_cube,
target_joints)
pm.skinPercent(target_skincl,
target_cube.vtx,
transformValue=(target_joints[-1], 1.0))
skinutils.copy_weights(source_cube, target_cube)
result = [
pm.skinPercent(source_skincl, v, value=True, q=True)
for v in source_cube.vtx
]
for e, r in zip(expected, result):
[
self.assertAlmostEqual(expected_weight, result_weight)
for expected_weight, result_weight in zip(e, r)
]
def test_normalizes_weights(self):
source_cube = self.create_cube()
target_cube = self.create_cube()
test_joints = [self.create_joint() for _ in range(5)]
skinutils.bind_mesh_to_joints(source_cube, test_joints)
target_skincl = skinutils.bind_mesh_to_joints(target_cube, test_joints)
target_skincl.setNormalizeWeights(False)
pm.skinPercent(target_skincl,
target_cube.vtx,
transformValue=(test_joints[-1], 2.0))
weights = [
sum(pm.skinPercent(target_skincl, v, value=True, q=True))
for v in target_cube.vtx
]
[self.assertLess(1.0, w) for w in weights]
self.scene_nodes.append(skinutils.apply_delta_mush(source_cube))
target_skincl = skinutils.bake_deformer_to_skin(source_cube,
target_cube,
cleanup=True)
# target_skincl.forceNormalizeWeights()
weights = [
sum(pm.skinPercent(target_skincl, v, value=True, q=True))
for v in target_cube.vtx
]
[self.assertGreaterEqual(1.0, w) for w in weights]
def test_two_skeletons(self):
source_cube = self.create_cube()
target_cube = self.create_cube()
source_joints = [self.create_joint() for _ in range(5)]
pm.select(clear=True)
target_joints = [self.create_joint() for _ in range(5)]
skinutils.bind_mesh_to_joints(source_cube, source_joints)
target_skincl = skinutils.bind_mesh_to_joints(target_cube,
target_joints)
self.scene_nodes.append(skinutils.apply_delta_mush(source_cube))
pm.skinPercent(target_skincl,
target_cube.vtx,
transformValue=(target_joints[-1], 1.0))
previous_val = pm.skinPercent(target_skincl,
target_cube.vtx[0],
query=True,
transform=target_joints[-1])
# pm.skinPercent(skincluster, vertex, transformValue=pruned_infs_to_weights.items())
target_skincl = skinutils.bake_deformer_to_skin(
source_cube, target_cube, source_joints, target_joints)
result = pm.skinPercent(target_skincl,
target_cube.vtx[0],
query=True,
transform=target_joints[-1])
self.assertNotEqual(previous_val, result)
def test_multiple_bind_poses_on_skel(self):
test_cube, test_joints, test_skincluster = self.create_skinned_cube()
expected = pm.ls(type='dagPose')[0]
dummy_cube = self.create_cube()
test_joints[2].rotateX.set(30)
skinutils.bind_mesh_to_joints(dummy_cube, test_joints)
pm.dagPose(test_joints[0], bindPose=True, save=True)
bind_poses = pm.ls(type='dagPose')
self.assertEqual(3, len(bind_poses))
result = skinutils.get_bind_pose_from_skincluster(test_skincluster)
self.assertEqual(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_respects_max_influences(self):
source_cube = self.create_cube()
target_cube = self.create_cube()
test_joints = [self.create_joint() for _ in range(5)]
skinutils.bind_mesh_to_joints(source_cube, test_joints)
skinutils.bind_mesh_to_joints(target_cube, test_joints)
self.scene_nodes.append(skinutils.apply_delta_mush(source_cube))
expected = 3
target_skincl = skinutils.bake_deformer_to_skin(
source_cube, target_cube, max_influences=expected)
result = target_skincl.getMaximumInfluences()
self.assertEqual(expected, result)
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_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_maintains_max_influences_default_four(self):
skincl = skinutils.bind_mesh_to_joints(self.test_cube,
self.test_joints)
inf_values = pm.skinPercent(skincl,
self.test_cube.vtx[0],
q=True,
value=True)
inf_count = len([i for i in inf_values if i != 0.0])
self.assertEqual(4, inf_count)
def test_zero_bad_verts(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=4)
skincl.setNormalizeWeights(2) # 2 == post normalize method
result = skinutils.get_non_normalized_vert_indexes(
test_cube.vtx, skincl)
self.assertEqual(0, len(result))
def test_skinned_curve_in_scene(self):
"""
Should only return skinned meshes in the scene. Not skinned curves.
"""
test_skinned_cubes = [self.create_cube() for x in range(3)]
test_curve = self.pm.curve(p=[(0, 0, 0), (3, 5, 6), (5, 6, 7), (9, 9,
9)])
test_joints = [self.create_joint() for _ in range(5)]
curve_skincl = skinutils.bind_mesh_to_joints(test_curve, test_joints)
skinclusters = []
for each in test_skinned_cubes:
skincl = skinutils.bind_mesh_to_joints(each,
test_joints,
maximumInfluences=5)
skinclusters.append(skincl)
skinned_meshes_from_scene = skinutils.get_skinned_meshes_from_scene()
skinned_meshes_from_scene.sort()
test_skinned_cubes.sort()
self.assertListEqual(test_skinned_cubes, skinned_meshes_from_scene)
def test_no_bad_verts(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=4)
flagged_vert_indexes = skinutils.get_vert_indexes_with_exceeding_influences(
test_cube, skin_cluster=skincl, max_influences=4)
flagged_verts = [test_cube.vtx[i] for i in flagged_vert_indexes.keys()]
self.assertListEqual([], flagged_verts)
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))
def test_multiple_mats_assigned_to_skinned_mesh(self):
test_skinned_cube = self.create_cube()
test_joints = [self.create_joint() for _ in range(5)]
skincl = skinutils.bind_mesh_to_joints(test_skinned_cube,
test_joints,
maximumInfluences=5)
mat1, _ = matutils.create_material('foo')
mat2, _ = matutils.create_material('bar')
matutils.assign_material(test_skinned_cube, mat1)
matutils.assign_material(test_skinned_cube.f[0], mat2)
skinned_meshes_from_scene = skinutils.get_skinned_meshes_from_scene()
self.assertListEqual([test_skinned_cube], skinned_meshes_from_scene)
def test_one_bad_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=4)
skincl.setNormalizeWeights(2) # 2 == post normalize method
pm.skinPercent(skincl,
test_cube.vtx[0],
transformValue=(test_joints[0], 1.5))
result = skinutils.get_non_normalized_vert_indexes(
test_cube.vtx, skincl)
self.assertEqual(1, len(result))
def test_get_verts_with_more_than_four_infs(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)
flagged_vert_indexes = skinutils.get_vert_indexes_with_exceeding_influences(
test_cube, skin_cluster=skincl, max_influences=4)
flagged_verts = [test_cube.vtx[i] for i in flagged_vert_indexes.keys()]
flagged_verts.sort()
expected = list(test_cube.vtx)
expected.sort()
self.assertListEqual(expected, flagged_verts)
def setUp(self):
super(TestMoveWeights, self).setUp()
test_cube = self.create_cube()
test_joints = [self.create_joint() for _ in range(5)]
self.skincl = skinutils.bind_mesh_to_joints(test_cube,
test_joints,
maximumInfluences=4)
self.vert = test_cube.vtx[0]
self.origin_inf = test_joints[0]
self.destination_inf = test_joints[1]
self.initial_origin_weight = self.pm.skinPercent(
self.skincl, self.vert, q=True, transform=self.origin_inf)
self.initial_destination_weight = self.pm.skinPercent(
self.skincl, self.vert, q=True, transform=self.destination_inf)
def test_does_not_export_extra_stuff(self):
test_cube, test_joints, test_skincluster = self.create_skinned_cube()
second_cube = self.create_cube()
skinutils.bind_mesh_to_joints(second_cube, test_joints)
sms = skinutils.get_skinned_meshes_from_scene()
self.assertEqual(2, len(sms))
fake_rig_controller = self.create_transform_node()
pm.parentConstraint(fake_rig_controller, test_joints[0])
with tempfile.TemporaryDirectory() as tempdir_name:
dest_filename = os.path.join(tempdir_name, 'test_weights.ma')
skinio.export_skinned_mesh(test_cube, dest_filename)
pm.openFile(dest_filename, force=True)
result_cube = skinutils.get_skinned_meshes_from_scene()
self.assertEqual(1, len(result_cube))
default_trash = [x.getParent() for x in pm.ls(cameras=True)]
default_trash.extend(pm.ls(type='joint'))
stuff = [
x for x in pm.ls(type='transform') if x not in default_trash
]
# [x for x in pm.ls(type='transform') if x not in pm.ls(defaultNodes=True, cameras=True)]
self.assertEqual(1, len(stuff))
constraints = pm.ls(type='parentConstraint')
self.assertEqual(0, len(constraints))
def test_get_skinned_meshes_from_scene(self):
test_skinned_cubes = [self.create_cube() for x in range(3)]
test_cube = self.create_cube()
test_joints = [self.create_joint() for _ in range(5)]
skinclusters = []
for each in test_skinned_cubes:
skincl = skinutils.bind_mesh_to_joints(each,
test_joints,
maximumInfluences=5)
skinclusters.append(skincl)
skinned_meshes_from_scene = skinutils.get_skinned_meshes_from_scene()
skinned_meshes_from_scene.sort()
test_skinned_cubes.sort()
self.assertListEqual(test_skinned_cubes, skinned_meshes_from_scene)
def test_returns_total(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=4)
skincl.setNormalizeWeights(2) # 2 == post normalize method
pm.skinPercent(skincl,
test_cube.vtx[0],
transformValue=(test_joints[0], 1.5))
pm.skinPercent(skincl,
test_cube.vtx[1],
transformValue=(test_joints[0], 1.5))
expected = {0: 2.25, 1: 2.25}
result = skinutils.get_non_normalized_vert_indexes(
test_cube.vtx, skincl)
self.assertDictEqual(expected, result)
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_returns_skincluster(self):
skincl = skinutils.bind_mesh_to_joints(self.test_cube,
self.test_joints)
self.assertIsNotNone(skincl)
def test_extra_joints_in_skeleton(self):
skincl = skinutils.bind_mesh_to_joints(self.test_cube,
self.test_joints[2:4])
result = skincl.influenceObjects()
self.assertListEqual(self.test_joints[2:4], result)
def test_get_root_joint_from_skinned_mesh(self):
test_cube = self.create_cube()
test_joints = [self.create_joint() for _ in range(5)]
skinutils.bind_mesh_to_joints(test_cube, test_joints)
result = skinutils.get_root_joint_from_skinned_mesh(test_cube)
self.assertEqual(test_joints[0], result)
def test_raises_with_no_mesh_to_skin(self):
self.assertRaises(
RuntimeError,
lambda: skinutils.bind_mesh_to_joints(None, self.test_joints))
def test_raises_with_no_joint(self):
self.assertRaises(
RuntimeError,
lambda: skinutils.bind_mesh_to_joints(self.test_cube, None))
