Esempio n. 1
0
    def __init__(
            self,
            nRows,
            nCols,
            vol_preserve,
            base,
            nLevels,
            valid_outside=True,
            tess='tri',
            sigma_lm=1000 / 10,  # worked pretty well (hands data)
            #                     sigma_lm = 1000/100, # Didn't work so well
        scale_spatial=1.0 * .1,
            scale_value=100,
            zero_v_across_bdry=[False] * 2,
            wlp=1e-4,
            scale_quiver=None):
        self.base = base
        self.nLevels = nLevels
        self.sigma_lm = sigma_lm
        self.wlp = wlp

        self.tw = TransformWrapper(nRows=nRows,
                                   nCols=nCols,
                                   vol_preserve=vol_preserve,
                                   nLevels=nLevels,
                                   base=base,
                                   scale_spatial=scale_spatial,
                                   scale_value=scale_value,
                                   tess=tess,
                                   valid_outside=valid_outside,
                                   zero_v_across_bdry=zero_v_across_bdry)

        if scale_quiver is None:
            raise ValueError
        self.scale_quiver = scale_quiver
Esempio n. 2
0
    def __init__(self,nRows=100,
                      nCols=100,
                      base = [2,2], 
                      nLevels=4,
                      tess='tri',
                      zero_v_across_bdry=[False]*2,
#                      range_max_val = 1, # FOR NOW, KEEP IT. 
#                      nPtsDense=10000,
                      scale_spatial=1.0 * 10,
                      scale_value=2.0,
                      sigma_signal=None,
                      wlp=1e-4,
                      ll_type=['gaussian','gaussian_on_distancetransform'][0],
                      only_local=False,
                      valid_outside=True):
        ll_type = ll_type.lower()                          
        if ll_type == 'gaussian':
            self.SDLL=SDLL_gaussian
#        elif ll_type =='gaussian_on_distancetransform':
#            self.SDLL=SDLL_gaussian_on_distancetransform
#        elif ll_type == 'vmf':
#            self.SDLL=SDLL_VMF
        else:
            raise ValueError(ll_type)
        
                    
#        self.range_min_val = 0.0
#        self.range_max_val = range_max_val
                          
        self.base = base
        self.nLevels=nLevels
        if  sigma_signal is None:
            raise ValueError("sigma_signal cannot be None")
        self.sigma_signal =  sigma_signal
                             
        self.wlp =  wlp
        
       
        self.tw = TransformWrapper(nRows=nRows,nCols=nCols,
                              nLevels=nLevels,  
                              base=base,
                              tess=tess,
#                              nPtsDense=nPtsDense,
                              scale_spatial=scale_spatial,
                              scale_value=scale_value,
                              zero_v_across_bdry=zero_v_across_bdry,
                              only_local=only_local,
                              valid_outside=valid_outside
                              )
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
Esempio n. 4
0
class Register(object):
    def __init__(self,nRows=100,
                      nCols=100,
                      base = [2,2], 
                      nLevels=4,
                      tess='tri',
                      zero_v_across_bdry=[False]*2,
#                      range_max_val = 1, # FOR NOW, KEEP IT. 
#                      nPtsDense=10000,
                      scale_spatial=1.0 * 10,
                      scale_value=2.0,
                      sigma_signal=None,
                      wlp=1e-4,
                      ll_type=['gaussian','gaussian_on_distancetransform'][0],
                      only_local=False,
                      valid_outside=True):
        ll_type = ll_type.lower()                          
        if ll_type == 'gaussian':
            self.SDLL=SDLL_gaussian
#        elif ll_type =='gaussian_on_distancetransform':
#            self.SDLL=SDLL_gaussian_on_distancetransform
#        elif ll_type == 'vmf':
#            self.SDLL=SDLL_VMF
        else:
            raise ValueError(ll_type)
        
                    
#        self.range_min_val = 0.0
#        self.range_max_val = range_max_val
                          
        self.base = base
        self.nLevels=nLevels
        if  sigma_signal is None:
            raise ValueError("sigma_signal cannot be None")
        self.sigma_signal =  sigma_signal
                             
        self.wlp =  wlp
        
       
        self.tw = TransformWrapper(nRows=nRows,nCols=nCols,
                              nLevels=nLevels,  
                              base=base,
                              tess=tess,
#                              nPtsDense=nPtsDense,
                              scale_spatial=scale_spatial,
                              scale_value=scale_value,
                              zero_v_across_bdry=zero_v_across_bdry,
                              only_local=only_local,
                              valid_outside=valid_outside
                              )
#                              500,500,500,50000,5000
        
        
    def set_dense(self,domain_start=-10,domain_end=10):
        """
        Remarks:
        1) The range of the domain has already been determined in self.tw
        2) For now, the src is always the "uniform cdf"
        """
         
        self.src_dense =  self.tw.pts_src_dense
        self.transformed_dense = self.tw.transformed_dense

    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 set_run_lengths(self,run_lengths):
        if len(run_lengths)!=self.nLevels:
            raise ValueError(len(run_lengths),self.nLevels)
        self.run_lengths = run_lengths

    def fit(self,use_prior=False,proposal_scale=0.001,use_local=True,dispOn=True,
            interp_type_for_ll=None,
            interp_type_during_visualization=None,
            scale_local_proposal=None):
        nLevels=self.nLevels
        tw = self.tw 
        sigma_signal = self.sigma_signal
        self.use_local = use_local
        
        inference_record = Bunch()        

        inference_record.tw_args = tw.args        
        inference_record.steps = []
        inference_record.use_prior = use_prior
        inference_record.proposal_scale= proposal_scale
        inference_record.sigma_signal = sigma_signal

        
        
        
        try:
            run_lengths = self.run_lengths
        except AttributeError:
            self.set_run_lengths([500]*self.nLevels)
            run_lengths = self.run_lengths
#            raise Exception("self.set_run_lengths was not called yet")
        wlp=self.wlp
        for i in range(nLevels):   
#        for i in range(nLevels+5): 
        
            if i<nLevels:
                level=i
                if level == 0:
                    theta = tw.ms.L_cpa_space[level].get_zeros_theta()
                else:    
                    theta_fine = tw.ms.L_cpa_space[level].get_zeros_theta()
                    tw.ms.propogate_theta_coarse2fine(theta_coarse=theta,theta_fine=theta_fine)
                    theta = theta_fine
                _sigma_signal = sigma_signal    
            else:                
                _sigma_signal  *= 0.9
                                                         
             
            print '-'*10 ,'level',level,  '-'*10
            cpa_space = tw.ms.L_cpa_space[level]
            print cpa_space
            
           
            data = {'src':self.src,'transformed':self.transformed,
                    'signal':self.signal}
            
            
            if use_prior:
                lp_func = LP(ms=tw.ms,msp=tw.msp,level=level,SDLP=SDLP,                                          
                                                   required={})
                                                                  
            else:
                lp_func = None         
                                       
            sampler = Metropolis(ll_func= LL(
                                 ms=tw.ms,level=level,SDLL=self.SDLL,
                                 data=data,
                                 required={'sigma_signal':_sigma_signal,
                                           'params_flow_int':tw.params_flow_int_coarse,
                                           'interp_type_for_ll':interp_type_for_ll} ),
                                 proposal=Proposal(ms=tw.ms,msp=tw.msp,level=level,
                                                   scale=proposal_scale,
                                                   use_local=use_local,
                                                   scale_local_proposal=scale_local_proposal),
#                                 proposal=ProposalSphericalGaussian(ms=tw.ms,
#                                                                    level=level,
#                                                   scale=0.1 / (1.2**level) 
#                                                   scale=0.01,
        #                                          scale=0.1 / (1.1**level)                   
        #                                           scale=0.1 
#                                                   ) ,
                                                   lp_func=lp_func,
                                        wlp=wlp
                                        )
               
            sampler.set_theta(theta)
            run_length = run_lengths[level]
            sampler.run(run_length)
            theta = sampler.theta_current # prepare for next iteration
            
            inference_record.steps.append(sampler.get_record())
            
            if dispOn:
                if i >= nLevels-1 or 1:
                    
                    plt.figure(i+1)
                    plt.clf()
                    self.disp(sampler=sampler,
                             interp_type_during_visualization=interp_type_during_visualization)               

                 
         
        inference_record.theta = theta.copy()  
        steps = inference_record.steps
        nAccepted =  [ step.nAccepted  for step in steps]
        run_lengths =  [ step.N  for step in steps]
        times = [ step.runs[0].time for step in steps]
        total_time = sum(times) 

        print "run_lengths:",run_lengths
        print "nAccepted:",nAccepted
        
        print 'times:'
        print_iterable(times)
        print 'time total:',total_time  
        
         




        return theta.copy(),inference_record



    def plot_src(self,*args,**kwargs):
        x = self.x
        plt.plot(x,self.src.cpu,*args,**kwargs)
#    def plot_dst(self,*args,**kwargs):
#        x = self.x
#        plt.plot(x,self.dst.cpu,*args,**kwargs)
                
    def __repr__(self):
        s = 'Register:'
        s += '\n'+ repr(self.tw.ms)
        return s     

    @staticmethod
    def plot_inference_summary(inference_record):
        ll = []
        lp = []
        wlp_plus_ll=[]
        for step in inference_record.steps:
            ll += step.ll[1:] # start from 1 and not 0: to skip the initial guess
            try:
                lp += step.lp[1:] 
                
                wlp_plus_ll += list((step.wlp * np.asarray(step.lp[1:]) + 
                                            np.asarray(step.ll[1:])).tolist())
            except AttributeError:
                pass
                    
        plt.title('ll',fontsize=30)
        plt.plot(ll,lw=2)
        plt.plot(lp,lw=2)
        plt.plot(wlp_plus_ll,lw=2)
        
         
        counter = 0
        for i,step in enumerate(inference_record.steps):
            if i%2==1:
                facecolor = ".2"
            else:
                facecolor = ".5"           
            plt.axvspan(counter, counter+step.nAccepted, facecolor=facecolor, alpha=0.2)
            counter += step.nAccepted 
        
        
    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$')
    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]
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()

plt.close('all')
disp(tw=tw,theta=theta_est,src=src,dst=dst,transformed=transformed,level=level,
Esempio n. 6
0
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]
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()

plt.close('all')
disp(tw=tw,
Esempio n. 7
0
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