Android 利用OpenCV制作人脸检测APP

前言

本篇文章手把手教大家使用opencv来实现一个能在安卓手机上运行的人脸检测app。其实不仅仅是能检测人脸，还能检测鼻子，嘴巴，眼睛和耳朵。花了不少精力写这篇文章，希望点赞收藏关注。

无图无真相，先把app运行的结果给大家看看。

如上图所示，app运行后，点击“选择图片”，从手机中选择一张图片，然后点击“处理”，app会将人脸用矩形给框起来，同时把鼻子也给检测出来了。由于目的是给大家做演示，所以app设计得很简单，而且也只实现了检测人脸和鼻子，没有实现对其他五官的检测。而且这个app也只能检测很简单的图片，如果图片中背景太复杂就无法检测出人脸。

下面我将一步一步教大家如何实现上面的app！

第一步：下载并安装android studio

为了保证大家能下载到和我相同版本的android studio，我把安装包上传了到微云。地址是：https://share.weiyun.com/bhvowgc9

下载后，一路点击下一步就安装好了。当然，安装过程中要联网，所以可能会中途失败，如果失败了，重试几次，如果还是有问题，那么可能要开启vpn。

第二步：下载sdk tools

打开android studio后，点击“file”->“settings”

点击“appearance & behavior”->“system settings”->“android sdk”->“sdk tools”。

然后选中“ndk”和“cmake”，点击“ok”。下载这两个工具可能要花一点时间，如果失败了请重试或开启vpn。

第三步：新建一个android app项目

点击“file”->“new”->“new project”

选中“empty activity”，点击“next”

“language”选择“java”，minimum sdk选择“api 21”。点击“finish”

第四步：下载opencv

下载地址

下载后解压。

第五步：导入opencv

将opencv-4.5.4-android-sdk\opencv-android-sdk下面的sdk复制到你在第三步创建的android项目下面。就是第三步图中的d:\programming\myapplication下面。然后将sdk文件夹改名为opencvsdk。

选择“project”->“settings.gradle”。在文件中添加include ‘:opencvsdk'

选择“project”->“opencvsdk”->“build.gradle”。

将apply plugin: 'kotlin-android'改为//apply plugin: ‘kotlin-android'

将compilesdkversion和minsdkversion，targetsdkversion改为31，21，31。

点击“file”->“project structure”

点击“dependencies”->“app”->“+”->“module dependency”

选中“opencvsdk”，点击“ok”，以及母窗口的“ok”

在android项目文件夹的app\src里面创建一个新文件夹jnilibs，然后把opencv文件夹的opencv-4.5.4-android-sdk\opencv-android-sdk\sdk\native\staticlibs里面的东西都copy到jnilibs文件夹中。

。解压后，将下图中的文件都复制到项目文件夹的app\src\main\res\raw文件夹下。

第六步：添加代码

双击“project”->“app”-》“main”-》“res”下面的“activity_main.xml”。然后点击右上角的“code”。

然后将里面的代码都换成下面的代码

<?xml version="1.0" encoding="utf-8"?>
<linearlayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".mainactivity"
    android:orientation="vertical"
    >

    <button
        android:id="@+id/select_btn"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="选择图片" />
    <button
        android:id="@+id/process_btn"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="处理" />

    <imageview
        android:id="@+id/imageview"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

</linearlayout>

双击“project”->“app”-》“main”-》“java”-》“com.example…”下面的“mainactivity”。然后把里面的代码都换成下面的代码（保留原文件里的第一行代码）

import androidx.appcompat.app.appcompatactivity;

import android.os.bundle;

import android.content.intent;
import android.graphics.bitmap;
import android.graphics.bitmapfactory;
import android.net.uri;
import android.util.log;
import android.view.view;
import android.widget.button;
import android.widget.imageview;

import org.opencv.android.opencvloader;
import org.opencv.android.utils;
import org.opencv.core.cvtype;
import org.opencv.core.mat;
import org.opencv.core.point;
import org.opencv.imgproc.imgproc;

import java.io.file;
import java.io.fileoutputstream;
import java.io.ioexception;
import java.io.inputstream;

import org.opencv.core.matofrect;
import org.opencv.core.rect;
import org.opencv.core.scalar;
import org.opencv.core.size;
import org.opencv.objdetect.cascadeclassifier;

import android.content.context;

public class mainactivity extends appcompatactivity {

    private double max_size = 1024;
    private int pick_image_request = 1;
    private imageview myimageview;
    private bitmap selectbp;

    private static final string    tag                 = "ocvsample::activity";
    private static final scalar    face_rect_color     = new scalar(0, 255, 0, 255);
    public static final int        java_detector       = 0;
    public static final int        native_detector     = 1;

    private mat                    mgray;
    private file                   mcascadefile;
    private cascadeclassifier      mjavadetector,mnosedetector;

    private int                    mdetectortype       = java_detector;

    private float                  mrelativefacesize   = 0.2f;
    private int                    mabsolutefacesize   = 0;

    @override
    protected void oncreate(bundle savedinstancestate) {
        super.oncreate(savedinstancestate);
        setcontentview(r.layout.activity_main);
        staticloadcvlibraries();
        myimageview = (imageview)findviewbyid(r.id.imageview);
        myimageview.setscaletype(imageview.scaletype.fit_center);
        button selectimagebtn = (button)findviewbyid(r.id.select_btn);
        selectimagebtn.setonclicklistener(new view.onclicklistener() {
            @override
            public void onclick(view v) {
                // maketext(mainactivity.this.getapplicationcontext(), "start to browser image", toast.length_short).show();
                selectimage();
            }

            private void selectimage() {
                intent intent = new intent();
                intent.settype("image/*");
                intent.setaction(intent.action_get_content);
                startactivityforresult(intent.createchooser(intent,"选择图像..."), pick_image_request);
            }
        });

        button processbtn = (button)findviewbyid(r.id.process_btn);
        processbtn.setonclicklistener(new view.onclicklistener() {
            @override
            public void onclick(view v) {
                // maketext(mainactivity.this.getapplicationcontext(), "hello, image process", toast.length_short).show();
                convertgray();
            }
        });

    }

    private void staticloadcvlibraries() {
        boolean load = opencvloader.initdebug();
        if(load) {
            log.i("cv", "open cv libraries loaded...");
        }

    }

    private void convertgray() {
        mat src = new mat();
        mat temp = new mat();
        mat dst = new mat();
        utils.bitmaptomat(selectbp, src);
        imgproc.cvtcolor(src, temp, imgproc.color_bgra2bgr);
        log.i("cv", "image type:" + (temp.type() == cvtype.cv_8uc3));
        imgproc.cvtcolor(temp, dst, imgproc.color_bgr2gray);
        utils.mattobitmap(dst, selectbp);
        myimageview.setimagebitmap(selectbp);

        mgray = dst;
        mjavadetector = loaddetector(r.raw.lbpcascade_frontalface,"lbpcascade_frontalface.xml");
        mnosedetector = loaddetector(r.raw.haarcascade_mcs_nose,"haarcascade_mcs_nose.xml");

        if (mabsolutefacesize == 0) {
            int height = mgray.rows();
            if (math.round(height * mrelativefacesize) > 0) {
                mabsolutefacesize = math.round(height * mrelativefacesize);
            }
        }

        matofrect faces = new matofrect();

        if (mjavadetector != null) {
            mjavadetector.detectmultiscale(mgray, faces, 1.1, 2, 2, // todo: objdetect.cv_haar_scale_image
                        new size(mabsolutefacesize, mabsolutefacesize), new size());

        }

        rect[] facesarray = faces.toarray();
        for (int i = 0; i < facesarray.length; i++) {

            log.e(tag, "start to detect nose!");

            mat faceroi = mgray.submat(facesarray[i]);

            matofrect noses = new matofrect();
            mnosedetector.detectmultiscale(faceroi, noses, 1.1, 2, 2,
                    new size(30, 30));

            rect[] nosesarray = noses.toarray();
            imgproc.rectangle(src,
                    new point(facesarray[i].tl().x + nosesarray[0].tl().x, facesarray[i].tl().y + nosesarray[0].tl().y) ,
                    new point(facesarray[i].tl().x + nosesarray[0].br().x, facesarray[i].tl().y + nosesarray[0].br().y) ,
                    face_rect_color, 3);

            imgproc.rectangle(src, facesarray[i].tl(), facesarray[i].br(), face_rect_color, 3);
        }

        utils.mattobitmap(src, selectbp);
        myimageview.setimagebitmap(selectbp);

    }

    private cascadeclassifier loaddetector(int rawid,string filename) {
        cascadeclassifier classifier = null;
        try {

            // load cascade file from application resources
            inputstream is = getresources().openrawresource(rawid);
            file cascadedir = getdir("cascade", context.mode_private);
            mcascadefile = new file(cascadedir, filename);
            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();

            log.e(tag, "start to load file:  " + mcascadefile.getabsolutepath());
            classifier = new cascadeclassifier(mcascadefile.getabsolutepath());

            if (classifier.empty()) {
                log.e(tag, "failed to load cascade classifier");
                classifier = null;
            } else
                log.i(tag, "loaded cascade classifier from " + mcascadefile.getabsolutepath());

            cascadedir.delete();


        } catch (ioexception e) {
            e.printstacktrace();
            log.e(tag, "failed to load cascade. exception thrown: " + e);
        }
        return classifier;
    }

    @override
    protected void onactivityresult(int requestcode, int resultcode, intent data) {
        super.onactivityresult(requestcode, resultcode, data);
        if (requestcode == pick_image_request && resultcode == result_ok && data != null && data.getdata() != null) {
            uri uri = data.getdata();
            try {
                log.d("image-tag", "start to decode selected image now...");
                inputstream input = getcontentresolver().openinputstream(uri);
                bitmapfactory.options options = new bitmapfactory.options();
                options.injustdecodebounds = true;
                bitmapfactory.decodestream(input, null, options);
                int raw_width = options.outwidth;
                int raw_height = options.outheight;
                int max = math.max(raw_width, raw_height);
                int newwidth = raw_width;
                int newheight = raw_height;
                int insamplesize = 1;
                if (max > max_size) {
                    newwidth = raw_width / 2;
                    newheight = raw_height / 2;
                    while ((newwidth / insamplesize) > max_size || (newheight / insamplesize) > max_size) {
                        insamplesize *= 2;
                    }
                }

                options.insamplesize = insamplesize;
                options.injustdecodebounds = false;
                options.inpreferredconfig = bitmap.config.argb_8888;
                selectbp = bitmapfactory.decodestream(getcontentresolver().openinputstream(uri), null, options);

                myimageview.setimagebitmap(selectbp);

            } catch (exception e) {
                e.printstacktrace();
            }
        }
    }
}

第七步：连接手机运行程序

首先要打开安卓手机的开发者模式，每个手机品牌的打开方式不一样，你自行百度一下就知道了。例如在百度中搜索“小米手机如何开启开发者模式”。

然后用数据线将手机和电脑连接起来。成功后，android studio里面会显示你的手机型号。如下图中显示的是“xiaomi mi 8 ud”，本例中的开发手机是小米手机。

点击上图中的“run”-》“run ‘app'”就可以将app运行到手机上面了，注意手机屏幕要处于打开状态。你自拍的图片可以检测不成功，可以下载我的测试图片试试。

到此这篇关于android 利用opencv制作人脸检测app的文章就介绍到这了,更多相关android opencv 人脸检测app内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！