BlurProcessor.h

#ifndef BLURPROCESSOR_H
#define BLURPROCESSOR_H
 
#include "image_proc_base.h"
 
class BlurProcessor : public ImageProc {
public:
    enum class HandleType {
        MedianBlur,    
        GuassainBlur,  
        MeanBlur,      
        FilterBlur     
    };
 
    explicit BlurProcessor(const HandleType t)
        : type(t) { }
 
    ~BlurProcessor() override = default;
 
    inline HandleType handleType() const { return type; }
 
private:
    HandleType type; 
};
 
struct AbstractParamsPack {
    virtual ~AbstractParamsPack() = default;
};
 
struct MedianBlurPackage : public AbstractParamsPack {
    ~MedianBlurPackage() override = default;
 
    int kernel_size { 5 };
};
 
struct GaussainPackage : public AbstractParamsPack {
    GaussainPackage()
        : kernel_size(5)
        , sigma_x(1.5) {
        sigma_y = sigma_x;
    }
 
    ~GaussainPackage() override = default;
 
    int kernel_size;
 
    double sigma_x;
 
    double sigma_y;
};
 
struct FilterPackage : public AbstractParamsPack {
    ~FilterPackage() override = default;
 
    int d;
 
    double sigma_space;
 
    double sigma_color;
};
 
struct MeanBlurPackage : public AbstractParamsPack {
    ~MeanBlurPackage() override = default;
 
    int kernel_size { 5 };
};
 
class MeanBlur : public BlurProcessor {
public:
    MeanBlur();
 
    ~MeanBlur() override = default;
 
    bool process(CVImage& prev_image) override;
 
    static bool process(CVImage& prev_image, const MeanBlurPackage& package);
 
    MeanBlurPackage package; 
};
 
class GuassainBlur : public BlurProcessor {
public:
    GuassainBlur();
 
    ~GuassainBlur() override = default;
 
    bool process(CVImage& prev_image) override;
 
    static bool process(CVImage& prev_image, const GaussainPackage& package);
 
    GaussainPackage package; 
};
 
class MedianBlur : public BlurProcessor {
public:
    MedianBlur();
 
    ~MedianBlur() override = default;
 
    bool process(CVImage& prev_image) override;
 
    static bool process(CVImage& prev_image, const MedianBlurPackage& package);
 
    MedianBlurPackage package; 
};
 
class FilterBlur : public BlurProcessor {
public:
    FilterBlur();
 
    ~FilterBlur() override = default;
 
    bool process(CVImage& prev_image) override;
 
    static bool process(CVImage& prev_image, const FilterPackage& package);
 
    FilterPackage package; 
};
 
#endif // BLURPROCESSOR_H