Exemple #1
0
	def smooth_resize(img, n_rows, n_cols, smooth_type):
		##----CAUTION---
		## THIS FUNCTION DOES NOT UPSCALE ON ONE AXIS AND DOWNSCALE IN THE OTHER
		# smooth_type= gaussian, bilinear interpolation, median or whatever
		# flag: 0 down else up
		if n_rows==img.shape[0]:
			return img
		if n_cols==img.shape[1]:
			return img
		flag = n_rows > img.shape[0]
		ratio_rows = (n_rows)*1.0 / img.shape[0]
		ratio_cols = (n_cols)*1.0 / img.shape[1]

		if flag:
			kernel_size = (math.ceil((ratio_rows + ratio_cols) / 2))*2-1 
		else:
			kernel_size = (math.ceil(math.log(math.ceil((math.pow(ratio_rows,-1) + math.pow(ratio_cols,-1)) / 2),2)))* 2 + 1
		resized_img = Sampling.simple_resize(img, n_rows, n_cols) if flag else Sampling.simple_resize(img, n_rows, n_cols)

		if smooth_type == Sampling.FILTER_MEDIAN:
			return conv.median_filter_nd(resized_img, kernel_size)
		elif smooth_type == Sampling.FILTER_BILINEAR_INTERPOLATION:
			return conv.convolution_nd(resized_img, ker.bilinear_interpolation(kernel_size))
		elif smooth_type == Sampling.FILTER_GAUSSIAN:
			return conv.convolution_nd(resized_img, ker.gaussian(kernel_size))
Exemple #2
0
  def __init__( self, shape, **kwargs ):

    self.shape = shape
    self.posecells = zeros(shape)
    #NOTE: might not need if gaussian_filter works
    self.kernel_3d = self.diff_gaussian( PC_E_DIM, PC_I_DIM, PC_E_SIGMA, PC_I_SIGMA, order=3 )
    self.kernel_2d = self.diff_gaussian( PC_E_DIM, PC_I_DIM, PC_E_SIGMA, PC_I_SIGMA, order=2 )
    self.kernel_1d = self.diff_gaussian( PC_E_DIM, PC_I_DIM, PC_E_SIGMA, PC_I_SIGMA, order=1 )
    self.kernel_1d_sep = self.diff_gaussian_separable( PC_E_DIM, PC_I_DIM, PC_E_SIGMA, PC_I_SIGMA )

    self.global_inhibition = PC_GLOBAL_INHIB
    self.pc_vtrans_scale = PC_CELL_X_SIZE
    self.pc_vrot_scale = 2.0*pi/shape[2]#PC_C_SIZE_TH
    
    #TODO: maybe change everything to float32 to make it go faster?
    #self.conv = Convolution( im=self.posecells, fil=self.kernel_1d, sep=True, type=float64 )
    #self.conv = Convolution( im=self.posecells, fil=self.kernel_1d_sep, sep=True, type=float64 )
    self.conv = Convolution( im=self.posecells, fil=self.kernel_3d, sep=False, type=float64 )
    
    filter = self.diff_gaussian_offset_2d( PC_E_SIGMA, PC_I_SIGMA, shape=(7,7), origin=(0,0) )
    #self.conv.new_filter( self.kernel_2d, dim=2 )
    self.conv.new_filter( filter, dim=2 )

    self.filter_dict_2d = self.build_diff_gaussian_set_2d( PC_E_SIGMA, PC_I_SIGMA, shape=(7,7), precision=1 )
    self.filter_dict_2d_precision = 10 # multiple the decimal by this number to get the right key
	def convoluteWavs(self,wav):
		BLOCKSIZE = 1024				
		def preprocess():
			if self.audioData.shape[0] < wav.audioData.shape[0]:
				audioSize = self.audioData.shape[0]				
				if audioSize%BLOCKSIZE != 0:
					lastblock = self.audioData[(self.audioData.shape[0]-(self.audioData.shape[0]%BLOCKSIZE)):]
					temp = self.audioData[:(self.audioData.shape[0]-(self.audioData.shape[0]%BLOCKSIZE))]
					self.audioData = np.concatenate((temp,WavProcessing.pad(len(lastblock),lastblock,BLOCKSIZE)))
					resultConv = np.zeros((self.audioData.shape[0],2),dtype=np.int16)
			elif self.audioData.shape[0] >= wav.audioData.shape[0]:
				audioSize = wav.audioData.shape[0]
				if audioSize%BLOCKSIZE != 0:
					lastblock = wav.audioData[(wav.audioData.shape[0]-(wav.audioData.shape[0]%BLOCKSIZE)):]
					temp = wav.audioData[:(wav.audioData.shape[0]-(wav.audioData.shape[0]%BLOCKSIZE))]
					wav.audioData = np.concatenate((temp,WavProcessing.pad(len(lastblock),lastblock,BLOCKSIZE)))					
					resultConv = np.zeros((wav.audioData.shape[0],2),dtype=np.int16)
			return resultConv,Matrix.ceil(audioSize,BLOCKSIZE)
		
		resultConv, nblocks = preprocess()			
		for i in xrange(nblocks):
			start = BLOCKSIZE*i
			end = BLOCKSIZE*(i+1)
			conv = Convolution(Matrix(self.audioData[start:end,0].tolist(),0),Matrix(wav.audioData[start:end,0].tolist(),0),Convolution.CIRCULAR)
			resultConv[start:end] = conv.convolute()
		self.audioData = resultConv[:]
		conv._plot()
class Conv(Layer):

    def __init__(self, n_filters, filter_shape,weight_scale,weight_decay):
        self.n_filters = n_filters
        self.filter_shape = filter_shape
        self.weight_scale = weight_scale
        self.weight_decay = weight_decay
        self.conv_ob = Convolution()

    def setup(self, input_shape, rng):

        n_featuremaps = input_shape[1]
        W_shape = (n_featuremaps, self.n_filters) + self.filter_shape # this appends the filter shape eg : (16,4,3,3)
        self.W = rng.normal( size=W_shape, scale=self.weight_scale)  # generate random filters with gaussian(normal) distribution
        self.b = numpy.zeros(self.n_filters) # initialize bias weights equal to zero

    def params(self):
        return self.W, self.b

    def param_incs(self):
        return self.dW, self.db

    def set_params(self,W,b):
        self.W = W
        self.b = b

    def output_shape(self, input_shape):
        # Zero padding is considered
        height = input_shape[2] #- self.filter_shape[0] + 1
        width = input_shape[3] #- self.filter_shape[1] + 1
        shape = (input_shape[0],
                 self.n_filters,
                 height,
                 width)
        return shape

    def forward_propogation(self, input): # forward propogation
        print("Forward  Propogation : Convolution")
        self.last_input = input # activation this layer
        self.last_input_shape = input.shape # shape of activation
        conv_shape = self.output_shape(input.shape)
        convout = self.conv_ob.convolve(input,self.W,conv_shape)
        z=self.W
        return convout + self.b[numpy.newaxis, :, numpy.newaxis, numpy.newaxis]


    def backward_propogation(self, output_grad): # backward propogation of gradients
        print("Backward Propogation : Convolution")
        input_grad = numpy.empty(self.last_input_shape)

        self.dW = numpy.zeros(self.W.shape)

        # Convolve
        input_grad, self.dW = self.conv_ob.convolve_backprop(self.last_input, output_grad, self.W, self.dW)
        n_imgs = output_grad.shape[0]
        self.db = numpy.sum(output_grad, axis=(0, 2, 3)) / (n_imgs)
        self.dW =self.dW -  self.weight_decay * self.W

        return input_grad
    def resol_spectrum (self,E,a,b,ordering,plot_this=False):

        if (ordering < -1) or (ordering > 1):
            print('Error: set ordering = 1 for NO, -1 for IO, 0 for both')
            return -1

        Reactor_Spectrum.unosc_spectrum(self,E)
        Oscillation_Prob.eval_prob(self,E,0)

        self.norm_osc_spect_N = self.norm_spectrum_un * self.prob_E_N
        self.norm_osc_spect_I = self.norm_spectrum_un * self.prob_E_I
        
        #Evis = E - 0.8

        ### class Convolution
        conv = Convolution()
        print('\n...adding experimental resolution via numerical convolution...')
        print('\nIt might take a while')
        self.resol_N = conv.numerical_conv(self.norm_osc_spect_N,E,a=a,b=b)
        self.resol_I = conv.numerical_conv(self.norm_osc_spect_I,E,a=a,b=b)

        if plot_this:

            fig = plt.figure()
            #fig.suptitle(r'Antineutrino spectrum')
            ax = fig.add_subplot(111)
            ax.legend()
            ax.grid()
            ax.set_xlabel(r'$\text{E}_{\text{vis}}$ [\si{MeV}]')
            ax.set_ylabel(r'N($\bar{\nu}$) [arb. unit]')
            ax.set_ylim(-0.005,0.095)
            ax.set_title(r'Antineutrino spectrum' + '\nwith finite energy resolution')

            if ordering == 1: # NO

                ax.plot(E-0.8,self.resol_N,'b',linewidth=1,label='NO')
                ax.legend()
                fig.savefig('AntineutrinoSpectrum/resol_spectrum_N.pdf',format='pdf',transparent=True)
                print('\nThe plot has been saved in AntineutrinoSpectrum/resol_spectrum_N.pdf')

            if ordering == -1: # IO

                ax.plot(E-0.8,self.resol_I,'r',linewidth=1,label='IO')
                ax.legend()
                fig.savefig('AntineutrinoSpectrum/resol_spectrum_I.pdf',format='pdf',transparent=True)
                print('\nThe plot has been saved in AntineutrinoSpectrum/resol_spectrum_I.pdf')

            if ordering == 0: # both NO and IO

                ax.plot(E-0.8,self.resol_N,'b',linewidth=1,label='NO')
                ax.plot(E-0.8,self.resol_I,'r--',linewidth=1,label='IO')
                ax.legend()
                fig.savefig('AntineutrinoSpectrum/resol_spectrum.pdf', format='pdf', transparent=True)
                print('\nThe plot has been saved in AntineutrinoSpectrum/resol_spectrum.pdf')

        return self.resol_N, self.resol_I
Exemple #6
0
 def __init__(self):
     '''Get the four layer's kernels, create the correlations and
    a convolution wrapper.
    :const MIN_IMG_WIDTH: Minimum image width for which to use 
                          NumPy/SciPy for convolution
 '''
     self.kernels = DifferenceOfGaussians()
     self.correlations = Correlation(self.kernels.full_kernels)
     self.convolver = Convolution()
     self.MIN_IMG_WIDTH = 256
Exemple #7
0
class MapDNF(FieldMap):
    def __init__(self,
                 name,
                 size,
                 dt=0.1,
                 wrap=True,
                 tau=0.64,
                 h=0,
                 model='cnft',
                 th=0.75,
                 iExc=1.25,
                 iInh=0.7,
                 wExc=0.1,
                 wInh=10,
                 alpha=10,
                 mapSize=1.,
                 **kwargs):
        super(MapDNF, self).__init__(name,
                                     size,
                                     dt=dt,
                                     wrap=wrap,
                                     tau=tau,
                                     h=h,
                                     model=model,
                                     th=th,
                                     **kwargs)

        self.act = ActivationMap(name + "_activation",
                                 size,
                                 dt=dt,
                                 model=model,
                                 th=th)
        self.lat = Convolution(name + "_lateral", size, dt=dt, wrap=wrap)
        self.kernel = LateralWeightsMap(name + "_kernel",
                                        mapSize=mapSize,
                                        globalSize=size,
                                        wrap=wrap,
                                        iExc=iExc,
                                        iInh=iInh,
                                        wExc=wExc,
                                        wInh=wInh,
                                        alpha=alpha)
        self.act.addChildren(field=self)
        self.addChildren(lat=self.lat)
        self.lat.addChildren(source=self.act, kernel=self.kernel)
        self.kernel.compute()

    def getActivation(self):
        return self.act

    def getArrays(self):
        return [
            self.act,
            self.lat,
        ]
    def plotDefaults(self):
        
        self.convolution = Convolution()

        self.plotUpdate()
        
        self.updateSlider()
        
        self.tminXInput.setText('{}'.format(self.convolution.getMinRangeX()))
        self.tminHInput.setText('{}'.format(self.convolution.getMinRangeH()))
        self.tmaxXInput.setText('{}'.format(self.convolution.getMaxRangeX()))
        self.tmaxHInput.setText('{}'.format(self.convolution.getMaxRangeH()))
        self.XFunctionInput.setText('{}'.format(self.convolution.getXFunctionString()))
        self.HFunctionInput.setText('{}'.format(self.convolution.getHFunctionString()))
 def __init__(self):
     super().__init__()
     self.title = 'La construction de la convolution'
     self.left = 50
     self.top = 50
     self.width = 1600
     self.height = 900
     
     self.sliderTimeFactor = 10
     self.modeEcho = True
     
     self.convolution = Convolution()
     
     self.initUI()
     
     self.plotDefaults()
Exemple #10
0
    def convoluteWavs(self, wav):
        BLOCKSIZE = 1024

        def preprocess():
            if self.audioData.shape[0] < wav.audioData.shape[0]:
                audioSize = self.audioData.shape[0]
                if audioSize % BLOCKSIZE != 0:
                    lastblock = self.audioData[(
                        self.audioData.shape[0] -
                        (self.audioData.shape[0] % BLOCKSIZE)):]
                    temp = self.audioData[:(
                        self.audioData.shape[0] -
                        (self.audioData.shape[0] % BLOCKSIZE))]
                    self.audioData = np.concatenate(
                        (temp,
                         WavProcessing.pad(len(lastblock), lastblock,
                                           BLOCKSIZE)))
                    resultConv = np.zeros((self.audioData.shape[0], 2),
                                          dtype=np.int16)
            elif self.audioData.shape[0] >= wav.audioData.shape[0]:
                audioSize = wav.audioData.shape[0]
                if audioSize % BLOCKSIZE != 0:
                    lastblock = wav.audioData[(
                        wav.audioData.shape[0] -
                        (wav.audioData.shape[0] % BLOCKSIZE)):]
                    temp = wav.audioData[:(
                        wav.audioData.shape[0] -
                        (wav.audioData.shape[0] % BLOCKSIZE))]
                    wav.audioData = np.concatenate(
                        (temp,
                         WavProcessing.pad(len(lastblock), lastblock,
                                           BLOCKSIZE)))
                    resultConv = np.zeros((wav.audioData.shape[0], 2),
                                          dtype=np.int16)
            return resultConv, Matrix.ceil(audioSize, BLOCKSIZE)

        resultConv, nblocks = preprocess()
        for i in xrange(nblocks):
            start = BLOCKSIZE * i
            end = BLOCKSIZE * (i + 1)
            conv = Convolution(
                Matrix(self.audioData[start:end, 0].tolist(), 0),
                Matrix(wav.audioData[start:end, 0].tolist(), 0),
                Convolution.CIRCULAR)
            resultConv[start:end] = conv.convolute()
        self.audioData = resultConv[:]
        conv._plot()
Exemple #11
0
    def __init__(
            self,
            input_dim=(1, 28, 28),
            conv_param={
                'filter_num': 30,
                'filter_size': 5,
                'pad': 0,
                'stride': 1
            },
            hidden_size=100,
            output_size=10,
            weight_init_std=0.01
    ):
        # 畳み込み層のハイパーパラメータ
        filter_num = conv_param['filter_num']
        filter_size = conv_param['filter_size']
        filter_pad = conv_param['pad']
        filter_stride = conv_param['stride']
        input_size = input_dim[1]

        conv_output_size = (input_size - filter_size + 2 *
                            filter_pad) / filter_stride + 1
        pool_output_size = int(
            filter_num * (conv_output_size / 2) * (conv_output_size / 2)
        )

        # 重みパラメータ
        self.params = {}
        self.params['W1'] = weight_init_std * \
            np.random.randn(filter_num, input_dim[0], filter_size, filter_size)
        self.params['b1'] = np.zeros(filter_num)

        self.params['W2'] = weight_init_std * \
            np.random.randn(pool_output_size, hidden_size)
        self.params['b2'] = np.zeros(hidden_size)

        self.params['W3'] = weight_init_std * \
            np.random.randn(hidden_size, output_size)
        self.params['b3'] = np.zeros(output_size)

        # レイヤー
        self.layers = OrderedDict()
        self.layers['Conv1'] = Convolution(
            self.params['W1'],
            self.params['b1'],
            conv_param['stride'],
            conv_param['pad']
        )
        self.layers['Relu1'] = Relu()
        self.layers['Pool1'] = Pooling(pool_h=2, pool_w=2, stride=2)

        self.layers['Affine2'] = Affine(self.params['W2'], self.params['b2'])
        self.layers['Relu2'] = Relu()

        self.layers['Affine3'] = Affine(self.params['W3'], self.params['b3'])
        self.last_layer = Softmax()
Exemple #12
0
 def createConvolution(self):
     width = 1280
     height = 720
     window_width = 50
     window_height = 40 # Break image into 18 vertical layers since image height is 720
     margin = 100 # How much to slide left and right for searching    print("warped shape: ", warped.shape)
     rough_lane_width = 897
     return Convolution(width = width, height = height, window_width = window_width,
                        window_height = window_height, margin = margin,
                        rough_lane_width = rough_lane_width)
Exemple #13
0
 def Convolution(x, args, name):
     """
     Create a convolutional layer with
     :param x: the placeholder for the tensor
     :param args: the arguments for the convolution (filter, strides, padding)
     :param name: a label for the operation
     :return: a convolved tensor
     """
     from convolution import Convolution
     return Convolution(x, args, name)
Exemple #14
0
    def __init__(self):

        output_size = 10
        hidden_size = 12
        self.modules = [
            Reshape((28, 28), (28, 28, 1)),
            Convolution((28, 28, 1), 5, 8), # to 24
            MaxPool(2),  # to 12
            Pad(1), # to 14
            Convolution((14, 14, 8), 3, 16), #to 12
            MaxPool(2), # to 6
            Convolution((6, 6, 16), 3, 24), # to 4
            MaxPool(2), # to 2
            Reshape((2,2,24),(2 * 2 * 24,)),
            MatrixMult([2 * 2 * 24, hidden_size]),
            MatrixAdd([hidden_size]),
            Relu(),
            MatrixMult([hidden_size, output_size]),
            Softmax(),
        ]
 def __init__(self, n_filters, filter_shape,weight_scale,weight_decay):
     self.n_filters = n_filters
     self.filter_shape = filter_shape
     self.weight_scale = weight_scale
     self.weight_decay = weight_decay
     self.conv_ob = Convolution()
Exemple #16
0
class Focal():
'''Filter Overlap Correction ALgorithm, simulates the foveal pit
    region of the human retina.
    Created by Basabdatta Sen Bhattacharya.
    See DOI: 10.1109/TNN.2010.2048339
'''

  def __init__(self):
    self.kernels = DifferenceOfGaussians()
    self.correlations = Correlation(self.kernels.full_kernels)
    self.convolver = Convolution()
    self.MIN_IMG_WIDTH = 256

  def apply(self, image, spikes_per_unit=0.3):
    spike_images = self.filter_image(image)
    focal_spikes = self.focal(spike_images, spikes_per_unit=spikes_per_unit)
    return focal_spikes
    

  def focal(self, spike_images, spikes_per_unit=0.3):
    '''Filter Overlap Correction ALgorithm, simulates the foveal pit
        region of the human retina.
        Created by Basabdatta Sen Bhattacharya.
        See DOI: 10.1109/TNN.2010.2048339
        
        spike_images => A list of the values generated by the convolution
                        procedure, stored as four 2D arrays, each with 
                        the same size/shape of the original image.
        spikes_per_unit => Percentage of the total spikes to be processed,
                           specified in a per unit [0, 1] range.
                           
        returns: an ordered list of 
                  [spike index, sorting value, cell layer/type] tuples.
    '''
    ordered_spikes = []
    
    img_size  = spike_images[0].size
    img_shape = spike_images[0].shape
    height, width = img_shape
    num_images = len(spike_images)

    #how many non-zero spikes are in the images
    max_cycles = 0
    for i in range(num_images):
        max_cycles += numpy.sum(img[i] != 0)

    total_spikes = max_cycles.copy()
    
    #reduce to desired number
    max_cycles = numpy.int(spikes_per_unit*max_cycles)
    
    #copy images from list to a large image to make it a single search space
    big_shape = (height*2, width*2)
    big_image = numpy.zeros(big_shape)
    big_coords = [(0, 0), (0, width), (height, 0), (height, width)]
    for cell_type in range(num_images):
        row, col = big_coords[cell_type]
        tmp_img = original_img[cell_type].copy()
        tmp_img[numpy.where(tmp_img == 0)] = -numpy.inf
        big_image[row:row+height, col:col+width] = tmp_img
    
    # Main FoCal loop
    for count in xrange(max_cycles):
        
        # print out completion percentage
        percent = (count*100.)/float(total_spikes-1)
        sys.stdout.write("\rFocal %d%%"%(percent))
        
        # Get maximum value's index
        max_idx = numpy.argmax(img_copies)
        # and its coordinates
        max_coords = numpy.unravel_index(max_idx, big_shape)
        # and the value
        max_val = big_image[max_coords]
        
        if max_val == numpy.inf or max_val == -numpy.inf or max_val == numpy.nan:
          sys.stderr.write("\nWrong max value in FoCal!")
          break
        
        # translate coordinates from the big image's to a single image coordinates
        if max_coords[0] < height and max_coords[1] < width:
            single_coords = max_coords
        else:
            single_coords = self.global_to_single_coords(max_coords, img_shape)
        
        # calculate a local index, to store per ganglion cell layer info 
        local_idx = single_coords[0]*width + single_coords[1]
        # calculate the type of cell from the index
        cell_type = self.cell_type_from_global_coords(max_coords, img_shape)
        
        # append max spike info to return list
        ordered_spikes.append([local_idx, max_val, cell_type])
        
        # correct surrounding pixels for overlapping kernel influence
        for overlap_cell_type in range(len(original_img)):
            # get equivalent coordinates for each layer
            overlap_idx = self.local_coords_to_global_idx(single_coords, 
                                                         overlap_cell_type, 
                                                         img_shape, big_shape)
            
            is_max_val_layer = overlap_cell_type == cell_type 
            # c_i = c_i - c_{max}<K_i, K_{max}>
            self.adjust_with_correlation_g(big_image,
                                           self.correlations[cell_type]\
                                                            [overlap_cell_type], 
                                           overlap_idx, max_val, 
                                           is_max_val_layer=is_max_val_layer)

    
    return ordered_spikes


  def filter_image(self, img, force_homebrew=False):
    '''Perform convolution with calculated kernels
        img           => the image to convolve
        force_hombrew => if True: use my separated convolution code 
                         else: use SciPy sepfir2d
    '''
    num_kernels = len(self.kernels.full_kernels)
    img_width, img_height = img.shape
    convolved_img = {}

    for cell_type in range(num_kernels):
      if img_width < self.MIN_IMG_WIDTH or img_height < self.MIN_IMG_WIDTH:
        force_homebrew = True
      else:
        force_homebrew = False
        
      c = self.convolver.dog_sep_convolution(img, self.kernels[cell_type], 
                                             cell_type,
                                             originating_function="filter",
                                             force_homebrew=force_homebrew)
      convolved_img[cell_type] =  c

    return convolved_img

  
  def adjust_with_correlation(self, img, correlation, max_idx, max_val, 
                              is_max_val_layer=True):
      
    img_height, img_width = img.shape
    correlation_width = correlation.shape[0]
    half_correlation_width = correlation_width/2
    half_img_width = img_width/2
    half_img_height = img_height/2

    # Get max value's coordinates
    row, col = idx2coord(max_idx, img_width)
    row_idx = row/half_img_height
    col_idx = col/half_img_width
    
    # Calculate the zone to affect with the correlation
    up_lim = (row_idx)*half_img_height
    left_lim = (col_idx)*half_img_width
    
    down_lim = (row_idx + 1)*half_img_height
    right_lim = (col_idx + 1)*half_img_width
    
    max_img_row = numpy.min([down_lim - 1, row + half_correlation_width + 1])
    max_img_col = numpy.min([right_lim  - 1, col + half_correlation_width + 1])
    min_img_row = numpy.max([up_lim, row - half_correlation_width])
    min_img_col = numpy.max([left_lim, col - half_correlation_width])
    
    max_img_row_diff = max_img_row - row
    max_img_col_diff = max_img_col - col
    min_img_row_diff = row - min_img_row
    min_img_col_diff = col - min_img_col
    
    min_knl_row = half_correlation_width - min_img_row_diff
    min_knl_col = half_correlation_width - min_img_col_diff
    max_knl_row = half_correlation_width + max_img_row_diff
    max_knl_col = half_correlation_width + max_img_col_diff

    img_r = [r for r in range(min_img_row, max_img_row)]
    img_c = [c for c in range(min_img_col, max_img_col)]
    
    knl_r = [r for r in range(min_knl_row, max_knl_row)]
    knl_c = [c for c in range(min_knl_col, max_knl_col)]
    
    # c_i = c_i - c_{max}<K_i, K_{max}>
    img[img_r, img_c] -= max_val*correlation[knl_r, knl_c]
        
    # mark any weird pixels as -inf so they don't matter in the search
    inf_indices = numpy.where(img[img_r, img_c] == numpy.inf)
    img[inf_indices] = 0
    img[inf_indices] -= numpy.inf
    
    nan_indices = numpy.where(img[img_r, img_c] == numpy.nan)
    img[nan_indices] = 0
    img[nan_indices] -= numpy.inf
    
    # mark max value's coordinate to -inf to get it out of the search
    if is_max_val_layer:
        img[row, col] -= numpy.inf
    
    # No need to return, values are affected because I'm doing = and -= ops


  def local_coords_to_global_idx(self, coords, cell_type, 
                                 local_img_shape, global_img_shape):
    row_add = cell_type/2
    col_add = cell_type%2
    global_coords = (coords[0] + row_add*local_img_shape[0], 
                     coords[1] + col_add*local_img_shape[1])
    global_idx = global_coords[0]*global_img_shape[1] + global_coords[1]
    return global_idx

  def global_to_single_coords(self, coords, single_shape):
    row_count = coords[0]/single_shape[0]
    col_count = coords[1]/single_shape[1]
    new_row = coords[0] - single_shape[0]*row_count
    new_col = coords[1] - single_shape[1]*col_count
    
    return (new_row, new_col)

  def cell_type_from_global_coords(self, coords, single_shape):
    row_type = coords[0]/single_shape[0]
    col_type = coords[1]/single_shape[1]
    cell_type = row_type*2 + col_type
    
    return cell_type
class App(QWidget):
    def __init__(self):
        super().__init__()
        self.title = 'La construction de la convolution'
        self.left = 50
        self.top = 50
        self.width = 1600
        self.height = 900
        
        self.sliderTimeFactor = 10
        self.modeEcho = True
        
        self.convolution = Convolution()
        
        self.initUI()
        
        self.plotDefaults()
        
    def initUI(self):
        
        self.setWindowTitle(self.title)
        self.setGeometry(self.left, self.top, self.width, self.height)
        self.show()
        
        self.createCanvas()
        self.createWidgets()

        self.createGridLayout()
        

    def createCanvas(self):
        # Figure and canvas instances - canvas takes the `figure` instance as a parameter to __init__
        self.figureX = plt.figure()
        self.figureH = plt.figure()
        self.figureRelative = plt.figure()
        self.figureResult = plt.figure()
        self.figureProducts = plt.figure()
        self.canvasX = FigureCanvas(self.figureX)
        self.canvasH = FigureCanvas(self.figureH)
        self.canvasRelative = FigureCanvas(self.figureRelative)
        self.canvasResult  = FigureCanvas(self.figureResult )
        self.canvasProducts  = FigureCanvas(self.figureProducts)

        # this is the Navigation widget
        # it takes the Canvas widget and a parent
        # self.toolbarX = NavigationToolbar(self.canvasX, self)
        
    def createWidgets(self):
        
        #Button Widgets
        self.buttonReset = QPushButton('Réinitialisation')
        self.buttonReset.clicked.connect(self.plotDefaults)
        self.buttonUpdate = QPushButton('Mettre à jour les graphiques')
        self.buttonUpdate.clicked.connect(self.plotUpdate)
        self.buttonEcho = QRadioButton('Mode echo')
        self.buttonEcho.setChecked(True)
        self.buttonEcho.clicked.connect(self.setModeEcho)
        self.buttonReverse = QRadioButton('Mode retourné')
        self.buttonReverse.clicked.connect(self.setModeReverse)
        
        
        self.sliderTimeLabel = QLabel("Selection du point t à évaluer")
        self.sliderTimeLabel.setAlignment(Qt.AlignCenter)
        self.sliderEchoLabel = QLabel("Nombre de points contribuant à l'évaluation du point t")
        self.sliderEchoLabel.setAlignment(Qt.AlignCenter)
        self.tminXLabel = QLabel("Valeur minimum de t pout x(t)")
        self.tminXLabel.setAlignment(Qt.AlignRight)
        self.tmaxXLabel = QLabel("Valeur maximum de t pour x(t)")
        self.tmaxXLabel.setAlignment(Qt.AlignRight)
        self.tminHLabel = QLabel("Valeur minimum de t pour h(t)")
        self.tminHLabel.setAlignment(Qt.AlignRight)
        self.tmaxHLabel = QLabel("Valeur maximum de t pour h(t)")
        self.tmaxHLabel.setAlignment(Qt.AlignRight)
        self.XFunctionLabel = QLabel("Fonction x(t)")
        self.XFunctionLabel.setAlignment(Qt.AlignRight)
        self.HFunctionLabel = QLabel("Fonction h(t)")
        self.HFunctionLabel.setAlignment(Qt.AlignRight)
        self.MessageLabel = QLabel("Les fonctions doivent être entrées avec" + 
                                   " la syntaxe Python et la nomenclature Numpy. " +
                                   "Il y a 1000 points dans le vecteur \"t\".")
        self.MessageLabel.setAlignment(Qt.AlignCenter)
        
        
        self.sliderTime = QSlider(Qt.Horizontal)
        self.sliderTime.valueChanged.connect(self.moveTau) 
        self.sliderTime.setTickPosition(QSlider.TicksBelow)
        
        self.sliderEcho = QSlider(Qt.Horizontal)
        self.sliderEcho.valueChanged.connect(self.changeNumberOfEchos) 
        self.sliderEcho.setTickPosition(QSlider.TicksBelow)
        
        self.sliderEcho.setMinimum(1)
        self.sliderEcho.setMaximum(300)
        
        self.tminXInput = QLineEdit()
        self.tminXInput.setValidator(QDoubleValidator())
        self.tminXInput.textChanged.connect(self.updateMinRangeX)
        
        self.tmaxXInput = QLineEdit()
        self.tmaxXInput.setValidator(QDoubleValidator())
        self.tmaxXInput.textChanged.connect(self.updateMaxRangeX)
        
        self.tminHInput = QLineEdit()
        self.tminHInput.setValidator(QDoubleValidator())
        self.tminHInput.textChanged.connect(self.updateMinRangeH)
        
        self.tmaxHInput = QLineEdit()
        self.tmaxHInput.setValidator(QDoubleValidator())
        self.tmaxHInput.textChanged.connect(self.updateMaxRangeH)
        
        self.XFunctionInput = QLineEdit()
        self.XFunctionInput.returnPressed.connect(self.updateXFunction)
        self.HFunctionInput = QLineEdit()
        self.HFunctionInput.returnPressed.connect(self.updateHFunction)
        
        
    def createGridLayout(self):
        # set the layout
        self.horizontalGroupBox = QGroupBox("Grid")
        layout = QGridLayout()
        layout.setColumnStretch(0, 50)
        layout.setColumnStretch(2, 50)
        layout.setColumnStretch(4, 1000)
        layout.addWidget(self.canvasX, 0, 0, 1, 2)
        layout.addWidget(self.canvasH, 0, 2, 1, 2)
        layout.addWidget(self.canvasRelative, 1, 0, 1, 4)
        layout.addWidget(self.canvasProducts, 0, 4, 2, 1)
        layout.addWidget(self.canvasResult, 2, 4, 10, 1)
        layout.addWidget(self.sliderTimeLabel, 2, 0, 1, 4)
        layout.addWidget(self.sliderTime, 3, 0, 1, 4)
        layout.addWidget(self.sliderEchoLabel, 4, 0, 1, 4)
        layout.addWidget(self.sliderEcho, 5, 0, 1, 4)
        layout.addWidget(self.buttonReset, 6, 0)
        layout.addWidget(self.buttonUpdate, 6, 1)
        
        layout.addWidget(self.buttonEcho, 6, 2)
        layout.addWidget(self.buttonReverse, 6, 3)
        
        layout.addWidget(self.tminXLabel, 7,0)
        layout.addWidget(self.tmaxXLabel, 8,0)
        layout.addWidget(self.tminXInput, 7,1)
        layout.addWidget(self.tmaxXInput, 8,1)
        
        layout.addWidget(self.tminHLabel, 7,2)
        layout.addWidget(self.tmaxHLabel, 8,2)
        layout.addWidget(self.tminHInput, 7,3)
        layout.addWidget(self.tmaxHInput, 8,3)
        
        layout.addWidget(self.XFunctionInput, 9,1,1,3)
        layout.addWidget(self.HFunctionInput, 10,1,1,3)
        layout.addWidget(self.XFunctionLabel, 9,0,1,1)
        layout.addWidget(self.HFunctionLabel, 10,0, 1,1)
        layout.addWidget(self.MessageLabel, 11,0, 1, 4)
        
        self.setLayout(layout)

    def plotDefaults(self):
        
        self.convolution = Convolution()

        self.plotUpdate()
        
        self.updateSlider()
        
        self.tminXInput.setText('{}'.format(self.convolution.getMinRangeX()))
        self.tminHInput.setText('{}'.format(self.convolution.getMinRangeH()))
        self.tmaxXInput.setText('{}'.format(self.convolution.getMaxRangeX()))
        self.tmaxHInput.setText('{}'.format(self.convolution.getMaxRangeH()))
        self.XFunctionInput.setText('{}'.format(self.convolution.getXFunctionString()))
        self.HFunctionInput.setText('{}'.format(self.convolution.getHFunctionString()))
        
    def updateSlider(self):
        self.sliderTime.setMinimum(self.convolution.getMinRangeX()*self.sliderTimeFactor)
        self.sliderTime.setMaximum(self.convolution.getMaxRangeX()*self.sliderTimeFactor)
        #self.sliderTime.setTickInterval(self.convolution.getStep())
        self.sliderTime.setSingleStep((self.convolution.getMaxRangeX()-self.convolution.getMinRangeX())/100)
        
    def plotUpdate(self):
        self.figureX.clear()
        ax = self.figureX.add_subplot(111)
        dataX = self.convolution.getXfunction()
        ax.plot(dataX[0], dataX[1])
        ax.set_title("x(t)")
        self.canvasX.draw()

        self.figureH.clear()
        ax = self.figureH.add_subplot(111)
        dataH = self.convolution.getHfunction()
        ax.plot(dataH[0], dataH[1])
        ax.set_title("h(t)")
        self.canvasH.draw()
        
        self.figureRelative.clear()
        ax = self.figureRelative.add_subplot(111)
        tau = self.convolution.getTau()
        ax.plot(dataX[0], dataX[1], color='blue')
        ax.axvline(x=tau, color='red')
        ax.plot((dataH[0]-dataH[0][0]+tau), dataH[1], color='green')
        ax.text(0.9, 0.9, 't = {}'.format(tau), transform=ax.transAxes, fontsize='large')
        ax.set_title("Positions relatives de x(t) et h(t)")
        self.canvasRelative.draw()
        
        
        tauindex = int(((tau-self.convolution.getMinRangeX())/self.convolution.getStep()))
        
        self.figureResult.clear()
        ax = self.figureResult.add_subplot(111)
        ax.set_title("Convolution x(t) et h(t)")
        data = self.convolution.getConvolution()
        ax.plot(data[0], data[1])
        ax.axvline(x=tau, color='red')
        ax.scatter(tau, data[1][tauindex])
        ax.text(0.8, 0.9, 'x(t) * h(t) = {0:5.4f}'.format(data[1][tauindex]), transform=ax.transAxes, fontsize='large')
        self.canvasResult.draw()
        
        if self.modeEcho == True:
            self.productPlotWithEchos()
        else:
            self.productPlotReverse()
        
    def productPlotWithEchos(self):
        self.figureProducts.clear()
        
        tau = self.convolution.getTau()
        dataX = self.convolution.getXfunction()
        dataH = self.convolution.getHfunction()
        
        ax = self.figureProducts.add_subplot(111)
        ax.axvline(x=tau, color='red')
        ax.plot(dataX[0], dataX[1], color='blue')
        ax.plot((dataH[0]-dataH[0][0]+tau), dataH[1], color='green')
        tauindex = int(((tau-self.convolution.getMinRangeX())/self.convolution.getStep()))
        ax.text(0.7, 0.95, r'$\Delta\tau=$ {0:5.4f}'.format(self.convolution.getEchoPoints()*self.convolution.getStep()), transform=ax.transAxes, fontsize='large')
        textincrement = 0
        total=dataH[1][0]*dataX[1][tauindex]*self.convolution.getEchoPoints()*self.convolution.getStep()
        ax.scatter(tau, dataX[1][tauindex], marker='x')
        for i, echo in enumerate(self.convolution.createEchos()):
            try:
                intersection = (dataX[1][i*(self.convolution.getEchoPoints())]*
                                dataH[1][self.convolution.getHindex(echo-self.convolution.getMinRangeX()+self.convolution.getMinRangeH())])
            except IndexError:
                intersection = 0
                
            if intersection>0:
                tOffset = dataH[0][0]-tau+echo-self.convolution.getMinRangeX()
                line, = ax.plot((dataH[0]-tOffset), dataX[1][i*(self.convolution.getEchoPoints())] * dataH[1], alpha = 0.5)
                ax.scatter(tau, intersection, color=line.get_color())
                if textincrement < 16:
                    ax.text(0.7, 0.9-textincrement*0.05, 
                            r'$x(t-\tau_{{{0}}})h(\tau_{{{0}}}) =$ {1:5.4f}'.format(textincrement+1, intersection), 
                            transform=ax.transAxes, fontsize='large', color=line.get_color())
                    textincrement+=1
                total += intersection*self.convolution.getEchoPoints()*self.convolution.getStep()
                
        ax.text(0.95, 0.1, r"$\sum{{x(t-\tau_{{n}})\cdot h(\tau_{{n}})\cdot\Delta\tau}}=${0:5.2f}".format(total), transform=ax.transAxes, fontsize='x-large', ha='right')
        ax.set_title("Translation de h(t) en un point")
        minVert = npmin([dataX[1], dataH[1]])
        maxVert = npmax([dataX[1], dataH[1]])
        adjust = (maxVert-minVert)*0.1
        plt.axis([dataX[0][0], dataX[0][-1], minVert-adjust, maxVert+adjust])
        self.canvasProducts.draw()
    
    def productPlotReverse(self):
        self.figureProducts.clear()
                
        tau = self.convolution.getTau()
        dataX = self.convolution.getXfunction()
        dataH = self.convolution.getHfunction()
        
        ax = self.figureProducts.add_subplot(111)
        ax.axvline(x=tau, color='red')
        ax.plot(dataX[0], dataX[1], color='blue')
        ax.plot(-(dataH[0]-dataH[0][0])+tau, dataH[1], color='green')
        tauindex = int(((tau-self.convolution.getMinRangeX())/self.convolution.getStep()))
        ax.text(0.7, 0.95, r'$\Delta\tau=$ {0:5.4f}'.format(self.convolution.getEchoPoints()*self.convolution.getStep()), transform=ax.transAxes, fontsize='large')
        textincrement = 0
        total=dataH[1][0]*dataX[1][tauindex]*self.convolution.getEchoPoints()*self.convolution.getStep()
        ax.scatter(tau, dataX[1][tauindex], marker='x')
        for i, echo in enumerate(self.convolution.createEchos()):
            try:
                intersection = (dataX[1][i*(self.convolution.getEchoPoints())]*
                                dataH[1][self.convolution.getHindex(echo-self.convolution.getMinRangeX()+
                                     self.convolution.getMinRangeH())])
            except IndexError:
                intersection = 0
                
            if intersection>0:
                xposition = tau-echo+self.convolution.getMinRangeX()
                line, = ax.plot([xposition, xposition], [0, intersection])
                #Find color and apply to scatter and text
                ax.scatter(xposition, intersection, color=line.get_color())
                if textincrement < 16:
                    ax.text(0.7, 0.9-textincrement*0.05, 
                            r'$x(t-\tau_{{{0}}})h(\tau_{{{0}}}) =$ {1:5.4f}'.format(textincrement+1, intersection), 
                            transform=ax.transAxes, fontsize='large', color=line.get_color())
                    textincrement+=1
                total += intersection*self.convolution.getEchoPoints()*self.convolution.getStep()
                
        ax.text(0.95, 0.1, r"$\sum{{x(\tau_{{n}})\cdot h(t-\tau_{{n}})\cdot\Delta\tau}}=${0:5.2f}".format(total), transform=ax.transAxes, fontsize='x-large', ha='right')
        ax.set_title("Translation de h(t) en un point")
        #SET Axes to fix X
        minVert = npmin([dataX[1], dataH[1]])
        maxVert = npmax([dataX[1], dataH[1]])
        adjust = (maxVert-minVert)*0.1
        plt.axis([dataX[0][0], dataX[0][-1], minVert-adjust, maxVert+adjust])
        self.canvasProducts.draw()
        
    
    def updateMinRangeX(self, minvalue):
        self.convolution.setMinRangeX(float(minvalue))
        self.plotUpdate()
        self.updateSlider()
        
    def updateMaxRangeX(self, maxvalue):
        self.convolution.setMaxRangeX(float(maxvalue))
        self.plotUpdate()
        self.updateSlider()
        
    def updateMinRangeH(self, minvalue):
        self.convolution.setMinRangeH(float(minvalue))
        self.plotUpdate()
        self.updateSlider()
        
    def updateMaxRangeH(self, maxvalue):
        self.convolution.setMaxRangeH(float(maxvalue))
        self.plotUpdate()
        self.updateSlider()
        
    def updateXFunction(self):
        self.convolution.setXFunction(self.XFunctionInput.text())
        self.plotUpdate()
        
    def updateHFunction(self):
        self.convolution.setHFunction(self.HFunctionInput.text())
        self.plotUpdate()
    
    def moveTau(self):
        tau = self.sliderTime.value()/float(self.sliderTimeFactor)
        self.convolution.setTau(tau)
        self.plotUpdate()
        
    def changeNumberOfEchos(self):
        self.convolution.setEchoRate(self.sliderEcho.value())
        self.plotUpdate()
        
    def setModeEcho(self):
        self.modeEcho = True
        self.productPlotWithEchos()
        
    def setModeReverse(self):
        self.modeEcho = False
        self.productPlotReverse()
Exemple #18
0
names = ['i-3-a', 'i-3-b', 'i-3-c']
char = 97

for name in names:
    path = '../input/convolution/' + name + '.jpg'
    img = cv2.imread(path)
    print(path)
    i = 0
    for n in [3, 7, 15]:
        kernel = np.ones((n, n), dtype=np.float32) / (n * n)
        size = str(n) + 'x' + str(n)
        print(size)
        start_time = time.time()
        img_out_1 = conv.convolution_nd(img,
                                        kernel,
                                        conv_type=conv.CONV_ITERATIVE)
        print("--- classical algorithm: %s seconds ---" %
              (time.time() - start_time))
        name = '../output/convolution/o-3-' + chr(char) + '-' + str(
            i) + '-' + size + 'ca.png'
        cv2.imwrite(name, img_out_1)
        i += 1

        start_time = time.time()
        img_out_2 = conv.convolution_nd(img,
                                        kernel,
                                        conv_type=conv.CONV_KERNEL_SIZE)
        print("--- vectorized element-wise multiplication %s seconds ---" %
              (time.time() - start_time))
        name = '../output/convolution/o-3-' + chr(char) + '-' + str(
	def __init__(self,num_filt=64):
		Neural_Network.__init__(self)
		self.conv = Convolution(num_filt)
class CNN(Neural_Network) :

	def __init__(self,num_filt=64):
		Neural_Network.__init__(self)
		self.conv = Convolution(num_filt)

	def train(self,X=None,y=None,nodesNumLayer=[16],nodes_outputLayer=1,learning_rate=0.1,epochs=100,hidden_activation=None,output_activation = None,save=False):
		if X is None or y is None :
			print('No Dataset or labels given')
			exit()

		if hidden_activation is None or output_activation is None :
			print("Activation function not given")
			exit()


		self.nodesNumLayer=nodesNumLayer #list of number of nodes in each layer
		self.nodes_outputLayer=nodes_outputLayer 
		self.lr = learning_rate		
		self.init_weights_bias(self.conv.feed_through_layer(X[0,:]).flatten().shape[0])
		self.hidden_activation = hidden_activation
		self.output_activation = output_activation
		cost_function=self.MSE

		for i in range(epochs) :
			cost_sum = 0
			print("epoch",i)
			for j in range(X.shape[0]) :
				convoluted_op = self.conv.feed_through_layer(X[j,:])
				cop_shape = convoluted_op.shape
				#print("cop_shape",cop_shape)
				convoluted_op = convoluted_op.flatten()
				y_pred = self.feedForward(convoluted_op,hidden_activation,output_activation)
				cost_sum  += np.sum(cost_function(y_pred,y[j]))
				self.backProp(cost_function,y[j],y_pred,X[j,:],cop_shape)

			
			print("cost:",cost_sum)
			print()

	def backProp(self,cost_function,actual,predicted,inp,conv_layer_shape):
		errors = []
		derivative_cost = scp.derivative(self.MSE,actual,dx=1e-6,args=(predicted,))
		output_layer = self.layer_vals[-1]
		output_error = derivative_cost*np.vectorize(scp.derivative)(self.output_activation,output_layer,dx=1e-6)
		current_err = output_error.reshape(1,-1)
		i=1
		while i<=(len(self.weights)) :
			errors.append(current_err)
			current_layer = self.layer_vals[-(i+1)]
			current_err = np.matmul(current_err,self.weights[-i].T)*np.vectorize(scp.derivative)(self.hidden_activation,current_layer,dx=1e-6)
			i+=1

		self.conv.conv_backProp(current_err.reshape(conv_layer_shape[0],conv_layer_shape[1],conv_layer_shape[2]),inp)

		for i in range(len(self.weights)-1) :

			x,y = np.meshgrid(errors[i],np.vectorize(self.hidden_activation)(self.layer_vals[-(i+2)]))
			delta_w = x*y*self.lr
			self.weights[-(i+1)] += delta_w

			self.bias[-(i+1)] += (self.lr*errors[i].flatten())


		x,y = np.meshgrid(errors[len(self.weights)-1],self.layer_vals[0])
		delta_w=x*y*self.lr
		self.weights[0] += delta_w
		self.bias[0] += (self.lr*errors[len(self.weights)-1].flatten())

	def test(self,X,y):
		count=0
		for i in range(X.shape[0]) :
			convoluted_op = self.conv.feed_through_layer(X[i,:])
			cop_shape = convoluted_op.shape
			#print("cop_shape",cop_shape)
			convoluted_op = convoluted_op.flatten()
			y_pred = self.feedForward(convoluted_op,self.hidden_activation,self.output_activation)

			if np.argmax(y_pred) == np.argmax(y[i]) :
				count+=1

		return count/y.shape[0]
        h3 = self.i(h3)
        h4 = self.i(h4)

        h3_square = h3 * h3
        h4_square = h4 * h4

        summed = numpy.add(h3_square, h4_square)

        img = numpy.sqrt(summed)
        img = self.f(summed)

        self.set(img)
        self.set(self.normalize(self.get()))

    def i(self, img):
        return img / 255

    def f(self, img):
        return img * 255


if __name__ == "__main__":
    import sys
    first = Convolution(sys.argv[1])
    second = Convolution(sys.argv[1])
    first.apply_def('h3')
    second.apply_def('h4')

    i = ConvolutionSquare(sys.argv[1])
    i.apply_multiplication(first, second)
    i.save_to_file("output.png")
Exemple #22
0
from MLP import MLP
from convolution import Convolution, Pooling, Model
from mnist import loadData

if __name__ == '__main__':
    trainX, trainY, testX, testY, valX, valY = loadData()
    model = Model()

    model.add_layer(Convolution(16, 1, 3, 1))
    model.add_layer(Pooling(2, 2))
    model.add_layer(MLP(784, 128, 10, activation='sigmoid'))
    model.feed_forward(trainX[0])
Exemple #23
0
class Focal():
    '''Filter Overlap Correction ALgorithm, simulates the foveal pit
      region of the human retina.
      Created by Basabdatta Sen Bhattacharya.
      See DOI: 10.1109/TNN.2010.2048339
  '''
    def __init__(self):
        '''Get the four layer's kernels, create the correlations and
       a convolution wrapper.
       :const MIN_IMG_WIDTH: Minimum image width for which to use 
                             NumPy/SciPy for convolution
    '''
        self.kernels = DifferenceOfGaussians()
        self.correlations = Correlation(self.kernels.full_kernels)
        self.convolver = Convolution()
        self.MIN_IMG_WIDTH = 256

    def apply(self, image, spikes_per_unit=0.3, overlapcorr=True):
        '''Wrapper function to convert an image into a FoCal representation
        :param image: The image to convert
        :param spikes_per_unit: How many spikes to return, specified in per-unit
                                (i.e. multiply by 100 to get percentage)
    '''
        spike_images = self.filter_image(image)
        focal_spikes = self.focal(spike_images,
                                  spikes_per_unit=spikes_per_unit,
                                  overlapcorr=overlapcorr)
        return focal_spikes

    def focal(self, spike_images, spikes_per_unit=0.3, overlapcorr=True):
        '''Filter Overlap Correction ALgorithm, simulates the foveal pit
        region of the human retina.
        Created by Basabdatta Sen Bhattacharya.
        See DOI: 10.1109/TNN.2010.2048339
        
        spike_images => A list of the values generated by the convolution
                        procedure, stored as four 2D arrays, each with 
                        the same size/shape of the original image.
        spikes_per_unit => Percentage of the total spikes to be processed,
                           specified in a per unit [0, 1] range.
                           
        returns: an ordered list of 
                  [spike index, sorting value, cell layer/type] tuples.
    '''
        ordered_spikes = []

        img_size = spike_images[0].size
        img_shape = spike_images[0].shape
        height, width = img_shape
        num_images = len(spike_images)

        #how many non-zero spikes are in the images
        max_cycles = 0
        for i in range(num_images):
            max_cycles += numpy.sum(spike_images[i] != 0)

        total_spikes = max_cycles.copy()

        #reduce to desired number
        max_cycles = numpy.int(spikes_per_unit * max_cycles)

        #copy images from list to a large image to make it a single search space
        big_shape = (height * 2, width * 2)
        big_image = numpy.zeros(big_shape)
        big_coords = [(0, 0), (0, width), (height, 0), (height, width)]
        for cell_type in range(num_images):
            row, col = big_coords[cell_type]
            tmp_img = spike_images[cell_type].copy()
            tmp_img[numpy.where(tmp_img == 0)] = -numpy.inf
            big_image[row:row + height, col:col + width] = tmp_img

        # Main FoCal loop
        for count in range(max_cycles):

            # print out completion percentage
            percent = (count * 100.) / float(total_spikes - 1)
            sys.stdout.write("\rFocal %d%%" % (percent))

            # Get maximum value's index,
            max_idx = numpy.argmax(big_image)
            # its coordinates
            max_coords = numpy.unravel_index(max_idx, big_shape)
            # and the value
            max_val = big_image[max_coords]

            if max_val == numpy.inf or max_val == -numpy.inf or max_val == numpy.nan:
                sys.stderr.write("\nWrong max value in FoCal!")
                break

            # translate coordinates from the big image's to a single image coordinates
            if max_coords[0] < height and max_coords[1] < width:
                single_coords = max_coords
            else:
                single_coords = self.global_to_single_coords(
                    max_coords, img_shape)

            # calculate a local index, to store per ganglion cell layer info
            local_idx = single_coords[0] * width + single_coords[1]
            # calculate the type of cell from the index
            cell_type = self.cell_type_from_global_coords(
                max_coords, img_shape)

            # append max spike info to return list
            ordered_spikes.append([local_idx, max_val, cell_type])

            if overlapcorr:
                # correct surrounding pixels for overlapping kernel influence
                for overlap_cell_type in range(len(spike_images)):
                    # get equivalent coordinates for each layer
                    overlap_idx = self.local_coords_to_global_idx(
                        single_coords, overlap_cell_type, img_shape, big_shape)

                    is_max_val_layer = overlap_cell_type == cell_type
                    # c_i = c_i - c_{max}<K_i, K_{max}>
                    self.adjust_with_correlation(
                        big_image,
                        self.correlations[cell_type][overlap_cell_type],
                        overlap_idx,
                        max_val,
                        is_max_val_layer=is_max_val_layer)

        return ordered_spikes

    def filter_image(self, img, force_homebrew=False):
        '''Perform convolution with calculated kernels
        img           => the image to convolve
        force_hombrew => if True: use my separated convolution code 
                         else: use SciPy sepfir2d
    '''
        num_kernels = len(self.kernels.full_kernels)
        img_width, img_height = img.shape
        convolved_img = {}

        for cell_type in range(num_kernels):
            if img_width < self.MIN_IMG_WIDTH or img_height < self.MIN_IMG_WIDTH:
                force_homebrew = True
            else:
                force_homebrew = False

            c = self.convolver.dog_sep_convolution(
                img,
                self.kernels[cell_type],
                cell_type,
                originating_function="filter",
                force_homebrew=force_homebrew)
            convolved_img[cell_type] = c

        return convolved_img

    def adjust_with_correlation(self,
                                img,
                                correlation,
                                max_idx,
                                max_val,
                                is_max_val_layer=True):
        '''Modify surrounding pixels by the correlation of kernels. 
       Example:
         If max_val is in layer 1, we overlap all layers and then multiply
         surrounding pixels by the correlation between layer 1 and layerX (1,2,3, or 4).
       :param img: An image representing the spikes generated by the previous step
                   or simulation of a ganglion cell layer
       :param max_idx: index of the pixel/neuron that has the maximum value from
                       the previous step or simulation
       :param max_val: value of the max pixel/neuron
       :param is_max_val_layer: Required to mark max_idx as visited
       
       :returns: img with the proper adjustment
    '''

        img_height, img_width = img.shape
        correlation_width = correlation.shape[0]
        half_correlation_width = int(correlation_width / 2)
        half_img_width = int(img_width / 2)
        half_img_height = int(img_height / 2)

        # Get max value's coordinates
        row, col = idx2coord(max_idx, img_width)
        row_idx = int(row / half_img_height)
        col_idx = int(col / half_img_width)

        # Calculate the zone to affect with the correlation
        up_lim = (row_idx) * half_img_height
        left_lim = (col_idx) * half_img_width

        down_lim = (row_idx + 1) * half_img_height
        right_lim = (col_idx + 1) * half_img_width

        max_img_row = numpy.min(
            [down_lim - 1, row + half_correlation_width + 1])
        max_img_col = numpy.min(
            [right_lim - 1, col + half_correlation_width + 1])
        min_img_row = numpy.max([up_lim, row - half_correlation_width])
        min_img_col = numpy.max([left_lim, col - half_correlation_width])

        max_img_row_diff = max_img_row - row
        max_img_col_diff = max_img_col - col
        min_img_row_diff = row - min_img_row
        min_img_col_diff = col - min_img_col

        min_knl_row = half_correlation_width - min_img_row_diff
        min_knl_col = half_correlation_width - min_img_col_diff
        max_knl_row = half_correlation_width + max_img_row_diff
        max_knl_col = half_correlation_width + max_img_col_diff

        # c_i = c_i - c_{max}<K_i, K_{max}>
        img[min_img_row:max_img_row,
            min_img_col:max_img_col] -= max_val * correlation[
                min_knl_row:max_knl_row, min_knl_col:max_knl_col]

        # mark any weird pixels as -inf so they don't matter in the search
        inf_indices = numpy.where(img[min_img_row:max_img_row,
                                      min_img_col:max_img_col] == numpy.inf)
        img[inf_indices] = 0
        img[inf_indices] -= numpy.inf

        nan_indices = numpy.where(img[min_img_row:max_img_row,
                                      min_img_col:max_img_col] == numpy.nan)
        img[nan_indices] = 0
        img[nan_indices] -= numpy.inf

        # mark max value's coordinate to -inf to get it out of the search
        if is_max_val_layer:
            img[row, col] -= numpy.inf

        # No need to return, variables are passed as reference because we're doing = and -= ops

    def local_coords_to_global_idx(self, coords, cell_type, local_img_shape,
                                   global_img_shape):
        '''Utility to transform from local (width*height) coordinates to
       global (2*width, 2*height) coords.             ---------
       Layers are represented in the global image as: [ 0 | 1 ]
                                                       -------
                                                      [ 2 | 3 ]
                                                      ---------
    '''
        row_add = int(cell_type / 2)
        col_add = int(cell_type % 2)
        global_coords = (coords[0] + row_add * local_img_shape[0],
                         coords[1] + col_add * local_img_shape[1])
        global_idx = global_coords[0] * global_img_shape[1] + global_coords[1]
        return global_idx

    def global_to_single_coords(self, coords, single_shape):
        '''Utility to transform from global (2*width, 2*height) coordinates to
       local (width*height) coords      .             ---------
       Layers are represented in the global image as: [ 0 | 1 ]
                                                       -------
                                                      [ 2 | 3 ]
                                                      ---------
    '''
        row_count = int(coords[0] / single_shape[0])
        col_count = int(coords[1] / single_shape[1])
        new_row = coords[0] - single_shape[0] * row_count
        new_col = coords[1] - single_shape[1] * col_count

        return (new_row, new_col)

    def cell_type_from_global_coords(self, coords, single_shape):
        '''Utility to compute which layer does a coordinate belong to'''
        row_type = int(coords[0] / single_shape[0])
        col_type = int(coords[1] / single_shape[1])
        cell_type = row_type * 2 + col_type

        return cell_type
Exemple #24
0
class PoseCellNetwork:

  def __init__( self, shape, **kwargs ):

    self.shape = shape
    self.posecells = zeros(shape)
    #NOTE: might not need if gaussian_filter works
    self.kernel_3d = self.diff_gaussian( PC_E_DIM, PC_I_DIM, PC_E_SIGMA, PC_I_SIGMA, order=3 )
    self.kernel_2d = self.diff_gaussian( PC_E_DIM, PC_I_DIM, PC_E_SIGMA, PC_I_SIGMA, order=2 )
    self.kernel_1d = self.diff_gaussian( PC_E_DIM, PC_I_DIM, PC_E_SIGMA, PC_I_SIGMA, order=1 )
    self.kernel_1d_sep = self.diff_gaussian_separable( PC_E_DIM, PC_I_DIM, PC_E_SIGMA, PC_I_SIGMA )

    self.global_inhibition = PC_GLOBAL_INHIB
    self.pc_vtrans_scale = PC_CELL_X_SIZE
    self.pc_vrot_scale = 2.0*pi/shape[2]#PC_C_SIZE_TH
    
    #TODO: maybe change everything to float32 to make it go faster?
    #self.conv = Convolution( im=self.posecells, fil=self.kernel_1d, sep=True, type=float64 )
    #self.conv = Convolution( im=self.posecells, fil=self.kernel_1d_sep, sep=True, type=float64 )
    self.conv = Convolution( im=self.posecells, fil=self.kernel_3d, sep=False, type=float64 )
    
    filter = self.diff_gaussian_offset_2d( PC_E_SIGMA, PC_I_SIGMA, shape=(7,7), origin=(0,0) )
    #self.conv.new_filter( self.kernel_2d, dim=2 )
    self.conv.new_filter( filter, dim=2 )

    self.filter_dict_2d = self.build_diff_gaussian_set_2d( PC_E_SIGMA, PC_I_SIGMA, shape=(7,7), precision=1 )
    self.filter_dict_2d_precision = 10 # multiple the decimal by this number to get the right key

  def build_diff_gaussian_set_2d( self, sigma_e, sigma_i, shape=(7,7), precision=1 ):
    """Builds a set of difference of gaussian kernels with origins within a unit square. 
       These will be used as a look up table of approximate kernels to improve speed"""
    dict = {}
    # larger precision values denote greater precision. Must be integer to prevent floating point errors
    for x in xrange( -5 * precision, 5 * precision ):
      for y in xrange( -5 * precision, 5 * precision ):
        dict[ ( x, y ) ] = self.diff_gaussian_offset_2d( sigma_e, sigma_i, shape=shape, 
                             origin=( x / ( precision * 10 ), y / ( precision * 10 ) ) )
    return dict

  # builds a 3D gaussian filter kernel with lengths of 'dim'
  def build_kernel( self, dim, sigma, order=3 ):
    if order==3:
      f = empty( ( dim, dim, dim ) )
      center = math.floor( dim / 2 )
      for x in xrange( dim ):
        for y in xrange( dim ):
          for z in xrange( dim ):
            f[x,y,z] = 1.0 / (sigma*math.sqrt(2*pi)) * \
                math.exp( (-(x-center)**2 - (y-center)**2 - (z-center)**2 ) / (2*sigma**2))

      f /= abs(sum(f.ravel())) # normalize
      return f
    elif order==2:
      f = empty( ( dim, dim ) )
      center = math.floor( dim / 2 )
      for x in xrange( dim ):
        for y in xrange( dim ):
          f[x,y] = 1.0 / (sigma*math.sqrt(2*pi)) * \
              math.exp( (-(x-center)**2 - (y-center)**2 ) / (2*sigma**2))

      f /= abs(sum(f.ravel())) # normalize
      return f
    elif order==1:
      f = empty( ( dim ) )
      center = math.floor( dim / 2 )
      for x in xrange( dim ):
          f[x] = 1.0 / (sigma*math.sqrt(2*pi)) * \
              math.exp( -(x-center)**2  / (2*sigma**2))

      f /= abs(sum(f.ravel())) # normalize
      return f
    else:
      pass #TODO: put an error statement here

  # builds a 3D difference of gaussians filter kernel with lengths of 'dim'
  def diff_gaussian( self, dim_e, dim_i, sigma_e, sigma_i, order=3 ):
    dim = max(dim_e, dim_i)
    if order==3:
      f = empty( ( dim, dim, dim ) )
      center = math.floor( dim / 2 )
      for x in xrange( dim ):
        for y in xrange( dim ):
          for z in xrange( dim ):
            f[x,y,z] = ( 1 if max(x,y,z) <= center + dim_e and min(x,y,z) >= center - dim_e else 0 ) * \
                1.0 / (sigma_e*math.sqrt(2*pi))**3 * \
                math.exp( (-(x-center)**2 - (y-center)**2 - (z-center)**2 ) / (2*sigma_e**2)) - \
                ( 1 if max(x,y,z) <= center + dim_i and min(x,y,z) >= center - dim_i else 0 ) * \
                1.0 / (sigma_i*math.sqrt(2*pi))**3 * \
                math.exp( (-(x-center)**2 - (y-center)**2 - (z-center)**2 ) / (2*sigma_i**2))

      f /= abs(sum(f.ravel())) # normalize
      return f
    elif order==2:
      f = empty( ( dim, dim ) )
      center = math.floor( dim / 2 )
      for x in xrange( dim ):
        for y in xrange( dim ):
          f[x,y] = ( 1 if max(x,y) <= center + dim_e and min(x,y) >= center - dim_e else 0 ) * \
              1.0 / (sigma_e * sigma_e * 2 * pi) * \
              math.exp( (-(x-center)**2 - (y-center)**2 ) / (2*sigma_e**2)) - \
              ( 1 if max(x,y) <= center + dim_i and min(x,y) >= center - dim_i else 0 ) * \
              1.0 / (sigma_i * sigma_i * 2 * pi) * \
              math.exp( (-(x-center)**2 - (y-center)**2 ) / (2*sigma_i**2))

      f /= abs(sum(f.ravel())) # normalize
      return f
    elif order==1:
      f = empty( ( dim ) )
      center = math.floor( dim / 2 )
      for x in xrange( dim ):
        f[x] = ( 1 if x <= center + dim_e and x >= center - dim_e else 0 ) * \
            1.0 / (sigma_e*math.sqrt(2*pi)) * \
            math.exp( -(x-center)**2  / (2*sigma_e**2)) - \
            ( 1 if x <= center + dim_i and x >= center - dim_i else 0 ) * \
            1.0 / (sigma_i*math.sqrt(2*pi)) * \
            math.exp( -(x-center)**2  / (2*sigma_i**2))

      f /= abs(sum(f.ravel())) # normalize
      return f
    else:
      pass #TODO: put an error statement here
  """ This one uses the Ratslam C++ gaussian formulas, which are not technically correct
  # builds a 3D difference of gaussians filter kernel with lengths of 'dim'
  def diff_gaussian( self, dim_e, dim_i, sigma_e, sigma_i, order=3 ):
    dim = max(dim_e, dim_i)
    if order==3:
      f = zeros( ( dim, dim, dim ) )
      center = math.floor( dim / 2 )
      for x in xrange( dim ):
        for y in xrange( dim ):
          for z in xrange( dim ):
            f[x,y,z] = ( 1 if max(x,y,z) <= center + dim_e and min(x,y,z) >= center - dim_e else 0 ) * \
                1.0 / (sigma_e*math.sqrt(2*pi)) * \
                math.exp( (-(x-center)**2 - (y-center)**2 - (z-center)**2 ) / (2*sigma_e**2)) - \
                ( 1 if max(x,y,z) <= center + dim_i and min(x,y,z) >= center - dim_i else 0 ) * \
                1.0 / (sigma_i*math.sqrt(2*pi)) * \
                math.exp( (-(x-center)**2 - (y-center)**2 - (z-center)**2 ) / (2*sigma_i**2))

      f /= abs(sum(f.ravel())) # normalize
      return f
    elif order==2:
      f = zeros( ( dim, dim ) )
      center = math.floor( dim / 2 )
      for x in xrange( dim ):
        for y in xrange( dim ):
          f[x,y] = ( 1 if max(x,y) <= center + dim_e and min(x,y) >= center - dim_e else 0 ) * \
              1.0 / (sigma_e*math.sqrt(2*pi)) * \
              math.exp( (-(x-center)**2 - (y-center)**2 ) / (2*sigma_e**2)) - \
              ( 1 if max(x,y) <= center + dim_i and min(x,y) >= center - dim_i else 0 ) * \
              1.0 / (sigma_i*math.sqrt(2*pi)) * \
              math.exp( (-(x-center)**2 - (y-center)**2 ) / (2*sigma_i**2))

      f /= abs(sum(f.ravel())) # normalize
      return f
    elif order==1:
      f = zeros( ( dim ) )
      center = math.floor( dim / 2 )
      for x in xrange( dim ):
        f[x] = ( 1 if x <= center + dim_e and x >= center - dim_e else 0 ) * \
            1.0 / (sigma_e*math.sqrt(2*pi)) * \
            math.exp( -(x-center)**2  / (2*sigma_e**2)) - \
            ( 1 if x <= center + dim_i and x >= center - dim_i else 0 ) * \
            1.0 / (sigma_i*math.sqrt(2*pi)) * \
            math.exp( -(x-center)**2  / (2*sigma_i**2))

      f /= abs(sum(f.ravel())) # normalize
      return f
    else:
      pass #TODO: put an error statement here
  """
  # FIXME: this doesn't actually work at all, because DoG filters are not separable
  # builds a 1D difference of gaussians filter kernel that can be used successively to create a 3D kernel
  def diff_gaussian_separable( self, dim_e, dim_i, sigma_e, sigma_i ):
    dim = max(dim_e, dim_i)
    f = empty( ( dim ) )
    center = math.floor( dim / 2 )
    for x in xrange( dim ):
      f[x] = ( 1 if x <= center + dim_e and x >= center - dim_e else 0 ) * \
          1.0 / (sigma_e*math.sqrt(2*pi)) * \
          math.exp( -(x-center)**2  / (2*sigma_e**2)) - \
          ( 1 if x <= center + dim_i and x >= center - dim_i else 0 ) * \
          1.0 / (sigma_i*math.sqrt(2*pi)) * \
          math.exp( -(x-center)**2  / (2*sigma_i**2))

    f /= abs(sum(f.ravel())) # normalize
    f = cbrt( f ) # Take the cubed root, so the filter applied 3 times will be normalized
    return f

  def diff_gaussian_offset_2d( self, sigma_e, sigma_i, shape=( 7, 7 ), origin=( 0, 0 ) ):
    """Builds a 2D difference of gaussian kernel centered at the origin given"""
    f = empty( shape )
    x, y = meshgrid( arange( shape[0] ) - origin[0], arange( shape[1] ) - origin[1] )
    center = ( math.floor( shape[0] / 2 ), math.floor( shape[1] / 2 ) )
    f = 1.0 / ( 2* sigma_e**2 * pi ) * \
        exp( (-( x - center[0])**2 - (y - center[1])**2 ) / (2*sigma_e**2)) - \
        1.0 / ( 2 * sigma_i**2 * pi ) * \
        exp( (-( x - center[0])**2 - (y - center[1])**2 ) / (2*sigma_i**2))
    f /= abs(sum(f.ravel())) # normalize
    #f = square( cbrt( f ) ) # The result of this filter and a 1D filter should be normalized
    f = cbrt( f ) # TEMP
    return f

  def diff_gaussian_offset_1d( self, sigma_e, sigma_i, size=7, origin=0 ):
    """Builds a 1D difference of gaussian kernel centered at the origin given"""
    f = empty( size )
    x = arange( size ) - origin
    center = math.floor( size / 2 )
    f = 1.0 / (sigma_e*math.sqrt(2*pi)) * \
        exp( -square(x-center)  / (2*sigma_e**2)) - \
        1.0 / (sigma_i*math.sqrt(2*pi)) * \
        exp( -square(x-center)  / (2*sigma_i**2))
    f /= abs(sum(f.ravel())) # normalize
    f = cbrt( f ) # The result of this filter and a 2D filter should be normalized
    return f

  def filters_from_origins( self, origins, shape=( 7, 7 ) ):
    num = origins.shape[1]
    filters = empty( ( shape[0], shape[1], num ) )
    for z in xrange(num):
      filters[:,:,z] = self.diff_gaussian_offset_2d( PC_E_SIGMA, PC_I_SIGMA, shape=shape, origin=origins[:,z] )
    return filters

  def filters_from_origins_approx( self, origins, shape=( 7, 7 ) ):
    num = origins.shape[1]
    filters = empty( ( shape[0], shape[1], num ) )
    prec = self.filter_dict_2d_precision
    for z in xrange(num):
      filters[:,:,z] = self.filter_dict_2d[ ( int( origins[:,z][0] * prec ), int( origins[:,z][0] * prec ) )  ]
    return filters

  def path_integration( self, vtrans, vrot ):
    vtrans /= self.pc_vtrans_scale
    vrot /= self.pc_vrot_scale #TODO ?? is this right? 

    #TODO - this can be optimized better in the future
    mid = math.floor( self.shape[2] / 2 )
    
    #"""
    dir_pc = arange( self.shape[2] ).reshape( (1, self.shape[2] ) )

    origins_exact = concatenate( ( vtrans*cos( (dir_pc - mid)*self.pc_vrot_scale ), 
                                   vtrans*sin( (dir_pc - mid)*self.pc_vrot_scale ) ), axis=0 )
    origins = concatenate( ( around( vtrans*cos( (dir_pc - mid)*self.pc_vrot_scale ) ), 
                             around( vtrans*sin( (dir_pc - mid)*self.pc_vrot_scale ) ) ), axis=0 )
    
    origins_diff = origins_exact - origins
    #filters = self.filters_from_origins( origins_diff )

    # Use a lookup table to get the filter set quickly
    filters = self.filters_from_origins_approx( origins_diff )
    
    self.posecells = self.conv.conv_im( self.posecells, axes=[0,1], radius=ceil( abs( vtrans ) ), 
                                        origins=origins, filters=filters )
    #"""
    """
    for dir_pc in xrange( self.shape[2] ):
      # use a 2D gaussian filter across every theta (direction) layer, with the origin offset based on vtrans and vrot
      origin = ( vtrans*cos( (dir_pc - mid)*self.pc_vrot_scale ), vtrans*sin( (dir_pc - mid)*self.pc_vrot_scale ) )
      #origin = ( vtrans*cos( (dir_pc)*self.pc_vrot_scale ), vtrans*sin( (dir_pc)*self.pc_vrot_scale ) )
      #origin = (4,4)
      ####print origin
      #filter = self.diff_gaussian_offset_2d( PC_E_SIGMA, PC_I_SIGMA, shape=(7,7), origin=origin )
      filter = self.diff_gaussian_offset_2d( PC_E_SIGMA, PC_I_SIGMA, shape=(12,12), origin=origin )
      #filter = self.diff_gaussian_offset_2d( PC_E_SIGMA, PC_I_SIGMA, shape=(7,7), origin=(0,0) )
      #self.conv.new_filter( filter, dim=2 )
      #self.posecells = self.conv.conv_im( self.posecells, axes=[0,1] )
      
      # Using origin shifted filter
      self.posecells[:,:,dir_pc] = \
          ndimage.correlate( self.posecells[:,:,dir_pc], filter, mode='wrap' )
      
      #self.posecells[:,:,dir_pc] = \
      #    ndimage.correlate( self.posecells[:,:,dir_pc], filter, mode='wrap', origin=origin )
      
      #self.posecells[:,:,dir_pc] = \
      #    ndimage.correlate( self.posecells[:,:,dir_pc], self.kernel_2d, mode='wrap', origin=origin )
    """
    # Remove any negative values
    self.posecells[self.posecells < 0] = 0
    
    # and then use a 1D gaussian across the theta layers
    #TODO - this can be optimized better in the future
    origin = math.floor(vrot+.5)
    #for x in xrange( self.shape[0] ):
    #  for y in xrange( self.shape[1] ):
    #    self.posecells[x,y,:] = ndimage.correlate( self.posecells[x,y,:], self.kernel_1d, mode='wrap', origin=origin )
    filter = self.diff_gaussian_offset_1d( PC_E_SIGMA, PC_I_SIGMA, size=7, origin=origin )
    self.conv.new_filter( filter, dim=1 )
    self.posecells = self.conv.conv_im( self.posecells, axes=[2] )
    #self.posecells = ndimage.correlate1d(input=self.posecells, weights=filter.tolist(), axis=2, mode='wrap')
   
    # Remove any negative values
    self.posecells[self.posecells < 0] = 0
    
  # Not entirely sure what this should do yet ##???????????????????
  def get_pc_max( self ):
    (x,y,th) = unravel_index(self.posecells.argmax(), self.posecells.shape)
    return (x,y,th)
    #pass # TODO - just copy it from ratslam-python for now

  def inject( self, energy, loc ): # loc is of the form [ x, y, z ]

    self.posecells[ loc ] += energy

  def update( self, v=(0.0, 0.0) ):

    vtrans = v[0]
    vrot = v[1]

    # 1. Internal X-Y Layer Update
    # 2. Inter-Layer Update

    #input and output the same might not work
    #self.posecells = ndimage.correlate(self.posecells, self.kernel_3d, mode='wrap')
    self.posecells = self.conv.conv_im( self.posecells )
    
    # 3. Global Inhibition
    self.posecells[self.posecells < self.global_inhibition] = 0
    self.posecells[self.posecells >= self.global_inhibition] -= self.global_inhibition

    # 4. Normalization
    total = sum(self.posecells.ravel())
    if total != 0:
      self.posecells /= total
    
    # Path Integration
    self.path_integration( vtrans, vrot )
    
    # get the maximum pose cell
    self.max_pc = self.get_pc_max()

    return self.max_pc
Exemple #25
0
 def __init__(self):
   self.kernels = DifferenceOfGaussians()
   self.correlations = Correlation(self.kernels.full_kernels)
   self.convolver = Convolution()
   self.MIN_IMG_WIDTH = 256