def disp_deformed_grid_lines(self,level,color=None,lw=1): # return if self.hlines is None or self.vlines is None: raise ValueError hlines,vlines=self.hlines,self.vlines # for lines,c in zip([hlines,vlines],['r','b']): # pts_at_0=np.asarray([lines[:,0,:].flatten(), # lines[:,1,:].flatten()]).T # pts_at_0 = CpuGpuArray(pts_at_0.copy()) # pts_at_T=CpuGpuArray.zeros_like(pts_at_0) # self.calc_T_fwd(pts_src=pts_at_0, # pts_fwd=pts_at_T, # level=level,verbose=0,int_quality=1) # if self.nCols != self.nCols: # raise NotImplementedError # pts_at_T.gpu2cpu() # lines_new_x=pts_at_T.cpu[:,0].reshape(lines[:,0,:].shape).copy() # lines_new_y=pts_at_T.cpu[:,1].reshape(lines[:,0,:].shape).copy() # for line_new_x,line_new_y in zip(lines_new_x,lines_new_y): # # plt.plot(line_new_x,line_new_y,c) if color is None: colors=['r','b'] else: colors=[color,color] s = hlines.shape if s[2]<=1: raise ValueError p = 0 L = 50000 if L >=s[2]: while p < np.ceil(s[2]): hlines=self.hlines[:,:,p:p+L] vlines=self.vlines[:,:,p:p+L] p+=L for lines,c in zip([hlines,vlines],colors): pts_at_0=np.asarray([lines[:,0,:].flatten(), lines[:,1,:].flatten()]).T if pts_at_0.size==0: break pts_at_0 = CpuGpuArray(pts_at_0.copy()) pts_at_T=CpuGpuArray.zeros_like(pts_at_0) self.calc_T_fwd(pts_src=pts_at_0, pts_fwd=pts_at_T, level=level,int_quality=1) if self.nCols != self.nCols: raise NotImplementedError pts_at_T.gpu2cpu() lines_new_x=pts_at_T.cpu[:,0].reshape(lines[:,0,:].shape).copy() lines_new_y=pts_at_T.cpu[:,1].reshape(lines[:,0,:].shape).copy() for line_new_x,line_new_y in zip(lines_new_x,lines_new_y): plt.plot(line_new_x,line_new_y,c,lw=lw) else: raise NotImplementedError
def __init__(self,ms,level,data, sigma_lm, params_flow_int, # src=None,dst=None,transformed=None ): # ipshell('hi') """ Cost is level-dependent. TODO: GPU in the LL part. """ src=data['src'] dst=data['dst'] transformed=data['transformed'] if not isinstance(src,CpuGpuArray): raise ObsoleteError if not isinstance(dst,CpuGpuArray): raise ObsoleteError if not isinstance(transformed,CpuGpuArray): raise ObsoleteError self.nCalls = 0 self.nCallbacks = 0 self.sigma_lm=sigma_lm cpa_space=ms.L_cpa_space[level] self.cpa_space = cpa_space # 1/0 if src.shape[1] != cpa_space.dim_domain: raise ValueError(src.shape,cpa_space.dim_domain) # # self.cpa_space = cpa_space # self.cpa_cov_inv = msp.L_cpa_space_covs[level].cpa_cov_inv self.mu = cpa_space.get_zeros_theta() self.src = src self.dst = dst self.transformed = transformed nPts = len(src) self.nPts = nPts self.err = CpuGpuArray.zeros_like(src) self.ll = CpuGpuArray.zeros(nPts,dtype=src.dtype) self.params_flow_int=params_flow_int self._pat = PAT(pa_space=cpa_space, Avees=cpa_space.get_zeros_PA())
def __init__( self, ms, level, data, sigma_lm, params_flow_int, # src=None,dst=None,transformed=None ): # ipshell('hi') src = data['src'] dst = data['dst'] transformed = data['transformed'] if not isinstance(src, CpuGpuArray): raise ObsoleteError if not isinstance(dst, CpuGpuArray): raise ObsoleteError if not isinstance(transformed, CpuGpuArray): raise ObsoleteError self.nCalls = 0 self.nCallbacks = 0 self.sigma_lm = sigma_lm cpa_space = ms.L_cpa_space[level] self.cpa_space = cpa_space if src.shape[1] != cpa_space.dim_domain: raise ValueError(src.shape, cpa_space.dim_domain) self.mu = cpa_space.get_zeros_theta() self.src = src self.dst = dst self.transformed = transformed nPts = len(src) self.nPts = nPts self.err = CpuGpuArray.zeros_like(src) self.ll = CpuGpuArray.zeros(nPts, dtype=src.dtype) if nPts <= 1: raise ValueError self.err_by_der = CpuGpuArray.zeros((nPts - 1, src.shape[1]), dtype=src.dtype) self.ll_by_der = CpuGpuArray.zeros(nPts - 1, dtype=src.dtype) self.params_flow_int = params_flow_int self._pat = PAT(pa_space=cpa_space, Avees=cpa_space.get_zeros_PA())
def __init__(self,ms,level,data, sigma_lm, params_flow_int, # src=None,dst=None,transformed=None ): # ipshell('hi') src=data['src'] dst=data['dst'] transformed=data['transformed'] if not isinstance(src,CpuGpuArray): raise ObsoleteError if not isinstance(dst,CpuGpuArray): raise ObsoleteError if not isinstance(transformed,CpuGpuArray): raise ObsoleteError self.nCalls = 0 self.nCallbacks = 0 self.sigma_lm=sigma_lm cpa_space=ms.L_cpa_space[level] self.cpa_space = cpa_space if src.shape[1] != cpa_space.dim_domain: raise ValueError(src.shape,cpa_space.dim_domain) self.mu = cpa_space.get_zeros_theta() self.src = src self.dst = dst self.transformed = transformed nPts = len(src) self.nPts = nPts self.err = CpuGpuArray.zeros_like(src) self.ll = CpuGpuArray.zeros(nPts,dtype=src.dtype) if nPts <= 1: raise ValueError self.err_by_der = CpuGpuArray.zeros((nPts-1,src.shape[1]),dtype=src.dtype) self.ll_by_der = CpuGpuArray.zeros(nPts-1,dtype=src.dtype) self.params_flow_int=params_flow_int self._pat = PAT(pa_space=cpa_space, Avees=cpa_space.get_zeros_PA())
def set_data(self, data): if data.kind != 'landmarks': raise NotImplementedError self.kind = data.kind src = data.src dst = data.dst self.landmarks_are_lin_ordered = data.landmarks_are_lin_ordered if not isinstance(src, CpuGpuArray): raise TypeError(type(src)) if not isinstance(dst, CpuGpuArray): raise TypeError(type(dst)) if src.shape != dst.shape: raise ValueError(src.shape, dst.shape) self.src = src self.dst = dst self.transformed = CpuGpuArray.zeros_like(self.dst)
def set_data(self,data): if data.kind!= 'landmarks': raise NotImplementedError self.kind=data.kind src=data.src dst=data.dst self.landmarks_are_lin_ordered = data.landmarks_are_lin_ordered if not isinstance(src,CpuGpuArray): raise TypeError(type(src)) if not isinstance(dst,CpuGpuArray): raise TypeError(type(dst)) if src.shape != dst.shape: raise ValueError(src.shape,dst.shape) self.src = src self.dst = dst self.transformed = CpuGpuArray.zeros_like(self.dst)
def set_data(self,x,y,range_start,range_end): """ For now, assumes dst was evaluated on evenly-space points """ if x.shape != y.shape: raise ValueError(x.shape,y.shape) if x.dtype != np.float64: raise TypeError(x.dtype) if y.dtype != np.float64: raise TypeError(y.dtype) nPts = len(x) self.x=x self.y=y self.y_scale = range_end-range_start self.y_offset = range_start dst = (y-self.y_offset)/self.y_scale if dst.ndim == 1: dst = dst.reshape(nPts,1).copy() if not isinstance(dst,CpuGpuArray): dst = CpuGpuArray(dst) self.dst=dst # cpa_space = self.tw.ms.L_cpa_space[0] domain_start,domain_end = self.domain_start,self.domain_end # self.interval = np.linspace(domain_start,domain_end,nPts) # line = (x - domain_start) / ( domain_end - domain_start) line = self.manipulate_predictors(x) if line.ndim == 1: line = line.reshape(nPts,1).copy() self.src=CpuGpuArray(line) self.transformed = CpuGpuArray.zeros_like(self.src)
def set_data(self, x, y, range_start, range_end): """ For now, assumes dst was evaluated on evenly-space points """ if x.shape != y.shape: raise ValueError(x.shape, y.shape) if x.dtype != np.float64: raise TypeError(x.dtype) if y.dtype != np.float64: raise TypeError(y.dtype) nPts = len(x) self.x = x self.y = y self.y_scale = range_end - range_start self.y_offset = range_start dst = (y - self.y_offset) / self.y_scale if dst.ndim == 1: dst = dst.reshape(nPts, 1).copy() if not isinstance(dst, CpuGpuArray): dst = CpuGpuArray(dst) self.dst = dst # cpa_space = self.tw.ms.L_cpa_space[0] domain_start, domain_end = self.domain_start, self.domain_end # self.interval = np.linspace(domain_start,domain_end,nPts) # line = (x - domain_start) / ( domain_end - domain_start) line = self.manipulate_predictors(x) if line.ndim == 1: line = line.reshape(nPts, 1).copy() self.src = CpuGpuArray(line) self.transformed = CpuGpuArray.zeros_like(self.src)
def __init__( self, ms, level, data, sigma_signal, params_flow_int, interp_type_for_ll, # src=None,dst=None,transformed=None ): # ipshell('hi') if interp_type_for_ll not in self.supported_interp_types: msg = """ interp_type_for_ll must be in ['gpu_linear', cv2.INTER_LINEAR, cv2.INTER_CUBIC, cv2.INTER_LANCZOS4] """ raise ValueError(msg, interp_type_for_ll) self.interp_type_for_ll = interp_type_for_ll src = data['src'] transformed = data['transformed'] signal = data['signal'] for obj in [src, transformed]: if not isinstance(obj, CpuGpuArray): raise TypeError for obj in [signal.src, signal.dst, signal.transformed]: if not isinstance(obj, CpuGpuArray): raise TypeError self.nCalls = 0 self.nCallbacks = 0 self.sigma_signal = sigma_signal cpa_space = ms.L_cpa_space[level] self.cpa_space = cpa_space if src.shape[1] != cpa_space.dim_domain: raise ValueError(src.shape, cpa_space.dim_domain) # self.mu = cpa_simple_mean(cpa_space) self.my = cpa_space.get_zeros_theta() self.src = src self.transformed = transformed self.signal = signal # self.dim_signal = signal.src.shape[1] if signal.src.ndim == 2: self.dim_signal = 2 else: raise NotImplementedError if self.dim_signal != 2: raise NotImplementedError(signal.src.shape) if self.signal.src.shape != self.signal.dst.shape: raise ValueError if self.signal.src.shape != self.signal.transformed.shape: raise ValueError nPts = len(src) self.nPts = nPts # self.err = CpuGpuArray.zeros_like(src) # self.signal.err = CpuGpuArray.zeros_like(src) self.signal.err = CpuGpuArray.zeros_like(self.signal.src) self.ll = CpuGpuArray.zeros(nPts, dtype=src.dtype) if nPts <= 1: raise ValueError self.params_flow_int = params_flow_int self._pat = PAT(pa_space=cpa_space, Avees=cpa_space.get_zeros_PA())
if 0: ds0,ds1,ds2=10,10,10 # pts_grid=cpa_space.x_dense_grid[:,::ds0,::ds1,50:51] pts_grid=cpa_space.x_dense_grid[:,::ds0,::ds1,::ds2] pts=np.vstack([pts_grid[0].ravel(), pts_grid[1].ravel(), pts_grid[2].ravel()]).T.copy() pts = CpuGpuArray(pts) print pts_grid.shape print pts.shape pts_transformed = CpuGpuArray.zeros_like(pts) mu = cpa_space.get_zeros_theta() np.random.seed(0) # theta *= 4 # cpa_space.theta2Avees(theta=theta) cpa_space.update_pat()
def example(tess='I', base=[2, 2, 2], nLevels=1, zero_v_across_bdry=[True] * 3, vol_preserve=False, nRows=100, nCols=100, nSlices=100, use_mayavi=False, eval_v=False, eval_cell_idx=False): tw = TransformWrapper(nRows=nRows, nCols=nCols, nSlices=nSlices, nLevels=nLevels, base=base, zero_v_across_bdry=zero_v_across_bdry, tess=tess, valid_outside=False, only_local=False, vol_preserve=vol_preserve) print_iterable(tw.ms.L_cpa_space) print tw # create some fake 3D image. img = np.zeros((nCols, nRows, nSlices), dtype=np.float64) # img[:]=np.random.random_integers(0,255,img.shape) # Fill the image with the x coordinates as fake values img[:] = tw.pts_src_dense.cpu[:, 0].reshape(img.shape) img0 = CpuGpuArray(img.copy().astype(np.float64)) img_wrapped_fwd = CpuGpuArray.zeros_like(img0) img_wrapped_inv = CpuGpuArray.zeros_like(img0) seed = 0 np.random.seed(seed) ms_Avees = tw.get_zeros_PA_all_levels() ms_theta = tw.get_zeros_theta_all_levels() if tess == 'II': for level in range(tw.ms.nLevels): cpa_space = tw.ms.L_cpa_space[level] Avees = ms_Avees[level] # 1/0 if level == 0: tw.sample_gaussian(level, ms_Avees[level], ms_theta[level], mu=None) # zero mean # ms_theta[level].fill(0) # ms_theta[level][-4]=10 cpa_space.theta2Avees(theta=ms_theta[level], Avees=Avees) else: tw.sample_from_the_ms_prior_coarse2fine_one_level( ms_Avees, ms_theta, level_fine=level) else: # For tess='I' in 3D, I have yet to implement the coarse-to-fine sampling. for level in range(tw.ms.nLevels): cpa_space = tw.ms.L_cpa_space[level] velTess = cpa_space.zeros_velTess() ms_Avees[level].fill(0) Avees = ms_Avees[level] tw.sample_gaussian_velTess(level, Avees, velTess, mu=None) print 'img shape:', img0.shape # You don't have use these. You can use any 2d array # that has 3 columns (regardless of the number of rows). pts_src = tw.pts_src_dense pts_src = CpuGpuArray(pts_src.cpu[::1].copy()) # Create a buffer for the output pts_fwd = CpuGpuArray.zeros_like(pts_src) pts_inv = CpuGpuArray.zeros_like(pts_src) for level in range(tw.ms.nLevels): tw.update_pat_from_Avees(ms_Avees[level], level) if eval_v: # Evaluating the velocity field. # You don't have to do it in unless you want to visualize v. # (when evaluting the treansformation, v will be internally # evaluated anyway -- but its result won't be stored) tw.calc_v(level=level) print 'level', level print print 'number of points:', len(pts_src) print 'number of cells:', tw.ms.L_cpa_space[level].nC # optional, if you want to time it timer_gpu_T_fwd = GpuTimer() # Simply calling # tic = time.clock() # and then # tic = time.clock() # won't work. # In fact, most likely you will get that toc-tic is zero. # You need to use the GpuTimer object. When you do that, # one side effect is that suddenly the toc-tic from above will # give you a more realistic result. tic = time.clock() timer_gpu_T_fwd.tic() tw.calc_T_fwd(pts_src, pts_fwd, level=level) timer_gpu_T_fwd.toc() toc = time.clock() print 'Time, in sec, for computing T_fwd:' print timer_gpu_T_fwd.secs print toc - tic # likely to be 0, unless you also used the GpuTimer. # You can also time the inv of course. Results will be similar. tw.calc_T_inv(pts_src, pts_inv, level=level) if eval_cell_idx: # cell_idx is computed here just for display. cell_idx = CpuGpuArray.zeros(len(pts_src), dtype=np.int32) tw.calc_cell_idx(pts_src, cell_idx, level) tw.remap_fwd(pts_inv, img0, img_wrapped_fwd) tw.remap_inv(pts_fwd, img0, img_wrapped_inv) # For display purposes, do gpu2cpu transfer print "For display purposes, do gpu2cpu transfer" if eval_cell_idx: cell_idx.gpu2cpu() if eval_v: tw.v_dense.gpu2cpu() pts_fwd.gpu2cpu() pts_inv.gpu2cpu() img_wrapped_fwd.gpu2cpu() img_wrapped_inv.gpu2cpu() if use_mayavi: ds = 1 # downsampling factor i = 17 pts_src_grid = pts_src.cpu.reshape(tw.nRows, tw.nCols, -1, 3) pts_src_ds = pts_src_grid[::ds, ::ds, i].reshape(-1, 3) pts_fwd_grid = pts_fwd.cpu.reshape(tw.nRows, tw.nCols, -1, 3) pts_fwd_ds = pts_fwd_grid[::ds, ::ds, i].reshape(-1, 3) pts_inv_grid = pts_inv.cpu.reshape(tw.nRows, tw.nCols, -1, 3) pts_inv_ds = pts_inv_grid[::ds, ::ds, i].reshape(-1, 3) from of.my_mayavi import * mayavi_mlab_close_all() mayavi_mlab_figure_bgwhite('src') x, y, z = pts_src_ds.T mayavi_mlab_plot3d(x, y, z) mayavi_mlab_figure_bgwhite('fwd') x, y, z = pts_fwd_ds.T mayavi_mlab_plot3d(x, y, z) figsize = (12, 12) plt.figure(figsize=figsize) i = 17 # some slice plt.subplot(131) plt.imshow(img0.cpu[:, :, i].astype(np.uint8), interpolation="Nearest") plt.title('slice from img') plt.subplot(132) plt.imshow(img_wrapped_fwd.cpu[:, :, i].astype(np.uint8), interpolation="Nearest") plt.axis('off') plt.title('slice from fwd(img)') plt.subplot(133) plt.imshow(img_wrapped_inv.cpu[:, :, i].astype(np.uint8), interpolation="Nearest") plt.axis('off') plt.title('slice from inv(img)') if 0: # debug cpa_space = tw.ms.L_cpa_space[level] if eval_v: vx = tw.v_dense.cpu[:, 0].reshape( cpa_space.x_dense_grid_img.shape[1:]) vy = tw.v_dense.cpu[:, 1].reshape( cpa_space.x_dense_grid_img.shape[1:]) vz = tw.v_dense.cpu[:, 2].reshape( cpa_space.x_dense_grid_img.shape[1:]) plt.figure() plt.imshow(vz[:, :, 17], interpolation="Nearest") plt.colorbar() plt.title('vz in some slice') return tw
def __init__(self,nRows,nCols,vol_preserve=False, nLevels=1, base=[2,2], scale_spatial=1.0 * .1, scale_value=100, zero_v_across_bdry=[False]*2, # For now, don't change that. tess = None, valid_outside=True, only_local=False, cont_constraints_are_separable=False): """ Input params: nRows: number of rows in the image nCols: number of cols in the image vol_preserve: boolean flag (area-preserving or not) nLevels: number of levels in the multiscale representation base = (# of cells in X direction, # of cells in Y direction) Determines the resolution of the tesselation as the base level of the multiscale representation. scale_spatial: paramter for the Gaussian prior. Higher val <=> more smoothness scale_value: paramter for the Gaussian prior. Higher val <=> larger covariance """ super(type(self),self).__init__( vol_preserve=vol_preserve, nLevels=nLevels, base=base, scale_spatial=scale_spatial, scale_value=scale_value, zero_v_across_bdry=zero_v_across_bdry, tess=tess, valid_outside=valid_outside, only_local=only_local, cont_constraints_are_separable=cont_constraints_are_separable) self.nRows = self.args.nRows = nRows self.nCols = self.args.nCols = nCols print self.args # print if tess=='tri': tess='I' if tess=='rect': tess=='II' if tess not in ['I','II']: raise ValueError(tess,"tess must be in ['I','II']") if only_local and tess !='I': raise NotImplementedError self.nRows=nRows self.nCols=nCols XMINS=[0,0] XMAXS=[nCols,nRows] # Note: This inclusive; e.g., if your image is # 512x512, XMAXS=[512,512], not [511,511] # XMINS=[-nCols/2,-nRows/2] # XMAXS=[ nCols/2, nRows/2] warp_around=[False,False] # For now, don't change that. # zero_v_across_bdry=[False,False] # For now, don't change that. Nx = XMAXS[0]-XMINS[0] Ny = XMAXS[1]-XMINS[1] self.config_plt = ConfigPlt(Nx=Nx,Ny=Ny) Ngrids=[Nx,Ny] ms=Multiscale(XMINS,XMAXS,zero_v_across_bdry, vol_preserve, warp_around=warp_around, nLevels=nLevels,base=base, tess=tess, Ngrids=Ngrids, valid_outside=valid_outside, only_local=only_local, cont_constraints_are_separable=cont_constraints_are_separable) self.ms=ms if only_local == False: self.msp=MultiscaleCoarse2FinePrior(ms,scale_spatial=scale_spatial, scale_value=scale_value, left_blk_std_dev=1.0/100,right_vec_scale=1) else: self.msp = None self.pts_src_dense = CpuGpuArray(ms.L_cpa_space[0].x_dense_img.copy()) self.v_dense = CpuGpuArray.zeros_like(self.pts_src_dense) self.transformed_dense = CpuGpuArray.zeros_like(self.pts_src_dense) self.params_flow_int = get_params_flow_int() self.params_flow_int.nStepsODEsolver = 10 # Usually this is enough. self.params_flow_int_coarse = copy.deepcopy(self.params_flow_int) self.params_flow_int_coarse.nTimeSteps /= 10 self.params_flow_int_coarse.dt *= 10 self.params_flow_int_fine = copy.deepcopy(self.params_flow_int) self.params_flow_int_fine.nTimeSteps *= 10 self.params_flow_int_fine.dt /= 10 self.ms_pats = ms.pats
def set_dense(self): self.src_dense = self.tw.pts_src_dense self.transformed_dense = CpuGpuArray.zeros_like(self.src_dense)
# x_select = x_select.copy() # x_select = x[::100/2].copy() x_select = CpuGpuArray(x_dense.cpu[::100/2].copy()) # x_select[:]=np.linspace(.1,1.0,len(x_select)) # x_select[3:-1] +=.1 # x_select[6:-1] -=.05 # pat = PAT(pa_space=cpa_space,Avees=sample_Avees_all_levels[level]) cpa_space.update_pat(Avees=sample_Avees_all_levels[level]) # v_dense = CpuGpuArray.zeros_like(x_dense) cpa_space.calc_v(pts=x_dense,out=v_dense) src=x_dense print '#pts =',len(src) transformed = CpuGpuArray.zeros_like(src) tic=time.clock() cpa_space.calc_T(pts = src, mysign=1,out=transformed,**params_flow_int) toc = time.clock() print "time (src)",toc-tic
def set_data(self,x,signal_src,signal_dst,isbinary): """ For now, assumes dst was evaluated on evenly-space points // Is the comment above still current? """ self.isbinary=isbinary nPts = len(x) if x.ndim !=2 or x.shape[1]!=2: raise ValueError(x.shape) if signal_src.shape != signal_dst.shape: raise ValueError(gnal_src.shape , signal_dst.shape) if signal_src.ndim !=2: # Want a single channel raise ValueError(signal_src.shape) # signal_src = signal_src.reshape(nPts,1).astype(np.float64) # signal_dst = signal_dst.reshape(nPts,1).astype(np.float64) signal_src = signal_src.astype(np.float64) signal_dst = signal_dst.astype(np.float64) # if nPts != signal_src.shape[0]: # raise ValueError( nPts , signal_src.shape) # if x.shape[0] != signal_dst.shape[0]: # raise ValueError( nPts , signal_dst.shape) if nPts != signal_src.size: raise ValueError( nPts , signal_src.shape) if x.shape[0] != signal_dst.size: raise ValueError( nPts , signal_dst.shape) if x.dtype != np.float64: raise TypeError(x.dtype) if signal_src.dtype != np.float64: raise TypeError(signal_src.dtype) if signal_dst.dtype != np.float64: raise TypeError(signal_dst.dtype) if signal_src.ndim == 1: raise ValueError(signal_src.ndim) if signal_dst.ndim == 1: raise ValueError(signal_dst.ndim) if not isinstance(signal_src,CpuGpuArray): signal_src = CpuGpuArray(signal_src) if not isinstance(signal_dst,CpuGpuArray): signal_dst = CpuGpuArray(signal_dst) self.signal = Bunch() self.signal.src=signal_src self.signal.dst=signal_dst self.src = x self.transformed = CpuGpuArray.zeros_like(self.src) self.signal.transformed=CpuGpuArray.zeros_like(signal_src)
def example(tess='I',base=[2,2,2],nLevels=1, zero_v_across_bdry=[True]*3, vol_preserve=False, nRows=100, nCols=100,nSlices=100, use_mayavi=False, eval_v=False, eval_cell_idx=False): tw = TransformWrapper(nRows=nRows, nCols=nCols, nSlices=nSlices, nLevels=nLevels, base=base, zero_v_across_bdry=zero_v_across_bdry, tess=tess, valid_outside=False, only_local=False, vol_preserve=vol_preserve) print_iterable(tw.ms.L_cpa_space) print tw # create some fake 3D image. img = np.zeros((nCols,nRows,nSlices),dtype=np.float64) # img[:]=np.random.random_integers(0,255,img.shape) # Fill the image with the x coordinates as fake values img[:]=tw.pts_src_dense.cpu[:,0].reshape(img.shape) img0 = CpuGpuArray(img.copy().astype(np.float64)) img_wrapped_fwd= CpuGpuArray.zeros_like(img0) img_wrapped_inv= CpuGpuArray.zeros_like(img0) seed=0 np.random.seed(seed) ms_Avees=tw.get_zeros_PA_all_levels() ms_theta=tw.get_zeros_theta_all_levels() if tess == 'II' : for level in range(tw.ms.nLevels): cpa_space = tw.ms.L_cpa_space[level] Avees = ms_Avees[level] # 1/0 if level==0: tw.sample_gaussian(level,ms_Avees[level],ms_theta[level],mu=None)# zero mean # ms_theta[level].fill(0) # ms_theta[level][-4]=10 cpa_space.theta2Avees(theta=ms_theta[level],Avees=Avees) else: tw.sample_from_the_ms_prior_coarse2fine_one_level(ms_Avees,ms_theta, level_fine=level) else: # For tess='I' in 3D, I have yet to implement the coarse-to-fine sampling. for level in range(tw.ms.nLevels): cpa_space = tw.ms.L_cpa_space[level] velTess = cpa_space.zeros_velTess() ms_Avees[level].fill(0) Avees = ms_Avees[level] tw.sample_gaussian_velTess(level,Avees,velTess,mu=None) print 'img shape:',img0.shape # You don't have use these. You can use any 2d array # that has 3 columns (regardless of the number of rows). pts_src = tw.pts_src_dense pts_src=CpuGpuArray(pts_src.cpu[::1].copy()) # Create a buffer for the output pts_fwd = CpuGpuArray.zeros_like(pts_src) pts_inv = CpuGpuArray.zeros_like(pts_src) for level in range(tw.ms.nLevels): tw.update_pat_from_Avees(ms_Avees[level],level) if eval_v: # Evaluating the velocity field. # You don't have to do it in unless you want to visualize v. # (when evaluting the treansformation, v will be internally # evaluated anyway -- but its result won't be stored) tw.calc_v(level=level) print 'level',level print print 'number of points:',len(pts_src) print 'number of cells:',tw.ms.L_cpa_space[level].nC # optional, if you want to time it timer_gpu_T_fwd = GpuTimer() # Simply calling # tic = time.clock() # and then # tic = time.clock() # won't work. # In fact, most likely you will get that toc-tic is zero. # You need to use the GpuTimer object. When you do that, # one side effect is that suddenly the toc-tic from above will # give you a more realistic result. tic = time.clock() timer_gpu_T_fwd.tic() tw.calc_T_fwd(pts_src,pts_fwd,level=level) timer_gpu_T_fwd.toc() toc = time.clock() print 'Time, in sec, for computing T_fwd:' print timer_gpu_T_fwd.secs print toc-tic # likely to be 0, unless you also used the GpuTimer. # You can also time the inv of course. Results will be similar. tw.calc_T_inv(pts_src,pts_inv,level=level) if eval_cell_idx: # cell_idx is computed here just for display. cell_idx = CpuGpuArray.zeros(len(pts_src),dtype=np.int32) tw.calc_cell_idx(pts_src,cell_idx,level) tw.remap_fwd(pts_inv,img0,img_wrapped_fwd) tw.remap_inv(pts_fwd,img0,img_wrapped_inv) # For display purposes, do gpu2cpu transfer print "For display purposes, do gpu2cpu transfer" if eval_cell_idx: cell_idx.gpu2cpu() if eval_v: tw.v_dense.gpu2cpu() pts_fwd.gpu2cpu() pts_inv.gpu2cpu() img_wrapped_fwd.gpu2cpu() img_wrapped_inv.gpu2cpu() if use_mayavi: ds=1 # downsampling factor i= 17 pts_src_grid = pts_src.cpu.reshape(tw.nRows,tw.nCols,-1,3) pts_src_ds=pts_src_grid[::ds,::ds,i].reshape(-1,3) pts_fwd_grid = pts_fwd.cpu.reshape(tw.nRows,tw.nCols,-1,3) pts_fwd_ds=pts_fwd_grid[::ds,::ds,i].reshape(-1,3) pts_inv_grid = pts_inv.cpu.reshape(tw.nRows,tw.nCols,-1,3) pts_inv_ds=pts_inv_grid[::ds,::ds,i].reshape(-1,3) from of.my_mayavi import * mayavi_mlab_close_all() mayavi_mlab_figure_bgwhite('src') x,y,z=pts_src_ds.T mayavi_mlab_plot3d(x,y,z) mayavi_mlab_figure_bgwhite('fwd') x,y,z=pts_fwd_ds.T mayavi_mlab_plot3d(x,y,z) figsize = (12,12) plt.figure(figsize=figsize) i= 17 # some slice plt.subplot(131) plt.imshow(img0.cpu[:,:,i].astype(np.uint8),interpolation="Nearest") plt.title('slice from img') plt.subplot(132) plt.imshow(img_wrapped_fwd.cpu[:,:,i].astype(np.uint8),interpolation="Nearest") plt.axis('off') plt.title('slice from fwd(img)') plt.subplot(133) plt.imshow(img_wrapped_inv.cpu[:,:,i].astype(np.uint8),interpolation="Nearest") plt.axis('off') plt.title('slice from inv(img)') if 0: # debug cpa_space=tw.ms.L_cpa_space[level] if eval_v: vx=tw.v_dense.cpu[:,0].reshape(cpa_space.x_dense_grid_img.shape[1:]) vy=tw.v_dense.cpu[:,1].reshape(cpa_space.x_dense_grid_img.shape[1:]) vz=tw.v_dense.cpu[:,2].reshape(cpa_space.x_dense_grid_img.shape[1:]) plt.figure() plt.imshow(vz[:,:,17],interpolation="Nearest");plt.colorbar() plt.title('vz in some slice') return tw
velTess*=-1 tw.update_pat_from_velTess(velTess,level=0) plt.subplot(222) plt.plot(x,pts_recovered_cf,'g') plt.grid('on') from of.gpu import CpuGpuArray pts_fwd = CpuGpuArray.zeros_like(tw.x_dense) tic=time.clock() tw.calc_T_fwd(tw.x_dense,pts_fwd,level=0,int_quality=1) pts_fwd.gpu2cpu() toc=time.clock() print 'time',toc-tic # 1/0 pts_recovered = CpuGpuArray.zeros_like(tw.x_dense) tw.calc_T_inv(pts_fwd,pts_recovered,level=0) pts_recovered.gpu2cpu() plt.plot(tw.x_dense.cpu,pts_fwd.cpu) plt.plot(tw.x_dense.cpu,pts_recovered.cpu)
from pycuda import autoinit from of.gpu import CpuGpuArray import numpy as np msg = """ The code below is for landmarks, not signals""" raise NotImplementedError(msg) yy, xx = np.mgrid[-2:2:1, -2:2:1] x = np.vstack([xx.ravel(), yy.ravel()]).T del xx, yy x = CpuGpuArray(x.copy().astype(np.float)) print x y = np.random.standard_normal(x.shape) y = CpuGpuArray(y) err = CpuGpuArray.zeros_like(y) nPts = len(err) ll = CpuGpuArray.zeros(nPts) calc_signal_err_per_sample(x.gpu, y.gpu, err.gpu) sigma = 1.0 calc_ll_per_sample(ll.gpu, err.gpu, sigma) err.gpu2cpu() ll.gpu2cpu() print np.allclose( ll.cpu, -0.5 * (err.cpu[:, 0]**2 + err.cpu[:, 1]**2) / (sigma**2))
print 'level: ',level print cpa_space # cpa_calcs=CpaCalcs(Nx=Nx,Ny=Ny,use_GPU_if_possible=True) # As = cpa_space.Avees2As(sample_Avees_all_levels[level]) # As[:,0,:]=0 # sample_Avees_all_levels[level] = cpa_space.As2Avees(As) # sample_cpa_all_levels[level] = cpa_space.project(sample_Avees_all_levels[level]) # ipshell('hi') # pat= PAT(pa_space=cpa_space,Avees=sample_Avees_all_levels[level]) cpa_space.update_pat(Avees=sample_Avees_all_levels[level]) pts = CpuGpuArray(cpa_space.x_dense_img) v_dense = CpuGpuArray.zeros_like(pts) cpa_space.calc_v(pts=pts,out=v_dense ) v_dense.gpu2cpu() # for display plt.figure(level); of.plt.maximize_figure() scale=[.4,0.25][cpa_space.vol_preserve] scale = 1 * Nx * 30 scale = np.sqrt((v_dense.cpu**2).sum(axis=1)).mean() / 10 for h in [233,236][:1]:
def example(base=[5], scale_spatial=100, nLevels=2, zero_v_across_bdry=[1], use_local_basis=True): nPtsDense = 10000 tw = TransformWrapper(nCols=100, nLevels=nLevels, base=base, scale_spatial=scale_spatial, nPtsDense=nPtsDense, zero_v_across_bdry=zero_v_across_bdry) print_iterable(tw.ms.L_cpa_space) seed = 0 np.random.seed(seed) for level in range(tw.ms.nLevels): cpa_space = tw.ms.L_cpa_space[level] Avees = cpa_space.Avees velTess = cpa_space.zeros_velTess() if use_local_basis: if 0: tw.sample_gaussian_velTess(level, Avees, velTess, mu=None) Avees *= 0.001 velTess *= 0.001 else: if not zero_v_across_bdry[0]: velTess[:] = 10 * np.random.standard_normal(velTess.shape) cpa_space.velTess2Avees(velTess=velTess, Avees=Avees) else: velTess[1:-1] = 10 * np.random.standard_normal( velTess[1:-1].shape) cpa_space.velTess2Avees(velTess=velTess, Avees=Avees) cpa_space.velTess2Avees(velTess=velTess, Avees=Avees) else: theta = cpa_space.get_zeros_theta() tw.sample_gaussian(level, Avees, theta, mu=None) # theta/=10 cpa_space.theta2Avees(theta=theta, Avees=Avees) # This step is important and must be done # before are trying to "use" the new values of # the (vectorized) A's. tw.update_pat_from_Avees(Avees, level) pts_src = tw.x_dense tw.calc_v(level=level, pts=pts_src, v=tw.v_dense) tw.v_dense.gpu2cpu() pts_fwd = CpuGpuArray.zeros_like( pts_src) # Create a buffer for the output tw.calc_T_fwd(pts_src, pts_fwd, level=level) pts_fwd.gpu2cpu() pts_inv = CpuGpuArray.zeros_like( pts_src) # Create a buffer for the output tw.calc_T_inv(pts_src, pts_inv, level=level) pts_inv.gpu2cpu() plt.figure(level) plt.clf() interval = pts_src.cpu # interval doesn't have to be pts_src.cpu Visualize.simple(tw.x_dense, tw.v_dense, interval, pts_src, transformed_fwd=pts_fwd, transformed_inv=pts_inv, cpa_space=cpa_space) return tw
use_local=inference_params.use_local) theta_est = theta.copy() fname_results = os.path.splitext(data.fname)[0] + '_result.pkl' FilesDirs.raise_if_dir_does_not_exist(os.path.dirname(fname_results)) tosave = {'tw_args': inference_record.tw_args, 'theta': inference_record.theta} tosave = Bunch(**tosave) Pkl.dump(fname_results, tosave, override=True) if 1: from disp import disp tw.create_grid_lines(step=0.1, factor=0.5) src = data.src dst = data.dst transformed = CpuGpuArray.zeros_like(src) scale_quiver = 1000 # The *smaller* this value is, the larger the plotted arrows will be. level = -1 # pick the finest scale cpa_space = tw.ms.L_cpa_space[level] cpa_space.theta2Avees(theta_est) cpa_space.update_pat() tw.calc_T_fwd(src, transformed, level=level) transformed.gpu2cpu() tw.calc_v(level=level) tw.v_dense.gpu2cpu() disp(tw=tw, theta=theta_est, src=src, dst=dst,
if 0: ds0,ds1,ds2=10,10,10 # pts_grid=cpa_space.x_dense_grid[:,::ds0,::ds1,50:51] pts_grid=cpa_space.x_dense_grid[:,::ds0,::ds1,::ds2] pts=np.vstack([pts_grid[0].ravel(), pts_grid[1].ravel(), pts_grid[2].ravel()]).T.copy() pts = CpuGpuArray(pts) pts_fwd = CpuGpuArray.zeros_like(pts) mu = cpa_space.get_zeros_theta() # np.random.seed(0) theta = np.random.multivariate_normal(mean=mu,cov=cpa_covs.cpa_cov) theta *=100 ## # theta.fill(0) # theta[8]=1 # theta[10]=1 cpa_space.theta2Avees(theta=theta)
def example(base=[5], scale_spatial=100, nLevels=2, zero_v_across_bdry=[1], use_local_basis=True): nPtsDense = 10000 tw = TransformWrapper(nCols=100, nLevels=nLevels, base=base, scale_spatial=scale_spatial, nPtsDense=nPtsDense, zero_v_across_bdry=zero_v_across_bdry) print_iterable(tw.ms.L_cpa_space) seed=0 np.random.seed(seed) for level in range(tw.ms.nLevels): cpa_space = tw.ms.L_cpa_space[level] Avees = cpa_space.Avees velTess = cpa_space.zeros_velTess() if use_local_basis: if 0: tw.sample_gaussian_velTess(level,Avees,velTess,mu=None) Avees*=0.001 velTess*=0.001 else: if not zero_v_across_bdry[0]: velTess[:]=10*np.random.standard_normal(velTess.shape) cpa_space.velTess2Avees(velTess=velTess,Avees=Avees) else: velTess[1:-1]=10*np.random.standard_normal(velTess[1:-1].shape) cpa_space.velTess2Avees(velTess=velTess,Avees=Avees) cpa_space.velTess2Avees(velTess=velTess,Avees=Avees) else: theta= cpa_space.get_zeros_theta() tw.sample_gaussian(level,Avees,theta,mu=None) # theta/=10 cpa_space.theta2Avees(theta=theta,Avees=Avees) # This step is important and must be done # before are trying to "use" the new values of # the (vectorized) A's. tw.update_pat_from_Avees(Avees,level) pts_src = tw.x_dense tw.calc_v(level=level,pts=pts_src,v=tw.v_dense) tw.v_dense.gpu2cpu() pts_fwd = CpuGpuArray.zeros_like(pts_src) # Create a buffer for the output tw.calc_T_fwd(pts_src,pts_fwd,level=level) pts_fwd.gpu2cpu() pts_inv = CpuGpuArray.zeros_like(pts_src) # Create a buffer for the output tw.calc_T_inv(pts_src,pts_inv,level=level) pts_inv.gpu2cpu() plt.figure(level) plt.clf() interval = pts_src.cpu # interval doesn't have to be pts_src.cpu Visualize.simple(tw.x_dense,tw.v_dense,interval,pts_src, transformed_fwd=pts_fwd,transformed_inv=pts_inv, cpa_space=cpa_space) return tw
velTess *= -1 tw.update_pat_from_velTess(velTess, level=0) closed_form_int.calc_phi_multiple_pts(x=pts_fwd_cf, velTess=velTess, pts_fwd=pts_recovered_cf, t=t) velTess *= -1 tw.update_pat_from_velTess(velTess, level=0) plt.subplot(222) plt.plot(x, pts_recovered_cf, 'g') plt.grid('on') from of.gpu import CpuGpuArray pts_fwd = CpuGpuArray.zeros_like(tw.x_dense) tic = time.clock() tw.calc_T_fwd(tw.x_dense, pts_fwd, level=0, int_quality=1) pts_fwd.gpu2cpu() toc = time.clock() print 'time', toc - tic # 1/0 pts_recovered = CpuGpuArray.zeros_like(tw.x_dense) tw.calc_T_inv(pts_fwd, pts_recovered, level=0) pts_recovered.gpu2cpu() plt.plot(tw.x_dense.cpu, pts_fwd.cpu) plt.plot(tw.x_dense.cpu, pts_recovered.cpu) plt.legend([r'$T(x)$', r'$(T^{-1}\circ T)(x)$', r'$T_{\mathrm{alg}}(x)$'],
def example(img=None,tess='I',eval_cell_idx=True,eval_v=True,show_downsampled_pts=True, valid_outside=True,base=[1,1], scale_spatial=.1, scale_value=100, permute_cell_idx_for_display=True, nLevels=3, vol_preserve=False, zero_v_across_bdry=[0,0], use_lims_when_plotting=True): show_downsampled_pts = bool(show_downsampled_pts) eval_cell_idx = bool(eval_cell_idx) eval_v = bool(eval_cell_idx) valid_outside = bool(valid_outside) permute_cell_idx_for_display = bool(permute_cell_idx_for_display) vol_preserve = bool(vol_preserve) if img is None: img = Img(get_std_test_img()) else: img=Img(img) img = img[:,:,::-1] # bgr2rgb tw = TransformWrapper(nRows=img.shape[0], nCols=img.shape[1], nLevels=nLevels, base=base, scale_spatial=scale_spatial, # controls the prior's smoothness scale_value=scale_value, # controls the prior's variance tess=tess, vol_preserve=vol_preserve, zero_v_across_bdry=zero_v_across_bdry, valid_outside=valid_outside) print tw # You probably want to do that: padding image border with zeros border_width=1 img[:border_width]=0 img[-border_width:]=0 img[:,:border_width]=0 img[:,-border_width:]=0 # The tw.calc_T_fwd (or tw.calc_T_inv) is always done in gpu. # After using it to compute new pts, # you may want to use remap (to warp an image accordingly). # If you will use tw.remap_fwd (or tw.remap_inv), which is done in gpu, # then the image type can be either float32 or float64. # But if you plan to use tw.tw.remap_fwd_opencv (or tw.remap_inv_opencv), # which is done in cpu (hence slightly lower) but supports better # interpolation methods, then the image type must be np.float32. # img_original = CpuGpuArray(img.copy().astype(np.float32)) img_original = CpuGpuArray(img.copy().astype(np.float64)) img_wrapped_fwd= CpuGpuArray.zeros_like(img_original) img_wrapped_bwd= CpuGpuArray.zeros_like(img_original) seed=0 np.random.seed(seed) ms_Avees=tw.get_zeros_PA_all_levels() ms_theta=tw.get_zeros_theta_all_levels() for level in range(tw.ms.nLevels): if level==0: tw.sample_gaussian(level,ms_Avees[level],ms_theta[level],mu=None)# zero mean else: tw.sample_from_the_ms_prior_coarse2fine_one_level(ms_Avees,ms_theta, level_fine=level) print('\nimg shape: {}\n'.format(img_original.shape)) # You don't have use these. You can use any 2d array # that has two columns (regardless of the number of rows). pts_src = tw.pts_src_dense # Create buffers for the output pts_fwd = CpuGpuArray.zeros_like(pts_src) pts_inv = CpuGpuArray.zeros_like(pts_src) for level in range(tw.ms.nLevels): ####################################################################### # instead of the tw.sample_from_the_ms_prior() above, # you may want to use one of the following. # 1) # tw.sample_gaussian(level,ms_Avees[level],ms_theta[level],mu=None)# zero mean # 2) # tw.sample_gaussian(level,ms_Avees[level],ms_theta[level],mu=some_user_specified_mu) # The following should be used only for level>0 : # 3) # tw.sample_normal_in_one_level_using_the_coarser_as_mean(Avees_coarse=ms_Avees[level-1], # Avees_fine=ms_Avees[level], # theta_fine=ms_theta[level], # level_fine=level) # ####################################################################### # You can also change the values this way: # cpa_space = tw.ms.L_cpa_space[level] # theta = cpa_space.get_zeros_theta() # theta[:] = some values # Avees = cpa_space.get_zeros_PA() # cpa_space.theta2Avees(theta,Avees) # cpa_space.update_pat(Avees) # This step is important and must be done # before are trying to "use" the new values of # the (vectorized) A's. tw.update_pat_from_Avees(ms_Avees[level],level) if eval_v: # Evaluating the velocity field. # You don't have to do it in unless you want to visualize v. # (when evaluting the treansformation, v will be internally # evaluated anyway -- but its result won't be stored) tw.calc_v(level=level) # optional, if you want to time it timer_gpu_T_fwd = GpuTimer() # Simply calling # tic = time.clock() # and then # tic = time.clock() # won't work. # In fact, most likely you will get that toc-tic is zero. # You need to use the GpuTimer object. When you do that, # one side effect is that suddenly the toc-tic from above will # give you a more realistic result. tic = time.clock() timer_gpu_T_fwd.tic() tw.calc_T_fwd(pts_src,pts_fwd,level=level) timer_gpu_T_fwd.toc() toc = time.clock() print 'Time, in sec, for computing T_fwd:' print timer_gpu_T_fwd.secs print toc-tic # likely to be 0, unless you also used the GpuTimer. # You can also time the inv of course. Results will be similar. tw.calc_T_inv(pts_src,pts_inv,level=level) if eval_cell_idx: # cell_idx is computed here just for display. cell_idx = CpuGpuArray.zeros(len(pts_src),dtype=np.int32) tw.calc_cell_idx(pts_src,cell_idx,level, permute_for_disp=permute_cell_idx_for_display) # If may also want ro to time the remap. # However, the remap is usually very fast (e.g, about 2 milisec). # timer_gpu_remap_fwd = GpuTimer() # tic = time.clock() # timer_gpu_remap_fwd.tic() # tw.remap_fwd(pts_inv=pts_inv,img=img_original,img_wrapped_fwd=img_wrapped_fwd) tw.remap_fwd(pts_inv=pts_inv,img=img_original,img_wrapped_fwd=img_wrapped_fwd) # timer_gpu_remap_fwd.toc() # toc = time.clock() # If the img type is np.float32, you may also use # tw.remap_fwd_opencv instead of tw.remap_fw. The differences between # the two methods are explained above tw.remap_inv(pts_fwd=pts_fwd,img=img_original,img_wrapped_inv=img_wrapped_bwd) # For display purposes, do gpu2cpu transfer print ("For display purposes, do gpu2cpu transfer") if eval_cell_idx: cell_idx.gpu2cpu() if eval_v: tw.v_dense.gpu2cpu() pts_fwd.gpu2cpu() pts_inv.gpu2cpu() img_wrapped_fwd.gpu2cpu() img_wrapped_bwd.gpu2cpu() figsize = (12,12) plt.figure(figsize=figsize) if eval_v: plt.subplot(332) tw.imshow_vx() plt.title('vx') plt.subplot(333) tw.imshow_vy() plt.title('vy') if eval_cell_idx: plt.subplot(331) cell_idx_disp = cell_idx.cpu.reshape(img.shape[0],-1) plt.imshow(cell_idx_disp) plt.title('tess (type {})'.format(tess)) if show_downsampled_pts: ds=20 pts_src_grid = pts_src.cpu.reshape(tw.nRows,-1,2) pts_src_ds=pts_src_grid[::ds,::ds].reshape(-1,2) pts_fwd_grid = pts_fwd.cpu.reshape(tw.nRows,-1,2) pts_fwd_ds=pts_fwd_grid[::ds,::ds].reshape(-1,2) pts_inv_grid = pts_inv.cpu.reshape(tw.nRows,-1,2) pts_inv_ds=pts_inv_grid[::ds,::ds].reshape(-1,2) use_lims=use_lims_when_plotting # return tw plt.subplot(334) plt.plot(pts_src_ds[:,0],pts_src_ds[:,1],'r.') plt.title('pts ds') tw.config_plt() plt.subplot(335) plt.plot(pts_fwd_ds[:,0],pts_fwd_ds[:,1],'g.') plt.title('fwd(pts)') tw.config_plt(axis_on_or_off='on',use_lims=use_lims) plt.subplot(336) plt.plot(pts_inv_ds[:,0],pts_inv_ds[:,1],'b.') plt.title('inv(pts)') tw.config_plt(axis_on_or_off='on',use_lims=use_lims) plt.subplot(337) plt.imshow(img_original.cpu.astype(np.uint8)) plt.title('img') # plt.axis('off') plt.subplot(338) plt.imshow(img_wrapped_fwd.cpu.astype(np.uint8)) # plt.axis('off') plt.title('fwd(img)') plt.subplot(339) plt.imshow(img_wrapped_bwd.cpu.astype(np.uint8)) # plt.axis('off') plt.title('inv(img)') return tw
def __init__(self,nCols,vol_preserve=False, nLevels=1, base=[5], # scale_spatial=1.0 * .1, # scale_value=100, scale_spatial=1.0 * 10, scale_value=2, zero_v_across_bdry=[True] # For now, don't change that. ,nPtsDense=None, only_local=False ): """ """ super(type(self),self).__init__( vol_preserve=vol_preserve, nLevels=nLevels, base=base, scale_spatial=scale_spatial, scale_value=scale_value, zero_v_across_bdry=zero_v_across_bdry, tess=None, valid_outside=None, only_local=only_local) self.nCols = self.args.nCols = nCols self.args.nPtsDense=nPtsDense self.nCols=nCols XMINS=[0] XMAXS=[nCols] # Note: This is inclusive warp_around=[False] # For now, don't change that. # zero_v_across_bdry=[True] # For now, don't change that. Nx = XMAXS[0]-XMINS[0] Ngrids=[Nx] ms=Multiscale(XMINS,XMAXS,zero_v_across_bdry, vol_preserve, warp_around=warp_around, nLevels=nLevels,base=base , Ngrids=Ngrids) self.ms=ms self.msp=MultiscaleCoarse2FinePrior(ms,scale_spatial=scale_spatial,scale_value=scale_value, # left_blk_std_dev=1.0/100, # right_vec_scale=1 left_blk_std_dev=1.0, right_vec_scale=1.0 ) # self.pts_src_dense = ms.L_cpa_space[0].get_x_dense(1000) # self.x_dense= ms.L_cpa_space[0].get_x_dense(1000) # self.v_dense = CpuGpuArray.zeros_like(self.x_dense) self.nPtsDense=nPtsDense if nPtsDense is None: raise ObsoleteError else: self.x_dense= ms.L_cpa_space[0].get_x_dense(nPtsDense) self.v_dense = CpuGpuArray.zeros_like(self.x_dense) self.transformed_dense = CpuGpuArray.zeros_like(self.x_dense) self.params_flow_int = get_params_flow_int() self.params_flow_int.nStepsODEsolver = 10 # Usually this is enough. # self.params_flow_int_coarse = copy.deepcopy(self.params_flow_int) self.params_flow_int_coarse.nTimeSteps /= 10 self.params_flow_int_coarse.dt *= 10 self.params_flow_int_fine = copy.deepcopy(self.params_flow_int) self.params_flow_int_fine.nTimeSteps *= 10 self.params_flow_int_fine.dt /= 10 self.ms_pats = ms.pats
def __init__(self,ms,level,data, sigma_signal, params_flow_int, interp_type_for_ll, # src=None,dst=None,transformed=None ): # ipshell('hi') if interp_type_for_ll not in self.supported_interp_types: msg = """ interp_type_for_ll must be in ['gpu_linear', cv2.INTER_LINEAR, cv2.INTER_CUBIC, cv2.INTER_LANCZOS4] """ raise ValueError(msg,interp_type_for_ll) self.interp_type_for_ll=interp_type_for_ll src=data['src'] transformed=data['transformed'] signal=data['signal'] for obj in [src,transformed]: if not isinstance(obj,CpuGpuArray): raise TypeError for obj in [signal.src,signal.dst,signal.transformed]: if not isinstance(obj,CpuGpuArray): raise TypeError self.nCalls = 0 self.nCallbacks = 0 self.sigma_signal=sigma_signal cpa_space=ms.L_cpa_space[level] self.cpa_space = cpa_space if src.shape[1] != cpa_space.dim_domain: raise ValueError(src.shape,cpa_space.dim_domain) # self.mu = cpa_simple_mean(cpa_space) self.my = cpa_space.get_zeros_theta() self.src = src self.transformed = transformed self.signal = signal # self.dim_signal = signal.src.shape[1] if signal.src.ndim==2: self.dim_signal = 2 else: raise NotImplementedError if self.dim_signal != 2: raise NotImplementedError(signal.src.shape) if self.signal.src.shape != self.signal.dst.shape: raise ValueError if self.signal.src.shape != self.signal.transformed.shape: raise ValueError nPts = len(src) self.nPts = nPts # self.err = CpuGpuArray.zeros_like(src) # self.signal.err = CpuGpuArray.zeros_like(src) self.signal.err = CpuGpuArray.zeros_like(self.signal.src) self.ll = CpuGpuArray.zeros(nPts,dtype=src.dtype) if nPts <= 1: raise ValueError self.params_flow_int=params_flow_int self._pat = PAT(pa_space=cpa_space, Avees=cpa_space.get_zeros_PA())
def disp(self,sampler,interp_type_during_visualization): level=sampler.level theta=sampler.theta_current tw=self.tw # interval=self.interval # interval_dense=self.interval_dense markersize = 5 fontsize=30 cpa_space = tw.ms.L_cpa_space[level] plt.subplot(231) sampler.plot_ll() plt.title('ll',fontsize=fontsize) sampler.plot_wlp() sampler.plot_wlp_plus_ll() if sampler.lp_func: plt.legend(['ll','wlp','ll+wlp']) plt.subplot(232) sampler.plot_ar() plt.title('accept ratio',fontsize=fontsize) # print theta cpa_space.theta2As(theta=theta) tw.update_pat_from_Avees(level=level) tw.calc_v(level=level) tw.v_dense.gpu2cpu() src = self.src # dst = self.dst transformed = self.transformed # src_dense=self.src_dense # transformed_dense=self.transformed_dense # tw.calc_T(src_dense, transformed_dense, mysign=1, level=level, # # transformed_dense.gpu2cpu() tw.calc_T_inv(src, transformed, level=level, int_quality=+1) transformed.gpu2cpu() if interp_type_during_visualization=='gpu_linear': my_dtype = np.float64 else: my_dtype = np.float32 # For opencv img_src = self.signal.src.cpu.reshape(tw.nRows,tw.nCols) img_src = CpuGpuArray(img_src.astype(my_dtype)) img_wrapped = CpuGpuArray.zeros_like(img_src) img_dst = self.signal.dst.cpu.reshape(tw.nRows,tw.nCols) img_dst = CpuGpuArray(img_dst) if interp_type_during_visualization=='gpu_linear': tw.remap_fwd(transformed,img_src,img_wrapped) else: tw.remap_fwd_opencv(transformed,img_src,img_wrapped,interp_type_during_visualization) img_wrapped.gpu2cpu() plt.subplot(233) plt.imshow(img_src.cpu,interpolation="None") plt.gray() cpa_space.plot_cells('r') tw.config_plt(axis_on_or_off='on') plt.title(r'$I_{\mathrm{src}}$') plt.subplot(234) plt.imshow(img_wrapped.cpu,interpolation="None") plt.gray() # cpa_space.plot_cells('w') tw.config_plt(axis_on_or_off='on') plt.title(r'$I_{\mathrm{src}}\circ T^{\theta}$') plt.subplot(235) plt.imshow(img_dst.cpu,interpolation="None") plt.gray() plt.title(r'$I_{\mathrm{dst}}$') # cpa_space.plot_cells('w') tw.config_plt(axis_on_or_off='on') plt.subplot(2,6,11) self.tw.imshow_vx() pylab.jet() tw.config_plt(axis_on_or_off='on') plt.title(r'$v_x$') plt.subplot(2,6,12) self.tw.imshow_vy() pylab.jet() tw.config_plt(axis_on_or_off='on') plt.title(r'$v_y$')
# pts_grid[1].ravel(), # pts_grid[2].ravel()]).T.copy() pts = cpa_space.x_dense if 0: ds0, ds1, ds2 = 10, 10, 10 # pts_grid=cpa_space.x_dense_grid[:,::ds0,::ds1,50:51] pts_grid = cpa_space.x_dense_grid[:, ::ds0, ::ds1, ::ds2] pts = np.vstack( [pts_grid[0].ravel(), pts_grid[1].ravel(), pts_grid[2].ravel()]).T.copy() pts = CpuGpuArray(pts) pts_fwd = CpuGpuArray.zeros_like(pts) mu = cpa_space.get_zeros_theta() # np.random.seed(0) theta = np.random.multivariate_normal(mean=mu, cov=cpa_covs.cpa_cov) theta *= 100 ## # theta.fill(0) # theta[8]=1 # theta[10]=1 cpa_space.theta2Avees(theta=theta) cpa_space.update_pat() # 1/0
# continue print 'level: ', level print cpa_space # cpa_calcs=CpaCalcs(Nx=Nx,Ny=Ny,use_GPU_if_possible=True) # As = cpa_space.Avees2As(sample_Avees_all_levels[level]) # As[:,0,:]=0 # sample_Avees_all_levels[level] = cpa_space.As2Avees(As) # sample_cpa_all_levels[level] = cpa_space.project(sample_Avees_all_levels[level]) # ipshell('hi') # pat= PAT(pa_space=cpa_space,Avees=sample_Avees_all_levels[level]) cpa_space.update_pat(Avees=sample_Avees_all_levels[level]) pts = CpuGpuArray(cpa_space.x_dense_img) v_dense = CpuGpuArray.zeros_like(pts) cpa_space.calc_v(pts=pts, out=v_dense) v_dense.gpu2cpu() # for display plt.figure(level) of.plt.maximize_figure() scale = [.4, 0.25][cpa_space.vol_preserve] scale = 1 * Nx * 30 scale = np.sqrt((v_dense.cpu**2).sum(axis=1)).mean() / 10 for h in [233, 236][:1]: plt.subplot(h) cpa_space.quiver(cpa_space.x_dense_grid_img, v_dense,
def __init__( self, nRows, nCols, vol_preserve=False, nLevels=1, base=[2, 2], scale_spatial=1.0 * .1, scale_value=100, zero_v_across_bdry=[False] * 2, # For now, don't change that. tess=None, valid_outside=True, only_local=False, cont_constraints_are_separable=False): """ Input params: nRows: number of rows in the image nCols: number of cols in the image vol_preserve: boolean flag (area-preserving or not) nLevels: number of levels in the multiscale representation base = (# of cells in X direction, # of cells in Y direction) Determines the resolution of the tesselation as the base level of the multiscale representation. scale_spatial: paramter for the Gaussian prior. Higher val <=> more smoothness scale_value: paramter for the Gaussian prior. Higher val <=> larger covariance """ super(type(self), self).__init__( vol_preserve=vol_preserve, nLevels=nLevels, base=base, scale_spatial=scale_spatial, scale_value=scale_value, zero_v_across_bdry=zero_v_across_bdry, tess=tess, valid_outside=valid_outside, only_local=only_local, cont_constraints_are_separable=cont_constraints_are_separable) self.nRows = self.args.nRows = nRows self.nCols = self.args.nCols = nCols print self.args # print if tess == 'tri': tess = 'I' if tess == 'rect': tess == 'II' if tess not in ['I', 'II']: raise ValueError(tess, "tess must be in ['I','II']") if only_local and tess != 'I': raise NotImplementedError self.nRows = nRows self.nCols = nCols XMINS = [0, 0] XMAXS = [nCols, nRows] # Note: This inclusive; e.g., if your image is # 512x512, XMAXS=[512,512], not [511,511] # XMINS=[-nCols/2,-nRows/2] # XMAXS=[ nCols/2, nRows/2] warp_around = [False, False] # For now, don't change that. # zero_v_across_bdry=[False,False] # For now, don't change that. Nx = XMAXS[0] - XMINS[0] Ny = XMAXS[1] - XMINS[1] self.config_plt = ConfigPlt(Nx=Nx, Ny=Ny) Ngrids = [Nx, Ny] ms = Multiscale( XMINS, XMAXS, zero_v_across_bdry, vol_preserve, warp_around=warp_around, nLevels=nLevels, base=base, tess=tess, Ngrids=Ngrids, valid_outside=valid_outside, only_local=only_local, cont_constraints_are_separable=cont_constraints_are_separable) self.ms = ms if only_local == False: self.msp = MultiscaleCoarse2FinePrior(ms, scale_spatial=scale_spatial, scale_value=scale_value, left_blk_std_dev=1.0 / 100, right_vec_scale=1) else: self.msp = None self.pts_src_dense = CpuGpuArray(ms.L_cpa_space[0].x_dense_img.copy()) self.v_dense = CpuGpuArray.zeros_like(self.pts_src_dense) self.transformed_dense = CpuGpuArray.zeros_like(self.pts_src_dense) self.params_flow_int = get_params_flow_int() self.params_flow_int.nStepsODEsolver = 10 # Usually this is enough. self.params_flow_int_coarse = copy.deepcopy(self.params_flow_int) self.params_flow_int_coarse.nTimeSteps /= 10 self.params_flow_int_coarse.dt *= 10 self.params_flow_int_fine = copy.deepcopy(self.params_flow_int) self.params_flow_int_fine.nTimeSteps *= 10 self.params_flow_int_fine.dt /= 10 self.ms_pats = ms.pats
msg=""" The code below is for landmarks, not signals""" raise NotImplementedError(msg) yy,xx = np.mgrid[-2:2:1,-2:2:1] x = np.vstack([xx.ravel(),yy.ravel()]).T del xx,yy x = CpuGpuArray(x.copy().astype(np.float)) print x y = np.random.standard_normal(x.shape) y = CpuGpuArray(y) err = CpuGpuArray.zeros_like(y) nPts = len(err) ll = CpuGpuArray.zeros(nPts) calc_signal_err_per_sample(x.gpu,y.gpu,err.gpu) sigma=1.0 calc_ll_per_sample(ll.gpu,err.gpu,sigma) err.gpu2cpu() ll.gpu2cpu() print np.allclose( ll.cpu, -0.5*(err.cpu[:,0]**2+err.cpu[:,1]**2)/(sigma**2))
def disp_deformed_grid_lines(self, level, color=None, lw=1): # return if self.hlines is None or self.vlines is None: raise ValueError hlines, vlines = self.hlines, self.vlines # for lines,c in zip([hlines,vlines],['r','b']): # pts_at_0=np.asarray([lines[:,0,:].flatten(), # lines[:,1,:].flatten()]).T # pts_at_0 = CpuGpuArray(pts_at_0.copy()) # pts_at_T=CpuGpuArray.zeros_like(pts_at_0) # self.calc_T_fwd(pts_src=pts_at_0, # pts_fwd=pts_at_T, # level=level,verbose=0,int_quality=1) # if self.nCols != self.nCols: # raise NotImplementedError # pts_at_T.gpu2cpu() # lines_new_x=pts_at_T.cpu[:,0].reshape(lines[:,0,:].shape).copy() # lines_new_y=pts_at_T.cpu[:,1].reshape(lines[:,0,:].shape).copy() # for line_new_x,line_new_y in zip(lines_new_x,lines_new_y): # # plt.plot(line_new_x,line_new_y,c) if color is None: colors = ['r', 'b'] else: colors = [color, color] s = hlines.shape if s[2] <= 1: raise ValueError p = 0 L = 50000 if L >= s[2]: while p < np.ceil(s[2]): hlines = self.hlines[:, :, p:p + L] vlines = self.vlines[:, :, p:p + L] p += L for lines, c in zip([hlines, vlines], colors): pts_at_0 = np.asarray( [lines[:, 0, :].flatten(), lines[:, 1, :].flatten()]).T if pts_at_0.size == 0: break pts_at_0 = CpuGpuArray(pts_at_0.copy()) pts_at_T = CpuGpuArray.zeros_like(pts_at_0) self.calc_T_fwd(pts_src=pts_at_0, pts_fwd=pts_at_T, level=level, int_quality=1) if self.nCols != self.nCols: raise NotImplementedError pts_at_T.gpu2cpu() lines_new_x = pts_at_T.cpu[:, 0].reshape( lines[:, 0, :].shape).copy() lines_new_y = pts_at_T.cpu[:, 1].reshape( lines[:, 0, :].shape).copy() for line_new_x, line_new_y in zip(lines_new_x, lines_new_y): plt.plot(line_new_x, line_new_y, c, lw=lw) else: raise NotImplementedError
def __init__(self, nSuperpixels, s_std, i_std, prior_count, nChannels): """ Initilize the parameters for the superpixels: The means are set to zeros at this point, and will be set later in the first M step. The space/color covariances (and their inverse), however, are being set to initial values here. We use a Inverse-Wishart prior on the space covariance Arguments: nSuperpixels: the number of superpixels to generate s_std: should be fixed as nPixels_on_side i_std: control the relative importance between RGB and location. The smaller it is, bigger the RGB effect is / more irregular the superpixels are. prior_count: determines the weight of Inverse-Wishart prior of space covariance(ex:1,5,10) nChannels: the number of channels of the input image (gray:1, LAB/RGB: 3) """ if nChannels not in (1,3): raise NotImplementedError(nChannels) dim_i=nChannels dim_s=2 self.dim_i=dim_i self.dim_s=dim_s self.nSuperpixels=nSuperpixels self.s_std, self.i_std, self.prior_count = s_std,i_std,prior_count mu_s = CpuGpuArray.zeros((nSuperpixels,dim_s)) mu_i = CpuGpuArray.zeros((nSuperpixels,dim_i)) Sigma_s = CpuGpuArray.zeros(shape = (nSuperpixels,dim_s,dim_s)) J_s = CpuGpuArray.zeros_like(Sigma_s) Sigma_i = CpuGpuArray.zeros((nSuperpixels,dim_i,dim_i)) J_i = CpuGpuArray.zeros_like(Sigma_i) logdet_Sigma_i = CpuGpuArray.zeros((nSuperpixels,1)) # scalars logdet_Sigma_s = CpuGpuArray.zeros((nSuperpixels,1)) # start with unnormalized counts (uniform) counts = np.ones(nSuperpixels,dtype=np.int32) counts = CpuGpuArray(counts) self.params = Bunch() self.params.mu_i = mu_i self.params.mu_s = mu_s self.params.Sigma_i = Sigma_i self.params.Sigma_s = Sigma_s self.params.prior_sigma_s_sum = Sigma_s self.params.J_i = J_i self.params.J_s = J_s self.params.logdet_Sigma_i = logdet_Sigma_i self.params.logdet_Sigma_s = logdet_Sigma_s self.params.counts = counts # set those parameters related to covariance self.initialize_params() # intermediate arrays needed for the Gaussian parameter calculation on GPU self.gpu_helper = Bunch() self.gpu_helper.mu_i_helper = gpuarray.zeros((nSuperpixels,dim_i),dtype=np.int64) self.gpu_helper.mu_s_helper = gpuarray.zeros((nSuperpixels,dim_s),dtype=np.int64) self.gpu_helper.prior_sigma_s = self.params.prior_sigma_s_sum.gpu.copy() self.gpu_helper.sigma_s_helper = gpuarray.zeros((nSuperpixels,3),dtype=np.int64) self.gpu_helper.log_count_helper = gpuarray.zeros(nSuperpixels,dtype=np.double) self.gpu_helper.non_NaN_count = gpuarray.zeros(nSuperpixels,dtype=np.int32) self.gpu_helper.NaN_count = gpuarray.zeros(nSuperpixels,dtype=np.int32)
from of.utils import * from of.gpu import CpuGpuArray import of.plt from cpab.cpa2d.TransformWrapper import TransformWrapper from get_data_LFW import get_data from disp import disp if not inside_spyder(): pylab.ion() name = 'LFW_5_to_6' data = get_data(name) src = CpuGpuArray(data.src) dst = CpuGpuArray(data.dst) transformed = CpuGpuArray.zeros_like(src) fname_results = os.path.splitext(data.fname)[0]+'_result.pkl' FilesDirs.raise_if_dir_does_not_exist(os.path.dirname(fname_results)) print 'Loading',fname_results results=Pkl.load(fname_results) theta_est = results.theta tw = TransformWrapper(**results.tw_args) tw.create_grid_lines(step=0.1,factor=0.5) scale_quiver=1000 # The *smaller* this value is, the larger the plotted arrows will be. level=-1 # pick the finest scale cpa_space = tw.ms.L_cpa_space[level]
def __init__(self, nSuperpixels, s_std, i_std, prior_count, nChannels): """ Initilize the parameters for the superpixels: The means are set to zeros at this point, and will be set later in the first M step. The space/color covariances (and their inverse), however, are being set to initial values here. We use a Inverse-Wishart prior on the space covariance Arguments: nSuperpixels: the number of superpixels to generate s_std: should be fixed as nPixels_on_side i_std: control the relative importance between RGB and location. The smaller it is, bigger the RGB effect is / more irregular the superpixels are. prior_count: determines the weight of Inverse-Wishart prior of space covariance(ex:1,5,10) nChannels: the number of channels of the input image (gray:1, LAB/RGB: 3) """ if nChannels not in (1,3): raise NotImplementedError(nChannels) dim_i=nChannels dim_s=2 self.dim_i=dim_i self.dim_s=dim_s self.nSuperpixels=nSuperpixels self.s_std, self.i_std, self.prior_count = s_std,i_std,prior_count mu_s = CpuGpuArray.zeros((nSuperpixels,dim_s)) mu_i = CpuGpuArray.zeros((nSuperpixels,dim_i)) Sigma_s = CpuGpuArray.zeros(shape = (nSuperpixels,dim_s,dim_s)) J_s = CpuGpuArray.zeros_like(Sigma_s) Sigma_i = CpuGpuArray.zeros((nSuperpixels,dim_i,dim_i)) J_i = CpuGpuArray.zeros_like(Sigma_i) logdet_Sigma_i = CpuGpuArray.zeros((nSuperpixels,1)) # scalars logdet_Sigma_s = CpuGpuArray.zeros((nSuperpixels,1)) # start with unnormalized counts (uniform) counts = np.ones(nSuperpixels,dtype=np.int32) counts = CpuGpuArray(counts) self.params = Bunch() self.params.mu_i = mu_i self.params.mu_s = mu_s self.params.Sigma_i = Sigma_i self.params.Sigma_s = Sigma_s self.params.prior_sigma_s_sum = Sigma_s self.params.J_i = J_i self.params.J_s = J_s self.params.logdet_Sigma_i = logdet_Sigma_i self.params.logdet_Sigma_s = logdet_Sigma_s self.params.counts = counts # set those parameters related to covariance self.initialize_params() # intermediate arrays needed for the Gaussian parameter calculation on GPU self.gpu_helper = Bunch() self.gpu_helper.mu_i_helper = gpuarray.zeros((nSuperpixels,dim_i),dtype=np.int32) self.gpu_helper.mu_s_helper = gpuarray.zeros((nSuperpixels,dim_s),dtype=np.int32) self.gpu_helper.prior_sigma_s = self.params.prior_sigma_s_sum.gpu.copy() self.gpu_helper.sigma_s_helper = gpuarray.zeros((nSuperpixels,3),dtype=np.int64) self.gpu_helper.log_count_helper = gpuarray.zeros((nSuperpixels,1),dtype=np.double)
def example(img=None, tess='I', eval_cell_idx=True, eval_v=True, show_downsampled_pts=True, valid_outside=True, base=[1, 1], scale_spatial=.1, scale_value=100, permute_cell_idx_for_display=True, nLevels=3, vol_preserve=False, zero_v_across_bdry=[0, 0], use_lims_when_plotting=True): show_downsampled_pts = bool(show_downsampled_pts) eval_cell_idx = bool(eval_cell_idx) eval_v = bool(eval_cell_idx) valid_outside = bool(valid_outside) permute_cell_idx_for_display = bool(permute_cell_idx_for_display) vol_preserve = bool(vol_preserve) if img is None: img = Img(get_std_test_img()) else: img = Img(img) img = img[:, :, ::-1] # bgr2rgb tw = TransformWrapper( nRows=img.shape[0], nCols=img.shape[1], nLevels=nLevels, base=base, scale_spatial=scale_spatial, # controls the prior's smoothness scale_value=scale_value, # controls the prior's variance tess=tess, vol_preserve=vol_preserve, zero_v_across_bdry=zero_v_across_bdry, valid_outside=valid_outside) print tw # You probably want to do that: padding image border with zeros border_width = 1 img[:border_width] = 0 img[-border_width:] = 0 img[:, :border_width] = 0 img[:, -border_width:] = 0 # The tw.calc_T_fwd (or tw.calc_T_inv) is always done in gpu. # After using it to compute new pts, # you may want to use remap (to warp an image accordingly). # If you will use tw.remap_fwd (or tw.remap_inv), which is done in gpu, # then the image type can be either float32 or float64. # But if you plan to use tw.tw.remap_fwd_opencv (or tw.remap_inv_opencv), # which is done in cpu (hence slightly lower) but supports better # interpolation methods, then the image type must be np.float32. # img_original = CpuGpuArray(img.copy().astype(np.float32)) img_original = CpuGpuArray(img.copy().astype(np.float64)) img_wrapped_fwd = CpuGpuArray.zeros_like(img_original) img_wrapped_bwd = CpuGpuArray.zeros_like(img_original) seed = 0 np.random.seed(seed) ms_Avees = tw.get_zeros_PA_all_levels() ms_theta = tw.get_zeros_theta_all_levels() for level in range(tw.ms.nLevels): if level == 0: tw.sample_gaussian(level, ms_Avees[level], ms_theta[level], mu=None) # zero mean else: tw.sample_from_the_ms_prior_coarse2fine_one_level(ms_Avees, ms_theta, level_fine=level) print('\nimg shape: {}\n'.format(img_original.shape)) # You don't have use these. You can use any 2d array # that has two columns (regardless of the number of rows). pts_src = tw.pts_src_dense # Create buffers for the output pts_fwd = CpuGpuArray.zeros_like(pts_src) pts_inv = CpuGpuArray.zeros_like(pts_src) for level in range(tw.ms.nLevels): ####################################################################### # instead of the tw.sample_from_the_ms_prior() above, # you may want to use one of the following. # 1) # tw.sample_gaussian(level,ms_Avees[level],ms_theta[level],mu=None)# zero mean # 2) # tw.sample_gaussian(level,ms_Avees[level],ms_theta[level],mu=some_user_specified_mu) # The following should be used only for level>0 : # 3) # tw.sample_normal_in_one_level_using_the_coarser_as_mean(Avees_coarse=ms_Avees[level-1], # Avees_fine=ms_Avees[level], # theta_fine=ms_theta[level], # level_fine=level) # ####################################################################### # You can also change the values this way: # cpa_space = tw.ms.L_cpa_space[level] # theta = cpa_space.get_zeros_theta() # theta[:] = some values # Avees = cpa_space.get_zeros_PA() # cpa_space.theta2Avees(theta,Avees) # cpa_space.update_pat(Avees) # This step is important and must be done # before are trying to "use" the new values of # the (vectorized) A's. tw.update_pat_from_Avees(ms_Avees[level], level) if eval_v: # Evaluating the velocity field. # You don't have to do it in unless you want to visualize v. # (when evaluting the treansformation, v will be internally # evaluated anyway -- but its result won't be stored) tw.calc_v(level=level) # optional, if you want to time it timer_gpu_T_fwd = GpuTimer() # Simply calling # tic = time.clock() # and then # tic = time.clock() # won't work. # In fact, most likely you will get that toc-tic is zero. # You need to use the GpuTimer object. When you do that, # one side effect is that suddenly the toc-tic from above will # give you a more realistic result. tic = time.clock() timer_gpu_T_fwd.tic() tw.calc_T_fwd(pts_src, pts_fwd, level=level) timer_gpu_T_fwd.toc() toc = time.clock() print 'Time, in sec, for computing T_fwd:' print timer_gpu_T_fwd.secs print toc - tic # likely to be 0, unless you also used the GpuTimer. # You can also time the inv of course. Results will be similar. tw.calc_T_inv(pts_src, pts_inv, level=level) if eval_cell_idx: # cell_idx is computed here just for display. cell_idx = CpuGpuArray.zeros(len(pts_src), dtype=np.int32) tw.calc_cell_idx(pts_src, cell_idx, level, permute_for_disp=permute_cell_idx_for_display) # If may also want ro to time the remap. # However, the remap is usually very fast (e.g, about 2 milisec). # timer_gpu_remap_fwd = GpuTimer() # tic = time.clock() # timer_gpu_remap_fwd.tic() # tw.remap_fwd(pts_inv=pts_inv,img=img_original,img_wrapped_fwd=img_wrapped_fwd) tw.remap_fwd(pts_inv=pts_inv, img=img_original, img_wrapped_fwd=img_wrapped_fwd) # timer_gpu_remap_fwd.toc() # toc = time.clock() # If the img type is np.float32, you may also use # tw.remap_fwd_opencv instead of tw.remap_fw. The differences between # the two methods are explained above tw.remap_inv(pts_fwd=pts_fwd, img=img_original, img_wrapped_inv=img_wrapped_bwd) # For display purposes, do gpu2cpu transfer print("For display purposes, do gpu2cpu transfer") if eval_cell_idx: cell_idx.gpu2cpu() if eval_v: tw.v_dense.gpu2cpu() pts_fwd.gpu2cpu() pts_inv.gpu2cpu() img_wrapped_fwd.gpu2cpu() img_wrapped_bwd.gpu2cpu() figsize = (12, 12) plt.figure(figsize=figsize) if eval_v: plt.subplot(332) tw.imshow_vx() plt.title('vx') plt.subplot(333) tw.imshow_vy() plt.title('vy') if eval_cell_idx: plt.subplot(331) cell_idx_disp = cell_idx.cpu.reshape(img.shape[0], -1) plt.imshow(cell_idx_disp) plt.title('tess (type {})'.format(tess)) if show_downsampled_pts: ds = 20 pts_src_grid = pts_src.cpu.reshape(tw.nRows, -1, 2) pts_src_ds = pts_src_grid[::ds, ::ds].reshape(-1, 2) pts_fwd_grid = pts_fwd.cpu.reshape(tw.nRows, -1, 2) pts_fwd_ds = pts_fwd_grid[::ds, ::ds].reshape(-1, 2) pts_inv_grid = pts_inv.cpu.reshape(tw.nRows, -1, 2) pts_inv_ds = pts_inv_grid[::ds, ::ds].reshape(-1, 2) use_lims = use_lims_when_plotting # return tw plt.subplot(334) plt.plot(pts_src_ds[:, 0], pts_src_ds[:, 1], 'r.') plt.title('pts ds') tw.config_plt() plt.subplot(335) plt.plot(pts_fwd_ds[:, 0], pts_fwd_ds[:, 1], 'g.') plt.title('fwd(pts)') tw.config_plt(axis_on_or_off='on', use_lims=use_lims) plt.subplot(336) plt.plot(pts_inv_ds[:, 0], pts_inv_ds[:, 1], 'b.') plt.title('inv(pts)') tw.config_plt(axis_on_or_off='on', use_lims=use_lims) plt.subplot(337) plt.imshow(img_original.cpu.astype(np.uint8)) plt.title('img') # plt.axis('off') plt.subplot(338) plt.imshow(img_wrapped_fwd.cpu.astype(np.uint8)) # plt.axis('off') plt.title('fwd(img)') plt.subplot(339) plt.imshow(img_wrapped_bwd.cpu.astype(np.uint8)) # plt.axis('off') plt.title('inv(img)') return tw