line.hpp

浏览该文件的文档.

/*
 * @Description: 线类 头文件及其实现
 * @Version:
 * @Autor: dreamy-xay
 * @Date: 2023-12-01 15:02:12
 * @LastEditors: dreamy-xay
 * @LastEditTime: 2024-05-20
 */
 
#ifndef COMMON_LINE_HPP
#define COMMON_LINE_HPP
 
#include <iostream>
#include <opencv2/core.hpp>
 
#include "common/base/interval.hpp"
#include "common/base/point.hpp"
#include "common/enum.h"
#include "common/macro.h"
#include "common/type.h"
 
namespace cm {
 
class Line {
   public:
    struct GEEquation {
        double a;
        double b;
        double c;
 
        GEEquation() = default;
        GEEquation(double a, double b, double c) : a(a), b(b), c(c) {}
        GEEquation(const GEEquation& ge) = default;
 
        double GetX(double y) const;
        double GetY(double x) const;
    };
 
    struct SIEquation {
        double slope;
        double intercept;
        LineType line_type;
 
        SIEquation() = default;
        SIEquation(double slope, double intercept, LineType line_type) : slope(slope), intercept(intercept), line_type((line_type != HLINE && line_type != VLINE) ? (throw Exception("The \"line type\" only supports \"cm::HLINE\" or \"cm::VLINE\" types!")) : line_type) {}
        SIEquation(const SIEquation& ge) = default;
 
        double GetX(double y) const;
        double GetY(double x) const;
    };
 
    struct Hash {
        size_t operator()(const Line& line) const;
    };
 
    struct CompareByLength {
       private:
        bool is_rough;
 
       public:
        explicit CompareByLength(bool is_rough = false);
        bool operator()(const Line& line1, const Line& line2) const;
    };
 
    struct CompareByCoordinate {
       private:
        int min_distance;
        bool (*compare)(const Line&, const Line&, const int&);
 
       public:
        explicit CompareByCoordinate(LineType type, int min_distance = 10, bool use_pt1 = true);
        bool operator()(const Line& line1, const Line& line2) const;
    };
 
    Point2i pt1;
    Point2i pt2;
 
    Line();
    Line(int pt1_x, int pt1_y, int pt2_x, int pt2_y);
    Line(const std::initializer_list<int>& initial_list);
    Line(const Point2i& pt1, const Point2i& pt2);
    Line(const cv::Vec4i& line);
    Line(const std::vector<int>& list);
    Line(const Line& line);
    ~Line();
 
    operator cv::Vec4i() const;
    operator std::vector<int>() const;
 
    friend bool operator==(const Line& line1, const Line& line2);
    friend bool operator!=(const Line& line1, const Line& line2);
    friend std::ostream& operator<<(std::ostream& out, const Line& line);
 
    int& operator[](size_t index);
    const int& operator[](size_t index) const;
 
    LineType Type() const;
    double Length(bool is_rough = false) const;
    GEEquation GECoefficients() const;
    SIEquation SICoefficients() const;
 
    template <typename T>
    double DistanceTo(const Point<T>& pt) const;
    double DistanceTo(const Line& line, LineDistanceType type) const;
    Line& Translate(int dx, int dy);
    Line& Scale(double factor, bool round = true);
    template <typename T>
    Line& Rotate(double angle, const Point<T>& center = {0, 0});
    Line& TidyLine();
 
    Point2d Intersect(const Line& line) const;
    Point2d Intersect(const GEEquation& ge) const;
    Point2d Intersect(const SIEquation& si) const;
    Point2d Midpoint() const;
    double X(Statistic type) const;
    double Y(Statistic type) const;
    Line& LimitX(const Interval& interval);
    Line& LimitY(const Interval& interval);
 
    bool InInterval(const Interval& x_interval, const Interval& y_interval) const;
 
    bool IsIntersect(const Line& line, IntersectType type = INTERSECT_XY, bool is_include_boundaries = false) const;
    bool IsPoint() const;
    Line SimpleConnect(const Line& line) const;
    bool IsAligned(const Line& line, Position align_direction, int threshold = 5) const;
    bool IsNear(const Line& line, double threshold = 5.0, Statistic type = MAXIMUM) const;
};
 
inline double Line::GEEquation::GetX(double y) const {
    Cm_Assert(a != 0, "The x-coordinate of the horizontal line can be any value");
 
    return -(b * y + c) / a;
}
 
inline double Line::GEEquation::GetY(double x) const {
    Cm_Assert(b != 0, "The y-coordinate of the vertical line can be any value");
 
    return -(a * x + c) / b;
}
 
inline double Line::SIEquation::GetX(double y) const {
    switch (line_type) {
        case HLINE:  // 横线：y = kx + b
            Cm_Assert(slope != 0, "The x-coordinate of the horizontal line can be any value");
 
            return (y - intercept) / slope;
        case VLINE:  // 竖线：x = ky + b
            return slope * y + intercept;
        default:
            throw Exception("The \"line type\" only supports \"cm::HLINE\" or \"cm::VLINE\" types!");
    }
}
 
inline double Line::SIEquation::GetY(double x) const {
    switch (line_type) {
        case HLINE:  // 横线：y = kx + b
            Cm_Assert(slope != 0, "The x-coordinate of the horizontal line can be any value");
 
            return slope * x + intercept;
        case VLINE:  // 竖线：x = ky + b
            Cm_Assert(slope != 0, "The y-coordinate of the vertical line can be any value");
 
            return (x - intercept) / slope;
        default:
            throw Exception("The \"line type\" only supports \"cm::HLINE\" or \"cm::VLINE\" types!");
    }
}
 
inline size_t Line::Hash::operator()(const Line& line) const {
    return std::hash<int>()(line.pt1.x) ^ std::hash<int>()(line.pt1.y) ^ std::hash<int>()(line.pt2.x) ^ std::hash<int>()(line.pt2.y);
}
 
inline Line::CompareByLength::CompareByLength(bool is_rough) {
    this->is_rough = is_rough;
}
 
inline bool Line::CompareByLength::operator()(const Line& line1, const Line& line2) const {
    return line1.Length(is_rough) < line2.Length(is_rough);
}
 
inline Line::CompareByCoordinate::CompareByCoordinate(LineType type, int min_distance, bool use_pt1) {
    this->min_distance = min_distance;
 
    switch (type) {
        case HLINE:
            if (use_pt1)
                compare = [](const Line& line1, const Line& line2, const int& min_distance) {
                    if (std::abs((line1.pt1.y + line1.pt2.y) - (line2.pt1.y + line2.pt2.y)) / 2.0 <= min_distance)
                        return line1.pt1.x < line2.pt1.x;
                    return line1.pt1.y < line2.pt1.y;
                };
            else
                compare = [](const Line& line1, const Line& line2, const int& min_distance) {
                    if (std::abs((line1.pt1.y + line1.pt2.y) - (line2.pt1.y + line2.pt2.y)) / 2.0 <= min_distance)
                        return line1.pt2.x < line2.pt2.x;
                    return line1.pt2.y < line2.pt2.y;
                };
            break;
        case VLINE:
            if (use_pt1)
                compare = [](const Line& line1, const Line& line2, const int& min_distance) {
                    if (std::abs((line1.pt1.x + line1.pt2.x) - (line2.pt1.x + line2.pt2.x)) / 2.0 <= min_distance)
                        return line1.pt1.y < line2.pt1.y;
                    return line1.pt1.x < line2.pt1.x;
                };
            else
                compare = [](const Line& line1, const Line& line2, const int& min_distance) {
                    if (std::abs((line1.pt1.x + line1.pt2.x) - (line2.pt1.x + line2.pt2.x)) / 2.0 <= min_distance)
                        return line1.pt2.y < line2.pt2.y;
                    return line1.pt2.x < line2.pt2.x;
                };
            break;
        default:
            throw Exception("The \"line type\" only supports \"cm::HLINE\" or \"cm::VLINE\" types!");
    }
}
 
inline bool Line::CompareByCoordinate::operator()(const Line& line1, const Line& line2) const {
    return compare(line1, line2, min_distance);
}
 
inline Line::Line() : pt1{}, pt2{} {}
 
inline Line::Line(int pt1_x, int pt1_y, int pt2_x, int pt2_y) : pt1(pt1_x, pt1_y), pt2(pt2_x, pt2_y) {
    this->TidyLine();  // 整理线中第一和第二个点的坐标
}
 
inline Line::Line(const std::initializer_list<int>& initial_list) {
    auto iter = initial_list.begin();
 
    pt1.x = *(iter++);
    pt1.y = *(iter++);
    pt2.x = *(iter++);
    pt2.y = *(iter++);
 
    this->TidyLine();  // 整理线中第一和第二个点的坐标
}
 
inline Line::Line(const Point2i& pt1, const Point2i& pt2) : pt1(pt1), pt2(pt2) {
    this->TidyLine();  // 整理线中第一和第二个点的坐标
}
 
inline Line::Line(const cv::Vec4i& line) : pt1(line[0], line[1]), pt2(line[2], line[3]) {
    this->TidyLine();  // 整理线中第一和第二个点的坐标
}
 
inline Line::Line(const std::vector<int>& list) {
    Cm_Assert(list.size() == 4, "list size must be 4!!!");
 
    pt1.x = list[0];
    pt1.y = list[1];
    pt2.x = list[2];
    pt2.y = list[3];
 
    this->TidyLine();  // 整理线中第一和第二个点的坐标
}
 
inline Line::Line(const Line& line) : pt1(line.pt1), pt2(line.pt2) {
    this->TidyLine();  // 整理线中第一和第二个点的坐标
}
 
inline Line::~Line() {}
 
inline Line::operator cv::Vec4i() const {
    return {pt1.x, pt1.y, pt2.x, pt2.y};
}
 
inline Line::operator std::vector<int>() const {
    return {pt1.x, pt1.y, pt2.x, pt2.y};
}
 
inline bool operator==(const Line& line1, const Line& line2) {
    return line1.pt1 == line2.pt1 && line1.pt2 == line2.pt2;
}
 
inline bool operator!=(const Line& line1, const Line& line2) {
    return line1.pt1 != line2.pt1 || line1.pt2 != line2.pt2;
}
 
inline std::ostream& operator<<(std::ostream& out, const Line& line) {
    out << "{ pt1: { x: " << line.pt1.x << ", y: " << line.pt1.y << " }, pt2: { x: " << line.pt2.x << ", y: " << line.pt2.y << " } }";
 
    return out;
}
 
inline int& Line::operator[](size_t index) {
    Cm_Assert(index < 4, "index must be less than 4!");
 
    switch (index) {
        case 0:
            return pt1.x;
        case 1:
            return pt1.y;
        case 2:
            return pt2.x;
        case 3:
            return pt2.y;
        default:
            throw Exception("Index must be less than 4!");
    }
}
 
inline const int& Line::operator[](size_t index) const {
    Cm_Assert(index < 4, "index must be less than 4!");
 
    switch (index) {
        case 0:
            return pt1.x;
        case 1:
            return pt1.y;
        case 2:
            return pt2.x;
        case 3:
            return pt2.y;
        default:
            throw Exception("Index must be less than 4!");
    }
}
 
inline LineType Line::Type() const {
    // 如果两点x坐标大于y坐标，则判定为横线，否则为竖线
    if (std::abs(pt1.x - pt2.x) > std::abs(pt1.y - pt2.y))
        return HLINE;
    else
        return VLINE;
}
 
inline double Line::Length(bool is_rough) const {
    if (is_rough)  // 线的粗糙长度
        return std::max(std::abs(pt2.x - pt1.x), std::abs(pt2.y - pt1.y));
    else  // 线的精准长度，算两点距离
        return pt1.DistanceTo(pt2);
}
 
inline Line::GEEquation Line::GECoefficients() const {
    Cm_Assert(!this->IsPoint(), "the coordinates of the two points of the line segment are not the same!");
 
    /*
    point1: ax1 + by1 + c = 0   @1
    point2: ax2 + by2 + c = 0   @2
    其中 a b c 是线方程的系数，@1表示公式1，@2表示公式2
 
    @1 - @2 => a(x1 - x2) + b(y1 - y2) = 0 => a / b = (y2 - y1) / (x1 - x2)
 
    则有如下公式
    a = y2 - y1
    b = x1 - x2
    c = x2y1 - x1y2
     */
 
    return {static_cast<double>(pt2.y - pt1.y), static_cast<double>(pt1.x - pt2.x), pt2.Cross(pt1)};
}
 
inline Line::SIEquation Line::SICoefficients() const {
    Cm_Assert(!this->IsPoint(), "the coordinates of the two points of the line segment are not the same!");
 
    if (this->Type() == HLINE) {  // 横线
        // （斜截式：y = kx + b => k = (y2 - y1) / (x2 - x1) => b = y1 - kx1）
        double slope = static_cast<double>(pt2.y - pt1.y) / (pt2.x - pt1.x);
 
        return {slope, pt1.y - slope * pt1.x, HLINE};
    } else {  // 竖线
        // （斜截式：x = ky + b => k = (x2 - x1) / (y2 - y1) => b = x1 - ky1）
        double slope = static_cast<double>(pt2.x - pt1.x) / (pt2.y - pt1.y);
 
        return {slope, pt1.x - slope * pt1.y, VLINE};
    }
}
 
template <typename T>
inline double Line::DistanceTo(const Point<T>& pt) const {
    /*
    对于线的一般方程，有系数a，b，c
 
    distance = |ax + by + c| / sqrt(a^2 + b^2)
 
    其中 x1 y1 x2 y2 是线的两点坐标，x y 是需要计算的点的坐标
     */
 
    auto ge = std::move(this->GECoefficients());  // 获取横线一般方程的系数
 
    return std::abs(ge.a * pt.x + ge.b * pt.y + ge.c) / std::sqrt(ge.a * ge.a + ge.b * ge.b);
}
 
inline double Line::DistanceTo(const Line& line, LineDistanceType type) const {
    switch (type) {
        case LDIS_HORIZONTAL:  // 两竖线之间的水平距离
            return std::abs((pt1.x + pt2.x) - (line.pt1.x + line.pt2.x)) / 2.0;
        case LDIS_VERTICAL:  // 两横线之间的垂直距离
            return std::abs((pt1.y + pt2.y) - (line.pt1.y + line.pt2.y)) / 2.0;
        case LDIS_HLINE_H:  // 横线与横线之间的水平距离（注：要求已经 TidyLine 了）
            return std::max(pt1.x, line.pt1.x) - std::min(pt2.x, line.pt2.x);
        case LDIS_VLINE_V:  // 竖线与竖线之间的垂直距离（注：要求已经 TidyLine 了）
            return std::max(pt1.y, line.pt1.y) - std::min(pt2.y, line.pt2.y);
        case LDIS_MAX_X:  // 两线之间的最大x坐标距离
            return std::max(std::max(pt1.x, pt2.x) - std::min(line.pt1.x, line.pt2.x), std::max(line.pt1.x, line.pt2.x) - std::min(pt1.x, pt2.x));
        case LDIS_MAX_Y:  // 两线之间的最大y坐标距离
            return std::max(std::max(pt1.y, pt2.y) - std::min(line.pt1.y, line.pt2.y), std::max(line.pt1.y, line.pt2.y) - std::min(pt1.y, pt2.y));
        case LDIS_MIN_X:  // 两线之间的最小x坐标距离
            return std::min(std::abs(std::min(pt1.x, pt2.x) - std::max(line.pt1.x, line.pt2.x)), std::abs(std::min(line.pt1.x, line.pt2.x) - std::max(pt1.x, pt2.x)));
        case LDIS_MIN_Y:  // 两线之间的最小y坐标距离
            return std::min(std::abs(std::min(pt1.y, pt2.y) - std::max(line.pt1.y, line.pt2.y)), std::abs(std::min(line.pt1.y, line.pt2.y) - std::max(pt1.y, pt2.y)));
        default:
            throw Exception("The type(LineDistanceType) of param \"type\" is incorrect!");
    }
}
 
inline Line& Line::Translate(int dx, int dy) {
    pt1.Translate(dx, dy);  // 线的平移本质上是两个点的平移
    pt2.Translate(dx, dy);
 
    return *this;
}
 
inline Line& Line::Scale(double factor, bool round) {
    pt1.Scale(factor, round);  // 线的缩放本质上是两个点的缩放
    pt2.Scale(factor, round);
 
    return *this;
}
 
template <typename T>
inline Line& Line::Rotate(double angle, const Point<T>& center) {
    pt1.Rotate(angle, center);  // 线的旋转本质上是两个点的旋转
    pt2.Rotate(angle, center);
 
    return *this;
}
 
inline Line& Line::TidyLine() {
    if (this->Type() == HLINE) {
        if (pt1.x > pt2.x)
            std::swap(pt1, pt2);  // 横线：pt1 在 pt2 的左侧
    } else {
        if (pt1.y > pt2.y)
            std::swap(pt1, pt2);  // 竖线：pt1 在 pt2 的上侧
    }
 
    return *this;
}
 
inline Point2d Line::Intersect(const Line& line) const {
    auto ge = std::move(line.GECoefficients());  // 获取当前线一般方程的系数
 
    return std::move(this->Intersect(ge));  // 使用一般方程求交点
}
 
inline Point2d Line::Intersect(const Line::GEEquation& ge) const {
    /*
    对于线的一般方程，有系数a，b，c
 
    line1: a1x + b1y + c1 = 0     @1
    line2: a2x + b2y + c2 = 0     @2
    其中 a1 a2 b1 b2 c1 c2 是两条线方程的系数，@1表示公式1，@2表示公式2
 
    @1 * b2 - @2 * b1 => (a1b2x + b1b2y + b2c1) - (a2b1x + b1b2y + b1c2) = 0 => (a1b2 - a2b1)x + (b2c1 - b1c2) = 0
 
    则有如下公式
    x = (b1c2 - b2c1) / (a1b2 - a2b1)
    y = (a2c1 - a1c2) / (a1b2 - a2b1)
 
    该方程，只要两条线不平行即有解，即 a1b2 - a2b1 不为 0
     */
 
    auto this_ge = std::move(this->GECoefficients());  // 获取当前横线一般方程的系数，当前横线作为线1
 
    double divisor = this_ge.a * ge.b - ge.a * this_ge.b;  // 公式中的被除数
 
    Cm_Assert(divisor != 0, "two parallel lines do not intersect!");  // 两线平行触发断言
 
    return {(this_ge.b * ge.c - ge.b * this_ge.c) / divisor, (ge.a * this_ge.c - this_ge.a * ge.c) / divisor};
}
 
inline Point2d Line::Intersect(const Line::SIEquation& si) const {
    Cm_Assert(si.line_type != this->Type(), "only different types of lines can calculate intersections");  // 类型相同触发断言
 
    auto this_si = this->SICoefficients();  // 获取当前横线斜截式的系数，当前横线作为线1
    if (this_si.line_type == VLINE) {
        /*
        两个直线方程求交点 (k1=this_si.slope, b1=this_si.intercept, k2=si.slope, b2=si.intercept)
        x = k1y + b1
        y = k2x + b2
 
        将 y 代入 => x = k1(k2x + b2) + b1 => x = k1k2x + k1b2 + b1 => (1 - k1k2)x = k1b2 + b1
 
        则有如下公式
        x = (k1b2 + b1) / (1 - k1k2)
        y = k2 * x + b2
         */
 
        double x = (this_si.slope * si.intercept + this_si.intercept) / (1.0 - this_si.slope * si.slope);  // x
        double y = si.slope * x + si.intercept;                                                            // y
 
        return {x, y};
    } else {
        /*
        两个直线方程求交点 (k1=this_si.slope, b1=this_si.intercept, k2=si.slope, b2=si.intercept)
        y = k1x + b1
        x = k2y + b2
 
        将 y 代入 => x = k2(k1x + b1) + b2 => x = k2k1x + k2b1 + b2 => (1 - k2k1)x = k2b1 + b2
 
        则有如下公式
        x = (k2b1 + b2) / (1 - k2k1)
        y = k1x + b1
         */
 
        double x = (si.slope * this_si.intercept + si.intercept) / (1.0 - si.slope * this_si.slope);  // x
        double y = this_si.slope * x + this_si.intercept;                                             // y
 
        return {x, y};
    }
}
 
inline Point2d Line::Midpoint() const {
    return {(pt1.x + pt2.x) / 2.0, (pt1.y + pt2.y) / 2.0};
}
 
inline double Line::X(Statistic type) const {
    switch (type) {
        case AVERAGE:
            return (pt1.x + pt2.x) / 2.0;  // 线的平均x坐标
        case MAXIMUM:
            return std::max(pt1.x, pt2.x);  // 线的最大x坐标
        case MINIMUM:
            return std::min(pt1.x, pt2.x);  // 线的最小x坐标
        default:
            throw Exception("The type(Statistic) of param \"type\" is incorrect!");
    }
}
 
inline double Line::Y(Statistic type) const {
    switch (type) {
        case AVERAGE:
            return (pt1.y + pt2.y) / 2.0;  // 线的平均y坐标
        case MAXIMUM:
            return std::max(pt1.y, pt2.y);  // 线的最大y坐标
        case MINIMUM:
            return std::min(pt1.y, pt2.y);  // 线的最小y坐标
        default:
            throw Exception("The type(Statistic) of param \"type\" is incorrect!");
    }
}
 
inline Line& Line::LimitX(const Interval& interval) {
    pt1.LimitX(interval.start, interval.end - 1);
    pt2.LimitX(interval.start, interval.end - 1);
 
    return *this;
}
 
inline Line& Line::LimitY(const Interval& interval) {
    pt1.LimitY(interval.start, interval.end - 1);
    pt2.LimitY(interval.start, interval.end - 1);
 
    return *this;
}
 
inline bool Line::InInterval(const Interval& x_interval, const Interval& y_interval) const {
    return (pt1.x >= x_interval.start && pt1.x < x_interval.end) &&
           (pt2.x >= x_interval.start && pt2.x < x_interval.end) &&
           (pt1.y >= y_interval.start && pt1.y < y_interval.end) &&
           (pt2.y >= y_interval.start && pt2.y < y_interval.end);
}
 
inline bool Line::IsIntersect(const Line& line, IntersectType type, bool is_include_boundaries) const {
    if (is_include_boundaries)
        switch (type) {
            case INTERSECT_X:  // 水平方向上相交
                return std::max(pt1.x, pt2.x) >= std::min(line.pt1.x, line.pt2.x) && std::max(line.pt1.x, line.pt2.x) >= std::min(pt1.x, pt2.x);
            case INTERSECT_Y:  // 垂直方向上相交
                return std::max(pt1.y, pt2.y) >= std::min(line.pt1.y, line.pt2.y) && std::max(line.pt1.y, line.pt2.y) >= std::min(pt1.y, pt2.y);
            case INTERSECT_XY: {  // 两个方向上都相交
                /*
                    线段1：点a和点b构成
                    线段2：点c和点d构成
 
                    a         d
                    \       /
                     \    /
                      \ /
                      /\
                    /   \
                  /      \
                 c        b
 
                    跨立实验：(ad x cd) * (bd x cd) <= 0
                    其中 x 表示叉乘，* 表示两数字乘积，ad表示ad向量（d - a），cd同理
                    < 0 表示两线段相交（不含端点）
                    = 0 表示两线段相交（仅端点相交）
 
                 */
                auto& a = pt1;
                auto& b = pt2;
                auto& c = line.pt1;
                auto& d = line.pt2;
 
                // 执行快速排斥实验（即在x和y坐标方向上都不相交，即对 INTERSECT_X 和 INTERSECT_Y 情况取非）
                if (std::max(a.x, b.x) < std::min(c.x, d.x) || std::max(c.x, d.x) < std::min(a.x, b.x) || std::max(a.y, b.y) < std::min(c.y, d.y) || std::max(c.y, d.y) < std::min(a.y, b.y))
                    return false;
 
                auto cd_vec = d - c;
 
                // 执行跨立实验
                return (d - a).Cross(cd_vec) * (d - b).Cross(cd_vec) <= 0;
            }
            default:
                throw Exception("The type(IntersectType) of param \"type\" is incorrect!");
        }
    else
        switch (type) {
            case INTERSECT_X:  // 水平方向上相交
                return std::max(pt1.x, pt2.x) > std::min(line.pt1.x, line.pt2.x) && std::max(line.pt1.x, line.pt2.x) > std::min(pt1.x, pt2.x);
            case INTERSECT_Y:  // 垂直方向上相交
                return std::max(pt1.y, pt2.y) > std::min(line.pt1.y, line.pt2.y) && std::max(line.pt1.y, line.pt2.y) > std::min(pt1.y, pt2.y);
            case INTERSECT_XY: {  // 两个方向上都相交
                /*
                    线段1：点a和点b构成
                    线段2：点c和点d构成
 
                    a         d
                    \       /
                     \    /
                      \ /
                      /\
                    /   \
                  /      \
                 c        b
 
                    跨立实验：(ad x cd) * (bd x cd) <= 0
                    其中 x 表示叉乘，* 表示两数字乘积，ad表示ad向量（d - a），cd同理
                    < 0 表示两线段相交（不含端点）
                    = 0 表示两线段相交（仅端点相交）
 
                 */
                auto& a = pt1;
                auto& b = pt2;
                auto& c = line.pt1;
                auto& d = line.pt2;
 
                // 执行快速排斥实验（即在x和y坐标方向上都不相交，即对 INTERSECT_X 和 INTERSECT_Y 情况取非）
                if (std::max(a.x, b.x) < std::min(c.x, d.x) || std::max(c.x, d.x) < std::min(a.x, b.x) || std::max(a.y, b.y) < std::min(c.y, d.y) || std::max(c.y, d.y) < std::min(a.y, b.y))
                    return false;
 
                auto cd_vec = d - c;
 
                // 执行跨立实验
                return (d - a).Cross(cd_vec) * (d - b).Cross(cd_vec) < 0;
            }
            default:
                throw Exception("The type(IntersectType) of param \"type\" is incorrect!");
        }
}
 
inline bool Line::IsPoint() const {
    return pt1.x == pt2.x && pt1.y == pt2.y;  // 两点坐标相等即为点
}
 
inline Line Line::SimpleConnect(const Line& line) const {
    Cm_Assert(this->Type() == line.Type(), "this function requires line type is same!");
 
    Line new_line;
 
    if (this->Type() == VLINE) {
        // 竖线
        // 设置新线的上端点（y坐标小的即为上端点）
        if (pt1.y < line.pt1.y) {
            new_line.pt1.x = pt1.x;
            new_line.pt1.y = pt1.y;
        } else {
            new_line.pt1.x = line.pt1.x;
            new_line.pt1.y = line.pt1.y;
        }
 
        // 设置新线的下端点（y坐标大的即为下端点）
        if (pt2.y > line.pt2.y) {
            new_line.pt2.x = pt2.x;
            new_line.pt2.y = pt2.y;
        } else {
            new_line.pt2.x = line.pt2.x;
            new_line.pt2.y = line.pt2.y;
        }
    } else {
        // 横线
        // 设置新线的左端点（x坐标小的即为左端点）
        if (pt1.x < line.pt1.x) {
            new_line.pt1.x = pt1.x;
            new_line.pt1.y = pt1.y;
        } else {
            new_line.pt1.x = line.pt1.x;
            new_line.pt1.y = line.pt1.y;
        }
 
        // 设置新线的右端点（x坐标大的即为右端点）
        if (pt2.x > line.pt2.x) {
            new_line.pt2.x = pt2.x;
            new_line.pt2.y = pt2.y;
        } else {
            new_line.pt2.x = line.pt2.x;
            new_line.pt2.y = line.pt2.y;
        }
    }
    return new_line;
}
 
inline bool Line::IsAligned(const Line& line, Position align_direction, int threshold) const {
    Cm_Assert(this->Type() != line.Type(), "this function requires line type is different!");
 
    Point2d pt = this->Intersect(line);
 
    if (this->Type() == HLINE) {
        switch (align_direction) {
            case LEFT:
                //  ╟
                return std::abs(pt.x - pt1.x) <= threshold;
            case RIGHT:
                //  ╢
                return std::abs(pt.x - pt2.x) <= threshold;
            default:
                throw Exception("The horizontal line \"align direction\" only supports \"cm::LEFT\" or \"cm::RIGHT\" types!");
        }
    } else {
        switch (align_direction) {
            case TOP:
                //  ╤
                return std::abs(pt.y - pt1.y) <= threshold;
            case BOTTOM:
                //  ╧
                return std::abs(pt.y - pt2.y) <= threshold;
            default:
                throw Exception("The vertical line \"align direction\" only supports \"cm::TOP\" or \"cm::BOTTOM\" types!");
        }
    }
}
 
inline bool Line::IsNear(const Line& line, double threshold, Statistic type) const {
    // 计算点到直线距离，如果统计（最大，最小，平均）距离都小于阈值，那么判断它们离得很近
    double dst1 = this->DistanceTo(line.pt1);
    double dst2 = this->DistanceTo(line.pt2);
    double dst3 = line.DistanceTo(pt1);
    double dst4 = line.DistanceTo(pt2);
 
    switch (type) {
        case MAXIMUM:
            return std::max(dst1, std::max(dst2, std::max(dst3, dst4))) <= threshold;
        case MINIMUM:
            return std::min(dst1, std::min(dst2, std::min(dst3, dst4))) <= threshold;
        case AVERAGE:
            return (dst1 + dst2 + dst3 + dst4) <= threshold * 4;
        default:
            throw Exception("The type(Statistic) of param \"type\" is incorrect!");
    }
}
 
}  // namespace cm
 
#endif