Android——上传截图相似度对比

你的名字 2021-07-25 12:42 413阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNjA4MDAw_size_16_color_FFFFFF_t_70]

--------------------

QQ 1285575001  
Wechat M010527  
技术交流 QQ群599020441  
纪年科技aming

--------------------

### 引荐 ###

#### 相似图片搜索的原理 ####

阮一峰 2011年7月21日发布的博客  
Google “相似图片搜索”  
根据Neal Krawetz博士的解释，原理非常简单易懂。  
我们可以用一个快速算法，就达到基本的效果  
“感知哈希算法”（Perceptual hash algorithm）  
它的作用是对每张图片生成一个"指纹"（fingerprint）字符串，  
然后比较不同图片的指纹。  
结果越接近，就说明图片越相似。

--------------------

最简单的实现：  
第一步，缩小尺寸。  
将图片缩小到8x8的尺寸，总共64个像素。  
这一步的作用是去除图片的细节，只保留结构、明暗等基本信息，  
摒弃不同尺寸、比例带来的图片差异。

第二步，简化色彩。

将缩小后的图片，转为64级灰度。  
也就是说，所有像素点总共只有64种颜色。

第三步，计算平均值。

计算所有64个像素的灰度平均值。

第四步，比较像素的灰度。

将每个像素的灰度，与平均值进行比较。  
大于或等于平均值，记为1；小于平均值，记为0。

第五步，计算哈希值。

将上一步的比较结果，组合在一起，就构成了一个64位的整数，  
这就是这张图片的指纹。  
组合的次序并不重要，只要保证所有图片都采用同样次序就行了。

得到指纹以后，就可以对比不同的图片，看看64位中有多少位是不一样的。

--------------------

在理论上，这等同于计算"汉明距离"（Hamming distance）。  
如果不相同的数据位不超过5，就说明两张图片很相似；  
如果大于10，就说明这是两张不同的图片。

这种算法的优点是简单快速，不受图片大小缩放的影响，  
缺点是图片的内容不能变更。  
如果在图片上加几个文字，它就认不出来了。  
所以，它的最佳用途是根据缩略图，找出原图。

实际应用中，往往采用更强大的pHash算法和SIFT算法，  
它们能够识别图片的变形。  
只要变形程度不超过25%，它们就能匹配原图。  
这些算法虽然更复杂，但是原理与上面的简便算法是一样的，  
就是先将图片转化成Hash字符串，然后再进行比较。

UPDATE（2013.03.31）

--------------------

一、颜色分布法

每张图片都可以生成颜色分布的直方图（color histogram）。  
如果两张图片的直方图很接近，就可以认为它们很相似。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNjA4MDAw_size_16_color_FFFFFF_t_70 1]  
任何一种颜色都是由红绿蓝三原色（RGB）构成的，  
所以上图共有4张直方图（三原色直方图 + 最后合成的直方图）。

如果每种原色都可以取256个值，那么整个颜色空间共有1600万种颜色（256的三次方）。

针对这1600万种颜色比较直方图，计算量实在太大了，因此需要采用简化方法。  
可以将0～255分成四个区：  
0～63为第0区，64～127为第1区，128～191为第2区，192～255为第3区。  
这意味着红绿蓝分别有4个区，总共可以构成64种组合（4的3次方）。

任何一种颜色必然属于这64种组合中的一种，这样就可以统计每一种组合包含的像素数量。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNjA4MDAw_size_16_color_FFFFFF_t_70 2]  
上图是某张图片的颜色分布表，将表中最后一栏提取出来，  
组成一个64维向量(7414, 230, 0, 0, 8, …, 109, 0, 0, 3415, 53929)。  
这个向量就是这张图片的特征值或者叫"指纹"。

于是，寻找相似图片就变成了找出与其最相似的向量。  
这可以用皮尔逊相关系数或者余弦相似度算出。

二、内容特征法  
除了颜色构成，还可以从比较图片内容的相似性入手。  
首先，将原图转成一张较小的灰度图片，假定为50x50像素。  
然后，确定一个阈值，将灰度图片转成黑白图片。  
![在这里插入图片描述][20200208174533620.png]![在这里插入图片描述][20200208174539246.png]![在这里插入图片描述][20200208174544160.png]  
如果两张图片很相似，它们的黑白轮廓应该是相近的。  
于是，问题就变成了，第一步如何确定一个合理的阈值，正确呈现照片中的轮廓？

显然，前景色与背景色反差越大，轮廓就越明显。  
这意味着，如果我们找到一个值，可以使得前景色和背景色各自的"类内差异最小"（minimizing the intra-class variance），或者"类间差异最大"（maximizing the inter-class variance），那么这个值就是理想的阈值。

--------------------

1979年，日本学者大津展之证明了，“类内差异最小"与"类间差异最大"是同一件事，即对应同一个阈值。  
他提出一种简单的算法，可以求出这个阈值，这被称为"大津法”（Otsu’s method）。

下面就是他的计算方法。

假定一张图片共有n个像素，其中灰度值小于阈值的像素为 n1 个，大于等于阈值的像素为 n2 个（ n1 + n2 = n ）。  
w1 和 w2 表示这两种像素各自的比重。

w1 = n1 / n
    w2 = n2 / n

再假定，所有灰度值小于阈值的像素的平均值和方差分别为 μ1 和 σ1，所有灰度值大于等于阈值的像素的平均值和方差分别为 μ2 和 σ2。于是，可以得到

类内差异 = w1(σ1的平方) + w2(σ2的平方)
    类间差异 = w1w2(μ1-μ2)^2

可以证明，这两个式子是等价的：  
得到"类内差异"的最小值，等同于得到"类间差异"的最大值。  
不过，从计算难度看，后者的计算要容易一些。

下一步用"穷举法"，  
将阈值从灰度的最低值到最高值，依次取一遍，分别代入上面的算式。  
使得"类内差异最小"或"类间差异最大"的那个值，就是最终的阈值。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNjA4MDAw_size_16_color_FFFFFF_t_70 3]  
有了50x50像素的黑白缩略图，就等于有了一个50x50的0-1矩阵。  
矩阵的每个值对应原图的一个像素，0表示黑色，1表示白色。  
这个矩阵就是一张图片的特征矩阵。  
两个特征矩阵的不同之处越少，就代表两张图片越相似。  
这可以用"异或运算"实现（即两个值之中只有一个为1，则运算结果为1，否则运算结果为0）。  
对不同图片的特征矩阵进行"异或运算"，结果中的1越少，就是越相似的图片。

--------------------

#### Android里的方法来实现 ####

第一步，缩小尺寸。

Bitmap bitmap8 = ThumbnailUtils.extractThumbnail(bitmapOriginal, 8, 8);

第二步，简化色彩。

public static Bitmap convertGreyImg(Bitmap img) { 
            int width = img.getWidth();         //获取位图的宽
            int height = img.getHeight();       //获取位图的高
    
            int[] pixels = new int[width * height]; //通过位图的大小创建像素点数组
    
            img.getPixels(pixels, 0, width, 0, 0, width, height);
            int alpha = 0xFF << 24;
            for (int i = 0; i < height; i++) { 
                for (int j = 0; j < width; j++) { 
                    int original = pixels[width * i + j];
                    int red = ((original & 0x00FF0000) >> 16);
                    int green = ((original & 0x0000FF00) >> 8);
                    int blue = (original & 0x000000FF);
    
                    int grey = (int) ((float) red * 0.3 + (float) green * 0.59 + (float) blue * 0.11);
                    grey = alpha | (grey << 16) | (grey << 8) | grey;
                    pixels[width * i + j] = grey;
                }
            }
            Bitmap result = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
            result.setPixels(pixels, 0, width, 0, 0, width, height);
            return result;
        }

第三步，计算平均值。

public static int getAvg(Bitmap img) { 
            int width = img.getWidth();
            int height = img.getHeight();
            int[] pixels = new int[width * height];
            img.getPixels(pixels, 0, width, 0, 0, width, height);
    
            int avgPixel = 0; for (int pixel : pixels) { 
                avgPixel += pixel;
            }
            return avgPixel / pixels.length;
        }

第四步，比较像素的灰度。

public static String getBinary(Bitmap img, int average) { 
            StringBuilder sb = new StringBuilder();
    
            int width = img.getWidth();
            int height = img.getHeight();
            int[] pixels = new int[width * height];
    
            img.getPixels(pixels, 0, width, 0, 0, width, height);
            for (int i = 0; i < height; i++) { 
                for (int j = 0; j < width; j++) { 
                    int original = pixels[width * i + j]; if (original >= average) { 
                        pixels[width * i + j] = 1;
                    } else { 
                        pixels[width * i + j] = 0;
                    }
                    sb.append(pixels[width * i + j]);
                }
            }
            return sb.toString();
        }

第五步，计算哈希值。  
下面是得到16位16进制的字符串，作为该图片的消息指纹

public static String binaryString2hexString(String bString) { 
            if (bString == null || bString.equals("") || bString.length() % 8 != 0)
                return null;
            StringBuilder sb = new StringBuilder();
            int iTmp;
            for (int i = 0; i < bString.length(); i += 4) { 
                iTmp = 0;
                for (int j = 0; j < 4; j++) { 
                    iTmp += Integer.parseInt(bString.substring(i + j, i + j + 1)) << (4 - j - 1);
                }
                sb.append(Integer.toHexString(iTmp));
            }
            return sb.toString

下面是两张图片的消息指纹比较的方法

static void diff(String s1, String s2) { 
            char[] s1s = s1.toCharArray();
            char[] s2s = s2.toCharArray();
            int diffNum = 0;
            for (int i = 0; i<s1s.length; i++) { 
                if (s1s[i] != s2s[i]) { 
                    diffNum++;
                }
            }
            System.out.println("diffNum="+diffNum);
        }

Str64->16=81000081e9ff0000  
    Str64->16=01800049e1ff0000  
    Str64->16=10000d41ebff8000  
    Str64->16=fdff47e80020231b  
    Str64->16=ffffcfb80028031b  
    Str64->16=ffff4fee0408031b  
    Str64->16=040c7104000e7fff  
    Str64->16=0b1b999f0300052f  
    Str64->16=0b1b99c101400527

1、2、3行，4、5、6行，8、9行是大致同一个位置  
（手持手机，尽量保持同一个位置），  
第7行是其他位置，说明结果还是比较靠谱的，  
个人认为diff(s1, s2)方法  
结果在1 ~ 5说明两张照片极其相似，6 ~ 10说明较为相似，10以上说明不相似

--------------------

可能的需求：

*  截自己的屏
 *  截所有的屏
 *  带导航栏截屏
 *  不带导航栏截屏
 *  截屏并编辑选取一部分
 *  自动截取某个空间或者布局
 *  截取长图
 *  在后台去截屏

1.只截取自己应用内部界面

1.1 截取除了导航栏之外的屏幕

View dView = getWindow().getDecorView();
    dView.setDrawingCacheEnabled(true);
    dView.buildDrawingCache();
    Bitmap bitmap = Bitmap.createBitmap(dView.getDrawingCache()); if (bitmap != null) { 
      try { 
        // 获取内置SD卡路径
        String sdCardPath = Environment.getExternalStorageDirectory().getPath();
        // 图片文件路径
        String filePath = sdCardPath + File.separator + "screenshot.png";
        File file = new File(filePath);
        FileOutputStream os = new FileOutputStream(file);
        bitmap.compress(Bitmap.CompressFormat.PNG, 100, os);
        os.flush();
        os.close();
        DebugLog.d("a7888", "存储完成");
      } catch (Exception e) { 
      }
    }

1.2 截取某个控件或者区域

两种方案：

跟上面差不多，只不过view不适用根view，而是使用某个某个控件。

View dView = title;
    dView.setDrawingCacheEnabled(true);
    dView.buildDrawingCache();
    Bitmap bitmap = Bitmap.createBitmap(dView.getDrawingCache());

手动draw

View dView = titleTv;
    Bitmap bitmap = Bitmap.createBitmap(dView.getWidth(), dView.getHeight(), Bitmap.Config.ARGB_8888);
    //使用Canvas，调用自定义view控件的onDraw方法，绘制图片
    Canvas canvas = new Canvas(bitmap);
    dView.draw(canvas);

1.3 截取带导航栏的整个屏幕

这一小节会将一些理论上可以，但是实践会特别复杂，不太推荐使用。  
可以学习了解。

adb 命令

这里指的不是连接电脑进行adb操控，而是在App内部实现adb命令的操控

在APK中调用“adb shell screencap -pfilepath” 命令

该命令读取系统的framebuffer，需要获得系统权限：

（1）. 在AndroidManifest.xml文件中添加

<uses-permissionandroid:name="android.permission.READ_FRAME_BUFFER"/>

2）. 修改APK为系统权限，将APK放到源码中编译， 修改Android.mk

LOCAL_CERTIFICATE := platform publicvoid takeScreenShot(){  
      String mSavedPath = Environment.getExternalStorageDirectory()+File. separator + "screenshot.png" ; try {            
          Runtime. getRuntime().exec("screencap -p " + mSavedPath); 
      } catch (Exception e) {  
          e.printStackTrace(); 
      }

利用系统的隐藏API，实现Screenshot,这部分代码是系统隐藏的，需要在源码下编译。

1).修改Android.mk， 添加系统权限

LOCAL_CERTIFICATE := platform

2).修改AndroidManifest.xml 文件，添加权限

<uses-permissionandroid:name="android.permission.READ_FRAME_BUFFER"/>

public boolean takeScreenShot(String imagePath){ 
           if(imagePath.equals("" )){ 
               imagePath = Environment.getExternalStorageDirectory()+File. separator+"Screenshot.png" ;
           }
                
         Bitmap mScreenBitmap;
         WindowManager mWindowManager;
         DisplayMetrics mDisplayMetrics;
         Display mDisplay;
              
         mWindowManager = (WindowManager) mcontext.getSystemService(Context.WINDOW_SERVICE);
         mDisplay = mWindowManager.getDefaultDisplay();
         mDisplayMetrics = new DisplayMetrics();
         mDisplay.getRealMetrics(mDisplayMetrics); float[] dims = { mDisplayMetrics.widthPixels , mDisplayMetrics.heightPixels };
         mScreenBitmap = Surface. screenshot((int) dims[0], ( int) dims[1]); if (mScreenBitmap == null) {  
             return false ;
         }
              
        try { 
         FileOutputStream out = new FileOutputStream(imagePath);
         mScreenBitmap.compress(Bitmap.CompressFormat. PNG, 100, out);
            
        } catch (Exception e) { 
             
             
         return false ;
        }    
                   
        return true ;
    }

Android本地编程（Native Programming）读取framebuffer

命令行，框架的截屏功能是通过framebuffer来实现的，  
所以我们先来介绍一下framebuffer。

framebuffer介绍

帧缓冲（framebuffer）是Linux为显示设备提供的一个接口，  
把显存抽象后的一种设备，  
他允许上层应用程序在图形模式下直接对显示缓冲区进行 读写操作。  
这种操作是抽象的，统一的。  
用户不必关心物理显存的位置、换页机制等等具体细节。  
这些都是由Framebuffer设备驱动来完成的。

linux FrameBuffer 本质上只是提供了对图形设备的硬件抽象，  
在开发者看来，  
FrameBuffer 是一块显示缓存，  
往显示缓存中写入特定格式的数据就意味着向屏幕输出内容。  
所以说FrameBuffer就是一块白板。  
例如对于初始化为16 位色的FrameBuffer 来说，  
FrameBuffer中的两个字节代表屏幕上一个点，从上到下，从左至右，  
屏幕位置与内存地址是顺序的线性关系。

帧缓存有个地址，是在内存里。  
我们通过不停的向frame buffer中写入数据，  
显示控制器就自动的从frame buffer中取数据并显示出来。  
全部的图形都共享内存中同一个帧缓存。

android截屏实现思路

Android系统是基于Linux内核的，所以也存在framebuffer这个设备，  
我们要实现截屏的话只要能获取到framebuffer中的数据，  
然后把数据转换成图片就可以了，  
android中的framebuffer数据是存放在 /dev/graphics/fb0 文件中的，  
所以我们只需要来获取这个文件的数据就可以得到当前屏幕的内容。

现在我们的测试代码运行时候是通过RC(remote controller)方式来运行被测应用的，  
那就需要在PC机上来访问模拟器或者真机上的framebuffer数据，  
这个的话可以通过android的ADB命令来实现。

各大手机自带的按键组合进行截屏

Android源码中对按键的捕获位于文件PhoneWindowManager.java（alps\\frameworks\\base\\policy\\src\\com\\android\\internal\\policy\\impl）中，  
这个类处理所有的键盘输入事件，  
其中函数interceptKeyBeforeQueueing（）会对常用的按键做特殊处理。

1.  截取非含当前应用的屏幕部分（最佳官方方案）

Android 在5.0 之后支持了实时录屏的功能。  
通过实时录屏我们可以拿到截屏的图像。  
同时可以通过在Service中处理实现后台的录屏。  
具体的类讲解大家自行网上查阅。

大体步骤：

1.初始化一个MediaProjectionManager。

MediaProjectionManager mMediaProjectionManager = 
     (MediaProjectionManager)getApplication().getSystemService(Context.MEDIA_PROJECTION_SERVICE);

2.创建intent,并启动Intent。注意这里是startActivityForResult

startActivityForResult(mMediaProjectionManager.createScreenCaptureIntent(), 
    REQUEST_MEDIA_PROJECTION);

3.在onActivityResult中拿到Mediaprojection。

mResultCode = resultCode;
    mResultData = data;
    mMediaProjection = mMediaProjectionManager.getMediaProjection(mResultCode, mResultData);

4.设置VirtualDisplay 将图像和展示的View关联起来。  
一般来说我们会将图像展示到SurfaceView，  
这里为了为了便于拿到截图，我们使用ImageReader，他内置有SurfaceView。

mImageReader = ImageReader.newInstance(windowWidth, windowHeight, 0x1, 2); //ImageFormat.RGB_565
    mVirtualDisplay = mMediaProjection.createVirtualDisplay("screen-mirror",
            windowWidth, windowHeight, mScreenDensity,       DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR,
            mImageReader.getSurface(), null, null);

5.通过ImageReader拿到截图

strDate = dateFormat.format(new java.util.Date());
    nameImage = pathImage+strDate+".png";
     
    Image image = mImageReader.acquireLatestImage();
    int width = image.getWidth();
    int height = image.getHeight();
    final Image.Plane[] planes = image.getPlanes();
    final ByteBuffer buffer = planes[0].getBuffer();
    int pixelStride = planes[0].getPixelStride();
    int rowStride = planes[0].getRowStride();
    int rowPadding = rowStride - pixelStride * width;
    Bitmap bitmap = Bitmap.createBitmap(width+rowPadding/pixelStride, height, Bitmap.Config.ARGB_8888);
    bitmap.copyPixelsFromBuffer(buffer);
    bitmap = Bitmap.createBitmap(bitmap, 0, 0,width, height);
    image.close();

6.注意截屏之后要及时关闭VirtualDisplay ，  
因为VirtualDisplay 是十分消耗内存和电量的。

if (mVirtualDisplay == null) { 
          return;
    }
    mVirtualDisplay.release();
    mVirtualDisplay = null;

ps: 具体可以参考Google官方给的demo以及其他开发者写的Demo

https://github.com/googlesamples/android-ScreenCapture  
https://github.com/VincentWYJ/CaptureScreen

--------------------

1.  截取长屏

截取长屏其实原理就是截取整个ScrollView或者ListView的视图，  
因此实现原理跟上面中提到的截取某个控件的View基本一致。

ScrollView 实现截屏

/** * 截取scrollview的屏幕 * **/
    public static Bitmap getScrollViewBitmap(ScrollView scrollView) { 
      int h = 0;
      Bitmap bitmap;
      for (int i = 0; i < scrollView.getChildCount(); i++) { 
        h += scrollView.getChildAt(i).getHeight();
      }
      // 创建对应大小的bitmap
      bitmap = Bitmap.createBitmap(scrollView.getWidth(), h,
          Bitmap.Config.ARGB_8888);
      final Canvas canvas = new Canvas(bitmap);
      scrollView.draw(canvas);
      return bitmap;
    }

ListView实现截屏

/** * 截图listview * **/
     public static Bitmap getListViewBitmap(ListView listView,String picpath) { 
       int h = 0;
       Bitmap bitmap;
       // 获取listView实际高度
       for (int i = 0; i < listView.getChildCount(); i++) { 
         h += listView.getChildAt(i).getHeight();
       }
       Log.d(TAG, "实际高度:" + h);
       Log.d(TAG, "list 高度:" + listView.getHeight());
       // 创建对应大小的bitmap
       bitmap = Bitmap.createBitmap(listView.getWidth(), h,
           Bitmap.Config.ARGB_8888);
       final Canvas canvas = new Canvas(bitmap);
       listView.draw(canvas);
       return bitmap;
     }

WebView实现截屏

//这是webview的，利用了webview的api private static Bitmap captureWebView(WebView webView) { 
        Picture snapShot = webView.capturePicture();
        Bitmap bmp = Bitmap.createBitmap(snapShot.getWidth(),
            snapShot.getHeight(), Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(bmp);
        snapShot.draw(canvas);
        return bmp;
      }

有时候我们可能需要去滚动屏幕，然后再滚动到某一个地方时停止截屏，  
这样就会去截取从开始到滚动结束位置的view，而不是整个ScrollView，  
这个时候就需要进行一些控制，具体原理跟上面讲的差不多，  
可以参考一下下面的实现：

https://androidnotes.github.io/2016/12/03/android%E9%95%BF%E6%88%AA%E5%B1%8F%E5%8E%9F%E7%90%86/

1.  实时截屏

可参考2中Android 在5.0的做法，进行实时录制。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNjA4MDAw_size_16_color_FFFFFF_t_70]: /images/20210725/521dafc90bf54ccba706cb3765608538.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNjA4MDAw_size_16_color_FFFFFF_t_70 1]: /images/20210725/9ab2528b40444def8aa37f2bc1eeaee1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNjA4MDAw_size_16_color_FFFFFF_t_70 2]: /images/20210725/1c89f512ebdf4896856dd4b86efa9d9d.png
[20200208174533620.png]: https://img-blog.csdnimg.cn/20200208174533620.png
[20200208174539246.png]: https://img-blog.csdnimg.cn/20200208174539246.png
[20200208174544160.png]: /images/20210725/62cddd53c70d4127b900ed9eea66a593.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNjA4MDAw_size_16_color_FFFFFF_t_70 3]: /images/20210725/d7a3fe93a2264b92b0568c31146d448b.png