Adds test_model_config tests partially back

RHeckerIntel · RHeckerIntel · commit fbf8250ece4e · 2025-07-01T07:27:03.000+02:00
Missing serialization. Need to allow for that again.
diff --git a/src/cpp/include/tasks/anomaly.h b/src/cpp/include/tasks/anomaly.h
@@ -40,7 +40,10 @@ class Anomaly {
     }
 
     static void serialize(std::shared_ptr<ov::Model>& ov_model);
-    static Anomaly create_model(const std::string& model_path, const ov::AnyMap& user_config = {}, bool preload = true, const std::string& device = "AUTO");
+    static Anomaly create_model(const std::string& model_path,
+                                const ov::AnyMap& user_config = {},
+                                bool preload = true,
+                                const std::string& device = "AUTO");
 
     AnomalyResult infer(cv::Mat image);
     std::vector<AnomalyResult> inferBatch(std::vector<cv::Mat> image);
diff --git a/src/cpp/include/tasks/classification.h b/src/cpp/include/tasks/classification.h
@@ -58,7 +58,10 @@ class Classification {
     }
 
     static void serialize(std::shared_ptr<ov::Model>& ov_model);
-    static Classification create_model(const std::string& model_path, const ov::AnyMap& user_config = {}, bool preload = true, const std::string& device = "AUTO");
+    static Classification create_model(const std::string& model_path,
+                                       const ov::AnyMap& user_config = {},
+                                       bool preload = true,
+                                       const std::string& device = "AUTO");
 
     ClassificationResult infer(cv::Mat image);
     std::vector<ClassificationResult> inferBatch(std::vector<cv::Mat> image);
diff --git a/src/cpp/include/tasks/detection.h b/src/cpp/include/tasks/detection.h
@@ -18,6 +18,7 @@
 class DetectionModel {
 public:
     std::unique_ptr<Pipeline<DetectionResult>> pipeline;
+    std::unique_ptr<SSD> algorithm;
 
     DetectionModel(std::unique_ptr<SSD> algorithm, const ov::AnyMap& user_config) : algorithm(std::move(algorithm)) {
         auto config = this->algorithm->adapter->getModelConfig();
@@ -67,11 +68,11 @@ class DetectionModel {
                                    const std::vector<cv::Rect>& tile_coords,
                                    const utils::TilingInfo& tiling_info);
 
-    static DetectionModel create_model(const std::string& model_path, const ov::AnyMap& user_config = {}, bool preload = true, const std::string& device = "AUTO");
+    static DetectionModel create_model(const std::string& model_path,
+                                       const ov::AnyMap& user_config = {},
+                                       bool preload = true,
+                                       const std::string& device = "AUTO");
 
     DetectionResult infer(cv::Mat image);
     std::vector<DetectionResult> inferBatch(std::vector<cv::Mat> image);
-
-private:
-    std::unique_ptr<SSD> algorithm;
 };
diff --git a/src/cpp/include/tasks/instance_segmentation.h b/src/cpp/include/tasks/instance_segmentation.h
@@ -37,7 +37,10 @@ class InstanceSegmentation {
     }
 
     static void serialize(std::shared_ptr<ov::Model>& ov_model);
-    static InstanceSegmentation create_model(const std::string& model_path, const ov::AnyMap& user_config = {}, bool preload = true, const std::string& device = "AUTO");
+    static InstanceSegmentation create_model(const std::string& model_path,
+                                             const ov::AnyMap& user_config = {},
+                                             bool preload = true,
+                                             const std::string& device = "AUTO");
 
     InstanceSegmentationResult infer(cv::Mat image);
     std::vector<InstanceSegmentationResult> inferBatch(std::vector<cv::Mat> image);
diff --git a/src/cpp/include/tasks/semantic_segmentation.h b/src/cpp/include/tasks/semantic_segmentation.h
@@ -34,7 +34,10 @@ class SemanticSegmentation {
     }
 
     static void serialize(std::shared_ptr<ov::Model>& ov_model);
-    static SemanticSegmentation create_model(const std::string& model_path, const ov::AnyMap& user_config = {}, bool preload = true, const std::string& device = "AUTO");
+    static SemanticSegmentation create_model(const std::string& model_path,
+                                             const ov::AnyMap& user_config = {},
+                                             bool preload = true,
+                                             const std::string& device = "AUTO");
 
     std::map<std::string, ov::Tensor> preprocess(cv::Mat);
     SemanticSegmentationResult postprocess(InferenceResult& infResult);
diff --git a/src/cpp/src/tasks/anomaly.cpp b/src/cpp/src/tasks/anomaly.cpp
@@ -47,11 +47,15 @@ void Anomaly::serialize(std::shared_ptr<ov::Model>& ov_model) {
                                       mean_values,
                                       scale_values);
 
+    ov_model->set_rt_info(true, "model_info", "embedded_processing");
     ov_model->set_rt_info(input_shape[0], "model_info", "orig_width");
     ov_model->set_rt_info(input_shape[1], "model_info", "orig_height");
 }
 
-Anomaly Anomaly::create_model(const std::string& model_path, const ov::AnyMap& user_config, bool preload, const std::string& device) {
+Anomaly Anomaly::create_model(const std::string& model_path,
+                              const ov::AnyMap& user_config,
+                              bool preload,
+                              const std::string& device) {
     auto adapter = std::make_shared<OpenVINOInferenceAdapter>();
     adapter->loadModel(model_path, device, user_config, false);
 
diff --git a/src/cpp/src/tasks/classification.cpp b/src/cpp/src/tasks/classification.cpp
@@ -176,11 +176,15 @@ void Classification::serialize(std::shared_ptr<ov::Model>& ov_model) {
         addOrFindSoftmaxAndTopkOutputs(ov_model, topk, output_raw_scores);
     }
 
+    ov_model->set_rt_info(true, "model_info", "embedded_processing");
     ov_model->set_rt_info(input_shape[0], "model_info", "orig_width");
     ov_model->set_rt_info(input_shape[1], "model_info", "orig_height");
 }
 
-Classification Classification::create_model(const std::string& model_path, const ov::AnyMap& user_config, bool preload, const std::string& device) {
+Classification Classification::create_model(const std::string& model_path,
+                                            const ov::AnyMap& user_config,
+                                            bool preload,
+                                            const std::string& device) {
     auto adapter = std::make_shared<OpenVINOInferenceAdapter>();
     adapter->loadModel(model_path, device, user_config, false);
 
diff --git a/src/cpp/src/tasks/detection.cpp b/src/cpp/src/tasks/detection.cpp
@@ -13,7 +13,10 @@
 #include "utils/nms.h"
 #include "utils/tensor.h"
 
-DetectionModel DetectionModel::create_model(const std::string& model_path, const ov::AnyMap& user_config, bool preload, const std::string& device) {
+DetectionModel DetectionModel::create_model(const std::string& model_path,
+                                            const ov::AnyMap& user_config,
+                                            bool preload,
+                                            const std::string& device) {
     auto adapter = std::make_shared<OpenVINOInferenceAdapter>();
     adapter->loadModel(model_path, device, user_config, false);
 
diff --git a/src/cpp/src/tasks/detection/ssd.cpp b/src/cpp/src/tasks/detection/ssd.cpp
@@ -115,6 +115,7 @@ void SSD::serialize(std::shared_ptr<ov::Model>& ov_model) {
         // prepareMultipleOutputs(ov_model); //This does nothing from what I can see.
     }
 
+    ov_model->set_rt_info(true, "model_info", "embedded_processing");
     ov_model->set_rt_info(input_shape[0], "model_info", "orig_width");
     ov_model->set_rt_info(input_shape[1], "model_info", "orig_height");
 }
diff --git a/src/cpp/src/tasks/instance_segmentation.cpp b/src/cpp/src/tasks/instance_segmentation.cpp
@@ -186,11 +186,15 @@ void InstanceSegmentation::serialize(std::shared_ptr<ov::Model>& ov_model) {
                                saliency_map_name + ", " + feature_vector_name + " and 3 or 4 other outputs");
     }
 
+    ov_model->set_rt_info(true, "model_info", "embedded_processing");
     ov_model->set_rt_info(input_shape.width, "model_info", "orig_width");
     ov_model->set_rt_info(input_shape.height, "model_info", "orig_height");
 }
 
-InstanceSegmentation InstanceSegmentation::create_model(const std::string& model_path, const ov::AnyMap& user_config, bool preload, const std::string& device) {
+InstanceSegmentation InstanceSegmentation::create_model(const std::string& model_path,
+                                                        const ov::AnyMap& user_config,
+                                                        bool preload,
+                                                        const std::string& device) {
     auto adapter = std::make_shared<OpenVINOInferenceAdapter>();
     adapter->loadModel(model_path, device, user_config, false);
 
diff --git a/src/cpp/src/tasks/semantic_segmentation.cpp b/src/cpp/src/tasks/semantic_segmentation.cpp
@@ -20,7 +20,10 @@ cv::Mat get_activation_map(const cv::Mat& features) {
     return int_act_map;
 }
 
-SemanticSegmentation SemanticSegmentation::create_model(const std::string& model_path, const ov::AnyMap& user_config, bool preload, const std::string& device) {
+SemanticSegmentation SemanticSegmentation::create_model(const std::string& model_path,
+                                                        const ov::AnyMap& user_config,
+                                                        bool preload,
+                                                        const std::string& device) {
     auto adapter = std::make_shared<OpenVINOInferenceAdapter>();
     adapter->loadModel(model_path, device, user_config, false);
 
@@ -114,6 +117,7 @@ void SemanticSegmentation::serialize(std::shared_ptr<ov::Model>& ov_model) {
     ov_model = ppp.build();
 
     cv::Size input_shape(shape[ov::layout::width_idx(layout)], shape[ov::layout::height_idx(layout)]);
+    ov_model->set_rt_info(true, "model_info", "embedded_processing");
     ov_model->set_rt_info(input_shape.width, "model_info", "orig_width");
     ov_model->set_rt_info(input_shape.height, "model_info", "orig_height");
 }
diff --git a/tests/cpp/precommit/CMakeLists.txt b/tests/cpp/precommit/CMakeLists.txt
@@ -20,3 +20,6 @@ find_package(OpenCV REQUIRED COMPONENTS imgcodecs)
 
 add_executable(test_sanity test_sanity.cpp)
 target_link_libraries(test_sanity gtest_main nlohmann_json::nlohmann_json model_api ${OpenCV_LIBRARIES})
+
+add_executable(test_model_config test_model_config.cpp)
+target_link_libraries(test_model_config gtest_main nlohmann_json::nlohmann_json model_api ${OpenCV_LIBRARIES})
diff --git a/tests/cpp/precommit/test_model_config.cpp b/tests/cpp/precommit/test_model_config.cpp
diff --git a/tests/cpp/precommit/test_sanity.cpp b/tests/cpp/precommit/test_sanity.cpp

Original file line number	Diff line number	Diff line change
`@@ -176,11 +176,15 @@ void Classification::serialize(std::shared_ptr<ov::Model>& ov_model) {`
`176`	`176`	`addOrFindSoftmaxAndTopkOutputs(ov_model, topk, output_raw_scores);`
`177`	`177`	`}`
`178`	`178`
	`179`	`+ ov_model->set_rt_info(true, "model_info", "embedded_processing");`
`179`	`180`	`ov_model->set_rt_info(input_shape[0], "model_info", "orig_width");`
`180`	`181`	`ov_model->set_rt_info(input_shape[1], "model_info", "orig_height");`
`181`	`182`	`}`
`182`	`183`
`183`		`-Classification Classification::create_model(const std::string& model_path, const ov::AnyMap& user_config, bool preload, const std::string& device) {`
	`184`	`+Classification Classification::create_model(const std::string& model_path,`
	`185`	`+ const ov::AnyMap& user_config,`
	`186`	`+ bool preload,`
	`187`	`+ const std::string& device) {`
`184`	`188`	`auto adapter = std::make_shared<OpenVINOInferenceAdapter>();`
`185`	`189`	`adapter->loadModel(model_path, device, user_config, false);`
`186`	`190`
Original file line number	Diff line number	Diff line change
`@@ -115,6 +115,7 @@ void SSD::serialize(std::shared_ptr<ov::Model>& ov_model) {`
`115`	`115`	`// prepareMultipleOutputs(ov_model); //This does nothing from what I can see.`
`116`	`116`	`}`
`117`	`117`
	`118`	`+ ov_model->set_rt_info(true, "model_info", "embedded_processing");`
`118`	`119`	`ov_model->set_rt_info(input_shape[0], "model_info", "orig_width");`
`119`	`120`	`ov_model->set_rt_info(input_shape[1], "model_info", "orig_height");`
`120`	`121`	`}`
Original file line number	Diff line number	Diff line change
`@@ -186,11 +186,15 @@ void InstanceSegmentation::serialize(std::shared_ptr<ov::Model>& ov_model) {`
`186`	`186`	`saliency_map_name + ", " + feature_vector_name + " and 3 or 4 other outputs");`
`187`	`187`	`}`
`188`	`188`
	`189`	`+ ov_model->set_rt_info(true, "model_info", "embedded_processing");`
`189`	`190`	`ov_model->set_rt_info(input_shape.width, "model_info", "orig_width");`
`190`	`191`	`ov_model->set_rt_info(input_shape.height, "model_info", "orig_height");`
`191`	`192`	`}`
`192`	`193`
`193`		`-InstanceSegmentation InstanceSegmentation::create_model(const std::string& model_path, const ov::AnyMap& user_config, bool preload, const std::string& device) {`
	`194`	`+InstanceSegmentation InstanceSegmentation::create_model(const std::string& model_path,`
	`195`	`+ const ov::AnyMap& user_config,`
	`196`	`+ bool preload,`
	`197`	`+ const std::string& device) {`
`194`	`198`	`auto adapter = std::make_shared<OpenVINOInferenceAdapter>();`
`195`	`199`	`adapter->loadModel(model_path, device, user_config, false);`
`196`	`200`