深入学习图像处理——图像相似度算法

from PIL import Image

#  load a color image
im = Image.open(‘durant.jpg‘ )

#  convert to grey level image
Lim = im.convert(‘L‘ )
Lim.save(‘grey.jpg‘ )

#  setup a converting table with constant threshold
threshold = 185
table = []
for i in range(256):
    if i < threshold:
        table.append(0)
    else:
        table.append(1)

# convert to binary image by the table
bim = Lim.point(table, ‘1‘ )

bim.save(‘durant_grey.jpg‘ )

    模式‘1’为二值图像，非黑即白。但是它每个像素用8个bit表示，
0表示黑，255表示白。

    模式‘L’为灰色图像它的每个像素用8个bit表示，0表示黑，
255表示白，其他数字表示不同的灰度。在PIL中，从模式“RGB”转
换为“L”模式是按照下面的公式转换的：
    L = R * 299/1000 + G * 587/1000+ B * 114/1000

    模式“P”为8位彩色图像，它的每个像素用8个bit表示，其对应的
彩色值是按照调色板查询出来的。

    模式“RGBA”为32位彩色图像，它的每个像素用32个bit表示，其
中24bit表示红色、绿色和蓝色三个通道，另外8bit表示alpha通道，
即透明通道。

    模式“CMYK”为32位彩色图像，它的每个像素用32个bit表示。模
式“CMYK”就是印刷四分色模式，它是彩色印刷时采用的一种套色模
式，利用色料的三原色混色原理，加上黑色油墨，共计四种颜色混合
叠加，形成所谓“全彩印刷”。

    模式“YCbCr”为24位彩色图像，它的每个像素用24个bit表示。
YCbCr其中Y是指亮度分量，Cb指蓝色色度分量，而Cr指红色色度分
量。人的肉眼对视频的Y分量更敏感，因此在通过对色度分量进行子
采样来减少色度分量后，肉眼将察觉不到的图像质量的变化。

    模式“RGB”转换为“YCbCr”的公式如下：
        Y= 0.257R+0.504G+0.098B+16
        Cb = -0.148R-0.291G+0.439B+128
        Cr = 0.439R-0.368G-0.071*B+128

    模式“I”为32位整型灰色图像，它的每个像素用32个bit表示，0表示黑，
255表示白，(0,255)之间的数字表示不同的灰度。在PIL中，从模式“RGB”
转换为“I”模式是按照下面的公式转换的：
    I = R * 299/1000 + G * 587/1000 + B * 114/1000

    模式“F”为32位浮点灰色图像，它的每个像素用32个bit表示，0表示黑，
255表示白，(0,255)之间的数字表示不同的灰度。在PIL中，从模式“RGB”转
换为“F”模式是按照下面的公式转换的：
    F = R * 299/1000+ G * 587/1000 + B * 114/1000    

from PIL import Image
from PIL import ImageEnhance
# 原始图像
image = Image.open(‘deal_with/A1.jpg‘)
image.show()

#亮度增强
enh_bri = ImageEnhance.Brightness(image)
brightness = 1.5
image_brightened = enh_bri.enhance(brightness)
image_brightened.show()
image_brightened.save("image_brightened.jpg")

#色度增强
enh_col = ImageEnhance.Color(image)
color = 1.5
image_colored = enh_col.enhance(color)
image_colored.show()
image_colored.save("image_colored.jpg")

#对比度增强
enh_con = ImageEnhance.Contrast(image)
contrast = 1.5
image_contrasted = enh_con.enhance(contrast)
image_contrasted.show()
image_contrasted.save("image_contrasted.jpg")

#锐度增强
enh_sha = ImageEnhance.Sharpness(image)
sharpness = 3.0
image_sharped = enh_sha.enhance(sharpness)
image_sharped.show()
image_sharped.save("image_sharped.jpg")

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("james.jpg")
diff1=getdiff(img1)
print(‘img1:‘,getss(diff1))

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

ss1=getss(diff1)
ss2=getss(diff11)
print("两张照片的方差为：%s"%(abs(ss1-ss2)))

x=range(30)

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


cv2.waitKey(0)
cv2.destroyAllWindows()

img1: 357.03162469135805
img11: 202.56193703703704
两张照片的方差为：154.469687654321

    此算法参考博客：http://www.ruanyifeng.com/blog/2011/07
    /principle_of_similar_image_search.html
    
但是未实现代码，代码如下：

#!/usr/bin/python

import glob
import os
import sys

from PIL import Image

EXTS = ‘jpg‘, ‘jpeg‘, ‘JPG‘, ‘JPEG‘, ‘gif‘, ‘GIF‘, ‘png‘, ‘PNG‘

def avhash(im):
    if not isinstance(im, Image.Image):
        im = Image.open(im)
    im = im.resize((8, 8), Image.ANTIALIAS).convert(‘L‘)
    avg = reduce(lambda x, y: x + y, im.getdata()) / 64.
    return reduce(lambda x, (y, z): x | (z << y),
                  enumerate(map(lambda i: 0 if i < avg else 1, im.getdata())),
                  0)

def hamming(h1, h2):
    h, d = 0, h1 ^ h2
    while d:
        h += 1
        d &= d - 1
    return h

if __name__ == ‘__main__‘:
    if len(sys.argv) <= 1 or len(sys.argv) > 3:
        print "Usage: %s image.jpg [dir]" % sys.argv[0]
    else:
        im, wd = sys.argv[1], ‘.‘ if len(sys.argv) < 3 else sys.argv[2]
        h = avhash(im)

        os.chdir(wd)
        images = []
        for ext in EXTS:
            images.extend(glob.glob(‘*.%s‘ % ext))

        seq = []
        prog = int(len(images) > 50 and sys.stdout.isatty())
        for f in images:
            seq.append((f, hamming(avhash(f), h)))
            if prog:
                perc = 100. * prog / len(images)
                x = int(2 * perc / 5)
                print ‘\rCalculating... [‘ + ‘#‘ * x + ‘ ‘ * (40 - x) + ‘]‘,
                print ‘%.2f%%‘ % perc, ‘(%d/%d)‘ % (prog, len(images)),
                sys.stdout.flush()
                prog += 1

        if prog: print
        for f, ham in sorted(seq, key=lambda i: i[1]):
            print "%d\t%s" % (ham, f)

def waitKey(delay=None): # real signature unknown; restored from __doc__
    """
    waitKey([, delay]) -> retval
    .   @brief Waits for a pressed key.
    .   
    .   The function waitKey waits for a key event infinitely (when \f$\texttt{delay}\leq 0\f$ ) or for delay
    .   milliseconds, when it is positive. Since the OS has a minimum time between switching threads, the
    .   function will not wait exactly delay ms, it will wait at least delay ms, depending on what else is
    .   running on your computer at that time. It returns the code of the pressed key or -1 if no key was
    .   pressed before the specified time had elapsed.
    .   
    .   @note
    .   
    .   This function is the only method in HighGUI that can fetch and handle events, so it needs to be
    .   called periodically for normal event processing unless HighGUI is used within an environment that
    .   takes care of event processing.
    .   
    .   @note
    .   
    .   The function only works if there is at least one HighGUI window created and the window is active.
    .   If there are several HighGUI windows, any of them can be active.
    .   
    .   @param delay Delay in milliseconds. 0 is the special value that means "forever".
    """
    pass

1，斜坡面上，一阶微分一直不为0 ；二阶微分只有终点和起点不为0

2，一阶微分产生较粗的边缘，二阶微分则细得多

3，一阶微分处理一般对灰度阶梯有较强的响应；二阶微分处理细节有较强的响应

 cp36代表着匹配python3.6版本。

win32、amd64代表着32位、64位系统。