Python计算机视觉编程_02

    #在一幅灰度图像中，计算每一个像素点的Harris角点
    def compute_harris_response(im,sigma=3):
    
    # 计算导数
    imx = zeros(im.shape)
    filters.gaussian_filter(im, (sigma,sigma), (0,1), imx)
    imy = zeros(im.shape)
    filters.gaussian_filter(im, (sigma,sigma), (1,0), imy)
    
        # 可视化原图
    plt.subplot(2, 3, 1)
    plt.title('gray')
    plt.axis('off')
    plt.imshow(img, plt.cm.gray)
    
    # 可视化x方向导数图像
    plt.subplot(2, 3, 2)
    plt.title('Derivative in X direction')
    plt.axis('off')
    plt.imshow(imx, plt.cm.gray)
    
    # 可视化y方向导数图像
    plt.subplot(2, 3, 3)
    plt.title("Derivative in y direction")
    plt.axis('off')
    plt.imshow(imy, plt.cm.gray)
    
    plt.subplot(2, 3, 4)
    plt.title("Second derivative in X direction")
    plt.axis('off')
    plt.imshow(imx * imx, plt.cm.gray)
    
    plt.subplot(2, 3, 5)
    plt.title("Second derivative in X/Y direction")
    plt.axis('off')
    plt.imshow(imx * imy, plt.cm.gray)
    
    plt.subplot(2, 3, 6)
    plt.title("Second derivative in y direction")
    plt.axis('off')
    plt.imshow(imy * imy, plt.cm.gray)
    plt.show()
    
    # 计算Harris矩阵的分量
    Wxx = filters.gaussian_filter(imx*imx,sigma)
    Wxy = filters.gaussian_filter(imx*imy,sigma)
    Wyy = filters.gaussian_filter(imy*imy,sigma)
    
    # 计算特征值和迹
    Wdet = Wxx*Wyy - Wxy**2
    Wtr = Wxx + Wyy
    
    return Wdet / (Wtr*Wtr)
    
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    

    #从一幅Harris响应图像中返回角点。min_dist为分隔角点和图像边界的最少像素数目
    def get_harris_points(harrisim,min_dist=10,threshold=0.1):
    
    # 寻找高于阈值的候选角点
    corner_threshold = harrisim.max() * threshold
    harrisim_t = (harrisim > corner_threshold) 
    
    # 得到候选点的坐标
    coords = array(harrisim_t.nonzero()).T
    
    # 得到候选点的Harris响应值
    candidate_values = [harrisim[c[0],c[1]] for c in coords]
    
    # 对候选点按照Harris响应值进行排序
    index = argsort(candidate_values)
    
    # 将可行点的位置保存到数组中
    allowed_locations = zeros(harrisim.shape)
    allowed_locations[min_dist:-min_dist,min_dist:-min_dist] = 1
    
    # 按照min_distance原则，选择最佳Harris点
    filtered_coords = []
    for i in index:
        if allowed_locations[coords[i,0],coords[i,1]] == 1:
            filtered_coords.append(coords[i])
            allowed_locations[(coords[i,0]-min_dist):(coords[i,0]+min_dist), 
                        (coords[i,1]-min_dist):(coords[i,1]+min_dist)] = 0
    
    return filtered_coords
    
    #绘制图像中检测到的角点
    def plot_harris_points(image,filtered_coords):
    
    figure()
    gray()
    imshow(image)
    plot([p[1] for p in filtered_coords],
                [p[0] for p in filtered_coords],'*')
    axis('off')
    show()
    
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    

    import cv2 as cv
    from cv2 import waitKey
    import numpy as np
    import matplotlib.pyplot as plt
    if __name__ == '__main__':
    box = cv.imread("C:\ Users\ 19835\ Desktop\ opencv\ task2\ task_1.jpg")
    # 压缩图片以便显示
    box=cv.resize(box,(960,540))
    box_in_sence = cv.imread("C:\ Users\ 19835\ Desktop\ opencv\ task2\ task_2.jpg")
    box_in_sence=cv.resize(box_in_sence,(960,540))
    cv.imshow("box", box)
    cv.imshow("box_in_sence", box_in_sence)
    
    # 创建SIFT特征检测器
    sift = cv.SIFT_create()
    
    # 特征点提取与描述子生成
    kp1, des1 = sift.detectAndCompute(box,None)
    kp2, des2 = sift.detectAndCompute(box_in_sence,None)
    
    # 暴力匹配
    bf = cv.DescriptorMatcher_create(cv.DescriptorMatcher_BRUTEFORCE)
    matches = bf.match(des1,des2)
    
    # 绘制最佳匹配
    matches = sorted(matches, key = lambda x:x.distance)
    result = cv.drawMatches(box, kp1, box_in_sence, kp2, matches[:15], None)
    cv.imshow("-match", result)
    cv.waitKey(0)
    cv.destroyAllWindows()
    
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    

    from pylab import *
    from PIL import Image
    from PCV.localdescriptors import sift
    from PCV.tools import imtools
    import pydot
    
    #download_path = "panoimages"  # set this to the path where you downloaded the panoramio images
    #path = "/FULLPATH/panoimages/"  # path to save thumbnails (pydot needs the full system path)
    
    download_path = "C:\ Users\ 19835\ Desktop\ opencv\ task2"  # set this to the path where you downloaded the panoramio images
    path = "C:\ Users\ 19835\ Desktop\ opencv\ task2"  # path to save thumbnails (pydot needs the full system path)
    
    # list of downloaded filenames
    imlist = imtools.get_imlist(download_path)
    nbr_images = len(imlist)
    
    # extract features
    featlist = [imname[:-3] + 'sift' for imname in imlist]
    for i, imname in enumerate(imlist):
    sift.process_image(imname, featlist[i])
    
    matchscores = zeros((nbr_images, nbr_images))
    
    for i in range(nbr_images):
    for j in range(i, nbr_images):  # only compute upper triangle
        print ('comparing ', imlist[i], imlist[j])
        l1, d1 = sift.read_features_from_file(featlist[i])
        l2, d2 = sift.read_features_from_file(featlist[j])
        matches = sift.match_twosided(d1, d2)
        nbr_matches = sum(matches > 0)
        print ('number of matches = ', nbr_matches)
        matchscores[i, j] = nbr_matches
    print ("The match scores is: \n", matchscores)
    
    # copy values
    for i in range(nbr_images):
    for j in range(i + 1, nbr_images):  # no need to copy diagonal
        matchscores[j, i] = matchscores[i, j]
    
    #可视化
    
    threshold = 2  # min number of matches needed to create link
    
    g = pydot.Dot(graph_type='graph')  # don't want the default directed graph
    
    for i in range(nbr_images):
    for j in range(i + 1, nbr_images):
        if matchscores[i, j] > threshold:
            # first image in pair
            im = Image.open(imlist[i])
            im.thumbnail((100, 100))
            filename = path + str(i) + '.png'
            im.save(filename)  # need temporary files of the right size
            g.add_node(pydot.Node(str(i), fontcolor='transparent', shape='rectangle', image=filename))
    
            # second image in pair
            im = Image.open(imlist[j])
            im.thumbnail((100, 100))
            filename = path + str(j) + '.png'
            im.save(filename)  # need temporary files of the right size
            g.add_node(pydot.Node(str(j), fontcolor='transparent', shape='rectangle', image=filename))
    
            g.add_edge(pydot.Edge(str(i), str(j)))
    g.write_png('test.png')