robustness_tool.h

Go to the documentation of this file.

#ifndef ROBUSTNESS_TOOL_H
#define ROBUSTNESS_TOOL_H

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

class RobustnessToolDriver {
public:
    virtual void computeImage(const cv::Mat &image, cv::Mat &computed_image) = 0;
    
    virtual void computeSegmentation(const cv::Mat &segmentation, 
            cv::Mat &computed_segmentation) = 0;
    
    virtual bool next() = 0;
    
    virtual std::string identify() = 0;
    
};

class RobustnessTool {
public:
    
    RobustnessTool(boost::filesystem::path &base_directory, boost::filesystem::path &image_directory, 
            boost::filesystem::path &gt_directory, std::string command_line, RobustnessToolDriver* driver);
    
    void setFilesToKeep(const std::vector<std::string> &files);
    
    void evaluate();
    
private:
    
    void cleanDirectory(boost::filesystem::path directory);
    
    boost::filesystem::path base_directory;
    boost::filesystem::path image_directory;
    boost::filesystem::path gt_directory;
    
    std::string command_line;
    
    RobustnessToolDriver* driver;    
    
    std::vector<std::string> files;
    
};

class GaussianNoiseDriver : public RobustnessToolDriver {
public:
    
    GaussianNoiseDriver(std::string type, const std::vector<float> &variances);
    
    void computeImage(const cv::Mat &image, cv::Mat &computed_image);
    
    void computeSegmentation(const cv::Mat &segmentation, 
            cv::Mat &computed_segmentation);
    
    bool next();
    
    std::string identify();
    
private:
    
    std::string type;
    
    std::vector<float> variances;
    
    int current;
};

class PoissonNoiseDriver : public RobustnessToolDriver {
public:
    
    PoissonNoiseDriver();
    
    void computeImage(const cv::Mat &image, cv::Mat &computed_image);
    
    void computeSegmentation(const cv::Mat &segmentation, 
            cv::Mat &computed_segmentation);
    
    bool next();
    
    std::string identify();
    
};

class SaltAndPepperNoiseDriver : public RobustnessToolDriver {
public:
    
    SaltAndPepperNoiseDriver(const std::vector<float> &probabilities);
    
    void computeImage(const cv::Mat &image, cv::Mat &computed_image);
    
    void computeSegmentation(const cv::Mat &segmentation, 
            cv::Mat &computed_segmentation);
    
    bool next();
    
    std::string identify();
    
private:
    
    std::vector<float> probabilities;
    
    int current;
    
};

class BlurDriver : public RobustnessToolDriver {
public:
    
    BlurDriver(const std::vector<int> &sizes);
    
    void computeImage(const cv::Mat &image, cv::Mat &computed_image);
    
    void computeSegmentation(const cv::Mat &segmentation, 
            cv::Mat &computed_segmentation);
    
    bool next();
    
    std::string identify();
    
private:
    
    std::vector<int> sizes;
    
    int current;
    
};

class GaussianBlurDriver : public RobustnessToolDriver {
public:
    
    GaussianBlurDriver(const std::vector<int> &sizes, const std::vector<float> &variances);
    
    void computeImage(const cv::Mat &image, cv::Mat &computed_image);
    
    void computeSegmentation(const cv::Mat &segmentation, 
            cv::Mat &computed_segmentation);
    
    bool next();
    
    std::string identify();
    
private:
    
    std::vector<int> sizes;
    
    std::vector<float> variances;
    
    int current;
    
};

class MedianBlurDriver : public RobustnessToolDriver {
public:
    
    MedianBlurDriver(const std::vector<int> &sizes);
    
    void computeImage(const cv::Mat &image, cv::Mat &computed_image);
    
    void computeSegmentation(const cv::Mat &segmentation, 
            cv::Mat &computed_segmentation);
    
    bool next();
    
    std::string identify();
    
private:
    
    std::vector<int> sizes;
    
    int current;
};

class BilateralFilterDriver : public RobustnessToolDriver {
public:
    
    BilateralFilterDriver(const std::vector<int> &sizes, const std::vector<float> &color_variances, 
            const std::vector<float> &space_variances);
    
    void computeImage(const cv::Mat &image, cv::Mat &computed_image);
    
    void computeSegmentation(const cv::Mat &segmentation, 
            cv::Mat &computed_segmentation);
    
    bool next();
    
    std::string identify();
    
private:
    
    std::vector<int> sizes;
    
    std::vector<float> color_variances;
    
    std::vector<float> space_variances;
    
    int current;
    
};

class MotionBlurDriver : public RobustnessToolDriver {
public:
    
    MotionBlurDriver(const std::vector<int> &sizes, const std::vector<float> &angles);
    
    void computeImage(const cv::Mat &image, cv::Mat &computed_image);
    
    void computeSegmentation(const cv::Mat &segmentation, 
            cv::Mat &computed_segmentation);
    
    bool next();
    
    std::string identify();
    
private:
    
    std::vector<int> sizes;
    
    std::vector<float> angles;
    
    int current;
    
};

class ShearDriver : public RobustnessToolDriver {
public:
    
    ShearDriver(std::string type, int crop, const std::vector<float> &m);
    
    void computeImage(const cv::Mat &image, cv::Mat &computed_image);
    
    void computeSegmentation(const cv::Mat &segmentation, 
            cv::Mat &computed_segmentation);
    
    bool next();
    
    std::string identify();
    
private:
    
    std::string type;
    
    int crop;
    
    std::vector<float> m;
    
    int current;
    
};

class RotationDriver : public RobustnessToolDriver {
public:
    
    RotationDriver(int crop, const std::vector<float> &angles);
    
    void computeImage(const cv::Mat &image, cv::Mat &computed_image);
    
    void computeSegmentation(const cv::Mat &segmentation, 
            cv::Mat &computed_segmentation);
    
    bool next();
    
    std::string identify();
    
private:
    
    int crop;
    
    std::vector<float> angles;
    
    int current;
    
};

class TranslationDriver : public RobustnessToolDriver {
public:
    
    TranslationDriver(int crop, const std::vector<int> &x, const std::vector<int> &y);
    
    void computeImage(const cv::Mat &image, cv::Mat &computed_image);
    
    void computeSegmentation(const cv::Mat &segmentation, 
            cv::Mat &computed_segmentation);
    
    bool next();
    
    std::string identify();
    
private:
    
    int crop;
    
    std::vector<int> x;
    
    std::vector<int> y;
    
    int current;
    
};

#endif  /* ROBUSTNESS_TOOL_H */