single option optimization working

Author: tzmcion

App/Components/Optimalization/Optimaliation.h

@@ -24,7 +24,7 @@
         /**
          * Function aims to sequentially change single option to find the best match for user image
          */
-        void single_option_optimization(cv::Mat &img, AlgorithmOptions &options, std::string option_class, size_t option_index, bool uneven = false, int max_iterations=50, double resolution = 0.2);
+        void single_option_optimization(cv::Mat &img, AlgorithmOptions &options, std::string option_class, size_t option_index, bool uneven = false, int max_iterations=50, int min_start = 1, double resolution = 0.2);
 
         /**
          * Function reads the mask saved in image and saves it in variable
@@ -36,24 +36,24 @@
          */
         double calculate_intersection_over_union(cv::Mat &image);
 
+        //Function runs the watershed segmentation with given options and returns a mask
+        void simulate_watershed(cv::Mat &img, cv::Mat &out, AlgorithmOptions &options);
+
     private:
 
         //Function finds unique values in matrix and stores it in a vector
         void find_unique_values(cv::Mat &matrix, std::vector<int> &storage);
 
         //Function adds one, or creates a new record with a certain object_id
-        void sum_up_storage(std::map<int,int> &storage, int object_value);
-
-        //Function runs the watershed segmentation with given options and returns a mask
-        void simulate_watershed(cv::Mat &img, cv::Mat &out, AlgorithmOptions &options);
+        void sum_up_storage(std::map<long int,long int> &storage, int object_value);
 
         /**
          * This function calculates maximum intersection over union on object (because many objects can overlap the user matrix)
          * returns pair, with first being max IoU, and second is the size of the object
          * @param object_id object id in USER MASK
          * @param matrix image/mask given to compare with USER MASK
          */
-        std::pair<double,int> calc_intersection_over_union_per_object(int object_id, cv::Mat &matrix);
+        std::pair<double,long int> calc_intersection_over_union_per_object(int object_id, cv::Mat &matrix);
 
         cv::Mat user_mask_matrix; //OpenCV like connected components matrix for user mask
         AlgorithmOptions *options;  //Algorithm options

App/Components/Optimalization/Optimization.cpp

@@ -25,36 +25,35 @@ void Optimalization::read_user_mask(std::string path_to_mask){
 
 }
 
-void Optimalization::single_option_optimization(cv::Mat &img, AlgorithmOptions &options, std::string option_class, size_t option_index,bool uneven,int max_iterations, double resolution){
+void Optimalization::single_option_optimization(cv::Mat &img, AlgorithmOptions &options, std::string option_class, size_t option_index,bool uneven,int max_iterations, int min_start, double resolution){
     //Rescale the image to given ratio
     const int opt_size = int(img.cols * resolution);   //Material should be a square
     cv::Mat image, result;
     img.copyTo(image);
     Transformations::square_and_resize(image,opt_size);
-    double precision = 1;
-    int best_val = 0;
+    double precision = 0.0, new_precision = 0.0;
     //get the value of the option, and define max and minimum values.
     if(options.get_db_var(option_index,option_class) == AlgorithmOptions::MAX_DB){
         //Then we work with integers
         //With integers it is easier, just iterate over every value from 0 to 10
         simulate_watershed(image,result,options);
+        int best_val = options.get_int_var(option_index,option_class);
         precision = calculate_intersection_over_union(result);
-        std::cout << "PREC: " << precision << std::endl;
-        best_val = options.get_int_var(option_index, option_class);
-        for(int x = 1; x < max_iterations; x++){
+        for(int x = min_start; x < max_iterations; x++){
             if(uneven && x !=1){
                 x+=1;
             }
-            // options.set_int_value(option_index, option_class, x);
+            options.set_int_value(option_index, option_class, x);
             simulate_watershed(image,result,options);
-            double new_precision = calculate_intersection_over_union(result);
+            new_precision = calculate_intersection_over_union(result);
+            // std::cout << "PRECISION: " << new_precision << std::endl;
             if(new_precision > precision){
                 precision = new_precision;
                 std:: cout << "Found new best value for " << option_index << " : " << x << "  || Precision: " << precision << std::endl;
                 best_val = x;
             }
         }
-        //options.set_int_value(option_index, option_class, best_val);
+        options.set_int_value(option_index, option_class, best_val);
     }
     else{
 
@@ -76,9 +75,9 @@ double Optimalization::calculate_intersection_over_union(cv::Mat &image){
     this->find_unique_values(this->user_mask_matrix,unique_in_user_matrix);
     //Then, calculate the intersection per object, including it's size
     double val_sum = 0;
-    int pixel_sum = 0;
+    long int pixel_sum = 0;
     for(size_t x = 0; x < unique_in_user_matrix.size(); x++){
-        std::pair<double,int> result = this->calc_intersection_over_union_per_object(unique_in_user_matrix[x],image);
+        std::pair<double,long int> result = this->calc_intersection_over_union_per_object(unique_in_user_matrix[x],image);
         val_sum += result.first * result.second;
         pixel_sum += result.second;
     }
@@ -101,7 +100,7 @@ void Optimalization::find_unique_values(cv::Mat &matrix, std::vector<int> &stora
     }
 }
 
-void Optimalization::sum_up_storage(std::map<int,int> &storage, int object_value){
+void Optimalization::sum_up_storage(std::map<long int,long int> &storage, int object_value){
     //Find if key already exists
     auto it = storage.find(object_value);
     if(it == storage.end()){
@@ -114,20 +113,21 @@ void Optimalization::sum_up_storage(std::map<int,int> &storage, int object_value
 
 //I KNOW THIS ALGORITHM CAN BE MORE OPTIMAL, BUT I DID IT THEY WAY I DID IT, SO SCREW IT
 //I mean, it could be reduced from in final version O(p(2n^2)), where p=nr of objects in user_mask, to just O(2n^2) ...
-std::pair<double,int> Optimalization::calc_intersection_over_union_per_object(int object_id, cv::Mat &matrix){
+std::pair<double,long int> Optimalization::calc_intersection_over_union_per_object(int object_id, cv::Mat &matrix){
     //Working in O(2(n^2)) time, where n is width=height of matrix
-    cv::Mat mask = this->user_mask_matrix == object_id;
+    cv::Mat mask;
+    cv::compare(this->user_mask_matrix, object_id, mask, cv::CMP_EQ);
     if(mask.size() != matrix.size()){
         throw std::invalid_argument("Error, trying to compare user mask, and argument mask, they are different in size");
     }
     //Creating a storage for calculating intersection over union
-    std::map<int,int> intersection_storage;
-    std::map<int,int> union_storage;
-    int overall_matrix = 0;
-    for(int x=0; x < mask.cols; x++){
-        for(int y=0;y<mask.rows;y++){
-            int val_mask = mask.at<int>(x,y);
-            int val_matrix = matrix.at<int>(x,y);
+    std::map<long int,long int> intersection_storage;
+    std::map<long int,long int> union_storage;
+    long int overall_matrix = 0;
+    for(int x=0; x < mask.rows; x++){
+        for(int y=0;y<mask.cols;y++){
+            int val_mask = mask.at<uchar>(x,y);
+            int val_matrix = matrix.at<uchar>(x,y);
             if(val_mask != 0){
                 sum_up_storage(intersection_storage,val_matrix);
                 overall_matrix += 1;
@@ -137,9 +137,9 @@ std::pair<double,int> Optimalization::calc_intersection_over_union_per_object(in
         }
     }
     //Now, find the maximum value of intersection over union, here only the maximum value is in interest
-    double max_val = 0;
+    double max_val = 0.0;
     for(const auto &iter : intersection_storage){
-        int key = iter.first;
+        long int key = iter.first;
         if(key == 1)continue; //Exclude background
         int to_add = -1;
         //Find the same key in union_storage
@@ -150,14 +150,14 @@ std::pair<double,int> Optimalization::calc_intersection_over_union_per_object(in
         if(to_add == -1){
             to_add = union_val->second;
         }
-        int intersec_value = iter.second;
-        int union_value = overall_matrix - intersec_value + to_add;
+        long int intersec_value = iter.second;
+        long int union_value = overall_matrix - intersec_value + to_add;
         double IoU = (double)intersec_value / union_value;
         if(IoU > max_val){
             max_val = IoU;
         }
     }
-    return std::pair<double,int>(max_val,overall_matrix);
+    return std::pair<double,long int>(max_val,overall_matrix);
 }
 
 void Optimalization::simulate_watershed(cv::Mat &img, cv::Mat &out, AlgorithmOptions &options){

App/Components/Watershed/Watershed.cpp

@@ -214,7 +214,7 @@ void Watershed::draw_watershed_lines(cv::Mat &src, cv::Mat &dst, cv::Mat &waters
 
     // Blend the watershed result with the original image using 20% opacity for the result
     Mat blended;
-    addWeighted(imageBGRA, 0.7, result, 0.3, 0, blended); // 80% original + 20% overlay
+    addWeighted(imageBGRA, 0.5, result, 0.5, 0, blended); // 80% original + 20% overlay
     blended.copyTo(dst);
 }
 

App/Utils/TEST/main.cpp

@@ -21,12 +21,32 @@ int main(int argc, char **argv){
     opt.read_user_mask(user_mask_path);
     //Create new mask
     AlgorithmOptions options(OPTIONS_PATH.c_str());
-    cv::Mat image;
-    image = cv::imread(image_path, cv::IMREAD_GRAYSCALE);
-    opt.single_option_optimization(image,options,"WATERSHED",4,true);
-    opt.single_option_optimization(image,options,"WATERSHED",2,true);
-    opt.single_option_optimization(image,options,"WATERSHED",1,true);
-    opt.single_option_optimization(image,options,"WATERSHED",0,true);
+    AlgorithmOptions original(OPTIONS_PATH.c_str());
+    cv::Mat image = cv::imread(image_path, cv::IMREAD_GRAYSCALE);
+    opt.single_option_optimization(image,options,"FOREGROUND_MASK",0,true,20);
+    opt.single_option_optimization(image,options,"FOREGROUND_MASK",1,true,20);
+    opt.single_option_optimization(image,options,"FOREGROUND_REGIONS",0,true,20);
+    opt.single_option_optimization(image,options,"WATERSHED",0,true,20);
+    opt.single_option_optimization(image,options,"FOREGROUND_MASK",2,true,20);
+    opt.single_option_optimization(image,options,"FOREGROUND_MASK",10,true,500,200);
+    opt.single_option_optimization(image,options,"FOREGROUND_MASK",3,true,20);
+    opt.single_option_optimization(image,options,"FOREGROUND_REGIONS",3,true,20);
+    opt.single_option_optimization(image,options,"WATERSHED",2,true,20);
+    opt.single_option_optimization(image,options,"FOREGROUND_MASK",8,false,50,10);
+    opt.single_option_optimization(image,options,"FOREGROUND_MASK",9,false,10);
+    opt.single_option_optimization(image,options,"FOREGROUND_REGIONS",5,true,20);
+    opt.single_option_optimization(image,options,"WATERSHED",4,true,20);
+    opt.single_option_optimization(image,options,"FOREGROUND_MASK",12,false,5);
+    opt.single_option_optimization(image,options,"FOREGROUND_REGIONS",1,true,20);
+    opt.single_option_optimization(image,options,"WATERSHED",1,true,20);
+    cv::Mat result, org_result, mask_result, mask_org;
+    opt.simulate_watershed(image, mask_result, options);
+    opt.simulate_watershed(image, mask_org, original);
+    Watershed::draw_watershed_lines(image, result, mask_result);
+    Watershed::draw_watershed_lines(image, org_result, mask_org);
+    cv::imshow("Result optimization", result);
+    cv::imshow("Beofre Opt", org_result);
+    cv::waitKey(0);
     //
     return 0;
 }