关于YOLO8学习（六）安卓部署ncnn模型--图片检测_yolov8部署到手机上拍照识别

教学视频地址

B站

前文

关于YOLO8学习（一）环境搭建，官方检测模型部署到手机
关于YOLO8学习（二）数据集收集，处理
关于YOLO8学习（三）训练自定义的数据集
关于YOLO8学习（四）模型转换为ncnn
关于YOLO8学习（五）安卓部署ncnn模型–视频检测

简介

前文第五章，讲述了部署自定义模型后，进行安卓视频检测人脸。
本文将会讲解：
（1）使用前文可以运行的demo，讲解如何使用模型对图片进行识别，并且标注，自定义返回结果

注意！！文末有安卓关键代码源码

效果图

开发环境

win10、python 3.11、cmake、pytorch2.0.1+cu117、pycharm、ultralytics==8.0.134
要特别注意，不要升级到python312，目前onnx还没支持到312，所以转换了，会导致转换模型失效。
对于上述环境如何配置，请看我之前的文章。
安卓：as4+,ndk21+,jdk11

开发过程

本次实现Yolo8的安卓图片检测，对于新手来说，应该会十分坎坷，因为整个流程，涉及到了java，安卓，jni，python这几个语言的糅合，话不多说，直接上干活。

先说思路，图片检测的原理，就是通过传入的图片对象，然后使用ncnn自带的一些方法，检测出目标的位置，然后返回给上层坐标系，标签等信息，在通过安卓canvas进行绘制。

（1）对于“检测出目标的位置”这个流程，是不是时曾相识？没错，前面的文章中，我们已经实现了视频的检测，细心一点的朋友可能会发现，源码中的yolo.cpp类，detect和draw方法，不就是检测和绘制吗？正确
（2）对于返回给上层的信息，是不是也可以通过jni定义好，然后c层直接封装，java曾直接解析，就可以了？

关键点说完了，下面直接看关键的代码：

博主先在Yolov8Ncnn.java文件中，定义了一个jni方法，名字为

    public native List<HashMap<String, String>> detectedStaticPic(Bitmap bitmap);
1

这个方法，就是要求c层，返回一个列表，列表每一项中，都是一个key,value组成的map，那么这个map，就可以放下我们的x,y,label等信息了。然后再看输入对象是一个bitmap。到此位置，jni层的java类已经定义完成。

接着在yolov8ncnn.cpp文件中，直接创建对应的方法，具体代码如下：

/**
 * 檢測圖片
 * */
extern "C"
JNIEXPORT jobject JNICALL
Java_com_north_light_yolov8ncnn_Yolov8Ncnn_detectedStaticPic(JNIEnv *env, jobject thiz,
                                                         jobject bitmap) {
    return g_yolo->detected_static_pic(env, thiz, bitmap);
}
1
2
3
4
5
6
7
8
9
10

可以看到，这里直接调用回yolo.cpp的方法，同样，按照c语言的习惯，我们直接在yolo.h和yolo.cpp定义好即可。具体代码如下：

yolo.h

 jobject detected_static_pic(JNIEnv *pEnv, jobject pJobject, jobject pJobject1);
1

yolo.cpp

jobject Yolo::detected_static_pic(JNIEnv *env, jobject thiz, jobject bitmap)
1

定义好了以后，所有有关的检测逻辑，都在yolo.cpp里面编写，最后返回一个List<HashMap<String,String>>对象给上层即可。

---

至此，我们已经搭建完成整个开发骨架了，接下来，就是具体业务的编写：
这里先提供一个思路，后面会放出所有的代码：

实现方法，函数中收到的是一个bitmap，而ncnn不能直接处理bitmap，而是处理rgb的mat，所以，这里就涉及到一个bitmap转为mat（rgb）的逻辑。再者，对于ncnn处理完成后，要返回刚才定义的List<HashMap<String,String>>对象给上层，然后再在安卓端使用canvas进行边框绘制。核心代码如下：

yolo.cpp

// 检测静态图片
jobject Yolo::detected_static_pic(JNIEnv *env, jobject thiz, jobject bitmap) {

    //结果数据
    jclass arrayListClass = env->FindClass("java/util/ArrayList");
    jmethodID arrayListInit = env->GetMethodID(arrayListClass, "<init>", "()V");
    jobject arrayListObj = env->NewObject(arrayListClass, arrayListInit);

    // 获取Bitmap信息
    AndroidBitmapInfo info;
    if (AndroidBitmap_getInfo(env, bitmap, &info) < 0) {
        return arrayListObj;
    }
    if (info.format != ANDROID_BITMAP_FORMAT_RGB_565 &&
        info.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {
        return arrayListObj;
    }

    // 锁定Bitmap像素
    void *pixels = nullptr;
    if (AndroidBitmap_lockPixels(env, bitmap, &pixels) < 0) {
        return arrayListObj;
    }

    // 计算RGB数据大小
    size_t pixelCount = info.width * info.height;
    size_t rgbDataSize = pixelCount * 3; // 每个像素3个字节(RGB)
    std::vector<unsigned char> rgbData(rgbDataSize);

    // 提取RGB值
    uint8_t *p = static_cast<uint8_t *>(pixels);
    for (size_t i = 0; i < pixelCount; ++i) {
        if (info.format == ANDROID_BITMAP_FORMAT_RGB_565) {
            // 对于RGB_565格式，需要转换为RGB888
            uint16_t pixel = *reinterpret_cast<uint16_t *>(p);
            rgbData[i * 3] = ((pixel >> 8) & 0xF8) | ((pixel >> 13) & 0x07); // R
            rgbData[i * 3 + 1] = ((pixel >> 3) & 0xF8) | ((pixel >> 11) & 0x07); // G
            rgbData[i * 3 + 2] = ((pixel << 3) & 0xF8) | ((pixel >> 5) & 0x07); // B
            p += 2; // RGB_565每像素2字节
        } else if (info.format == ANDROID_BITMAP_FORMAT_RGBA_8888) {
            // 直接提取RGB分量，忽略Alpha
            rgbData[i * 3] = p[0]; // R
            rgbData[i * 3 + 1] = p[1]; // G
            rgbData[i * 3 + 2] = p[2]; // B
            p += 4; // ARGB_8888每像素4字节
        }
    }
    int width = info.width;
    int height = info.height;
    // 解锁Bitmap像素
    AndroidBitmap_unlockPixels(env, bitmap);

    // 确保数据量与宽度、高度匹配
    if (rgbData.size() != static_cast<size_t>(width * height * 3)) {
        return arrayListObj;
    }
    cv::Mat mat(height, width, CV_8UC3, (void *) rgbData.data());
    //完成了数据的转换，开始检测
    std::vector<Object> objects;
    detect(mat, objects);
    draw(mat,objects);

//    __android_log_print(ANDROID_LOG_DEBUG, "ncnn", "objects size %d", objects.size());

    if (objects.size() <= 0) {
        return arrayListObj;
    }

    //上述步骤，可以检测出具体的框
    //组装数据

    jmethodID addMethod = env->GetMethodID(arrayListClass, "add", "(Ljava/lang/Object;)Z");

    if (objects.size() > 0) {
        for (int i = 0; i < objects.size(); i++) {
            int label_pos = objects[i].label;

            jclass hashMapClass = env->FindClass("java/util/HashMap");
            jmethodID hashMapInit = env->GetMethodID(hashMapClass, "<init>", "()V");
            jobject hashMapObj = env->NewObject(hashMapClass, hashMapInit);

            jstring xKeyStr = charToString(env, "x");
            jstring xValue = intToString(env, objects[i].rect.x);

            jstring yKeyStr = charToString(env, "y");
            jstring yValue = intToString(env, objects[i].rect.y);

            jstring wKeyStr = charToString(env, "w");
            jstring wValue = intToString(env, objects[i].rect.width);

            jstring hKeyStr = charToString(env, "h");
            jstring hValue = intToString(env, objects[i].rect.height);

            jstring labelKeyStr = charToString(env, "label");
            jstring labelValue = intToString(env, objects[i].label);

            jstring labelStrKeyStr = charToString(env, "label_str");
            jstring labelStrValue = charToString(env, class_names[label_pos]);

            jstring probKeyStr = charToString(env, "prob");
            jstring probValue = floatToString(env, objects[i].prob);

            putKeyValueToMap(env, hashMapObj, hashMapClass, xKeyStr, xValue);
            putKeyValueToMap(env, hashMapObj, hashMapClass, yKeyStr, yValue);
            putKeyValueToMap(env, hashMapObj, hashMapClass, wKeyStr, wValue);
            putKeyValueToMap(env, hashMapObj, hashMapClass, hKeyStr, hValue);
            putKeyValueToMap(env, hashMapObj, hashMapClass, labelKeyStr, labelValue);
            putKeyValueToMap(env, hashMapObj, hashMapClass, labelStrKeyStr, labelStrValue);
            putKeyValueToMap(env, hashMapObj, hashMapClass, probKeyStr, probValue);

            env->CallBooleanMethod(arrayListObj, addMethod, hashMapObj);

            env->DeleteLocalRef(hashMapObj);

            env->DeleteLocalRef(xKeyStr);
            env->DeleteLocalRef(xValue);
            env->DeleteLocalRef(yKeyStr);
            env->DeleteLocalRef(yValue);
            env->DeleteLocalRef(wKeyStr);
            env->DeleteLocalRef(wValue);
            env->DeleteLocalRef(hKeyStr);
            env->DeleteLocalRef(hValue);
            env->DeleteLocalRef(labelKeyStr);
            env->DeleteLocalRef(labelValue);
            env->DeleteLocalRef(labelStrKeyStr);
            env->DeleteLocalRef(labelStrValue);
            env->DeleteLocalRef(probKeyStr);
            env->DeleteLocalRef(probValue);
        }
    }

    return arrayListObj;
}



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

Yolov8Ncnn.java

// Tencent is pleased to support the open source community by making ncnn available.
//
// Copyright (C) 2021 THL A29 Limited, a Tencent company. All rights reserved.
//
// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// https://opensource.org/licenses/BSD-3-Clause
//
// Unless required by applicable law or agreed to in writing, software distributed
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.

package com.north.light.yolov8ncnn;

import android.content.res.AssetManager;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.view.Surface;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class Yolov8Ncnn implements Serializable {

    public native boolean loadModel(AssetManager mgr, int modelid, int cpugpu);

    /**
     * @param facing 0前置 1后置
     */
    public native boolean openYoloCamera(int facing);

    public native boolean closeYoloCamera();

    public native boolean setOutputWindow(Surface surface);

    public native List<HashMap<String, String>> detectedStaticPic(Bitmap bitmap);

    static {
        System.loadLibrary("yolov8ncnn");
    }

    private static final int[] colors = new int[]{
            Color.rgb(54, 67, 244),
            Color.rgb(99, 30, 233),
            Color.rgb(176, 39, 156),
            Color.rgb(183, 58, 103),
            Color.rgb(181, 81, 63),
            Color.rgb(243, 150, 33),
            Color.rgb(244, 169, 3),
            Color.rgb(212, 188, 0),
            Color.rgb(136, 150, 0),
            Color.rgb(80, 175, 76),
            Color.rgb(74, 195, 139),
            Color.rgb(57, 220, 205),
            Color.rgb(59, 235, 255),
            Color.rgb(7, 193, 255),
            Color.rgb(0, 152, 255),
            Color.rgb(34, 87, 255),
            Color.rgb(72, 85, 121),
            Color.rgb(158, 158, 158),
            Color.rgb(139, 125, 96)
    };

    public List<TrainDetectedObject> trainDataToDetectedObject(List<HashMap<String, String>> data) {
        if (data == null || data.size() == 0) {
            return new ArrayList<>();
        }
        List<TrainDetectedObject> result = new ArrayList<>();
        for (int i = 0; i < data.size(); i++) {
            HashMap<String, String> item = data.get(i);
            if (item.containsKey("label") && item.containsKey("label_str") &&
                    item.containsKey("prob") && item.containsKey("x") &&
                    item.containsKey("y") && item.containsKey("w") &&
                    item.containsKey("h")) {
                TrainDetectedObject obj = new TrainDetectedObject();
                obj.label = item.get("label");
                obj.labelName = item.get("label_str");
                obj.prob = Float.parseFloat(item.get("prob"));
                obj.x = Float.parseFloat(item.get("x"));
                obj.y = Float.parseFloat(item.get("y"));
                obj.w = Float.parseFloat(item.get("w"));
                obj.h = Float.parseFloat(item.get("h"));
                result.add(obj);
            }
        }
        return result;
    }


    public Bitmap showObjects(List<TrainDetectedObject> objects, Bitmap orgBitmap) {
        if (objects == null) {
            return null;
        }
        // draw objects on bitmap
        Bitmap rgba = orgBitmap.copy(Bitmap.Config.ARGB_8888, true);

        Canvas canvas = new Canvas(rgba);

        Paint paint = new Paint();
        paint.setStyle(Paint.Style.STROKE);
        paint.setStrokeWidth(4);

        Paint textbgpaint = new Paint();
        textbgpaint.setColor(Color.WHITE);
        textbgpaint.setStyle(Paint.Style.FILL);

        Paint textpaint = new Paint();
        textpaint.setColor(Color.BLACK);
        textpaint.setTextSize(26);
        textpaint.setTextAlign(Paint.Align.LEFT);

        for (int i = 0; i < objects.size(); i++) {
            paint.setColor(colors[i % 19]);
            canvas.drawRect(objects.get(i).x, objects.get(i).y, objects.get(i).x + objects.get(i).w, objects.get(i).y + objects.get(i).h, paint);
            {
                String text = objects.get(i).labelName + " = " + String.format("%.1f", objects.get(i).prob * 100) + "%";
                float text_width = textpaint.measureText(text);
                float text_height = -textpaint.ascent() + textpaint.descent();

                float x = objects.get(i).x;
                float y = objects.get(i).y - text_height;
                if (y < 0)
                    y = 0;
                if (x + text_width > rgba.getWidth())
                    x = rgba.getWidth() - text_width;

                canvas.drawRect(x, y, x + text_width, y + text_height, textbgpaint);

                canvas.drawText(text, x, y - textpaint.ascent(), textpaint);
            }
        }
        return rgba;
    }
}

···

通过以上的方式，就可以实现jni层检测，安卓层绘制边框的逻辑了。

### 更详细的安卓代码，如下：
## 安卓demo源码：关注并回复 “yolo8检测人脸图片检测代码”即可
![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/4d865e2d13444726b3ea24a9acb55897.jpeg)

that's all--------------------------------------------------------------------------------------------
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150