Remove input shape as input for the tasks

orig_width and height are stored in rt_info anyway.
Serialization is a separate step and it _should_ output the same model

Author: RHeckerIntel

src/cpp/include/tasks/classification.h

@@ -19,9 +19,8 @@ class Classification {
     std::shared_ptr<InferenceAdapter> adapter;
     VisionPipeline<ClassificationResult> pipeline;
 
-    Classification(std::shared_ptr<InferenceAdapter> adapter, cv::Size input_shape)
-        : adapter(adapter),
-          input_shape(input_shape) {
+    Classification(std::shared_ptr<InferenceAdapter> adapter)
+        : adapter(adapter) {
         pipeline = VisionPipeline<ClassificationResult>(
             adapter,
             [&](cv::Mat image) {
@@ -56,7 +55,7 @@ class Classification {
         }
     }
 
-    static cv::Size serialize(std::shared_ptr<ov::Model>& ov_model);
+    static void serialize(std::shared_ptr<ov::Model>& ov_model);
     static Classification load(const std::string& model_path);
 
     ClassificationResult infer(cv::Mat image);

src/cpp/include/tasks/detection/ssd.h

@@ -28,15 +28,17 @@ class SSD {
 public:
     std::shared_ptr<InferenceAdapter> adapter;
 
-    SSD(std::shared_ptr<InferenceAdapter> adapter, cv::Size input_shape) : adapter(adapter), input_shape(input_shape) {
+    SSD(std::shared_ptr<InferenceAdapter> adapter) : adapter(adapter), input_shape(input_shape) {
         auto config = adapter->getModelConfig();
         labels = utils::get_from_any_maps("labels", config, {}, labels);
         confidence_threshold = utils::get_from_any_maps("confidence_threshold", config, {}, confidence_threshold);
+        input_shape.width = utils::get_from_any_maps("orig_width", config, {}, input_shape.width);
+        input_shape.height = utils::get_from_any_maps("orig_height", config, {}, input_shape.height);
     }
     std::map<std::string, ov::Tensor> preprocess(cv::Mat);
     DetectionResult postprocess(InferenceResult& infResult);
 
-    static cv::Size serialize(std::shared_ptr<ov::Model> ov_model);
+    static void serialize(std::shared_ptr<ov::Model> ov_model);
 
     SSDOutputMode output_mode;
 

src/cpp/include/tasks/instance_segmentation.h

@@ -18,9 +18,8 @@ class InstanceSegmentation {
     std::shared_ptr<InferenceAdapter> adapter;
     VisionPipeline<InstanceSegmentationResult> pipeline;
 
-    InstanceSegmentation(std::shared_ptr<InferenceAdapter> adapter, cv::Size input_shape)
-        : adapter(adapter),
-          input_shape(input_shape) {
+    InstanceSegmentation(std::shared_ptr<InferenceAdapter> adapter)
+        : adapter(adapter) {
         pipeline = VisionPipeline<InstanceSegmentationResult>(
             adapter,
             [&](cv::Mat image) {
@@ -33,9 +32,11 @@ class InstanceSegmentation {
         auto config = adapter->getModelConfig();
         labels = utils::get_from_any_maps("labels", config, {}, labels);
         confidence_threshold = utils::get_from_any_maps("confidence_threshold", config, {}, confidence_threshold);
+        input_shape.width = utils::get_from_any_maps("orig_width", config, {}, input_shape.width);
+        input_shape.height = utils::get_from_any_maps("orig_height", config, {}, input_shape.width);
     }
 
-    static cv::Size serialize(std::shared_ptr<ov::Model>& ov_model);
+    static void serialize(std::shared_ptr<ov::Model>& ov_model);
     static InstanceSegmentation load(const std::string& model_path);
 
     InstanceSegmentationResult infer(cv::Mat image);

src/cpp/include/tasks/semantic_segmentation.h

@@ -33,7 +33,7 @@ class SemanticSegmentation {
         blur_strength = utils::get_from_any_maps("blur_strength", config, {}, blur_strength);
     }
 
-    static cv::Size serialize(std::shared_ptr<ov::Model>& ov_model);
+    static void serialize(std::shared_ptr<ov::Model>& ov_model);
     static SemanticSegmentation load(const std::string& model_path);
 
     std::map<std::string, ov::Tensor> preprocess(cv::Mat);

src/cpp/src/tasks/classification.cpp

@@ -82,7 +82,7 @@ std::vector<size_t> get_non_xai_output_indices(const std::vector<ov::Output<ov::
 }
 }  // namespace
 
-cv::Size Classification::serialize(std::shared_ptr<ov::Model>& ov_model) {
+void Classification::serialize(std::shared_ptr<ov::Model>& ov_model) {
     // --------------------------- Configure input & output -------------------------------------------------
     // --------------------------- Prepare input  ------------------------------------------------------
     auto config = ov_model->has_rt_info("model_info") ? ov_model->get_rt_info<ov::AnyMap>("model_info") : ov::AnyMap{};
@@ -171,7 +171,9 @@ cv::Size Classification::serialize(std::shared_ptr<ov::Model>& ov_model) {
     if (multiclass) {
         addOrFindSoftmaxAndTopkOutputs(ov_model, topk, output_raw_scores);
     }
-    return cv::Size(input_shape[0], input_shape[1]);
+
+    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::load(const std::string& model_path) {
@@ -185,16 +187,14 @@ Classification Classification::load(const std::string& model_path) {
         throw std::runtime_error("Incorrect or unsupported model_type");
     }
 
-    cv::Size origin_input_shape;
     if (utils::model_has_embedded_processing(model)) {
         std::cout << "model already was serialized" << std::endl;
-        origin_input_shape = utils::get_input_shape_from_model_info(model);
     } else {
-        origin_input_shape = Classification::serialize(model);
+        Classification::serialize(model);
     }
     auto adapter = std::make_shared<OpenVINOInferenceAdapter>();
     adapter->loadModel(model, core, "AUTO");
-    return Classification(adapter, origin_input_shape);
+    return Classification(adapter);
 }
 
 ClassificationResult Classification::infer(cv::Mat image) {

src/cpp/src/tasks/detection.cpp

@@ -22,16 +22,15 @@ DetectionModel DetectionModel::load(const std::string& model_path, const ov::Any
         throw std::runtime_error("Incorrect or unsupported model_type");
     }
 
-    cv::Size origin_input_shape;
     if (utils::model_has_embedded_processing(model)) {
         std::cout << "model already was serialized" << std::endl;
-        origin_input_shape = utils::get_input_shape_from_model_info(model);
+        //utils::get_input_shape_from_model_info(model);
     } else {
-        origin_input_shape = SSD::serialize(model);
+        SSD::serialize(model);
     }
     auto adapter = std::make_shared<OpenVINOInferenceAdapter>();
     adapter->loadModel(model, core, "AUTO");
-    return DetectionModel(std::make_unique<SSD>(adapter, origin_input_shape), configuration);
+    return DetectionModel(std::make_unique<SSD>(adapter), configuration);
 }
 
 InferenceInput DetectionModel::preprocess(cv::Mat image) {

src/cpp/src/tasks/detection/ssd.cpp

@@ -67,7 +67,7 @@ std::map<std::string, ov::Tensor> SSD::preprocess(cv::Mat image) {
     return input;
 }
 
-cv::Size SSD::serialize(std::shared_ptr<ov::Model> ov_model) {
+void SSD::serialize(std::shared_ptr<ov::Model> ov_model) {
     auto output_mode = ov_model->outputs().size() > 1 ? SSDOutputMode::multi : SSDOutputMode::single;
 
     auto input_tensor = ov_model->inputs()[0];
@@ -111,7 +111,9 @@ cv::Size SSD::serialize(std::shared_ptr<ov::Model> ov_model) {
         // prepareMultipleOutputs(ov_model); //This does nothing from what I can see.
     }
 
-    return cv::Size(input_shape[0], input_shape[1]);
+    
+    ov_model->set_rt_info(input_shape[0], "model_info", "orig_width");
+    ov_model->set_rt_info(input_shape[1], "model_info", "orig_height");
 }
 
 void SSD::prepareSingleOutput(std::shared_ptr<ov::Model> ov_model) {

src/cpp/src/tasks/instance_segmentation.cpp

@@ -121,7 +121,7 @@ cv::Mat segm_postprocess(const SegmentedObject& box, const cv::Mat& unpadded, in
     return im_mask;
 }
 
-cv::Size InstanceSegmentation::serialize(std::shared_ptr<ov::Model>& ov_model) {
+void InstanceSegmentation::serialize(std::shared_ptr<ov::Model>& ov_model) {
     if (ov_model->inputs().size() != 1) {
         throw std::logic_error("MaskRCNNModel model wrapper supports topologies with only 1 input");
     }
@@ -145,6 +145,7 @@ cv::Size InstanceSegmentation::serialize(std::shared_ptr<ov::Model>& ov_model) {
     mean_values = utils::get_from_any_maps("mean_values", config, ov::AnyMap{}, mean_values);
     uint8_t pad_value = 0;
     bool reverse_input_channels = false;
+    reverse_input_channels = utils::get_from_any_maps("reverse_input_channels", config, ov::AnyMap{}, reverse_input_channels);
 
     ov_model = utils::embedProcessing(
         ov_model,
@@ -180,7 +181,8 @@ cv::Size InstanceSegmentation::serialize(std::shared_ptr<ov::Model>& ov_model) {
                                saliency_map_name + ", " + feature_vector_name + " and 3 or 4 other outputs");
     }
 
-    return input_shape;
+    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::load(const std::string& model_path) {
@@ -194,16 +196,14 @@ InstanceSegmentation InstanceSegmentation::load(const std::string& model_path) {
         throw std::runtime_error("Incorrect or unsupported model_type");
     }
 
-    cv::Size origin_input_shape;
     if (utils::model_has_embedded_processing(model)) {
         std::cout << "model already was serialized" << std::endl;
-        origin_input_shape = utils::get_input_shape_from_model_info(model);
     } else {
-        origin_input_shape = serialize(model);
+        serialize(model);
     }
     auto adapter = std::make_shared<OpenVINOInferenceAdapter>();
     adapter->loadModel(model, core, "AUTO");
-    return InstanceSegmentation(adapter, origin_input_shape);
+    return InstanceSegmentation(adapter);
 }
 
 InstanceSegmentationResult InstanceSegmentation::infer(cv::Mat image) {

src/cpp/src/tasks/semantic_segmentation.cpp

@@ -31,19 +31,17 @@ SemanticSegmentation SemanticSegmentation::load(const std::string& model_path) {
         throw std::runtime_error("Incorrect or unsupported model_type");
     }
 
-    cv::Size origin_input_shape;
     if (utils::model_has_embedded_processing(model)) {
         std::cout << "model already was serialized" << std::endl;
-        origin_input_shape = utils::get_input_shape_from_model_info(model);
     } else {
-        origin_input_shape = SemanticSegmentation::serialize(model);
+        SemanticSegmentation::serialize(model);
     }
     auto adapter = std::make_shared<OpenVINOInferenceAdapter>();
     adapter->loadModel(model, core, "AUTO");
     return SemanticSegmentation(adapter);
 }
 
-cv::Size SemanticSegmentation::serialize(std::shared_ptr<ov::Model>& ov_model) {
+void SemanticSegmentation::serialize(std::shared_ptr<ov::Model>& ov_model) {
     if (ov_model->inputs().size() != 1) {
         throw std::logic_error("Segmentation model wrapper supports topologies with only 1 input");
     }
@@ -90,14 +88,13 @@ cv::Size SemanticSegmentation::serialize(std::shared_ptr<ov::Model>& ov_model) {
     scale_values = utils::get_from_any_maps("scale_values", config, ov::AnyMap{}, scale_values);
     mean_values = utils::get_from_any_maps("mean_values", config, ov::AnyMap{}, mean_values);
 
-    auto input_shape = ov::Shape{shape[ov::layout::width_idx(layout)], shape[ov::layout::height_idx(layout)]};
 
     ov_model = utils::embedProcessing(ov_model,
                                       input.get_any_name(),
                                       layout,
                                       resize_mode,
                                       interpolation_mode,
-                                      input_shape,
+                                      ov::Shape{shape[ov::layout::width_idx(layout)], shape[ov::layout::height_idx(layout)]},
                                       pad_value,
                                       reverse_input_channels,
                                       mean_values,
@@ -115,7 +112,10 @@ cv::Size SemanticSegmentation::serialize(std::shared_ptr<ov::Model>& ov_model) {
     }
     ov_model = ppp.build();
 
-    return cv::Size(input_shape[0], input_shape[1]);
+    cv::Size input_shape(shape[ov::layout::width_idx(layout)],
+                         shape[ov::layout::height_idx(layout)]);
+    ov_model->set_rt_info(input_shape.width, "model_info", "orig_width");
+    ov_model->set_rt_info(input_shape.height, "model_info", "orig_height");
 }
 
 std::map<std::string, ov::Tensor> SemanticSegmentation::preprocess(cv::Mat image) {
@@ -162,7 +162,6 @@ SemanticSegmentationResult SemanticSegmentation::postprocess(InferenceResult& in
     SemanticSegmentationResult result;
     result.resultImage = hard_prediction;
     if (return_soft_prediction) {
-        std::cout << " got a soft prediction..." << std::endl;
         cv::resize(soft_prediction, soft_prediction, infResult.inputImageSize, 0.0, 0.0, cv::INTER_NEAREST);
         result.soft_prediction = soft_prediction;
         auto iter = infResult.data.find(feature_vector_name);
@@ -227,7 +226,6 @@ cv::Mat SemanticSegmentation::create_hard_prediction_from_soft_prediction(cv::Ma
 
     bool applyBlurAndSoftThreshold = (blur_strength > -1 && soft_threshold < std::numeric_limits<float>::infinity());
     if (applyBlurAndSoftThreshold) {
-        std::cout << "applying blur and soft threshold:  " << blur_strength << std::endl;
         cv::blur(soft_prediction_blurred, soft_prediction_blurred, cv::Size{blur_strength, blur_strength});
     }