python+opencv图像处理（一）

import cv2
import numpy as np
from matplotlib import pyplot

#最简单的以huidu直方图作为相似比较的实现
def classify_gray_hist(image1,image2,size = (256,256)):
    #先调整大小
    image1 = cv2.resize(image1,size)
    image2 = cv2.resize(image2,size)
    hist1 = cv2.calcHist([image1],[0],None,[256],[0.0,255.0])
    hist2 = cv2.calcHist([image2],[0],None,[256],[0.0,255.0])
    #比较直方图
    pyplot.plot(range(256),hist1,‘r‘)
    pyplot.plot(range(256),hist2,‘y‘)
    pyplot.show()
    #计算直方图的重合度
    degree = 0
    for i in range(len(hist1)):
        if hist1[i] != hist2[i]:
            degree = degree + (1-(abs(hist1[i]-hist2[i])/max(hist1[i],hist2[i])))
        else:
            degree = degree + 1
    degree = degree/len(hist1)
    return degree

def classify_hist_with_split(image1,image2,size = (256,256)):
    #将图像resize后，分类为三个通道，再计算每个通道的相似值
    image1 = cv2.resize(image1,size)
    image2 = cv2.resize(image2,size)
    sub_image1 = cv2.split(image1)
    sub_image2 = cv2.split(image2)
    sub_data = 0
    for im1,im2 in zip(sub_image1,sub_image2):
        sub_data += calculate(im1,im2)
    sub_data = sub_data/3
    return sub_data

def calculate(im1,im2):
    hist1 = cv2.calcHist([im1],[0],None,[256],[0.0,255.0])
    hist2 = cv2.calcHist([im2],[0],None,[256],[0.0,255.0])
    pyplot.plot(range(256),hist1,‘r‘)
    pyplot.plot(range(256),hist2,‘y‘)
    pyplot.show()
    degree = 0
    for i in range(len(hist1)):
        if hist1[i] != hist2[i]:
            degree = degree + (1 - (abs(hist1[i] - hist2[i]) / max(hist1[i], hist2[i])))
        else:
            degree = degree + 1
    degree = degree / len(hist1)
    return degree

# 平均哈希算法计算
def classify_aHash(image1,image2):
    image1 = cv2.resize(image1,(8,8))
    image2 = cv2.resize(image2,(8,8))
    gray1 = cv2.cvtColor(image1,cv2.COLOR_BGR2GRAY)  #切换至灰度图
    gray2 = cv2.cvtColor(image2,cv2.COLOR_BGR2GRAY)
    hash1 = getHash(gray1)
    hash2 = getHash(gray2)
    return Hamming_distance(hash1,hash2)

def classify_pHash(image1,image2):
    image1 = cv2.resize(image1,(32,32))
    image2 = cv2.resize(image2,(32,32))
    gray1 = cv2.cvtColor(image1,cv2.COLOR_BGR2GRAY)   #切换至灰度图
    gray2 = cv2.cvtColor(image2,cv2.COLOR_BGR2GRAY)
    # 将灰度图转为浮点型，再进行dct变换
    dct1 = cv2.dct(np.float32(gray1))
    dct2 = cv2.dct(np.float32(gray2))
    # 取左上角的8*8，这些代表图片的最低频率
    # 这个操作等价于c++中利用opencv实现的掩码操作
    # 在python中进行掩码操作，可以直接这样取出图像矩阵的某一部分
    dct1_roi = dct1[0:8,0:8]
    dct2_roi = dct2[0:8,0:8]
    print(dct1)
    hash1 = getHash(dct1_roi)
    hash2 = getHash(dct2_roi)
    return Hamming_distance(hash1,hash2)


# 输入灰度图，返回hash
def getHash(image):
    avreage = np.mean(image)  #计算像素平均值
    hash = []
    for i in range(image.shape[0]):
        for j in range(image.shape[1]):
            if image[i, j] > avreage:
                hash.append(1)
            else:
                hash.append(0)
    return hash


# 计算汉明距离
def Hamming_distance(hash1, hash2):
    num = 0
    for index in range(len(hash1)):
        if hash1[index] != hash2[index]:
            num += 1
    return num

#差值感知算法
def dhash(image1,image2):
    image1 = cv2.resize(image1,(9,8))
    image2 = cv2.resize(image2,(9,8))
    gray1 = cv2.cvtColor(image1,cv2.COLOR_BGR2GRAY)  #切换至灰度图
    gray2 = cv2.cvtColor(image2,cv2.COLOR_BGR2GRAY)
    hash1 = dhashcaulate(gray1)
    hash2 = dhashcaulate(gray2)
    return Hamming_distance(hash1,hash2)

def dhashcaulate(gray):
    hash_str = ‘‘
    for i in range(8):
        for j in range(8):
            if gray[i, j] > gray[i, j + 1]:
                hash_str = hash_str + ‘1‘
            else:
                hash_str = hash_str + ‘0‘
    return hash_str

if __name__ == ‘__main__‘:
    imgobj1 = cv2.imread(‘one.jpg‘)
    imgobj2 = cv2.imread(‘three.jpg‘)
    cv2.imshow(‘img1‘,imgobj1)
    cv2.imshow(‘img2‘,imgobj2)
    #degree = classify_gray_hist(imgobj1,imgobj2)   #单通道直方图
    #degree = classify_hist_with_split(imgobj1,imgobj2)  #三通道直方图
    #degree = classify_aHash(imgobj1,imgobj2)          #平均哈希法
    #degree = classify_pHash(imgobj1,imgobj2)          #感知哈希法
    degree = dhash(imgobj1,imgobj2)          #差值感知哈希法
    print(degree)
    cv2.waitKey(0)

import cv2
import matplotlib.pyplot as plt

#计算方差
def getss(list):
    #计算平均值
    avg=sum(list)/len(list)
    #定义方差变量ss，初值为0
    ss=0
    #计算方差
    for l in list:
        ss+=(l-avg)*(l-avg)/len(list)
    #返回方差
    return ss

#获取每行像素平均值
def getdiff(img):
    #定义边长
    Sidelength=30
    #缩放图像
    img=cv2.resize(img,(Sidelength,Sidelength),interpolation=cv2.INTER_CUBIC)
    #灰度处理
    gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
    #avglist列表保存每行像素平均值
    avglist=[]
    #计算每行均值，保存到avglist列表
    for i in range(Sidelength):
        avg=sum(gray[i])/len(gray[i])
        avglist.append(avg)
    #返回avglist平均值
    return avglist

#读取测试图片
img1=cv2.imread("one.jpg")
diff1=getdiff(img1)
print(‘img1:‘,getss(diff1))

#读取测试图片
img11=cv2.imread("two.jpg")
diff11=getdiff(img11)
print(‘img11:‘,getss(diff11))


x=range(30)

plt.figure("avg")
plt.plot(x,diff1,marker="*",label="$walk01$")
plt.plot(x,diff11,marker="*",label="$walk03$")
plt.title("avg")
plt.legend()
plt.show()


cv2.waitKey(0)
cv2.destroyAllWindows()