Remove async from public api side

Author: RHeckerIntel

examples/cpp/CMakeLists.txt

@@ -94,5 +94,4 @@ find_package(OpenCV REQUIRED COMPONENTS imgcodecs)
 
 add_subdirectory(../../src/cpp ${Samples_BINARY_DIR}/src/cpp)
 
-add_example(NAME asynchronous_api SOURCES ./asynchronous_api/main.cpp DEPENDENCIES model_api)
-add_example(NAME synchronous_api SOURCES ./synchronous_api/main.cpp DEPENDENCIES model_api)
+add_example(NAME synchronous_api SOURCES ./main.cpp DEPENDENCIES model_api)

examples/cpp/synchronous_api/README.md examples/cpp/README.mdexamples/cpp/synchronous_api/README.md renamed to examples/cpp/README.md

@@ -65,9 +65,6 @@ class DetectionModel {
     static DetectionModel load(const std::string& model_path, const ov::AnyMap& configuration = {});
 
     DetectionResult infer(cv::Mat image);
-    void inferAsync(cv::Mat image, ov::AnyMap user_data);
-    void setCallback(std::function<void(DetectionResult, ov::AnyMap)>);
-
     std::vector<DetectionResult> inferBatch(std::vector<cv::Mat> image);
 
 private:

examples/cpp/asynchronous_api/README.md

@@ -43,8 +43,6 @@ class InstanceSegmentation {
     static InstanceSegmentation load(const std::string& model_path);
 
     InstanceSegmentationResult infer(cv::Mat image);
-    void inferAsync(cv::Mat image, ov::AnyMap user_data);
-    void setCallback(std::function<void(InstanceSegmentationResult, ov::AnyMap)>);
     std::vector<InstanceSegmentationResult> inferBatch(std::vector<cv::Mat> image);
 
     std::map<std::string, ov::Tensor> preprocess(cv::Mat);

examples/cpp/asynchronous_api/main.cpp

@@ -52,8 +52,6 @@ class SemanticSegmentation {
     std::vector<Contour> getContours(const SemanticSegmentationResult& result);
 
     SemanticSegmentationResult infer(cv::Mat image);
-    void inferAsync(cv::Mat image, ov::AnyMap user_data);
-    void setCallback(std::function<void(SemanticSegmentationResult, ov::AnyMap)>);
     std::vector<SemanticSegmentationResult> inferBatch(std::vector<cv::Mat> image);
 
 private:

examples/cpp/synchronous_api/main.cpp examples/cpp/main.cppexamples/cpp/synchronous_api/main.cpp renamed to examples/cpp/main.cpp

@@ -12,8 +12,6 @@ class Pipeline {
 public:
     Pipeline() {}
     virtual ResultType infer(cv::Mat image) = 0;
-    virtual void setCallback(std::function<void(ResultType, ov::AnyMap)> callback) = 0;
-    virtual void inferAsync(cv::Mat image, ov::AnyMap user_data) = 0;
     virtual std::vector<ResultType> inferBatch(std::vector<cv::Mat> images) = 0;
 };
 
@@ -41,26 +39,6 @@ class VisionPipeline : public Pipeline<ResultType> {
         return postprocess(result);
     }
 
-    inline void setCallback(std::function<void(ResultType, ov::AnyMap)> callback) {
-        adapter->setCallback([&](ov::InferRequest request, CallbackData additional_data) {
-            InferenceResult result;
-            size_t index = additional_data->at("index").as<size_t>();
-            result.inputImageSize = additional_data->at("inputImageSize").as<cv::Size>();
-            auto user_data = additional_data->at("user_data").as<ov::AnyMap>();
-            for (const auto& item : adapter->getOutputNames()) {
-                result.data.emplace(item, request.get_tensor(item));
-            }
-            callback(postprocess(result), user_data);
-        });
-    }
-
-    inline void inferAsync(cv::Mat image, ov::AnyMap user_data) {
-        auto additional_data = std::make_shared<ov::AnyMap>();
-        additional_data->insert({"inputImageSize", image.size()});
-        additional_data->insert({"user_data", user_data});
-        adapter->inferAsync(preprocess(image), additional_data);
-    }
-
     inline std::vector<ResultType> inferBatch(std::vector<cv::Mat> images) {
         auto results = std::vector<ResultType>(images.size());
 
@@ -138,12 +116,6 @@ class TilingPipeline : public Pipeline<ResultType> {
         return merge_tiling_results(tile_results, image.size(), tile_coords, tiling_info);
     }
 
-    inline void setCallback(std::function<void(ResultType, ov::AnyMap)> callback) {}
-
-    inline void inferAsync(cv::Mat image, ov::AnyMap user_data) {
-        throw std::runtime_error("No inferAsync for tiling yet.");
-    }
-
     inline std::vector<ResultType> inferBatch(std::vector<cv::Mat> images) {
         std::vector<std::vector<ResultType>> tile_results_for_all_images(images.size());
         std::vector<ResultType> output(images.size());

src/cpp/include/tasks/detection.h

@@ -204,14 +204,6 @@ DetectionResult DetectionModel::infer(cv::Mat image) {
     return pipeline->infer(image);
 }
 
-void DetectionModel::inferAsync(cv::Mat image, ov::AnyMap user_data) {
-    pipeline->inferAsync(image, user_data);
-}
-
-void DetectionModel::setCallback(std::function<void(DetectionResult, ov::AnyMap)> callback) {
-    pipeline->setCallback(callback);
-}
-
 std::vector<DetectionResult> DetectionModel::inferBatch(std::vector<cv::Mat> images) {
     return pipeline->inferBatch(images);
 }