point.hpp

浏览该文件的文档.

/*
 * @Description: 点类 头文件及其实现
 * @Version:
 * @Autor: dreamy-xay
 * @Date: 2023-12-01 15:02:12
 * @LastEditors: dreamy-xay
 * @LastEditTime: 2024-03-06
 */
 
#ifndef COMMON_POINT_HPP
#define COMMON_POINT_HPP
 
#include <cmath>
#include <iostream>
#include <opencv2/core.hpp>
 
#include "common/enum.h"
#include "common/macro.h"
#include "common/type.h"
 
namespace cm {
 
template <typename T>
class Point {
   public:
    T x;
    T y;
 
    Point();
    Point(T x, T y);
    template <typename U>
    Point(const Point<U>& pt);
    template <typename U>
    Point(const cv::Point_<U>& pt);
    ~Point();
 
    template <typename U>
    operator cv::Point_<U>() const;
 
    template <typename U>
    operator Point<U>() const;
 
    template <typename U>
    friend bool operator==(const Point<U>& pt1, const Point<U>& pt2);
    template <typename U>
    friend bool operator!=(const Point<U>& pt1, const Point<U>& pt2);
    template <typename U>
    friend bool operator<(const Point<U>& pt1, const Point<U>& pt2);
    template <typename U>
    friend bool operator>(const Point<U>& pt1, const Point<U>& pt2);
    template <typename U>
    friend bool operator<=(const Point<U>& pt1, const Point<U>& pt2);
    template <typename U>
    friend bool operator>=(const Point<U>& pt1, const Point<U>& pt2);
 
    template <typename U>
    friend Point<U> operator-(const Point<U>& pt1, const Point<U>& pt2);
 
    template <typename U>
    friend std::ostream& operator<<(std::ostream& out, const Point<U>& pt);
 
    template <typename U>
    double DistanceTo(const Point<U>& pt) const;
    Point<T>& Translate(T dx, T dy);
    Point<T>& Scale(double factor, bool round = false);
    template <typename U>
    Point<T>& Rotate(double angle, const Point<U>& center = {0, 0});
 
    template <typename U>
    double Dot(const Point<U>& pt) const;
    template <typename U>
    double Cross(const Point<U>& pt) const;
 
    template <typename U>
    Point<T>& LimitX(U start, U end);
    template <typename U>
    Point<T>& LimitY(U start, U end);
};
 
typedef Point<int> Point2i;
typedef Point<float> Point2f;
typedef Point<double> Point2d;
 
template <typename T>
inline Point<T>::Point() : x{}, y{} {}
 
template <typename T>
inline Point<T>::Point(T x, T y) : x(x), y(y) {}
 
template <typename T>
template <typename U>
inline Point<T>::Point(const Point<U>& pt) : x(static_cast<T>(pt.x)), y(static_cast<T>(pt.y)) {}
 
template <typename T>
template <typename U>
inline Point<T>::Point(const cv::Point_<U>& pt) : x(static_cast<T>(pt.x)), y(static_cast<T>(pt.y)) {}
 
template <typename T>
inline Point<T>::~Point() {}
 
template <typename T>
template <typename U>
inline Point<T>::operator cv::Point_<U>() const {
    return cv::Point_<U>(static_cast<U>(x), static_cast<U>(y));
}
 
template <typename T>
template <typename U>
inline Point<T>::operator Point<U>() const {
    return Point<U>(static_cast<U>(x), static_cast<U>(y));
}
 
template <typename U>
inline bool operator==(const Point<U>& pt1, const Point<U>& pt2) {
    return pt1.x == pt2.x && pt1.y == pt2.y;
}
 
template <typename U>
inline bool operator!=(const Point<U>& pt1, const Point<U>& pt2) {
    return pt1.x != pt2.x || pt1.y != pt2.y;
}
 
template <typename U>
inline bool operator<(const Point<U>& pt1, const Point<U>& pt2) {
    if (pt1.x == pt2.x)
        return pt1.y < pt2.y;
    return pt1.x < pt2.x;
}
 
template <typename U>
inline bool operator>(const Point<U>& pt1, const Point<U>& pt2) {
    if (pt1.x == pt2.x)
        return pt1.y > pt2.y;
    return pt1.x > pt2.x;
}
 
template <typename U>
inline bool operator<=(const Point<U>& pt1, const Point<U>& pt2) {
    if (pt1.x == pt2.x)
        return pt1.y <= pt2.y;
    return pt1.x <= pt2.x;
}
 
template <typename U>
inline bool operator>=(const Point<U>& pt1, const Point<U>& pt2) {
    if (pt1.x == pt2.x)
        return pt1.y >= pt2.y;
    return pt1.x >= pt2.x;
}
 
template <typename U>
inline Point<U> operator-(const Point<U>& pt1, const Point<U>& pt2) {
    return {pt1.x - pt2.x, pt1.y - pt2.y};
}
 
template <typename U>
inline std::ostream& operator<<(std::ostream& out, const Point<U>& pt) {
    out << "{ x: " << pt.x << ", y: " << pt.y << " }";
    return out;
}
 
template <typename T>
template <typename U>
inline double Point<T>::DistanceTo(const Point<U>& pt) const {
    return std::sqrt(static_cast<double>((pt.x - x) * (pt.x - x) + (pt.y - y) * (pt.y - y)));
}
 
template <typename T>
inline Point<T>& Point<T>::Translate(T dx, T dy) {
    x += dx;
    y += dy;
 
    return *this;
}
 
template <typename T>
inline Point<T>& Point<T>::Scale(double factor, bool round) {
    if (round) {
        x = std::round(x * factor);
        y = std::round(y * factor);
    } else {
        x *= factor;
        y *= factor;
    }
 
    return *this;
}
 
template <typename T>
template <typename U>
inline Point<T>& Point<T>::Rotate(double angle, const Point<U>& center) {
    // 将相对于中心点的坐标转换为相对于原点的坐标
    T translated_x = x - center.x;
    T translated_y = y - center.y;
 
    // 计算旋转后的坐标
    T rotated_x = translated_x * std::cos(angle) - translated_y * std::sin(angle);
    T rotated_y = translated_x * std::sin(angle) + translated_y * std::cos(angle);
 
    // 将相对于原点的坐标转换回相对于中心点的坐标
    x = rotated_x + center.x;
    y = rotated_y + center.y;
 
    return *this;
}
 
template <typename T>
template <typename U>
inline double Point<T>::Dot(const Point<U>& pt) const {
    return x * pt.x + y * pt.y;
}
 
template <typename T>
template <typename U>
inline double Point<T>::Cross(const Point<U>& pt) const {
    return x * pt.y - pt.x * y;
}
 
template <typename T>
template <typename U>
Point<T>& Point<T>::LimitX(U min_x, U max_x) {
    if (x < min_x)
        x = min_x;
 
    if (x > max_x)
        x = max_x;
 
    return *this;
}
 
template <typename T>
template <typename U>
Point<T>& Point<T>::LimitY(U min_y, U max_y) {
    if (y < min_y)
        y = min_y;
 
    if (y > max_y)
        y = max_y;
 
    return *this;
}
 
}  // namespace cm
 
#endif