def init_cudaqs_module(res_ctx, ctx): print('init_cudaqs_module') device, dtype = ctx['device'], torch.double batch_size = ctx['batch_size'] verbose = ctx['verbose'] if 'verbose' in ctx else False use_multi_thread = False shared_data_dir = res_ctx['shared_data_dir'] patch_id = ctx['patch_id'] if 'patch_id' in ctx else -1 stiffen_anchor_factor = ctx['stiffen_anchor_factor'] use_variable_m = ctx['use_variable_m'] stiffen_anchor = load_anchor_data(shared_data_dir) edges, l0, k = load_spring_data(shared_data_dir) axial_i, axial_w, axial_k = load_axial_data(shared_data_dir) if patch_id >= 0: patch_manager = PatchManager( shared_data_dir=res_ctx['shared_data_dir']) patch_vt_ids = patch_manager.load_patch_vt_ids(patch_id) patch_edge_ids = patch_manager.get_patch_edge_ids(patch_vt_ids, edges) stiffen_anchor = stiffen_anchor[patch_vt_ids] edges = patch_manager.get_patch_edges(patch_id, edges) l0 = l0[patch_edge_ids] k = k[patch_edge_ids] patch_axial_edge_ids = patch_manager.get_patch_edge_ids( patch_vt_ids, axial_i) axial_i = patch_manager.get_patch_edges(patch_id, axial_i) axial_w = axial_w[patch_axial_edge_ids] axial_k = axial_k[patch_axial_edge_ids] stiffen_anchor = torch.from_numpy(stiffen_anchor).to( device=device, dtype=dtype) * stiffen_anchor_factor edges = torch.from_numpy(edges).to(device=device, dtype=torch.int32) l0 = torch.from_numpy(l0).to(device=device, dtype=dtype) k = torch.from_numpy(k).to(device=device, dtype=dtype) axial_i = torch.from_numpy(axial_i).to(device=device, dtype=torch.int32) axial_w = torch.from_numpy(axial_w).to(device=device, dtype=dtype) axial_k = torch.from_numpy(axial_k).to(device=device, dtype=dtype) n_vts = len(stiffen_anchor) module = CudaqsModule() cudaqs.init(n_vts, batch_size, use_multi_thread, verbose) spring_data = cudaqs.init_spring(edges, l0, k) axial_data = cudaqs.init_axial(axial_i, axial_w, axial_k) system = cudaqs.init_system(n_vts, spring_data, axial_data) forward_opt = cudaqs.init_forward(system) backward_opt = cudaqs.init_backward(system, use_variable_m) # print('len(edges):',len(edges)) opt_data = cudaqs.init_opt_data(batch_size, n_vts, len(edges)) module.init(spring_data, axial_data, system, forward_opt, backward_opt, opt_data, use_variable_m) module.stiffen_anchor = stiffen_anchor.unsqueeze(0) print('init_cudaqs_module finish') return module
class SpringOptModule(nn.Module): def __init__(self,res_ctx,ctx): super(SpringOptModule,self).__init__() self.device=ctx['device'] self.dtype=ctx['dtype'] self.patch_id=ctx['patch_id'] m,edges,l0=load_opt_data(res_ctx,ctx) k=res_ctx['stiffness'] harmonic_m=1/(1/m[edges[:,0]]+1/m[edges[:,1]]) k*=harmonic_m if self.patch_id>=0: self.patch_manager=PatchManager(shared_data_dir=res_ctx['shared_data_dir']) self.patch_vt_ids=self.patch_manager.load_patch_vt_ids(self.patch_id) patch_edge_ids=self.patch_manager.get_patch_edge_ids(self.patch_vt_ids,edges) m=m[self.patch_vt_ids] l0=l0[patch_edge_ids] edges=self.patch_manager.get_patch_edges(self.patch_id,edges) k=k[patch_edge_ids] axial_i,axial_w=load_axial_data(res_ctx) if self.patch_id>=0: axial_i,axial_w=get_patch_axial_data(self.patch_vt_ids,axial_i,axial_w) m0,m1,m2,m3=m[axial_i[:,0]],m[axial_i[:,1]],m[axial_i[:,2]],m[axial_i[:,3]] axial_harmonic_m=4/(1/m0+1/m1+1/m2+1/m3) axial_k=axial_harmonic_m*1e-1 # magic number m*=2 self.m=torch.from_numpy(m).to(dtype=self.dtype,device=self.device).view(-1,1) self.edges=torch.from_numpy(edges).to(dtype=torch.long,device=self.device).view(-1,2) self.l0=torch.from_numpy(l0).to(dtype=self.dtype,device=self.device).view(-1,1) self.k=torch.from_numpy(k).to(dtype=self.dtype,device=self.device).view(-1,1) axial_i=torch.from_numpy(axial_i).to(dtype=torch.long,device=self.device).view(-1,4) axial_w=torch.from_numpy(axial_w).to(dtype=self.dtype,device=self.device).view(-1,4) axial_k=torch.from_numpy(axial_k).to(dtype=self.dtype,device=self.device).view(-1,1) self.axial_data=(axial_i,axial_w,axial_k) self.system=SpringOptSystem(self.m,self.edges,self.l0,self.k,m_alpha=0.1,axial_data=self.axial_data) # magic number self.opt=NewtonOpt(self.system,newton_tol=1e-12,cg_tol=1e-3,cg_max_iter=max(len(self.m)//2,250)) # magic number def forward(self,x): return spring_opt(self.opt,x)
def __init__(self): self.shared_data_dir = '../../shared_data' self.pd_dir = 'opt_test/cvxpy' self.cr_dir = 'opt_test/cvxpy' self.patch_id = -1 if self.patch_id >= 0: self.pd_dir = join(self.pd_dir, 'p{:02d}'.format(self.patch_id)) self.cr_dir = join(self.cr_dir, 'p{:02d}'.format(self.patch_id)) else: self.pd_dir = join(self.pd_dir, 'whole') self.cr_dir = join(self.cr_dir, 'whole') self.vlz_dir = join(self.cr_dir, 'vlz') if not isdir(self.pd_dir): os.makedirs(self.pd_dir) if not isdir(self.cr_dir): os.makedirs(self.cr_dir) if not isdir(self.vlz_dir): os.makedirs(self.vlz_dir) res_ctx = {'shared_data_dir': self.shared_data_dir} ctx = {'max_num_constraints': -1} m, edges, l0 = load_opt_data(res_ctx, ctx) self.agg_n_vts = len(m) flat_obj = read_obj(join(self.shared_data_dir, 'flat_tshirt.obj')) self.f = flat_obj.f if self.patch_id >= 0: patch_manager = PatchManager( shared_data_dir=res_ctx['shared_data_dir']) self.patch_vt_ids = patch_manager.load_patch_vt_ids(self.patch_id) self.patch_fc_ids = patch_manager.get_patch_fc_ids( self.patch_vt_ids, self.f) self.patch_edge_ids = patch_manager.get_patch_edge_ids( self.patch_vt_ids, edges) m = m[self.patch_vt_ids] l0 = l0[self.patch_edge_ids] edges = patch_manager.get_patch_edges(self.patch_id, edges) self.opt = CvxpyOpt(m, edges, l0)
class SpringOptTest: def __init__(self): self.data_root_dir = '/data/zhenglin/poses_v3' self.pd_dir = 'spring_test/newton' self.cr_dir = 'spring_test/newton' self.shared_data_dir = '../../shared_data' self.device = torch.device('cuda:0') self.dtype = torch.double self.patch_id = -1 # self.patch_id=13 res_ctx = {'shared_data_dir': self.shared_data_dir} ctx = { 'dtype': self.dtype, 'device': self.device, 'patch_id': self.patch_id, 'max_num_constraints': -1, 'use_spring': True } self.res_ctx = res_ctx self.ctx = ctx m, edges, l0 = load_opt_data(res_ctx, ctx) k = res_ctx['stiffness'] harmonic_m = 1 / (1 / m[edges[:, 0]] + 1 / m[edges[:, 1]]) k *= harmonic_m print('avg m:', np.mean(m), 'avg k:', np.mean(k)) flat_obj = read_obj(join(self.shared_data_dir, 'flat_tshirt.obj')) self.f = flat_obj.f self.agg_n_vts = len(flat_obj.v) if self.patch_id >= 0: self.patch_manager = PatchManager( shared_data_dir=res_ctx['shared_data_dir']) self.patch_vt_ids = self.patch_manager.load_patch_vt_ids( self.patch_id) self.patch_fc_ids = self.patch_manager.get_patch_fc_ids( self.patch_vt_ids, self.f) self.patch_local_fcs = self.patch_manager.get_patch_local_fcs( self.patch_vt_ids, self.f[self.patch_fc_ids]) patch_edge_ids = self.patch_manager.get_patch_edge_ids( self.patch_vt_ids, edges) m = m[self.patch_vt_ids] l0 = l0[patch_edge_ids] edges = self.patch_manager.get_patch_edges(self.patch_id, edges) k = k[patch_edge_ids] self.pd_dir = join(self.pd_dir, 'p{}'.format(self.patch_id)) self.cr_dir = join(self.cr_dir, 'p{}'.format(self.patch_id)) else: self.pd_dir = join(self.pd_dir, 'whole') self.cr_dir = join(self.cr_dir, 'whole') self.opt_dir = join(self.pd_dir, 'opt') if not isdir(self.pd_dir): os.makedirs(self.pd_dir) if not isdir(self.cr_dir): os.makedirs(self.cr_dir) if not isdir(self.opt_dir): os.makedirs(self.opt_dir) self.use_axial_springs = True if self.use_axial_springs: axial_i, axial_w = load_axial_data(res_ctx) if self.patch_id >= 0: axial_i, axial_w = get_patch_axial_data( self.patch_vt_ids, axial_i, axial_w) m0, m1, m2, m3 = m[axial_i[:, 0]], m[axial_i[:, 1]], m[ axial_i[:, 2]], m[axial_i[:, 3]] axial_harmonic_m = 4 / (1 / m0 + 1 / m1 + 1 / m2 + 1 / m3) axial_k = axial_harmonic_m * 1e-1 # m*=2 # m*=0.05 m *= 0.2 # out_dir='spring_test/data' # if not isdir(out_dir): # os.makedirs(out_dir) # np.savetxt(join(out_dir,'stiffen_anchor.txt'),m,fmt='%.100f') # np.savetxt(join(out_dir,'edges.txt'),edges,fmt='%d') # np.savetxt(join(out_dir,'l0.txt'),l0,fmt='%.100f') # np.savetxt(join(out_dir,'k.txt'),k,fmt='%.100f') # np.savetxt(join(out_dir,'axial_i.txt'),axial_i,fmt='%d') # np.savetxt(join(out_dir,'axial_w.txt'),axial_w,fmt='%.100f') # np.savetxt(join(out_dir,'axial_k.txt'),axial_k,fmt='%.100f') # exit(0) # self.m=torch.ones((len(m),1)).to(dtype=self.dtype,device=self.device) # self.m=(torch.ones((len(m),1))+(torch.rand((len(m),1))-0.5)*1).to(dtype=self.dtype,device=self.device)*4 self.stiffen_anchors_net = torch.from_numpy(m).to( dtype=self.dtype, device=self.device).view(-1, 1) / 2 self.stiffen_anchors_reg = torch.from_numpy(m).to( dtype=self.dtype, device=self.device).view(-1, 1) / 2 self.edges = torch.from_numpy(edges).to(dtype=torch.long, device=self.device).view( -1, 2) self.l0 = torch.from_numpy(l0).to(dtype=self.dtype, device=self.device).view(-1, 1) self.k = torch.from_numpy(k).to(dtype=self.dtype, device=self.device).view(-1, 1) if self.use_axial_springs: axial_i = torch.from_numpy(axial_i).to(dtype=torch.long, device=self.device).view( -1, 4) axial_w = torch.from_numpy(axial_w).to(dtype=self.dtype, device=self.device).view( -1, 4) axial_k = torch.from_numpy(axial_k).to(dtype=self.dtype, device=self.device).view( -1, 1) self.axial_data = (axial_i, axial_w, axial_k) else: self.axial_data = None def read_obj(self, path, patch_id=-1): pd_obj = read_obj(path) pd_vt = pd_obj.v f = pd_obj.f if patch_id >= 0: pd_vt = pd_vt[self.patch_vt_ids] f = f[self.patch_fc_ids] return pd_vt, f 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 test_forward(self, sample_id, n_iters=10): # gt_path=join(self.pd_dir,'gt_{:08d}.obj'.format(sample_id)) # v,f=self.read_obj(gt_path,patch_id=self.patch_id) # print('save gt') # np.savetxt('spring_test/data/gt_{:08d}.txt'.format(sample_id),v,fmt='%.100f') # exit(0) pd_path = join(self.pd_dir, 'pd_{:08d}.obj'.format(sample_id)) v, f = self.read_obj(pd_path, patch_id=self.patch_id) # np.savetxt('spring_test/data/fcs.txt',f,fmt='%d') # np.savetxt('spring_test/data/anchor.txt',v,fmt='%.100f') v = torch.from_numpy(v).to(device=self.device, dtype=self.dtype) system = SpringOptSystem(self.stiffen_anchors_net, self.stiffen_anchors_reg, self.edges, self.l0, self.k, m_alpha=0.1, axial_data=self.axial_data) opt = NewtonOpt(system, newton_tol=1e-3, cg_tol=1e-3, cg_max_iter=1000) x = v start_time = time.time() for i in range(n_iters): x, data, success = opt.solve(v, x) # print('diff',torch.norm(x-v).item()) end_time = time.time() print('forward time:', end_time - start_time) if i % 1 == 0: x_save = x.detach().cpu().numpy() cr_path = join(self.cr_dir, 'cr_{:08d}_i{:02d}.obj'.format(sample_id, i)) self.write_obj(x_save, f, cr_path, patch_id=self.patch_id) cr_path = join(self.cr_dir, 'cr_{:08d}.npy'.format(sample_id)) np.save(cr_path, x_save) # m_path=join(self.cr_dir,'m_{:08d}.npy'.format(sample_id)) # np.save(m_path,data['m_adjusted'].cpu().numpy()) # data_dir=join(self.cr_dir,'data') # if not isdir(data_dir): # os.makedirs(data_dir) # save_data(data_dir,gather_data([data])) def test_dataset(self, start, end, n_iters=10): gt_offset_dir = join(self.data_root_dir, 'lowres_offset_npys') skin_dir = join(self.data_root_dir, 'lowres_skin_npys') out_dir = join(self.data_root_dir, 'lowres_offsets_i{}'.format(n_iters)) if not isdir(out_dir): os.makedirs(out_dir) system = SpringOptSystem(self.m, self.edges, self.l0, self.k, m_alpha=0.1, axial_data=self.axial_data) opt = NewtonOpt(system, newton_tol=1e-12, cg_tol=1e-3, cg_max_iter=250) for sample_id in range(start, end + 1): print('sample_id', sample_id) try: offset = np.load( join(gt_offset_dir, 'offset_{:08d}.npy'.format(sample_id))) skin = np.load( join(skin_dir, 'skin_{:08d}.npy'.format(sample_id))) x = torch.from_numpy(offset + skin).to(device=self.device, dtype=self.dtype) for i in range(n_iters): x = opt.solve(x) x_save = x.cpu().numpy() offset_save = x_save - skin np.save(join(out_dir, 'offset_{:08d}.npy'.format(sample_id)), offset_save) # cr_path=join(self.cr_dir,'cr_{:08d}.obj'.format(sample_id)) # self.write_obj(x_save,None,cr_path,patch_id=self.patch_id) except: continue def test_forward_dir(self, in_dir, out_dir, n_iters=1, start=0, end=2247): system = SpringOptSystem(self.stiffen_anchors_net, self.stiffen_anchors_reg, self.edges, self.l0, self.k, m_alpha=0.1, axial_data=self.axial_data) opt = NewtonOpt(system, newton_tol=1e-12, cg_tol=1e-3, cg_max_iter=250) if not isdir(out_dir): os.makedirs(out_dir) for sample_id in range(start, end + 1): pd_path = join(in_dir, '{:08d}.obj'.format(sample_id)) v, f = self.read_obj(pd_path, patch_id=self.patch_id) v = torch.from_numpy(v).to(device=self.device, dtype=self.dtype) x = v start_time = time.time() for i in range(n_iters): x, data, success = opt.solve(v, x) end_time = time.time() print('forward time:', end_time - start_time) x_save = x.detach().cpu().numpy() cr_path = join(out_dir, '{:08d}.obj'.format(sample_id)) self.write_obj(x_save, f, cr_path, patch_id=self.patch_id) def test_backward(self, sample_id): pd_path = join(self.pd_dir, 'pd_{:08d}.obj'.format(sample_id)) pd_v, f = self.read_obj(pd_path, patch_id=self.patch_id) pd_v = torch.from_numpy(pd_v).to(device=self.device, dtype=self.dtype) gt_path = join(self.pd_dir, 'gt_{:08d}.obj'.format(sample_id)) gt_v, _ = self.read_obj(gt_path, patch_id=self.patch_id) gt_v = torch.from_numpy(gt_v).to(device=self.device, dtype=self.dtype) dv = pd_v - gt_v cr_path = join(self.cr_dir, 'cr_{:08d}.npy'.format(sample_id)) cr_v = np.load(cr_path) cr_v = torch.from_numpy(cr_v).to(device=self.device, dtype=self.dtype) # m_path=join(self.cr_dir,'m_{:08d}.npy'.format(sample_id)) # m_adjusted=np.load(m_path) # m_adjusted=torch.from_numpy(m_adjusted).to(device=self.device,dtype=self.dtype) # system=SpringOptSystem(self.m,self.edges,self.l0,self.k,m_alpha=0.1,axial_data=self.axial_data) system = SpringOptSystem(self.stiffen_anchors_net, self.stiffen_anchors_reg, self.edges, self.l0, self.k, m_alpha=0.1, axial_data=self.axial_data) system.use_m_adjusted = False data = system.get_data(cr_v) data['c'] = pd_v data['anchors_net'] = pd_v data['anchors_reg'] = pd_v data['stiffen_anchors_net'] = self.stiffen_anchors_net data['stiffen_anchors_reg'] = self.stiffen_anchors_reg # data['m_adjusted']=m_adjusted J = system.get_J(data) norm_J = torch.norm(J) data['J_rms'] = norm_J / np.sqrt(len(cr_v)) dx = spring_opt_backward(system, data, dv, cg_tol=1e-3, cg_max_iter=250) grad_path = join(self.cr_dir, 'grad_{:08d}.npy'.format(sample_id)) print('save to', grad_path) np.save(grad_path, dx.cpu().numpy()) def test_grad(self, sample_id): pd_path = join(self.pd_dir, 'pd_{:08d}.obj'.format(sample_id)) print('pd_path', pd_path) pd_vt, _ = self.read_obj(pd_path, patch_id=self.patch_id) grad = np.load(join(self.cr_dir, 'grad_{:08d}.npy'.format(sample_id))) print('grad.norm', np.linalg.norm(grad)) grad_len = 1 ed_vt = pd_vt - grad * grad_len n_vts = len(pd_vt) obj_path = join(self.cr_dir, 'grad_{:08d}.obj'.format(sample_id)) print('write to', obj_path) with open(obj_path, 'w') as f: for v in pd_vt: f.write('v {} {} {}\n'.format(v[0], v[1], v[2])) for v in ed_vt: f.write('v {} {} {}\n'.format(v[0], v[1], v[2])) for i in range(n_vts): f.write('l {} {}\n'.format(i + 1, i + 1 + n_vts)) def test_module(self, sample_id, n_iters=1): pd_path = join(self.pd_dir, 'pd_{:08d}.obj'.format(sample_id)) pd_v, f = self.read_obj(pd_path, patch_id=self.patch_id) pd_v = torch.from_numpy(pd_v).to(device=self.device, dtype=self.dtype).unsqueeze(0) gt_path = join(self.pd_dir, 'gt_{:08d}.obj'.format(sample_id)) gt_v, _ = self.read_obj(gt_path, patch_id=self.patch_id) gt_v = torch.from_numpy(gt_v).to(device=self.device, dtype=self.dtype).unsqueeze(0) proj_module = SpringOptModule(self.res_ctx, self.ctx) x = pd_v x.requires_grad_(True) for i in range(n_iters): x = proj_module(x) loss = torch.sum((gt_v - x)**2) / 2 loss.backward() print('grad.norm', torch.norm(pd_v.grad)) def test_loss_along_line(self, sample_id, n_iters): pd_path = join(self.pd_dir, 'pd_{:08d}.obj'.format(sample_id)) pd_v, f = self.read_obj(pd_path, patch_id=self.patch_id) pd_v = torch.from_numpy(pd_v).to(device=self.device, dtype=self.dtype).unsqueeze(0) # gt_vt=np.load(join(self.data_root_dir,'lowres_skin_npys/skin_{:08d}.npy'.format(sample_id)))+np.load(join(self.data_root_dir,'lowres_offsets_i10/offset_{:08d}.npy'.format(sample_id))) gt_path = join(self.pd_dir, 'gt_{:08d}.obj'.format(sample_id)) gt_v, f = self.read_obj(gt_path, patch_id=self.patch_id) gt_v = torch.from_numpy(gt_v).to(device=self.device, dtype=self.dtype).unsqueeze(0) proj_module = SpringOptModule(self.res_ctx, self.ctx) def f(x): for i in range(n_iters): x = proj_module(x) return torch.sum(((x - gt_v)**2).view(x.size(0), -1), dim=1) / 2 pd_v.requires_grad_(True) loss = f(pd_v) loss.backward() g = pd_v.grad[0] pd_v.requires_grad_(False) loss_list = [] total_n = 100 processed_n = 0 end = 2 batch_size = 1 while processed_n < total_n: x = pd_v.repeat(batch_size, 1, 1) for i in range(batch_size): t = (i + processed_n) / total_n * end x[i] -= t * g loss = f(x) loss_list += loss.tolist() processed_n += batch_size print(loss_list) np.savetxt(join(self.opt_dir, 'loss_{}.txt'.format(end)), np.array(loss_list)) def plot_loss_along_line(self, sample_id): end = 2 loss = np.loadtxt(join(self.opt_dir, 'loss_{}.txt'.format(2))) x = np.linspace(0, end, len(loss)) fig = plt.gcf() ax = plt.gca() ax.plot(x, loss) ax.set_title('iter=10') plot_path = join(self.opt_dir, 'loss_{}.png'.format(end)) print('plot_path', plot_path) fig.savefig(plot_path)
def init_ecos_opt_module(res_ctx,ctx): print('use_lap:',ctx['use_lap']) device,dtype=torch.device('cpu'),ctx['dtype'] batch_size=ctx['batch_size'] verbose=ctx['verbose'] if 'verbose' in ctx else False use_multi_thread=True use_debug=ctx['use_debug'] cvx_opt_cpp.init(batch_size,verbose,use_multi_thread,use_debug) m,edges,l0=load_opt_data(res_ctx,ctx) patch_id=ctx['patch_id'] if 'patch_id' in ctx else -1 if patch_id>=0: patch_manager=PatchManager(shared_data_dir=res_ctx['shared_data_dir']) patch_vt_ids=patch_manager.load_patch_vt_ids(patch_id) patch_edge_ids=patch_manager.get_patch_edge_ids(patch_vt_ids,edges) m=m[patch_vt_ids] l0=l0[patch_edge_ids] edges=patch_manager.get_patch_edges(patch_id,edges) m=torch.from_numpy(m).to(device=device,dtype=dtype) edges=torch.from_numpy(edges).to(device=device,dtype=torch.long) l0=torch.from_numpy(l0).to(device=device,dtype=dtype) if ctx['use_spring']: k=res_ctx['stiffness'] # set by load_opt_data if patch_id>=0: k=k[patch_edge_ids] res_ctx['stiffness']=k k=torch.from_numpy(k).to(device=device,dtype=dtype) cvx_opt_cpp.init_spring(k,ctx['lmd_k']) print('init_spring') if ctx['use_lap']: assert(patch_id<0) Lpr_np,Ljc_np,Lir_np=load_lap_matrix(res_ctx['shared_data_dir'],len(m)) Lpr=torch.from_numpy(Lpr_np).to(device=device,dtype=dtype) Ljc=torch.from_numpy(Ljc_np[1:]).to(device=device,dtype=torch.long) Lir=torch.from_numpy(Lir_np).to(device=device,dtype=torch.long) print('init_lap') cvx_opt_cpp.init_lap(Lpr,Ljc,Lir,ctx['lmd_lap']) cvx_opt_cpp.init_forward(m,edges,l0) cvx_opt_cpp.init_backward() print('n_edges:',len(edges)) maxit=ctx.get('maxit',50) feastol=ctx.get('feastol',1e-6) abstol=ctx.get('abstol',1e-6) reltol=ctx.get('reltol',5e-1) # reltol=ctx.get('reltol',1e-6) feastol_inacc=ctx.get('feastol_inacc',5e-3) abstol_inacc=ctx.get('abstol_inacc',1e-2) reltol_inacc=ctx.get('reltol_inacc',5e0) print('maxit',maxit,'feastol',feastol,'abstol',abstol,'reltol',reltol,'feastol_inacc',feastol_inacc,'abstol_inacc',abstol_inacc,'reltol_inacc',reltol_inacc) cvx_opt_cpp.init_options(maxit,feastol,abstol,reltol,feastol_inacc,abstol_inacc,reltol_inacc) module=EcosOptModule() module.edges=edges.numpy() module.m=m.numpy() module.l0=l0.numpy() if ctx['use_spring']: module.k=k if ctx['use_lap']: n_vts=len(m) module.L=csc_matrix((Lpr_np,Lir_np,Ljc_np),(n_vts,n_vts)) return module
return ratios def plot_ratios(path,ratios,title,xlim): ax=plt.gca() fig=plt.gcf() ax.hist(ratios,bins=20,range=xlim) fig.savefig(path) if __name__=='__main__': shared_data_dir='../../shared_data_midres/' l0=np.loadtxt(join(shared_data_dir,'mat_or_med_linear.txt')) edges=np.loadtxt(join(shared_data_dir,'linear_edges.txt')).astype(np.int) patch_id=13 if patch_id>=0: patch_manager=PatchManager(shared_data_dir=shared_data_dir) patch_vt_ids=patch_manager.load_patch_vt_ids(patch_id) patch_edge_ids=patch_manager.get_patch_edge_ids(patch_vt_ids,edges) l0=l0[patch_edge_ids] edges=patch_manager.get_patch_edges(patch_id,edges) ratios_path='figs/0528/ratios_vt.npy' png_path='figs/0528/ratios_vt.png' # ratios=compute_edge_lengths('../../rundir/midres_vt_patch/t0/eval_test/waist_front_hip_front_hip_right_waist_right','pd_{:08d}.obj',edges,l0) # np.save(ratios_path,ratios) # ratios=np.load(ratios_path) # plot_ratios(png_path,ratios,'w/o cvx',(0.8,1.2)) ratios=np.load('figs/0528/ratios_avg.npy') plot_ratios('figs/0528/ratios_avg.png',ratios,'avg',(0.8,1.2))