def test_samples_dir(self, samples_dir): sample_dirs = os.listdir(samples_dir) pd_pattern = 'pd_cloth_{:08d}.obj' cr_pattern = 'cr_ineq_cloth_{:08d}.obj' # pd_pattern='pd_{:08d}.obj' # cr_pattern='cr_ineq_{:08d}.obj' anchor = [] ids = [] for i, sample_dir in enumerate(sample_dirs): sample_id = int(sample_dir) pd_path = join(samples_dir, sample_dir, pd_pattern.format(sample_id)) pd_obj = read_obj(pd_path) v, f = pd_obj.v, pd_obj.f v = torch.from_numpy(v).to(device=self.device, dtype=self.dtype) v = v.unsqueeze(0) anchor.append(v) ids.append(sample_id) if len(anchor) == self.batch_size or i == len(sample_dirs) - 1: anchor = torch.cat(anchor, dim=0) start_time = time.time() x = self.proj_module(anchor) end_time = time.time() # print('ellapse:',end_time-start_time) for j, sample_id in enumerate(ids): x_save = x[j].detach().cpu().numpy() cr_path = join(samples_dir, '{:08d}'.format(sample_id), cr_pattern.format(sample_id)) print('write to', cr_path) write_obj(Obj(v=x_save, f=f), cr_path) anchor = [] ids = []
def run_pp(self,in_path,out_path): if self.cudaqs_utils is None: self.cudaqs_utils=CudaqsUtils('../../pixel_network/shared_data_hr_front') obj=read_obj(in_path) obj.v=self.cudaqs_utils.forward(obj.v) print('write to',out_path) write_obj(obj,out_path)
def write_obj(self, v, f, out_path, patch_id=-1): if patch_id >= 0: full_v = np.zeros((self.agg_n_vts, 3)) full_v[self.patch_vt_ids, :] = v v = full_v print('write to', out_path) write_obj(Obj(v=v, f=f), out_path)
def get_circle_blender_dir(self, out_dir, n_key_frames, n_total_frames, start_camera_pos): if not isdir(out_dir): os.makedirs(out_dir) with open(join(out_dir, 'last_frame.txt'), 'w') as f: f.write('{} {}\n'.format(n_key_frames, n_total_frames)) key_frame_vt = self.get_circle_key_frame_vt(n_key_frames) for i in range(n_total_frames): ratio = i * n_key_frames / n_total_frames key_frame_0 = int(ratio) key_frame_1 = (key_frame_0 + 1) % n_key_frames t = ratio - key_frame_0 vt_0 = key_frame_vt[key_frame_0] vt_1 = key_frame_vt[key_frame_1] vt = vt_0 * (1 - t) + vt_1 * t # out_path=join(out_dir,'vt_{}.txt'.format(i)) # print('write to',out_path) # write_vt(out_path,vt) # out_path=join(out_dir,'uv_{}.txt'.format(i)) # print('write to',out_path) # write_uv(out_path,vt,self.fcs) out_path = join(out_dir, 'frame_{}.obj'.format(i)) print('write to', out_path) write_obj(Obj(v=self.pd_v, f=self.fcs, vt=vt), out_path) theta = i / n_total_frames * (2 * np.pi) camera_transform = self.get_circle_camera_transform( theta, start_camera_pos) out_path = join(out_dir, 'cam_{}.txt'.format(i)) # print('write to',out_path) self.write_camera_transform(out_path, camera_transform)
def write_skin_img_cloth_from_id(self, test_id, prefix='cloth', out_dir=None): device = self.device offset_img = np.load( os.path.join(self.offset_img_dir, 'offset_img_{:08d}.npy'.format(test_id))) skin_img = np.load( os.path.join(self.skin_img_dir, 'skin_img_{:08d}.npy'.format(test_id))) cloth_img = offset_img + skin_img cloth_imgs = torch.from_numpy(cloth_img).permute(2, 0, 1).unsqueeze(0) cloth_vt = self.get_offsets_torch(cloth_imgs)[0].detach().cpu().numpy() gt_cloth_path = os.path.join(self.data_root_dir, 'lowres_tshirts', 'tshirt_{:08d}.obj'.format(test_id)) gt_cloth_vt = read_obj(gt_cloth_path).v print('error', self.get_error(gt_cloth_vt - cloth_vt)) obj = Obj(v=cloth_vt, f=self.fcs) if out_dir is None: out_dir = self.out_dir out_path = os.path.join(self.out_dir, '{}_{:08d}.obj'.format(prefix, test_id)) write_obj(obj, out_path)
def save_region_pieces_obj(self, samples_dir, sample_id): skin_path = os.path.join(self.skin_dir, 'skin_{:08d}.npy'.format(sample_id)) skin = np.load(skin_path) n_vts = len(skin) sample_dir = os.path.join(samples_dir, '{:08d}'.format(sample_id)) vts = [] fcs = [] for region_id in range(self.n_regions): region_name = self.region_names[region_id] region_offset_path = os.path.join( sample_dir, '{}_offset.npy'.format(region_name)) region_offset = np.load(region_offset_path).reshape((-1, 3)) region_vt_ids = self.all_region_vt_ids[region_id] region_fcs = self.all_region_intr_fcs[region_id] region_vts = skin.copy() region_vts[region_vt_ids] += region_offset vts.append(region_vts) fcs.append(region_fcs + region_id * n_vts) # break vts = np.concatenate(vts, axis=0) fcs = np.concatenate(fcs, axis=0) obj_path = os.path.join(sample_dir, 'region_pieces.obj') obj = Obj(v=vts, f=fcs) write_obj(obj, obj_path)
def save_stitched_regions_obj(self, samples_dir, sample_id): skin_path = os.path.join(self.skin_dir, 'skin_{:08d}.npy'.format(sample_id)) skin = np.load(skin_path) n_vts = len(skin) sample_dir = os.path.join(samples_dir, '{:08d}'.format(sample_id)) vt_offsets = [[] for i in range(n_vts)] for region_id in range(self.n_regions): region_name = self.region_names[region_id] region_offset_path = os.path.join( sample_dir, '{}_offset.npy'.format(region_name)) region_offset = np.load(region_offset_path).reshape((-1, 3)) region_vt_ids = self.all_region_vt_ids[region_id] for i in range(len(region_offset)): vt_id = region_vt_ids[i] vt_offsets[vt_id].append(region_offset[i]) for i in range(n_vts): vt_offsets[i] = np.mean(np.array(vt_offsets[i]), axis=0) vt_offsets = np.array(vt_offsets) obj_path = os.path.join(sample_dir, 'stitched_regions.obj') obj = Obj(v=skin + vt_offsets, f=self.fcs) write_obj(obj, obj_path) gt_vt_offsets = np.load( '/data/zhenglin/poses_v3/lowres_offset_npys/offset_{:08d}.npy'. format(sample_id)) print('error', self.get_error(vt_offsets - gt_vt_offsets))
def save_patch_pieces_obj(self,samples_dir,sample_id): skin_path=os.path.join(self.skin_dir,'skin_{:08d}.npy'.format(sample_id)) skin=np.load(skin_path) n_vts=len(skin) sample_dir=os.path.join(samples_dir,'{:08d}'.format(sample_id)) vts=[] fcs=[] for patch_id in range(self.n_patches): patch_name=self.patch_names[patch_id] patch_offset_path=os.path.join(sample_dir,'patches/pd_offset_{}.npy'.format(patch_name)) patch_offset=np.load(patch_offset_path).reshape((-1,3)) patch_vt_ids=self.all_patch_vt_ids[patch_id] patch_fcs=self.all_patch_intr_fcs[patch_id] patch_vts=skin.copy() patch_vts[patch_vt_ids]+=patch_offset vts.append(patch_vts) fcs.append(patch_fcs+patch_id*n_vts) # break vts=np.concatenate(vts,axis=0) fcs=np.concatenate(fcs,axis=0) obj_path=os.path.join(sample_dir,'pieces.obj') obj=Obj(v=vts,f=fcs) write_obj(obj,obj_path)
def write_obj(self, v, f, prefix, sample_id, patch_id=-1): if patch_id >= 0: full_v = np.zeros((self.agg_n_vts, 3)) full_v[self.patch_vt_ids, :] = v v = full_v out_path = '{}_{:08d}.obj'.format(prefix, sample_id) print('write to', out_path) write_obj(Obj(v=v, f=f), out_path)
def write_bone_origins_obj(bone_structure,out_file): vts=[] for bone in bone_structure.bone_list: vts.append(bone.world_frame[:3,3]) vts=np.array(vts) fcs=np.empty((0,3)) obj=Obj(v=vts,f=fcs) write_obj(obj,out_file)
def write_objs(batch, vts, fc, out_dir, prefix): n_samples = len(vts) for i in range(n_samples): sample_id = batch['index'][i] sample_out_dir = join(out_dir, '{:08d}'.format(sample_id)) if not isdir(sample_out_dir): os.makedirs(sample_out_dir) write_obj( Obj(v=vts[i].detach().cpu().numpy(), f=fc), join(sample_out_dir, '{}_{:08d}.obj'.format(prefix, sample_id)))
def test_opt(self, sample_id, save_obj=False): pd_obj = read_obj(join(self.pd_dir, 'pd_{:08d}.obj'.format(sample_id))) pd_vt = torch.from_numpy(pd_obj.v).to(device=self.device, dtype=self.dtype) cr_vt = self.solver.solve(pd_vt) if save_obj: cr_vt = cr_vt.cpu().numpy() cr_obj = Obj(v=cr_vt, f=pd_obj.f) write_obj(cr_obj, join(self.cr_dir, 'cr_{:08d}.obj'.format(sample_id)))
def save_region_from_whole_obj(self, whole_obj_path, out_dir, region_id, prefix=''): whole_obj = read_obj(whole_obj_path) region_obj = Obj(v=whole_obj.v, f=self.all_region_intr_fcs[region_id]) region_name = self.region_names[region_id] region_obj_path = os.path.join(out_dir, '{}{}.obj'.format(prefix, region_name)) write_obj(region_obj, region_obj_path)
def save_projected_obj(self, in_path, out_dir, test_id, n_pcs=2048): if not os.path.isdir(out_dir): os.makedirs(out_dir) in_obj = read_obj(in_path) skin = np.load( os.path.join(self.skin_dir, 'skin_{:08d}.npy'.format(test_id))) offsets = in_obj.v - skin proj_offsets = self.project_pc(offsets, n_pcs=n_pcs) out_obj = Obj(v=skin + proj_offsets, f=in_obj.f) out_path = os.path.join(out_dir, 'proj_{}.obj'.format(n_pcs)) write_obj(out_obj, out_path)
def write_tie(self, test_id, offset, out_dir=None, prefix='tie'): skin_path = os.path.join(self.skin_dir, 'skin_{:08d}.npy'.format(test_id)) skin = np.load(skin_path) tie = skin + offset obj = Obj(v=tie, f=self.fcs) if out_dir is None: out_dir = self.out_dir out_path = os.path.join(out_dir, '{}_{:08d}.obj'.format(prefix, test_id)) write_obj(obj, out_path)
def trim_obj(self,in_path,out_pattern,n_iters=1): def trim_vts(ids,trim_id_set): left_ids=[] for i in ids: if not i in trim_id_set: left_ids.append(i) return left_ids def add_to_set(trim_id_set,next_trim_list): for v in next_trim_list: trim_id_set.add(v) def next_trim(trim_id_set,edges): next_trim_id_set=set() for i0,i1 in edges: i0_in=i0 in trim_id_set i1_in=i1 in trim_id_set if i0_in and not i1_in: next_trim_id_set.add(i1) if not i0_in and i1_in: next_trim_id_set.add(i0) return list(next_trim_id_set) def trim_fcs(fcs,ids): id_set=set(ids) result_fcs=[] for fc in fcs: i0,i1,i2=fc if i0 in id_set and i1 in id_set and i2 in id_set: result_fcs.append(fc) return np.array(result_fcs).astype(np.int) bdry_ids=np.loadtxt(join(self.shared_data_dir,'bdry_vertices.txt')).astype(np.int) trim_id_set=set(bdry_ids) left_ids=trim_vts(self.front_vt_ids,trim_id_set) obj=read_obj(in_path) edges=get_edge_from_fcs(self.front_fcs) fcs=obj.f iters=0 while True: fcs=trim_fcs(fcs,left_ids) out_path=out_pattern.format(iters) print('write to',out_path) write_obj(Obj(obj.v,f=fcs),out_path) iters+=1 if iters>=n_iters: break next_trim_list=next_trim(trim_id_set,edges) add_to_set(trim_id_set,next_trim_list) left_ids=trim_vts(left_ids,trim_id_set)
def test_forward(self, sample_id): # pd_obj=read_obj(join(self.pd_dir,'pd_{:08d}.obj'.format(sample_id))) print('forward:{:08d}'.format(sample_id)) pd_obj = read_obj( join(self.pd_dir, '{:08d}/gt_cloth_{:08d}.obj'.format(sample_id, sample_id))) pd_vt = pd_obj.v cr_vt, lmd = forward_solve(self.opt, pd_vt) print('lmd:min:', np.min(lmd), 'max:', np.max(lmd)) np.save(join(self.cr_dir, 'cr_{:08d}.npy'.format(sample_id)), cr_vt) np.save(join(self.cr_dir, 'lmd_{:08d}.npy'.format(sample_id)), lmd) write_obj(Obj(v=cr_vt, f=pd_obj.f), join(self.cr_dir, 'cr_gt_{:08d}.obj'.format(sample_id)))
def convert(npy_dir,skin_tshirts_dir,f=None): npy_files=os.listdir(npy_dir) for npy_file in npy_files: if not npy_file.endswith('.npy'): continue name=npy_file[:-4] obj_path=join(skin_tshirts_dir,'{}.obj'.format(name)) tri_path=join(skin_tshirts_dir,'{}.tri'.format(name)) npy_path=join(npy_dir,npy_file) v=np.load(npy_path) obj=Obj(v=v,f=f) write_obj(obj,obj_path) cmd='/data/zhenglin/PhysBAM/Tools/obj2tri/obj2tri {} {}'.format(obj_path,tri_path) os.system(cmd) print('finish',npy_file)
def save_region_piece_obj(self, samples_dir, sample_id, region_id): skin_path = os.path.join(self.skin_dir, 'skin_{:08d}.npy'.format(sample_id)) skin = np.load(skin_path) n_vts = len(skin) region_name = self.region_names[region_id] sample_dir = os.path.join(samples_dir, '{:08d}'.format(sample_id)) region_offset_path = os.path.join(sample_dir, '{}_offset.npy'.format(region_name)) region_offset = np.load(region_offset_path).reshape((-1, 3)) region_vt_ids = self.all_region_vt_ids[region_id] region_vts = skin[region_vt_ids] + region_offset region_intr_fcs = self.get_region_local_fcs(region_id) region_obj_path = os.path.join(sample_dir, '{}.obj'.format(region_name)) region_obj = Obj(v=region_vts, f=region_intr_fcs) write_obj(region_obj, region_obj_path)
def replace_textures(in_dir, disp_dir, out_dir): if not isdir(out_dir): os.makedirs(out_dir) files = os.listdir(in_dir) rest_vt = read_vt('../vt_groundtruth_div.txt') for sample_id in range(15000, 30000): in_obj_path = join(in_dir, 'pd_div_{:08d}_tex.obj'.format(sample_id)) if not isfile(in_obj_path): continue disp_path = join(disp_dir, 'displace_{:08d}.txt'.format(sample_id)) if not isfile(disp_path): continue obj = read_obj(in_obj_path) disp = np.loadtxt(disp_path) out_obj_path = join(out_dir, 'pd_{:08d}.obj'.format(sample_id)) print('write to', out_obj_path) write_obj(Obj(v=obj.v, f=obj.f, vt=rest_vt + disp, mat='tshirt.mtl'), out_obj_path)
def test_samples_dir(self, samples_dir): sample_dirs = os.listdir(samples_dir) pd_pattern = 'pd_cloth_{:08d}.obj' cr_pattern = 'cr_cloth_{:08d}.obj' for sample_dir in sample_dirs: sample_id = int(sample_dir) pd_path = join(samples_dir, sample_dir, pd_pattern.format(sample_id)) pd_obj = read_obj(pd_path) v, f = pd_obj.v, pd_obj.f v = torch.from_numpy(v).to(device=self.device, dtype=self.dtype) v = v.unsqueeze(0) anchor = v x = self.module(anchor) x_save = x[0].detach().cpu().numpy() cr_path = join(samples_dir, sample_dir, cr_pattern.format(sample_id)) print('write to', cr_path) write_obj(Obj(v=x_save, f=f), cr_path)
def avg_samples_dir(self, samples_dir): sample_dirs = os.listdir(samples_dir) pd_pattern = 'pd_cloth_{:08d}.obj' cr_pattern = 'cr_cloth_{:08d}.obj' avg_pattern = 'avg_cloth_{:08d}.obj' for i, sample_dir in enumerate(sample_dirs): sample_id = int(sample_dir) pd_path = join(samples_dir, sample_dir, pd_pattern.format(sample_id)) pd_obj = read_obj(pd_path) v0, f = pd_obj.v, pd_obj.f cr_path = join(samples_dir, sample_dir, cr_pattern.format(sample_id)) cr_obj = read_obj(cr_path) v1 = cr_obj.v avg_path = join(samples_dir, sample_dir, avg_pattern.format(sample_id)) print('write to', avg_path) write_obj(Obj(v=(v0 + v1) / 2, f=f), avg_path)
def merge_obj_dirs(obj_dirs, out_dir, offsets): if not os.path.isdir(out_dir): os.makedirs(out_dir) obj_dir0 = obj_dirs[0] files = os.listdir(obj_dir0) counter = 0 for file in files: merged_vts = [] merged_fcs = [] if not file.endswith('.obj'): continue vertex_offset = 0 n_obj_dirs = len(obj_dirs) filename = file[:-4] for dir_i in range(n_obj_dirs): obj_dir = obj_dirs[dir_i] offset = offsets[dir_i] obj_path = os.path.join(obj_dir, file) # print('obj_path',obj_path) if not os.path.isfile(obj_path): continue obj = read_obj(obj_path) merged_vts.append(obj.v + offset) merged_fcs.append(obj.f + vertex_offset) n_vts = len(obj.v) vertex_offset += n_vts if len(merged_vts) == len(obj_dirs): # print('len',len(merged_vts)) merged_obj = Obj(v=np.concatenate(merged_vts, axis=0), f=np.concatenate(merged_fcs, axis=0)) else: continue # elif len(merged_vts)==1: # merged_obj=Obj(v=merged_vts[0],f=merged_fcs[0]) print('merge_obj', file[:-4]) merged_obj_path = os.path.join(out_dir, file) write_obj(merged_obj, merged_obj_path)
def get_grid_blender_dir(self, out_dir, size, keys_dir=None): if not isdir(out_dir): os.makedirs(out_dir) n_rows, n_cols = size n_cameras = n_rows * n_cols n_key_frames = 4 n_total_frames = n_cameras cam_path = join(self.sample_dir, 'camera.txt') cams = np.loadtxt(cam_path) if keys_dir is None: key_frame_vt = self.get_key_frame_vt( [n_rows * n_cols - 1, n_rows * n_cols - n_cols, n_cols - 1, 0], keys_dir=keys_dir) else: key_frame_vt = self.get_key_frame_vt(range(4), keys_dir=keys_dir) with open(join(out_dir, 'last_frame.txt'), 'w') as f: f.write('{} {}\n'.format(n_key_frames, n_total_frames)) for camera_i in range(n_cameras): row_i = camera_i // n_cols col_i = camera_i % n_cols y = row_i / (n_rows - 1) x = col_i / (n_cols - 1) w = np.array([x * y, (1 - x) * y, x * (1 - y), (1 - x) * (1 - y)]) camera_pos = sum([cams[i] * w[i] for i in range(4)]) vt = sum([key_frame_vt[i] * w[i] for i in range(4)]) out_path = join(out_dir, 'fill_vt_{}.txt'.format(camera_i)) print('write to', out_path) np.savetxt(out_path, vt) out_path = join(out_dir, 'frame_{}.obj'.format(camera_i)) print('write to', out_path) write_obj(Obj(v=self.pd_v, f=self.fcs, vt=vt), out_path) camera_transform = self.blender_pos(camera_pos), np.array( [1, 0, 0, 0]) out_path = join(out_dir, 'cam_{}.txt'.format(camera_i)) self.write_camera_transform(out_path, camera_transform)
def txt_to_obj(self, in_path, out_path): vts = np.loadtxt(in_path).reshape((-1, 3)) agg_vts = np.zeros((self.agg_n_vts, 3)) agg_vts[self.patch_vt_ids, :] = vts print('write to', out_path) write_obj(Obj(v=agg_vts, f=self.f), out_path)
patch_name=self.patch_names[patch_id] patch_offset_path=os.path.join(sample_dir,'patches/pd_offset_{}.npy'.format(patch_name)) patch_offset=np.load(patch_offset_path).reshape((-1,3)) patch_vt_ids=self.all_patch_vt_ids[patch_id] for i in range(len(patch_offset)): vt_id=patch_vt_ids[i] vt_offsets[vt_id].append(patch_offset[i]) for i in range(n_vts): vt_offsets[i]=np.mean(np.array(vt_offsets[i]),axis=0) vt_offsets=np.array(vt_offsets) obj_path=os.path.join(sample_dir,'stitched.obj') obj=Obj(v=skin+vt_offsets,f=self.fcs) write_obj(obj,obj_path) if __name__=='__main__': import argparse parser=argparse.ArgumentParser() parser.add_argument('-test_case',choices=['lowres','midres']) parser.add_argument('-samples_dir') args=parser.parse_args() def get_res_ctx(res): data_root_dir='/data/zhenglin/poses_v3' res_ctx={ 'shared_data_dir':'../../shared_data_{}'.format(res), 'vt_offset_dir':join(data_root_dir,'{}_offset_npys'.format(res)), 'skin_dir':join(data_root_dir,'{}_skin_npys'.format(res))
with open(embedding_path) as f: while True: line=f.readline() if line=='': break parts=line.split() face_id=int(parts[0])-1 weights=(float(parts[1]),float(parts[2]),float(parts[3])) vertex_embeds.append((face_id,weights)) return vertex_embeds def get_skin_cloth_vts(body_obj,cloth_embeds): vts=[] for face_id,weights in cloth_embeds: fc=body_obj.f[face_id] x0,x1,x2=body_obj.v[fc[0]],body_obj.v[fc[1]],body_obj.v[fc[2]] vts.append(x0*weights[0]+x1*weights[1]+x2*weights[2]) vts=np.array(vts) return vts if __name__=='__main__': shared_data_dir='../../shared_data' embedding_path=os.path.join(shared_data_dir,'dressed_TshirtW_embedding.txt') model_path=os.path.join(shared_data_dir,'modelT.obj') modelT=read_obj(model_path) vertex_embeds=load_cloth_embeddings(embedding_path) vts=np.array(modelT,vertex_embeds) obj=Obj(v=vts,f=np.empty((0,3))) write_obj(obj,'cloth_skin.obj')
def npy_to_obj(self, in_path, out_path): vts = np.load(in_path) agg_vts = np.zeros((self.agg_n_vts, 3)) agg_vts[self.patch_vt_ids, :] = vts print('write to', out_path) write_obj(Obj(v=agg_vts, f=self.f), out_path)
def get_square_blender_dir(self, out_dir, n_total_frames, use_key_frames=True): if not isdir(out_dir): os.makedirs(out_dir) n_key_frames = 4 with open(join(out_dir, 'last_frame.txt'), 'w') as f: f.write('{} {}\n'.format(n_key_frames, n_total_frames)) if use_key_frames: key_frame_vt = self.get_key_frame_vt(range(n_key_frames)) else: camera_pos_list = [] total_length = (2 + 2 * np.sqrt(2)) cam_path = join(self.sample_dir, 'camera.txt') cameras = np.loadtxt(cam_path) for i in range(n_total_frames): t = i / n_total_frames * total_length if t < 1: seg_t = t camera_pos = (1 - seg_t) * cameras[0] + seg_t * cameras[1] w = np.array([1 - seg_t, seg_t, 0, 0]) elif t < 1 + np.sqrt(2): seg_t = (t - 1) / np.sqrt(2) camera_pos = (1 - seg_t) * cameras[1] + seg_t * cameras[2] w = np.array([ seg_t * (1 - seg_t), (1 - seg_t) * (1 - seg_t), seg_t * seg_t, (1 - seg_t) * seg_t ]) elif t < 2 + np.sqrt(2): seg_t = t - (1 + np.sqrt(2)) camera_pos = (1 - seg_t) * cameras[2] + seg_t * cameras[3] w = np.array([0, 0, 1 - seg_t, seg_t]) else: seg_t = (t - (2 + np.sqrt(2))) / np.sqrt(2) camera_pos = (1 - seg_t) * cameras[3] + seg_t * cameras[0] w = np.array([ seg_t * seg_t, (1 - seg_t) * seg_t, seg_t * (1 - seg_t), (1 - seg_t) * (1 - seg_t) ]) if use_key_frames: vt = sum([key_frame_vt[i] * w[i] for i in range(4)]) out_path = join(out_dir, 'frame_{}.obj'.format(i)) print('write to', out_path) write_obj(Obj(v=self.pd_v, f=self.fcs, vt=vt), out_path) else: camera_pos_list.append(camera_pos) camera_transform = self.blender_pos(camera_pos), np.array( [1, 0, 0, 0]) out_path = join(out_dir, 'cam_{}.txt'.format(i)) # print('write to',out_path) self.write_camera_transform(out_path, camera_transform) if not use_key_frames: n_threads = 30 def f(frame_i): self.get_fill_obj(camera_pos_list[frame_i], postfix=str(frame_i), frame=frame_i, check=False) pool = ProcessPool(nodes=n_threads) pool.map(f, range(n_total_frames))
def write_obj(self,out_path): write_obj(Obj(v=self.v,f=self.f),out_path)