rect.hpp

浏览该文件的文档.

/*
 * @Descrirection: 矩形类 头文件及其实现
 * @Version:
 * @Autor: dreamy-xay
 * @Date: 2023-12-01 15:02:12
 * @LastEditors: LL
 * @LastEditTime: 2024-05-20
 */
 
#ifndef COMMON_RECT_HPP
#define COMMON_RECT_HPP
 
#include <iostream>
#include <opencv2/core.hpp>
#include <vector>
 
#include "common/base/line.hpp"
#include "common/base/point.hpp"
#include "common/enum.h"
#include "common/macro.h"
#include "common/type.h"
 
namespace cm {
 
class Rect {
   public:
    int x;
    int y;
    int width;
    int height;
 
    struct Hash {
        size_t operator()(const Rect& rect) const;
    };
 
    struct Margin {
        int top;
        int right;
        int bottom;
        int left;
 
        explicit Margin(int top, int right, int bottom, int left);
        explicit Margin(int top, int left_and_right, int bottom);
        explicit Margin(int top_and_bottom, int left_and_right);
        Margin(int margin);
    };
 
    Rect();
    Rect(int x, int y, int width, int height);
    Rect(Point2i pt1, Point2i pt2);
    Rect(const Rect& rect);
    Rect(const cv::Vec4i& rect);
    Rect(const cv::Rect& rect);
    Rect(const std::vector<int>& list);
    ~Rect();
    operator cv::Rect() const;
    operator cv::Vec4i() const;
    operator std::vector<int>() const;
 
    friend bool operator==(const Rect& rect1, const Rect& rect2);
    friend bool operator!=(const Rect& rect1, const Rect& rect2);
    friend bool operator<(const Rect& rect1, const Rect& rect2);
    friend bool operator>(const Rect& rect1, const Rect& rect2);
    friend bool operator<=(const Rect& rect1, const Rect& rect2);
    friend bool operator>=(const Rect& rect1, const Rect& rect2);
 
    friend std::ostream& operator<<(std::ostream& out, const Rect& rect);
 
    bool IsPoint() const;
 
    template <typename U>
    bool Include(const Point<U>& pt, const Margin& margin = 0, bool is_include_boundaries = true) const;
 
    bool Include(const Line& line, const Margin& margin = 0, bool is_include_boundaries = true) const;
    bool Include(const Rect& rect, const Margin& margin = 0, bool is_include_boundaries = true) const;
    bool IsIntersect(const Rect& rect, IntersectType type = INTERSECT_XY, const Margin& margin = 0, bool is_include_boundaries = false) const;
    bool IsIntersect(const Line& line, IntersectType type = INTERSECT_XY, const Margin& margin = 0, bool is_include_boundaries = true) const;
 
    Rect Intersect(const Rect& rect) const;
    Line Intersect(const Line& line) const;
    Rect Union(const Rect& rect) const;
    Point2i DiagonalPoint(bool is_left_top = false) const;
    Point2d CenterPoint() const;
    Rect& Translate(int dx, int dy);
    Rect& Scale(double factor);
    Rect& Scale(const Margin& margin);
    Rect& TidyRect();
};
 
inline size_t Rect::Hash::operator()(const Rect& rect) const {
    return std::hash<int>()(rect.x) ^ std::hash<int>()(rect.y) ^ std::hash<int>()(rect.width) ^ std::hash<int>()(rect.height);
}
 
inline Rect::Margin::Margin(int top, int right, int bottom, int left) : top(top), right(right), bottom(bottom), left(left) {}
 
inline Rect::Margin::Margin(int top, int left_and_right, int bottom) : top(top), right(left_and_right), bottom(bottom), left(left_and_right) {}
 
inline Rect::Margin::Margin(int top_and_bottom, int left_and_right) : top(top_and_bottom), right(left_and_right), bottom(top_and_bottom), left(left_and_right) {}
 
inline Rect::Margin::Margin(int margin) : top(margin), right(margin), bottom(margin), left(margin) {}
 
inline Rect::Rect() : x{}, y{}, width{}, height{} {}
 
inline Rect::Rect(int x, int y, int width, int height) : x(x), y(y), width(width), height(height) {
    this->TidyRect();
}
 
inline Rect::Rect(Point2i pt1, Point2i pt2) : x(pt1.x), y(pt1.y), width(pt2.x - pt1.x), height(pt2.y - pt1.y) {
    this->TidyRect();
}
 
inline Rect::Rect(const Rect& rect) : x(rect.x), y(rect.y), width(rect.width), height(rect.height) {}
 
inline Rect::Rect(const cv::Rect& rect) : x(rect.x), y(rect.y), width(rect.width), height(rect.height) {
    this->TidyRect();
}
 
inline Rect::Rect(const cv::Vec4i& rect) : x(rect[0]), y(rect[1]), width(rect[2]), height(rect[3]) {
    this->TidyRect();
}
 
inline Rect::Rect(const std::vector<int>& list) {
    Cm_Assert(list.size() == 4, "list size must be 4!!!");
 
    x = list[0];
    y = list[1];
    width = list[2];
    height = list[3];
 
    this->TidyRect();
}
 
inline Rect::~Rect() {}
 
inline Rect::operator cv::Rect() const {
    return cv::Rect(x, y, width, height);
}
 
inline Rect::operator cv::Vec4i() const {
    return {x, y, width, height};
}
 
inline Rect::operator std::vector<int>() const {
    return {x, y, width, height};
}
 
inline bool operator==(const Rect& rect1, const Rect& rect2) {
    return rect1.x == rect2.x && rect1.y == rect2.y && rect1.width == rect2.width && rect1.height == rect2.height;
}
 
inline bool operator!=(const Rect& rect1, const Rect& rect2) {
    return rect1.x != rect2.x || rect1.y != rect2.y || rect1.width != rect2.width || rect1.height != rect2.height;
}
 
inline bool operator<(const Rect& rect1, const Rect& rect2) {
    if (rect1.x == rect2.x) {                // 如果x相同，比较y
        if (rect1.y == rect2.y) {            // 如果y相同，比较宽
            if (rect1.width == rect2.width)  // 如果宽相同，比较高
                return rect1.height < rect2.height;
            return rect1.width < rect2.width;
        }
        return rect1.y < rect2.y;
    }
    return rect1.x < rect2.x;
}
 
inline bool operator>(const Rect& rect1, const Rect& rect2) {
    if (rect1.x == rect2.x) {                // 如果x相同，比较y
        if (rect1.y == rect2.y) {            // 如果y相同，比较宽
            if (rect1.width == rect2.width)  // 如果宽相同，比较高
                return rect1.height > rect2.height;
            return rect1.width > rect2.width;
        }
        return rect1.y > rect2.y;
    }
    return rect1.x > rect2.x;
}
 
inline bool operator<=(const Rect& rect1, const Rect& rect2) {
    if (rect1.x == rect2.x) {                // 如果x相同，比较y
        if (rect1.y == rect2.y) {            // 如果y相同，比较宽
            if (rect1.width == rect2.width)  // 如果宽相同，比较高
                return rect1.height <= rect2.height;
            return rect1.width <= rect2.width;
        }
        return rect1.y <= rect2.y;
    }
    return rect1.x <= rect2.x;
}
 
inline bool operator>=(const Rect& rect1, const Rect& rect2) {
    if (rect1.x == rect2.x) {                // 如果x相同，比较y
        if (rect1.y == rect2.y) {            // 如果y相同，比较宽
            if (rect1.width == rect2.width)  // 如果宽相同，比较高
                return rect1.height >= rect2.height;
            return rect1.width >= rect2.width;
        }
        return rect1.y >= rect2.y;
    }
    return rect1.x >= rect2.x;
}
 
inline std::ostream& operator<<(std::ostream& out, const Rect& rect) {
    out << "{ x: " << rect.x << ", y: " << rect.y << ", width: " << rect.width << ", height: " << rect.height << " }";
    return out;
}
 
inline bool Rect::IsPoint() const {
    return width == 0 && height == 0;
}
 
template <typename U>
inline bool Rect::Include(const Point<U>& pt, const Margin& margin, bool is_include_boundaries) const {
    if (is_include_boundaries)
        return pt.x >= (x - margin.left) && pt.x <= (x + width + margin.right) && pt.y >= (y - margin.top) && pt.y <= (y + height + margin.bottom);
    else
        return pt.x > (x - margin.left) && pt.x < (x + width + margin.right) && pt.y > (y - margin.top) && pt.y < (y + height + margin.bottom);
}
 
inline bool Rect::Include(const Line& line, const Margin& margin, bool is_include_boundaries) const {
    return this->Include(line.pt1, margin, is_include_boundaries) && this->Include(line.pt2, margin, is_include_boundaries);
}
 
inline bool Rect::Include(const Rect& rect, const Margin& margin, bool is_include_boundaries) const {
    return this->Include(Point2i(rect.x, rect.y), margin, is_include_boundaries) && this->Include(Point2i(rect.x + rect.width, rect.y), margin, is_include_boundaries) && this->Include(Point2i(rect.x, rect.y + rect.height), margin, is_include_boundaries) && this->Include(Point2i(rect.x + rect.width, rect.y + rect.height), margin, is_include_boundaries);
}
 
inline bool Rect::IsIntersect(const Rect& rect, IntersectType type, const Margin& margin, bool is_include_boundaries) const {
    switch (type) {
        case INTERSECT_X:  // 水平方向上相交
            return Line(x - margin.left, y, x + width + margin.right, y).IsIntersect(Line(rect.x, rect.y, rect.x + rect.width, rect.y), INTERSECT_X, is_include_boundaries);
        case INTERSECT_Y:  // 垂直方向上相交
            return Line(x, y - margin.top, x, y + height + margin.bottom).IsIntersect(Line(rect.x, rect.y, rect.x, rect.y + rect.height), INTERSECT_Y, is_include_boundaries);
        case INTERSECT_XY:  // 两个方向上都相交
            return Line(x - margin.left, y, x + width + margin.right, y).IsIntersect(Line(rect.x, rect.y, rect.x + rect.width, rect.y), INTERSECT_X, is_include_boundaries) && Line(x, y - margin.top, x, y + height + margin.bottom).IsIntersect(Line(rect.x, rect.y, rect.x, rect.y + rect.height), INTERSECT_Y, is_include_boundaries);
        default:
            throw Exception("The type(IntersectType) of param \"type\" is incorrect!");
    }
}
 
inline bool Rect::IsIntersect(const Line& line, IntersectType type, const Margin& margin, bool is_include_boundaries) const {
    switch (type) {
        case INTERSECT_X:  // 水平方向上相交
            return Line(x - margin.left, y, x + width + margin.right, y).IsIntersect(line, INTERSECT_X, is_include_boundaries);
        case INTERSECT_Y:  // 垂直方向上相交
            return Line(x, y - margin.top, x, y + height + margin.bottom).IsIntersect(line, INTERSECT_Y, is_include_boundaries);
        case INTERSECT_XY: {                                      // 线段至少有个点在矩形内，或者线段与矩阵四条边中一条边相交
            auto diagonal_pt = std::move(this->DiagonalPoint());  // 右下方的对角点
            return this->Include(line.pt1, margin, is_include_boundaries) ||
                   this->Include(line.pt2, margin, is_include_boundaries) ||
                   Line(x - margin.left, y - margin.top, diagonal_pt.x + margin.right, y - margin.top).IsIntersect(line, INTERSECT_XY, is_include_boundaries) ||
                   Line(x - margin.left, diagonal_pt.y + margin.bottom, diagonal_pt.x + margin.right, diagonal_pt.y + margin.bottom).IsIntersect(line, INTERSECT_XY, is_include_boundaries) ||
                   Line(x - margin.left, y - margin.top, x - margin.left, diagonal_pt.y + margin.bottom).IsIntersect(line, INTERSECT_XY, is_include_boundaries) ||
                   Line(diagonal_pt.x + margin.right, y - margin.top, diagonal_pt.x + margin.right, diagonal_pt.y + margin.bottom).IsIntersect(line, INTERSECT_XY, is_include_boundaries);
        }
        default:
            throw Exception("The type(IntersectType) of param \"type\" is incorrect!");
    }
}
 
inline Rect Rect::Intersect(const Rect& rect) const {
    int max_top_x = std::max(x, rect.x);                           // 两个矩形中上边界最大值
    int max_left_y = std::max(y, rect.y);                          // 两个矩形中左边界最大值
    int min_bottom_x = std::min(x + width, rect.x + rect.width);   // 两个矩形中下边界最小值
    int min_right_y = std::min(y + height, rect.y + rect.height);  // 两个矩形中有边界最大值
 
    return {max_top_x, max_left_y, min_bottom_x - max_top_x, min_right_y - max_left_y};
}
 
inline Line Rect::Intersect(const Line& line) const {
    Cm_Assert(this->IsIntersect(line), "the line do not intersect with rectangle!");
 
    bool is_pt1_in_rect = this->Include(line.pt1, 0, true);
    bool is_pt2_in_rect = this->Include(line.pt2, 0, true);
 
    if (is_pt1_in_rect && is_pt2_in_rect)
        return line;
    else {
        if (is_pt1_in_rect && !this->Include(line.pt1, 0, false)) {
            if (line.pt2.x == line.pt1.x)
                return {line.pt1, {line.pt2.x, line.pt2.y > y ? y + height : y}};
            else if (line.pt2.y == line.pt1.y)
                return {line.pt1, {line.pt2.x > x ? x + width : x, line.pt2.y}};
        } else if (is_pt2_in_rect && !this->Include(line.pt2, 0, false)) {
            if (line.pt1.x == line.pt2.x)
                return {line.pt2, {line.pt1.x, line.pt1.y > y ? y + height : y}};
            else if (line.pt1.y == line.pt2.y)
                return {line.pt2, {line.pt1.x > x ? x + width : x, line.pt1.y}};
        }
 
        Point2i diagonal_pt = std::move(this->DiagonalPoint());  // 右下方的对角点
 
        std::vector<Line> lines;
        lines.emplace_back(x, y, diagonal_pt.x, y);                          // 上边界线
        lines.emplace_back(x, y, x, diagonal_pt.y);                          // 左边界线
        lines.emplace_back(x, diagonal_pt.y, diagonal_pt.x, diagonal_pt.y);  // 下边界线
        lines.emplace_back(diagonal_pt.x, y, diagonal_pt.x, diagonal_pt.y);  // 右边界线
 
        auto CalcIntersection = [](const std::vector<Line>& lines, const Line& line) -> std::pair<Point2d, int> {
            int num_lines = lines.size();
            for (int i = 0; i < num_lines; ++i)
                if (line.IsIntersect(lines[i]))
                    return {line.Intersect(lines[i]), i};
            return {{0, 0}, -1};
        };
 
        if (is_pt1_in_rect || is_pt2_in_rect) {
            auto& intersection = is_pt1_in_rect ? line.pt1 : line.pt2;
            auto intersection_info = CalcIntersection(lines, line);
 
            if (intersection_info.second == -1)
                return {intersection, intersection};
 
            return {CalcIntersection(lines, line).first, intersection};
        } else {
            auto intersection1_info = CalcIntersection(lines, line);
 
            lines.erase(lines.begin() + intersection1_info.second);
 
            return {intersection1_info.first, CalcIntersection(lines, line).first};
        }
    }
}
 
inline Rect Rect::Union(const Rect& rect) const {
    Point2i pt1 = this->DiagonalPoint();
    Point2i pt2 = rect.DiagonalPoint();
    int min_top = std::min(x, rect.x);
    int min_left = std::min(y, rect.y);
    int max_bottom = std::max(pt1.x, pt2.x);
    int max_right = std::max(pt1.y, pt2.y);
    return Rect(min_top, min_left, max_bottom - min_top, max_right - min_left);
}
 
inline Point2i Rect::DiagonalPoint(bool is_left_top) const {
    if (is_left_top)
        return {x, y};
    else
        return {x + width, y + height};
}
 
inline Point2d Rect::CenterPoint() const {
    return {x + width / 2.0, y + height / 2.0};
}
 
inline Rect& Rect::Translate(int dx, int dy) {
    x += dx;  // 计算偏移之后的x
    y += dy;  // 计算偏移之后的y
    return *this;
}
 
inline Rect& Rect::Scale(double factor) {
    x *= factor;       // 计算新的x
    y *= factor;       // 计算新的y
    width *= factor;   // 计算新宽
    height *= factor;  // 计算新高
 
    return *this;
}
 
inline Rect& Rect::Scale(const Margin& margin) {
    x -= margin.left;                      // 计算新的x
    y -= margin.top;                       // 计算新的y
    width += margin.left + margin.right;   // 计算新宽
    height += margin.top + margin.bottom;  // 计算新高
 
    return *this;
}
 
inline Rect& Rect::TidyRect() {
    if (width < 0) {
        width = -width;
        x -= width;
    }
    if (height < 0) {
        height = -height;
        y -= height;
    }
    return *this;
}
 
}  // namespace cm
 
#endif