Android opencv 差值哈希算法，均值哈希算法，图片差异相似度识别

android上使用OpenCV，首先是要导入相应的sdk模块，这个网上都有很多了，不再多说了，要注意的一点是，Android opencv 的sdk要是3.4.7的，sdk模块的名称是openCVLibrary347。

在android上使用opencv的时候，打包成的apk会比较大，大概有80M。

接下来上代码

1.  
   package com.example.agrdf.picturecompare;
2.  
    
3.  
   import org.opencv.core.CvType;
4.  
   import org.opencv.core.Mat;
5.  
   import org.opencv.core.Size;
6.  
   import org.opencv.imgcodecs.Imgcodecs;
7.  
   import org.opencv.imgproc.Imgproc;
8.  
    
9.  
   /**
10.  
    * Created by agrdf on 2022/12/9.
11.  
    */
12.  
     
13.  
    public class example {
14.  
     
15.  
    // 判断差异值，小于差异值，判断为相同图片，返回true，否则返回false
16.  
    public boolean path_to_judge2(String path1,String path2,double auui,double auui2){
17.  
    Mat img1=cv_read(path1);
18.  
    Mat img2=cv_read(path2);
19.  
    // 判断差异值的
20.  
    return method_2(img1,img2,auui,auui2);
21.  
    }
22.  
     
23.  
    // 从图片绝对路径得到Mat
24.  
    public Mat cv_read(String res){
25.  
    Mat img = Imgcodecs.imread(res, Imgcodecs.IMREAD_UNCHANGED);
26.  
    return img;
27.  
    }
28.  
     
29.  
    // 对图片的Mat进行缩放
30.  
    private void resize_to_eight_eight(Mat srcMat){
31.  
    // 缩放成8*8大小，比较ahash均值哈希值
32.  
    Imgproc.resize(srcMat, srcMat,new Size(8,8) , 0, 0, Imgproc.INTER_CUBIC);
33.  
    }
34.  
    // 缩放成8*9大小，比较dhash差值哈希算法的值
35.  
    private void resize_to_nine_eight(Mat srcMat){
36.  
    Imgproc.resize(srcMat, srcMat,new Size(9,8) , 0, 0, Imgproc.INTER_CUBIC);
37.  
    }
38.  
     
39.  
    // 就Mat转换为灰度图
40.  
    private Mat mat_to_gray(Mat resaa){
41.  
    Size dsize = new Size(resaa.width() , resaa.height() );
42.  
    Mat img2 = new Mat(dsize, CvType.CV_16U);
43.  
    Imgproc.cvtColor(resaa,img2,Imgproc.COLOR_BGR2GRAY);
44.  
    return img2;
45.  
    }
46.  
     
47.  
    // 算出一个mat的均值哈希值ahash
48.  
    private double[] get_one_averg_gray(Mat dst1){
49.  
    double[][] data1 = new double[64][1];
50.  
     
51.  
    //iAvg 平均像素灰度值，arr像素灰度值，
52.  
    int iAvg1 = 0;
53.  
    double[] arr1 = new double[64];
54.  
     
55.  
    //get灰度给data，用data给arr充值，算平均灰度值iAvg。
56.  
    for (int i = 0; i < 8; i )
57.  
    {
58.  
    int tmp = i * 8;
59.  
    for (int j = 0; j < 8; j )
60.  
    {
61.  
    int tmp1 = tmp j;
62.  
    // data得到1个点位的像素
63.  
    data1[tmp1] = dst1.get(i,j);
64.  
    // 然后赋值到arr上储存起来
65.  
    arr1[tmp1] = data1[tmp1][0];
66.  
    // 每个像素点相加，得到总灰度
67.  
    iAvg1 = arr1[tmp1];
68.  
     
69.  
    }
70.  
    }
71.  
     
72.  
    // 总灰度变成平均灰度
73.  
    iAvg1 /= 64;
74.  
    //比对每个像素灰度值和平均灰度值大小，大于平均灰度的，就 1
75.  
    for (int i = 0; i < 64; i )
76.  
    {
77.  
    arr1[i] = (arr1[i] >= iAvg1) ? 1 : 0;
78.  
    }
79.  
    return arr1;
80.  
    }
81.  
     
82.  
     
83.  
    // 比较两个ahash，得到差异数量，1为差异最大
84.  
    private double dif_ahsah(double[] arr1,double[] arr2 ){
85.  
    int iDiffNum = 0;
86.  
    for (int i = 0; i < 64; i ){
87.  
    if (arr1[i] != arr2[i]){
88.  
    iDiffNum;
89.  
    }
90.  
     
91.  
    }
92.  
    return ((double)iDiffNum)/64.0;
93.  
    }
94.  
     
95.  
     
96.  
    // 得到一个差值哈希值
97.  
    private String dhash(Mat src){
98.  
     
99.  
    double average = 0;
100.  
     String hash = "";
101.  
     int[] arr = new int[64];
102.  
     for (int i = 0; i < 8; i ) {
103.  
     int count = i*8;
104.  
     for (int j = 0; j < 8; j ) {
105.  
     double[] data = src.get(i, j);
106.  
     double[] data2 = src.get(i, j 1);
107.  
      
108.  
     if ((int) data[0] > (int) data2[0]){
109.  
      
110.  
     hash = "0";
111.  
     }else {
112.  
     hash = "1";
113.  
     }
114.  
      
115.  
     }
116.  
     }
117.  
      
118.  
     return hash;
119.  
      
120.  
     }
121.  
      
122.  
     // 比较两个差值哈希，得到差异值
123.  
     private double dif_dhsah(String str1,String str2){
124.  
     int num = 0;
125.  
     for (int i = 0; i < 64; i ) {
126.  
     if (str1.charAt(i) != str2.charAt(i)){
127.  
     num ;
128.  
     }
129.  
     }
130.  
     return ((double)num)/64.0;
131.  
     }
132.  
      
133.  
     // double ook1, double ook2分别是均值哈希和差值哈希算法的对比值
134.  
     // 是差异的数量，越大，代表差异越大，是不同的图片，最大差异值为1，为完全不相同的图片
135.  
     // 区别不同图片，一般设置为0.5.差异数量超过0.5，就可以认为是不同的图片。因为可能会有一些其他色素的误差。
136.  
     private boolean method_2(Mat source1, Mat source2, double ook1, double ook2){
137.  
      
138.  
     // 这是比较ahash的
139.  
     resize_to_eight_eight(source1);
140.  
     Mat gra1=mat_to_gray(source1);
141.  
     double[] ahash1=get_one_averg_gray(gra1);
142.  
      
143.  
     resize_to_eight_eight(source2);
144.  
     Mat gra2=mat_to_gray(source2);
145.  
     double[] ahash2=get_one_averg_gray(gra2);
146.  
      
147.  
     double judge_ahash=dif_ahsah(ahash1,ahash2);
148.  
      
149.  
     // 接下来是比较dhash的
150.  
      
151.  
     resize_to_nine_eight(source1);
152.  
     Mat dhash_gra1=mat_to_gray(source1);
153.  
     String dhash1=dhash(dhash_gra1);
154.  
      
155.  
     resize_to_nine_eight(source2);
156.  
     Mat dhash_gra2=mat_to_gray(source2);
157.  
     String dhash2=dhash(dhash_gra2);
158.  
      
159.  
     double judge_dhash=dif_dhsah(dhash1,dhash2);
160.  
      
161.  
     if((judge_ahash<ook1)&&(judge_dhash<ook2)){
162.  
      
163.  
     return true;
164.  
     }else {
165.  
      
166.  
     return false;
167.  
      
168.  
     }
169.  
     }
170.  
     }

这篇好文章是转载于：学新通技术网