又是时隔多日了，日子过的有点荒废了，必须在这里找点存在感了，最近为了优化项目中的流程和算法，接触到了哈希算法，这个跟深度学习没什么关系，我用这个仅仅是来判断图片的正反，最后把图片归一化到同一个方向，可能还有更简单的方法，不过，无所谓了，能解决项目上的事情就先分享出来。

所以我们先来看看哈希算法是个什么东西

对我来说哈希算法分为三个：1.均值哈希算法  2.差值哈希算法  3感知哈希算法。我们分别来研究研究。

1.均值哈希算法

算法步骤：

1.读取图像后转换为灰度图

2.resize成8*8大小的图像

3.求这个64个点的均值，也就是说累加起来再除以64

4.再拿这个8*8的举证和这个均值做比较，大于均值的地方为1，小于均值的地方为0

5.得到一个8*8或者说是64个值的0和1的数据，这个数据也就是我们这个图片的哈希编码

2.差值哈希算法

1.读取图像后转换为灰度图

2.resize成9*8大小的图像，需要注意的是这里是9*8

3.每行前一个像素大于后一个像素为1，相反为0，生成哈希，这里也可以看出，为什么要resize成9*8

4.得到一个8*8或者说是64个值的0和1的数据，这个数据也就是我们这个图片的哈希编码

3.感知哈希算法

1.读取图像后转换为灰度图

2.resize成32*32，其实这里也可以resize成32*32，我也是试过128*128，256*256，结果上的差异并不大

3.对这个32*32的图像做一个离散余弦变化，别吃惊，离散余弦变换你要是不知道是什么的话，就当成一个变换函数好了，因为我也暂时还没搞清楚，等我搞清楚了，我再回来更新，哈哈哈

4.离散余弦变换后，我们去这个举证的前8行8列

5.这样我们又得到一个8*8或者说是64个值的0和1的数据，这个数据也就是我们这个图片的哈希编码

然后，我们就可以根据两张图片的哈希编码来判断两张图片的相似度了。判断方法是就是拿哈希编码对应位置比对，不相同就+1，所以如果最后的值越大，就表示两个图片越不相似。

4.实战

我们根据这个，原来进行一个判断图片正反的实例，我们采用感知哈希算法来做。

先说一下这个的逻辑，然后再上代码

逻辑：1.选取文件夹中的一张图作为模板图1，然后将这张图旋转180°，作为模板图2。

           2.计算这两张模板图的哈希编码。

           3.遍历这个文件夹下其他图片，然后计算哈希编码，那计算出来的哈希编码和两张模板图的哈希编码求相似度

           4.这样，我们这个文件夹里的图片就可以分为两个反方向了，上效果图看看

和模板1相似的图片

 和模板2相似的图片

可以看到明显是分出来的。

我们上代代码吧

# -*- coding: utf-8 -*-
# @Time : 2022/7/21 17:01
# @Author : guligedong
# coding: utf-8
 
import operator
import time
 
from PIL import Image
import numpy as np
import cv2
import os
import shutil
 
"""图片处理: 图片截取、图片相似度比对、哈希算法比对"""
 
 
def cmp_pic(pic1, pic2):
    """
    比对图片相似度
    @param pic1:
    @param pic2:
    @return:
    """
 
    a = Image.open(pic1)
    b = Image.open(pic2)
    return operator.eq(a, b)
 
 
def image_interception(image):
    """
    图片截取
    @param image:  目标图片
    @return:
    """
    img = cv2.imread(image)
    print('图片{}高度、宽度、通道数为：{}'.format(image, img.shape))  # (1792, 828, 3) 高度、宽度、通道数
    cropped = img[170:650, 0:900]  # 裁剪坐标为[y0:y1, x0:x1]
    cv2.imwrite(image, cropped)
    return image
 
 
def aHash(img):
    """
    均值哈希算法
    @param img:
    @return:
    """
    # 缩放为8*8
    img = cv2.resize(cv2.imread(img), (8, 8))
    # 转换为灰度图
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    # s为像素和初值为0，hash_str为hash值初值为''
    s = 0
    hash_str = ''
    # 遍历累加求像素和
    for i in range(8):
        for j in range(8):
            s = s + gray[i, j]
    # 求平均灰度
    avg = s / 64
    # 灰度大于平均值为1相反为0生成图片的hash值
    for i in range(8):
        for j in range(8):
            if gray[i, j] > avg:
                hash_str = hash_str + '1'
            else:
                hash_str = hash_str + '0'
    return hash_str
 
 
def dHash(img):
    """
    差值感知算法
    @param img:
    @return:
    """
    # 缩放8*8
    img = cv2.resize(cv2.imread(img), (9, 8))
    # 转换灰度图
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    hash_str = ''
    # 每行前一个像素大于后一个像素为1，相反为0，生成哈希
    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
 
 
def pHash(img,rotate_flag=False):
    """
    感知哈希算法(pHash)
    @param img:
    @return:
    """
    # 缩放32*32
    img = cv2.resize(cv2.imread(img), (265, 256))  # , interpolation=cv2.INTER_CUBIC
    if rotate_flag:
        img = cv2.rotate(img,cv2.ROTATE_180)
    # 转换为灰度图
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    # 将灰度图转为浮点型，再进行dct变换
    dct = cv2.dct(np.float32(gray))
    # opencv实现的掩码操作
    dct_roi = dct[0:8, 0:8]
 
    hash = []
    avreage = np.mean(dct_roi)
    for i in range(dct_roi.shape[0]):
        for j in range(dct_roi.shape[1]):
            if dct_roi[i, j] > avreage:
                hash.append(1)
            else:
                hash.append(0)
    return hash
 
 
def classify_hist_with_split(image1, image2, size=(256, 256)):
    """
    通过得到RGB每个通道的直方图来计算相似度
    @param image1:
    @param image2:
    @param size:
    @return:
    """
    # 将图像resize后，分离为RGB三个通道，再计算每个通道的相似值
    image1 = cv2.resize(cv2.imread(image1), size)
    image2 = cv2.resize(cv2.imread(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
    # print(sub_data)
    return sub_data
 
 
def calculate(image1, image2):
    """
    计算单通道的直方图的相似值
    @param image1:
    @param image2:
    @return:
    """
    hist1 = cv2.calcHist([image1], [0], None, [256], [0.0, 255.0])
    hist2 = cv2.calcHist([image2], [0], None, [256], [0.0, 255.0])
    # 计算直方图的重合度
    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 cmpHash(hash1, hash2):
    """
    Hash值对比
    @param hash1:
    @param hash2:
    @return:
    """
    n = 0
    # hash长度不同则返回-1代表传参出错
    if len(hash1) != len(hash2):
        return -1
    # 遍历判断
    for i in range(len(hash1)):
        # 不相等则n计数+1，n最终为相似度
        if hash1[i] != hash2[i]:
            n = n + 1
    return n
 
 
if __name__ == '__main__':
    base_folder = r'C:\Users\59436\Desktop\0720output\DB30723CAS_Q1_SolderLight\TRAIN'
    img1 = base_folder + '/' + '2022-7-19-14-27-7-284797-DB30723CAS_Q1-SolderLight.jpg'
    output_folder = r'D:\demo'
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
 
    hash_value = pHash(img1)
    hash_value_rotate = pHash(img1,True)
    print(hash_value)
    print(hash_value_rotate)
    for i in os.listdir(base_folder):
        t1 = time.thread_time()
        image2_path = os.path.join(base_folder,i)
        result1 = cmpHash(hash_value,pHash(image2_path))
        result2 = cmpHash(hash_value_rotate, pHash(image2_path))
        t2 = time.thread_time()
        if result1 > result2:
            save_folder = os.path.join(output_folder,'temp2')
            if not os.path.exists(save_folder):
                os.makedirs(save_folder)
            shutil.copy(image2_path,os.path.join(save_folder,i))
        else:
            save_folder = os.path.join(output_folder, 'temp1')
            if not os.path.exists(save_folder):
                os.makedirs(save_folder)
            shutil.copy(image2_path,os.path.join(save_folder,i))

好了不多说了

salute！！！！老规矩上咩咩