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)
