Adapt object_detection_demo for batch processing

demos/common/cpp/models/include/models/detection_model_ssd.h

@@ -50,6 +50,9 @@ class ModelSSD : public DetectionModel {
              const std::string& layout = "");
 
     std::shared_ptr<InternalModelData> preprocess(const InputData& inputData, ov::InferRequest& request) override;
+    std::shared_ptr<InternalModelData> preprocess(std::vector<std::shared_ptr<InputData>>::iterator inputDataBegin,
+                                                                std::vector<std::shared_ptr<InputData>>::iterator inputDataEnd,
+                                                                ov::InferRequest& request) override;
     std::unique_ptr<ResultBase> postprocess(InferenceResult& infResult) override;
 
 protected:

demos/common/cpp/models/src/classification_model.cpp

@@ -44,27 +44,16 @@ ClassificationModel::ClassificationModel(const std::string& modelFileName,
 
 std::unique_ptr<ResultBase> ClassificationModel::postprocess(InferenceResult& infResult) {
     const ov::Tensor& indicesTensor = infResult.outputsData.find(outputsNames[0])->second;
-    const void* indicesTensorBuffer = reinterpret_cast<const void*>(indicesTensor.data());
-    std::cout << "-S- indices tensor data: " << indicesTensorBuffer <<  ", size: " << indicesTensor.get_size() << std::endl;
     const int* indicesPtr = indicesTensor.data<int>();
-    for (int i = 0; i < indicesTensor.get_size(); i++){
-        std::cout << "-S- index[" << i << "]: " << indicesPtr[i] <<std::endl;
-    }
     const ov::Tensor& scoresTensor = infResult.outputsData.find(outputsNames[1])->second;
     const float* scoresPtr = scoresTensor.data<float>();
-    const void* scoresTensorBuffer = reinterpret_cast<const void*>(scoresTensor.data());
-    std::cout << "-S- scores tensor data: " << scoresTensorBuffer << ", size: " << scoresTensor.get_size() <<std::endl;
-    for (int i = 0; i < scoresTensor.get_size(); i++){
-        std::cout << "-S- score[" << i << "]: " << scoresPtr[i] <<std::endl;
-    }
 
     ClassificationResult* result = new ClassificationResult(infResult.frameId, infResult.metaData);
     auto retVal = std::unique_ptr<ResultBase>(result);
 
     result->topLabels.reserve(scoresTensor.get_size());
     for (size_t i = 0; i < scoresTensor.get_size(); ++i) {
         int ind = indicesPtr[i];
-         std::cout << "-S- index???[" << i << "]: " << ind << ", labels size: " << labels.size() <<std::endl;
         if (ind < 0 || ind >= static_cast<int>(labels.size())) {
             throw std::runtime_error(std::string("Invalid index: ") + std::to_string(ind) + " for the class label is found during postprocessing, label size: " + std::to_string(labels.size()));
         }

demos/common/cpp/models/src/detection_model_ssd.cpp

@@ -53,6 +53,21 @@ std::shared_ptr<InternalModelData> ModelSSD::preprocess(const InputData& inputDa
     return DetectionModel::preprocess(inputData, request);
 }
 
+std::shared_ptr<InternalModelData> ModelSSD::preprocess(std::vector<std::shared_ptr<InputData>>::iterator inputDataBegin,
+                                                                std::vector<std::shared_ptr<InputData>>::iterator inputDataEnd,
+                                                                ov::InferRequest& request) {
+    if (inputsNames.size() > 1) {
+        const auto& imageInfoTensor = request.get_tensor(inputsNames[1]);
+        const auto info = imageInfoTensor.data<float>();
+        info[0] = static_cast<float>(netInputHeight);
+        info[1] = static_cast<float>(netInputWidth);
+        info[2] = 1;
+        request.set_tensor(inputsNames[1], imageInfoTensor);
+    }
+
+    return DetectionModel::preprocess(inputDataBegin, inputDataEnd, request);
+}
+
 std::unique_ptr<ResultBase> ModelSSD::postprocess(InferenceResult& infResult) {
     return outputsNames.size() > 1 ? postprocessMultipleOutputs(infResult) : postprocessSingleOutput(infResult);
 }

demos/common/cpp/models/src/image_model.cpp

@@ -43,12 +43,15 @@ std::shared_ptr<InternalModelData> ImageModel::preprocess(std::vector<std::share
     const size_t width = tensorShape[ov::layout::width_idx(layout)];
     const size_t height = tensorShape[ov::layout::height_idx(layout)];
     const size_t channels = tensorShape[ov::layout::channels_idx(layout)];
-    std::cout << "ImageModel::preprocess: batch: " << batch << ", width: " << width << ", height: " << height << ", channels: " << channels << std::endl;
     char* memoryBlob = nullptr;
     size_t image_index = 0;
     bool isMatFloat = false;
     int origImg_cols = 0;
     int origImg_rows = 0;
+    size_t image_count = std::distance(inputDataBegin, inputDataEnd);
+    if (image_count != batch) {
+        throw std::runtime_error("Image count in preprocess must repeat batch count");
+    }
     for (auto inputDataIt = inputDataBegin; inputDataIt != inputDataEnd; ++inputDataIt ) {
         const auto& origImg = (*inputDataIt)->asRef<ImageInputData>().inputImage;
         origImg_cols = origImg.cols;
@@ -75,7 +78,6 @@ std::shared_ptr<InternalModelData> ImageModel::preprocess(std::vector<std::share
             img = resizeImageExt(img, width, height, resizeMode, interpolationMode);
         }
         size_t sizeInBytes = img.total() * img.elemSize();
-        std::cout << "image size in bytes: " << sizeInBytes << std::endl;
         if (!memoryBlob) {
             memoryBlob = new char[sizeInBytes * batch]; // intended memory leak
         }
@@ -85,7 +87,6 @@ std::shared_ptr<InternalModelData> ImageModel::preprocess(std::vector<std::share
         image_index++;
     }
 
-    std::cout << "isMatFloat: " << isMatFloat << std::endl;
     auto precision = isMatFloat ? ov::element::f32 : ov::element::u8;
     auto batched_tensor =  ov::Tensor(precision, ov::Shape{ batch, height, width, channels }, memoryBlob);
     request.set_tensor(inputsNames[0], batched_tensor);

demos/common/cpp/pipelines/include/pipelines/metadata.h

@@ -40,6 +40,31 @@ struct ImageMetaData : public MetaData {
     ImageMetaData(cv::Mat img, std::chrono::steady_clock::time_point timeStamp) : img(img), timeStamp(timeStamp) {}
 };
 
+struct ImageBatchMetaData : public MetaData {
+    std::chrono::steady_clock::time_point timeStamp;
+    std::vector<std::shared_ptr<ImageMetaData>> metadatas;
+
+    ImageBatchMetaData() {}
+
+    ImageBatchMetaData(std::vector<cv::Mat>::iterator imagesBeginIt,
+                       const std::vector<cv::Mat>::iterator imagesEndIt,
+                       std::chrono::steady_clock::time_point timeStamp) : timeStamp(timeStamp) {
+        size_t images_count = std::distance(imagesBeginIt, imagesEndIt);
+        metadatas.reserve(images_count);
+        for (; imagesBeginIt != imagesEndIt;) {
+            metadatas.push_back(std::make_shared<ImageMetaData>(*imagesBeginIt++, timeStamp));
+        }
+    }
+
+    void add(cv::Mat img, std::chrono::steady_clock::time_point timeStamp) {
+        metadatas.push_back(std::make_shared<ImageMetaData>(img, timeStamp));
+        this->timeStamp = timeStamp;
+    }
+    void clear() {
+        metadatas.clear();
+    }
+};
+
 struct ClassificationImageMetaData : public ImageMetaData {
     unsigned int groundTruthId;
 

demos/common/cpp/pipelines/src/async_pipeline.cpp

@@ -95,7 +95,6 @@ int64_t AsyncPipeline::submitData(std::vector<std::shared_ptr<InputData>>::itera
             {
                 const std::lock_guard<std::mutex> lock(mtx);
                 inferenceMetrics.update(startTime);
-                std::cout << "callback has been called" << std::endl;
                 try {
                     if (ex) {
                         std::rethrow_exception(ex);
@@ -108,14 +107,11 @@ int64_t AsyncPipeline::submitData(std::vector<std::shared_ptr<InputData>>::itera
 
                     for (const auto& outName : model->getOutputsNames()) {
                         auto tensor = request.get_tensor(outName);
-                        std::cout << "-S- output tensorName: " << outName << ", tensor ptr: " << reinterpret_cast<void*>(tensor.data()) << ", size: " << tensor.get_size() << std::endl;
                         result.outputsData.emplace(outName, tensor);
                     }
 
                     completedInferenceResults.emplace(frameID, result);
-                    std::cout << "before setRequestIdle: " << std::endl;
                     requestsPool->setRequestIdle(request);
-                    std::cout << "after setRequestIdle: " << std::endl;
                 } catch (...) {
                     if (!callbackException) {
                         callbackException = std::current_exception();