コード例 #1
0
 def templateMatching(self, test_image, template_image, \
                      charac_index, elasticity=16):
     test = utils.im2array(test_image)
     template = utils.im2array(template_image)
     Coord = np.array(charac_index)
 
     width = 5
     # creating K from the template image
     A = Coord[:, 0] - width
     B = Coord[:, 0] + width
     C = Coord[:, 1] - width
     D = Coord[:, 1] + width
     
 ##    r, c = Coord.shape
     row, col = test.shape  
     ONE = np.ones(Coord.shape[0])
     ZERO = np.zeros(Coord.shape[0]) 
 
     A = np.maximum(A, ZERO)
     B = np.minimum(B, row * ONE - 1)    
     C = np.maximum(C, ZERO)
     D = np.minimum(D, col * ONE - 1)
 
     NumCharac = Coord.shape[0]
     ABCD = np.array(np.zeros((NumCharac, 4)))
     ABCD[:, 0] = A
     ABCD[:, 1] = B
     ABCD[:, 2] = C
     ABCD[:, 3] = D   
 
     errors = np.zeros(NumCharac) 
     for i in xrange(NumCharac):        
         a, b, c, d = ABCD[i, :]        
         K = template[a:b + 1, c:d + 1]        
         pre_error = 10 ** 6
 
         increment = 2
         for j in xrange(-elasticity, elasticity + increment, increment):
             for k in xrange(-elasticity, elasticity + increment, increment):
 ##                print "i, j, k", i, j, k
                 if a + j >= 0 and b + j + 1 <= row \
                     and c + k >= 0 and d + k + 1 <= col:                                                
                     test_sample = test[a + j:b + j + 1, c + k:d + k + 1]                        
                     errors[i] = norm(test_sample - K, 2)                    
 
                     if pre_error > errors[i]:
                         pre_error = errors[i]
                         newX_index = np.ceil((a + b) / 2 + j)
                         newY_index = np.ceil((c + d) / 2 + k)                        
                         Coord[i, :] = [newX_index, newY_index]
 
         errors[i] = pre_error # for debugging
 
 ##    print "modification toggle"
 ##    print "Errors = ", errors
     error = errors.sum()
 ##    print "Error Sum: ", error
 
     return Coord, error
コード例 #2
0
 def matchingError(self, test_image, template_image, warped_index):
     test = utils.im2array(test_image)
     template = utils.im2array(template_image)
     
     ti = np.transpose(np.nonzero(test)) 
     wi = warped_index
 
     NumPixel = ti.shape[0]
 
     ERROR = np.zeros((NumPixel, 1)) 
     ERROR[:, 0] = test[ti[:, 0], ti[:, 1]] - template[wi[:, 0], wi[:, 1]]
     ERROR **= 2
     Error_matching = np.sqrt(ERROR.sum())
 
     return Error_matching
コード例 #3
0
def LAT(img, threshold=None):
    '''Adaptive thresholding'''
    
    imArray = utils.im2array(img)

    # set default threshold if not specified
    if threshold is None:
        T=imArray.mean()
    else:
        T=threshold

    Tdiff=1
    while(Tdiff):        
        # Segment image into object and background
        G1_mask=np.array(imArray>T, dtype='uint8') # object segments mask
        G2_mask=np.array(imArray<=T, dtype='uint8') # background mask

        G1=G1_mask*imArray # object image pixel
        G2=G2_mask*imArray # background image pixel

        # A new threshold is created using the mean values of the two segments
        Tnew= (G1.mean()+G2.mean())/2
        Tdiff=Tnew-T
        T=Tnew # set the new threshold as threshold
        # iterate until new threshold aproximately matches the old threshold
        if Tdiff<0.0002:
            Tdiff=0

    G1=np.array(imArray>T, dtype='uint8')
    G1*=255
    G, imG1 = utils.formatimage(G1)
    return imG1
コード例 #4
0
def EEIM(TemplateImage, EdgeIntensity, EdgeMap):
    '''
    EEIM is a subfunction for elastic edge intensity matching,
    which returns a matching error.
    '''

    # initialization
    imArray = utils.im2array(TemplateImage)
    #row_size, column_size = imArray.shape
    EdgeMapN = EdgeMap.sum()
    elasticity = 4
    NumCluster = 10

    # K-means Clustering of EdgeIntensity
    EdgeCoord = np.transpose(np.nonzero(EdgeMap > 0))

    [centroid, label] = clusters.kmeans2(EdgeCoord, NumCluster)

    # Partitioning of EdgeIntensity
    Cluster = np.array(np.zeros((label.size, 4)))
    Cluster[:, 0] = label
    Cluster[:, 1:3] = EdgeCoord
    selEI = []
    for i in label:
        row, col = EdgeCoord[i]
        selEI.append(EdgeIntensity[row, col])
    selEI = np.array(selEI)
    Cluster[:, -1] = selEI
コード例 #5
0
def EEIM(TemplateImage, EdgeIntensity, EdgeMap):
    '''
    EEIM is a subfunction for elastic edge intensity matching,
    which returns a matching error.
    '''

    # initialization
    imArray = utils.im2array(TemplateImage)
    #row_size, column_size = imArray.shape
    EdgeMapN = EdgeMap.sum()
    elasticity = 4
    NumCluster = 10    

    # K-means Clustering of EdgeIntensity
    EdgeCoord = np.transpose(np.nonzero(EdgeMap > 0))

    [centroid, label] = clusters.kmeans2(EdgeCoord, NumCluster)    
    
    # Partitioning of EdgeIntensity
    Cluster = np.array(np.zeros((label.size, 4)))
    Cluster[:,0] = label
    Cluster[:,1:3] = EdgeCoord
    selEI = []
    for i in label:
        row,col = EdgeCoord[i]
        selEI.append(EdgeIntensity[row,col])
    selEI = np.array(selEI)
    Cluster[:,-1] = selEI
コード例 #6
0
    def gaborwavelet(self, img):
        '''
        Gabor wavelet (GW) filter
        (Is this working?) 
        '''
        imArray = utils.im2array(img)

        row_size, col_size = imArray.shape
        x = np.array(range(1, row_size + 1), dtype='float')
        x = x.reshape((row_size, 1))
        y = np.array(range(1, col_size + 1), dtype='float')
        y = y.reshape((1, col_size))

        orientations = []
        for i in range(8):
            orientations.append(i * pi / 8)

        w = signal.freqz()  # spatial frequency
        G = np.exp(-(x**2 + y**2) / (2 * imArray.std()**2))
        GList = []  # image edge container for different directions
        for theta in orientations:
            wave_vector = x * np.cos(theta) + y * np.sin(theta)
            G *= np.cos(w * wave_vector) + 1j * np.sin(w * wave_vector)

            # Apply Gabor filter to image
            sigma = convolve.convolve2d(imArray, G)
            GList.append(sigma)
            # Get the imaginary part of GW

        # format the output image
        sigma, output_image = utils.formatimage(sigma)
        return output_image
コード例 #7
0
def LAT(img, threshold=None):
    '''Adaptive thresholding'''

    imArray = utils.im2array(img)

    # set default threshold if not specified
    if threshold is None:
        T = imArray.mean()
    else:
        T = threshold

    Tdiff = 1
    while (Tdiff):
        # Segment image into object and background
        G1_mask = np.array(imArray > T, dtype='uint8')  # object segments mask
        G2_mask = np.array(imArray <= T, dtype='uint8')  # background mask

        G1 = G1_mask * imArray  # object image pixel
        G2 = G2_mask * imArray  # background image pixel

        # A new threshold is created using the mean values of the two segments
        Tnew = (G1.mean() + G2.mean()) / 2
        Tdiff = Tnew - T
        T = Tnew  # set the new threshold as threshold
        # iterate until new threshold aproximately matches the old threshold
        if Tdiff < 0.0002:
            Tdiff = 0

    G1 = np.array(imArray > T, dtype='uint8')
    G1 *= 255
    G, imG1 = utils.formatimage(G1)
    return imG1
コード例 #8
0
ファイル: gaborfilter.py プロジェクト: versae/transfer
 def gaborwavelet(self, img):
     '''
     Gabor wavelet (GW) filter
     (Is this working?) 
     '''
     imArray = utils.im2array(img)
     
     row_size, col_size = imArray.shape
     x = np.array(range(1, row_size + 1), dtype='float')
     x = x.reshape((row_size, 1))
     y = np.array(range(1, col_size + 1), dtype='float')
     y = y.reshape((1, col_size))
 
     orientations = []
     for i in range(8):
         orientations.append(i * pi / 8)
 
     w = signal.freqz()# spatial frequency
     G = np.exp(-(x ** 2 + y ** 2) / (2 * imArray.std()**2))
     GList = [] # image edge container for different directions
     for theta in orientations:
         wave_vector = x * np.cos(theta) + y * np.sin(theta)
         G *= np.cos(w * wave_vector) + 1j * np.sin(w * wave_vector)
     
         # Apply Gabor filter to image    
         sigma = convolve.convolve2d(imArray, G)
         GList.append(sigma)
         # Get the imaginary part of GW
 
     # format the output image    
     sigma, output_image = utils.formatimage(sigma)
     return output_image
コード例 #9
0
def xp01(test_image, db_path, character_index):
    ''' Experiment on ORL facedatabase
    using template matching on the given image
    '''
    
    linedivide = '=' * 50
    print '\n', linedivide
    print "Test image: ", test_image
    testClass = os.path.dirname(test_image)
    testClass = os.path.split(testClass)[-1]    
    
    print "\nPerforming template matching on ORL facedatabase"    

    matching_error = np.zeros(40)
    for i in range(40): # for 40 templates
        template_class = 's' + str(i + 1) # get template class
        template_image = os.path.join(db_path, template_class, '1.pgm')
##        print "\nTemplate: ", template_image
              
        tm  = templateMatching.templateMatching2()        
        AC = tm.templateMatching(test_image, template_image, \
                                         character_index[i])[0]
##        print "warped feature point coordinate is "
##        print AC
##        ErrorSum[i] = error

##            print "\nComputing coeffs"
        test = utils.im2array(test_image)
        test_index = np.transpose(np.nonzero(test))        
        
        A, B = tm.sinusoidalCoeffs(character_index[i], AC)
##        print "A = ", A
##        print "B = ", B

##            print "\nComputing DX"
        DX = tm.sinusoidalWarping(A, B, test_index)
##        print "DX = ", DX
        
        # compute template matching error
        matching_error[i] = tm.matchingError(test_image, template_image, DX)
##        print "With", template_class, "matching error = ", matching_error[i]

##    print "ErrorSum = ", ErrorSum
##    ErrMin = ErrorSum.min()
    error_min = matching_error.min()
    MinErrorClass = np.nonzero(matching_error == error_min)[0][0] + 1
    MinErrorClass = 's' + str(MinErrorClass)

    verdict = "\tIncorrect match."    

    if MinErrorClass == testClass:
        verdict = "\tCorrect match!"        

    linedivide = '-' * 50
    print "\n", linedivide
    print "Match result:", verdict
    print "\nMin Error = ", error_min    
    print "Min Error Class is", MinErrorClass
    print "True Class: ", testClass
コード例 #10
0
def sobel(img, threshold=0, mode=None):
    imArray = utils.im2array(img)    

    Gx=ndimage.sobel(imArray, axis=0) # the horizontal derivative approx.
    Gy=ndimage.sobel(imArray, axis=1) # the vertical derivative approx.
    G_mag = np.sqrt( Gx**2 + Gy**2)    
    G_angle = np.arctan2(Gy, Gx)

    G_mag -= threshold
    
    G_mag, imG_mag = utils.formatimage(G_mag, mode=mode)    
        
    return [G_mag, imG_mag]
コード例 #11
0
def sobel_handson(img):
    imArray = utils.im2array(img)    

    gx = np.array([[1, 0, -1], [2, 0, -2] , [1, 0, -1]], dtype='float')
    gy = gx.transpose()

    Gx = ndimage.convolve(imArray, gx) # the horizontal derivative approx.
    Gy = ndimage.convolve(imArray, gy) # the vertical derivative approx.
    G_mag = np.sqrt(Gx**2 + Gy**2)
    G_angle = np.arctan2(Gy, Gx)

    G_mag, output_image = utils.formatimage(G_mag)
    
    return [output_image]
コード例 #12
0
def EdgeImage(img, threshold=0):
    imArray = utils.im2array(img)
    G_mag, imG_mag = sobels.sobel(img, threshold=threshold)
    row_size, col_size = G_mag.shape
    EdgeMap = np.zeros(imArray.shape)
    
    # thresholding and Edge map
    #EdgeMap = np.array(G_mag > threshold, dtype='uint8')
    for row in xrange(0,row_size-3):
        for col in xrange(0, col_size-3):
            if G_mag[row, col] > threshold:
                EdgeMap[row:row+3, col:col+3] = np.ones((3,3))

    EdgeIntensity = imArray * EdgeMap
    EdgeIntensity, imEdgeIntensity = utils.formatimage(EdgeIntensity)

    return [EdgeIntensity, EdgeMap, imEdgeIntensity]
コード例 #13
0
def EdgeImage(img, threshold=0):
    imArray = utils.im2array(img)
    G_mag, imG_mag = sobels.sobel(img, threshold=threshold)
    row_size, col_size = G_mag.shape
    EdgeMap = np.zeros(imArray.shape)

    # thresholding and Edge map
    #EdgeMap = np.array(G_mag > threshold, dtype='uint8')
    for row in xrange(0, row_size - 3):
        for col in xrange(0, col_size - 3):
            if G_mag[row, col] > threshold:
                EdgeMap[row:row + 3, col:col + 3] = np.ones((3, 3))

    EdgeIntensity = imArray * EdgeMap
    EdgeIntensity, imEdgeIntensity = utils.formatimage(EdgeIntensity)

    return [EdgeIntensity, EdgeMap, imEdgeIntensity]
コード例 #14
0
def sobelLAT(img):
    '''
    Edge extraction of image using 4-directional
    Sobel edge operators with LAT
    '''    
    imArray = utils.im2array(img)
    
    # low pass filtering of input image
    LowPassFilter=np.array([[1., 2., 1.],[2., 4., 2.],[1., 2., 1.]])
    LowPassFilter /= 16
    imArray_lowpass=ndimage.convolve(imArray, LowPassFilter)

    # sobel edge operators
    z0=np.array([[1., 2., 1.], [0., 0., 0.], [-1., -2., -1]])
    z1=np.array([[2., 1., 0.], [1., 0., -1.], [0., -1., -2.]])
    z2=np.array([[1., 0., -1.], [2., 0., -2.], [1., 0., -1.]])
    z3=np.array([[0., -1., -2.], [1., 0., -1.], [2., 1., 0.]])
    SobelEdgeList=[z0, z1, z2, z3]

    G=np.array(np.zeros(imArray.shape))
    for zk in SobelEdgeList:
        Gx = ndimage.convolve(imArray, zk)
        Gy = ndimage.convolve(imArray, zk.transpose())
        Gnew = np.sqrt( Gx**2 + Gy**2 )
        # keeping max values
        left_mask = np.array( Gnew >= G, dtype='uint8')
        right_mask = np.array( left_mask==0, dtype='uint8')
        G = Gnew * left_mask + G * right_mask 

    LAT = G/imArray_lowpass
    
    LAT, imLAT = utils.formatimage(LAT, dtype='uint8')  # format image as uint8
    
    binary_edge_map=np.array(LAT>1, dtype='uint8')    
    binary_edge_map *= 255 # grayscaling
    binary_edge_map, imOutput = utils.formatimage(binary_edge_map)

    return [binary_edge_map, imOutput]
コード例 #15
0
def wtHighFreq(img, mode='haar', level=1):
    '''
    Apply Wavelet Transform to an image
    Author: Lee Seongjoo [email protected]
    2009 (c) Lee Seongjoo
    '''
    imArray = utils.im2array(img)

    # compute coefficients of multiresolution WT
    coeffs = pywt.wavedec2(imArray, mode, level=level)

    # high frequency coeffs
    coeffs_H = list(coeffs)
    # discarding the low frequency
    # Approximation coeffs are from the low-pass filter
    coeffs_H[0] = np.zeros(coeffs_H[0].shape)

    # multilevel reconstruction
    imArray_H = pywt.waverec2(coeffs_H, mode)

    #Compute binarization of image
    HA = imArray_H.mean()  # mean value of high frequency part imArray_H
    SBEI = np.array(imArray_H < HA + 5, dtype='uint8')  # binarized image

    #msg='Multiresolution Wavelet Transform level: '+ str(level)
    #print msg
    #print "execution took", t_end-t0, "seconds"

    # converting resulting ndarray into an image
    imArray_H, image_wavetransformed = utils.formatimage(imArray_H)

    SBEI *= 255  # SBEI to grayscale
    SBEI, image_binarized = utils.formatimage(SBEI)

    imgData = [SBEI, image_wavetransformed, image_binarized]

    return imgData
コード例 #16
0
def wtHighFreq(img, mode='haar', level=1):
    '''
    Apply Wavelet Transform to an image
    Author: Lee Seongjoo [email protected]
    2009 (c) Lee Seongjoo
    '''    
    imArray = utils.im2array(img)   
    
    # compute coefficients of multiresolution WT
    coeffs=pywt.wavedec2(imArray, mode, level=level)

    # high frequency coeffs
    coeffs_H=list(coeffs)
    # discarding the low frequency
    # Approximation coeffs are from the low-pass filter
    coeffs_H[0]=np.zeros(coeffs_H[0].shape) 

    # multilevel reconstruction
    imArray_H=pywt.waverec2(coeffs_H, mode)
    
    #Compute binarization of image
    HA=imArray_H.mean() # mean value of high frequency part imArray_H
    SBEI=np.array(imArray_H<HA+5, dtype='uint8') # binarized image
           
    #msg='Multiresolution Wavelet Transform level: '+ str(level)
    #print msg
    #print "execution took", t_end-t0, "seconds"

    # converting resulting ndarray into an image
    imArray_H, image_wavetransformed = utils.formatimage(imArray_H)
    
    SBEI *= 255 # SBEI to grayscale
    SBEI, image_binarized = utils.formatimage(SBEI) 
    
    imgData=[SBEI,image_wavetransformed, image_binarized]
    
    return imgData
コード例 #17
0
def xp01(test_image, db_path, character_index):
    ''' Experiment on ORL facedatabase
    using template matching on the given image
    '''

    linedivide = '=' * 50
    print '\n', linedivide
    print "Test image: ", test_image
    testClass = os.path.dirname(test_image)
    testClass = os.path.split(testClass)[-1]

    print "\nPerforming template matching on ORL facedatabase"

    matching_error = np.zeros(40)
    for i in range(40):  # for 40 templates
        template_class = 's' + str(i + 1)  # get template class
        template_image = os.path.join(db_path, template_class, '1.pgm')
        ##        print "\nTemplate: ", template_image

        tm = templateMatching.templateMatching2()
        AC = tm.templateMatching(test_image, template_image, \
                                         character_index[i])[0]
        ##        print "warped feature point coordinate is "
        ##        print AC
        ##        ErrorSum[i] = error

        ##            print "\nComputing coeffs"
        test = utils.im2array(test_image)
        test_index = np.transpose(np.nonzero(test))

        A, B = tm.sinusoidalCoeffs(character_index[i], AC)
        ##        print "A = ", A
        ##        print "B = ", B

        ##            print "\nComputing DX"
        DX = tm.sinusoidalWarping(A, B, test_index)
        ##        print "DX = ", DX

        # compute template matching error
        matching_error[i] = tm.matchingError(test_image, template_image, DX)


##        print "With", template_class, "matching error = ", matching_error[i]

##    print "ErrorSum = ", ErrorSum
##    ErrMin = ErrorSum.min()
    error_min = matching_error.min()
    MinErrorClass = np.nonzero(matching_error == error_min)[0][0] + 1
    MinErrorClass = 's' + str(MinErrorClass)

    verdict = "\tIncorrect match."

    if MinErrorClass == testClass:
        verdict = "\tCorrect match!"

    linedivide = '-' * 50
    print "\n", linedivide
    print "Match result:", verdict
    print "\nMin Error = ", error_min
    print "Min Error Class is", MinErrorClass
    print "True Class: ", testClass
コード例 #18
0
ファイル: gaborfilter.py プロジェクト: versae/transfer
 def __init__(self, image):
     '''
     Constructor
     '''
     self.image = utils.im2array(image) 
コード例 #19
0
 def __init__(self, image):
     '''
     Constructor
     '''
     self.image = utils.im2array(image)