感知哈希算法

感知算法（Preceptatual hash algorithm） ，它的作用是对每一张图生成一个64位哈希值，之后比较不同图片的哈希值，结果越接近，说明图片越相似。

下面是简单的实现：

第一步：缩小尺寸。

将图片缩小到8x8的尺寸，总共64个像素，这一步的作用是去除图片的细节，仅仅保留结构等基本信息，忽略不同尺寸、比例带来的图片差异

第二步：简化色彩，进行灰度处理

将缩小的图片，转换成64级灰度，也就是说，所有的像素点总共只有64中颜色

第三步：计算平均值

计算所有64个像素的灰度平均值

第四步：比较像素灰度

将每个像素的灰度，与平均值进行比较，大于或者等于平均值，即为1，小于平均值为0

第五步：计算哈希值

将上一步的比较结果，组合在一起，就构成了一个64位的整数，组合顺序不重要，只要保证所有的图片都是采用同样的次序就行。

from PIL import Image
import copy
from Object import Object


class PHA(Object):
    """
    1:缩小尺寸
    2：简化色彩
    3：计算平均值
    4：比较像素灰度
    """
    def __init__(self, Item = None):
        self.m_pic_data = None
        self.m_pic_path_name = None#str
        self.m_gray_mean = None#int
        self.m_gray_mean_L = None
        self.m_img_array = None#图片色素
        self.m_str = None   #str
        self.m_Item = Item

    def get_gray_mean_L(self):
        return self.m_gray_mean_L
    
    def get_str(self):
        return self.m_str
    
    #对路径文件进行组合
    def consist_path_and_file(self):
        if self.m_Item == None:
            return None
        filepicture = str(self.m_Item) + '.jpg'
        if len(filepath) is 0:
            print "filepath is error "
            return None
        TmpStr = copy.deepcopy(filepath)
        TmpStr += filepicture
        self.m_pic_path_name = TmpStr
        
            
    #读取文件进行缩小尺寸
    def read_picture(self):
        #对文件和路径进行组合
        self.consist_path_and_file()
        try:
            Image_Fp = Image.open(self.m_pic_path_name)
        except IOError:
            print "%s is not exist", self.m_pic_path_name
            exit()
        self.m_pic_data = Image_Fp.resize((8,8)) 
        return  self.m_pic_data 
    
    #简化色彩
    def color_simplify(self):
        self.m_pic_data.convert('L')

    def mean(self, mean_g = True):
        size_x,size_y = self.m_pic_data.size
        mean_x = 0
        mean_y = 0
        mean_z = 0
        for x in range(size_x):
            for y in range(size_y):
                mean_x += self.m_img_array[x,y][0]
                mean_y += self.m_img_array[x,y][1]
                mean_z += self.m_img_array[x,y][2]
        return [mean_x/64, mean_y/64, mean_z/64]
    
    #计算平均值
    def gray_level_mean(self):
        img_array = self.m_pic_data.load()
        self.m_img_array = img_array
        #mean_list = self.mean()    
        self.m_gray_mean_L =  self.mean()
        #转成01字符串
        #self.m_bin_gray_mean_L = [ str for str in bin(self.m_gray_mean).split('0b')[1]]

    #比较像素灰度int gray = 0.3*red + 0.59*green + 0.11*blue
    def com_gray_level(self):
        #计算灰度算法
        L = str()
        size_x,size_y = self.m_pic_data.size
        mean_x = 0
        mean_y = 0
        mean_z = 0
        for x in range(size_x):
            for y in range(size_y):
                if int(self.m_img_array[x,y][0]) < self.m_gray_mean_L[0] or \
                    int(self.m_img_array[x, y][1]) < self.m_gray_mean_L[1] or \
                    int(self.m_img_array[x, y][2]) < self.m_gray_mean_L[2]:
                    L += '0'
                else:
                    L += '1'

        self.m_str = L                                                
    
    def Run(self):
        try:
            self.read_picture()
            self.color_simplify()
            self.gray_level_mean()
            self.com_gray_level()
        except:
            return None
        return True

  #计算哈希值
def count(oneCmd, twoCmd):
    i = 0
    tmp_num = 0
    for str in twoCmd:
        if cmp(str, oneCmd[i]) == 0:
            pass
        else:
            tmp_num +=1
        i += 1
    if  tmp_num > 15:
            #不相同      
        return False
    else:
        return True