原创 杨亦诚 文章转自：OpenVINO中文社区

meter_test/|-- 20190822_105.jpg|-- 20190822_142.jpg|-- ... ...

$ mo --input_model meter_det_model/model.pdmodel$ mo --input_model meter_seg_model/model.pdmodel

meter_det_model/|-- model.xml|-- model.bin|-- model.mapping

$ git clone https://github.com/OpenVINO-dev-contest/meter_reader_openvino_cpp.git

cmake_minimum_required(VERSION 3.10)set(CMAKE_CXX_STANDARD 11)find_package(OpenCV REQUIRED)#find_package(OpenVINO REQUIRED)
set(openvino_LIBRARIES "/home/ethan/intel/openvino_2022.1.0.643/runtime/lib/intel64/libopenvino.so")
include_directories(    ./    /home/ethan/intel/openvino_2022.1.0.643/runtime/include    /home/ethan/intel/openvino_2022.1.0.643/runtime/include/ie    /home/ethan/intel/openvino_2022.1.0.643/runtime/include/ngraph    /home/ethan/intel/openvino_2022.1.0.643/runtime/include/openvino    ${OpenCV_INCLUDE_DIR})link_directories("/home/ethan/intel/openvino_2022.1.0.643/runtime/lib")aux_source_directory(src SRC)add_executable(meter_reader main.cpp ${SRC})target_link_librarie***eter_reader PRIVATE ${openvino_LIBRARIES} ${OpenCV_LIBS})

$ cd ~/meter_reader_openvino_cpp $ mkdir build && cd build $ cmake .. $ make

include <openvino/openvino.hpp>ov::Core core;

ov::CompiledModel compied_model = core.compile_model("model.xml", "AUTO");

ov::InferRequest infer_request = compiled_model.create_infer_request();

// Get input port for model with one inputauto input_port = compiled_model.input();// Create tensor from external memoryov::Tensor input_tensor(input_port.get_element_type(), input_port.get_shape(), memory_ptr);// Set input tensor for model with one inputinfer_request.set_input_tensor(input_tensor);

infer_request.start_async();infer_request.wait();

// Get output tensor by tensor nameauto output = infer_request.get_tensor("tensor_name");const float \*output_buffer = output.data<const float>();

bool Detector::init(string model_path, double threshold){    _model_path = model_path;    _threshold = threshold;    ov::Core core;    shared_ptr<ov::Model> model = core.read_model(_model_path);    map<string, ov::PartialShape> name_to_shape;    name_to_shape["image"] = ov::PartialShape{1, 3, 608, 608};    name_to_shape["im_shape"] = ov::PartialShape{1, 2};    name_to_shape["scale_factor"] = ov::PartialShape{1, 2};    model->reshape(name_to_shape);    ov::CompiledModel detect_model = core.compile_model(model, "CPU");    detect_infer_request = detect_model.create_infer_request();    return true;}
bool Detector::process_frame(Mat &src_img, vector<Rect> &detected_objects){    int total_num = 22743;    float mean[3] = {0.485, 0.456, 0.406};    float std[3] = {0.229, 0.224, 0.225};    float height = src_img.rows;    float width = src_img.cols;    float scale_x = width / 608 * 2;    float scale_y = height / 608;
    Mat img;    resize(src_img, img, Size(608, 608));    ov::Tensor input_tensor0 = detect_infer_request.get_tensor("im_shape");    ov::Tensor input_tensor1 = detect_infer_request.get_tensor("image");    ov::Tensor input_tensor2 = detect_infer_request.get_tensor("scale_factor");    // nhwc -> nchw    auto data1 = input_tensor1.data<float>();    for (int h = 0; h < 608; h++)    {        for (int w = 0; w < 608; w++)        {            for (int c = 0; c < 3; c++)            {                int out_index = c * 608 * 608 + h * 608 + w;                data1[out_index] = float(((float(img.at<Vec3b>(h, w)[c]) / 255.0f) - mean[c]) / std[c]);            }        }    }
    auto data0 = input_tensor0.data<float>();    data0[0] = 608;    data0[1] = 608;
    auto data2 = input_tensor2.data<float>();    data2[0] = 1;    data2[1] = 2;
    //start inference    detect_infer_request.infer();
    //extract the output data    auto output = detect_infer_request.get_output_tensor(0);    const float *result = output.data<const float>();    for (int num = 0; num < total_num; num++)    {        auto box_prob = result[num * 6 + 1];        if (box_prob > _threshold && box_prob <= 1)        {            float x0 = result[num * 6 + 2] * scale_x;            float y0 = result[num * 6 + 3] * scale_y;            float x1 = result[num * 6 + 4] * scale_x;            float y1 = result[num * 6 + 5] * scale_y;            Rect rect = Rect(round(x0), round(y0), round(x1 - x0), round(y1 - y0));            detected_objects.push_back(rect);        }    }
    return true;}

bool Segmenter::init(string model_path){    _model_path = model_path;    ov::Core core;    shared_ptr<ov::Model> model = core.read_model(_model_path);    map<string, ov::PartialShape> name_to_shape;    model->reshape({{-1, 3, 512, 512}});    ov::CompiledModel segment_model = core.compile_model(model, "CPU");    segment_infer_request = segment_model.create_infer_request();    return true;}
bool Segmenter::process_frame(vector<Mat> &inframes, vector<Mat> &masks){    static map<int32_t, Vec3b> color_table = {        {0, Vec3b(0, 0, 0)},        {1, Vec3b(20, 59, 255)},        {2, Vec3b(120, 59, 200)},    };    float mean[3] = {0.5, 0.5, 0.5};    float std[3] = {0.5, 0.5, 0.5};
    int batch_size = inframes.size();    ov::Tensor input_tensor0 = segment_infer_request.get_input_tensor(0);    input_tensor0.set_shape({batch_size, 3, 512, 512});    auto data0 = input_tensor0.data<float>();    // nhwc -> nchw    for (int batch = 0; batch < batch_size; batch++)    {        resize(inframe***atch], inframe***atch], Size(512, 512));        for (int h = 0; h < 512; h++)        {            for (int w = 0; w < 512; w++)            {                for (int c = 0; c < 3; c++)                {                    int out_index = batch * 3 * 512 * 512 + c * 512 * 512 + h * 512 + w;                    data0[out_index] = float(((float(inframe***atch].at<Vec3b>(h, w)[c]) / 255.0f) - mean[c]) / std[c]);                }            }        }    }
    //start inference    segment_infer_request.infer();
    //extract the output data    auto output = segment_infer_request.get_output_tensor(0);    const float *result = output.data<const float>();    // nchw -> nhwc    for (int batch = 0; batch < batch_size; batch++)    {        Mat mask = Mat::zeros(512, 512, CV_8UC1);        for (int h = 0; h < 512; h++)        {            for (int w = 0; w < 512; w++)            {                int argmax_id;                float max_conf = numeric_limits<float>::min();                for (int c = 0; c < 3; c++)                {                    int out_index = batch * 3 * 512 * 512 + c * 512 * 512 + h * 512 + w;                    float out_value = result[out_index];                    if (out_value > max_conf)                    {                        argmax_id = c;                        max_conf = out_value;                    }                }                mask.at<uchar>(h, w) = argmax_id;            }        }        masks.push_back(mask);    }
    return true;}

bool Erode(const int32_t &kernel_size,           const vector<Mat> &seg_results,           vector<vector<uint8_t>> *seg_label_maps);
bool CircleToRectangle(    const vector<uint8_t> &seg_label_map,    vector<uint8_t> *rectangle_meter);
bool RectangleToLine(const vector<uint8_t> &rectangle_meter,                     vector<int> *line_scale,                     vector<int> *line_pointer);
bool MeanBinarization(const vector<int> &data,                      vector<int> *binaried_data);
bool LocateScale(const vector<int> &scale,                 vector<float> *scale_location);
bool LocatePointer(const vector<int> &pointer,                   float *pointer_location);
bool GetRelativeLocation(    const vector<float> &scale_location,    const float &pointer_location,    MeterResult *result);
bool CalculateReading(const MeterResult &result,                      float *reading);
bool PrintMeterReading(const vector<float> &readings);
bool Visualize(Mat &img,               vector<Rect> &detected_objects,               const vector<float> &readings);
bool GetMeterReading(    const vector<vector<uint8_t>> &seg_label_maps,    vector<float> *readings);