java:均值哈希实现图像内容相似度比较

雨点打透心脏的1/2处 2022-06-15 23:27 285阅读 0赞

这阵子发现我的图像数据库中有不少内容一样的图像需要剔除，这些内容一样的图像可能尺寸不一样，通道数也可能不一样(灰度/彩色)，如下三张图内容完全一样，只是亮度或色彩通道数不同，
这里写图片描述这里写图片描述这里写图片描述
于是想到了用google或baidu的识图功能所用到的“感知哈希算法”来搜索数据库内容一样的图像。
通过这篇文章搞清楚了“感知哈希算法”的基本原理，
《三种基于感知哈希算法的相似图像检索技术》，发现原理很简单，很适合我等粗人，呵呵，于是在java下实现了这个算法的代码 ：

java实现

  1. package net.gdface.image;
  3. import java.awt.Graphics;
  4. import java.awt.Image;
  5. import java.awt.color.ColorSpace;
  6. import java.awt.image.BufferedImage;
  7. import java.awt.image.ColorConvertOp;
  8. import java.util.Arrays;
  10. /**
  11.  * 均值哈希实现图像指纹比较
  12.  * @author guyadong
  13.  *
  14.  */
  15. public final class FingerPrint {
  17.     /**
  18.      * 图像指纹的尺寸,将图像resize到指定的尺寸，来计算哈希数组 
  19.      */
  20.     private static final int HASH_SIZE=16;
  21.     /**
  22.      * 保存图像指纹的二值化矩阵
  23.      */
  24.     private final byte[] binaryzationMatrix;
  25.     public FingerPrint(byte[] hashValue) {
  26.         if(hashValue.length!=HASH_SIZE*HASH_SIZE)
  27.             throw new IllegalArgumentException(String.format("length of hashValue must be %d",HASH_SIZE*HASH_SIZE ));
  28.         this.binaryzationMatrix=hashValue;
  29.     }
  30.     public FingerPrint(String hashValue) {
  31.         this(toBytes(hashValue));
  32.     }
  33.     public FingerPrint (BufferedImage src){
  34.         this(hashValue(src));
  35.     }
  36.     private static byte[] hashValue(BufferedImage src){
  37.         BufferedImage hashImage = resize(src,HASH_SIZE,HASH_SIZE);
  38.         byte[] matrixGray = (byte[]) toGray(hashImage).getData().getDataElements(0, 0, HASH_SIZE, HASH_SIZE, null); 
  39.         return  binaryzation(matrixGray);
  40.     }
  41.     /**
  42.      * 从压缩格式指纹创建{@link FingerPrint}对象
  43.      * @param compactValue
  44.      * @return
  45.      */
  46.     public static FingerPrint createFromCompact(byte[] compactValue){
  47.         return new FingerPrint(uncompact(compactValue));
  48.     }
  50.     public static boolean validHashValue(byte[] hashValue){
  51.         if(hashValue.length!=HASH_SIZE)
  52.             return false;
  53.         for(byte b:hashValue){
  54.             if(0!=b&&1!=b)return false;         
  55.         }
  56.         return true;
  57.     }
  58.     public static boolean validHashValue(String hashValue){
  59.         if(hashValue.length()!=HASH_SIZE)
  60.             return false;
  61.         for(int i=0;i<hashValue.length();++i){
  62.             if('0'!=hashValue.charAt(i)&&'1'!=hashValue.charAt(i))return false;         
  63.         }
  64.         return true;
  65.     }
  66.     public byte[] compact(){
  67.         return compact(binaryzationMatrix);
  68.     }
  70.     /**
  71.      * 指纹数据按位压缩
  72.      * @param hashValue
  73.      * @return
  74.      */
  75.     private static byte[] compact(byte[] hashValue){
  76.         byte[] result=new byte[(hashValue.length+7)>>3];
  77.         byte b=0;
  78.         for(int i=0;i<hashValue.length;++i){
  79.             if(0==(i&7)){
  80.                 b=0;
  81.             }
  82.             if(1==hashValue[i]){
  83.                 b|=1<<(i&7);
  84.             }else if(hashValue[i]!=0)
  85.                 throw new IllegalArgumentException("invalid hashValue,every element must be 0 or 1");
  86.             if(7==(i&7)||i==hashValue.length-1){
  87.                 result[i>>3]=b;
  88.             }
  89.         }
  90.         return result;
  91.     }
  93.     /**
  94.      * 压缩格式的指纹解压缩
  95.      * @param compactValue
  96.      * @return
  97.      */
  98.     private static byte[] uncompact(byte[] compactValue){
  99.         byte[] result=new byte[compactValue.length<<3];
  100.         for(int i=0;i<result.length;++i){
  101.             if((compactValue[i>>3]&(1<<(i&7)))==0)
  102.                 result[i]=0;
  103.             else
  104.                 result[i]=1;
  105.         }
  106.         return result;      
  107.     }
  108.     /**
  109.      * 字符串类型的指纹数据转为字节数组
  110.      * @param hashValue
  111.      * @return
  112.      */
  113.     private static byte[] toBytes(String hashValue){
  114.         hashValue=hashValue.replaceAll("\\s", "");
  115.         byte[] result=new byte[hashValue.length()];
  116.         for(int i=0;i<result.length;++i){
  117.             char c = hashValue.charAt(i);
  118.             if('0'==c)
  119.                 result[i]=0;
  120.             else if('1'==c)
  121.                 result[i]=1;
  122.             else
  123.                 throw new IllegalArgumentException("invalid hashValue String");
  124.         }
  125.         return result;
  126.     }
  127.     /**
  128.      * 缩放图像到指定尺寸
  129.      * @param src
  130.      * @param width
  131.      * @param height
  132.      * @return
  133.      */
  134.     private static BufferedImage resize(Image src,int width,int height){
  135.         BufferedImage result = new BufferedImage(width, height,  
  136.                 BufferedImage.TYPE_3BYTE_BGR); 
  137.          Graphics g = result.getGraphics();
  138.          try{
  139.              g.drawImage(src.getScaledInstance(width, height, Image.SCALE_SMOOTH), 0, 0, null);
  140.          }finally{
  141.              g.dispose();
  142.          }
  143.         return result;      
  144.     }
  145.     /**
  146.      * 计算均值
  147.      * @param src
  148.      * @return
  149.      */
  150.     private static  int mean(byte[] src){
  151.         long sum=0;
  152.         // 将数组元素转为无符号整数
  153.         for(byte b:src)sum+=(long)b&0xff;
  154.         return (int) (Math.round((float)sum/src.length));
  155.     }
  156.     /**
  157.      * 二值化处理
  158.      * @param src
  159.      * @return
  160.      */
  161.     private static byte[] binaryzation(byte[]src){
  162.         byte[] dst = src.clone();
  163.         int mean=mean(src);
  164.         for(int i=0;i<dst.length;++i){
  165.             // 将数组元素转为无符号整数再比较
  166.             dst[i]=(byte) (((int)dst[i]&0xff)>=mean?1:0);
  167.         }
  168.         return dst;
  170.     }
  171.     /**
  172.      * 转灰度图像
  173.      * @param src
  174.      * @return
  175.      */
  176.     private static BufferedImage toGray(BufferedImage src){
  177.         if(src.getType()==BufferedImage.TYPE_BYTE_GRAY){
  178.             return src;
  179.         }else{
  180.             // 图像转灰
  181.             BufferedImage grayImage = new BufferedImage(src.getWidth(), src.getHeight(),  
  182.                     BufferedImage.TYPE_BYTE_GRAY);
  183.             new ColorConvertOp(ColorSpace.getInstance(ColorSpace.CS_GRAY), null).filter(src, grayImage);
  184.             return grayImage;       
  185.         }
  186.     }
  188.     @Override
  189.     public String toString() {
  190.         return toString(true);
  191.     }
  192.     /**
  193.      * @param multiLine 是否分行
  194.      * @return
  195.      */
  196.     public String toString(boolean multiLine) {
  197.         StringBuffer buffer=new StringBuffer();
  198.         int count=0;
  199.         for(byte b:this.binaryzationMatrix){
  200.             buffer.append(0==b?'0':'1');
  201.             if(multiLine&&++count%HASH_SIZE==0)
  202.                 buffer.append('\n');
  203.         }
  204.         return buffer.toString();
  205.     }
  206.     @Override
  207.     public boolean equals(Object obj) {
  208.         if(obj instanceof FingerPrint){
  209.             return Arrays.equals(this.binaryzationMatrix,((FingerPrint)obj).binaryzationMatrix);
  210.         }else
  211.             return super.equals(obj);
  212.     }
  214.     /**
  215.      * 与指定的压缩格式指纹比较相似度
  216.      * @param compactValue
  217.      * @return
  218.      * @see #compare(FingerPrint)
  219.      */
  220.     public float compareCompact(byte[] compactValue){
  221.         return compare(createFromCompact(compactValue));
  222.     }
  223.     /**
  224.      * @param hashValue
  225.      * @return
  226.      * @see #compare(FingerPrint)
  227.      */
  228.     public float compare(String hashValue){
  229.         return compare(new FingerPrint(hashValue));
  230.     }
  231.     /**
  232.      * 与指定的指纹比较相似度
  233.      * @param hashValue
  234.      * @return
  235.      * @see #compare(FingerPrint)
  236.      */
  237.     public float compare(byte[] hashValue){
  238.         return compare(new FingerPrint(hashValue));
  239.     }
  240.     /**
  241.      * 与指定图像比较相似度
  242.      * @param image2
  243.      * @return
  244.      * @see #compare(FingerPrint)
  245.      */
  246.     public float compare(BufferedImage image2){
  247.         return compare(new FingerPrint(image2));
  248.     }
  249.     /**
  250.      * 比较指纹相似度
  251.      * @param src
  252.      * @return 
  253.      * @see #compare(byte[], byte[])
  254.      */
  255.     public float compare(FingerPrint src){
  256.         if(src.binaryzationMatrix.length!=this.binaryzationMatrix.length)
  257.             throw new IllegalArgumentException("length of hashValue is mismatch");
  258.         return compare(binaryzationMatrix,src.binaryzationMatrix);
  259.     }
  260.     /**
  261.      * 判断两个数组相似度，数组长度必须一致否则抛出异常
  262.      * @param f1
  263.      * @param f2
  264.      * @return 返回相似度(0.0~1.0)
  265.      */
  266.     private static float compare(byte[] f1,byte[] f2){
  267.         if(f1.length!=f2.length)
  268.             throw new IllegalArgumentException("mismatch FingerPrint length");
  269.         int sameCount=0;
  270.         for(int i=0;i<f1.length;++i){
  271.             if(f1[i]==f2[i])++sameCount;
  272.         }
  273.         return (float)sameCount/f1.length;
  274.     }
  275.     public static float compareCompact(byte[] f1,byte[] f2){
  276.         return compare(uncompact(f1),uncompact(f2));
  277.     }
  278.     public static float compare(BufferedImage image1,BufferedImage image2){
  279.         return new FingerPrint(image1).compare(new FingerPrint(image2));
  280.     }
  281. }

调用示例

junit测试代码

  1. package test;
  3. import java.io.File;
  4. import java.io.IOException;
  6. import javax.imageio.ImageIO;
  8. import org.junit.Test;
  9. import net.gdface.image.FingerPrint;
  10. import net.gdface.image.NotImage;
  11. import net.gdface.image.UnsupportedFormat;
  13. public class TestFingerPrint {
  16.     @Test
  17.     public void testCompare() throws IOException{
  18.         FingerPrint fp1 = new FingerPrint(ImageIO.read(new File("d:\\tmp\\he049-black.jpg")));
  19.         FingerPrint fp2 =new FingerPrint(ImageIO.read(new File("d:\\tmp\\he049-gray.jpg")));
  20.         System.out.println(fp1.toString(true));
  21.         System.out.printf("sim=%f",fp1.compare(fp2));
  22.     }
  23. }

发表评论

表情：
评论列表 （有 0 条评论，285人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Python实现字符串相似度比较

    Python实现字符串相似度比较 在日常的开发中，我们可能需要对不同的字符串进行比较，以判断它们之间的相似程度。例如，在搜索引擎、拼写检查和数据清洗等任务中，字符串相似度比较

    - 日理万妓- 日理万妓/ 0 赞/ 96 阅读