在Android studio 中使用opencv，不用安装手机上的opencv。附上opencv调用摄像头并处理图像的例程。

最新推荐文章于 2022-07-06 16:34:47 发布
最新推荐文章于 2022-07-06 16:34:47 发布
阅读量978 收藏 9
点赞数 2
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XHL_CSDN_DOW/article/details/107206354
版权

1.首先，导入opencv for android
请参考这篇文章：导入opencv包
链接：https://blog.csdn.net/qq_39321542/article/details/106080136
2.将opencv实例化
需要在程序的最前面加上：

private BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this) {
      	  @Override
      	  public void onManagerConnected(int status) {
       	     switch(status){
        	        case LoaderCallbackInterface.SUCCESS:
         	       {
            	        Log.d(TAG,"OpenCV loaded successfully");//打印日志，TAG定义为String
            	        mOpenCvCameraView.enableView();//可替换为自己的函数，不必须
           	     }break;
             	   default:
              	  {
               	     super.onManagerConnected(status);
             	   }break;
          	  }
       	 }
   	 };

需要重点说明的是，如果直接复制这段代码，手机依然显示让你安装opencv，可能需要自己抄写这段代码。（我就遇到过这种问题）
这些程序请自己选择需要的
1.AndroidManifest.xml文件

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="com.example.opencvtest"
>

    <application
        android:label="@string/app_name"
        android:icon="@drawable/icon">
<!--强制横屏显示,捕获手机状态，“keyboardHidden“ 用户打开手机硬件键盘，“orientation“ 设备旋转，横向显示和竖向显示模式切换。-->
        <activity android:name="ImageManipulationsActivity"
                  android:label="@string/app_name"
                  android:screenOrientation="landscape"
                  android:configChanges="keyboardHidden|orientation">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

    <supports-screens android:resizeable="true"
                      android:smallScreens="true"
                      android:normalScreens="true"
                      android:largeScreens="true"
                      android:anyDensity="true" />

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

    <uses-feature android:name="android.hardware.camera" android:required="false"/>
    <uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
    <uses-feature android:name="android.hardware.camera.front" android:required="false"/>
    <uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>

</manifest>

2.布局文件（image_manipulations_surface_view.xml）

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    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/image_manipulations_activity_surface_view" />

</LinearLayout>

public class ImageManipulationsActivity extends CameraActivity implements CvCameraViewListener2 {
    private static final String  TAG                 = "OCVSample::Activity";

    public static final int      VIEW_MODE_RGBA      = 0;//彩图
    public static final int      VIEW_MODE_HIST      = 1;//显示具体颜色比例
    public static final int      VIEW_MODE_CANNY     = 2;//黑色边缘
    public static final int      VIEW_MODE_SEPIA     = 3;//褐色
    public static final int      VIEW_MODE_SOBEL     = 4;//黑色虚化
    public static final int      VIEW_MODE_ZOOM      = 5;//小框显示
    public static final int      VIEW_MODE_PIXELIZE  = 6;//模糊
    public static final int      VIEW_MODE_POSTERIZE = 7;//细微模糊

    private MenuItem             mItemPreviewRGBA;
    private MenuItem             mItemPreviewHist;
    private MenuItem             mItemPreviewCanny;
    private MenuItem             mItemPreviewSepia;
    private MenuItem             mItemPreviewSobel;
    private MenuItem             mItemPreviewZoom;
    private MenuItem             mItemPreviewPixelize;
    private MenuItem             mItemPreviewPosterize;
    private CameraBridgeViewBase mOpenCvCameraView;//定义显示图片变量

    private Size                 mSize0;//函数

    private Mat                  mIntermediateMat;
    private Mat                  mMat0;
    private MatOfInt             mChannels[];//opencv.core。类
    private MatOfInt             mHistSize;
    private int                  mHistSizeNum = 25;//
    private MatOfFloat           mRanges;
    private Scalar               mColorsRGB[];//颜色变量
    private Scalar               mColorsHue[];
    private Scalar               mWhilte;
    private Point                mP1;
    private Point                mP2;
    private float                mBuff[];
    private Mat                  mSepiaKernel;

    public static int           viewMode = VIEW_MODE_RGBA;//相机模式
//实例化opencv，必须要有。为了支持opencv与app相互作用
    private BaseLoaderCallback  mLoaderCallback = new BaseLoaderCallback(this) {
        @Override
        public void onManagerConnected(int status) {
            switch (status) {
                case LoaderCallbackInterface.SUCCESS:
                {
                    Log.i(TAG, "OpenCV loaded successfully");
                    mOpenCvCameraView.enableView();
                } break;
                default:
                {
                    super.onManagerConnected(status);
                } break;
            }
        }
    };
//主函数
    public ImageManipulationsActivity() {
        Log.i(TAG, "Instantiated new " + this.getClass());
    }

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        Log.i(TAG, "called onCreate");
        super.onCreate(savedInstanceState);
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);//设置窗体始终点亮，不熄屏

        setContentView(R.layout.image_manipulations_surface_view);

        mOpenCvCameraView = (CameraBridgeViewBase) findViewById(R.id.image_manipulations_activity_surface_view);
        mOpenCvCameraView.setVisibility(CameraBridgeViewBase.VISIBLE);
        mOpenCvCameraView.setCvCameraViewListener(this);//设置界面监听
    }
//当活动停止时调用该函数，也就是系统去调用另一个活动
    @Override
    public void onPause()
    {
        super.onPause();
        if (mOpenCvCameraView != null)
            mOpenCvCameraView.disableView();
    }
//当活动准备好与用户进行交互时调用，此时活动位于栈顶，并处于运行状态
    @Override
    public void onResume()
    {
        super.onResume();
        if (!OpenCVLoader.initDebug()) {
            Log.d(TAG, "Internal OpenCV library not found. Using OpenCV Manager for initialization");
            OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_3_0_0, this, mLoaderCallback);
        } else {
            Log.d(TAG, "OpenCV library found inside package. Using it!");
            mLoaderCallback.onManagerConnected(LoaderCallbackInterface.SUCCESS);
        }
    }
//用来接受系统的view列表
    @Override
    protected List<? extends CameraBridgeViewBase> getCameraViewList() {
        return Collections.singletonList(mOpenCvCameraView);
    }
//在活动被销毁前调用
    public void onDestroy() {
        super.onDestroy();
        if (mOpenCvCameraView != null)
            mOpenCvCameraView.disableView();
    }
//创建选项
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        Log.i(TAG, "called onCreateOptionsMenu");
        mItemPreviewRGBA  = menu.add("Preview RGBA");
        mItemPreviewHist  = menu.add("Histograms");
        mItemPreviewCanny = menu.add("Canny");
        mItemPreviewSepia = menu.add("Sepia");
        mItemPreviewSobel = menu.add("Sobel");
        mItemPreviewZoom  = menu.add("Zoom");
        mItemPreviewPixelize  = menu.add("Pixelize");
        mItemPreviewPosterize = menu.add("Posterize");
        return true;
    }
//监控选项卡
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        Log.i(TAG, "called onOptionsItemSelected; selected item: " + item);
        if (item == mItemPreviewRGBA)
            viewMode = VIEW_MODE_RGBA;
        if (item == mItemPreviewHist)
            viewMode = VIEW_MODE_HIST;
        else if (item == mItemPreviewCanny)
            viewMode = VIEW_MODE_CANNY;
        else if (item == mItemPreviewSepia)
            viewMode = VIEW_MODE_SEPIA;
        else if (item == mItemPreviewSobel)
            viewMode = VIEW_MODE_SOBEL;
        else if (item == mItemPreviewZoom)
            viewMode = VIEW_MODE_ZOOM;
        else if (item == mItemPreviewPixelize)
            viewMode = VIEW_MODE_PIXELIZE;
        else if (item == mItemPreviewPosterize)
            viewMode = VIEW_MODE_POSTERIZE;
        return true;
    }
//当界面准备好交互时调用该函数，完成初始化给变量分配空间
    public void onCameraViewStarted(int width, int height) {
        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);
    }
//当摄像头停止时调用，释放空间
    public void onCameraViewStopped() {
        // Explicitly deallocate Mats
        if (mIntermediateMat != null)
            mIntermediateMat.release();

        mIntermediateMat = null;
    }
//在回调中调用这个函数，用于处理图片
    public Mat onCameraFrame(CvCameraViewFrame inputFrame) {
        Mat rgba = inputFrame.rgba();//图像转为这个
        Size sizeRgba = rgba.size();//得到图像的尺寸

        Mat rgbaInnerWindow;

        int rows = (int) sizeRgba.height;//得到图像的高
        int cols = (int) sizeRgba.width;//宽

        int left = cols / 8;
        int top = rows / 8;

        int width = cols * 3 / 4;
        int height = rows * 3 / 4;

        switch (ImageManipulationsActivity.viewMode) {
        case ImageManipulationsActivity.VIEW_MODE_RGBA://显示原图
            break;

        case ImageManipulationsActivity.VIEW_MODE_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(rgba), 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(rgba, mP1, mP2, mColorsRGB[c], thikness);//画图
                }
            }
            // Value and Hue
            Imgproc.cvtColor(rgba, mIntermediateMat, Imgproc.COLOR_RGB2HSV_FULL);//设置颜色
            // Value
            Imgproc.calcHist(Arrays.asList(mIntermediateMat), 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(rgba, mP1, mP2, mWhilte, thikness);
            }
            // Hue
            Imgproc.calcHist(Arrays.asList(mIntermediateMat), mChannels[0], 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 + (4 * (mHistSizeNum + 10) + h) * thikness;
                mP1.y = sizeRgba.height-1;
                mP2.y = mP1.y - 2 - (int)mBuff[h];
                Imgproc.line(rgba, mP1, mP2, mColorsHue[h], thikness);
            }
            break;

        case ImageManipulationsActivity.VIEW_MODE_CANNY://黑色边缘
            rgbaInnerWindow = rgba.submat(top, top + height, left, left + width);
            Imgproc.Canny(rgbaInnerWindow, mIntermediateMat, 80, 90);
            Imgproc.cvtColor(mIntermediateMat, rgbaInnerWindow, Imgproc.COLOR_GRAY2BGRA, 4);
            rgbaInnerWindow.release();
            break;

        case ImageManipulationsActivity.VIEW_MODE_SOBEL://黑色虚化
            Mat gray = inputFrame.gray();
            Mat grayInnerWindow = gray.submat(top, top + height, left, left + width);
            rgbaInnerWindow = rgba.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 ImageManipulationsActivity.VIEW_MODE_SEPIA://图片为褐色，复古
            rgbaInnerWindow = rgba.submat(top, top + height, left, left + width);
            Core.transform(rgbaInnerWindow, rgbaInnerWindow, mSepiaKernel);
            rgbaInnerWindow.release();
            break;

        case ImageManipulationsActivity.VIEW_MODE_ZOOM://加上一个小框显示
            Mat zoomCorner = rgba.submat(0, rows / 2 - rows / 10, 0, cols / 2 - cols / 10);
            Mat mZoomWindow = rgba.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(), 0, 0, Imgproc.INTER_LINEAR_EXACT);
            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 ImageManipulationsActivity.VIEW_MODE_PIXELIZE://模糊图像
            rgbaInnerWindow = rgba.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;

        case ImageManipulationsActivity.VIEW_MODE_POSTERIZE://细微的模糊图像
            /*
            Imgproc.cvtColor(rgbaInnerWindow, mIntermediateMat, Imgproc.COLOR_RGBA2RGB);
            Imgproc.pyrMeanShiftFiltering(mIntermediateMat, mIntermediateMat, 5, 50);
            Imgproc.cvtColor(mIntermediateMat, rgbaInnerWindow, Imgproc.COLOR_RGB2RGBA);
            */
            rgbaInnerWindow = rgba.submat(top, top + height, left, left + width);
            Imgproc.Canny(rgbaInnerWindow, mIntermediateMat, 80, 90);
            rgbaInnerWindow.setTo(new Scalar(0, 0, 0, 255), mIntermediateMat);
            Core.convertScaleAbs(rgbaInnerWindow, mIntermediateMat, 1./16, 0);
            Core.convertScaleAbs(mIntermediateMat, rgbaInnerWindow, 16, 0);
            rgbaInnerWindow.release();
            break;
        }

        return rgba;
    }
}
student_xhl
关注
Python调用OpenCV打开电脑摄像头进行实时显示
走向CTO的路上...
05-28 1031
OpenCV是一个开源计算机视觉库，可以用于图像处理、视频分析、机器学习等。Python可以通过cv2模块调用OpenCV函数。查看摄像头画面捕捉图像录制视频进行简单的图像处理Python调用OpenCV打开电脑摄像头进行实时显示，可以实现多种功能，并具有广泛的应用场景。
Android Studio使用opencv打开摄像头.java以及.xml
05-14
本资源只包含两个重要文件，活动文件与界面文件，包含使用opencv打开摄像头部分，而且解决使用opencv打开摄像头会旋转90度的问题，解决办法仅供参考。
Android studio 使用opencv打开手机摄像头
XHL_CSDN_DOW的博客
07-08 1453
1.导入opencv,请参考导入opencv 2.在class上extends CameraActivity implements CameraBridgeViewBase.CvCameraViewListener2 在这里一般会显示错误，将鼠标移动到错误的波浪线上，ALT+Enter，导入三个方法， 3.onCameraViewStarted方法，在这里初始化一些变量 4.onCameraViewStopped，在这里释放一些内存资源。 5.onCameraFrame，在这里对摄像头的图像进行处理，函数自
安卓opencv图像处理
08-24
本资源里的工程文件是使用安卓利用opencv实现灰度化、二值化、边缘提取等功能。里面包含代码，安装后，点击菜单键进行选择。
Android Studio使用Opencv实现图像的实时处理
xuanwo11的博客
07-11 1万+
OpenCV是著名的跨平台计算机视觉开源库，广泛应用于计算机视觉相关领域。OpenCV 已经发布 Android 平台下的 SDK，可以直接导入 android Studio。Opencv移植进Android平台可以在移动端实现图像的处理，目标的识别等功能，具有良好的开发前景。 一.开发准备 第一步主要是搭好开发环境，将Opencv导入到Android Studio，可以直接在Andr
openCV集成到android，调用摄像头
02-08
讲android和opencv合拼一个项目，编译后的项目无需下载opencv。
Android和Windows下，使用 OpenCV 4.8 实现人脸识别 示例 Demo
最新发布
08-09
faceDetection.apk : 基于MyOpenCVTest打的apk包，可以直接安装到Android手机上，体验人脸识别功能 资料文件夹 : 搜集了一些和OpenCV相关的PDF资料，一并放在该资源中 - OPENCV函数手册(带目录).pdf - OpenCV例程...
如何在Android上使用OpenCV进行摄像头标定
花草的博客
07-06 3116
如何在Android上使用OpenCV进行摄像头标定，我们这里使用官方一个例程，其实并不难，只是网上的资料少了而已。相机标定是计算机视觉工作的前提，为了确定相机矩阵和畸变参数。
android下的openCV人脸检测使用例程
11-16
在Android项目中使用OpenCV，首先需要在Android Studio中添加OpenCV的SDK依赖。这通常通过在build.gradle文件中引入OpenCV的AAR库完成，然后同步项目以加载库。 2. **初始化OpenCV** 在Android应用启动时，需要...
Opencv4.3.0+android studio3.6.1运行打开摄像头示例
langzaitianya1的博客
04-21 1678
写在前面：opencv的demo都是基于eclipse开发环境来演示opencv功能的，还不是基于Android studio来演示。 参考链接：https://blog.csdn.net/weixin_43815930/article/details/90516455 https://blog.csdn.net/sakurakider/article/details/80470358 https...
Android 调用外接摄像头
08-06
适合开发需要开发外接摄像头的，可以实现拍照、录像以及上下转动摄像头。
2021.OpenCV+android studio(SDK方式)实现人脸检测+人脸区域自动截图保存
02-08
2021.OpenCV+android studio(SDK方式)实现人脸检测+人脸区域自动截图保存
OpenCV学习笔记（六）—— OpenCV for Android打开相机
热门推荐
linshuhe1的专栏
04-20 1万+
在之前的篇章中，我们完成了Android平台开发环境的配置，也找到了剔除OpenCV Manager API的办法，那么接下来我们开始从零开始，完成一个个人的程序，实现功能如下：         1.识别指定的图片，并用彩色框绘制图片边缘         2.在识别的图片上显示一个3D的模型         不难看出，这实际上就是AR最初步的功能，当然要完成这个功能却需要完成很多事情，步骤：
android摄像头 opencv,OpenCV 2.3：如何从Android摄像头捕获帧？
weixin_39719101的博客
05-27 188
我试图在Android上使用新的OpenCV功能：原生摄像头访问。根据this文件，这很容易，但我只会得到没有成功的错误。有DDMS日志：08-26 03:28:56.825: DEBUG/CAMERA_ACTIVITY(12613): Library name: libopencv_java.so08-26 03:28:56.825: DEBUG/CAMERA_ACTIVITY(12613): ...
opencv获取外接摄像头_【实时手势识别学习笔记1】使用OpenCV调用摄像头获取数据集（上）...
weixin_31556371的博客
12-24 482
今天是2008年5月12日汶川大地震10周年，逝者安息。在完成了环境搭建(具体请翻阅实时手势识别学习笔记第0篇)后，就可以着手搭建学习框架咯。不过由于我们组决定实现的是手语教学，所以需要让机器学习很多的我们自定义的手势，显然这个很难通过从网络获得的数据实现，因此我们有必要通过自己的摄像头来获取手势。同时，因为要拍摄用户的手势，同样要用到摄像头，总之，我们选择了OpenCV框架来帮我们实现这个功能。...
Android Studio3.3.2 +OpenCV3.4.3图像处理
不唐
04-26 1872
1 前言 大学一门课需要在Android Studio中配置OpenCV，感谢博主们的无私分享，将学习记录于此，文末有列出学习链接和demo源码。如果你也想在Android Studio中配置OpenCV，本文或许会给你帮助，来自小白的感谢。 2 开发环境 Android Studio 3.3.2 OpenCV for Android 3.4.3 Windows 10 Enterprise 64...
Android studio3.4.1基于OpenCV库（4.1.0）中的demo打开手机摄像头
weixin_39800738的博客
09-26 1200
Android studio联合OpenCV打开摄像头有许多博客可供参考，我自己也看了许多篇，或许本人笨拙，迟迟没成功，于是决定有朝一日我成功了，一定要记录下来。下面转载两篇我自己看后做成功的链接：[使用OpenCV库中的demo](https://www.jianshu.com/p/c74c64cda4ad) [因为我的手机安卓版本是7.0，需要添加动态权限，假如大家的版本号低于6.0就无需添加...
安卓图像处理（一）OpenCV环境以及处理
行走
12-01 409
安卓图像处理，使用Open CV
【OpenCV for Android】（二）相机的使用— —实时视频预览、拍照和相册读取
Jarvis_lele的博客
04-22 2187
package gloomyfish.opencvdemo; import android.content.Intent; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.net.Uri; import android.os.Bundle; import android.p...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值