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
Beispiel #2
0
    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()) 
Beispiel #3
0
    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())  
Beispiel #5
0
    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())
Beispiel #10
0
              
    
    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()       
    
Beispiel #11
0
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
Beispiel #12
0
    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)
Beispiel #14
0
#            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             

                     
Beispiel #15
0
    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)   
    
Beispiel #18
0
    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))
Beispiel #19
0
        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]:
Beispiel #20
0
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
Beispiel #21
0
    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,
Beispiel #22
0
              
    
    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)$'],
Beispiel #25
0
 def set_dense(self):
     self.src_dense = self.tw.pts_src_dense
     self.transformed_dense = CpuGpuArray.zeros_like(self.src_dense)
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())
Beispiel #29
0
    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$')
Beispiel #30
0
    #                   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
Beispiel #31
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
Beispiel #33
0

    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
Beispiel #35
0
    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]
Beispiel #37
0
    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)
Beispiel #38
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