Android 开发 打包OpenCV Manager包

最新推荐文章于 2022-02-16 16:00:18 发布
最新推荐文章于 2022-02-16 16:00:18 发布
阅读量1k 收藏
点赞数
分类专栏： Machine Vision Image Algorithm 文章标签： android opencv Manager
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/forest_world/article/details/53005275
版权

转载请注明：http://blog.csdn.net/forest_world
Android.mk

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

OPENCV_CAMERA_MODULES:=on
OPENCV_INSTALL_MODULES:=on
OPENCV_LIB_TYPE:=SHARED
include ../../sdk/native/jni/OpenCV.mk

LOCAL_SRC_FILES  := DetectionBasedTracker_jni.cpp
LOCAL_C_INCLUDES += $(LOCAL_PATH)
LOCAL_LDLIBS     += -llog -ldl

LOCAL_MODULE     := detection_based_tracker

include $(BUILD_SHARED_LIBRARY)

#OpenCV_CAMERA_MODULES:=on
#OpenCV_INSTALL_MODULES:=on
#OpenCV_LIB_TYPE:=SHARED
#include ${OpenCVROOT}/sdk/native/jni/OpenCV.mk

FdActivity.java

package org.opencv.samples.facedetect;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;

import org.opencv.android.BaseLoaderCallback;
import org.opencv.android.CameraBridgeViewBase.CvCameraViewFrame;
import org.opencv.android.LoaderCallbackInterface;
import org.opencv.android.OpenCVLoader;
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfRect;
import org.opencv.core.Point;
import org.opencv.core.Rect;
import org.opencv.core.Scalar;
import org.opencv.core.Size;
import org.opencv.android.CameraBridgeViewBase;
import org.opencv.android.CameraBridgeViewBase.CvCameraViewListener2;
import org.opencv.objdetect.CascadeClassifier;

import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.WindowManager;

//import java.text.SimpleDateFormat;
import java.util.*;

//#define CV_FILLED -1
public class FdActivity extends Activity implements CvCameraViewListener2 {

    private static final String    TAG                 = "OCVSample::Activity";
    private static final Scalar    FACE_RECT_COLOR     = new Scalar(0, 255, 0, 255);

    private static final Scalar    green_COLOR     = new Scalar(0, 139, 69, 255); 

    private static final Scalar    blue_COLOR     = new Scalar(0, 0, 255, 255);
    private static final Scalar    yellow_COLOR     = new Scalar(238, 238, 0, 255);
    private static final Scalar    orange_COLOR     = new Scalar(0, 153, 255, 255);
    private static final Scalar    red_COLOR     = new Scalar(255, 0, 0, 255);

    public static final int        JAVA_DETECTOR       = 0;
    public static final int        NATIVE_DETECTOR     = 1;

    public int                    count   = 0;



    private MenuItem               mItemFace50;
    private MenuItem               mItemFace40;
    private MenuItem               mItemFace30;
    private MenuItem               mItemFace20;
    private MenuItem               mItemType;

    private Mat                    mRgba;
    private Mat                    mGray;
    private File                   mCascadeFile;
    private CascadeClassifier      mJavaDetector;
    private DetectionBasedTracker  mNativeDetector;

    private int                    mDetectorType       = JAVA_DETECTOR;
    private String[]               mDetectorName;

    private float                  mRelativeFaceSize   = 0.2f;
    private int                    mAbsoluteFaceSize   = 0;

    private CameraBridgeViewBase   mOpenCvCameraView;

    private BaseLoaderCallback  mLoaderCallback = new BaseLoaderCallback(this) {
        @Override
        public void onManagerConnected(int status) {
            switch (status) {
                case LoaderCallbackInterface.SUCCESS:
                {

                    Log.i(TAG,"OpenCV library load!");
                    if (!OpenCVLoader.initDebug()) {
                        Log.i(TAG,"OpenCV load not successfully");
                    } else {
                        System.loadLibrary("detection_based_tracker");// load other libraries
                    }




                    /
                    Log.i(TAG, "OpenCV loaded successfully");

                    // Load native library after(!) OpenCV initialization
                    System.loadLibrary("detection_based_tracker");

                    try {
                        // load cascade file from application resources
                        InputStream is = getResources().openRawResource(R.raw.palm/*lbpcascade_frontalface*/);
                        File cascadeDir = getDir("cascade", Context.MODE_PRIVATE);
                        mCascadeFile = new File(cascadeDir, "cascade.dat"/*"lbpcascade_frontalface.xml"*/);
                        FileOutputStream os = new FileOutputStream(mCascadeFile);

                        byte[] buffer = new byte[4096];
                        int bytesRead;
                        while ((bytesRead = is.read(buffer)) != -1) {
                            os.write(buffer, 0, bytesRead);
                        }
                        is.close();
                        os.close();

                        mJavaDetector = new CascadeClassifier(mCascadeFile.getAbsolutePath());
                        if (mJavaDetector.empty()) {
                            Log.e(TAG, "Failed to load cascade classifier");
                            mJavaDetector = null;
                        } else
                            Log.i(TAG, "Loaded cascade classifier from " + mCascadeFile.getAbsolutePath());

                        mNativeDetector = new DetectionBasedTracker(mCascadeFile.getAbsolutePath(), 0);

                        cascadeDir.delete();

                    } catch (IOException e) {
                        e.printStackTrace();
                        Log.e(TAG, "Failed to load cascade. Exception thrown: " + e);
                    }

                    mOpenCvCameraView.enableView();
                } break;
                default:
                {
                    super.onManagerConnected(status);
                } break;
            }
        }
    };


    static {
         Log.i(TAG,"OpenCV library load!");
         if (!OpenCVLoader.initDebug()) {
         Log.i(TAG,"OpenCV load not successfully");
         } else {
         System.loadLibrary("detection_based_tracker");// load other libraries
        }
        }



    public FdActivity() {
        mDetectorName = new String[2];
        mDetectorName[JAVA_DETECTOR] = "Java";
        mDetectorName[NATIVE_DETECTOR] = "Native (tracking)";

        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.face_detect_surface_view);


        // add start
        try {
            // load cascade file from application resources
            InputStream is = getResources().openRawResource(R.raw.lbpcascade_frontalface);
            File cascadeDir = getDir("cascade", Context.MODE_PRIVATE);
            mCascadeFile = new File(cascadeDir,"lbpcascade_frontalface.xml");
            FileOutputStream os = new FileOutputStream(mCascadeFile);

            byte[] buffer = new byte[4096];
            int bytesRead;
            while ((bytesRead = is.read(buffer)) != -1)
            {
                os.write(buffer, 0, bytesRead);
            }
            is.close();
            os.close();

            mJavaDetector = new CascadeClassifier(mCascadeFile.getAbsolutePath());
            if (mJavaDetector.empty()) 
            {
                Log.e(TAG,"Failed to load cascade classifier");
                mJavaDetector = null;
            } 
            else
                Log.i(TAG,"Loaded cascade classifier from"+ mCascadeFile.getAbsolutePath());

            mNativeDetector = new DetectionBasedTracker(mCascadeFile.getAbsolutePath(), 0);

            cascadeDir.delete();

        } 
        catch (IOException e)
        {
            e.printStackTrace();
            Log.e(TAG,"Failed to load cascade. Exception thrown:"+ e);
        }
        //add end


        mOpenCvCameraView = (CameraBridgeViewBase) findViewById(R.id.fd_activity_surface_view);
        mOpenCvCameraView.setCvCameraViewListener(this);
        mOpenCvCameraView.enableView();// add.
        //mOpenCvCameraView.setCameraIndex(CameraBridgeViewBase.CAMERA_ID_FRONT);//前置摄像头 CameraBridgeViewBase.CAMERA_ID_BACK为后置摄像头
        mOpenCvCameraView.setCvCameraViewListener(this);

    }

    @Override
    public void onPause()
    {
        super.onPause();
        if (mOpenCvCameraView != null)
            mOpenCvCameraView.disableView();
    }

    @Override
    public void onResume()
    {
        super.onResume();
        //OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_3, this, mLoaderCallback);
    }

    public void onDestroy() {
        super.onDestroy();
        mOpenCvCameraView.disableView();
    }

    public void onCameraViewStarted(int width, int height) {
        mGray = new Mat();
        mRgba = new Mat();
    }

    public void onCameraViewStopped() {
        mGray.release();
        mRgba.release();
    }


    public int min(int a, int b) {
        if(a<=b)
            return a;
        else
            return b;
    }

    public int max(int a, int b) {
        if(a>=b)
            return a;
        else
            return b;
    }


    public float bbOverlap(Rect facesArray1 ,Rect facesArray2)
    {
      if (facesArray1.x > facesArray2.x+facesArray2.width) 
      { return 0; }
      if (facesArray1.y > facesArray2.y+facesArray2.height) 
      { return 0; }
      if (facesArray1.x+facesArray1.width < facesArray2.x) 
      { return 0; }
      if (facesArray1.y+facesArray1.height < facesArray2.y) 
      { return 0; }
      float colInt =  min(facesArray1.x+facesArray1.width,facesArray2.x+facesArray2.width) - 
              max(facesArray1.x, facesArray2.x);
      float rowInt =  min(facesArray1.y+facesArray1.height,facesArray2.y+facesArray2.height) - 
              max(facesArray1.y,facesArray2.y);
      float intersection = colInt * rowInt;
      float area1 = facesArray1.width*facesArray1.height;
      float area2 = facesArray1.width*facesArray2.height;
      return intersection / (area1 + area2 - intersection);
    } 

    public Mat onCameraFrame(CvCameraViewFrame inputFrame) {

        mRgba = inputFrame.rgba();
        mGray = inputFrame.gray();

        if (mAbsoluteFaceSize == 0) {
            int height = mGray.rows();
            if (Math.round(height * mRelativeFaceSize) > 0) {
                mAbsoluteFaceSize = Math.round(height * mRelativeFaceSize);
            }
            mNativeDetector.setMinFaceSize(mAbsoluteFaceSize);
        }

        MatOfRect faces = new MatOfRect();

        //if (mDetectorType == JAVA_DETECTOR) {
            //if (mJavaDetector != null)
                mJavaDetector.detectMultiScale(mGray, faces, 1.1, 2, 2, // TODO: objdetect.CV_HAAR_SCALE_IMAGE
                        new Size(mAbsoluteFaceSize, mAbsoluteFaceSize), new Size());
        //}
        //else if (mDetectorType == NATIVE_DETECTOR) {
            //if (mNativeDetector != null)
                //mNativeDetector.detect(mGray, faces);
        //}
        //else {
        //    Log.e(TAG, "Detection method is not selected!");
        //}

        Rect[] facesArray = faces.toArray();

        for (int i = 0; i < facesArray.length-1; i++)
            for (int j = i+1; j < facesArray.length; j++)
            {
                if((facesArray[j].tl().x >=facesArray[i].tl().x)&&(facesArray[j].tl().y >=facesArray[i].tl().y)&&
                    (facesArray[j].br().x <=facesArray[i].br().x)&&(facesArray[j].br().x <=facesArray[i].br().x)    
                  )
                    {
                        facesArray[j].x = facesArray[j].y = facesArray[j].width = facesArray[j].height = 0;
                    }
                else if((facesArray[j].tl().x <=facesArray[i].tl().x)&&(facesArray[j].tl().y <=facesArray[i].tl().y)&&
                        (facesArray[j].br().x >=facesArray[i].br().x)&&(facesArray[j].br().x >=facesArray[i].br().x)    
                      )
                {
                    facesArray[i].x = facesArray[i].y = facesArray[i].width = facesArray[i].height = 0;
                }
                //if(bbOverlap(facesArray[i] ,facesArray[j]) > 0)
                //{
                //  facesArray[j].x = facesArray[j].y = facesArray[j].width = facesArray[j].height = 0;
                //  num++;
                //} 
            }

        int num = facesArray.length;
        for (int i = 0; i < facesArray.length-1; i++)   
        {
            if((facesArray[i].width == 0)&&(facesArray[i].height == 0))
            {
                for (int j = facesArray.length-1; j >= 0; j--)
                {
                    if((facesArray[j].width != 0)&&(facesArray[j].height != 0))
                    {
                        facesArray[i].x = facesArray[j].x; 
                        facesArray[i].y = facesArray[j].y; 
                        facesArray[i].width = facesArray[j].width; 
                        facesArray[i].height = facesArray[j].height;

                        facesArray[j].x = 0; 
                        facesArray[j].y = 0; 
                        facesArray[j].width = 0; 
                        facesArray[j].height = 0;
                        num--;
                    }
                }

            }   
        }

        Point point1 = new Point(60, 30);

        //Core.putText(mRgba,  text,  point1, fontFace, fontScale,  red_COLOR,4);
        for (int i = 0; i < /*facesArray.length*/num; i++)
        {
            Core.rectangle(mRgba, facesArray[i].tl(), facesArray[i].br(), red_COLOR, 5);

            Point p1_e = new Point(facesArray[i].tl().x, facesArray[i].tl().y + 0.9*mRgba.height()/10.);
            Point p2_e = new Point(facesArray[i].br().x, facesArray[i].tl().y + 3.1*mRgba.height()/10.);
            //Core.rectangle(mRgba, p1_e, p2_e,  green_COLOR, 5);

        }

        if(num > 0)
            count +=10;
        else if(num == 0)
            count -=2;


        Calendar c = Calendar.getInstance();
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH);
        int day = c.get(Calendar.DAY_OF_MONTH);
        int hour = c.get(Calendar.HOUR);
        int minute = c.get(Calendar.MINUTE);
        int second = c.get(Calendar.SECOND);

        Point point2 = new Point(1*mRgba.width()/8., 2*mRgba.height()/8.);
        Point point3 = new Point(1*mRgba.width()/8., 3*mRgba.height()/8.);
        Point point4 = new Point(1*mRgba.width()/8., 4*mRgba.height()/8.);

        Point p1_warning = new Point(2*mRgba.width()/8., 6*mRgba.height()/8.);
        Point p2_warning = new Point(6*mRgba.width()/8., 7*mRgba.height()/8.);
        //Core.rectangle(mRgba, p1_warning, p2_warning,  green_COLOR, -1);
        return mRgba;
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        Log.i(TAG, "called onCreateOptionsMenu");
        mItemFace50 = menu.add("Face size 50%");
        mItemFace40 = menu.add("Face size 40%");
        mItemFace30 = menu.add("Face size 30%");
        mItemFace20 = menu.add("Face size 20%");
        mItemType   = menu.add(mDetectorName[mDetectorType]);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        Log.i(TAG, "called onOptionsItemSelected; selected item: " + item);
        if (item == mItemFace50)
            setMinFaceSize(0.5f);
        else if (item == mItemFace40)
            setMinFaceSize(0.4f);
        else if (item == mItemFace30)
            setMinFaceSize(0.3f);
        else if (item == mItemFace20)
            setMinFaceSize(0.2f);
        else if (item == mItemType) {
            int tmpDetectorType = (mDetectorType + 1) % mDetectorName.length;
            item.setTitle(mDetectorName[tmpDetectorType]);
            setDetectorType(tmpDetectorType);
        }
        return true;
    }

    private void setMinFaceSize(float faceSize) {
        mRelativeFaceSize = faceSize;
        mAbsoluteFaceSize = 0;
    }

    private void setDetectorType(int type) {
        if (mDetectorType != type) {
            mDetectorType = type;

            if (type == NATIVE_DETECTOR) {
                Log.i(TAG, "Detection Based Tracker enabled");
                mNativeDetector.start();
            } else {
                Log.i(TAG, "Cascade detector enabled");
                mNativeDetector.stop();
            }
        }
    }
}

出现问题：Can’t load CascadeClassifier解决：
这里写图片描述

参考资料：
http://www.android100.org/html/201502/14/118706.html

cv.exp
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android中使用OpenCV（二），flutterplugin修改
m0_64319298的博客
11-25 1795
/** Helper class provides common initialization methods for OpenCV library. */ public class OpenCVLoader { /** OpenCV Library version 2.4.2. */ public static final String OPENCV_VERSION_2_4_2 = “2.4.2”; /** OpenCV Library version 2.4.3. */ public sta
opencv android 服务包,将 OpenCV 打包为 Android AAR
weixin_42653691的博客
05-25 792
8种机械键盘轴体对比本人程序员，要买一个写代码的键盘，请问红轴和茶轴怎么选？OpenCV(http://www.opencv.org)在 8 月 3 号发布了新版本 OpenCV 3.3，距离上个版本近十个月时间，现在还可以说 OpenCV 3.3 发布不久吧。将 OpenCV 打包编译为 AAR 可以将库与 APP 模块分离重用，不需要机器安装 OpenCV 库进程，也方便 OpenCV 版本...
opencv4android3.0,android-Opencv 3.0.0 OpenCVEngineInterface
weixin_33588445的博客
05-27 1514
我正在尝试在Android Studio IDE中安装opencv 3.0.0.但是每次导入“ org.opencv.engine.OpenCVEngineInterface”遇到此问题时,IDE都会给我4个错误,例如：Error:(7, 25) error: package org.opencv.engine does not existError:(47, 15) error: cannot ...
Android&OpenCv之Android程序加载OpenCv库（二）
baipeng298的专栏
04-15 2355
好的开始是成功的一半，在第一节中我总结了如何在Eclipse中创建开发带有OpenCv库的Android APP的环境的工作。 本节讲如何在Android程序中加载OpenCv库，以便后续开发工作中调用OpenCv提供的API的接口。 我们知道OpenCv库作为一个.so的库。在Android程序中我们一般是通过System.LoadLibrary（“xxx.so”)来加载.so库的。所以加载
OpenCV在Android上踩过的坑
dorytmx的博客
03-23 1494
最近一个新项目需要用的到人脸检测,想着之前见过opencv,就在网上找了配置教程,结果一直无法成功,鉴于网上的基本都是330版本,想着可能比较老,去官网下载了最新版(那个下载速度啊,真的是…)建议可以去github上面下载,我下的是3.4.0(为什么不是最新版呢?因为我下过了,不行,后面看到有人说不要下载最新版 ^ 笑哭^) 好了, 配置看上面的有人的文章就好了 万一有人的文章不进了呢,那我还是复制一下吧 导入modul 就常规的import module啊 选择下载的文件里面sdk 文件夹下面的 ja
OpenCV 人脸识别、图片相似度检测
未来很长，但我会努力的走下去。
09-11 4223
OpenCVCheck 项目地址：SOFTPOWER1991/OpenCVCheck 简介： OpenCV 人脸识别、图片相似度检测 更多：作者提 Bug 标签： OpenCV 人脸识别、图片相似度检测 检测任意两张图片的相似度思路 加载两张图片为 bitmap 进入内存 将内存中的两张图片 bitmap 转换为 Mat 矩阵(Mat 类是 OpenCV 最基本...
OpenCV Android开发中避免安装OpenCV Manager
wunghao8的专栏
08-27 1770
开发app过程中，运行前总提示要先安装OpenCV Manager，自己开发还好，
Opencv manager
04-12
标签 "OpenCV manager" 强调了这个资源与OpenCV库的管理和更新功能有关，对开发基于OpenCV的Android应用至关重要。 在实际开发中，Android开发者通常会遵循以下步骤来使用OpenCV Manager： 1. **集成SDK**：首先，...
OpenCV 2.4.10 Android Manager apk
01-09
自己想使用在安卓app上调用并使用OpenCV的库函数前，必须安装的管理app，我的理解是自己编写的调用了OpenCV库函数的app是不能打包OpenCV的原库的，所以手机里必须安装了原库，才能使用app中调用的OpenCV库函数。
Android配置Opencv
05-31
- **问题描述**：“OpenCvManager package was not found” - **解决方案**： - 原因：模拟器未安装OpenCVManager。 - 解决方法：从已下载的`Opencv_2.4.9_android_sdk`中找到`OpenCV_2.4.9_Manager_2.18_armeabi`...
已编译好的最新kafka-manager包
03-06
kafka-manager-1.3.3.16.zip，已编译好的最新版本kafka-manager包
OpenCV3.0之android开发需要用到的动态库
09-20
- **OpenCV Manager**: 早期的OpenCV版本推荐使用OpenCV Manager来动态下载和更新库，但现代开发中，通常建议将OpenCV库静态链接到你的应用中，以避免依赖外部服务。 - **Java Bindings**: OpenCV提供了Java API，...
opencv-3.4.13-android-sdk .zip
04-18
1. **SDK Manager**: 这是一个用于管理OpenCV库和其他Android开发工具的工具。你可以通过它来安装、更新或卸载OpenCV版本。 2. **Documentation**: 包含了OpenCV的API文档，对每个函数、类和方法进行了详细解释，是...
OpenCV4Android开发实录(2)： 使用OpenCV3.4.1库实现人脸检测
老蒋也疯狂
01-06 1万+
上一篇文章OpenCV4Android开发实录(1)：移植OpenCV3.3.0库到Android Studio大概介绍了下OpenCV库的基本情况，阐述了将OpenCV库移植到Android Studio项目中的具体步骤。本文将在此文的基础上，通过对OpenCV框架中的人脸检测模块做相应介绍，然后实现人脸检测功能。
opencv manager package was not found 解决办法
zjck1995的专栏
12-19 7720
从网上好不容易找到的一个方法 1 解压opencv sdk 压缩包 2 eclipse 导入 sdk，选择 sdk和其中一个sample ：15puzzle 导入 3 右键 项目15puzzle ， 选择 properties ，再找到android 选项，下方有个library add按钮，点击添加oencv libraray 2.4.11（这是我的sdk版本）,接着找到java b
openCV OpenCV Manager package was not found! Try to install it? 问题记录
豌豆的专栏
08-01 5377
首先说一点我用的是比较新的opencv版本。 回到正题，为啥会出现这个问题呢，先看几段代码。 @Override protected void onResume() { super.onResume(); if (!OpenCVLoader.initDebug()) { Log.d(TAG, "Internal OpenCV...
QT配置opencv并打包发布
mu_xing_的博客
02-16 3144
QT配置opencv并打包发布QT配置opencv（一）软件环境（二）配置OpenCV的MinGW版（三）配置CMake（四）编译 OpenCV（五）编译opencv常见错误（六）配置Qt中的OpenCV打包发布 QT配置opencv （一）软件环境 Windows10 QT-5.10.1 CMake-3.18.4 OpenCV-3.4.0（建议用3系列） （二）配置OpenCV的MinGW版 由于Opencv没有编译好的MinGW版，因此需要利用Cmake进行编译。 安装好后打开QtCreator，在工具
PackageManager解析
weifeng的博客
03-13 1万+
PackageManager：管理应用程序包功能： 安装，卸载应用 查询permission相关信息 查询Application相关信息(application，activity，receiver，service，provider及相应属性等） 查询已安装应用 增加，删除permission 清除用户数据、缓存，代码段等 使用方法：在Android中，为应用包的安装，删除各种操作服务的，是Packa
Gabor滤波器与特征提取
热门推荐
计算机视觉算法、工程、产品
03-18 2万+
一、Gabor滤波器 Gabor滤波器，最主要使用优势体现在对物体纹理特征的提取上。二维Gabor基函数能够很好地描述哺乳动物初级视觉系统中一对简单视觉神经元的感受野特性。随着小波变换和神经生理学的发展，Gabor变换逐渐演变成二维Gabor小波的形式。Gabor滤波器对于图像的亮度和对比度变化以及人脸姿态变化具有较强的健壮性，并且它表达的是对人脸识别最为有用的局部特征，故在计算机视觉及纹理分析中
OpenCVManager详解：Android设备上的库管理服务
OpenCVManager是Android平台上OpenCV应用开发的重要工具，它简化了库的管理和更新，提高了应用的稳定性和效率。通过理解和充分利用其提供的功能，开发者可以更好地利用OpenCV进行图像处理和计算机视觉相关的应用开发...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值