【手把手AI项目】八、MobileNetSSD通过Ncnn前向推理框架在Android端的使用--Cmake编译(目标检测 objection detection)_add the installation prefix of "onnxruntime" to cm

一、前言

• 安装win10+linux-Ubuntu16.04的双系统（超细致）
• ubuntu16.04+caffe＋CUDA10.0+cudnn7.4+opencv2.4.9.1+python2.7　（超超细致）
• Caffe_ssd安装以及利用VOC2012,VOC2007数据集测试VGG_SSD网络
• Caffe实现MobileNetSSD以及各个文件的具体解释，利用自己的数据集dataset训练MobileNetSSD建立模型

推荐看这篇之前把下面这篇先看一下，因为这篇中一些运用的前提在下面PC篇，如转换模型。

• MobileNetSSD通过Ncnn前向推理框架在PC端的使用(目标检测 objection detection)

因为我本来本科大二的时候玩过android， 所以接触这个项目移植这部分我主要负责，早想把自己弄得清晰思路分享大家了。

二、安装Android Studio (AS)

１．下载AS安装包

进入下面这个网站，找到Android Studio板块之后点进去，自动就会显示你当前系统版本和配置的下载包，下载即可，傻瓜操作，不赘述了
https://developer.android.google.cn

２．解压

解压到/usr/local文件中

sudo unzip android-studio-ide-181.5056338-linux.zip -d /usr/local
1

３．打开使用

/usr/local/android-studio/bin/中有个studio.sh　启动即可　之后点安卓图标右键锁定到启动器，以后直接点击桌面左面图标即可
第一次打开会有一些配置选项，问题不大，最主要是会有一个自动的android sdk的安装最好网络好一些，要不会很卡（自动下载还是很方便的，像以前我用eclipse开发android的时候，还需要自己配置sdk，很麻烦）下载之后也会发现自己的home里多了一个Android文件夹
下载完成，你可以随便开始一个project。
这边移植的话主要按下面步骤来

三、android前期准备

NDKbuild 当时做项目的时候研究了几天发现代码没错，就是编译不成功，又挺了几天果断换成Cmake进行编译

１．下载需要的包

首先新建一个空的工程
这里是demo，之后一直next即可
点击File->Settings->Appearance&Behavior->System Settings->Android SDK下载一些必要的包如图所示

如果要是之前自动下载了NDK那目前的步骤只需要下载LLDB,NDK,CMAKE，因为其他的都自动下载完了。

２．添加环境变量

这里不多讲了我之前的博客也有说过或者百度bashrc 和vim使用即可

vim .bashrc

export NDK_HOME=/home/che/Android/Sdk/ndk-bundle
PATH=$NDK_HOME:$PATH

source ~/.bashrc
1
2
3
4
5
6

四、ncnn for android 前期准备

进行buld ncnn(android)

ANDROID_ABI 是移动端硬件架构名字，"armeabi-v7a" 支持绝大部分手机硬件，项目中运用RK3399是v8硬件架构,这边用手机测试所以用v7a
ANDROID_ARM_NEON 是否使用 NEON 指令集，设为 ON 支持绝大部分手机硬件 
ANDROID_PLATFORM 指定最低系统版本，"android-14" 就是 android-4.0（这个玩过android的应该都清楚）

cd ncnn
mkdir -p build-android
cd build-android
cmake -DCMAKE_TOOLCHAIN_FILE=/home/che/Android/Sdk/ndk-bundle/build/cmake/android.toolchain.cmake     -DANDROID_ABI="armeabi-v7a" -DANDROID_ARM_NEON=ON     -DANDROID_PLATFORM=android-14 ..
make -j4
make install
1
2
3
4
5
6
7
8
9
10

一般都会出现错误，这里需要把cmake升级下（要求3.6.0及以上）
首先在http://www.cmake.org/files找到自己想下的版本，我在这里下载3.6.2

sudo apt-get install build-essential 
wget https://cmake.org/files/v3.6/cmake-3.6.2.tar.gz
tar xf cmake-3.6.2.tar.gz 
cd cmake-3.6.2 
./configure  
make 
sudo make install
1
2
3
4
5
6
7

安装完可以用以下命令查看Cmake版本

cmake --version
1

搞定
重新进行进行buld ncnn(android)那步骤
依然可能出现问题
CMake Error at examples/CMakeLists.txt:4 (find_package):
By not providing “FindOpenCV.cmake” in CMAKE_MODULE_PATH this project has
asked CMake to find a package configuration file provided by “OpenCV”, but
CMake did not find one.

Could not find a package configuration file provided by “OpenCV” with any
of the following names:

OpenCVConfig.cmake
opencv-config.cmake
1
2

Add the installation prefix of “OpenCV” to CMAKE_PREFIX_PATH or set
“OpenCV_DIR” to a directory containing one of the above files. If “OpenCV”
provides a separate development package or SDK, be sure it has been
installed.
解决方案把ncnn/CMakeLists.txt里的
add_subdirectory(examples)注释掉，本来默认就是注释的，但是看过我的第一篇ncnn文章 MobileNetSSD通过Ncnn前向推理框架在PC端的使用(目标检测 objection detection)的朋友可能这里修改了一下，需要改回来。
最后make install成功后
会在ncnn/build-android下产生一个install文件夹里面有两个文件

• include文件夹　里面包含各种常用的.h文件
• lib/libncnn.a文件　　以我理解这个文件就是相当于把ncnn打包成android可导入的形式
  

五、创建android工程

命名为MobileNetSSD_demo
file/new/newproject
因为这里我们采用cmake编译.so文件的方法，所以相当于用java接口去调用c++,使用NDK技术,所以这边需要选择include c++ support之后next　选择Phone和Tablet之后选择空project之后next 到了下面这个界面需要选择c++11
finish

发现文件里多个cpp文件，下面也多了一个CMakeLists.txt

六、复制文件到android项目中(加密model和网络文件以及build-android文件)

生成转换文件请看 MobileNetSSD通过Ncnn前向推理框架在PC端的使用(目标检测 objection detection)

• 在main目录下创建assets目录，将MobileNetSSD_deploy.param.bin （转换后网络模型参数）MobileNetSSD_deploy.bin （转换后的网络权重）复制到文件中去，自己创建一个words.txt也复制到其中
  words.txt内容(如果是自己的dataset就按照自己的label创建即可)如下：

background
aeroplane
bicycle
bird
boat
bottle
bus
car
cat
chair
cow
diningtable
dog
horse
motorbike
person
pottedplant
sheep
sofa
train
tvmonitor
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

• 复制上述build-android得到的install文件中的include文件夹以及ncnn加密得到的编译
  把mobilenet_v2.id.h复制到cpp目录下。（一会主要c++文件也放在其中这个一会讲到）
• 在main目录下创建jniLibs/armeabi-v7a/目录，并把复制上述build-android得到的install文件中lib下的libncnn.a文件复制到该目录。(jniLibs下的这个文件夹名称和上面build-andorid时考虑的兼容硬件架构一致，如果这边使用RK3399则为v8)
• 还有一点你会发现新建的android工程中有cpp下native-lib.cpp文件里面是NDK代码的一个demo，你会在MainActivity中发现这个cpp的java接口代码，我当时研究NDK的时候也是根据这个demo自己去琢磨的，你也可以多看看如果没有学过NDK的话，这边就不赘述了直接删掉　最后的文件部署如下图所示
  

七、核心代码和配置

下面代码自己仿照ncnn的examples里的squeezencnn的安卓项目工程里面的代码所修改，这个项目工程是利用NDK-build不是我所讲的Cmake方式

１．MobileNetssd.cpp（创建或者直接从example里更改）

具体代码如下（有详细注释）

#include <android/bitmap.h>
#include <android/log.h>
#include <jni.h>
#include <string>
#include <vector>

// ncnn
#include "include/opencv.h"
#include "MobileNetSSD_deploy.id.h"   //这里看成自己的id.h
#include <sys/time.h>
#include <unistd.h>
#include "include/net.h"

static ncnn::UnlockedPoolAllocator g_blob_pool_allocator;
static ncnn::PoolAllocator g_workspace_pool_allocator;

static ncnn::Mat ncnn_param;
static ncnn::Mat ncnn_bin;
static ncnn::Net ncnn_net;

extern "C" {

// public native boolean Init(byte[] words,byte[] param, byte[] bin);　　原函数形式（c++） 以下形式为ndk的c++形式
JNIEXPORT jboolean JNICALL
Java_com_example_che_mobilenetssd_demo_MobileNetssd_Init(JNIEnv *env, jobject obj, jbyteArray param, jbyteArray bin){
    __android_log_print(ANDROID_LOG_DEBUG, "MobileNetssd", "enter the jni func");
    // init param
    {
        int len = env->GetArrayLength(param);
        ncnn_param.create(len, (size_t) 1u);
        env->GetByteArrayRegion(param, 0, len, (jbyte *) ncnn_param);
        int ret = ncnn_net.load_param((const unsigned char *) ncnn_param);
        __android_log_print(ANDROID_LOG_DEBUG, "MobileNetssd", "load_param %d %d", ret, len);
    }

    // init bin
    {
        int len = env->GetArrayLength(bin);
        ncnn_bin.create(len, (size_t) 1u);
        env->GetByteArrayRegion(bin, 0, len, (jbyte *) ncnn_bin);
        int ret = ncnn_net.load_model((const unsigned char *) ncnn_bin);
        __android_log_print(ANDROID_LOG_DEBUG, "MobileNetssd", "load_model %d %d", ret, len);
    }

    ncnn::Option opt;
    opt.lightmode = true;
    opt.num_threads = 4;   //线程 这里可以修改
    opt.blob_allocator = &g_blob_pool_allocator;
    opt.workspace_allocator = &g_workspace_pool_allocator;

    ncnn::set_default_option(opt);

    return JNI_TRUE;
}

// public native String Detect(Bitmap bitmap);
JNIEXPORT jfloatArray JNICALL Java_com_example_che_mobilenetssd_demo_MobileNetssd_Detect(JNIEnv* env, jobject thiz, jobject bitmap)
{
    // ncnn from bitmap
    ncnn::Mat in;
    {
        AndroidBitmapInfo info;
        AndroidBitmap_getInfo(env, bitmap, &info);
//        int origin_w = info.width;
//        int origin_h = info.height;
//        int width = 300;
//        int height = 300;
        int width = info.width;
        int height = info.height;
        if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888)
            return NULL;

        void* indata;
        AndroidBitmap_lockPixels(env, bitmap, &indata);
        // 把像素转换成data，并指定通道顺序
        // 因为图像预处理每个网络层输入的数据格式不一样一般为300*300 128*128等等所以这类需要一个resize的操作可以在cpp中写，也可以是java读入图片时有个resize操作
//      in = ncnn::Mat::from_pixels_resize((const unsigned char*)indata, ncnn::Mat::PIXEL_RGBA2RGB, origin_w, origin_h, width, height);

        in = ncnn::Mat::from_pixels((const unsigned char*)indata, ncnn::Mat::PIXEL_RGBA2RGB, width, height);

        // 下面一行为debug代码
        //__android_log_print(ANDROID_LOG_DEBUG, "MobilenetssdJniIn", "Mobilenetssd_predict_has_input1, in.w: %d; in.h: %d", in.w, in.h);
        AndroidBitmap_unlockPixels(env, bitmap);
    }

    // ncnn_net
    std::vector<float> cls_scores;
    {
        // 减去均值和乘上比例（这个数据和前面的归一化图片预处理形式一一对应）
        const float mean_vals[3] = {127.5f, 127.5f, 127.5f};
        const float scale[3] = {0.007843f, 0.007843f, 0.007843f};

        in.substract_mean_normalize(mean_vals, scale);// 归一化

        ncnn::Extractor ex = ncnn_net.create_extractor();//前向传播

        // 如果不加密是使用ex.input("data", in);
        // BLOB_data在id.h文件中可见，相当于datainput网络层的id
        ex.input(MobileNetSSD_deploy_param_id::BLOB_data, in);
        //ex.set_num_threads(4); 和上面一样一个对象

        ncnn::Mat out;
        // 如果时不加密是使用ex.extract("prob", out);
        //BLOB_detection_out.h文件中可见，相当于dataout网络层的id,输出检测的结果数据
        ex.extract(MobileNetSSD_deploy_param_id::BLOB_detection_out, out);

        int output_wsize = out.w;
        int output_hsize = out.h;

        //输出整理
        jfloat *output[output_wsize * output_hsize];
        for(int i = 0; i< out.h; i++) {
            for (int j = 0; j < out.w; j++) {
                output[i*output_wsize + j] = &out.row(i)[j];
            }
        }
        jfloatArray jOutputData = env->NewFloatArray(output_wsize);
        if (jOutputData == nullptr) return nullptr;
        env->SetFloatArrayRegion(jOutputData, 0,  output_wsize * output_hsize,
                                 reinterpret_cast<const jfloat *>(*output));

        return jOutputData;
    }
}
}

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

将.cpp文件放到cpp文件夹下

２．AndroidManifest.xml添加权限

    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.CAMERA"/>
1
2
3

３．CMakeLists.txt修改

# For more information about using CMake with Android Studio, read the
# documentation: https://d.android.com/studio/projects/add-native-code.html

# Sets the minimum version of CMake required to build the native library.

cmake_minimum_required(VERSION 3.4.1)

# Creates and names a library, sets it as either STATIC
# or SHARED, and provides the relative paths to its source code.
# You can define multiple libraries, and CMake builds them for you.
# Gradle automatically packages shared libraries with your APK.

##需要添加　相当于添加ncnn for android 的包　need to add
set(ncnn_lib ${CMAKE_SOURCE_DIR}/src/main/jniLibs/armeabi-v7a/libncnn.a)
add_library (ncnn_lib STATIC IMPORTED)
set_target_properties(ncnn_lib PROPERTIES IMPORTED_LOCATION ${ncnn_lib})

add_library( # Sets the name of the library.
        MobileNetssd ## 为生成.so的文字最好直接和.cpp名字一样,需要更改　need to add

        # Sets the library as a shared library.
        SHARED

        # Provides a relative path to your source file(s).
        src/main/cpp/MobileNetssd.cpp　)##cpp文件的name

# Searches for a specified prebuilt library and stores the path as a
# variable. Because CMake includes system libraries in the search path by
# default, you only need to specify the name of the public NDK library
# you want to add. CMake verifies that the library exists before
# completing its build.

find_library( # Sets the name of the path variable.
        log-lib

        # Specifies the name of the NDK library that
        # you want CMake to locate.
        log)

# Specifies libraries CMake should link to your target library. You
# can link multiple libraries, such as libraries you define in this
# build script, prebuilt third-party libraries, or system libraries.

target_link_libraries( # Specifies the target library.
        ##以下三个都要添加　need to add
        MobileNetssd   #和上面一样
        ncnn_lib       #这个ncnn的lib的add
        jnigraphics    #这个jni也需要add

        # Links the target library to the log library
        # included in the NDK.
        ${log-lib})
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

４．build.gradle修改

apply plugin: 'com.android.application'

android {
    compileSdkVersion 28
    defaultConfig {
        applicationId "com.example.che.mobilenetssd_demo"
        minSdkVersion 15
        targetSdkVersion 28
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
        externalNativeBuild {
            cmake {
                cppFlags "-std=c++11 -fopenmp"//c++,多线程 需要添加　need to add
                abiFilters "armeabi-v7a" // 手机的硬件架构，基本所有的硬件都适配　need to add
            }
        }
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
    externalNativeBuild {
        cmake {
            path "CMakeLists.txt"
        }
    }

    // 需要添加 把 .a文件导入, .a为 ncnn make intall生成的里面的.a文件　need to add
    sourceSets {
        main {
            jniLibs.srcDirs = ["src/main/jniLibs"]
            jni.srcDirs = ['src/cpp']
        }
    }
}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'com.android.support:appcompat-v7:28.0.0'
    implementation 'com.android.support.constraint:constraint-layout:1.1.3'
    testImplementation 'junit:junit:4.12'
    implementation 'com.github.bumptech.glide:glide:4.3.1'   // 需要添加，增加图片类 bumptech，build自动红线消失　need to add
    androidTestImplementation 'com.android.support.test:runner:1.0.2'
    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
}

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

５．自己编写java接口

命名为和.cpp文件一样的名称
这里就是MobileNetssd.java

package com.example.che.mobilenetssd_demo;

import android.graphics.Bitmap;

/**
 *  MobileNetssd的java接口，与本地c++代码相呼应 native为本地 此文件与 MobileNetssd.cpp相呼应
 */
public class MobileNetssd {

    public native boolean Init(byte[] param, byte[] bin); // 初始化函数　
    public native float[] Detect(Bitmap bitmap); // 检测函数
    // Used to load the 'native-lib' library on application startup.
    static {
        System.loadLibrary("MobileNetssd");//最后
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

• public native boolean Init(byte[] param, byte[] bin); // 初始化函数　对应于NDK编写的.cpp文件中的JNIEXPORT jboolean JNICALL
  Java_com_example_che_mobilenetssd_demo_MobileNetssd_Init(JNIEnv *env, jobject obj, jbyteArray param, jbyteArray bin)
• public native float[] Detect(Bitmap bitmap); // 检测函数　对应于NDK编写的.cpp文件中的JNIEXPORT jfloatArray JNICALL Java_com_example_che_mobilenetssd_demo_MobileNetssd_Detect(JNIEnv* env, jobject thiz, jobject bitmap)
  其实有规律可寻以第二个为例子
  函数前三个都是JNIEXPORT +函数返回类型(NDK形式)+JNICALL
  Java_com_example_che_mobilenetssd_demo_MobileNetssd_Detect(JNIEnv* env, jobject thiz, jobject bitmap)
  对于这个命名先看下面这个图你可能就懂了
  
  相当于绝对路径那种感觉了显示java文件夹，再是com.example.che.mobilenetssd_demo这个包再是MobileNetssd.java文件最后是 java接口文件中的public native float[] Detect(Bitmap bitmap); 函数的文件名，即Java_com_example_che_mobilenetssd_demo_MobileNetssd_Detect，后面参数则为
  （JNIEnv* env, jobject thiz,＋原函数的函数参数(NDK类型格式)）
  其实正常来讲NDK这种不应该是先写cpp再写java接口而是应该先写java接口再利用IDE本身带有的NDK的开发环境可以直接双点写的java接口的函数（函数格式如上需要加一个native）之后快捷键按ALT+ENTER即可直接在cpp文件中添加成功,具体请看NDK技术即可，这里不赘余了。
  接下来就是我的其他.java文件以及UI的XML文件了

６．activity_main.xml（res/layout/activity_main.xml）

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout 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">
    <LinearLayout
        android:id="@+id/btn_ll"
        android:layout_alignParentBottom="true"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal">
        <Button
            android:id="@+id/use_photo"
            android:layout_weight="1"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:text="相册"/>
    </LinearLayout>
    <TextView
        android:layout_above="@id/btn_ll"
        android:id="@+id/result_text"
        android:textSize="16sp"
        android:layout_width="match_parent"
        android:hint="预测结果会在这里显示"
        android:layout_height="100dp"/>
    <ImageView
        android:layout_alignParentTop="true"
        android:layout_above="@id/result_text"
        android:id="@+id/show_image"
        android:layout_width="match_parent"
        android:layout_height="match_parent"/>
</RelativeLayout>
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

７．MainActivity.java修改成如下

package com.example.che.mobilenetssd_demo;

import android.Manifest;
import android.app.Activity;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.res.AssetManager;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.net.Uri;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.text.method.ScrollingMovementMethod;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;


import com.bumptech.glide.Glide;
import com.bumptech.glide.load.engine.DiskCacheStrategy;
import com.bumptech.glide.request.RequestOptions;


public class MainActivity extends AppCompatActivity {

    private static final String TAG = MainActivity.class.getName();
    private static final int USE_PHOTO = 1001;
    private String camera_image_path;
    private ImageView show_image;
    private TextView result_text;
    private boolean load_result = false;
    private int[] ddims = {1, 3, 300, 300}; //这里的维度的值要和train model的input 一一对应
    private int model_index = 1;
    private List<String> resultLabel = new ArrayList<>();
    private MobileNetssd mobileNetssd = new MobileNetssd(); //java接口实例化　下面直接利用java函数调用NDK c++函数

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        try
        {
            initMobileNetSSD();
        } catch (IOException e) {
            Log.e("MainActivity", "initMobileNetSSD error");
        }
        init_view();
        readCacheLabelFromLocalFile();
}

    /**
     *
     * MobileNetssd初始化，也就是把model文件进行加载
     */
    private void initMobileNetSSD() throws IOException {
        byte[] param = null;
        byte[] bin = null;
        {
            //用io流读取二进制文件，最后存入到byte[]数组中
            InputStream assetsInputStream = getAssets().open("MobileNetSSD_deploy.param.bin");// param：  网络结构文件
            int available = assetsInputStream.available();
            param = new byte[available];
            int byteCode = assetsInputStream.read(param);
            assetsInputStream.close();
        }
        {
            //用io流读取二进制文件，最后存入到byte上，转换为int型
            InputStream assetsInputStream = getAssets().open("MobileNetSSD_deploy.bin");//bin：   model文件
            int available = assetsInputStream.available();
            bin = new byte[available];
            int byteCode = assetsInputStream.read(bin);
            assetsInputStream.close();
        }

        load_result = mobileNetssd.Init(param, bin);// 再将文件传入java的NDK接口(c++ 代码中的init接口 )
        Log.d("load model", "MobileNetSSD_load_model_result:" + load_result);
    }


    // initialize view
    private void init_view() {
        request_permissions();
        show_image = (ImageView) findViewById(R.id.show_image);
        result_text = (TextView) findViewById(R.id.result_text);
        result_text.setMovementMethod(ScrollingMovementMethod.getInstance());
        Button use_photo = (Button) findViewById(R.id.use_photo);
        // use photo click
        use_photo.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if (!load_result) {
                    Toast.makeText(MainActivity.this, "never load model", Toast.LENGTH_SHORT).show();
                    return;
                }
                PhotoUtil.use_photo(MainActivity.this, USE_PHOTO);
            }
        });
    }

    // load label's name
    private void readCacheLabelFromLocalFile() {
        try {
            AssetManager assetManager = getApplicationContext().getAssets();
            BufferedReader reader = new BufferedReader(new InputStreamReader(assetManager.open("words.txt")));//这里是label的文件
            String readLine = null;
            while ((readLine = reader.readLine()) != null) {
                resultLabel.add(readLine);
            }
            reader.close();
        } catch (Exception e) {
            Log.e("labelCache", "error " + e);
        }
    }


    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
        String image_path;
        RequestOptions options = new RequestOptions().skipMemoryCache(true).diskCacheStrategy(DiskCacheStrategy.NONE);
        if (resultCode == Activity.RESULT_OK) {
            switch (requestCode) {
                case USE_PHOTO:
                    if (data == null) {
                        Log.w(TAG, "user photo data is null");
                        return;
                    }
                    Uri image_uri = data.getData();

                    //Glide.with(MainActivity.this).load(image_uri).apply(options).into(show_image);

                    // get image path from uri
                    image_path = PhotoUtil.get_path_from_URI(MainActivity.this, image_uri);
                    // predict image
                    predict_image(image_path);
                    break;
            }
        }
    }

    //  predict image
    private void predict_image(String image_path) {
        // picture to float array
        Bitmap bmp = PhotoUtil.getScaleBitmap(image_path);
        Bitmap rgba = bmp.copy(Bitmap.Config.ARGB_8888, true);
        // resize to 300*300
        Bitmap input_bmp = Bitmap.createScaledBitmap(rgba, ddims[2], ddims[3], false);
        try {
            // Data format conversion takes too long
            // Log.d("inputData", Arrays.toString(inputData));
            long start = System.currentTimeMillis();
            // get predict result
            float[] result = mobileNetssd.Detect(input_bmp);
            // time end
            long end = System.currentTimeMillis();
            Log.d(TAG, "origin predict result:" + Arrays.toString(result));
            long time = end - start;
            Log.d("result length", "length of result: " + String.valueOf(result.length));
            // show predict result and time
            float[] r = get_max_result(result);

            String show_text = "result：" + Arrays.toString(r) + "\nname：" + resultLabel.get((int) r[0]) + "\nprobability：" + r[1] + "\ntime：" + time + "ms" ;
            result_text.setText(show_text);
            Canvas canvas = new Canvas(rgba);
            //图像上画矩形
            Paint paint = new Paint();
            paint.setColor(Color.RED);
            paint.setStyle(Paint.Style.STROKE);//不填充
            paint.setStrokeWidth(10); //线的宽度
            canvas.drawRect(r[2]*rgba.getWidth(), r[3]*rgba.getHeight(), r[4]*rgba.getWidth(), r[5]*rgba.getHeight(), paint);
            show_image.setImageBitmap(rgba);


        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // get max probability label
    private float[] get_max_result(float[] result) {
        int num_rs = result.length / 6;
        float maxProp = result[1];
        int maxI = 0;
        for(int i = 1; i<num_rs;i++){
            if(maxProp<result[i*6+1]){
                maxProp = result[i*6+1];
                maxI = i;
            }
        }
        float[] ret = {0,0,0,0,0,0};
        for(int j=0;j<6;j++){
            ret[j] = result[maxI*6 + j];
        }
        return ret;
    }

    // request permissions(add)
    private void request_permissions() {
        List<String> permissionList = new ArrayList<>();
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
            permissionList.add(Manifest.permission.CAMERA);
        }
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
            permissionList.add(Manifest.permission.WRITE_EXTERNAL_STORAGE);
        }
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
            permissionList.add(Manifest.permission.READ_EXTERNAL_STORAGE);
        }
        // if list is not empty will request permissions
        if (!permissionList.isEmpty()) {
            ActivityCompat.requestPermissions(this, permissionList.toArray(new String[permissionList.size()]), 1);
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode) {
            case 1:
                if (grantResults.length > 0) {
                    for (int i = 0; i < grantResults.length; i++) {
                        int grantResult = grantResults[i];
                        if (grantResult == PackageManager.PERMISSION_DENIED) {
                            String s = permissions[i];
                            Toast.makeText(this, s + "permission was denied", Toast.LENGTH_SHORT).show();
                        }
                    }
                }
                break;
        }
    }



}


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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252

８．PhotoUtil.java（照片工具类）

package com.example.che.mobilenetssd_demo;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.provider.MediaStore;

public class PhotoUtil {
    // get picture in photo
    public static void use_photo(Activity activity, int requestCode) {
        Intent intent = new Intent(Intent.ACTION_PICK);
        intent.setType("image/*");
        activity.startActivityForResult(intent, requestCode);
    }

    // get photo from Uri
    public static String get_path_from_URI(Context context, Uri uri) {
        String result;
        Cursor cursor = context.getContentResolver().query(uri, null, null, null, null);
        if (cursor == null) {
            result = uri.getPath();
        } else {
            cursor.moveToFirst();
            int idx = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA);
            result = cursor.getString(idx);
            cursor.close();
        }
        return result;
    }

    // compress picture
    public static Bitmap getScaleBitmap(String filePath) {
        BitmapFactory.Options opt = new BitmapFactory.Options();
        opt.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(filePath, opt);

        int bmpWidth = opt.outWidth;
        int bmpHeight = opt.outHeight;

        int maxSize = 500;

        // compress picture with inSampleSize
        opt.inSampleSize = 1;
        while (true) {
            if (bmpWidth / opt.inSampleSize < maxSize || bmpHeight / opt.inSampleSize < maxSize) {
                break;
            }
            opt.inSampleSize *= 2;
        }
        opt.inJustDecodeBounds = false;
        return BitmapFactory.decodeFile(filePath, opt);
    }
}


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

全部完毕

八、build project /真机测试

１．build

点击Build，之后点击Make Project,等一会，不出意外应该是成功了
查看自己的这个文件夹的对应的编译硬件架构的文件夹下成功生成.so文件，名字为libMobileNetssd.so

2．真机测试

我喜欢用真机测试，插上真机打开开发者模式等等，可百度一下，很多，不赘述了
先导入一些测试图片，之后run 就好了，这个地方太基本不想多说了，没说过android的朋友稍微探索一下怎么成功导入app即可，这过程中可能因为手机版本等更换SDK版本等等问题，常见的就是修改sdk版本即可，在导入的过程中需要一些手机真机的钥匙等确认。
安装完毕打开app有几个权限需要手机确认以下即可，真机照片(这里会出现一个无法编译成功的错误，看总结里写到解决方式，主要和NDK命名规则有关)


前面提到一个 线程的问题，这里可以自行更改到速度最快即可，一般为4最快，这个也和你输入的图片

九、总结

这边的代码目前只支持单目标检测，现在一张图片中有多个目标则无法成功检测出最后的框图版本，下一篇博客把这个实现写上准备，这里还有一点就是.cpp文件中的NDK函数的名称需要修改才能最后app装在手机上成功，我项目的android名称为一连串的，而这回起名为MobileNetSSD_demo形式（感觉自己也是没事找事＝　＝），中多个下划线，这里直接关系到NDK的函数命名格式

Java_com_example_che_mobilenetssd_demo_MobileNetssd_Init（原来的）
Java_com_example_che_mobilenetssd_1demo_MobileNetssd_Init（更改的）
1
2

在mobilenetssd_后多个1再加上demo才能关联成功，java接口的这个函数直接go to Declaration就可以直接关联到.cpp中这个函数了，Detect函数以此列推，如果你自己再走一遍流程起名是一连串的(比如MobileNetssddemo)就不会出现这样的问题了，但是这个问题不会影响之前的所有讲解，没有问题，改完之后需要clean project 之后重新make project　即可成功　成功结果如上图所示

十、代码链接

已在我的github上，希望大家给个star follow.因为准备和下一篇博文多检测的分开重命名为single
https://github.com/chehongshu/ncnnforandroid_objectiondetection_Mobilenetssd/tree/master/MobileNetSSD_demo_single

PS： 如果觉得本篇本章对您有所帮助，欢迎关注、评论、点赞！Github给个Star就更完美了_！

十一、补充

如果想打包成android APK请参照我另一篇博文
Android studio打包APK Android Studio

联系本人，手机观看，欢迎关注本人公众号

Reference

https://blog.csdn.net/freezingxu/article/details/73917933

https://blog.csdn.net/qq_36982160/article/details/79931741

https://blog.csdn.net/qq_33200967/article/details/82421089#_85

https://blog.csdn.net/learning_tortosie/article/details/80593956