evaluation_summary.h

Go to the documentation of this file.

#ifndef EVALUATION_SUMMARY_H
#define EVALUATION_SUMMARY_H

#include <vector>
#include <boost/filesystem.hpp>
#include <opencv2/opencv.hpp>

class EvaluationSummary {
public:
    
    struct SuperpixelVisualizations {
        SuperpixelVisualizations() : contour(false), random(false), perturbed_mean(false),
                mean(false), pre_rec(false), ue(false) {};
        
        bool contour;
        bool random;
        bool perturbed_mean;
        bool mean;
        bool pre_rec;
        bool ue;
        
        bool any() {
            return contour || random || perturbed_mean || mean || pre_rec || ue;
        }
    };
    
    struct EvaluationMetrics {
        EvaluationMetrics() : ue(true), oe(true), rec(true), pre(true),
                ue_np(true), ue_levin(true), asa(true), sse_rgb(true), sse_xy(true),
                co(true), ev(true), mde(true), icv(true), cd(true),
                reg(true), sp(true), sp_size(true) {};
        
        bool ue;
        bool oe;
        bool rec;
        bool pre;
        bool ue_np;
        bool ue_levin;
        bool asa;
        bool sse_rgb;
        bool sse_xy;
        bool co;
        bool ev;
        bool mde;
        bool icv;
        bool cd;
        bool reg;
        bool sp;
        bool sp_size;
    };
    
    struct EvaluationStatistics {
        
        EvaluationStatistics() : mean(true), median_and_quartiles(true), 
                min_and_max(true), mid_range(true), std(true) {};
        
        bool mean;
        bool median_and_quartiles;
        bool min_and_max;
        bool mid_range;
        bool std;
    };
    
    EvaluationSummary(boost::filesystem::path sp_directory, 
            boost::filesystem::path gt_directory, boost::filesystem::path img_directory);
    
    EvaluationSummary(boost::filesystem::path sp_directory, 
            boost::filesystem::path gt_directory, boost::filesystem::path img_directory,
            EvaluationMetrics evaluation_metrics, EvaluationStatistics evaluation_statistics);
    
    EvaluationSummary(boost::filesystem::path sp_directory, 
            boost::filesystem::path gt_directory, boost::filesystem::path img_directory,
            EvaluationMetrics evaluation_metrics, EvaluationStatistics evaluation_statistics,
            SuperpixelVisualizations superpixel_visualizations);
    
    void computeSummary(int &gt_max);
    
    void setAppendFile(const boost::filesystem::path &append_file);
    
    void setEvaluationStatistics(const EvaluationStatistics &evaluation_statistics);
    
    void setEvaluationMetrics(const EvaluationMetrics &evaluation_metrics);
    
    void setSuperpixelVisualizations(const SuperpixelVisualizations &superpixel_visualizations);
    
    void setComputeCorrelation(bool compute_correlation);
    
    void getEvaluationStatistics(EvaluationSummary::EvaluationStatistics &evaluation_statistics);

    void getEvaluationMetrics(EvaluationSummary::EvaluationMetrics &evaluation_metrics);

    void getSuperpixelVisualizations(EvaluationSummary::SuperpixelVisualizations &superpixel_visualizations);

    bool getComputeCorrelation();
    
protected:
    
    int countMetrics();
    
    void evaluateHeader(std::stringstream &output, std::vector<std::string> &metric_order);
    
    void evaluate(const cv::Mat &sp_segmentation, const cv::Mat &gt_segmentation, 
            const cv::Mat &image, cv::Mat &data, std::stringstream &output);
    
    void visualize(const cv::Mat &sp_segmentation, const cv::Mat &gt_segmentation,
            const cv::Mat &image, std::string name, int t = 0);
    
    void correlate(const cv::Mat &mat_results, const std::vector<std::string> &metric_order,
            cv::Mat &mat_correlation, std::string &csv_correlation);
    
    int countStatistics(int gt_max);
    
    void validateStatistics();
    
    void summaryHeader(const std::vector<int> &gt, std::stringstream &output);
    
    void summarize(const std::vector<int> &gt, const cv::Mat &data, 
            int j, cv::Mat &mat_summary, std::stringstream &output);
    
    float computeMean(const std::vector<int> gt, const cv::Mat &data, int j, 
            std::vector<float> &mean, float &mean_min, float &mean_max);
    
    float comuteMedian(const std::vector<int> gt, const cv::Mat &data, int j, 
            std::vector<float> &median, float &median_min, float &median_max);
    
    void comuteMedianFirstAndThirdQuartile(const std::vector<int> gt, const cv::Mat &data, int j, 
            std::vector<float> &median, std::vector<float> &first_q, std::vector<float> &thrid_q, 
            float &median_min, float &first_q_min, float &third_q_min, float &median_max,
            float &first_q_max, float &second_q_max);
    
    void comuteMinMax(const std::vector<int> gt, const cv::Mat &data, int j,
            std::vector<float> &min, std::vector<float> &max, float &min_min,
            float &max_min, float &min_max, float&max_max);
    
    float computeStandardDeviation(const std::vector<int> gt, const cv::Mat &data, int j,
        const std::vector<float> &mean, std::vector<float> &std, float &std_min,
        float &std_max);
    
    EvaluationMetrics evaluation_metrics;
    EvaluationStatistics evaluation_statistics;
    SuperpixelVisualizations superpixel_visualizations;
    
    bool compute_correlation;
    
    boost::filesystem::path sp_directory;
    boost::filesystem::path gt_directory;
    boost::filesystem::path img_directory;
    boost::filesystem::path results_file;
    boost::filesystem::path correlation_file;
    boost::filesystem::path summary_file;
    boost::filesystem::path vis_directory;
    boost::filesystem::path append_file;
};

#endif  /* EVALUATION_SUMMARY_H */