[哈希算法]----判断图片正反

最新推荐文章于 2024-06-04 22:50:27 发布

咕里个咚

最新推荐文章于 2024-06-04 22:50:27 发布

阅读量1k

点赞数

文章标签：哈希算法算法

本文链接：https://blog.csdn.net/guligedong/article/details/126017788

版权

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

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

对我来说哈希算法分为三个：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！！！！老规矩上咩咩

咕里个咚

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
[哈希算法]----判断图片正反

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

扫一扫