图像分类EdgeBoard(FZ)专用SDK集成文档

baidu_easyedge_linux_cpp_aarch64_EdgeBoardFZ1.5_*
├── ReadMe.txt
├── bin
│   ├── easyedge_image_inference
│   ├── easyedge_serving
│   └── easyedge_video_inference
├── include
│   └── easyedge
├── lib
│   ├── libeasyedge.so -> libeasyedge.so.1
│   ├── libeasyedge.so.1 -> libeasyedge.so.1.3.1
│   ├── libeasyedge.so.1.3.1
│   ├── libeasyedge_static.a
│   ├── libeasyedge_videoio.so -> libeasyedge_videoio.so.1
│   ├── libeasyedge_videoio.so.1 -> libeasyedge_videoio.so.1.3.1
│   ├── libeasyedge_videoio.so.1.3.1
│   ├── libeasyedge_videoio_static.a
│   ├── libpaddle_full_api_shared.so -> libpaddle_full_api_shared.so.1.8.0
│   ├── libpaddle_full_api_shared.so.1.8.0
│   ├── libverify.so -> libverify.so.1
│   ├── libverify.so.1 -> libverify.so.1.0.0
│   └── libverify.so.1.0.0
├── now_sre.log
├── src
│   ├── CMakeLists.txt
│   ├── cmake
│   ├── common
│   ├── demo_image_inference
│   ├── demo_serving
│   └── demo_video_inference
└── thirdparty
    └── opencv

insmod /home/root/workspace/driver/{zu9|zu5|zu3}/fpgadrv.ko

Failed to to fpga device: -1

date --set "2019-5-18 20:48:00"

# ./easyedge_serving {RES目录} "" {绑定的host，默认0.0.0.0} {绑定的端口，默认24401}
cd ${SDK_ROOT}
export LD_LIBRARY_PATH=./lib
./demo/easyedge_serving ../../../RES  ""

2019-07-18 13:27:05,941 INFO [EasyEdge] [http_server.cpp:136] 547974369280 Serving at 0.0.0.0:24401

cd src
mkdir build && cd build
cmake .. && make

./easyedge_image_inference  {RES资源文件夹路径}  {测试图片路径}

    /**
     * @brief 同步预测接口
     * inference synchronous
     * Supported by most chip and engine
     * @param image: must be BGR , HWC format (opencv default)
     * @param result
     * @param threshold
     * @return
     */
    virtual int infer(
            cv::Mat &image, std::vector<EdgeResultData> &result, float threshold = 0.1
    ) = 0;

struct EdgeResultData {
    int index;  // 分类结果的index
    std::string label;  // 分类结果的label
    float prob;  // 置信度

    // object detection field
    float x1, y1, x2, y2;  // (x1, y1): 左上角， （x2, y2): 右下角； 均为0~1的长宽比例值。
};

import requests

with open('./1.jpg', 'rb') as f:
    img = f.read()
    result = requests.post(
	    'http://127.0.0.1:24401/',
	    params={'threshold': 0.1},
	    data=img).json()

FileStream fs = new FileStream("./img.jpg", FileMode.Open);
BinaryReader br = new BinaryReader(fs);
byte[] img = br.ReadBytes((int)fs.Length);
br.Close();
fs.Close();
string url = "http://127.0.0.1:8402?threshold=0.1";
HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
request.Method = "POST";
Stream stream = request.GetRequestStream();
stream.Write(img, 0, img.Length);
stream.Close();

WebResponse response = request.GetResponse();
StreamReader sr = new StreamReader(response.GetResponseStream());
Console.WriteLine(sr.ReadToEnd());
sr.Close();
response.Close();

#include <sys/stat.h>
    #include <curl/curl.h>
    #include <iostream>
    #include <string>
    #define S_ISREG(m) (((m) & 0170000) == (0100000))   
    #define S_ISDIR(m) (((m) & 0170000) == (0040000))   
    
    size_t write_callback(void *ptr, size_t size, size_t num, void *data) {
        std::string *str = dynamic_cast<std::string *>((std::string *)data);
        str->append((char *)ptr, size*num);
        return size*num;
    }
    
    int main(int argc, char *argv[]) {
        const char *post_data_filename = "./img.jpg";
        FILE *fp = NULL;
        std::string response;
        struct stat stbuf = { 0, };
        fp = fopen(post_data_filename, "rb");
        if (!fp) {
            fprintf(stderr, "Error: failed to open file "%s"
    ", post_data_filename);
            return -1;
        }
        if (fstat(fileno(fp), &stbuf) || !S_ISREG(stbuf.st_mode)) {
            fprintf(stderr, "Error: unknown file size "%s"
    ", post_data_filename);
            return -1;
        }
        CURL *curl;
        CURLcode res;
        curl_global_init(CURL_GLOBAL_ALL);
        curl = curl_easy_init();
        if (curl != NULL) {
            curl_easy_setopt(curl, CURLOPT_URL, "http://127.0.0.1:24401?threshold=0.1");
            curl_easy_setopt(curl, CURLOPT_POST, 1L);
            curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE_LARGE,(curl_off_t)stbuf.st_size);
            curl_easy_setopt(curl, CURLOPT_READDATA, (void *)fp);
    		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
            curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
            res = curl_easy_perform(curl);
    
            if (res != CURLE_OK) {
                fprintf(stderr, "curl_easy_perform() failed: %s
    ", curl_easy_strerror(res));
            }
            std::cout << response << std::endl; // response即为返回的json数据
            curl_easy_cleanup(curl);
        }
        curl_global_cleanup();
        fclose(fp);
        return 0;
    }

{
    "cost_ms": 52,
    "error_code": 0,
    "results": [
        {
            "confidence": 0.94482421875,
            "index": 1,
            "label": "IronMan",
            "x1": 0.059185408055782318,
            "x2": 0.18795496225357056,
            "y1": 0.14762254059314728,
            "y2": 0.52510076761245728
        },
        {
            "confidence": 0.94091796875,
            "index": 1,
            "label": "IronMan",
            "x1": 0.79151463508605957,
            "x2": 0.92310667037963867,
            "y1": 0.045728668570518494,
            "y2": 0.42920106649398804
        }
      ]
}

    /**
     * @brief 获取输入源的下一帧
     * @param frame_tensor
     * @return
     */
    virtual int next(FrameTensor &frame_tensor) = 0;

    /**
     * @brief 显示当前frame_tensor中的视频帧
     * @param frame_tensor
     * @return
     */
    virtual int display(const FrameTensor &frame_tensor) = 0;

    /**
     * @brief 将当前frame_tensor中的视频帧写为本地视频文件
     * @param frame_tensor
     * @return
     */
    virtual int save(FrameTensor &frame_tensor) = 0;

    /**
     * @brief 获取视频的fps属性
     * @return
     */
    virtual int get_fps() = 0;
     /**
      * @brief 获取视频的width属性
      * @return
      */
    virtual int get_width() = 0;

    /**
     * @brief 获取视频的height属性
     * @return
     */
    virtual int get_height() = 0;

/**
 * @brief 视频源、抽帧策略、存储策略的设置选项
 */
struct VideoConfig {
    SourceType source_type;            // 输入源类型
    std::string source_value;          // 输入源地址，如视频文件路径、摄像头index、网络流地址
    int skip_frames{0};                // 设置跳帧，每隔skip_frames帧抽取一帧，并把该抽取帧的is_needed置为true
    int retrieve_all{false};           // 是否抽取所有frame以便于作为显示和存储，对于不满足skip_frames策略的frame，把所抽取帧的is_needed置为false
    int input_fps{0};                  // 在采取抽帧之前设置视频的fps
    Resolution resolution{Resolution::kAuto}; // 采样分辨率，只对camera有效

    bool enable_display{false};
    std::string window_name{"EasyEdge"};
    bool display_all{false};           // 是否显示所有frame，若为false，仅显示根据skip_frames抽取的frame

    bool enable_save{false};
    std::string save_path;             // frame存储为视频文件的路径
    bool save_all{false};              // 是否存储所有frame，若为false，仅存储根据skip_frames抽取的frame

    std::map::string, std::string> conf;
};

video_config.conf["backend"] = "2";

EdgeLogConfig log_config;
log_config.enable_debug = true;
global_controller()->set_log_config(log_config);

find_package(CURL REQUIRED)
target_link_libraries(easyedge_demo  ${OpenCV_LIBS} easyedge_static pthread ${CURL_LIBRARIES} paddle-mobile)

headers = curl_slist_append(headers, "Expect:");

ethaddr=00:0a:35:00:00:09
uenvcmd=fatload mmc 1 0x3000000 image.ub && bootm 0x3000000

bootargs=earlycon console=ttyPS0,115200 clk_ignore_unused cpuidle.off=1 root=/dev/mmcblk1p2 rw rootwait cma=128M

libeasyedge.so: file format not recognized; treating as linker script