def _init_model(self, g): pose = None betas = None trans = None if self.model is not None: pose = self.model.pose.r betas = self.model.betas.r trans = self.model.trans.r if g == 'f': self.model = load_model( 'smpl/models/basicModel_f_lbs_10_207_0_v1.1.0.pkl') else: self.model = load_model( 'smpl/models/basicmodel_m_lbs_10_207_0_v1.1.0.pkl') self._loaded_gender = g if pose is not None: self.model.pose[:] = pose self.model.betas[:] = betas self.model.trans[:] = trans self.light.set(v=self.model, f=self.model.f, num_verts=len(self.model)) self.rn.set(v=self.model, f=self.model.f) self.camera.set(v=self.model) self.joints2d.set(v=self.model.J_transformed) self.draw()
def test_our(img_path, joint_path, out_path="test.pkl", use_interpenetration=True, n_betas=10, flength=5000., pix_thsh=25., use_neutral=False, viz=True): with open('lsp_gender.csv') as f: genders = f.readlines() model_female = load_model(MODEL_FEMALE_PATH) model_male = load_model(MODEL_MALE_PATH) out_path = out_path + ".pkl" print img_path img = cv2.imread(img_path) gender = 'male' data = np.load(joint_path)['pose'] joint = [] for i in range(len(data[0])): joint.append([data[0][i], data[1][i]]) conf = data[2] do_degrees = [0.] joint = np.array(joint) sph_regs = None params, vis = run_single_fit(img, joint, conf, model_male, regs=sph_regs, n_betas=n_betas, flength=flength, pix_thsh=pix_thsh, scale_factor=1, viz=viz, do_degrees=do_degrees) if viz: import matplotlib.pyplot as plt plt.ion() plt.show() plt.subplot(121) plt.imshow(img[:, :, ::-1]) if do_degrees is not None: for di, deg in enumerate(do_degrees): plt.subplot(122) plt.cla() plt.imshow(vis[di]) plt.draw() plt.title('%d deg' % deg) plt.pause(1) with open(out_path, 'w') as outf: pickle.dump(params, outf) # This only saves the first rendering. if do_degrees is not None: cv2.imwrite(out_path.replace('.pkl', '.png'), vis[0])
def __init__(self): super(self.__class__, self).__init__() self.setupUi(self) self.setWindowTitle('DANCE HELPER') self.file_name = '' self.frame = -1 self.processOn = False self.file_paths = [] self.isFirst = True self.compared = False self.mode1 = 0 self.mode2 = 0 self.m = load_model( './models/smpl/basicModel_f_lbs_10_207_0_v1.0.0.pkl') self.m2 = load_model( './models/smpl/basicModel_f_lbs_10_207_0_v1.0.0.pkl') self.pkl_paths = [] self.pkl_paths2 = [] self.op_joints = [] self.op_joints2 = [] self.ind = 0 self.ind2 = 0 self.rotx = 0.0 self.roty = 0.0 self.rotz = 0.0 self.rotx2 = 0.0 self.roty2 = 0.0 self.rotz2 = 0.0 self.res = None self.res2 = None self.img = None self.img2 = None self.w = None self.h = None self.w2 = None self.h2 = None self.label_sim_title.hide() model_temp = QStandardItemModel() RESULT_DIR = 'opmlify/result' for dirpath, dirname, filename in os.walk(RESULT_DIR): if self.isFirst: self.isFirst = False for a in dirname: model_temp.appendRow(QStandardItem(a)) self.file_paths.append(RESULT_DIR + '/' + a) self.listView1.setModel(model_temp) self.listView2.setModel(model_temp) atexit.register(self.exit_handler)
def load_smpl(gender='female'): from os.path import join path = '/home/alfred/smpl/models/' if gender == 'female': fname_female = 'basicModel_f_lbs_10_207_0_v1.0.0.pkl' m = load_model(join(path, fname_female)) else: fname_male = 'basicmodel_m_lbs_10_207_0_v1.0.0.pkl' m = load_model(join(path, fname_male)) return m
def visualize_result_single(self, start, end, res_dir, render_util): from smpl_webuser.serialization import load_model smpl_origin = load_model( osp.join(self.model_root, 'smpl_cocoplus_neutral.pkl')) for i, result in enumerate(self.pred_results[start:end]): # get result subdir path and image file path img_path = self.data_list[result['data_idx']]['image_path'] img_name = img_path.split('/')[-1] subdir = eval_utils.get_subdir(img_path) res_subdir = osp.join(res_dir, subdir) res_img_path = osp.join(res_subdir, img_name) # render predicted smpl to image img = eval_utils.pad_and_resize(cv2.imread(img_path)) render_img = render_util.render_smpl_to_image( img.copy(), result['vis_verts'], result['cam'], self.renderer) render_img = np.concatenate((img, render_img), axis=1) blank_img = np.ones((224, 224, 3), dtype=np.uint8) render_img = np.concatenate((render_img, blank_img), axis=1) # render predicted smpl in multi-view smpl = copy.deepcopy(smpl_origin) render_pred_smpl = render_util.render_image( smpl, result['smpl_pose'], result['smpl_shape']) # save image res_img = np.concatenate((render_img, render_pred_smpl), axis=0) cv2.imwrite(res_img_path, res_img) if i % 10 == 0: print("{} Processed:{}/{}".format( os.getpid(), i, len(self.pred_results[start:end])))
def make_prdicted_mesh_neutral(predicted_params_path, flame_model_path): params = np.load(predicted_params_path, allow_pickle=True, encoding='latin1') #print(params) params = params[()] pose = np.zeros(15) #expression = np.zeros(100) shape = np.hstack( (params['shape'], np.zeros(300 - params['shape'].shape[0]))) #pose = np.hstack((params['pose'], np.zeros(15-params['pose'].shape[0]))) expression = np.hstack( (params['expression'], np.zeros(100 - params['expression'].shape[0]))) flame_genral_model = load_model(flame_model_path) generated_neutral_mesh = verts_decorated( #ch.array([0.0,0.0,0.0]), ch.array(params['cam']), ch.array(pose), ch.array(flame_genral_model.r), flame_genral_model.J_regressor, ch.array(flame_genral_model.weights), flame_genral_model.kintree_table, flame_genral_model.bs_style, flame_genral_model.f, bs_type=flame_genral_model.bs_type, posedirs=ch.array(flame_genral_model.posedirs), betas=ch.array( np.hstack((shape, expression)) ), #betas=ch.array(np.concatenate((theta[0,75:85], np.zeros(390)))), # shapedirs=ch.array(flame_genral_model.shapedirs), want_Jtr=True) # neutral_mesh = Mesh(v=generated_neutral_mesh.r, f=generated_neutral_mesh.f) neutral_mesh = trimesh.Trimesh(vertices=generated_neutral_mesh.r, faces=generated_neutral_mesh.f) return neutral_mesh
def main(): args = parse_args() #dataset_size = 1000 #dataloader = load_data(args.dataset_size, args) device = torch.device("cuda:%d" % args.gpu if torch.cuda.is_available() else "cpu") num_output = 82 model = myresnet50(device, num_output=num_output, use_pretrained=True, num_views=args.num_views) gender = 'male' m = load_model('../../models/basicModel_%s_lbs_10_207_0_v1.0.0.pkl' % gender[0]) #parent_dic = "/home/yifu/workspace/data_smpl/A_pose_3/new_vertexes" #parent_dic = "/home/yifu/workspace/data_smpl/A_pose_4/scaled" parent_dic = "/home/yifu/workspace/Data/MPI-FAUST/training/registrations_obj/male/test_model_2" #path = "./trained_resnet.pth" save_name = 'trained_resnet_%d_%d.pth' % (num_output, 100000) path = os.path.join(parent_dic, save_name) model.load_state_dict(torch.load(path)) #parent_dic = "/home/yifu/workspace/data_smpl/A_pose_3" #path = os.path.join(parent_dic, 'test') ''' parent_dic = "/home/yifu/workspace/data_smpl/real_human" path = os.path.join(parent_dic, 'scaled') ''' path = parent_dic evaluate_model(m, model, args.num_views, path, device, args)
def __init__(self, model_path): # Load SMPL model (here we load the female model) self.body = load_model(model_path) self.num_cam = 3 self.num_theta = 72 self.num_beta = 10
def output_FLAME_meshes(flame_model_fname, params_fname, out_path): ''' Reconstruct meshes given a sequence of FLAME paramters :param flame_model_fname: path of the FLAME model :param params_fname path of the FLAME paramters file :param out_path: output path of the FLAME meshes ''' if not os.path.exists(out_path): os.makedirs(out_path) model = load_model(flame_model_fname) params = np.load(params_fname, allow_pickle=True).item() shape = params['shape'] pose = params['pose'] exp = params['expression'] model.betas[:300] = shape num_frames = pose.shape[0] for frame_idx in range(num_frames): model.pose[:] = pose[frame_idx, :] model.betas[300:] = exp[frame_idx, :] out_fname = os.path.join(out_path, '%05d_FLAME.obj' % frame_idx) Mesh(model.r, model.f).write_obj(out_fname)
def generate_pose_data(): # Load FLAME model (here we load the female model) # Make sure path is correct model_path = './models/female_model.pkl' model = load_model( model_path ) # the loaded model object is a 'chumpy' object, check https://github.com/mattloper/chumpy for details print "loaded model from:", model_path # Assign random pose and shape parameters model.pose[:] = np.random.randn(model.pose.size) * 0.0 model.betas[:] = np.random.randn(model.betas.size) * 1.0 # model.trans[:] = np.random.randn( model.trans.size ) * 0.01 # you may also manipulate the translation of mesh outmesh_dir = './output' safe_mkdir(outmesh_dir) # Save zero pose outmesh_path = join(outmesh_dir, 'pose_0.obj') write_simple_obj(mesh_v=model.r, mesh_f=model.f, filepath=outmesh_path) # Write to an .obj file model.pose[3:6] = np.random.randn(3) * 0.3 outmesh_path = join(outmesh_dir, 'pose_t.obj') write_simple_obj(mesh_v=model.r, mesh_f=model.f, filepath=outmesh_path) np.savetxt('./output/pose_t.txt', model.pose.r) # Print message print 'output mesh saved to: ', outmesh_path
def visualize_result(self, model_dir, res_dir): assert sys.version_info[0] == 2, "This code could only run in Python 2" from models.renderer import SMPLRenderer from smpl_webuser.serialization import load_model smpl_model_path = osp.join(model_dir, 'smpl_cocoplus_neutral.pkl') self.renderer = SMPLRenderer(img_size=224, face_path=osp.join( model_dir, 'smpl_faces.npy')) # build result subdirs first self.build_dirs() # start processing num_process = min(8, len(self.pred_results)) num_each = len(self.pred_results) // num_process process_list = list() for i in range(num_process): start = i * num_each end = (i + 1) * num_each if i < num_process - 1 else len( self.pred_results) smpl = load_model(smpl_model_path) p = mp.Process(target=self.visualize_result_single, args=(start, end, smpl)) p.start() process_list.append(p) for p in process_list: p.join()
def main(name): ## Load SMPL model (here we load the female model) ## Make sure path is correct m = load_model( '/Users/akase/smpl/smpl_webuser/hello_world/basicModel_m_lbs_10_207_0_v1.0.0.pkl' ) ### Assign random pose and shape parameters #m.pose[:] = np.random.rand(m.pose.size) * .2 #m.betas[:] = np.random.rand(m.betas.size) * .03 #自分で作った # theta = np.loadtxt('/Users/akase/smpl/smpl_webuser/hello_world/theta/theta.csv',delimiter=',') theta = np.loadtxt('exp/theta/theta' + name + '.csv', delimiter=',') m.pose[:] = theta[3:75] m.betas[:] = theta[75:] ## Write to an .obj file outmesh_path = 'exp/objdata/' + name + '.obj' with open(outmesh_path, 'w') as fp: for v in m.r: fp.write('v %f %f %f\n' % (v[0], v[1], v[2])) for f in m.f + 1: # Faces are 1-based, not 0-based in obj files fp.write('f %d %d %d\n' % (f[0], f[1], f[2])) ## Print message print '..Output mesh saved to: ', outmesh_path
def load_animal_model(model_name='my_smpl_15.pkl'): from smpl_webuser.serialization import load_model from os.path import exists, join model_dir = '../../' model_path = join(model_dir, 'smpl_models', model_name) model = load_model(model_path) return model
def load_smal_model(model_name='my_smpl_00781_4_all.pkl'): model_path = os.path.join(model_dir, model_name) model = load_model(model_path) v = align_smal_template_to_symmetry_axis(model.r.copy()) return v, model.f
def alter_sequence_shape(source_path, out_path, flame_model_fname, pc_idx=0, pc_range=(0, 3), uv_template_fname='', texture_img_fname=''): ''' Load existing animation sequence in "zero pose" and change the identity dependent shape over time. :param source_path: path of the animation sequence (files must be provided in OBJ file format) :param out_path: output path of the altered sequence :param flame_model_fname: path of the FLAME model :param pc_idx Identity shape parameter to be varied in [0,300) as FLAME provides 300 shape paramters :param pc_range Tuple (start/end, max/min) defining the range of the shape variation. i.e. (0,3) varies the shape from 0 to 3 stdev and back to 0 ''' if pc_idx < 0 or pc_idx >= 300: print('shape parameter index out of range [0,300)') return if not os.path.exists(out_path): os.makedirs(out_path) # Load sequence files sequence_fnames = sorted(glob.glob(os.path.join(source_path, '*.obj'))) num_frames = len(sequence_fnames) if num_frames == 0: print('No sequence meshes found') return # Load FLAME head model model = load_model(flame_model_fname) model_parms = np.zeros((num_frames, 300)) # Generate interpolated shape parameters for each frame x1, y1 = [0, num_frames / 2], pc_range x2, y2 = [num_frames / 2, num_frames], pc_range[::-1] xsteps1 = np.arange(0, num_frames / 2) xsteps2 = np.arange(num_frames / 2, num_frames) model_parms[:, pc_idx] = np.hstack( (np.interp(xsteps1, x1, y1), np.interp(xsteps2, x2, y2))) predicted_vertices = np.zeros( (num_frames, model.v_template.shape[0], model.v_template.shape[1])) for frame_idx in range(num_frames): model.v_template[:] = Mesh(filename=sequence_fnames[frame_idx]).v model.betas[:300] = model_parms[frame_idx] predicted_vertices[frame_idx] = model.r output_sequence_meshes(predicted_vertices, Mesh(model.v_template, model.f), out_path, uv_template_fname=uv_template_fname, texture_img_fname=texture_img_fname)
def compute_FLAME_params(source_path, params_out_fname, flame_model_fname, template_fname): ''' Load a template and an existing animation sequence in "zero pose" and compute the FLAME shape, jaw pose, and expression paramters. Outputs one set of shape paramters for the entire sequence, and pose and expression parameters for each frame. :param source_path: path of the animation sequence (files must be provided in OBJ file format) :param params_out_fname output path of the FLAME paramters file :param flame_model_fname: path of the FLAME model :param template_fname "zero pose" template used to generate the sequence ''' if not os.path.exists(os.path.dirname(params_out_fname)): os.makedirs(os.path.dirname(params_out_fname)) # Load sequence files sequence_fnames = sorted(glob.glob(os.path.join(source_path, '*.obj'))) num_frames = len(sequence_fnames) if num_frames == 0: print('No sequence meshes found') return model = load_model(flame_model_fname) print('Optimize for template identity parameters') template_mesh = Mesh(filename=template_fname) ch.minimize(template_mesh.v - model, x0=[model.betas[:300]], options={ 'sparse_solver': lambda A, x: cg(A, x, maxiter=2000)[0] }) betas = model.betas.r[:300].copy() model.betas[:] = 0. model.v_template[:] = template_mesh.v model_pose = np.zeros((num_frames, model.pose.shape[0])) model_exp = np.zeros((num_frames, 100)) for frame_idx in range(num_frames): print('Process frame %d/%d' % (frame_idx + 1, num_frames)) model.betas[:] = 0. model.pose[:] = 0. frame_vertices = Mesh(filename=sequence_fnames[frame_idx]).v # Optimize for jaw pose and facial expression ch.minimize(frame_vertices - model, x0=[model.pose[6:9], model.betas[300:]], options={ 'sparse_solver': lambda A, x: cg(A, x, maxiter=2000)[0] }) model_pose[frame_idx] = model.pose.r.copy() model_exp[frame_idx] = model.betas.r[300:].copy() np.save(params_out_fname, { 'shape': betas, 'pose': model_pose, 'expression': model_exp })
def run_fitting_demo(): # input landmarks lmk_path = './data/landmark_3d.pkl' lmk_3d = load_binary_pickle(lmk_path) print "loaded 3d landmark from:", lmk_path # model model_path = './models/male_model.pkl' # change to 'female_model.pkl' or 'generic_model.pkl', if needed model = load_model( model_path ) # the loaded model object is a 'chumpy' object, check https://github.com/mattloper/chumpy for details print "loaded model from:", model_path # landmark embedding lmk_emb_path = './data/lmk_embedding_intraface_to_flame.pkl' lmk_face_idx, lmk_b_coords = load_embedding(lmk_emb_path) print "loaded lmk embedding" # output output_dir = './output' safe_mkdir(output_dir) # weights weights = {} weights['lmk'] = 1.0 weights['shape'] = 0.001 weights['expr'] = 0.001 weights['pose'] = 0.1 # optimization options import scipy.sparse as sp opt_options = {} opt_options['disp'] = 1 opt_options['delta_0'] = 0.1 opt_options['e_3'] = 1e-4 opt_options['maxiter'] = 100 sparse_solver = lambda A, x: sp.linalg.cg( A, x, maxiter=opt_options['maxiter'])[0] opt_options['sparse_solver'] = sparse_solver # run fitting mesh_v, mesh_f, parms = fit_lmk3d( lmk_3d=lmk_3d, # input landmark 3d model=model, # model lmk_face_idx=lmk_face_idx, lmk_b_coords=lmk_b_coords, # landmark embedding weights=weights, # weights for the objectives shape_num=300, expr_num=100, opt_options=opt_options) # options # write result output_path = join(output_dir, 'fit_lmk3d_result.obj') write_simple_obj(mesh_v=mesh_v, mesh_f=mesh_f, filepath=output_path, verbose=False)
def alter_sequence_head_pose(source_path, out_path, flame_model_fname, pose_idx=3, rot_angle=np.pi / 6): ''' Load existing animation sequence in "zero pose" and change the head pose (i.e. rotation around the neck) over time. :param source_path: path of the animation sequence (files must be provided in OBJ file format) :param out_path: output path of the altered sequence :param flame_model_fname: path of the FLAME model :param pose_idx: head pose parameter to be varied in [3,6) :param rot_angle: maximum rotation angle in [0,2pi) ''' if pose_idx < 3 or pose_idx >= 6: print('pose parameter index out of range [3,6)') return if not os.path.exists(out_path): os.makedirs(out_path) # Load sequence files sequence_fnames = sorted(glob.glob(os.path.join(source_path, '*.obj'))) num_frames = len(sequence_fnames) if num_frames == 0: print('No sequence meshes found') return # Load FLAME head model model = load_model(flame_model_fname) model_parms = np.zeros((num_frames, model.pose.shape[0])) # Generate interpolated pose parameters for each frame x1, y1 = [0, num_frames // 4], [0, rot_angle] x2, y2 = [num_frames // 4, num_frames // 2], [rot_angle, 0] x3, y3 = [num_frames // 2, 3 * num_frames // 4], [0, -rot_angle] x4, y4 = [3 * num_frames // 4, num_frames], [-rot_angle, 0] xsteps1 = np.arange(0, num_frames // 4) xsteps2 = np.arange(num_frames // 4, num_frames / 2) xsteps3 = np.arange(num_frames // 2, 3 * num_frames // 4) xsteps4 = np.arange(3 * num_frames // 4, num_frames) model_parms[:, pose_idx] = np.hstack( (np.interp(xsteps1, x1, y1), np.interp(xsteps2, x2, y2), np.interp(xsteps3, x3, y3), np.interp(xsteps4, x4, y4))) predicted_vertices = np.zeros( (num_frames, model.v_template.shape[0], model.v_template.shape[1])) for frame_idx in range(num_frames): model.v_template[:] = Mesh(filename=sequence_fnames[frame_idx]).v model.pose[:] = model_parms[frame_idx] predicted_vertices[frame_idx] = model.r output_sequence_meshes(predicted_vertices, Mesh(model.v_template, model.f), out_path)
def main(): """Set up paths to image and joint data, saves results. :param base_dir: folder containing LSP images and data :param out_dir: output folder :param use_interpenetration: boolean, if True enables the interpenetration term :param n_betas: number of shape coefficients considered during optimization :param flength: camera focal length (an estimate) :param pix_thsh: threshold (in pixel), if the distance between shoulder joints in 2D is lower than pix_thsh, the body orientation as ambiguous (so a fit is run on both the estimated one and its flip) :param use_neutral: boolean, if True enables uses the neutral gender SMPL model :param viz: boolean, if True enables visualization during optimization """ # Render degrees: List of degrees in azimuth to render the final fit. # Note that rendering many views can take a while. import glob import os seqPath = '/home/xiul/databag/dbfusion/record0' allImgs = glob.glob(os.path.join(seqPath, 'xiu/*.png')) allImgs.sort() allPoses = np.loadtxt( os.path.join(seqPath, 'pose_parameters_per_frame.txt')) allBetas = np.loadtxt(os.path.join(seqPath, 'shape_parameters.txt')) camK = np.loadtxt(os.path.join(seqPath, 'cam_params.txt'), delimiter=',') allTrans = allPoses[:, 3:6] allPose = np.hstack((allPoses[:, 0:3], allPoses[:, 6:])) model = load_model(MODEL_MALE_PATH) useIds = range(len(allImgs)) allJson = glob.glob('/home/xiul/databag/dbfusion/record0/openpose/*.json') allJson.sort() for idx in useIds[10::10]: tarIUV = cv2.imread(allImgs[idx]) tarIUV = cv2.resize(tarIUV, (1280, 720)) tarIUV = tarIUV[:, :, ::-1] tarIUV[tarIUV[:, :, 0] == 0, :] = 255 tarIUV = tarIUV.astype(np.float) tarIUV = tarIUV / 255.0 cJ2d, wJ2d = load_pose(allJson[idx]) run_single_fit(tarIUV, cJ2d, wJ2d, allPose[idx, 0:3], allTrans[idx, :], allPose[idx, 3:], model, camK, viz=True, ids=idx)
def get_height(pose, betas): m = load_model('../../models/basicModel_m_lbs_10_207_0_v1.0.0.pkl') #height = (6677,411) m.pose[:] = pose m.betas[:] = betas[:] # rint(m.v_shaped[411][1]) # print(m.v_shaped[6677][1]) # print('height:') height = m.v_shaped[411][1] - m.v_shaped[6677][1] return height
def run_fitting(): # input landmarks lmk_path = './data/scan_lmks.npy' # measurement unit of landmarks ['m', 'cm', 'mm'] unit = 'mm' scale_factor = get_unit_factor('m') / get_unit_factor(unit) lmk_3d = scale_factor*np.load(lmk_path) print("loaded 3d landmark from:", lmk_path) # model model_path = './models/generic_model.pkl' # change to 'female_model.pkl' or 'male_model.pkl', if gender is known model = load_model(model_path) # the loaded model object is a 'chumpy' object, check https://github.com/mattloper/chumpy for details print("loaded model from:", model_path) # landmark embedding lmk_emb_path = './models/flame_static_embedding.pkl' lmk_face_idx, lmk_b_coords = load_embedding(lmk_emb_path) print("loaded lmk embedding") # output output_dir = './output' safe_mkdir(output_dir) # weights weights = {} # landmark term weights['lmk'] = 1.0 # shape regularizer (weight higher to regularize face shape more towards the mean) weights['shape'] = 0.001 # expression regularizer (weight higher to regularize facial expression more towards the mean) weights['expr'] = 0.001 # regularization of head rotation around the neck and jaw opening (weight higher for more regularization) weights['pose'] = 0.1 # optimization options import scipy.sparse as sp opt_options = {} opt_options['disp'] = 1 opt_options['delta_0'] = 0.1 opt_options['e_3'] = 1e-4 opt_options['maxiter'] = 100 sparse_solver = lambda A, x: sp.linalg.cg(A, x, maxiter=opt_options['maxiter'])[0] opt_options['sparse_solver'] = sparse_solver # run fitting mesh_v, mesh_f, parms = fit_lmk3d( lmk_3d=lmk_3d, # input landmark 3d model=model, # model lmk_face_idx=lmk_face_idx, lmk_b_coords=lmk_b_coords, # landmark embedding weights=weights, # weights for the objectives shape_num=300, expr_num=100, opt_options=opt_options ) # options # write result output_path = join( output_dir, 'fit_lmk3d_result.obj' ) write_simple_obj( mesh_v=mesh_v, mesh_f=mesh_f, filepath=output_path, verbose=False )
def __init__(self, obj_path, model_path, w=224, h=224): self.m = get_body_mesh(obj_path, trans=ch.array([0, 0, 4]), rotation=ch.array([np.pi / 2, 0, 0])) # Load SMPL model (here we load the female model) self.body = load_model(model_path) self.w = w self.h = h self.img_size = min(self.w, self.h) self.num_cam = 3 self.num_theta = 72 self.num_beta = 10
def get_horse_template(model_name='my_smpl_00781_4_all.pkl', data_name='my_smpl_data_00781_4_all.pkl'): model_path = os.path.join(model_dir, model_name) model = load_model(model_path) nBetas = len(model.betas.r) data_path = os.path.join(model_dir, 'my_smpl_data_00781_4_all.pkl') data = pkl.load(open(data_path)) # Select average zebra/horse betas = data['cluster_means'][2][:nBetas] model.betas[:] = betas v = model.r.copy() return v
def load_animal_model(model_name='my_smpl_15.pkl'): from smpl_webuser.serialization import load_model from os.path import exists, join model_dir = '/scratch1/projects/MPI_data/' if exists( '/scratch1/projects') else '/is/ps/shared/silvia/' model_dir = '/Users/silvia/Dropbox/animal_proj_silvia/' model_dir = '../../' #model_path = join(model_dir, 'smpl_animal_models', model_name) model_path = join(model_dir, 'smpl_models', model_name) model = load_model(model_path) return model
def generate_exp_sequence(output_dir): # Load FLAME model (here we load the female model) # Make sure path is correct model_path = './models/generic_model.pkl' model = load_model( model_path ) # the loaded model object is a 'chumpy' object, check https://github.com/mattloper/chumpy for details print "loaded model from:", model_path safe_mkdir(output_dir) safe_mkdir(output_dir + '/gtcoeff') safe_mkdir(output_dir + '/gtcoeff/pose_coeff') safe_mkdir(output_dir + '/gtcoeff/exp_coeff') # Assign random pose and shape parameters model.pose[:] = np.random.randn(model.pose.size) * 0.0 model.betas[:] = np.random.randn(model.betas.size) * 0.0 save_model_joints_info(model, output_dir) save_model_pose_bs(model, output_dir + "/pose_bs.txt") model.betas[0:300] = np.random.randn(300) * 0.5 save_model_joints_info(model, output_dir + "/gtcoeff") # model.trans[:] = np.random.randn( model.trans.size ) * 0.01 # you may also manipulate the translation of mesh # Save zero pose outmesh_path = join(output_dir, '0000.obj') write_simple_obj(mesh_v=model.r, mesh_f=model.f, filepath=outmesh_path) np.savetxt(output_dir + '/gtcoeff/beta.txt', model.betas.r, fmt='%.8f') save_model_pose_info(model, output_dir + "/gtcoeff/pose_coeff/0000.txt") save_model_exp_info(model, output_dir + '/gtcoeff/exp_coeff/0000.txt') # Write to an .obj file for idx in range(1, 10): model.pose[0:5] = np.random.randn(5) * 0.01 model.pose[6] = abs(np.random.randn(1)) * 0.3 model.pose[7:9] = np.random.randn(2) * 0.01 model.trans[:] = np.random.randn(model.trans.size) * 0.01 model.betas[300:] = np.random.randn(100) * 1 outmesh_path = join(output_dir, '{:04d}.obj'.format(idx)) write_simple_obj(mesh_v=model.r, mesh_f=model.f, filepath=outmesh_path) save_model_pose_info( model, output_dir + "/gtcoeff/pose_coeff/{:04d}.txt".format(idx)) save_model_exp_info( model, output_dir + "/gtcoeff/exp_coeff/{:04d}.txt".format(idx)) # Print message print 'output mesh saved to: ', outmesh_path
def main(): """Set up paths to image and joint data, saves results. :param base_dir: folder containing LSP images and data :param out_dir: output folder :param use_interpenetration: boolean, if True enables the interpenetration term :param n_betas: number of shape coefficients considered during optimization :param flength: camera focal length (an estimate) :param pix_thsh: threshold (in pixel), if the distance between shoulder joints in 2D is lower than pix_thsh, the body orientation as ambiguous (so a fit is run on both the estimated one and its flip) :param use_neutral: boolean, if True enables uses the neutral gender SMPL model :param viz: boolean, if True enables visualization during optimization """ # Render degrees: List of degrees in azimuth to render the final fit. # Note that rendering many views can take a while. import glob import os allImgs = glob.glob(os.path.join(ROOT_PATH, 'images/*')) allImgs.sort() model = load_model(MODEL_MALE_PATH) all_ids = range(len(allImgs)) #only the last for idx in all_ids[::1]: cImg = allImgs[idx] cImgBase = os.path.basename(cImg) cImgName = os.path.splitext(cImgBase)[0] img_raw, img, uv, j2d, j2d_w, pose, trans, betas, cam, cam_old = prepare_data( ROOT_PATH, cImg) run_single_fit(img_raw, img, uv, j2d, j2d_w, trans, pose, betas, model, cam, cam_old, viz=True, imgname=cImgName)
def main(): # <===== PARSE ARGUMENTS import argparse parser = argparse.ArgumentParser(description='Fit SMPL body to mesh predictions.') parser.add_argument('--dataname', type=str, help='name of the data') args = parser.parse_args() dataname = args.dataname print('------- Option -------') print('\tdataname: %s' % dataname) # ======> # <========= LOAD SMPL MODEL m = load_model(join(SMPL_PATH, 'models/basicModel_neutral_lbs_10_207_0_v1.0.0.pkl')) # Init upright t-pose initial_model = m.copy() initial_model.pose[0:3] = np.array((np.pi, 0, 0))
def hello_world(): # Load FLAME model (here we load the female model) # Make sure path is correct model_path = './models/female_model.pkl' model = load_model( model_path ) # the loaded model object is a 'chumpy' object, check https://github.com/mattloper/chumpy for details print "loaded model from:", model_path # Show component number print "\nFLAME coefficients:" print "shape (identity) coefficient shape =", model.betas[ 0:300].shape # valid shape component range in "betas": 0-299 print "expression coefficient shape =", model.betas[ 300:].shape # valid expression component range in "betas": 300-399 print "pose coefficient shape =", model.pose.shape print "\nFLAME model components:" print "shape (identity) component shape =", model.shapedirs[:, :, 0:300].shape print "expression component shape =", model.shapedirs[:, :, 300:].shape print "pose corrective blendshape shape =", model.posedirs.shape print "" # ----------------------------------------------------------------------------- # Assign random pose and shape parameters model.pose[:] = np.random.randn(model.pose.size) * 0.05 model.pose[3:6] = np.random.randn(3) * 0.5 model.betas[:] = np.random.randn(model.betas.size) * 1.0 # model.trans[:] = np.random.randn( model.trans.size ) * 0.01 # you may also manipulate the translation of mesh # Write to an .obj file outmesh_dir = './output' safe_mkdir(outmesh_dir) outmesh_path = join(outmesh_dir, 'hello_flame.obj') write_simple_obj(mesh_v=model.r, mesh_f=model.f, filepath=outmesh_path) # Print message print 'output mesh saved to: ', outmesh_path
def main(): """Set up paths to image and joint data, saves results. data is stored as root_path --images --hmr --densepose --openpose --smplify: for result store """ import glob import os allImgs = glob.glob(os.path.join(ROOT_PATH, 'images/*')) allImgs.sort() model = load_model(MODEL_MALE_PATH) all_ids = range(len(allImgs)) for idx in all_ids[::5]: cImg = allImgs[idx] img_old, img, uv, j2d, j2d_w, pose, trans, betas, cam, cam_old = smplify_prepare_data( root_path, cImg) run_single_fit(img_old, img, uv, j2d, j2d_w, trans, pose, betas, model, cam, cam_old, viz=True, ids=idx)
def __init__(self, parent=None): super(domeGLWidget, self).__init__(parent) self.xRot = 0 self.yRot = 0 self.zRot = 0 self.z_trans = 300 self.x_trans = 0 self.y_trans = 0 self.z_near = 0.01 self.z_far = 5000. self.frame_id = 0 self.last_frameid = 0 self.g_ambientLight = (0.35, 0.35, 0.35, 1.0) self.g_diffuseLight = (0.75, 0.75, 0.75, 0.7) self.g_specular = (1.0, 1.0, 1.0, 1.0) self.lastPos = QPoint() self.hdCams = [] self.smpl_Lists = [] self.ske_Lists = [] self.smpl = load_model( '/home/xiul/workspace/SMPL_python/smpl/models/basicmodel_m_lbs_10_207_0_v1.0.0.pkl' ) self.smpl_facenum = 0 self.smpl_params = [] self.vts_buffer = [] self.vns_buffer = [] self.inds_buffer = [] self.face_num = [] self.skeletons = [] self.render_lock = QMutex() self.meshlib = meshWrapper( lib_file= '/home/xiul/workspace/PanopticDome/build/libPythonWrapper.so' ) # change this to your built shared library self.meshlib.load_totalmodel()
seq = args.seq + '_1_C1' data_dir = join(base_dir, 'results/human_eva', seq) results_path = join(data_dir, 'all_results.pkl') joints_path = join(data_dir, 'est_joints.npz') if 'S1' in seq: model_path = join(model_dir, 'basicModel_f_lbs_10_207_0_v1.0.0.pkl') else: model_path = join(model_dir, 'basicmodel_m_lbs_10_207_0_v1.0.0.pkl') # Load everything: # SMPL model model = load_model(model_path) # detected joints est = np.load(joints_path)['est_joints'] # SMPL parameters + camera print('opening %s' % results_path) with open(results_path, 'r') as f: res = pickle.load(f) poses = res['poses'] betas = res['betas'] # Camera rotation is always at identity, # The rotation of the body is encoded by the first 3 bits of poses. cam_ts = res['cam_ts'] focal_length = res['focal_length'] principal_pt = res['principal_pt']
def main(base_dir, out_dir, use_interpenetration=True, n_betas=10, flength=5000., pix_thsh=25., use_neutral=False, viz=True): """Set up paths to image and joint data, saves results. :param base_dir: folder containing LSP images and data :param out_dir: output folder :param use_interpenetration: boolean, if True enables the interpenetration term :param n_betas: number of shape coefficients considered during optimization :param flength: camera focal length (an estimate) :param pix_thsh: threshold (in pixel), if the distance between shoulder joints in 2D is lower than pix_thsh, the body orientation as ambiguous (so a fit is run on both the estimated one and its flip) :param use_neutral: boolean, if True enables uses the neutral gender SMPL model :param viz: boolean, if True enables visualization during optimization """ img_dir = join(abspath(base_dir), 'images/') print img_dir data_dir = join(abspath(base_dir), 'results/lsp') if not exists(out_dir): makedirs(out_dir) _LOGGER.info("make out dir") # Render degrees: List of degrees in azimuth to render the final fit. # Note that rendering many views can take a while. do_degrees = [0.] sph_regs = None if not use_neutral: _LOGGER.info("Reading genders...") # File storing information about gender in LSP with open(join(data_dir, 'lsp_gender.csv')) as f: genders = f.readlines() model_female = load_model(MODEL_FEMALE_PATH) model_male = load_model(MODEL_MALE_PATH) if use_interpenetration: sph_regs_male = np.load(SPH_REGS_MALE_PATH) sph_regs_female = np.load(SPH_REGS_FEMALE_PATH) else: gender = 'neutral' model = load_model(MODEL_NEUTRAL_PATH) if use_interpenetration: sph_regs = np.load(SPH_REGS_NEUTRAL_PATH) # Load joints est = np.load(join(data_dir, 'est_joints.npz'))['est_joints'] # Load images img_paths = sorted(glob(join(img_dir, '*[0-9].jpg'))) for ind, img_path in enumerate(img_paths): out_path = '%s/%04d.pkl' % (out_dir, ind) if not exists(out_path): _LOGGER.info('Fitting 3D body on `%s` (saving to `%s`).', img_path, out_path) img = cv2.imread(img_path) if img.ndim == 2: _LOGGER.warn("The image is grayscale!") img = np.dstack((img, img, img)) joints = est[:2, :, ind].T conf = est[2, :, ind] if not use_neutral: gender = 'male' if int(genders[ind]) == 0 else 'female' if gender == 'female': model = model_female if use_interpenetration: sph_regs = sph_regs_female elif gender == 'male': model = model_male if use_interpenetration: sph_regs = sph_regs_male params, vis = run_single_fit( img, joints, conf, model, regs=sph_regs, n_betas=n_betas, flength=flength, pix_thsh=pix_thsh, scale_factor=2, viz=viz, do_degrees=do_degrees) if viz: import matplotlib.pyplot as plt plt.ion() plt.show() plt.subplot(121) plt.imshow(img[:, :, ::-1]) if do_degrees is not None: for di, deg in enumerate(do_degrees): plt.subplot(122) plt.cla() plt.imshow(vis[di]) plt.draw() plt.title('%d deg' % deg) plt.pause(1) raw_input('Press any key to continue...') with open(out_path, 'w') as outf: pickle.dump(params, outf) # This only saves the first rendering. if do_degrees is not None: cv2.imwrite(out_path.replace('.pkl', '.png'), vis[0])
============================= Inside Terminal, navigate to the smpl/webuser/hello_world directory. You can run the hello world script now by typing the following: > python render_smpl.py ''' import numpy as np from opendr.renderer import ColoredRenderer from opendr.lighting import LambertianPointLight from opendr.camera import ProjectPoints from smpl_webuser.serialization import load_model ## Load SMPL model (here we load the female model) m = load_model('../../models/basicModel_f_lbs_10_207_0_v1.0.0.pkl') ## Assign random pose and shape parameters m.pose[:] = np.random.rand(m.pose.size) * .2 m.betas[:] = np.random.rand(m.betas.size) * .03 m.pose[0] = np.pi ## Create OpenDR renderer rn = ColoredRenderer() ## Assign attributes to renderer w, h = (640, 480) rn.camera = ProjectPoints(v=m, rt=np.zeros(3), t=np.array([0, 0, 2.]), f=np.array([w,w])/2., c=np.array([w,h])/2., k=np.zeros(5)) rn.frustum = {'near': 1., 'far': 10., 'width': w, 'height': h} rn.set(v=m, f=m.f, bgcolor=np.zeros(3))