精华内容
下载资源
问答
  • /usr/bin/python # -*- coding: UTF-8 -*- #Less than 10 add to list and sort import glob import os import sys from functools import reduce from PIL import Image EXTS = 'jpg', '...
    #!/usr/bin/python  
    # -*- coding: UTF-8 -*-
    #Less than 10 add to list and sort
    import glob  
    import os  
    import sys  
    from functools import reduce
    from PIL import Image  
      
    EXTS = 'jpg', 'jpeg', 'JPG', 'JPEG', 'gif', 'GIF', 'png' 
      
    def avhash(im):  
        if not isinstance(im, Image.Image):  
            im = Image.open(im)  
        if im.mode=='RGBA':
            im=ConvertRBGA(im)
        im = im.resize((8, 8), Image.ANTIALIAS).convert('L')  
        avg = reduce(lambda x, y: x + y, im.getdata()) / 64.0
        return reduce(lambda x, y_z:  x | (y_z[1] << y_z[0]),  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 
     
    def ConvertRBGA(img):
        x,y = img.size  
        #   # (alpha band as paste mask).    
        p = Image.new('RGBA', img.size, (255,255,255))   
        p.paste(img, (0, 0, x, y),img)   
        return p
    
    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]  
            im, wd = 'gs6.png', '.' 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:  
                result=avhash(f)
                seq.append((f, hamming(result, 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))  

     

    转载于:https://www.cnblogs.com/daxiongblog/p/5718213.html

    展开全文
  • Python-PIL 采用感知哈希算法基于python-PIL的图像去重 简单小代码
  • 感知哈希算法——Python实现

    千次阅读 2017-12-24 20:54:30
    1. 前言现在手中只有一张图像需要在一个集合中去找到与之最相近的那一张,这个过程实际是一个匹配的过程,特别是在多模态医学图像中解决这样的问题是比较迫切的,今年试验了一种广泛使用的算法——感知哈希算法!...

    1. 前言

    现在手中只有一张图像需要在一个集合中去找到与之最相近的那一张,这个过程实际是一个匹配的过程,特别是在多模态医学图像中解决这样的问题是比较迫切的,今年试验了一种广泛使用的算法——感知哈希算法!具体的实验结果将在下文中给出。

    2. 算法原理

    step1:缩小图片尺寸
    将图片缩小到8x8的尺寸, 总共64个像素. 这一步的作用是去除各种图片尺寸和图片比例的差异, 只保留结构、明暗等基本信息。
    这里写图片描述
    step2:转为灰度图片
    将缩小后的图片, 转为64级灰度图片。
    这里写图片描述
    step3:计算灰度平均值
    计算图片中所有像素的灰度平均值
    step4:比较像素的灰度
    将每个像素的灰度与平均值进行比较, 如果大于或等于平均值记为1, 小于平均值记为0。
    step5:计算哈希值
    将上一步的比较结果, 组合在一起, 就构成了一个64位的二进制整数, 这就是这张图片的指纹。
    step6:对比图片指纹
    得到图片的指纹后, 就可以对比不同的图片的指纹, 计算出64位中有多少位是不一样的. 如果不相同的数据位数不超过5, 就说明两张图片很相似, 如果大于10, 说明它们是两张不同的图片。

    3. Python实现

    # -*- coding=utf-8 -*-
    import numpy as np
    from PIL import Image
    import matplotlib.pyplot as plt
    
    
    # extract feature
    # lines: src_img path
    def Extra_Featrue(lines, new_rows=64, new_cols=64):
        for name in lines:
            ori_img = Image.open(name.strip())
            feature_img = ori_img.resize((new_rows, new_cols))
            feature_img = feature_img.convert('L')
            mean_value = np.mean(np.mean(feature_img))
            feature = feature_img >= mean_value
            feature = np.matrix(feature, np.int8)
            if 'features' in locals():
                temp = np.reshape(feature, (1, new_cols * new_rows))
                features = np.vstack([features, temp])
            else:
                features = np.matrix(np.reshape(feature, (1, new_cols * new_rows)))
    
        return features
    
    
    # use MRI image features to find candidate CT images
    def MRIFindCT(mri_feature, mri_lines, ct_feature, ct_lines):
        for i in np.arange(0, np.shape(mri_feature)[0]):
            dist = []
            mri = mri_feature[i, :]
            for j in np.arange(0, np.shape(ct_feature)[0]):
                ct = ct_feature[j, :]
                temp = mri != ct
                sum = np.sum(temp)
                dist.append(sum)
            # find minimum while ignoring the zeros on the diagonal
            index = np.argsort(dist)
            img1_path = mri_lines[i]
            img2_path = ct_lines[index[1]]
            img3_path = ct_lines[index[2]]
            img4_path = ct_lines[index[3]]
            img1 = Image.open(img1_path)
            img2 = Image.open(img2_path)
            img3 = Image.open(img3_path)
            img4 = Image.open(img4_path)
            plt.subplot(2, 2, 1)
            plt.imshow(img1)
            plt.title('MRI Image(%s)' % img1_path[img1_path.__len__() - 10:])
            plt.axis('off')
            plt.xlabel(img1_path[img1_path.__len__() - 10:])
            plt.subplot(2, 2, 2)
            plt.imshow(img2)
            plt.title('Candidate CT Image1(%s)' % img2_path[img2_path.__len__() - 10:])
            plt.axis('off')
            plt.xlabel(img2_path[img2_path.__len__() - 10:])
            plt.subplot(2, 2, 3)
            plt.imshow(img3)
            plt.title('Candidate CT Image2(%s)' % img3_path[img3_path.__len__() - 10:])
            plt.axis('off')
            plt.xlabel(img3_path[img3_path.__len__() - 10:])
            plt.subplot(2, 2, 4)
            plt.imshow(img4)
            plt.title('Candidate CT Image3(%s)' % img4_path[img4_path.__len__() - 10:])
            plt.axis('off')
            plt.xlabel(img4_path[img4_path.__len__() - 10:])
            plt.show()
    
    # set data source
    src_path = './1794-MR/MR.txt'  # *.txt file contain MRI images
    dst_path = './1794-CT/CT.txt'  # *.txt file contain CT images
    mri_lines = [line.strip() for line in open(src_path)]
    ct_lines = [line.strip() for line in open(dst_path)]
    
    # extract feature
    set_size = 8
    mri_feature = Extra_Featrue(mri_lines, set_size, set_size)
    ct_feature = Extra_Featrue(ct_lines, set_size, set_size)
    
    # use feature to find candidate img
    MRIFindCT(mri_feature, mri_lines, ct_feature, ct_lines)

    4. 结果

    上面已经将算法的原理介绍了,很简单实现起来也很容易。这里给出几幅实验的结果作为参考
    case1:
    1
    case2:
    2
    从结果可以看到在一些图片中匹配的效果并不是很好,应该是抽取的特征致使匹配的结果出现偏差

    展开全文
  • 相似图像搜索的哈希算法有三种:(1)均值哈希算法(2)差值哈希算法(3)感知哈希算法我们这里介绍Phash,附录有另外两种的实现。感知哈希算法步骤:1、设置图片大小:一般是32 * 32,一个较好的大小,方便DCT计算;2、...

    相似图像搜索的哈希算法有三种:

    (1)均值哈希算法

    (2)差值哈希算法

    (3)感知哈希算法

    我们这里介绍Phash,附录有另外两种的实现。

    感知哈希算法步骤:

    1、设置图片大小:一般是32 * 32,一个较好的大小,方便DCT计算;

    2、转化为灰度图:把缩放后的图片转化为256阶的灰度图;

    3、计算DCT: DCT把图片分离成分率的集合;

    4、DCT计算后的矩阵是32 * 32,保留左上角的8 * 8,这些代表的图片的最低频率;

    5、计算平均值:计算缩小DCT后的所有像素点的平均值;

    6、计算图片哈希值,大于平均值记录为1,反之记录为0,得到信息指纹,组合64个信息位,顺序随意保持一致性;

    7、最后比对两张图片的指纹,对比汉明距离从而比较图片相似性。

    汉明距离:两个等长距离的字符串的汉明距离为两个字符串对应位置不同字符的个数,比如“100010”和“000001”的汉明距离为3。

    // 感知哈希算法

    import cv2

    import numpy as np

    #定义感知哈希

    def phash(img):

    #step1:调整大小32x32

    img=cv2.resize(img,(32,32))

    img=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

    img=img.astype(np.float32)

    #step2:离散余弦变换

    img=cv2.dct(img)

    img=img[0:8,0:8]

    sum=0.

    hash_str=''

    #step3:计算均值

    # avg = np.sum(img) / 64.0

    for i in range(8):

    for j in range(8):

    sum+=img[i,j]

    avg=sum/64

    #step4:获得哈希

    for i in range(8):

    for j in range(8):

    if img[i,j]>avg:

    hash_str=hash_str+'1'

    else:

    hash_str=hash_str+'0'

    return hash_str

    #计算汉明距离

    def hmdistance(hash1,hash2):

    num=0

    assert len(hash1)==len(hash2)

    for i in range(len(hash1)):

    if hash1[i]!=hash2[i]:

    num+=1

    return num

    if __name__ == '__main__':

    img1=cv2.imread('data/000_0001.png')

    img2=cv2.imread('data/003_0001.png')

    hash1=phash(img1)

    hash2=phash(img2)

    print(hash1)

    print(hash2)

    dist=hmdistance(hash1,hash2)

    print('距离为:',dist)

    原文链接:https://blog.csdn.net/weixin_42872907/article/details/108329795

    站长简介:前每日优鲜python全栈开发工程师,自媒体达人,逗比程序猿,钱少话少特宅,关注我,做朋友, 我们一起谈人生和理想吧!我的公众号:想吃麻辣香锅

    关注公众号回复充值+你的账号,免费为您充值1000积分

    展开全文
  • Python3实现基于PHA实现图像配准
  • 所谓感知哈希算法 它不是很严格的哈希算法 而是相对的hash 本篇介绍的感知哈希算法为:dhash dHash:差异值哈希,基于渐变的hash算法,精确度较高,且速度也比较快(本文没有转换,见代码注释)前提用到了PIL...

    所谓感知哈希算法 它不是很严格的哈希算法
    而是相对的hash
    本篇介绍的感知哈希算法为:dhash
    dHash:差异值哈希,基于渐变的hash算法,精确度较高,且速度也比较快(本文没有转换,见代码注释)

    注:用到了PIL库
    以及汉明距离(传送门


    正文来了

    先贴代码

    # -*- coding:utf-8 -*-
    
    """
    
    用dhash判断是否相同照片
    基于渐变比较的hash
    hash可以省略(本文省略)
    By Guanpx
    
    """
    
    from PIL import Image
    from os import listdir
    
    
    def picPostfix():  # 相册后缀的集合
        postFix = set()
        postFix.update(['bmp', 'jpg', 'png', 'tiff', 'gif', 'pcx', 'tga', 'exif',
                        'fpx', 'svg', 'psd', 'cdr', 'pcd', 'dxf', 'ufo', 'eps', 'JPG', 'raw', 'jpeg'])
        return postFix
    
    
    def getDiff(width, high, image):  # 将要裁剪成w*h的image照片 
        diff = []
        im = image.resize((width, high))
        imgray = im.convert('L')  # 转换为灰度图片 便于处理
        pixels = list(imgray.getdata())  # 得到像素数据 灰度0-255
    
        for row in range(high): # 逐一与它左边的像素点进行比较
            rowStart = row * width  # 起始位置行号
            for index in range(width - 1):
                leftIndex = rowStart + index  
                rightIndex = leftIndex + 1  # 左右位置号
                diff.append(pixels[leftIndex] > pixels[rightIndex])
    
        return diff  #  *得到差异值序列 这里可以转换为hash码*
    
    
    def getHamming(diff=[], diff2=[]):  # 暴力计算两点间汉明距离
        hamming_distance = 0
        for i in range(len(diff)):
            if diff[i] != diff2[i]:
                hamming_distance += 1
    
        return hamming_distance
    
    
    if __name__ == '__main__':
    
        width = 32
        high = 32  # 压缩后的大小
        dirName = ""  # 相册路径
        allDiff = []
        postFix = picPostfix()  #  图片后缀的集合
    
        dirList = listdir(dirName)
        cnt = 0
        for i in dirList:
            cnt += 1
            print cnt  # 可以不打印 表示处理的文件计数
            if str(i).split('.')[-1] in postFix:  # 判断后缀是不是照片格式
                im = Image.open(r'%s\%s' % (dirName, unicode(str(i), "utf-8")))
                diff = getDiff(width, high, im)
                allDiff.append((str(i), diff))
                
        for i in range(len(allDiff)):
            for j in range(i + 1, len(allDiff)):
                if i != j:
                    ans = getHamming(allDiff[i][1], allDiff[j][1])
                    if ans <= 5:  # 判别的汉明距离,自己根据实际情况设置
                        print allDiff[i][0], "and", allDiff[j][0], "maybe same photo..."
    
    

    具体注释见上代码
    1.通过listdir列出目录内文件,通过后缀集合(postFix)进行图片格式检查
    2.每个图片转换为灰度图片并压缩大小 便于处理
    3.得到每个像素的value(0-255)
    4.每一个像素点与它左边的像素点进行比较,得到0或者1
    5.比较结果存入diff后放在allDiff中
    6.暴力比较每两张图片的汉明距离
    7.设定汉明距离的范围 得出重复图片

    GitHub

    展开全文
  • python---感知哈希算法

    千次阅读 2018-11-13 22:55:53
    某些情况下,我们需要检测图片之间的相似性,比较简单、易用的解决方案是采用感知哈希算法 感知哈希算法是一类算法的总称,包括aHash、pHash、dHash。顾名思义,感知哈希不是以严格的方式计算Hash值,而是以更加相对...
  • 感知哈希算法原理与步骤: 1缩小图片:32 * 32是一个较好的大小,这样方便DCT计算 2转化为灰度图:把缩放后的图片转化为256阶的灰度图。(具体算法见平均哈希算法步骤) 3计算DCT:DCT把图片分离成分率的集合 4...
  • 感知哈希算法--python实现

    千次阅读 2016-05-10 21:04:34
    最近在看运动目标跟踪方面的资料,偶然间看到zouxy09大神的一篇《基于感知哈希算法的视觉跟踪》,觉得挺有意思的。于是去查了相关的感知哈希的资料,发现在图片搜索领域里面应用非常广泛,这种技术我觉得有点像模板...
  • 感知哈希算法(pHash算法+python代码实现) pHash算法是计算图片相似度算法的一种,可以用在以图搜图上面,原理也很简单,下面简单罗列一下算法过程: 缩放图片尺寸:缩放到8*8的大小,这里是为了去除图片的细节,...
  • 感知哈希算法步骤: 1、设置图片大小:一般是32 * 32,一个较好的大小,方便DCT计算; 2、转化为灰度图:把缩放后的图片转化为256阶的灰度图; 3、计算DCT: DCT把图片分离成分率的集合; 4、DCT计算后的矩阵是32 * ...
  • 点击查看:Python3.8+Qt5.0感知哈希算法实现图像检索系统 文件大小:13M 操作系统:Windows10旗舰版 开发工具:Python3.8、Qt5 开发语言:.py 简要概述: 基于感知哈希算法实现图像检索 使用 Python3 & Qt5 实现...
  • 相似图片检测:感知哈希算法之dHash的Python实现某些情况下,我们需要检测图片之间的相似性,进行我们需要的处理:删除同一张图片、标记盗版等。如何判断是同一张图片呢?最简单的方法是使用加密哈希(例如MD5, SHA-...
  • Java进阶(五十七)-基于感知哈希算法的pHash图像配准算法  毕业论文提交之后,老师交给自己一项任务:图像配准,也就是给你两幅图像,通过系统来判定两幅图像是否为同一副图像。自己作为这一方面的小白,先去网上...
  • 相似图片检测:感知哈希算法之aHash,dHash,pHash的Python实现  原文:http://blog.sina.com.cn/s/blog_56fd58ab0102xpqf.html 感知哈希算法是一类算法的总称,包括aHash、pHash、dHash。顾名思义,感知哈希不是...
  • 感知哈希算法

    千次阅读 2015-10-31 15:12:36
    感知算法(Preceptatual hash algorithm) ,它的作用是对每一张图生成一个64位哈希值,之后比较不同图片的哈希值,结果越接近,说明图片越相似。 下面是简单的实现: 第一步:缩小尺寸。 将图片缩小到8x8的尺寸,...
  • Java进阶(五十七)-基于感知哈希算法的pHash图像配准算法  毕业论文提交之后,老师交给自己一项任务:图像配准,也就是给你两幅图像,通过系统来判定两幅图像是否为同一副图像。自己作为这一方面的小白,先去网上...
  • 现在手中只有一张图像需要在一个集合中去找到与之最相近的那一张,这个过程实际是一个匹配的过程,特别是在多模态医学图像中解决这样的问题是比较迫切的,今年试验了一种广泛使用的算法——感知哈希算法!...
  • 感知哈希本质上是哈希算法中的一类算法,最初被提出来就是用来做相似图片的匹配与计算的,以图搜图的本质也是在做详细图片的计算与匹配,不同的算法会有不同的计算精度和计算速度。 对于我们每个人来说,我们有...
  • 图片搜索之感知哈希算法

    千次阅读 2011-10-28 15:10:31
    不过从结果看来,它使用了一种叫做“感知哈希算法(以下简称PHA)”的东西。  PHA是一类比较哈希方法的统称。图片所包含的特征被用来生成一组指纹(不过它不是唯一的),而这些指纹是可以进行比较的。  PHA与加密...
  • 感知哈希算法”(Perceptual hash algorithm),它的作用是对每张图片生成一个”指纹”(fingerprint)字符串,然后比较不同图片的指纹。结果越接近,就说明图片越相似。下面是一个最简单的实现: 第一步,缩小...
  • from:... ”感知哈希算法”(Perceptual hash algorithm),它的作用是对每张图片生成一个”指纹”(fingerprint)字符串,然后比较不同图片的指纹。结果越接近,就说明图
  • 技术原理 原理参考...  参考Neal Krawetz博士的这篇文章, 实现这种功能的关键技术叫做"感知哈希算法"(Perceptual Hash Algorithm), 意思是为图片生成一个指纹(字符串格式)

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,524
精华内容 1,009
关键字:

感知哈希算法python

python 订阅