Finished implementing intersection over union

Author: tzmcion

App/Components/Optimalization/Optimaliation.h

@@ -1,3 +1,4 @@
+#pragma once
 /**
  * This file is used for options optimalization
  * For handlign the integration between the modules
@@ -17,20 +18,7 @@
          * Function crops the image and saves it to the temp folder in provided name
          * @param scale Parameter to define the scale of the saving
         */
-        void crop_save_image_sample(cv::Mat &out_img,std::vector<std::string> &images, std::string save_path,int scale=3){
-            const std::string image_to_crop = images[rand() % images.size()];
-            const int CROP_SIZE = 200;
-            //Select random area on the image
-            cv::Mat image = cv::imread(image_to_crop,cv::IMREAD_GRAYSCALE);
-            int begin_x = rand() % (image.cols - CROP_SIZE);
-            int begin_y = rand() % (image.rows - CROP_SIZE);
-            //define region of interest
-            cv::Rect roi(begin_x,begin_y,CROP_SIZE,CROP_SIZE);
-            cv::Mat cropped = image(roi);
-            Transformations::square_and_resize(cropped,CROP_SIZE*scale);
-            cv::imwrite(save_path.c_str(),cropped);
-            out_img = cropped;
-        }
+        void crop_save_image_sample(cv::Mat &out_img,std::vector<std::string> &images, std::string save_path,int scale=3);
 
         /**
          * Function aims to sequentially change single option to find the best match for user image
@@ -40,7 +28,28 @@
         /**
          * Function reads the mask saved in image and saves it in variable
          */
-        void read_user_mask(){};
+        void read_user_mask(std::string path_to_mask);
+
+        /**
+         * Function compares user mask to the material mask specified
+         */
+        double calculate_intersection_over_union(cv::Mat &image);
+
+    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);
+
+        /**
+         * 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);
 
         cv::Mat user_mask_matrix; //OpenCV like connected components matrix for user mask
         AlgorithmOptions *options;  //Algorithm options

App/Components/Optimalization/Optimization.cpp

@@ -0,0 +1,122 @@
+#include "./Optimaliation.h"
+
+
+void Optimalization::crop_save_image_sample(cv::Mat &out_img,std::vector<std::string> &images, std::string save_path,int scale){
+    const std::string image_to_crop = images[rand() % images.size()];
+    const int CROP_SIZE = 200;
+    //Select random area on the image
+    cv::Mat image = cv::imread(image_to_crop,cv::IMREAD_GRAYSCALE);
+    int begin_x = rand() % (image.cols - CROP_SIZE);
+    int begin_y = rand() % (image.rows - CROP_SIZE);
+    //define region of interest
+    cv::Rect roi(begin_x,begin_y,CROP_SIZE,CROP_SIZE);
+    cv::Mat cropped = image(roi);
+    Transformations::square_and_resize(cropped,CROP_SIZE*scale);
+    cv::imwrite(save_path.c_str(),cropped);
+    out_img = cropped;
+}
+
+void Optimalization::read_user_mask(std::string path_to_mask){
+    cv::Mat mask = cv::imread(path_to_mask,cv::IMREAD_GRAYSCALE);
+    mask.convertTo(this->user_mask_matrix, CV_32S);
+    //I don't think I need to normalize it
+
+}
+
+double Optimalization::calculate_intersection_over_union(cv::Mat &image){
+    //Check if user mask is specified
+    if(this->user_mask_matrix.empty()){
+        throw std::invalid_argument("Trying to calculate intersection without user mask specified");
+    }
+    //Check if image is specified
+    if(image.empty()){
+        throw std::invalid_argument("Argument image in intersection calculation is not specified");
+    }
+    //Detect how many unique objects are there in a user matrix
+    std::vector<int> unique_in_user_matrix;
+    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;
+    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);
+        val_sum += result.first * result.second;
+        pixel_sum += result.second;
+    }
+    return val_sum / pixel_sum;
+}
+
+
+//Private
+
+
+void Optimalization::find_unique_values(cv::Mat &matrix, std::vector<int> &storage){
+    for (int x=0; x < matrix.rows; x++){
+        for(int y = 0; y < matrix.cols; y++){
+            int value = matrix.at<int>(x,y);
+            if(value == -1 || value == 0)continue;
+            if(std::find(storage.begin(), storage.end(), value) == storage.end() ){
+                storage.push_back(value);
+            }
+        }
+    }
+}
+
+void Optimalization::sum_up_storage(std::map<int,int> &storage, int object_value){
+    //Find if key already exists
+    auto it = storage.find(object_value);
+    if(it == storage.end()){
+        storage.insert({object_value,1});
+        return;
+    }
+    //If found
+    it->second = it->second+1; 
+}
+
+//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){
+    //Working in O(2(n^2)) time, where n is width=height of matrix
+    cv::Mat mask = this->user_mask_matrix == object_id;
+    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);
+            if(val_mask != 0){
+                sum_up_storage(intersection_storage,val_matrix);
+                overall_matrix += 1;
+                continue;
+            }
+            sum_up_storage(union_storage,val_matrix);
+        }
+    }
+    //Now, find the maximum value of intersection over union, here only the maximum value is in interest
+    double max_val = 0;
+    for(const auto &iter : intersection_storage){
+        int key = iter.first;
+        if(key == 1)continue; //Exclude background
+        int to_add = -1;
+        //Find the same key in union_storage
+        auto union_val = union_storage.find(key);
+        if(union_val == union_storage.end()){
+            to_add = 0;
+        }
+        if(to_add == -1){
+            to_add = union_val->second;
+        }
+        int intersec_value = iter.second;
+        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);
+}

App/Components/Watershed/Watershed.cpp

@@ -167,6 +167,57 @@ void Watershed::foreground_mask(cv::Mat &src, cv::Mat &dst_mask, cv::Mat &foregr
     }
     dst_mask = center_mask;
 }
+//
+//
+//
+void Watershed::watershed_with_masks(cv::Mat &src, cv::Mat &dst, cv::Mat &background, cv::Mat &foreground, int opening_force, int blur_force, int mean_median_force, double clache_force, int med_blur_second){
+    cv::Mat markers;
+    cv::connectedComponents(foreground,markers);
+    markers.setTo(1, background == 0); // Ensure background is labeled as 1
+    markers.setTo(0, (background != 0) & (foreground == 0)); // Unknown regions are 0
+    cv::Mat to_wat;
+    src.copyTo(to_wat);
+    cv::Mat image_watershed, result, watershed_markers;
+    Transformations::opening(to_wat,to_wat,'O',opening_force);
+    Transformations::double_blur(to_wat,to_wat,blur_force,mean_median_force);
+    Watershed::clache(to_wat,to_wat,clache_force);
+    cv::medianBlur(to_wat,to_wat,med_blur_second);
+    cv::cvtColor(to_wat, image_watershed, cv::COLOR_GRAY2BGR);
+    markers.convertTo(watershed_markers,CV_32S);
+    cv::watershed(image_watershed,watershed_markers);
+    watershed_markers.copyTo(dst);
+}
+//
+//
+//
+void Watershed::draw_watershed_lines(cv::Mat &src, cv::Mat &dst, cv::Mat &watershed_mask){
+    cv::Mat result;
+    cv::cvtColor(src,result,cv::COLOR_GRAY2RGB);
+    int count_green = 0;
+    for (int i = 0; i < watershed_mask.rows; i++) {
+        for (int j = 0; j < watershed_mask.cols; j++) {
+            int markerValue = watershed_mask.at<int>(i, j);
+            if (markerValue == -1) {
+                result.at<Vec3b>(i, j) = Vec3b((markerValue*10)%255, 105, 0); // Red for watershed boundaries
+            }
+            else if (markerValue == 1) {
+                result.at<Vec3b>(i, j) = Vec3b(150, 150, 150); // Blue for background
+            }
+            else if (markerValue >= 2) {
+                count_green += 1;
+                result.at<Vec3b>(i, j) = Vec3b((markerValue*10)%255,(markerValue*10)%255,(markerValue*25)%255);
+            }
+        }
+    }
+    Mat imageBGRA;
+    cvtColor(src, imageBGRA, COLOR_BGR2RGB);
+
+    // 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
+    blended.copyTo(dst);
+}
+
 
 /*
     ***********************

App/Components/Watershed/Watershed.h

@@ -98,12 +98,37 @@ class Watershed{
 
 
         /**
+         * Function performes watershed with given background mask and foreground mask
+         * @return watershed markers
+         * @param src
+         * @param dst
+         * @param background
+         * @param foreground
+         * @param opening_force
+         * @param blur_force
+         * @param mean_median_force
+         * @param clache_force
+         * @param med_blur_second
+         */
+
+         static void watershed_with_masks(cv::Mat &src, cv::Mat &dst, cv::Mat &background, cv::Mat &foreground, int opening_force, int blur_force, int mean_median_force, double clache_force, int med_blur_second);
+
+                 /**
          * Functions uses other technique, clacheIMG and medianblur to do first preprocessing of the image
          * @param src source image
          * @param dst destination image
          * @param clache_limit a force of clache filter
          * */
         static void clache(cv:: Mat &src, cv::Mat &dst, double clache_limit=4.0);
+
+        /**
+         * Function draws the line on the image, making it visually distinguishable
+         * @param src
+         * @param dst
+         * @param watershed_mask
+         */
+        static void draw_watershed_lines(cv::Mat &src, cv::Mat &dst, cv::Mat &watershed_mask);
+
     //*************
     //** PRIVATE **
     //*************

App/Utils/;�%

@@ -61,12 +61,15 @@ int main(int argc, char **argv){
     Entites::FILES::write_to_file(comm_file.c_str(),"CREATED");
     while(1){
         std::string msg = Threading::await_file_change(comm_file.c_str(),500000,2);
-        opt->crop_save_image_sample(cropped,images,std::string(std::string(OUT_FOLDER) + std::string("/cropped_bg.jpg")));
-        Entites::FILES::write_to_file(comm_file.c_str(),"NEW_SAMPLE",' ',false,true);
+        std::cout << msg << std::endl;
+        if(msg == "!NEW_SAMPLE"){
+            opt->crop_save_image_sample(cropped,images,std::string(std::string(OUT_FOLDER) + std::string("/cropped_bg.jpg")));
+            Entites::FILES::write_to_file(comm_file.c_str(),"$NEW_SAMPLE",' ',false,true);
+        }
     }
-
-    //Await changes in  mask file, with high limit
 
+    //Await changes in  mask file, with high limit
 
+    delete opt;
     return 0;
 }

App/Utils/D�

@@ -38,4 +38,10 @@
     gftt_corners<int>: 3000
     gftt_quality<double>: 0.05
     cell_radius_multiplier<int>: 2      #multiplier for cell size
+-WATERSHED
+    opening_force<int>: 3
+    blur_force<int>: 3
+    mean_median_force<int>: 3
+    clache_force<double>: 3.0
+    med_blur_second<int>: 3
 

App/Utils/Options_Optimizer/main.cpp

@@ -4,14 +4,38 @@
 #include "../../Components/Structures/Structures.h"
 #include "../../Components/Optimalization/Optimaliation.h"
 #include "../../Components/Threading/Threads.h"
+#include "../../Components/Structures/AlgorithmOptions.h"
 
 /**
-    OH BROTHER NOW I HAE TO WRITE UNIT TESTS UH
+    This file is for testing whatever needs to be tested in that specific moment
+    it does not contain any unit/integration tests
 */
 
 int main(int argc, char **argv){
+    const std::string user_mask_path = "./data/generated_mask.bmp";
+    const std::string image_path = "./data/cropped_bg.jpg";
+    const std::string OPTIONS_PATH = "./data/algorithm_default.option";
 
 
-    
+    Optimalization opt = Optimalization();
+    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);
+    cv::Mat background_mask, foreground_mask, foreground_regions, watershed_mask, result;
+    Watershed::background_mask(image,background_mask,options.get_int_var(0,"BACKGROUND_MASK"),options.get_int_var(1,"BACKGROUND_MASK"),options.get_db_var(2,"BACKGROUND_MASK"),options.get_int_var(3,"BACKGROUND_MASK"),options.get_int_var(4,"BACKGROUND_MASK"),options.get_int_var(5,"BACKGROUND_MASK"),options.get_db_var(6,"BACKGROUND_MASK"),options.get_int_var(7,"BACKGROUND_MASK"));
+    // //This will be even longer
+    Watershed::foreground_regions(image,foreground_regions,background_mask,options.get_int_var(0,"FOREGROUND_REGIONS"),options.get_int_var(1,"FOREGROUND_REGIONS"),options.get_db_var(2,"FOREGROUND_REGIONS"),options.get_int_var(3,"FOREGROUND_REGIONS"),options.get_db_var(4,"FOREGROUND_REGIONS"),options.get_int_var(5,"FOREGROUND_REGIONS"));
+    // //And thiss will be the longest
+    Watershed::foreground_mask(image,foreground_mask,foreground_regions,background_mask,options.get_int_var(0,"FOREGROUND_MASK"), options.get_int_var(1,"FOREGROUND_MASK"), options.get_int_var(2,"FOREGROUND_MASK"), options.get_int_var(3,"FOREGROUND_MASK"), options.get_db_var(4,"FOREGROUND_MASK"), options.get_db_var(5,"FOREGROUND_MASK"),options.get_db_var(6,"FOREGROUND_MASK"), options.get_db_var(7,"FOREGROUND_MASK"), options.get_int_var(8,"FOREGROUND_MASK"), options.get_int_var(9,"FOREGROUND_MASK"), options.get_int_var(10,"FOREGROUND_MASK"), options.get_db_var(11,"FOREGROUND_MASK"), options.get_int_var(12,"FOREGROUND_MASK"));
+    //And apply the watershed with masks and options
+    Watershed::watershed_with_masks(image,watershed_mask,background_mask,foreground_mask,options.get_int_var(0,"WATERSHED"),options.get_int_var(1,"WATERSHED"),options.get_int_var(2,"WATERSHED"),options.get_db_var(3,"WATERSHED"),options.get_int_var(4,"WATERSHED"));
+    //new sample should be in variable watershed_mask
+    Watershed::draw_watershed_lines(image,result,watershed_mask);
+    // std::cout << "Oversection_over_union: ";
+    std::cout << opt.calculate_intersection_over_union(watershed_mask) << std::endl;
+    // cv::imshow("SHOW",result);
+    // cv::waitKey(0);
     return 0;
 }

App/Utils/Options_Optimizer/main.out

@@ -38,4 +38,10 @@
     gftt_corners<int>: 3000
     gftt_quality<double>: 0.05
     cell_radius_multiplier<int>: 2      #multiplier for cell size
+-WATERSHED
+    opening_force<int>: 3
+    blur_force<int>: 3
+    mean_median_force<int>: 3
+    clache_force<double>: 3.0
+    med_blur_second<int>: 3