OpenCV学习笔记（七）—— OpenCV for Android实时图像处理-低调大师

OpenCV学习笔记（七）—— OpenCV for Android实时图像处理

2017-03-16 662

在上篇中我们已经实现了相机打开和实时图像信息的获取，那么接下来我们可以尝试在获取的图像信息进行一些处理，然后实时显示出来，在这里我们要完成的的几种处理：

灰化、Canny边缘检测、Hist直方图计算、Sobel边缘检测、SEPIA(色调变换)、ZOOM放大镜、PIXELIZE像素化

一、修改布局界面：

由于这里我们需要切换不同的图像处理模式，所以这里我们需要在界面上放置一个按钮，我们可以放置很多个按钮，每个按钮对应一种处理模式，但是这里我们也可以只放置一个按钮，每次点击按钮就切换一次，循环切换模式：

activity_main.xml文件：

[java]view plain copy 
    
 print?
 <FrameLayout    
     xmlns:android="http://schemas.android.com/apk/res/android"   
     xmlns:tools="http://schemas.android.com/tools"   
     xmlns:opencv="http://schemas.android.com/apk/res-auto"   
     android:layout_width="match_parent"   
     android:layout_height="match_parent">   
    
     <org.opencv.android.JavaCameraView    
         android:layout_width="fill_parent"   
         android:layout_height="fill_parent"   
         android:id="@+id/camera_view"   
         opencv:show_fps="true"    
         opencv:camera_id="any"/>   
        
     <RelativeLayout    
         android:layout_width="fill_parent"   
         android:layout_height="fill_parent"   
         android:gravity="bottom|center_horizontal">   
         <Button    
             android:id="@+id/deal_btn"   
             android:layout_width="100dp"   
             android:layout_height="40dp"   
             android:layout_marginBottom="20dp"   
             android:text="处理"/>   
     </RelativeLayout>   
    
 </FrameLayout>   

查看预览图：

二、获取按钮组件并监听按钮点击：

1.声明一个Button对象用于绑定上面的按钮组件和一个状态标志位用于存储当前状态：

[java]view plain copy 
    
 print?
        //按钮组件   
 private Button mButton;   
 //当前处理状态   
 private static int Cur_State = 0;   

2.在OnCreate中绑定按钮和按钮点击监听：

[java]view plain copy 
    
 print?
 mButton = (Button) findViewById(R.id.deal_btn);   
 mButton.setOnClickListener(new OnClickListener(){   
     @Override   
     public void onClick(View v) {   
         if(Cur_State<8){   
             //切换状态   
             Cur_State ++;   
         }else{   
             //恢复初始状态   
             Cur_State = 0;   
         }   
     }   
                
 });   

这里的状态标志位Cur_State与图像处理的每个类型对应，0对应默认状态，也就是显示原图，1-7分别对应：灰化、Canny边缘检测、Hist直方图计算、Sobel边缘检测、SEPIA(色调变换)、ZOOM放大镜、PIXELIZE像素化

三、图像信息获取保存、处理和显示：

1.在OpenCV中一般都是使用Mat类型来存储图像等矩阵信息，所以我们可以声明一个Mat对象用来作为实时帧图像的缓存对象：

[java]view plain copy 
    
 print?
 //缓存相机每帧输入的数据   
 private Mat mRgba;   

2.对象实例化以及基本属性的设置，包括：长度、宽度和图像类型标志：

[java]view plain copy 
    
 print?
 public void onCameraViewStarted(int width, int height) {   
     // TODO Auto-generated method stub   
     mRgba = new Mat(height, width, CvType.CV_8UC4);   
 }   

3.对象赋值，这里只对原图和灰化两种情况进行了处理，其他的处理后续再添加：

[java]view plain copy 
    
 print?
        /**  
  * 图像处理都写在此处  
  */   
 @Override   
 public Mat onCameraFrame(CvCameraViewFrame inputFrame) {   
     switch (Cur_State) {   
     case 1:   
         //灰化处理   
         Imgproc.cvtColor(inputFrame.gray(), mRgba, Imgproc.COLOR_GRAY2RGBA,4);   
         break;   
     default:   
         //显示原图   
         mRgba = inputFrame.rgba();   
         break;   
     }   
     //返回处理后的结果数据   
     return mRgba;   
 }   

4.由于用对象存储图像数据的话，数据会保存到内存中，所以结束的时候需要进行数据释放，不然可能导致崩溃：

[java]view plain copy 
    
 print?
        @Override   
 public void onCameraViewStopped() {   
     // TODO Auto-generated method stub   
     mRgba.release();   
 }   

5.运行查看效果：

正常模式：

灰化图：

四、其他处理及结果：

在以上的例子中我们已经完成了预览图的灰化处理，那么接下来我们把其他处理都添加到代码中，查看效果。由于在2.x版本中使用到的部分方法已经发生了变化，如：在OpenCV 3.1.0中org.opencv.core.Core类中的方法line和rectangle都已失效，可以用org.opencv.imgproc.Imgproc中的line和rectangle来代替：

1. MainActivity.Java源码：

[java]view plain copy 
    
 print?
 package com.linsh.opencv_test;   
    
 import java.util.Arrays;   
    
 import org.opencv.android.BaseLoaderCallback;   
 import org.opencv.android.CameraBridgeViewBase;   
 import org.opencv.android.OpenCVLoader;   
 import org.opencv.android.CameraBridgeViewBase.CvCameraViewFrame;   
 import org.opencv.android.CameraBridgeViewBase.CvCameraViewListener2;   
 import org.opencv.android.LoaderCallbackInterface;   
 import org.opencv.core.Core;   
 import org.opencv.core.CvType;   
 import org.opencv.core.Mat;   
 import org.opencv.core.MatOfFloat;   
 import org.opencv.core.MatOfInt;   
 import org.opencv.core.Point;   
 import org.opencv.core.Scalar;   
 import org.opencv.core.Size;   
 import org.opencv.imgproc.Imgproc;   
    
 import android.R.string;   
 import android.app.Activity;   
 import android.os.Bundle;   
 import android.util.Log;   
 import android.widget.Button;   
 import android.view.View;   
 import android.view.View.OnClickListener;   
    
 public class MainActivity extends Activity implements CvCameraViewListener2{   
     private String TAG = "OpenCV_Test";   
     //OpenCV的相机接口   
     private CameraBridgeViewBase mCVCamera;   
     //缓存相机每帧输入的数据   
     private Mat mRgba,mTmp;   
     //按钮组件   
     private Button mButton;   
     //当前处理状态   
     private static int Cur_State = 0;   
        
     private Size mSize0;   
     private Mat mIntermediateMat;   
     private MatOfInt mChannels[];   
     private MatOfInt mHistSize;   
     private int mHistSizeNum = 25;   
     private Mat mMat0;   
     private float[] mBuff;   
     private MatOfFloat mRanges;   
     private Point mP1;   
     private Point mP2;   
     private Scalar mColorsRGB[];   
     private Scalar mColorsHue[];   
     private Scalar mWhilte;   
     private Mat mSepiaKernel;   
        
     /**  
      * 通过OpenCV管理Android服务，异步初始化OpenCV  
      */   
     BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this) {   
         @Override   
         public void onManagerConnected(int status){   
             switch (status) {   
             case LoaderCallbackInterface.SUCCESS:   
                 Log.i(TAG,"OpenCV loaded successfully");   
                 mCVCamera.enableView();   
                 break;   
             default:   
                 break;   
             }   
         }   
     };   
        
     @Override   
     protected void onCreate(Bundle savedInstanceState) {   
         super.onCreate(savedInstanceState);   
         setContentView(R.layout.activity_main);   
            
         mCVCamera = (CameraBridgeViewBase) findViewById(R.id.camera_view);   
         mCVCamera.setCvCameraViewListener(this);   
            
         mButton = (Button) findViewById(R.id.deal_btn);   
         mButton.setOnClickListener(new OnClickListener(){   
             @Override   
             public void onClick(View v) {   
                 if(Cur_State<8){   
                     //切换状态   
                     Cur_State ++;   
                 }else{   
                     //恢复初始状态   
                     Cur_State = 0;   
                 }   
             }   
                
         });   
     }   
        
     @Override   
     public void onResume() {   
         super.onResume();   
         if (!OpenCVLoader.initDebug()) {   
             Log.d(TAG,"OpenCV library not found!");   
         } else {   
             Log.d(TAG, "OpenCV library found inside package. Using it!");   
             mLoaderCallback.onManagerConnected(LoaderCallbackInterface.SUCCESS);   
         }   
     };   
        
     @Override   
     public void onDestroy() {   
         if(mCVCamera!=null){   
             mCVCamera.disableView();   
         }   
     };   
    
     @Override   
     public void onCameraViewStarted(int width, int height) {   
         // TODO Auto-generated method stub   
         mRgba = new Mat(height, width, CvType.CV_8UC4);   
         mTmp = new Mat(height, width, CvType.CV_8UC4);   
            
         mIntermediateMat = new Mat();   
         mSize0 = new Size();   
         mChannels = new MatOfInt[] { new MatOfInt(0), new MatOfInt(1), new MatOfInt(2) };   
         mBuff = new float[mHistSizeNum];   
         mHistSize = new MatOfInt(mHistSizeNum);   
         mRanges = new MatOfFloat(0f, 256f);   
         mMat0 = new Mat();   
         mColorsRGB = new Scalar[] { new Scalar(200, 0, 0, 255), new Scalar(0, 200, 0, 255), new Scalar(0, 0, 200, 255) };   
         mColorsHue = new Scalar[] {   
                 new Scalar(255, 0, 0, 255), new Scalar(255, 60, 0, 255), new Scalar(255, 120, 0, 255), new Scalar(255, 180, 0, 255), new Scalar(255, 240, 0, 255),   
                 new Scalar(215, 213, 0, 255), new Scalar(150, 255, 0, 255), new Scalar(85, 255, 0, 255), new Scalar(20, 255, 0, 255), new Scalar(0, 255, 30, 255),   
                 new Scalar(0, 255, 85, 255), new Scalar(0, 255, 150, 255), new Scalar(0, 255, 215, 255), new Scalar(0, 234, 255, 255), new Scalar(0, 170, 255, 255),   
                 new Scalar(0, 120, 255, 255), new Scalar(0, 60, 255, 255), new Scalar(0, 0, 255, 255), new Scalar(64, 0, 255, 255), new Scalar(120, 0, 255, 255),   
                 new Scalar(180, 0, 255, 255), new Scalar(255, 0, 255, 255), new Scalar(255, 0, 215, 255), new Scalar(255, 0, 85, 255), new Scalar(255, 0, 0, 255)   
         };   
         mWhilte = Scalar.all(255);   
         mP1 = new Point();   
         mP2 = new Point();   
    
         // Fill sepia kernel   
         mSepiaKernel = new Mat(4, 4, CvType.CV_32F);   
         mSepiaKernel.put(0, 0, /* R */0.189f, 0.769f, 0.393f, 0f);   
         mSepiaKernel.put(1, 0, /* G */0.168f, 0.686f, 0.349f, 0f);   
         mSepiaKernel.put(2, 0, /* B */0.131f, 0.534f, 0.272f, 0f);   
         mSepiaKernel.put(3, 0, /* A */0.000f, 0.000f, 0.000f, 1f);   
     }   
        
     @Override   
     public void onCameraViewStopped() {   
         // TODO Auto-generated method stub   
         mRgba.release();   
         mTmp.release();   
     }   
        
     /**  
      * 图像处理都写在此处  
      */   
     @Override   
     public Mat onCameraFrame(CvCameraViewFrame inputFrame) {   
         mRgba = inputFrame.rgba();   
         Size sizeRgba = mRgba.size();   
         int rows = (int) sizeRgba.height;   
         int cols = (int) sizeRgba.width;   
         Mat rgbaInnerWindow;   
                
         int left = cols / 8;   
         int top = rows / 8;   
    
         int width = cols * 3 / 4;   
         int height = rows * 3 / 4;   
            
         switch (Cur_State) {   
         case 1:   
             //灰化处理   
             Imgproc.cvtColor(inputFrame.gray(), mRgba, Imgproc.COLOR_GRAY2RGBA,4);   
             break;   
         case 2:   
             //Canny边缘检测   
             mRgba = inputFrame.rgba();   
             Imgproc.Canny(inputFrame.gray(), mTmp, 80, 100);   
             Imgproc.cvtColor(mTmp, mRgba, Imgproc.COLOR_GRAY2RGBA, 4);   
             break;   
         case 3:   
             //Hist直方图计算   
             Mat hist = new Mat();   
             int thikness = (int) (sizeRgba.width / (mHistSizeNum + 10) / 5);   
             if(thikness > 5) thikness = 5;   
             int offset = (int) ((sizeRgba.width - (5*mHistSizeNum + 4*10)*thikness)/2);   
               
             // RGB   
             for(int c=0; c<3; c++) {   
                 Imgproc.calcHist(Arrays.asList(mRgba), mChannels[c], mMat0, hist, mHistSize, mRanges);   
                 Core.normalize(hist, hist, sizeRgba.height/2, 0, Core.NORM_INF);   
                 hist.get(0, 0, mBuff);   
                 for(int h=0; h<mHistSizeNum; h++) {   
                     mP1.x = mP2.x = offset + (c * (mHistSizeNum + 10) + h) * thikness;   
                     mP1.y = sizeRgba.height-1;   
                     mP2.y = mP1.y - 2 - (int)mBuff[h];   
                     Imgproc.line(mRgba, mP1, mP2, mColorsRGB[c], thikness);   
                 }   
             }   
             // Value and Hue   
             Imgproc.cvtColor(mRgba, mTmp, Imgproc.COLOR_RGB2HSV_FULL);   
             // Value   
             Imgproc.calcHist(Arrays.asList(mTmp), mChannels[2], mMat0, hist, mHistSize, mRanges);   
             Core.normalize(hist, hist, sizeRgba.height/2, 0, Core.NORM_INF);   
             hist.get(0, 0, mBuff);   
             for(int h=0; h<mHistSizeNum; h++) {   
                 mP1.x = mP2.x = offset + (3 * (mHistSizeNum + 10) + h) * thikness;   
                 mP1.y = sizeRgba.height-1;   
                 mP2.y = mP1.y - 2 - (int)mBuff[h];   
                 Imgproc.line(mRgba, mP1, mP2, mWhilte, thikness);   
             }   
             break;   
         case 4:   
             //Sobel边缘检测   
             Mat gray = inputFrame.gray();   
             Mat grayInnerWindow = gray.submat(top, top + height, left, left + width);   
             rgbaInnerWindow = mRgba.submat(top, top + height, left, left + width);   
             Imgproc.Sobel(grayInnerWindow, mIntermediateMat, CvType.CV_8U, 1, 1);   
             Core.convertScaleAbs(mIntermediateMat, mIntermediateMat, 10, 0);   
             Imgproc.cvtColor(mIntermediateMat, rgbaInnerWindow, Imgproc.COLOR_GRAY2BGRA, 4);   
             grayInnerWindow.release();   
             rgbaInnerWindow.release();   
             break;   
         case 5:   
             //SEPIA(色调变换)   
             rgbaInnerWindow = mRgba.submat(top, top + height, left, left + width);   
             Core.transform(rgbaInnerWindow, rgbaInnerWindow, mSepiaKernel);   
             rgbaInnerWindow.release();   
             break;   
         case 6:   
             //ZOOM放大镜   
             Mat zoomCorner = mRgba.submat(0, rows / 2 - rows / 10, 0, cols / 2 - cols / 10);   
             Mat mZoomWindow = mRgba.submat(rows / 2 - 9 * rows / 100, rows / 2 + 9 * rows / 100, cols / 2 - 9 * cols / 100, cols / 2 + 9 * cols / 100);   
             Imgproc.resize(mZoomWindow, zoomCorner, zoomCorner.size());   
             Size wsize = mZoomWindow.size();   
             Imgproc.rectangle(mZoomWindow, new Point(1, 1), new Point(wsize.width - 2, wsize.height - 2), new Scalar(255, 0, 0, 255), 2);   
             zoomCorner.release();   
             mZoomWindow.release();   
             break;   
         case 7:   
             //PIXELIZE像素化   
             rgbaInnerWindow = mRgba.submat(top, top + height, left, left + width);   
             Imgproc.resize(rgbaInnerWindow, mIntermediateMat, mSize0, 0.1, 0.1, Imgproc.INTER_NEAREST);   
             Imgproc.resize(mIntermediateMat, rgbaInnerWindow, rgbaInnerWindow.size(), 0., 0., Imgproc.INTER_NEAREST);   
             rgbaInnerWindow.release();   
             break;   
         default:   
             //显示原图   
             mRgba = inputFrame.rgba();   
             break;   
         }   
         //返回处理后的结果数据   
         return mRgba;   
     }   
 }   

2.效果图：

Canny边缘检测：

Hist直方图计算：

Sobel边缘检测：

SEPIA(色调变换)：

ZOOM放大镜：

PIXELIZE像素化：

微信关注我们

原文链接：https://yq.aliyun.com/articles/595125

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

bug -- android 7.0 popwindow显示位置异常情况解决

android 7.0 popwindow显示位置异常,在android7.1官方进行解决了，但是还是要多7.0的bug进行解决，我的解决方案里面通过重写popwindow进行适配： import android.content.Context; import android.os.Build; import android.util.AttributeSet; import android.view.Gravity; import android.view.View; import android.widget.PopupWindow; /** * 解决7.0 popwindow显示位置的问题 * Created by soyoungboy on 2017/3/16. */ public class FixPopWindow extends PopupWindow { public FixPopWindow() { } public FixPopWindow(View contentView) { super(contentView); } public FixPopWindow(V...

2017-03-17

518

Android OpenCv进行图片比对

摘要：OpenCv 对于图片有很多的处理方式，现在我想要实现俩张图片的比对。首先要知道做个需要那些步骤：（1）加载俩张图片（2）将两张图片转换为Mat矩阵（3）把Mat矩阵的type转换为Cv_8uc1类型，然后转换为Cv_32F，因为在c++代码中会判断他的类型。 OpenCv 对于图片有很多的处理方式，现在我想要实现俩张图片的比对。首先要知道做个需要那些步骤：（1）加载俩张图片（2）将两张图片转换为Mat矩阵（3）把Mat矩阵的type转换为Cv_8uc1类型，然后转换为Cv_32F，因为在c++代码中会判断他的类型。（4）通过OpenCv 来进行俩个矩阵的比较（俩个矩阵必须一样大小的高宽）我使用的比较类型是Imgproc.CV_COMP_CORREL， double target = Imgproc.compareHist(mat, mat2, Imgproc.CV_COMP_CORREL); 这个target的值越大那么也就是说相似度越高，如果完全一样就是1.0 。效果图：思路就是这样，看看代码的实现： package com.example.o...

2017-03-17

695

发表评论

资源下载

更多资源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。