projection.hpp

浏览该文件的文档.

/*
 * @Description: 投影类 头文件及其实现
 * @Version:
 * @Autor: dreamy-xay
 * @date: 2023-12-04
 * @LastEditors: dreamy-xay
 * @LastEditTime: 2024-05-10
 */
 
#ifndef COMMON_PROJECTION_HPP
#define COMMON_PROJECTION_HPP
 
#include <iostream>
#include <opencv2/core.hpp>
 
#include "common/base/interval.hpp"
#include "common/base/list.hpp"
#include "common/base/rect.hpp"
#include "common/enum.h"
#include "common/list/intervals.hpp"
#include "common/macro.h"
#include "common/type.h"
 
namespace cm {
 
class Projection {
   private:
    size_t height;             // 投影图像区域高度
    size_t width;              // 投影图像区域宽度
    size_t rows, cols;         // 投影缓存空间所对应的图像的行数和列数
    size_t** hdir_prefix_sum;  // 横向投影前缀和
    size_t** vdir_prefix_sum;  // 纵向投影前缀和
 
    void Reset(size_t height, size_t width, bool is_copy_data);
    void Free();
 
   public:
    Projection();
    Projection(const Projection& projection);
    Projection(Projection&& projection);
    Projection(const cv::Mat& binary_image);
    ~Projection();
 
    Projection& operator=(const Projection& projection);
    Projection& operator=(Projection&& projection);
 
    Projection& Reserve(size_t height, size_t width);
    Projection& Resize(size_t height, size_t width);
    Projection& Assign(const Projection& projection);
    Projection& Assign(const cv::Mat& binary_image);
    Projection& Swap(Projection& projection);
    Projection& Clear();
 
    cv::Mat Image(Direction direction, Interval row_range = Interval::All(), Interval col_range = Interval::All()) const;
    cv::Mat Image(Direction direction, const Rect& rect) const;
    List<size_t> Value(Direction direction, Interval row_range = Interval::All(), Interval col_range = Interval::All()) const;
    List<size_t> Value(Direction direction, const Rect& rect) const;
 
    size_t Row(size_t index, Interval col_range = Interval::All()) const;
    size_t Col(size_t index, Interval row_range = Interval::All()) const;
 
    size_t Height() const;
    size_t Width() const;
 
    Rect Boundary(double hdir_threshold = 0.005, double vdir_threshold = 0.005, int margin = 20) const;
 
    Intervals ExtractPeak(Direction direction, size_t min_proj_value, size_t min_peak_span, Interval row_range = Interval::All(), Interval col_range = Interval::All(), bool is_absolute_coord = true) const;
    Intervals ExtractPeak(Direction direction, size_t min_proj_value, size_t min_peak_span, const Rect& rect, bool is_absolute_coord = true) const;
    Intervals ExtractTrough(Direction direction, size_t max_proj_value, size_t min_trough_span, Interval row_range = Interval::All(), Interval col_range = Interval::All(), bool is_absolute_coord = true) const;
    Intervals ExtractTrough(Direction direction, size_t max_proj_value, size_t min_trough_span, const Rect& rect, bool is_absolute_coord = true) const;
 
    template <typename INDEXED>
    static Intervals ExtractPeak(INDEXED& projection, const Interval& interval, size_t min_proj_value, size_t min_peak_span);
    template <typename INDEXED>
    static Intervals ExtractTrough(INDEXED& projection, const Interval& interval, size_t max_proj_value, size_t min_trough_span);
};
 
inline Projection::Projection() : height(0), width(0), rows(0), cols(0), hdir_prefix_sum(nullptr), vdir_prefix_sum(nullptr) {}
 
inline Projection::Projection(const Projection& projection) {
    // 先初始化所有信息
    width = height = 0;
    rows = cols = 0;
    hdir_prefix_sum = vdir_prefix_sum = nullptr;
 
    // 调用重新赋值函数进行拷贝构造
    this->Assign(projection);
}
 
inline Projection::Projection(Projection&& projection) {
    // 更新当前类的所有信息
    width = projection.width;
    height = projection.height;
    rows = projection.rows;
    cols = projection.cols;
    hdir_prefix_sum = projection.hdir_prefix_sum;
    vdir_prefix_sum = projection.vdir_prefix_sum;
 
    // projection 置前缀和数组指针置为空，防止二次释放空间
    projection.hdir_prefix_sum = projection.vdir_prefix_sum = nullptr;
}
 
inline Projection::Projection(const cv::Mat& binary_image) {
    // 先初始化所有信息
    width = height = 0;
    rows = cols = 0;
    hdir_prefix_sum = vdir_prefix_sum = nullptr;
 
    // 调用重新赋值函数进行拷贝构造
    this->Assign(binary_image);
}
 
inline Projection::~Projection() {
    this->Free();  // 释放全部空间
}
 
inline Projection& Projection::operator=(const Projection& projection) {
    // 调用重新赋值函数进行拷贝构造
    this->Assign(projection);
 
    return *this;
}
 
inline Projection& Projection::operator=(Projection&& projection) {
    // 先释放当前类原有空间
    this->Free();
 
    // 再更新当前类的所有信息
    width = projection.width;
    height = projection.height;
    rows = projection.rows;
    cols = projection.cols;
    hdir_prefix_sum = projection.hdir_prefix_sum;
    vdir_prefix_sum = projection.vdir_prefix_sum;
 
    // projection 置前缀和数组指针置为空，防止二次释放空间
    projection.hdir_prefix_sum = projection.vdir_prefix_sum = nullptr;
 
    return *this;
}
 
inline void Projection::Free() {
    // 释放横向投影前缀和空间
    if (rows && hdir_prefix_sum) {
        for (int i = 0; i < rows; ++i)
            delete[] hdir_prefix_sum[i];
 
        rows = 0;
        delete[] hdir_prefix_sum;
        hdir_prefix_sum = nullptr;
    }
 
    // 释放纵向投影前缀和空间
    if (cols && vdir_prefix_sum) {
        for (int i = 0; i < cols; ++i)
            delete[] vdir_prefix_sum[i];
 
        delete[] vdir_prefix_sum;
        vdir_prefix_sum = nullptr;
        cols = 0;
    }
}
 
inline void Projection::Reset(size_t rows, size_t cols, bool is_copy_data) {
    // 如果需要重置的空间大小小于当前已分配空间大小，则不重置空间
    if (rows <= this->rows && cols <= this->cols)
        return;
 
    // 分配新的横向投影前缀和空间
    size_t** new_hdir_prefix_and = new size_t*[rows]();
    for (int i = 0; i < rows; ++i)
        new_hdir_prefix_and[i] = new size_t[cols + 1]();
 
    // 分配新的纵向投影前缀和空间
    size_t** new_vdir_prefix_and = new size_t*[cols]();
    for (int i = 0; i < cols; ++i)
        new_vdir_prefix_and[i] = new size_t[rows + 1]();
 
    // 根据条件选择性复制原来空间数据
    if (is_copy_data) {
        // 复制原来空间横向投影前缀和数据
        for (int i = 0; i < this->rows; ++i)
            memcpy(new_hdir_prefix_and[i], hdir_prefix_sum[i], (this->cols + 1) * sizeof(size_t));  // flawfinder: ignore
 
        // 复制原来空间纵向投影前缀和数据
        for (int i = 0; i < this->cols; ++i)
            memcpy(new_vdir_prefix_and[i], vdir_prefix_sum[i], (this->rows + 1) * sizeof(size_t));  // flawfinder: ignore
    }
 
    this->Free();  // 释放原来空间数据
 
    hdir_prefix_sum = new_hdir_prefix_and;  // 更新新的横向投影前缀和空间
    vdir_prefix_sum = new_vdir_prefix_and;  // 更新新的纵向投影前缀和空间
 
    this->rows = rows;  // 更新分配空间对应图像行数大小
    this->cols = cols;  // 更新分配空间对应图像列数大小
}
 
inline Projection& Projection::Reserve(size_t height, size_t width) {
    this->Reset(height, width, true);  // 重置空间大小并复制原空间数据
 
    return *this;
}
 
inline Projection& Projection::Resize(size_t height, size_t width) {
    this->Reset(height, width, true);  // 重置空间大小并复制原空间数据
 
    this->height = height;  // 更新投影所对应图像高度
    this->width = width;    // 更新投影所对应图像宽度
 
    return *this;
}
 
inline Projection& Projection::Assign(const Projection& projection) {
    // 先清空当前类原有数据（但分配的空间不动）
    this->Clear();
 
    // 更新投影所对应图像高度和宽度
    height = projection.height;
    width = projection.width;
 
    // 重置空间大小但不要复制原空间数据
    this->Reset(projection.height, projection.width, false);
 
    // 赋值更新横向投影前缀和数组
    for (int i = 0; i < rows; ++i)
        memcpy(hdir_prefix_sum[i], projection.hdir_prefix_sum[i], (cols + 1) * sizeof(size_t));  // flawfinder: ignore
 
    // 赋值更新纵向投影前缀和数组
    for (int i = 0; i < cols; ++i)
        memcpy(vdir_prefix_sum[i], projection.vdir_prefix_sum[i], (rows + 1) * sizeof(size_t));  // flawfinder: ignore
 
    return *this;
}
 
inline Projection& Projection::Assign(const cv::Mat& binary_image) {
    // 只支持单通道图像的投影赋值构造
    Cm_Assert(binary_image.channels() == 1, "only single-channel image (grayscale image) can be projected!");
 
    // 先清空当前类原有数据（但分配的空间不动）
    this->Clear();
 
    // 更新投影所对应图像高度和宽度
    height = binary_image.rows;
    width = binary_image.cols;
 
    // 重置空间大小但不要复制原空间数据
    this->Reset(height, width, false);
 
    // 计算横线投影前缀和
    for (int i = 0; i < height; ++i) {
        const uchar* row_ptr = binary_image.ptr<uchar>(i);  // 二值图行指针（加速索引）
 
        // 计算当前行的列前缀和
        for (int j = 0; j < width; ++j)
            hdir_prefix_sum[i][j + 1] = hdir_prefix_sum[i][j] + row_ptr[j];
    }
 
    // 计算纵向投影前缀和
    const uchar* image_ptr = binary_image.ptr<uchar>(0);  // 二值图图像数据首指针（加速索引）
    for (int i = 0; i < width; ++i)
        for (int j = 0; j < height; ++j)  // 计算当前列的行前缀和
            vdir_prefix_sum[i][j + 1] = vdir_prefix_sum[i][j] + image_ptr[i + j * width];
 
    return *this;
}
 
inline Projection& Projection::Swap(Projection& projection) {
    // 对于类内所有变量值进行交换
    std::swap(height, projection.height);
    std::swap(width, projection.width);
    std::swap(rows, projection.rows);
    std::swap(cols, projection.cols);
    std::swap(hdir_prefix_sum, projection.hdir_prefix_sum);
    std::swap(vdir_prefix_sum, projection.vdir_prefix_sum);
 
    return *this;
}
 
inline Projection& Projection::Clear() {
    // 在保证存在图像投影的情况下清零数据
    if (width && height) {
        // 只清空已经使用了的空间
        for (int i = 0; i < height; ++i)
            memset(hdir_prefix_sum[i], 0, (width + 1) * sizeof(size_t));
 
        for (int i = 0; i < width; ++i)
            memset(vdir_prefix_sum[i], 0, (height + 1) * sizeof(size_t));
    }
 
    width = height = 0;  // 投影所对应图像高度和宽度也清零
 
    return *this;
}
 
inline cv::Mat Projection::Image(Direction direction, Interval row_range, Interval col_range) const {
    row_range = std::move(row_range.Intersect({0, int(height)}));  // 保证行区间在图像的高度范围内
    col_range = std::move(col_range.Intersect({0, int(width)}));   // 保证列区间在图像的宽度范围内
 
    // 投影图像
    cv::Mat proj_image(row_range.Length(), col_range.Length(), CV_8UC1);  // 单通道二值图
    proj_image = 255;                                                     // 初始化为白色
 
    if (direction == HDIR)
        for (int i = 0; i < proj_image.rows; ++i)                                          // 横向投影
            proj_image(cv::Rect(0, i, this->Row(i + row_range.start, col_range), 1)) = 0;  // 画黑线
    else
        for (int i = 0; i < proj_image.cols; ++i)                                          // 纵向投影
            proj_image(cv::Rect(i, 0, 1, this->Col(i + col_range.start, row_range))) = 0;  // 画黑线
 
    return proj_image;
}
 
inline cv::Mat Projection::Image(Direction direction, const Rect& rect) const {
    // 默认调用获取指定行区间和列区间的投影图像图像（将矩形区域拆解成行和列区间）
    return this->Image(direction, {rect.y, rect.y + rect.height + 1}, {rect.x, rect.x + rect.width + 1});
}
 
inline List<size_t> Projection::Value(Direction direction, Interval row_range, Interval col_range) const {
    row_range = std::move(row_range.Intersect({0, int(height)}));  // 保证行区间在图像的高度范围内
    col_range = std::move(col_range.Intersect({0, int(width)}));   // 保证列区间在图像的宽度范围内
 
    List<size_t> proj_value;  // 新建一个列表存储投影值
 
    if (direction == HDIR)
        for (int i = row_range.start; i < row_range.end; ++i)  // 横向投影，根据前缀和求区间和，除以255是为了获取白色像素数目（即投影值）
            proj_value.emplace_back((hdir_prefix_sum[i][col_range.end] - hdir_prefix_sum[i][col_range.start]) / 255);
    else
        for (int i = col_range.start; i < col_range.end; ++i)  // 纵向投影，根据前缀和求区间和，除以255是为了获取白色像素数目（即投影值）
            proj_value.emplace_back((vdir_prefix_sum[i][row_range.end] - vdir_prefix_sum[i][row_range.start]) / 255);
 
    return std::move(proj_value);  // 返回投影值
}
 
inline List<size_t> Projection::Value(Direction direction, const Rect& rect) const {
    // 默认调用获取指定行区间和列区间的投影值（将矩形区域拆解成行和列区间）
    return this->Value(direction, {rect.y, rect.y + rect.height + 1}, {rect.x, rect.x + rect.width + 1});
}
 
inline size_t Projection::Row(size_t index, Interval col_range) const {
    // 断言行索引必须在图像的高度范围内
    Cm_Assert(index < height, "the index is out of bounds!");
 
    col_range = std::move(col_range.Intersect({0, int(width)}));  // 保证列区间在图像的高度范围内
 
    // 根据前缀和计算区间投影值
    return (hdir_prefix_sum[index][col_range.end] - hdir_prefix_sum[index][col_range.start]) / 255;
}
 
inline size_t Projection::Col(size_t index, Interval row_range) const {
    // 断言列索引必须在图像的高度范围内
    Cm_Assert(index >= 0 && index < width, "the index is out of bounds!");
 
    row_range = std::move(row_range.Intersect({0, int(height)}));  // 保证行区间在图像的高度范围内
 
    // 根据前缀和计算区间投影值
    return (vdir_prefix_sum[index][row_range.end] - vdir_prefix_sum[index][row_range.start]) / 255;
}
 
inline size_t Projection::Height() const {
    return height;
}
 
inline size_t Projection::Width() const {
    return width;
}
 
inline Rect Projection::Boundary(double hdir_threshold, double vdir_threshold, int margin) const {
    int upper_boundary = 0, lower_boundary = height;  // 图像的上下边界
    int left_boundary = 0, right_boundary = width;    // 图像的左右边界
 
    int min_h_proj_value = hdir_threshold * width;   // 最小的横向投影值
    int min_v_proj_value = vdir_threshold * height;  // 最小的纵向投影值
 
    for (int i = 0; i < width; ++i)  // 查找图像的左边界
        if ((vdir_prefix_sum[i][height] - vdir_prefix_sum[i][0]) / 255 >= min_v_proj_value) {
            left_boundary = i;
            break;
        }
 
    for (int i = width - 1; i >= left_boundary; --i)  // 查找图像的右边界
        if ((vdir_prefix_sum[i][height] - vdir_prefix_sum[i][0]) / 255 >= min_v_proj_value) {
            right_boundary = i;
            break;
        }
 
    for (int i = 0; i < height; ++i)  // 查找图像的上边界
        if ((hdir_prefix_sum[i][width] - hdir_prefix_sum[i][0]) / 255 >= min_h_proj_value) {
            upper_boundary = i;
            break;
        }
 
    for (int i = height - 1; i >= upper_boundary; --i)  // 查找图像的下边界
        if ((hdir_prefix_sum[i][width] - hdir_prefix_sum[i][0]) / 255 >= min_h_proj_value) {
            lower_boundary = i;
            break;
        }
 
    upper_boundary = std::max(0, upper_boundary - margin);                // 根据 margin 向上扩充像素
    lower_boundary = std::min(int(height) - 1, lower_boundary + margin);  // 根据 margin 向下扩充像素
    left_boundary = std::max(0, left_boundary - margin);                  // 根据 margin 向左扩充像素
    right_boundary = std::min(int(width) - 1, right_boundary + margin);   // 根据 margin 向右扩充像素
 
    return {left_boundary, upper_boundary, right_boundary - left_boundary + 1, lower_boundary - upper_boundary + 1};
}
 
inline Intervals Projection::ExtractPeak(Direction direction, size_t min_proj_value, size_t min_peak_span, Interval row_range, Interval col_range, bool is_absolute_coord) const {
    row_range = std::move(row_range.Intersect({0, int(height)}));  // 保证行区间在图像的高度范围内
    col_range = std::move(col_range.Intersect({0, int(width)}));   // 保证列区间在图像的宽度范围内
 
    List<size_t> projection = std::move(this->Value(direction, row_range, col_range));  // 通过函数获取指定区域的投影值
 
    // 拿到投影值的原始数据（加快索引速度）
    const size_t* proj_value_ptr = projection.data();
 
    // 投影区间
    auto& proj_range = direction == HDIR ? row_range : col_range;
 
    // 抽取波峰
    Intervals intervals = std::move(Projection::ExtractPeak(proj_value_ptr, {0, proj_range.Length()}, min_proj_value, min_peak_span));
 
    // 是否转换绝对坐标
    if (is_absolute_coord)
        for (auto& interval : intervals)
            interval.Translate(proj_range.start);  // 区间转换绝对坐标
 
    return std::move(intervals);
}
 
inline Intervals Projection::ExtractPeak(Direction direction, size_t min_proj_value, size_t min_peak_span, const Rect& rect, bool is_absolute_coord) const {
    // 默认调用根据指定的区域投影抽取波峰函数（将矩形区域拆解成行和列区间）
    return this->ExtractPeak(direction, min_proj_value, min_peak_span, {rect.y, rect.y + rect.height + 1}, {rect.x, rect.x + rect.width + 1}, is_absolute_coord);
}
 
inline Intervals Projection::ExtractTrough(Direction direction, size_t max_proj_value, size_t min_trough_span, Interval row_range, Interval col_range, bool is_absolute_coord) const {
    row_range = std::move(row_range.Intersect({0, int(height)}));  // 保证行区间在图像的高度范围内
    col_range = std::move(col_range.Intersect({0, int(width)}));   // 保证列区间在图像的宽度范围内
 
    List<size_t> projection = std::move(this->Value(direction, row_range, col_range));  // 通过函数获取指定区域的投影值
 
    // 拿到投影值的原始数据（加快索引速度）
    const size_t* proj_value_ptr = projection.data();
 
    // 投影区间
    auto& proj_range = direction == HDIR ? row_range : col_range;
 
    // 抽取波谷
    Intervals intervals = std::move(Projection::ExtractTrough(proj_value_ptr, {0, proj_range.Length()}, max_proj_value, min_trough_span));
 
    // 是否转换绝对坐标
    if (is_absolute_coord)
        for (auto& interval : intervals)
            interval.Translate(proj_range.start);  // 区间转换绝对坐标
 
    return std::move(intervals);
}
 
inline Intervals Projection::ExtractTrough(Direction direction, size_t max_proj_value, size_t min_trough_span, const Rect& rect, bool is_absolute_coord) const {
    // 默认调用根据指定的区域投影抽取波谷函数（将矩形区域拆解成行和列区间）
    return this->ExtractTrough(direction, max_proj_value, min_trough_span, {rect.y, rect.y + rect.height + 1}, {rect.x, rect.x + rect.width + 1}, is_absolute_coord);
}
 
template <typename INDEXED>
inline Intervals Projection::ExtractPeak(INDEXED& projection, const Interval& interval, size_t min_proj_value, size_t min_peak_span) {
    Intervals peak_intervals;  // 波峰区间列表
 
    int peak_span = 0;  // 波峰跨度
 
    // 遍历给定区间内所有投影值
    for (int i = interval.start; i < interval.end; ++i) {
        if (projection[i] >= min_proj_value)                    // 如果满足波峰条件
            ++peak_span;                                        // 波峰跨度加1
        else {                                                  // 如果不满足波峰条件
            if (peak_span >= min_peak_span)                     // 检测波峰跨度是否满足条件
                peak_intervals.emplace_back(i - peak_span, i);  // 满足则增加波峰区间
            peak_span = 0;                                      // 波峰跨度重置为0
        }
    }
    if (peak_span >= min_peak_span)                                           // 检测最后一个波峰区间跨度是否满足条件
        peak_intervals.emplace_back(interval.end - peak_span, interval.end);  // 满足则增加波峰区间
 
    return std::move(peak_intervals);
}
 
template <typename INDEXED>
inline Intervals Projection::ExtractTrough(INDEXED& projection, const Interval& interval, size_t max_proj_value, size_t min_trough_span) {
    Intervals trough_intervals;  // 波谷区间列表
 
    int trough_span = 0;  // 波谷跨度
 
    // 遍历给定区间内所有投影值
    for (int i = interval.start; i < interval.end; ++i) {
        if (projection[i] <= max_proj_value)                        // 如果满足波谷条件
            ++trough_span;                                          // 波谷跨度加1
        else {                                                      // 如果不满足波谷条件
            if (trough_span >= min_trough_span)                     // 检测波谷跨度是否满足条件
                trough_intervals.emplace_back(i - trough_span, i);  // 满足则增加波谷区间
            trough_span = 0;                                        // 波谷跨度重置为0
        }
    }
    if (trough_span >= min_trough_span)                                           // 检测最后一个波谷区间跨度是否满足条件
        trough_intervals.emplace_back(interval.end - trough_span, interval.end);  // 满足则增加波谷区间
 
    return std::move(trough_intervals);  // 返回波谷区间列表
}
 
}  // namespace cm
 
#endif