强大的openCV能做什么我就不啰嗦,你能想到的一切图像+视频处理.
这里,我们说说openCV的图像相似度对比, 嗯,说好听一点那叫图像识别,但严格讲, 图像识别是在一个图片中进行类聚处理,比如图片人脸识别,眼部识别,但相识度对比是指两个或两个以上的图片进行对比相似度.
先来几张图片
(a.png)image.png (a_cp.png)image.png (t1.png)image.png (t2.png)image.png
其中,a_cp.png 是复制a.png,也就是说是同一个图片, t1.png 与t2.png 看起来相同,但都是通过PIL裁剪的图片,可以认为相似但不相同.

我们先通过下面几个方法判断图片是否相同

operator对图片对象进行对比

operator.eq(a,b) 判断a,b 对象是否相同

  1. import operator
  2. from PIL import Image
  5. a=Image.open("a.png")
  6. a_cp=Image.open("a_cp.png")
  8. t1=Image.open("t1.png")
  9. t2=Image.open("t2.png")
  12. c=operator.eq(a,a_cp)
  13. e=operator.eq(t1,t2)
  14. print(c)
  15. print(e)

打印结果 c为True, e为False

numpy.subtract对图片对象进行对比

  1. import numpy as np
  2. from PIL import Image
  4. a = Image.open("a.png")
  5. a_cp = Image.open("a_cp.png")
  7. t1 = Image.open("t1.png")
  8. t2 = Image.open("t2.png")
  10. difference = np.subtract(a, a_cp)  # 判断imgv 与v 的差值,存在差值,表示不相同
  11. c = not np.any(difference)  # np.any 满足一个1即为真, (图片相同差值为0,np.any为false, not fasle 即为真认为存在相同的图片)
  13. difference = np.subtract(t1, t2)
  14. e = not np.any(difference)
  16. print(c)
  17. print(e)

打印结果 c为True, e为False

hashlib.md5对图片对象进行对比

  1. import hashlib
  3. a = open("a.png","rb")
  4. a_cp = open("a_cp.png",'rb')
  6. t1 = open("t1.png",'rb')
  7. t2 = open("t2.png",'rb')
  9. cmd5=hashlib.md5(a.read()).hexdigest()
  10. ccmd5=hashlib.md5(a_cp.read()).hexdigest()
  12. emd5=hashlib.md5(t1.read()).hexdigest()
  13. eecmd5=hashlib.md5(t2.read()).hexdigest()
  15. print(cmd5)
  16. if cmd5==ccmd5:
  17.     print(True)
  18. else:
  19.     print(False)
  21. print(emd5)
  22. if emd5==eecmd5:
  23.     print(True)
  24. else:
  25.     print(False)

打印文件md5结果:

  1. 928f9df2d83fa5656bbd0f228c8f5f46
  2. True
  3. bff71ccd5d2c85fb0730c2ada678feea
  4. False

由 operator.eq 与 numpy.subtract 和 hashlib.md5 方法发现,这些方法得出的结论,要不相同,要不不相同,世界万物皆如此.
说的好! 你给我的是boolean值,我不要,不要,不……
我们想要的就是得到两个图片的相似值,某些场景,我们需要这样的值, 比如探头监控中的人与真人照片对比,因受到距离, 分辨率,移动速度等影响,相同的人有可能无法准确辨认,在比如,连连看中的小方块,通过PIL裁剪后,相同的图像图片因灰度,尺寸大小不同我们会认为相同的图片以上三个方法就返回False. 因此openCV更适合这种百分比的相似度计算.
之前用过sklearn 的 Linear Regression 做过线性回归的数据预处理计算概率,因数据量小,未做到样本训练,突发奇想,如果openCV能结合sklearn的机器学习,给一堆图片,经过fit样本训练获取图片的各种特征,随便给一张图片,然后便能知道图片来自那个地方,拍摄时间,都有哪些人物…
回来,回来… 我们继续说openCV相识度问题.
一般通过三种哈希算法与灰度直方图算法进行判断

均值哈希算法

  1. #均值哈希算法
  2. def aHash(img):
  3.     #缩放为8*8
  4.     img=cv2.resize(img,(8,8))
  5.     #转换为灰度图
  6.     gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
  7.     #s为像素和初值为0，hash_str为hash值初值为''
  8.     s=0
  9.     hash_str=''
  10.     #遍历累加求像素和
  11.     for i in range(8):
  12.         for j in range(8):
  13.             s=s+gray[i,j]
  14.     #求平均灰度
  15.     avg=s/64
  16.     #灰度大于平均值为1相反为0生成图片的hash值
  17.     for i in range(8):
  18.         for j in range(8):
  19.             if  gray[i,j]>avg:
  20.                 hash_str=hash_str+'1'
  21.             else:
  22.                 hash_str=hash_str+'0'
  23.     return hash_str

差值哈希算法

  1. def dHash(img):
  2.     #缩放8*8
  3.     img=cv2.resize(img,(9,8))
  4.     #转换灰度图
  5.     gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
  6.     hash_str=''
  7.     #每行前一个像素大于后一个像素为1，相反为0，生成哈希
  8.     for i in range(8):
  9.         for j in range(8):
  10.             if   gray[i,j]>gray[i,j+1]:
  11.                 hash_str=hash_str+'1'
  12.             else:
  13.                 hash_str=hash_str+'0'
  14.     return hash_str

感知哈希算法

  1. def pHash(img):
  2.     #缩放32*32
  3.     img = cv2.resize(img, (32, 32))   # , interpolation=cv2.INTER_CUBIC
  5.     # 转换为灰度图
  6.     gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
  7.     # 将灰度图转为浮点型，再进行dct变换
  8.     dct = cv2.dct(np.float32(gray))
  9.     #opencv实现的掩码操作
  10.     dct_roi = dct[0:8, 0:8]
  14.     hash = []
  15.     avreage = np.mean(dct_roi)
  16.     for i in range(dct_roi.shape[0]):
  17.         for j in range(dct_roi.shape[1]):
  18.             if dct_roi[i, j] > avreage:
  19.                 hash.append(1)
  20.             else:
  21.                 hash.append(0)
  22.     return hash

灰度直方图算法

  1. # 计算单通道的直方图的相似值
  2. def calculate(image1, image2):
  3.     hist1 = cv2.calcHist([image1], [0], None, [256], [0.0, 255.0])
  4.     hist2 = cv2.calcHist([image2], [0], None, [256], [0.0, 255.0])
  5.     # 计算直方图的重合度
  6.     degree = 0
  7.     for i in range(len(hist1)):
  8.         if hist1[i] != hist2[i]:
  9.             degree = degree + (1 - abs(hist1[i] - hist2[i]) / max(hist1[i], hist2[i]))
  10.         else:
  11.             degree = degree + 1
  12.     degree = degree / len(hist1)
  13.     return degree

RGB每个通道的直方图计算相似度

  1. def classify_hist_with_split(image1, image2, size=(256, 256)):
  2.     # 将图像resize后，分离为RGB三个通道，再计算每个通道的相似值
  3.     image1 = cv2.resize(image1, size)
  4.     image2 = cv2.resize(image2, size)
  5.     sub_image1 = cv2.split(image1)
  6.     sub_image2 = cv2.split(image2)
  7.     sub_data = 0
  8.     for im1, im2 in zip(sub_image1, sub_image2):
  9.         sub_data += calculate(im1, im2)
  10.     sub_data = sub_data / 3
  11.     return sub_data

啥?
我为什么知道这三个哈希算法和通道直方图计算方法,嗯, 我也是从网上查的.
上素材
(x1y2.png)image.png (x2y4.png)image.png (x2y6.png)image.png (t1.png)image.png (t2.png)image.png (t3.png)image.png

完整代码:

  1. import cv2
  2. import numpy as np
  5. # 均值哈希算法
  6. def aHash(img):
  7.     # 缩放为8*8
  8.     img = cv2.resize(img, (8, 8))
  9.     # 转换为灰度图
  10.     gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
  11.     # s为像素和初值为0，hash_str为hash值初值为''
  12.     s = 0
  13.     hash_str = ''
  14.     # 遍历累加求像素和
  15.     for i in range(8):
  16.         for j in range(8):
  17.             s = s + gray[i, j]
  18.     # 求平均灰度
  19.     avg = s / 64
  20.     # 灰度大于平均值为1相反为0生成图片的hash值
  21.     for i in range(8):
  22.         for j in range(8):
  23.             if gray[i, j] > avg:
  24.                 hash_str = hash_str + '1'
  25.             else:
  26.                 hash_str = hash_str + '0'
  27.     return hash_str
  30. # 差值感知算法
  31. def dHash(img):
  32.     # 缩放8*8
  33.     img = cv2.resize(img, (9, 8))
  34.     # 转换灰度图
  35.     gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
  36.     hash_str = ''
  37.     # 每行前一个像素大于后一个像素为1，相反为0，生成哈希
  38.     for i in range(8):
  39.         for j in range(8):
  40.             if gray[i, j] > gray[i, j + 1]:
  41.                 hash_str = hash_str + '1'
  42.             else:
  43.                 hash_str = hash_str + '0'
  44.     return hash_str
  47. # 感知哈希算法(pHash)
  48. def pHash(img):
  49.     # 缩放32*32
  50.     img = cv2.resize(img, (32, 32))  # , interpolation=cv2.INTER_CUBIC
  52.     # 转换为灰度图
  53.     gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
  54.     # 将灰度图转为浮点型，再进行dct变换
  55.     dct = cv2.dct(np.float32(gray))
  56.     # opencv实现的掩码操作
  57.     dct_roi = dct[0:8, 0:8]
  59.     hash = []
  60.     avreage = np.mean(dct_roi)
  61.     for i in range(dct_roi.shape[0]):
  62.         for j in range(dct_roi.shape[1]):
  63.             if dct_roi[i, j] > avreage:
  64.                 hash.append(1)
  65.             else:
  66.                 hash.append(0)
  67.     return hash
  70. # 通过得到RGB每个通道的直方图来计算相似度
  71. def classify_hist_with_split(image1, image2, size=(256, 256)):
  72.     # 将图像resize后，分离为RGB三个通道，再计算每个通道的相似值
  73.     image1 = cv2.resize(image1, size)
  74.     image2 = cv2.resize(image2, size)
  75.     sub_image1 = cv2.split(image1)
  76.     sub_image2 = cv2.split(image2)
  77.     sub_data = 0
  78.     for im1, im2 in zip(sub_image1, sub_image2):
  79.         sub_data += calculate(im1, im2)
  80.     sub_data = sub_data / 3
  81.     return sub_data
  84. # 计算单通道的直方图的相似值
  85. def calculate(image1, image2):
  86.     hist1 = cv2.calcHist([image1], [0], None, [256], [0.0, 255.0])
  87.     hist2 = cv2.calcHist([image2], [0], None, [256], [0.0, 255.0])
  88.     # 计算直方图的重合度
  89.     degree = 0
  90.     for i in range(len(hist1)):
  91.         if hist1[i] != hist2[i]:
  92.             degree = degree + (1 - abs(hist1[i] - hist2[i]) / max(hist1[i], hist2[i]))
  93.         else:
  94.             degree = degree + 1
  95.     degree = degree / len(hist1)
  96.     return degree
  99. # Hash值对比
  100. def cmpHash(hash1, hash2):
  101.     n = 0
  102.     # hash长度不同则返回-1代表传参出错
  103.     if len(hash1)!=len(hash2):
  104.         return -1
  105.     # 遍历判断
  106.     for i in range(len(hash1)):
  107.         # 不相等则n计数+1，n最终为相似度
  108.         if hash1[i] != hash2[i]:
  109.             n = n + 1
  110.     return n
  113. img1 = cv2.imread('openpic/x1y2.png')  #  11--- 16 ----13 ---- 0.43
  114. img2 = cv2.imread('openpic/x2y4.png')
  116. img1 = cv2.imread('openpic/x3y5.png')  #  10----11 ----8------0.25
  117. img2 = cv2.imread('openpic/x9y1.png')
  119. img1 = cv2.imread('openpic/x1y2.png')  #  6------5 ----2--------0.84
  120. img2 = cv2.imread('openpic/x2y6.png')
  122. img1 = cv2.imread('openpic/t1.png')  #    14------19---10--------0.70
  123. img2 = cv2.imread('openpic/t2.png')
  125. img1 = cv2.imread('openpic/t1.png')  #    39------33---18--------0.58
  126. img2 = cv2.imread('openpic/t3.png')
  128. hash1 = aHash(img1)
  129. hash2 = aHash(img2)
  130. n = cmpHash(hash1, hash2)
  131. print('均值哈希算法相似度：', n)
  133. hash1 = dHash(img1)
  134. hash2 = dHash(img2)
  135. n = cmpHash(hash1, hash2)
  136. print('差值哈希算法相似度：', n)
  138. hash1 = pHash(img1)
  139. hash2 = pHash(img2)
  140. n = cmpHash(hash1, hash2)
  141. print('感知哈希算法相似度：', n)
  143. n = classify_hist_with_split(img1, img2)
  144. print('三直方图算法相似度：', n)

参考:

https://blog.csdn.net/haofan_/article/details/77097473?locationNum=7&fps=1
https://blog.csdn.net/feimengjuan/article/details/51279629
http://www.cnblogs.com/chujian1120/p/5512276.html
https://www.uisdc.com/head-first-histogram-design

https://www.cnblogs.com/dcb3688/p/4610660.html