image_preprocess.hpp

浏览该文件的文档.

/*
 * @Description: 图像预处理器类 头文件
 * @Version:
 * @Autor: dreamy-xay
 * @date: 2023-12-17
 * @LastEditors: dreamy-xay
 * @LastEditTime: 2024-05-28
 */
 
#ifndef COMMON_IMAGE_PREPROCESS_H
#define COMMON_IMAGE_PREPROCESS_H
 
#include <memory>
#include <opencv2/core.hpp>
#include <opencv2/opencv.hpp>
#include <vector>
 
#if defined(__linux__)
#include <opencv2/imgproc/types_c.h>
#endif
 
#include "common/base/percent.hpp"
#include "common/debug/print_package.h"
#include "common/enum.h"
#include "common/macro.h"
#include "common/type.h"
#include "common/utils/string.hpp"
 
namespace cm {
 
// * 图像预处理器：开始
 
class ImagePreprocessor {
   private:
    std::vector<std::shared_ptr<ImagePreprocessor>> actions;  // 图像预处理动作列表
 
   public:
    ImagePreprocessor() = default;
    ImagePreprocessor(const ImagePreprocessor& img_preprocessor) = default;
    virtual ~ImagePreprocessor() = default;
 
    ImagePreprocessor operator|(const ImagePreprocessor& img_preprocessor) const;
    ImagePreprocessor& operator|=(const ImagePreprocessor& img_preprocessor);
    ImagePreprocessor& AddAction(const ImagePreprocessor& img_preprocessor);
 
    cv::Mat operator()(const cv::Mat& image) const;
    virtual cv::Mat Preprocess(const cv::Mat& image) const;
    
   protected:
    void Init(ImagePreprocessor* self_pointer);
};
 
inline ImagePreprocessor ImagePreprocessor::operator|(const ImagePreprocessor& img_preprocessor) const {
    ImagePreprocessor new_img_preprocessor(*this);
 
    new_img_preprocessor.actions.insert(new_img_preprocessor.actions.end(), img_preprocessor.actions.begin(), img_preprocessor.actions.end());
 
    return std::move(new_img_preprocessor);
}
 
inline ImagePreprocessor& ImagePreprocessor::operator|=(const ImagePreprocessor& img_preprocessor) {
    actions.insert(actions.end(), img_preprocessor.actions.begin(), img_preprocessor.actions.end());
 
    return *this;
}
 
inline ImagePreprocessor& ImagePreprocessor::AddAction(const ImagePreprocessor& img_preprocessor) {
    actions.insert(actions.end(), img_preprocessor.actions.begin(), img_preprocessor.actions.end());
 
    return *this;
}
 
inline cv::Mat ImagePreprocessor::operator()(const cv::Mat& image) const {
    return std::move(this->Preprocess(image));
}
 
inline cv::Mat ImagePreprocessor::Preprocess(const cv::Mat& image) const {
    cv::Mat new_image(image);
 
    // 遍历所有动作
    for (auto& action : actions)
        new_image = std::move(action->Preprocess(new_image));
 
    return new_image;
}
 
inline void ImagePreprocessor::Init(ImagePreprocessor* self_pointer) {
    actions.emplace_back(std::shared_ptr<ImagePreprocessor>(self_pointer));
}
// * 图像预处理器：结束
 
namespace imp {
 
class Binarization : public ImagePreprocessor {
   private:
    bool is_common;
    double thresh_or_c;
    double maxval;
    int type;
    int adaptive_method;
    int block_size;
    bool reverse;
 
   public:
    static const struct CommonThreshold {
    } COMMON  Cm_WEAK_ATTRIBUTE ;
    static const struct AdaptiveThreshold {
    } ADAPTIVE  Cm_WEAK_ATTRIBUTE ;
 
    explicit Binarization(const CommonThreshold& _, double thresh = 0, double maxval = 255, int type = cv::THRESH_BINARY_INV | cv::THRESH_OTSU, bool reverse = false) : is_common(true), thresh_or_c(thresh), maxval(maxval), type(type), adaptive_method(), block_size(), reverse(reverse) {
        this->Init(new Binarization(*this));
    }
 
    explicit Binarization(const AdaptiveThreshold& _, double maxval = 255, int adaptive_method = cv::ADAPTIVE_THRESH_GAUSSIAN_C, int block_size = 61, double c = -7, int threshold_type = cv::THRESH_BINARY, bool reverse = true) : is_common(false), thresh_or_c(c), maxval(maxval), type(threshold_type), adaptive_method(adaptive_method), block_size(block_size), reverse(reverse) {
        this->Init(new Binarization(*this));
    }
 
    Binarization(const Binarization& binarization) = default;
    ~Binarization() = default;
 
    cv::Mat Preprocess(const cv::Mat& image) const override {
        cv::Mat new_image;
 
        if (image.channels() == 3) {
            cv::cvtColor(image, new_image, cv::COLOR_BGR2GRAY);
 
            if (reverse) {
                if (is_common)
                    cv::threshold(~new_image, new_image, thresh_or_c, maxval, type);
                else
                    cv::adaptiveThreshold(~new_image, new_image, maxval, adaptive_method, type, block_size, thresh_or_c);
            } else {
                if (is_common)
                    cv::threshold(new_image, new_image, thresh_or_c, maxval, type);
                else
                    cv::adaptiveThreshold(new_image, new_image, maxval, adaptive_method, type, block_size, thresh_or_c);
            }
        } else
            new_image = image.clone();
 
        return std::move(new_image);
    }
};
 
 
const Binarization::CommonThreshold Binarization::COMMON;
const Binarization::AdaptiveThreshold Binarization::ADAPTIVE;
 
const Binarization THRESHOLD_COMMON(Binarization::COMMON);
 
const Binarization THRESHOLD_ADAPTIVE(Binarization::ADAPTIVE);
 
class EdgeDetection : public ImagePreprocessor {
   private:
    enum EdgeDetectionType {
        EDT_SOBEL,
        EDT_SCHARR,
        EDT_LAPLACIAN,
        EDT_CANNY,
        EDT_ROBERTS,
        EDT_PREWITT,
        EDT_LOG,
        EDT_DOG
    } edge_detection_type;
 
    int ddepth;
    int dx;
    int dy;
    int ksize;
    double scale;
    double delta;
    int type;
    double threshold1;
    double threshold2;
    int aperture_size;
    bool l2_gradient;
    cv::Mat kernel;
    cv::Point anchor;
 
   public:
    static const struct SobelEdgeDection {
    } SOBEL  Cm_WEAK_ATTRIBUTE ;
    static const struct ScharrEdgeDection {
    } SCHARR  Cm_WEAK_ATTRIBUTE ;
    static const struct LaplacianEdgeDection {
    } LAPLACIAN  Cm_WEAK_ATTRIBUTE ;
    static const struct CannyEdgeDection {
    } CANNY  Cm_WEAK_ATTRIBUTE ;
    static const struct RobertsEdgeDection {
    } ROBERTS  Cm_WEAK_ATTRIBUTE ;
    static const struct PrewittEdgeDection {
    } PREWITT  Cm_WEAK_ATTRIBUTE ;
    static const struct DoGEdgeDection {
    } DOG  Cm_WEAK_ATTRIBUTE ;
 
    explicit EdgeDetection(const SobelEdgeDection& _, int ddepth = -1, int dx = 1, int dy = 1, int ksize = 3, double scale = 1, double delta = 0, int type = cv::BORDER_DEFAULT) : edge_detection_type(EDT_SOBEL), ddepth(ddepth), dx(dx), dy(dy), ksize(ksize), scale(scale), delta(delta), type(type), threshold1(), threshold2(), aperture_size(), l2_gradient(), kernel(), anchor() {
        this->Init(new EdgeDetection(*this));
    }
 
    explicit EdgeDetection(const ScharrEdgeDection& _, int ddepth = -1, int dx = 0, int dy = 1, double scale = 1, double delta = 0, int type = cv::BORDER_DEFAULT) : edge_detection_type(EDT_SCHARR), ddepth(ddepth), dx(dx), dy(dy), ksize(), scale(scale), delta(delta), type(type), threshold1(), threshold2(), aperture_size(), l2_gradient(), kernel(), anchor() {
        this->Init(new EdgeDetection(*this));
    }
 
    explicit EdgeDetection(const LaplacianEdgeDection& _, int ddepth = -1, int ksize = 1, double scale = 1, double delta = 0, int type = cv::BORDER_DEFAULT) : edge_detection_type(EDT_LAPLACIAN), ddepth(ddepth), dx(), dy(), ksize(ksize), scale(scale), delta(delta), type(type), threshold1(), threshold2(), aperture_size(), l2_gradient(), kernel(), anchor() {
        this->Init(new EdgeDetection(*this));
    }
 
    explicit EdgeDetection(const CannyEdgeDection& _, double threshold1 = 100, double threshold2 = 200, int aperture_size = 3, bool l2_gradient = false) : edge_detection_type(EDT_CANNY), ddepth(), dx(), dy(), ksize(), scale(), delta(), type(), threshold1(threshold1), threshold2(threshold2), aperture_size(aperture_size), l2_gradient(l2_gradient), kernel(), anchor() {
        this->Init(new EdgeDetection(*this));
    }
 
    explicit EdgeDetection(const RobertsEdgeDection& _, int ddepth = -1, cv::Mat kernel = (cv::Mat_<float>(2, 2) << 1, 0, 0, -1), cv::Point anchor = cv::Point(-1, -1), double delta = 0, int type = cv::BORDER_DEFAULT) : edge_detection_type(EDT_ROBERTS), ddepth(ddepth), dx(), dy(), ksize(), scale(), delta(delta), type(type), threshold1(), threshold2(), aperture_size(), l2_gradient(), kernel(kernel), anchor(anchor) {
        this->Init(new EdgeDetection(*this));
    }
 
    explicit EdgeDetection(const PrewittEdgeDection& _, int ddepth = -1, cv::Mat kernel = (cv::Mat_<float>(3, 3) << -1, 0, 1, -1, 0, 1, -1, 0, 1), cv::Point anchor = cv::Point(-1, -1), double delta = 0, int type = cv::BORDER_DEFAULT) : edge_detection_type(EDT_PREWITT), ddepth(ddepth), dx(), dy(), ksize(), scale(), delta(delta), type(type), threshold1(), threshold2(), aperture_size(), l2_gradient(), kernel(kernel), anchor(anchor) {
        this->Init(new EdgeDetection(*this));
    }
 
    explicit EdgeDetection(const DoGEdgeDection& _, int ddepth = -1, cv::Mat kernel = (cv::Mat_<float>(5, 5) << 0, 0, 1, 0, 0, 0, 1, 2, 1, 0, 1, 2, -16, 2, 1, 0, 1, 2, 1, 0, 0, 0, 1, 0, 0), cv::Point anchor = cv::Point(-1, -1), double delta = 0, int type = cv::BORDER_DEFAULT) : edge_detection_type(EDT_DOG), ddepth(ddepth), dx(), dy(), ksize(), scale(), delta(delta), type(type), threshold1(), threshold2(), aperture_size(), l2_gradient(), kernel(kernel), anchor(anchor) {
        this->Init(new EdgeDetection(*this));
    }
 
    EdgeDetection(const EdgeDetection& edge_detection) = default;
    ~EdgeDetection() = default;
 
    cv::Mat Preprocess(const cv::Mat& image) const override {
        cv::Mat new_image;
 
        switch (edge_detection_type) {
            case EDT_SOBEL:
                cv::Sobel(image, new_image, ddepth, dx, dy, ksize, scale, delta, type);
                break;
            case EDT_SCHARR:
                cv::Scharr(image, new_image, ddepth, dx, dy, scale, delta, type);
                break;
            case EDT_LAPLACIAN:
                cv::Laplacian(image, new_image, ddepth, ksize, scale, delta, type);
                break;
            case EDT_CANNY:
                cv::Canny(image, new_image, threshold1, threshold2, aperture_size, l2_gradient);
                break;
            case EDT_ROBERTS | EDT_PREWITT | EDT_DOG:
                cv::filter2D(image, new_image, ddepth, kernel, anchor, delta, type);
                break;
            default:
                new_image = image.clone();
                break;
        }
        return std::move(new_image);
    }
};
 
 
const EdgeDetection::SobelEdgeDection EdgeDetection::SOBEL;
const EdgeDetection::ScharrEdgeDection EdgeDetection::SCHARR;
const EdgeDetection::LaplacianEdgeDection EdgeDetection::LAPLACIAN;
const EdgeDetection::CannyEdgeDection EdgeDetection::CANNY;
const EdgeDetection::RobertsEdgeDection EdgeDetection::ROBERTS;
const EdgeDetection::PrewittEdgeDection EdgeDetection::PREWITT;
const EdgeDetection::DoGEdgeDection EdgeDetection::DOG;
 
const EdgeDetection ED_SOBEL(EdgeDetection::SOBEL);
const EdgeDetection ED_SCHARR(EdgeDetection::SCHARR);
const EdgeDetection ED_LAPLACIAN(EdgeDetection::LAPLACIAN);
const EdgeDetection ED_CANNY(EdgeDetection::CANNY);
const EdgeDetection ED_ROBERTS(EdgeDetection::ROBERTS);
const EdgeDetection ED_PREWITT(EdgeDetection::PREWITT);
const EdgeDetection ED_DOG(EdgeDetection::DOG);
 
 
class LinesDetection : public ImagePreprocessor {
   private:
    enum LinesDetectType {
        LDT_SOLID,
        LDT_DASHED,
        LDT_DOTTED
    } lines_detect_type;
    bool is_hline;
    Percent ksize_or_scale;
    Percent ksize_or_scale2;
 
   public:
    static const struct SolidLinesDetection {
    } SOLID  Cm_WEAK_ATTRIBUTE ;
    static const struct DashedLinesDetection {
    } DASHED  Cm_WEAK_ATTRIBUTE ;
    static const struct DottedLinesDetection {
    } DOTTED  Cm_WEAK_ATTRIBUTE ;
 
    explicit LinesDetection(const SolidLinesDetection& _, LineType line_type, const Percent& ksize_or_scale = 1.0 / 75) : lines_detect_type(LDT_SOLID), is_hline((line_type == HLINE || line_type == VLINE) ? line_type == HLINE : (throw Exception("The \"line type\" only supports \"cm::HLINE\" or \"cm::VLINE\" types!"))), ksize_or_scale(ksize_or_scale), ksize_or_scale2() {
        this->Init(new LinesDetection(*this));
    }
 
    explicit LinesDetection(const DashedLinesDetection& _, LineType line_type, const Percent& ksize_or_scale = 1.0 / 200) : lines_detect_type(LDT_DASHED), is_hline((line_type == HLINE || line_type == VLINE) ? line_type == HLINE : (throw Exception("The \"line type\" only supports \"cm::HLINE\" or \"cm::VLINE\" types!"))), ksize_or_scale(ksize_or_scale), ksize_or_scale2() {
        this->Init(new LinesDetection(*this));
    }
 
    explicit LinesDetection(const DottedLinesDetection& _, LineType line_type, const Percent& dilate_ksize_or_scale = 5, const Percent& open_ksize_or_scale = 1.0 / 30) : lines_detect_type(LDT_DOTTED), is_hline((line_type == HLINE || line_type == VLINE) ? line_type == HLINE : (throw Exception("The \"line type\" only supports \"cm::HLINE\" or \"cm::VLINE\" types!"))), ksize_or_scale(dilate_ksize_or_scale), ksize_or_scale2(open_ksize_or_scale) {
        this->Init(new LinesDetection(*this));
    }
 
    LinesDetection(const LinesDetection& lines_detection) = default;
    ~LinesDetection() = default;
 
    cv::Mat Preprocess(const cv::Mat& image) const override {
        Cm_Assert(image.channels() == 1, "the image is a single channel image!!!");
 
        size_t image_height = image.rows;
        size_t image_width = image.cols;
 
        size_t kernel_size = ksize_or_scale * (is_hline ? image_width : image_height);
        kernel_size = std::max(kernel_size, 1u);
 
        cv::Mat new_image;
 
        switch (lines_detect_type) {
            case LDT_SOLID: {
                cv::Size morph_open_ksize, morph_close_ksize;
 
                if (is_hline) {
                    morph_open_ksize = cv::Size(kernel_size << 1, 1);
                    morph_close_ksize = cv::Size(kernel_size, 1);
                } else {
                    morph_open_ksize = cv::Size(1, kernel_size << 1);
                    morph_close_ksize = cv::Size(1, kernel_size);
                }
 
                auto kernel = cv::getStructuringElement(cv::MORPH_RECT, morph_open_ksize);
 
                cv::morphologyEx(image, new_image, cv::MORPH_OPEN, kernel);
 
                kernel = cv::getStructuringElement(cv::MORPH_RECT, morph_close_ksize);
 
                cv::erode(new_image, new_image, kernel);
                cv::dilate(new_image, new_image, kernel);
 
                break;
            }
            case LDT_DASHED: {
                cv::Size erode_ksize = is_hline ? cv::Size(kernel_size, 1) : cv::Size(1, kernel_size);
 
                auto kernel = cv::getStructuringElement(cv::MORPH_RECT, erode_ksize);
                cv::erode(image, new_image, kernel);
                break;
            }
            case LDT_DOTTED: {
                cv::Size ksize = is_hline ? cv::Size(kernel_size, 1) : cv::Size(1, kernel_size);
 
                auto kernel = cv::getStructuringElement(cv::MORPH_RECT, ksize);
                cv::dilate(image, new_image, kernel);
 
                kernel_size = ksize_or_scale2 * (is_hline ? image_width : image_height);
                ksize = is_hline ? cv::Size(std::max(kernel_size, 1u), 1) : cv::Size(1, std::max(kernel_size, 1u));
                kernel = cv::getStructuringElement(cv::MORPH_RECT, ksize);
                cv::morphologyEx(new_image, new_image, cv::MORPH_OPEN, kernel);
                break;
            }
            default:
                new_image = image.clone();
        }
        return std::move(new_image);
    }
};
 
 
const LinesDetection::SolidLinesDetection LinesDetection::SOLID;
const LinesDetection::DashedLinesDetection LinesDetection::DASHED;
const LinesDetection::DottedLinesDetection LinesDetection::DOTTED;
 
const LinesDetection LD_SOLID_H(LinesDetection::SOLID, HLINE);
 
const LinesDetection LD_SOLID_V(LinesDetection::SOLID, VLINE);
 
const LinesDetection LD_DASHED_H(LinesDetection::DASHED, HLINE);
 
const LinesDetection LD_DASHED_V(LinesDetection::DASHED, VLINE);
 
const LinesDetection LD_DOTTED_H(LinesDetection::DOTTED, HLINE);
 
const LinesDetection LD_DOTTED_V(LinesDetection::DOTTED, VLINE);
 
}  // namespace imp
 
}  // namespace cm
 
#endif