def load_model(fname_or_dict):
dd = ready_arguments(fname_or_dict)
args = {
'pose': dd['pose'],
'v': dd['v_posed'],
'J': dd['J'],
'weights': dd['weights'],
'kintree_table': dd['kintree_table'],
'xp': ch,
'want_Jtr': True,
'bs_style': dd['bs_style']
}
result, Jtr = verts_core(**args)
result = result + dd['trans'].reshape((1, 3))
result.J_transformed = Jtr + dd['trans'].reshape((1, 3))
for k, v in dd.items():
setattr(result, k, v)
return result
#m= load_model( '../models/basicModel_f_lbs_10_207_0_v1.0.0.pkl' )
def load_model(fname_or_dict, params=None):
dd = ready_arguments(fname_or_dict)
#save_model_json(fname_or_dict)
#stop
#dd['pose'][5] = 0.78
args = {
'pose': dd['pose'],
'v': dd['v_posed'],
'J': dd['J'],
'weights': dd['weights'],
'kintree_table': dd['kintree_table'],
'xp': ch,
'want_Jtr': True,
'bs_style': dd['bs_style'],
}
#global tmp
#tmp+=0.5
#print tmp
dd['betas'][3] = 20
args2 = {
'trans': dd['trans'],
'pose': dd['pose'],
'v_template': dd['v_template'],
'J': dd['J_regressor'],
'weights': dd['weights'],
'kintree_table': dd['kintree_table'],
'bs_style': dd['bs_style'],
'f': dd['f'],
'bs_type': dd['bs_type'],
'posedirs': dd['posedirs'],
'betas': dd['betas'],
'shapedirs': dd['shapedirs'],
'want_Jtr': True
}
# FOR SHAPE
return verts_decorated(**args2)
# pose, v, J, weights, kintree_table, want_Jtr, xp
result, Jtr = verts_core(**args)
result = result + dd['trans'].reshape((1, 3))
result.J_transformed = Jtr + dd['trans'].reshape((1, 3))
#print result.J_transformed.shape
for k, v in dd.items():
setattr(result, k, v)
return result
def load_model(fname_or_dict,
ncomps=6,
flat_hand_mean=False,
v_template=None,
use_pca=True):
''' This model loads the fully articulable HAND SMPL model,
and replaces the pose DOFS by ncomps from PCA'''
from verts import verts_core
import numpy as np
import chumpy as ch
import pickle
import scipy.sparse as sp
np.random.seed(1)
if not isinstance(fname_or_dict, dict):
smpl_data = pickle.load(open(fname_or_dict))
else:
smpl_data = fname_or_dict
rot = 3 # for global orientation!!!
if use_pca:
hands_components = smpl_data[hands_components] # PCA components
else:
hands_components = np.eye(
45) # directly modify 15x3 articulation angles
hands_mean = np.zeros(hands_components.shape[1]
) if flat_hand_mean else smpl_data['hands_mean']
hands_coeffs = smpl_data['hands_coeffs'][:, :ncomps]
selected_components = np.vstack((hands_components[:ncomps]))
hands_mean = hands_mean.copy()
pose_coeffs = ch.zeros(rot + selected_components.shape[0])
full_hand_pose = pose_coeffs[rot:(rot + ncomps)].dot(selected_components)
smpl_data['fullpose'] = ch.concatenate(
(pose_coeffs[:rot], hands_mean + full_hand_pose))
smpl_data['pose'] = pose_coeffs
Jreg = smpl_data['J_regressor']
if not sp.issparse(Jreg):
smpl_data['J_regressor'] = (sp.csc_matrix(
(Jreg.data, (Jreg.row, Jreg.col)), shape=Jreg.shape))
# slightly modify ready_arguments to make sure that it uses the fullpose
# (which will NOT be pose) for the computation of posedirs
dd = ready_arguments(smpl_data, posekey4vposed='fullpose')
# create the smpl formula with the fullpose,
# but expose the PCA coefficients as smpl.pose for compatibility
args = {
'pose': dd['fullpose'],
'v': dd['v_posed'],
'J': dd['J'],
'weights': dd['weights'],
'kintree_table': dd['kintree_table'],
'xp': ch,
'want_Jtr': True,
'bs_style': dd['bs_style'],
}
result_previous, meta = verts_core(**args)
result = result_previous + dd['trans'].reshape((1, 3))
result.no_translation = result_previous
if meta is not None:
for field in ['Jtr', 'A', 'A_global', 'A_weighted']:
if (hasattr(meta, field)):
setattr(result, field, getattr(meta, field))
if hasattr(result, 'Jtr'):
result.J_transformed = result.Jtr + dd['trans'].reshape((1, 3))
for k, v in dd.items():
setattr(result, k, v)
if v_template is not None:
result.v_template[:] = v_template
result.dd = dd
return result
def load_model(fname_or_dict='./models/SMPLH_female.pkl',
ncomps=12,
flat_hand_mean=False,
v_template=None,
mano_path='./smpl_data/mano_v1_2/models/'):
''' This model loads the fully articulable SMPL model,
and replaces the 156-prefix last DOFS by ncomps from PCA'''
# import imp
# lm = imp.load_source('verts_core',
# './smpl_data/mano_v1_2/webuser/verts.py')
# from smpl_data.mano_v1_2.verts import verts_core
from os.path import dirname, relpath
import numpy as np
import chumpy as ch
import pickle
import scipy.sparse as sp
import sys
import os
dir_path = dirname(relpath(__file__))
sys.path.insert(1, dir_path)
from verts import verts_core
np.random.seed(1)
if not isinstance(fname_or_dict, dict):
# smpl_data = pickle.load(open(fname_or_dict))
smpl_data = pickle.load(open(fname_or_dict, 'rb'), encoding='latin1')
else:
smpl_data = fname_or_dict
body_pose_dofs = 66
with open(os.path.join(mano_path, 'MANO_LEFT.pkl'), 'rb') as infile:
manoLeft = pickle.load(infile, encoding='latin1')
hands_componentsl = manoLeft['hands_components']
hands_meanl = np.zeros(hands_componentsl.shape[1]
) if flat_hand_mean else manoLeft['hands_mean']
hands_coeffsl = manoLeft['hands_coeffs'][:, :ncomps // 2]
with open(os.path.join(mano_path, 'MANO_RIGHT.pkl'), 'rb') as infile:
manoRight = pickle.load(infile, encoding='latin1')
hands_componentsr = manoRight['hands_components']
hands_meanr = np.zeros(hands_componentsl.shape[1]
) if flat_hand_mean else manoRight['hands_mean']
hands_coeffsr = manoRight['hands_coeffs'][:, :ncomps // 2]
selected_components = np.vstack(
(np.hstack((hands_componentsl[:ncomps // 2],
np.zeros_like(hands_componentsl[:ncomps // 2]))),
np.hstack((np.zeros_like(hands_componentsr[:ncomps // 2]),
hands_componentsr[:ncomps // 2]))))
hands_mean = np.concatenate((hands_meanl, hands_meanr))
pose_coeffs = ch.zeros(body_pose_dofs + selected_components.shape[0])
full_hand_pose = pose_coeffs[body_pose_dofs:(
body_pose_dofs + ncomps)].dot(selected_components)
smpl_data['fullpose'] = ch.concatenate(
(pose_coeffs[:body_pose_dofs], hands_mean + full_hand_pose))
smpl_data['pose'] = pose_coeffs
Jreg = smpl_data['J_regressor']
if not sp.issparse(Jreg):
smpl_data['J_regressor'] = (sp.csc_matrix(
(Jreg.data, (Jreg.row, Jreg.col)), shape=Jreg.shape))
# very slightly modify ready_arguments to make sure that it uses the fullpose (which will NOT be pose) for the computation of posedirs
dd = ready_arguments(smpl_data, posekey4vposed='fullpose')
# create the smpl formula with the fullpose,
# but expose the PCA coefficients as smpl.pose for compatibility
args = {
'pose': dd['fullpose'],
'v': dd['v_posed'],
'J': dd['J'],
'weights': dd['weights'],
'kintree_table': dd['kintree_table'],
'xp': ch,
'want_Jtr': True,
'bs_style': dd['bs_style'],
}
result_previous, meta = verts_core(**args)
result = result_previous + dd['trans'].reshape((1, 3))
result.no_translation = result_previous
if meta is not None:
for field in ['Jtr', 'A', 'A_global', 'A_weighted']:
if (hasattr(meta, field)):
setattr(result, field, getattr(meta, field))
if hasattr(result, 'Jtr'):
result.J_transformed = result.Jtr + dd['trans'].reshape((1, 3))
for k, v in dd.items():
setattr(result, k, v)
#################################
result.fullpose = dd['fullpose']
#################################
if (hasattr(result, 'pose_subjects')):
# assign random instances of hand poses to the original flat-handed training poses
for ipsub, psub in enumerate(result.pose_subjects):
for iframe, pose_parm in enumerate(psub['pose_parms']):
# posep = np.concatenate((pose_parm[:body_pose_dofs],
# 2.*np.random.randn(ncomps)))
lidx = np.random.randint(len(hands_coeffsl))
ridx = np.random.randint(len(hands_coeffsr))
posep = np.concatenate(
(pose_parm[:body_pose_dofs], hands_coeffsl[lidx],
hands_coeffsr[ridx]))
result.pose_subjects[ipsub]['pose_parms'][iframe] = posep
result.part2num = {
'global': 0,
'head': 15,
'leftCalf': 4,
'leftFoot': 7,
'leftForeArm': 18,
'leftHand': 20,
'leftShoulder': 13,
'leftThigh': 1,
'leftToes': 10,
'leftUpperArm': 16,
'neck': 12,
'rightCalf': 5,
'rightFoot': 8,
'rightForeArm': 19,
'rightHand': 21,
'rightShoulder': 14,
'rightThigh': 2,
'rightToes': 11,
'rightUpperArm': 17,
'spine': 3,
'spine1': 6,
'spine2': 9
}
body_parts = len(result.part2num)
hand_count = 0
for side in ('l', 'r'):
for part in ('Index', 'Middle', 'Pinky', 'Ring', 'Thumb'):
for iphalanx in range(3):
result.part2num['%s%s%d' %
(side, part,
iphalanx)] = body_parts + hand_count
hand_count += 1
if v_template is not None:
result.v_template[:] = v_template
return result
