Smpl model

SMPL Of python There are two versions on the official website , Namely SMPL_python_v.1.0.0,SMPL_python_v.1.1.0. The difference is that ：SMPL_python_v.1.0.0 Incomplete , Provided only 10 individual shape PCA coefficients Model of .SMPL_python_v.1.1.0 Provides 3 Personality 300shape PCA coefficients Model of .

With SMPL_python_v1.1.0 For example , It contains three models And operation models Basic script for .
The three models are male,female,netrual Of pkl Format model , With netrual For example , Let's take a look at the data structure .

import pickle
with open(model_path, 'rb') as f:
	smpl = pickle.load(f, encoding='latin1')

'J_regressor_prior': [24, 6890], scipy.sparse.csc.csc_matrix
#  face 
'f': [13776, 3], numpy.ndarray
# regressor array that is used to calculate the 3d joints from the position of the vertices
'J_regressor': [24, 6890], scipy.sparse.csc.csc_matrix
# indices of parents for each joints
'kintree_table': [2, 24], numpy.ndarray
'J': [24, 3], numpy.ndarray
'weights_prior': [6890, 24], numpy.ndarray
# linear blend skinning weights that represent how much the rotation matrix of each parr affects each vertex
'weights': [6890, 24], numpy.ndarray
# pose blend shape basis, pose PCA coefficients
'posedirs':	[6890, 3, 207], numpy.ndarray
'bs_style': 'lbs'
# the vertices of the template model
'v_template': [6890, 3], numpy.ndarray
# tensor of PCA shape displacements
'shapedirs': [6890, 3, 300], chumpy.ch.Ch
'bs_type': 'lrotmin'

def forward_shape(self, betas):
	v_shaped = self.v_template + blend_shapes(betas, self.shapedirs)
	return SMPLOutput(vertices=v_shaped, betas=betas, v_shaped=v_shaped)

def forward(self, betas, body_pose, global_orient, transl,
		return_verts=True, return_full_pose=False, pose2rot=True, **kwargs):
	full_pose = torch.cat([global_orient, body_pose], dim=1)

	vertices, joints = lbs(beta, full_pose, self.v_template, self.shapedirs,
			self.posedirs, self.J_regressor, self.parents, self.lbs_weights,
			pose2rot=pose2rot)

	return SMPLOutput(vertices, global_orient=global_orient, body_pose=body_pose,
		joints=joints, betas=betas, full_pose=full_pose)

The core is in lbs.py in .

# add shape contribution
v_shaped = v_template + blend_shapes(betas, shapedirs)
# Get the joints
J = vertices2joints(J_regressor, v_shaped)
# add pose blend shapes
ident = torch.eye(3, dtype=dtype, device=device)
pose_feature = pose[:, 1:].view(batch_size, -1, 3, 3) - ident
# [N, P] * [P, V*3] -> [N, V, 3]
pose_offsets = torch.matmul(pose_feature.view(batch_size, -1),
                                    posedirs).view(batch_size, -1, 3)
v_posed = pose_offsets + v_shaped
# Get the global joint location
rot_mats = pose.view(batch_size, -1, 3, 3)
J_transformed, A = batch_rigid_transform(rot_mats, J, parents, dtype=dtype)
# Do skinning
W = lbs_weights.unsqueeze(dim=0).expand([batch_size, -1, -1])
T = torch.matmul(W, A.view(batch_size, num_joints, 16)) \
        .view(batch_size, -1, 4, 4)
homogen_coord = torch.ones([batch_size, v_posed.shape[1], 1],
                            dtype=dtype, device=device)
v_posed_homo = torch.cat([v_posed, homogen_coord], dim=2)
v_homo = torch.matmul(T, torch.unsqueeze(v_posed_homo, dim=-1))

verts = v_homo[:, :, :3, 0]

The code order is shape blend shape + pose blend shape -> skinning. The return is 6890*3 Model vertices and n individual 3d Key point coordinates .
For $scipy.sparse.csc.csc\_matrix$ type , In the process of processing, it can be converted to $numpy.ndarray$ type .

def to_np(array, dtype=np.float32):
	if 'scipy.sparse' in str(type(array)):
		array = array.todense()
	return np.array(array, dtype=dtype)

SMPL and SMPL-H The topology of is the same .

python3 Unable to identify in chumpy.ch.Ch Format , For compatibility python3, You need to convert the data in this format into numpy.ndarray Format .

output_dict = {
    }
for key, data in body_data.iteritems():
if 'chumpy' in str(type(data)):
	output_dict[key] = np.array(data)
else:
	output_dict[key] = data

with open(out_path, 'wb') as f:
	pickle.dump(output_dict, f)

Some projects will use $J\_regressor\_extra.npy$ Add additional key points .

J_regressor_extra: [9, 6890], numpy.ndarray
extra_joints = vertice2joints(J_regressor_extra, smpl_output.vertices)
joints = torch.cat([smpl_output.joints, extra_joints], dim=1)