Linux-CPP-SDK-Device

getconf LONG_BIT
32

# 这里修改并填入所使用的bmnnsdk路径
set(EDGE_BMSDK_ROOT "{这里填写sdk路径}")

cd src
mkdir build && cd build
cmake .. && make
./easyedge_image_inference {模型RES文件夹}  {测试图片路径}
# 如果是NNIE引擎，使用sudo运行
sudo ./easyedge_image_inference {模型RES文件夹}  {测试图片路径}

cmake -DEDGE_BUILD_OPENCV=ON .. && make -j16

cp ${cpp_kit位置路径}/thirdparty/openvino/deployment_tools/inference_engine/external/97-myriad-usbboot.rules /etc/udev/rules.d/
sudo udevadm control --reload-rules
sudo udevadm trigger
sudo ldconfig

 > ./easyedge_image_inference ../../../../RES 2.jpeg
2019-02-13 16:46:12,659 INFO [EasyEdge] [easyedge.cpp:34] 140606189016192 Baidu EasyEdge Linux Development Kit 0.2.1(20190213)
2019-02-13 16:46:14,083 INFO [EasyEdge] [paddlev2_edge_predictor.cpp:60] 140606189016192 Allocate graph success.
2019-02-13 16:46:14,326 DEBUG [EasyEdge] [paddlev2_edge_predictor.cpp:143] 140606189016192 Inference costs 168 ms
1, 1:txt_frame, p:0.994905 loc: 0.168161, 0.153654, 0.920856, 0.779621
Done

# ./easyedge_serving {res_dir} {serial_key} {host, default 0.0.0.0} {port, default 24401}
 ./easyedge_serving ../../../RES "1111-1111-1111-1111" 0.0.0.0  24401

HTTP is now serving at 0.0.0.0:24401

    // step 1: 配置运行参数
    EdgePredictorConfig config;
    config.model_dir = {模型文件目录};

    // step 2: 创建并初始化Predictor；这这里选择合适的引擎
    auto predictor = global_controller()->CreateEdgePredictor(config);

    // step 3-1: 预测图像
    auto img = cv::imread({图片路径});
    std::vector<EdgeResultData> results;
    predictor->infer(img, results);

	// step 3-2: 预测视频
	std::vector<EdgeResultData> results;
	FrameTensor frame_tensor;
	VideoConfig video_config;
	video_config.source_type = static_cast<SourceType>(video_type);  // source_type 定义参考头文件 easyedge_video.h
	video_config.source_value = video_src;
	/*
	... more video_configs, 根据需要配置video_config的各选项
	*/
	auto video_decoding = CreateVideoDecoding(video_config);
	while (video_decoding->next(frame_tensor) == EDGE_OK) {
	    results.clear();
	    if (frame_tensor.is_needed) {
	        predictor->infer(frame_tensor.frame, results);
	        render(frame_tensor.frame, results, predictor->model_info().kind);
	    }
	    //video_decoding->display(frame_tensor); // 显示当前frame，需在video_config中开启配置
	    //video_decoding->save(frame_tensor); // 存储当前frame到视频，需在video_config中开启配置
	 }

/**
 * @brief 序列号设置；序列号不设置留空时，SDK将会自动尝试使用本地已经激活成功的有效期内的序列号
 * 值类型：string
 * 默认值：空
 */
static constexpr auto PREDICTOR_KEY_SERIAL_NUM = "PREDICTOR_KEY_SERIAL_NUM";

EdgePredictorConfig config;
config.model_dir = ...;
config.set_config(params::PREDICTOR_KEY_SERIAL_NUM, "1DB7-1111-1111-D27D");

auto predictor = global_controller()->CreateEdgePredictor(config);
predictor->init();

 /**
  * @brief
  * 通用接口
  * @param image: must be BGR , HWC format (opencv default)
  * @param result
  * @return
  */
 virtual int infer(
         cv::Mat& image, std::vector<EdgeResultData>& result
 ) = 0;

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

    // 物体检测活图像分割时才有
    float x1, y1, x2, y2;  // (x1, y1): 左上角， （x2, y2): 右下角； 均为0~1的长宽比例值。

    // 图像分割时才有
    cv::Mat mask;  // 0, 1 的mask
    std::string mask_rle;  // Run Length Encoding，游程编码的mask
};

cv::Mat mask为图像掩码的二维数组
{
  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 1, 1, 1, 0, 0, 0, 0},
  {0, 0, 0, 1, 1, 1, 0, 0, 0, 0},
  {0, 0, 0, 1, 1, 1, 0, 0, 0, 0},
  {0, 0, 0, 1, 1, 1, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
}
其中1代表为目标区域，0代表非目标区域

    /**
     * @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<std::string, std::string> conf;
};

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

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

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

 /**
     * @brief 开启一个简单的demo http服务。
     * 该方法会block直到收到sigint/sigterm。
     * http服务里，图片的解码运行在cpu之上，可能会降低推理速度。
     * @tparam ConfigT
     * @param config
     * @param host
     * @param port
     * @param service_id service_id  user parameter, uri '/get/service_id' will respond this value with 'text/plain'
     * @param instance_num 实例数量，根据内存/显存/时延要求调整
     * @return
     */
    template<typename ConfigT>
    int start_http_server(
            const ConfigT &config,
            const std::string &host,
            int port,
            const std::string &service_id,
            int instance_num = 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()

import requests

with open('./1.jpg', 'rb') as f:
    img_data = f.read()
    res = requests.post('http://127.0.0.1:24401/',
        data=img_data)
    with open("gray_result.png", "wb") as fb:
        fb.write(res.content) # 语义分割模型是像素点级别输出，可将api返回结果保存为灰度图，每个像素值代表该像素分类结果

{
	"image": "<base64数据>"
	"top_num": 5
}

{
	"image": "<base64数据>"
}

import base64
import requests


def main():
    with open("1.jpg 【图片路径】", 'rb') as f:
        result = requests.post("http://{服务ip地址}:24401/", json={
            "image": base64.b64encode(f.read()).decode("utf8")
        })
        # print(result.request.body)
        # print(result.request.headers)
        print(result.content)


if __name__ == '__main__':
    main()

import base64
import requests
def main():
    with open("1.jpg 【图片路径】", 'rb') as f:
        res = requests.post("http://{服务ip地址}:24401/", json={"image": base64.b64encode(f.read()).decode("utf8")})
        with open("gray_result.png", "wb") as fb:
            fb.write(res.content) # 语义分割模型是像素点级别输出，可将api返回结果保存为灰度图，每个像素值代表该像素分类结果
if __name__ == '__main__':
    main()

{
    "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,
            "mask": "...",  // 图像分割模型字段
            "trackId": 0,  // 目标追踪模型字段
        },
        
      ]
}

global_controller()->set_config(easyedge::params::KEY_LOG_BRAND, "MY_BRAND");

open sys: Permission denied
open err
: Permission denied
open err
: Permission denied

export HTTP_PROXY="http://192.168.1.100:8888"
./easyedge_demo ...

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

LD_LIBRARY_PATH=$LD_LIBRARY_PATH:../lib ./easyedge_demo