debug.hpp

浏览该文件的文档.

/*
 * @Description: 调试类 头文件及其实现
 * @Version:
 * @Autor: dreamy-xay
 * @date: 2023-12-06
 * @LastEditors: dreamy-xay
 * @LastEditTime: 2024-07-01
 */
 
#ifndef COMMON_DEBUG_HPP
#define COMMON_DEBUG_HPP
 
#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/opencv.hpp>
#include <string>
 
#include "common/base/line.hpp"
#include "common/base/rect.hpp"
#include "common/base/scope.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 Debug {
   private:
    /* 计数器结构体 */
    struct Counter {
       private:
        size_t count;  // 计数器当前计数
        size_t step;   // 计数器自增步长
 
       public:
        Counter(size_t init_count = 0, size_t step = 1);
        size_t GetCount();
    };
 
    mutable Scope<Counter> counter;                       // 多作用域下计数器
    mutable Scope<std::string> output_image_name_suffix;  // 多作用域下输出文件名后缀
 
    bool is_enable_image_output;  // 是否启用图片输出
 
   public:
    std::string output_image_path;
    std::string image_name;
 
    static Printer Print  Cm_WEAK_ATTRIBUTE ;          // 简单打印器
    static ComplexPrinter CPrint  Cm_WEAK_ATTRIBUTE ;  // 复杂打印器，可以打印参数名
 
    struct ConfigLines {
       private:
        const std::vector<Line> lines;
        bool output_seq_num;
        bool is_arrowed;
        cv::Scalar line_color;
        int line_thickness;
        cv::Scalar text_color;
        int text_thickness;
 
       public:
        ConfigLines(const std::vector<Line>& lines, bool output_seq_num = true, bool is_arrowed = true, const cv::Scalar& line_color = cv::Scalar(255, 0, 0), int line_thickness = 1, const cv::Scalar& text_color = cv::Scalar(0, 0, 255), int text_thickness = 1);
        const ConfigLines& DrawLines(cv::Mat& image) const;
    };
 
    struct ConfigRects {
       private:
        const std::vector<Rect> rects;
        bool output_seq_num;
        cv::Scalar rect_color;
        int rect_thickness;
        cv::Scalar text_color;
        int text_thickness;
 
       public:
        ConfigRects(const std::vector<Rect>& rects, bool output_seq_num = true, const cv::Scalar& rect_color = cv::Scalar(255, 0, 0), int rect_thickness = 2, const cv::Scalar& text_color = cv::Scalar(0, 0, 255), int text_thickness = 1);
        const ConfigRects& DrawRects(cv::Mat& image) const;
    };
 
    /* Debug 类公有方法声明 */
    Debug(const std::string& output_image_path = "", const std::string& image_name = "debug", bool is_enable_image_output = true);
    ~Debug();
 
    Debug& SetImageOutputStatus(bool is_enable_image_output);
 
    const Debug& CounterStart(const std::string& counter_name = "__INITIAL__", size_t start = 0, size_t step = 1) const;
    const Debug& CounterEnd() const;
 
    const Debug& NamedStart(const std::string& image_name_suffix) const;
    const Debug& NamedEnd() const;
 
    const Debug& OutputImage(const std::string& image_name_suffix, const cv::Mat& image, const std::vector<ConfigLines>& lines_list = {}, const std::vector<ConfigRects>& rects_list = {}, bool is_print_image_path = false) const;
    const Debug& OutputImage(const cv::Mat& image, const std::vector<ConfigLines>& lines_list = {}, const std::vector<ConfigRects>& rects_list = {}, bool is_print_image_path = false) const;
    const Debug& OutputHistogram(const std::string& image_name_suffix, const cv::Mat& histogram, int item_width = 4, bool is_print_image_path = false) const;
    const Debug& OutputHistogram(const cv::Mat& histogram, int item_width = 4, bool is_print_image_path = false) const;
};
 
inline Debug::Counter::Counter(size_t init_count, size_t step) : count(init_count), step(step) {}
 
inline size_t Debug::Counter::GetCount() {
    size_t current_count = count;  // 报存原计数器值
    count += step;                 // 自增计数器
    return current_count;
}
 
Printer Debug::Print;
 
ComplexPrinter Debug::CPrint;
 
inline Debug::ConfigLines::ConfigLines(const std::vector<Line>& lines, bool output_seq_num, bool is_arrowed, const cv::Scalar& line_color, int line_thickness, const cv::Scalar& text_color, int text_thickness) : lines(lines), output_seq_num(output_seq_num), is_arrowed(is_arrowed), line_color(line_color), line_thickness(line_thickness), text_color(text_color), text_thickness(text_thickness) {}
 
inline const Debug::ConfigLines& Debug::ConfigLines::DrawLines(cv::Mat& image) const {
    // 遍历所有线
    for (int i = int(lines.size()) - 1; i >= 0; --i) {
        if (output_seq_num)
            cv::putText(image, std::to_string(i), lines[i].pt1, 1, 1, text_color, text_thickness);  // 显示线的序号
 
        if (is_arrowed)
            cv::arrowedLine(image, lines[i].pt1, lines[i].pt2, line_color, line_thickness, 8, 0, 0.01);  // 使用箭头线
        else
            cv::line(image, lines[i].pt1, lines[i].pt2, line_color, line_thickness);  // 使用直线
    }
 
    return *this;
}
 
inline Debug::ConfigRects::ConfigRects(const std::vector<Rect>& rects, bool output_seq_num, const cv::Scalar& rect_color, int rect_thickness, const cv::Scalar& text_color, int text_thickness) : rects(rects), output_seq_num(output_seq_num), rect_color(rect_color), rect_thickness(rect_thickness), text_color(text_color), text_thickness(text_thickness) {}
 
inline const Debug::ConfigRects& Debug::ConfigRects::DrawRects(cv::Mat& image) const {
    // 遍历所有矩形
    for (int i = int(rects.size()) - 1; i >= 0; --i) {
        if (output_seq_num)
            cv::putText(image, std::to_string(i), cv::Point(rects[i].x, rects[i].y), 1, 1, text_color, text_thickness);  // 显示矩形的序号
 
        cv::rectangle(image, rects[i], rect_color, rect_thickness);  // 绘制矩形
    }
 
    return *this;
}
 
inline Debug::Debug(const std::string& output_image_path, const std::string& image_name, bool is_enable_image_output) : output_image_path(output_image_path), image_name(image_name), is_enable_image_output(is_enable_image_output), counter("__INITIAL__"), output_image_name_suffix("__INITIAL__") {}
 
inline Debug::~Debug() {}
 
inline Debug& Debug::SetImageOutputStatus(bool is_enable_image_output) {
    this->is_enable_image_output = is_enable_image_output;
}
 
inline const Debug& Debug::CounterStart(const std::string& counter_name, size_t start, size_t step) const {
    // 如果不存在计数器则创建
    if (!counter.Has(counter_name))
        counter.Set(counter_name, Counter(start, step));
 
    // 存在计数器则切换
    counter.Switch(counter_name);
 
    return *this;
}
 
inline const Debug& Debug::CounterEnd() const {
    // 完成当前计数器计数工作
    counter.Finish();
 
    return *this;
}
 
inline const Debug& Debug::NamedStart(const std::string& image_name_suffix) const {
    // 断言默认图片名称不能为 "__INITIAL__"
    Cm_Assert(image_name_suffix != "__INITIAL__", "image name cannot be \"__INITIAL__\"!");
 
    // 如果不存在默认输出图片名则创建
    if (!output_image_name_suffix.Has(image_name_suffix))
        output_image_name_suffix.Set(image_name_suffix, image_name_suffix);
 
    // 存在默认输出图片名则切换
    output_image_name_suffix.Switch(image_name_suffix);
 
    return *this;
}
 
inline const Debug& Debug::NamedEnd() const {
    // 完成当前输出默认图片名工作
    output_image_name_suffix.Finish();
 
    return *this;
}
 
inline const Debug& Debug::OutputImage(const std::string& image_name_suffix, const cv::Mat& image, const std::vector<Debug::ConfigLines>& lines_list, const std::vector<Debug::ConfigRects>& rects_list, bool is_print_image_path) const {
    // 如果不启用图片输出，则直接返回
    if (!is_enable_image_output)
        return *this;
 
    cv::Mat output_image = image.clone();  // 克隆一份图片
 
    for (auto& lines : lines_list)  // 图片上画线
        lines.DrawLines(output_image);
 
    for (auto& rects : rects_list)  // 图片上画矩形
        rects.DrawRects(output_image);
 
    bool use_counter = !counter.IsInitial();  // 图片名是否使用计数器
 
    // 输出的图片路径
    auto image_path = std::move(Sprintf("%s/%s%s%s%s%s.jpg", output_image_path.c_str(), image_name.c_str(), image_name_suffix.empty() ? "" : "_", image_name_suffix.c_str(), use_counter ? "_" : "", use_counter ? std::to_string(counter.Value().GetCount()).c_str() : ""));
 
    if (is_print_image_path)
        CPrint("Output Image Path", image_path) << '\n';
 
    // 输出图片
    cv::imwrite(image_path, output_image);
 
    return *this;
}
 
inline const Debug& Debug::OutputImage(const cv::Mat& image, const std::vector<Debug::ConfigLines>& lines_list, const std::vector<Debug::ConfigRects>& rects_list, bool is_print_image_path) const {
    // 断言是否使用了NamedStart
    Cm_Assert(!output_image_name_suffix.IsInitial(), "please call the \"NamedStart\"(or \"NamedSwitch\") function to set the name of the output image!!!");
 
    this->OutputImage(output_image_name_suffix.Value(), image, lines_list, rects_list, is_print_image_path);  // 使用 默认输出图片名 输出图片
 
    return *this;
}
 
inline const Debug& Debug::OutputHistogram(const std::string& image_name_suffix, const cv::Mat& histogram, int item_width, bool is_print_image_path) const {
    // 如果不启用图片输出，则直接返回
    if (!is_enable_image_output)
        return *this;
 
    // 准备绘制直方图
    int hist_w = histogram.rows * item_width + 40;
    int hist_h = 200;
    double max_val;
    cv::Point max_val_point;
 
    // 计算直方图中最大值
    cv::minMaxLoc(histogram, nullptr, &max_val, nullptr, &max_val_point);
 
    // 直方图缩放比率
    double scale = 1.0;
    // 控制直方图的有效高度不得超过 2000
    if (max_val > 2000) {
        scale = 2000.0 / max_val;
        max_val = 2000.0;
    }
 
    hist_h += max_val;
 
    cv::Mat hist_image = cv::Mat::zeros(hist_h, hist_w, CV_8UC3);  // 准备 hist_image 为全黑背景色
 
    for (int i = 0; i < histogram.rows; ++i)
        cv::rectangle(hist_image, cv::Point(item_width * i + 20, hist_h - 100), cv::Point(item_width * (i + 1) + 20, hist_h - cvRound(histogram.at<float>(i) * scale) - 100), cv::Scalar(255, 255, 255), -1);  // 绘制直方图中的每一项
 
    // 输出直方图中最大值的灰度值
    cv::putText(hist_image, std::to_string(max_val_point.y), cv::Point(item_width * (max_val_point.y + 1) + 10, hist_h - cvRound(histogram.at<float>(max_val_point.y) * scale) - 110), 1, 1, cv::Scalar(255, 255, 255));
 
    bool use_counter = !counter.IsInitial();  // 图片名是否使用计数器
 
    // 输出的图片路径
    auto image_path = std::move(Sprintf("%s/%s%s%s%s%s.jpg", output_image_path.c_str(), image_name.c_str(), image_name_suffix.empty() ? "" : "_", image_name_suffix.c_str(), use_counter ? "_" : "", use_counter ? std::to_string(counter.Value().GetCount()).c_str() : ""));
 
    if (is_print_image_path)
        CPrint("Output Histogram Image Path", image_path) << '\n';
 
    // 输出图片
    cv::imwrite(image_path, hist_image);
 
    return *this;
}
 
inline const Debug& Debug::OutputHistogram(const cv::Mat& histogram, int item_width, bool is_print_image_path) const {
    // 断言是否使用了NamedStart
    Cm_Assert(!output_image_name_suffix.IsInitial(), "please call the \"NamedStart\" function to set the name of the output image!!!");
 
    this->OutputHistogram(output_image_name_suffix.Value(), histogram, item_width, is_print_image_path);  // 使用 默认输出图片名 输出直方图图片
 
    return *this;
}
 
}  // namespace cm
 
#endif