OpenVINO 目标检测底层C++代码改写实现（待优化）

python3.6 mo_tf.py  --input_model=/home/gsj/object-detection/test_models/ssd_inception_v2_coco_2018_01_28/frozen_inference_graph.pb --tensorflow_use_custom_operations_config /opt/intel/openvino_2019.2.201/deployment_tools/model_optimizer/extensions/front/tf/ssd_v2_support.json --tensorflow_object_detection_api_pipeline_config /home/gsj/object-detection/test_models/ssd_inception_v2_coco_2018_01_28/pipeline.config --reverse_input_channels --batch 32

main.cpp   self_object_detection_engine_head.h 
CMakeLists.txt  README.md  self_object_detection.h

  1 // Copyright (C) 2018-2019 Intel Corporation
  2 // SPDX-License-Identifier: Apache-2.0
  3 //
  4 /*******************************************************************
  5 * Copyright:2019-2030,CC
  6 * File Name: self_object_detection_engine_head.h
  7 * Description: main function includes ObjectDetection,  8 *                          Initialize_Check,readInputimagesNames,  9 *                          load_inference_engine,readIRfiles, 10 *                          prepare_input_blobs,load_and_create_request,*                          
 11 *                          prepare_input,process
 12 *Author: Gao Shengjun
 13 *Date: 2019-07-19
 14 *******************************************************************/
 15 #include <gflags/gflags.h>
 16 #include <iostream>
 17 #include <string>
 18 #include <memory>
 19 #include <vector>
 20 #include <algorithm>
 21 #include <map>
 22 
 23 #include <format_reader_ptr.h>
 24 #include <inference_engine.hpp>
 25 #include <ext_list.hpp>
 26 
 27 #include <samples/common.hpp>
 28 #include <samples/slog.hpp>
 29 #include <samples/args_helper.hpp>
 30 
 31 #include <vpu/vpu_tools_common.hpp>
 32 #include <vpu/vpu_plugin_config.hpp>
 33 
 34 #include "self_object_detection_engine_head.h"
 35 
 36 
 37 bool ParseAndCheckCommandLine(int argc,char *argv[]) {
 38     gflags::ParseCommandLineNonHelpFlags(&argc,&argv,true);
 39     if (FLAGS_h) {
 40         showUsage();
 41         showAvailableDevices();
 42         return false;
 43     }
 44 
 45     slog::info << "Parsing input parameters" << slog::endl;
 46 
 47     if (FLAGS_i.empty()) {
 48         throw std::logic_error("Parameter -i is not set");
 49     }
 50 
 51     if (FLAGS_m.empty()) {
 52         throw std::logic_error("Parameter -m is not set");
 53     }
 54 
 55     return true;
 56 }
 57 
 58 
 59 
 60 static std::map<std::string,std::string> configure(const std::string& confFileName) {
 61     auto config = parseConfig(confFileName);
 62 
 63     return config;
 64 }
 65 
 66 
 67 
 68 void Initialize_Check_params(int argc,char* argv[]){
 69       slog::info << "InferenceEngine: " << GetInferenceEngineVersion()<<"n";
 70       if(!ParseAndCheckCommandLine(argc,argv)){
 71           slog::info<<"Check successfully"<<"n";
 72           return ;
 73       }
 74       return;
 75 }
 76 
 77 
 78 
 79 std::vector<std::string> readInputimagesNames(){
 80         std::vector<std::string>images;
 81         parseInputFilesArguments(images);
 82         if(images.empty()) throw std::logic_error("No suitable images were found");
 83         return images;
 84 }
 85 
 86 
 87 void load_inference_engine(Core &ie){
 88        slog::info <<"Loading Inference Engine"<<slog::endl;
 89        slog::info <<"Device info:" <<slog::endl;
 90        std::cout<<ie.GetVersions(FLAGS_d);
 91        if(FLAGS_p_msg){
 92        ie.SetLogCallback(error_listener);
 93        }
 94        if (FLAGS_d.find("CPU")!=std::string::npos){
 95           ie.AddExtension(std::make_shared<Extensions::Cpu::CpuExtensions>(),"CPU");
 96        }
 97        if(!FLAGS_l.empty()){
 98           IExtensionPtr  extension_ptr = make_so_pointer<IExtension>(FLAGS_l);
 99           ie.AddExtension(extension_ptr,"CPU");
100           slog::info <<"CPU Extension loaded: "<<FLAGS_l<<slog::endl;
101        }
102        if(!FLAGS_c.empty()){
103           ie.SetConfig({{PluginConfigParams::KEY_CONFIG_FILE,FLAGS_c}},"GPU");
104           slog::info<<"GPU Extension loaded: "<<FLAGS_c<<slog::endl;
105        }
106 
107 }
108 
109 
110 struct NetworkReader_networkinfo readIRfiles(){
111       struct NetworkReader_networkinfo nettools;
112       std::string binFileName = fileNameNoExt(FLAGS_m) +".bin";
113       slog::info << "Loading network files:"
114             "nt" << FLAGS_m <<
115             "nt" << binFileName <<
116             slog::endl;
117       CNNNetReader  networkReader;
118       networkReader.ReadNetwork(FLAGS_m);
119       networkReader.ReadWeights(binFileName);
120       CNNNetwork network = networkReader.getNetwork();
121       nettools.networkReader = networkReader;
122       nettools.network = network;
123       return nettools;
124 }
125 
126 
127 
128 struct inputInfo_imageName prepare_input_blobs( CNNNetwork &network,CNNNetReader  &networkReader,InputsDataMap &inputsInfo){
129        slog::info << "Preparing input blobs" << slog::endl;
130        struct inputInfo_imageName res;
131        if (inputsInfo.size() != 1 && inputsInfo.size() != 2) throw std::logic_error("Sample supports topologies only with 1 or 2 inputs");
132        std::string imageInputName,imInfoInputName;
133        InputInfo::Ptr inputInfo  = nullptr;
134        SizeVector inputImageDims;
135        for(auto &item:inputsInfo){
136          if(item.second->getInputData()->getTensorDesc().getDims().size()==4){
137             imageInputName = item.first;
138             inputInfo = item.second;
139             slog::info<<"Batch size is "<<std::to_string(networkReader.getNetwork().getBatchSize())<<slog::endl;
140             Precision inputPrecision =Precision::U8;
141             item.second->setPrecision(inputPrecision);
142             }else if(item.second->getInputData()->getTensorDesc().getDims().size()==2){
143              imInfoInputName = item.first;
144              Precision inputPrecision = Precision::FP32;
145              item.second->setPrecision(inputPrecision);
146              if((item.second->getTensorDesc().getDims()[1]!=3 && item.second->getTensorDesc().getDims()[1]!=6)){
147                   throw std::logic_error("Invalid input info. Should be 3 or 6 values length");
148                }
149             }
150        }
151        if(inputInfo == nullptr){
152            inputInfo = inputsInfo.begin()->second;
153    }
154    res.inputInfo = inputInfo;
155    res.InputName = imageInputName;
156    res.imInfoInputName=imInfoInputName;
157    return res;
158 }
159 
160 
161 
162 struct outputInfoStruct prepare_output_blobs(CNNNetwork &network){
163    struct outputInfoStruct res_output;
164    slog::info << "Preparing output blobs" << slog::endl;
165    OutputsDataMap outputsInfo(network.getOutputsInfo());
166    std::string outputName;
167    DataPtr outputInfo;
168    for(const auto& out : outputsInfo){
169        if(out.second->getCreatorLayer().lock()->type=="DetectionOutput"){
170              outputName = out.first;
171              outputInfo = out.second;
172        }
173    }
174    if(outputInfo == nullptr){
175        throw std::logic_error("Can‘t find a DetectionOutput layers in the topology");
176    }
177    const SizeVector outputDims = outputInfo->getTensorDesc().getDims();
178    res_output.maxProposalCount=outputDims[2];
179    res_output.objectSize=outputDims[3];
180    res_output.outputName=outputName;
181    if (res_output.objectSize != 7) {
182             throw std::logic_error("Output item should have 7 as a last dimension");
183         }
184 
185    if (outputDims.size() != 4) {
186             throw std::logic_error("Incorrect output dimensions for SSD model");
187         }
188 
189    outputInfo->setPrecision(Precision::FP32);
190    return res_output;
191 }
192 
193 
194 
195 struct exenet_requests load_and_create_request(CNNNetwork& network,Core &ie){
196    struct exenet_requests res;
197    slog::info << "Loading model to the device" << slog::endl;
198    res.executable_network = ie.LoadNetwork(network,FLAGS_d,configure(FLAGS_config));
199    slog::info << "Create infer request" << slog::endl;
200    res.infer_request = res.executable_network.CreateInferRequest();
201    return res;
202 }
203 
204 
205 
206 
207 struct res_outputStruct prepare_input(std::vector<std::string>& images,CNNNetwork& network,struct inputInfo_imageName& res,InferRequest& infer_request,InputsDataMap& inputsInfo){
208      struct res_outputStruct output_res2;
209      std::vector<std::shared_ptr<unsigned char>> imageData,originalImagesData;
210      std::vector<size_t>imageWidths,imageHeights;
211      for(auto &i : images){
212          FormatReader::ReaderPtr reader(i.c_str());
213          if(reader.get()==nullptr){
214             slog::warn << "Image" + i + "cannot be read!" <<slog::endl;
215             continue;
216          }
217      std::shared_ptr<unsigned char>originalData(reader->getData());
218      std::shared_ptr<unsigned char>data(reader->getData(res.inputInfo->getTensorDesc().getDims()[3],res.inputInfo->getTensorDesc().getDims()[2]));
219      if(data.get()!=nullptr){
220           originalImagesData.push_back(originalData);
221           imageData.push_back(data);
222           imageWidths.push_back(reader->width());
223           imageHeights.push_back(reader->height());
224 
225         }
226 
227      }
228      if(imageData.empty())throw std::logic_error("Valid input images were not found!");
229      size_t batchSize = network.getBatchSize();
230      slog::info << "Batch Size is "<<std::to_string(batchSize)<<slog::endl;
231      if(batchSize!=imageData.size()){
232        slog::warn << "Number of images " + std::to_string(imageData.size()) + 233          "dosen‘t match batch size "+std::to_string(batchSize)<<slog::endl;
234      batchSize = std::min(batchSize,imageData.size());
235      slog::warn <<"Number of images to be processed is "<<std::to_string(batchSize)<<slog::endl;
236     }
237     Blob::Ptr imageInput = infer_request.GetBlob(res.InputName);
238     size_t num_channels = imageInput->getTensorDesc().getDims()[1];
239     size_t image_size=imageInput->getTensorDesc().getDims()[3]*imageInput->getTensorDesc().getDims()[2];
240     unsigned char* data = static_cast<unsigned char*>(imageInput->buffer());
241     for(size_t image_id = 0 ; image_id < std::min(imageData.size(),batchSize);++image_id){
242        for(size_t pid = 0; pid < image_size; pid++){
243           for(size_t ch = 0 ; ch  < num_channels;++ch){
244              data[image_id*image_size*num_channels + ch*image_size+pid] = imageData.at(image_id).get()[pid*num_channels + ch];
245           }
246        }
247     }
248     if(res.imInfoInputName!=""){
249         Blob::Ptr input2 = infer_request.GetBlob(res.imInfoInputName);
250         auto imInfoDim = inputsInfo.find(res.imInfoInputName)->second->getTensorDesc().getDims()[1];
251         float *p = input2->buffer().as<PrecisionTrait<Precision::FP32>::value_type*>();
252         for(size_t image_id=0;image_id<std::min(imageData.size(),batchSize);++image_id){
253             p[image_id*imInfoDim+0] = static_cast<float>(inputsInfo[res.InputName]->getTensorDesc().getDims()[2]);
254             p[image_id*imInfoDim+1] = static_cast<float>(inputsInfo[res.InputName]->getTensorDesc().getDims()[3]);
255             for(size_t k = 2; k < imInfoDim; ++k){
256                p[image_id*imInfoDim+k]=1.0f;
257             }
258         }
259     }
260      output_res2.originalImagesData=originalImagesData;
261      output_res2.imageWidths=imageWidths;
262      output_res2.imageHeights=imageHeights;
263      output_res2.batchSize=batchSize;
264      slog::info<<"Start inference"<<slog::endl;
265      infer_request.Infer();
266      return output_res2;
267 }
268 
269 
270 
271 void process(InferRequest& infer_request,std::string& outputName,size_t& batchSize,const int& maxProposalCount,const int& objectSize,std::vector<size_t>& imageWidths,std::vector<size_t>& imageHeights,std::vector<std::shared_ptr<unsigned char>>& originalImagesData){
272     slog::info << "Processing output blobs" <<slog::endl;
273     const Blob::Ptr output_blob = infer_request.GetBlob(outputName);
274     const float* detection = static_cast<PrecisionTrait<Precision::FP32>::value_type*>(output_blob->buffer());
275     std::vector<std::vector<int>>boxes(batchSize);
276     std::vector<std::vector<int>>classes(batchSize);
277     std::cout<<imageWidths[0]<<"--"<<imageHeights[0]<<"   "<<detection[3]<<std::endl;
278     
279     for(int curProposal = 0; curProposal < maxProposalCount;curProposal++){
280        auto image_id = static_cast<int>(detection[curProposal * objectSize +0]);
281        if(image_id < 0){break;}
282        float confidence =detection[curProposal * objectSize + 2];
283        auto label = static_cast<int>(detection[curProposal * objectSize + 1]);
284        auto xmin  = static_cast<int>(detection[curProposal * objectSize + 3] * imageWidths[image_id]);
285        auto ymin  = static_cast<int>(detection[curProposal * objectSize + 4] * imageHeights[image_id]);
286        auto xmax  = static_cast<int>(detection[curProposal * objectSize + 5] * imageWidths[image_id]);
287        auto ymax  = static_cast<int>(detection[curProposal * objectSize + 6] * imageHeights[image_id]);
288        std::cout << "[" << curProposal << "," << label << "] element,prob = " << confidence <<
289                 "    (" << xmin << "," << ymin << ")-(" << xmax << "," << ymax << ")" << " batch id : " << image_id;
290        if(confidence > 0.3){
291            classes[image_id].push_back(label);
292            boxes[image_id].push_back(xmin);
293            boxes[image_id].push_back(ymin);
294            boxes[image_id].push_back(xmax - xmin);
295            boxes[image_id].push_back(ymax - ymin);
296            std::cout << " WILL BE PRINTED!";
297        }
298        std::cout<<std::endl;
299    }
300    for(size_t batch_id = 0 ; batch_id < batchSize; ++batch_id){
301         addRectangles(originalImagesData[batch_id].get(),imageHeights[batch_id],imageWidths[batch_id],boxes[batch_id],classes[batch_id],BBOX_THICKNESS);
302    const std::string image_path = "out_" + std::to_string(batch_id) + ".bmp";
303    if (writeOutputBmp(image_path,originalImagesData[batch_id].get(),imageWidths[batch_id])) {
304           slog::info << "Image " + image_path + " created!" << slog::endl;
305             } else {
306                 throw std::logic_error(std::string("Can‘t create a file: ") + image_path);
307             }
308 
309 }
310 
311 }
312 
313 /****************************************MAIN***************************************************/
314 
315 int main(int argc,char *argv[]) {
316     try {
317         /** This sample covers certain topology and cannot be generalized for any object detection one **/
318         // --------------------------- 1. Parsing and validation of input args ---------------------------------
319         Initialize_Check_params(argc,argv);
320         // --------------------------- 2. Read input -----------------------------------------------------------
321         /** This vector stores paths to the processed images **/
322         std::vector<std::string> images = readInputimagesNames();
323         // -----------------------------------------------------------------------------------------------------
324 
325         // --------------------------- 3. Load inference engine -------------------------------------
326         Core ie;
327         load_inference_engine(ie);
328 
329         // --------------------------- 4. Read IR Generated by ModelOptimizer (.xml and .bin files) ------------
330         CNNNetwork network = readIRfiles().network;
331         CNNNetReader networkReader = readIRfiles().networkReader;
332         // -----------------------------------------------------------------------------------------------------
333 
334         // --------------------------- 5. Prepare input blobs --------------------------------------------------
335           /** Taking information about all topology inputs **/
336           InputsDataMap inputsInfo(network.getInputsInfo());
337 
338           struct inputInfo_imageName res =  prepare_input_blobs(network,networkReader,inputsInfo);
339           InputInfo::Ptr inputInfo = res.inputInfo;
340           std::string imageInputName = res.InputName;
341           std::string imInfoInputName = res.imInfoInputName;
342 
343         // -----------------------------------------------------------------------------------------------------
344 
345         // --------------------------- 6. Prepare output blobs -------------------------------------------------
346         struct outputInfoStruct res_output = prepare_output_blobs(network);
347         const int maxProposalCount = res_output.maxProposalCount;
348         const int objectSize =res_output.objectSize;
349         std::string outputName = res_output.outputName;
350 
351         // -----------------------------------------------------------------------------------------------------
352 
353         // --------------------------- 7. Loading model to the device ------------------------------------------
354         struct exenet_requests exe_req =  load_and_create_request(network,ie);
355         ExecutableNetwork executable_network = exe_req.executable_network;
356         InferRequest infer_request = exe_req.infer_request;
357         // -----------------------------------------------------------------------------------------------------
358         // --------------------------- 8. Prepare input --------------------------------------------------------
359          struct res_outputStruct out_struct =prepare_input(images,network,res,infer_request,inputsInfo);
360         std::vector<std::shared_ptr<unsigned char>>originalImagesData=out_struct.originalImagesData;
361         std::vector<size_t>imageWidths=out_struct.imageWidths;
362         std::vector<size_t>imageHeights=out_struct.imageHeights;
363         size_t batchSize = out_struct.batchSize;
364         // -----------------------------------------------------------------------------------------------------
365         // --------------------------- 9. Process output -------------------------------------------------------
366          process(infer_request,outputName,batchSize,maxProposalCount,objectSize,imageWidths,imageHeights,originalImagesData);
367         // -----------------------------------------------------------------------------------------------------
368     }
369     catch (const std::exception& error) {
370         slog::err << error.what() << slog::endl;
371         return 1;
372     }
373     catch (...) {
374         slog::err << "Unknown/internal exception happened." << slog::endl;
375         return 1;
376     }
377 
378     slog::info << "Execution successful" << slog::endl;
379     slog::info << slog::endl << "This sample is an API example,for any performance measurements "
380                                 "please use the dedicated benchmark_app tool" << slog::endl;
381     return 0;
382 }

  1 /*******************************************************************
  2 * Copyright:2019-2030,CC
  3 * File Name: self_object_detection_engine_head.h
  4 * Description: main function includes ObjectDetection,  5 *                          Initialize_Check,  6 *                          load_inference_engine,  7 *                          prepare_input_blobs,*                          
  8 *                          prepare_input,process
  9 *Author: Gao Shengjun
 10 *Date: 2019-07-19
 11 *******************************************************************/
 12 #ifndef SELF_OBJECT_DETECTION_ENGINE_HEAD_H
 13 #define SELF_OBJECT_DETECTION_ENGINE_HEAD_H
 14 
 15 #include "self_object_detection.h"
 16 #include <gflags/gflags.h>
 17 #include <iostream>
 18 #include <string>
 19 #include <memory>
 20 #include <vector>
 21 #include <algorithm>
 22 #include <map>
 23 
 24 #include <format_reader_ptr.h>
 25 #include <inference_engine.hpp>
 26 #include <ext_list.hpp>
 27 
 28 #include <samples/common.hpp>
 29 #include <samples/slog.hpp>
 30 #include <samples/args_helper.hpp>
 31 
 32 #include <vpu/vpu_tools_common.hpp>
 33 #include <vpu/vpu_plugin_config.hpp>
 34 using namespace InferenceEngine;
 35 ConsoleErrorListener error_listener;
 36 
 37 typedef struct NetworkReader_networkinfo{
 38         CNNNetReader networkReader;
 39         CNNNetwork network;
 40       }NetworkReader_networkinfo;
 41 
 42 typedef struct inputInfo_imageName{
 43         InputInfo::Ptr inputInfo;
 44         std::string InputName;
 45         std::string imInfoInputName;
 46 
 47 }inputInfo_imageName;
 48 
 49 typedef struct outputInfoStruct{
 50       int maxProposalCount ;
 51       int objectSize; 
 52       std::string outputName; 
 53 }outputInfoStruct;
 54 
 55 typedef struct exenet_requests{
 56       ExecutableNetwork executable_network;
 57       InferRequest infer_request;
 58 
 59 }exenet_requests;
 60 
 61 typedef struct res_outputStruct {
 62    std::vector<std::shared_ptr<unsigned char>>originalImagesData;
 63    std::vector<size_t>imageWidths;
 64    std::vector<size_t>imageHeights;
 65    size_t batchSize;
 66  
 67 }res_outputStruct;
 68 
 69 #ifdef __cplusplus
 70 extern "C"
 71 {
 72 #endif
 73 
 74 /**
 75  * @brief get the version of the InferenceEngine and parse the input params,print the help information about the instruct if needed,check the required input params eg. the file of model and the input images both are required.
 76  
 77 
 78  * @ param[in] argc: the number of the input params, 79  *            argv: the vector to store the input params
 80  * @ param[out] None         
 81  */
 82 void Initialize_Check_params(int argc,char* argv[]);
 83 
 84 
 85 /**
 86  *@brief get the input images filenames and store the in a vector
 87 
 88  *@ param[in] None
 89  *@ param[out] return the filenames of the images
 90  *@ Parse the info of the inputimages by call " parseInputFilesArguments "  build in OpenVINO
 91  */
 92 std::vector<std::string> readInputimagesNames();
 93 
 94 
 95 /**
 96  * @brief load the extension_plugin according the specific devices,eg CPU,GPU
 97  * @ param[in] Core &ie
 98  * @ param[out] None
 99  */
100 void load_inference_engine(Core& ie);
101 
102 
103 
104 /**
105  * @brief read the proto and weights files which produced by openvino model optimizer tools of the network.
106  * @ param[in] flags_m: the model files *.bin,*.xml
107  * @ param[out] Struct contains NetworkReader and the structure info of the model
108  */
109 struct NetworkReader_networkinfo readIRfiles();
110 
111 
112 
113 /*
114  * @brief get the detail  InputsInfo for the blob format according the InputsInfo,and set the precision of the inputs according to the input format,eg,[NCHW]:U8 [HW]:FP32
115  * @ param[in] network,CNNNetReader,inputsInfo
116  * @ param[out] strcut contains the inputInfo,ImageInputName,the info name of the input Image 
117  */
118 struct inputInfo_imageName  prepare_input_blobs( CNNNetwork &network,InputsDataMap &inputsInfo);
119 
120 
121 
122 /*
123  * @brief get the info of the ouputs from the network by calling the OPENVINO‘s "getOutputsInof()" 
124  * @ param[in] network
125  * @ param[out] strcut contains the model‘s maxProposals,outputName
126  */
127 struct outputInfoStruct prepare_output_blobs(CNNNetwork &network);
128 
129 
130 /*
131  * @brief Load the network to the device and create the infer request
132  * @ param[in] network,Core
133  * @ param[out] struct contains the excuteable network and the inferRequest
134  */
135 struct exenet_requests load_and_create_request(CNNNetwork& network,Core &ie);
136 
137 
138 /*
139  * @brief read the input images and create the input blob and start the infer request
140  * @ param[in] images:the path of the images,network: the info of the model,inputInfo_imageName,inputsInfo
141  * @ param[out] return the data of the input images and its height,width,batchSize. 
142  */
143 struct res_outputStruct prepare_input(std::vector<std::string>& images,InputsDataMap& inputsInfo);
144 
145 
146 /*
147  * @brief get the output according the output_blob,and get the (label,xmin,ymin,xmax,ymax) about the detection boxes,I set the thread value :0.3 it gets the better result.
148  * @param [in] infer_request,originalImagesData
149  * @param [out] None
150  */
151 void process(InferRequest& infer_request,std::vector<std::shared_ptr<unsigned char>>& originalImagesData);
152 #ifdef __cplusplus
153 }
154 #endif
155 #endif

 1 // Copyright (C) 2018-2019 Intel Corporation
 2 // SPDX-License-Identifier: Apache-2.0
 3 //
 4 
 5 #pragma once
 6 
 7 #include <string>
 8 #include <vector>
 9 #include <gflags/gflags.h>
10 #include <iostream>
11 
12 /* thickness of a line (in pixels) to be used for bounding boxes */
13 #define BBOX_THICKNESS 2
14 
15 /// @brief message for help argument
16 static const char help_message[] = "Print a usage message.";
17 
18 /// @brief message for images argument
19 static const char image_message[] = "Required. Path to an .bmp image.";
20 
21 /// @brief message for model argument
22 static const char model_message[] = "Required. Path to an .xml file with a trained model.";
23 
24 /// @brief message for plugin argument
25 static const char plugin_message[] = "Plugin name. For example MKLDNNPlugin. If this parameter is pointed," 26 "the sample will look for this plugin only";
27 
28 /// @brief message for assigning cnn calculation to device
29 static const char target_device_message[] = "Optional. Specify the target device to infer on (the list of available devices is shown below). " 30 "Default value is CPU. Use "-d HETERO:<comma-separated_devices_list>" format to specify HETERO plugin. " 31 "Sample will look for a suitable plugin for device specified";
32 
33 /// @brief message for clDNN custom kernels desc
34 static const char custom_cldnn_message[] = "Required for GPU custom kernels. "35 "Absolute path to the .xml file with the kernels descriptions.";
36 
37 /// @brief message for user library argument
38 static const char custom_cpu_library_message[] = "Required for CPU custom layers. " 39 "Absolute path to a shared library with the kernels implementations.";
40 
41 /// @brief message for plugin messages
42 static const char plugin_err_message[] = "Optional. Enables messages from a plugin";
43 
44 /// @brief message for config argument
45 static constexpr char config_message[] = "Path to the configuration file. Default value: "config".";
46 
47 /// brief Define flag for showing help message <br>
48 DEFINE_bool(h,false,help_message);
49 
50 /// brief Define parameter for set image file <br>
51 /// It is a required parameter
52 DEFINE_string(i,"",image_message);
53 
54 /// brief Define parameter for set model file <br>
55 /// It is a required parameter
56 DEFINE_string(m,model_message);
57 
58 /// brief device the target device to infer on <br>
59 DEFINE_string(d,"CPU",target_device_message);
60 
61 /// @brief Define parameter for clDNN custom kernels path <br>
62 /// Default is ./lib
63 DEFINE_string(c,custom_cldnn_message);
64 
65 /// @brief Absolute path to CPU library with user layers <br>
66 /// It is a optional parameter
67 DEFINE_string(l,custom_cpu_library_message);
68 
69 /// @brief Enable plugin messages
70 DEFINE_bool(p_msg,plugin_err_message);
71 
72 /// @brief Define path to plugin config
73 DEFINE_string(config,config_message);
74 
75 /**
76 * brief This function show a help message
77 */
78 static void showUsage() {
79     std::cout << std::endl;
80     std::cout << "object_detection_sample_ssd [OPTION]" << std::endl;
81     std::cout << "Options:" << std::endl;
82     std::cout << std::endl;
83     std::cout << "    -h                      " << help_message << std::endl;
84     std::cout << "    -i "<path>"             " << image_message << std::endl;
85     std::cout << "    -m "<path>"             " << model_message << std::endl;
86     std::cout << "      -l "<absolute_path>"  " << custom_cpu_library_message << std::endl;
87     std::cout << "          Or" << std::endl;
88     std::cout << "      -c "<absolute_path>"  " << custom_cldnn_message << std::endl;
89     std::cout << "    -d "<device>"           " << target_device_message << std::endl;
90     std::cout << "    -p_msg                  " << plugin_err_message << std::endl;
91 }

./self_object_detection -m /opt/intel/openvino_2019.2.201/deployment_tools/model_optimizer/./frozen_inference_graph.xml -d CPU -i /home/gsj/dataset/coco_val/val96

[ INFO ] InferenceEngine:
        API version ............ 2.0
        Build .................. custom_releases/2019/R2_3044732e25bc7dfbd11a54be72e34d512862b2b3
        Description ....... API
Parsing input parameters
[ INFO ] Files were added: 8
[ INFO ]     /home/gsj/dataset/coco_val/val8/000000000785.jpg
[ INFO ]     /home/gsj/dataset/coco_val/val8/000000000139.jpg
[ INFO ]     /home/gsj/dataset/coco_val/val8/000000000724.jpg
[ INFO ]     /home/gsj/dataset/coco_val/val8/000000000285.jpg
[ INFO ]     /home/gsj/dataset/coco_val/val8/000000000802.jpg
[ INFO ]     /home/gsj/dataset/coco_val/val8/000000000632.jpg
[ INFO ]     /home/gsj/dataset/coco_val/val8/000000000872.jpg
[ INFO ]     /home/gsj/dataset/coco_val/val8/000000000776.jpg
[ INFO ] Loading Inference Engine
[ INFO ] Device info:
        CPU
        MKLDNNPlugin version ......... 2.0
        Build ........... 26451
[ INFO ] Loading network files:
        /opt/intel/openvino_2019.2.201/deployment_tools/model_optimizer/./frozen_inference_graph.xml
        /opt/intel/openvino_2019.2.201/deployment_tools/model_optimizer/./frozen_inference_graph.bin
[ INFO ] Loading network files:
        /opt/intel/openvino_2019.2.201/deployment_tools/model_optimizer/./frozen_inference_graph.xml
        /opt/intel/openvino_2019.2.201/deployment_tools/model_optimizer/./frozen_inference_graph.bin
[ INFO ] Preparing input blobs
[ INFO ] Batch size is 32
[ INFO ] Preparing output blobs
[ INFO ] Loading model to the device
[ INFO ] Create infer request
[ WARNING ] Image is resized from (640,425) to (300,300)
[ WARNING ] Image is resized from (640,426) to (300,300)
[ WARNING ] Image is resized from (375,500) to (300,300)
[ WARNING ] Image is resized from (586,640) to (300,300)
[ WARNING ] Image is resized from (424,483) to (300,300)
[ WARNING ] Image is resized from (621,300)
[ WARNING ] Image is resized from (428,300)
[ INFO ] Batch Size is 32
[ WARNING ] Number of images 8dosen‘t match batch size 32
[ WARNING ] Number of images to be processed is 8
[ INFO ] Start inference
[ INFO ] Processing output blobs
640--425   0.452099
[0,1] element,prob = 0.851202    (289,42)-(485,385) batch id : 0 WILL BE PRINTED!
[1,35] element,prob = 0.495117    (205,360)-(600,397) batch id : 0 WILL BE PRINTED!
[2,prob = 0.376695    (380,177)-(398,208) batch id : 1 WILL BE PRINTED!
[3,prob = 0.337178    (398,159)-(459,292) batch id : 1 WILL BE PRINTED!
[4,62] element,prob = 0.668834    (365,214)-(428,310) batch id : 1 WILL BE PRINTED!
[5,prob = 0.558071    (294,220)-(365,321) batch id : 1 WILL BE PRINTED!
[6,prob = 0.432652    (388,205)-(440,307) batch id : 1 WILL BE PRINTED!
[7,prob = 0.313619    (218,228)-(300,319) batch id : 1 WILL BE PRINTED!
[8,64] element,prob = 0.488229    (217,178)-(269,217) batch id : 1 WILL BE PRINTED!
[9,72] element,prob = 0.885867    (9,165)-(149,263) batch id : 1 WILL BE PRINTED!
[10,86] element,prob = 0.305516    (239,196)-(255,217) batch id : 1 WILL BE PRINTED!
[11,3] element,prob = 0.332538    (117,284)-(146,309) batch id : 2 WILL BE PRINTED!
[12,13] element,prob = 0.992781    (122,73)-(254,223) batch id : 2 WILL BE PRINTED!
[13,23] element,prob = 0.988277    (4,75)-(580,632) batch id : 3 WILL BE PRINTED!
[14,79] element,prob = 0.981469    (29,292)-(161,516) batch id : 4 WILL BE PRINTED!
[15,82] element,prob = 0.94848    (244,189)-(412,525) batch id : 4 WILL BE PRINTED!
[16,prob = 0.428106    (255,233)-(348,315) batch id : 5 WILL BE PRINTED!
[17,prob = 0.978832    (336,217)-(429,350) batch id : 5 WILL BE PRINTED!
[18,prob = 0.333557    (192,148)-(235,234) batch id : 5 WILL BE PRINTED!
[19,65] element,prob = 0.985633    (-5,270)-(404,477) batch id : 5 WILL BE PRINTED!
[20,84] element,prob = 0.882272    (461,246)-(472,288) batch id : 5 WILL BE PRINTED!
[21,prob = 0.874527    (494,192)-(503,223) batch id : 5 WILL BE PRINTED!
[22,prob = 0.850498    (482,247)-(500,285) batch id : 5 WILL BE PRINTED!
[23,prob = 0.844409    (461,296)-(469,335) batch id : 5 WILL BE PRINTED!
[24,prob = 0.787552    (414,24)-(566,364) batch id : 5 WILL BE PRINTED!
[25,prob = 0.748578    (524,189)-(533,224) batch id : 5 WILL BE PRINTED!
[26,prob = 0.735457    (524,98)-(535,133) batch id : 5 WILL BE PRINTED!
[27,prob = 0.712015    (528,49)-(535,84) batch id : 5 WILL BE PRINTED!
[28,prob = 0.689215    (496,51)-(504,82) batch id : 5 WILL BE PRINTED!
[29,prob = 0.620327    (456,192)-(467,224) batch id : 5 WILL BE PRINTED!
[30,prob = 0.614535    (481,154)-(514,173) batch id : 5 WILL BE PRINTED!
[31,prob = 0.609089    (506,151)-(537,172) batch id : 5 WILL BE PRINTED!
[32,prob = 0.604894    (456,148)-(467,181) batch id : 5 WILL BE PRINTED!
[33,prob = 0.554959    (485,102)-(505,125) batch id : 5 WILL BE PRINTED!
[34,prob = 0.549844    (508,244)-(532,282) batch id : 5 WILL BE PRINTED!
[35,prob = 0.404613    (437,143)-(443,180) batch id : 5 WILL BE PRINTED!
[36,prob = 0.366167    (435,245)-(446,287) batch id : 5 WILL BE PRINTED!
[37,prob = 0.320608    (438,191)-(446,226) batch id : 5 WILL BE PRINTED!
[38,prob = 0.996094    (197,115)-(418,568) batch id : 6 WILL BE PRINTED!
[39,prob = 0.9818    (266,99)-(437,542) batch id : 6 WILL BE PRINTED!
[40,prob = 0.517957    (152,117)-(363,610) batch id : 6 WILL BE PRINTED!
[41,40] element,prob = 0.302339    (154,478)-(192,542) batch id : 6 WILL BE PRINTED!
[42,88] element,prob = 0.98227    (8,24)-(372,533) batch id : 7 WILL BE PRINTED!
[43,prob = 0.924668    (0,268)-(323,640) batch id : 7 WILL BE PRINTED!
[ INFO ] Image out_0.bmp created!
[ INFO ] Image out_1.bmp created!
[ INFO ] Image out_2.bmp created!
[ INFO ] Image out_3.bmp created!
[ INFO ] Image out_4.bmp created!
[ INFO ] Image out_5.bmp created!
[ INFO ] Image out_6.bmp created!
[ INFO ] Image out_7.bmp created!
[ INFO ] Execution successful

[ INFO ] This sample is an API example,for any performance measurements please use the dedicated benchmark_app tool