point.hpp

Go to the documentation of this file.

#pragma once
 
#include "math/function.hpp"
#include "vector.hpp" // Presumed to define Vec, Vec2, Vec3, Vec4, Float

 
namespace pbpt::math {
template<typename T, int N>
class Point {
private:
    Vector<T, N> m_coords{};
 
public:
    // --- 静态工厂函数 (Static Factory Functions) ---

    constexpr static Point filled(T value) noexcept { return Point(Vector<T, N>::filled(value)); }

    constexpr static Point zeros() noexcept { return Point(Vector<T, N>::zeros()); }

    constexpr static Point ones() noexcept { return Point(Vector<T, N>::ones()); }
    
    // --- 构造函数 (Constructors) ---

    constexpr Point() noexcept : m_coords(Vector<T, N>::zeros()) {}

    constexpr explicit Point(const Vector<T, N>& vec) noexcept : m_coords(vec) {}

    template<std::convertible_to<T>... Args>
    requires(sizeof...(Args) == N)
    constexpr explicit Point(Args&&... args) noexcept 
        : m_coords(std::forward<Args>(args)...) {}
 
    // --- 访问器 (Accessors) ---

    constexpr T& x() noexcept requires(N > 0) { return m_coords.x(); }
    constexpr T& y() noexcept requires(N > 1) { return m_coords.y(); }
    constexpr T& z() noexcept requires(N > 2) { return m_coords.z(); }
    constexpr T& w() noexcept requires(N > 3) { return m_coords.w(); }

    constexpr T x() const noexcept requires(N > 0) { return m_coords.x(); }
    constexpr T y() const noexcept requires(N > 1) { return m_coords.y(); }
    constexpr T z() const noexcept requires(N > 2) { return m_coords.z(); }
    constexpr T w() const noexcept requires(N > 3) { return m_coords.w(); }

    constexpr int dims() const noexcept { return N; }
 
    // --- 下标访问 (Subscript Access) ---

    constexpr const T& operator[](int index) const { return m_coords[index]; }
    constexpr T& operator[](int index) { return m_coords[index]; }
    constexpr const T& at(int index) const { return m_coords.at(index); }
 
    // --- 显式转换 (Explicit Conversion) ---

    constexpr Vector<T, N> to_vector() const noexcept { return m_coords; }
 
    // --- 复合赋值运算符 (Compound Assignment Operators) ---

    constexpr Point& operator+=(const Vector<T, N>& rhs) noexcept {
        m_coords += rhs;
        return *this;
    }
 
    /*** @brief less than */
    constexpr bool operator<(const Point& rhs) const {
        for (int i = 0; i < N; i ++) {
            if (!is_less(m_coords[i], rhs.m_coords[i]))
                return false;
        }
        return true;
    }
 
    /*** @brief less than or equal*/
    constexpr bool operator<=(const Point& rhs) const {
        for (int i = 0; i < N; i ++) {
            if (is_greater(m_coords[i], rhs.m_coords[i]))
                return false;
        }
        return true;
    }

    constexpr bool operator>(const Point& rhs) const {
        for (int i = 0; i < N; i ++) {
            if (!is_greater(m_coords[i], rhs.m_coords[i]))
                return false;
        }
        return true;
    }

    constexpr bool operator>=(const Point& rhs) const {
        for (int i = 0; i < N; i ++) {
            if (is_less(m_coords[i], rhs.m_coords[i]))
                return false;
        }
        return true;
    }

    constexpr bool operator==(const Point& rhs) const {
        for (int i = 0; i < N; i ++) {
            if (!is_equal(m_coords[i], rhs.m_coords[i]))
                return false;
        }
        return true;
    }

    constexpr Point& operator-=(const Vector<T, N>& rhs) noexcept {
        m_coords -= rhs;
        return *this;
    }
    
    // --- 流输出 (Stream Output) ---
    
    friend std::ostream& operator<<(std::ostream& os, const Point& point) {
        os << "Point" << N << "(";
        for (int i = 0; i < N; ++i) {
            os << point[i] << (i == N - 1 ? "" : ", ");
        }
        os << ")";
        return os;
    }

    constexpr Vector<T, N> operator-(const Point& rhs) const noexcept {
        return this->to_vector() - rhs.to_vector();
    }

    constexpr Point operator+(const Vector<T, N>& rhs) const noexcept {
        auto result = *this;
        result += rhs;
        return result;
    }

    constexpr Point operator-(const Vector<T, N>& rhs) const noexcept {
        auto result = *this;
        result -= rhs;
        return result;
    }

    constexpr Point mid(const Point<T, N>& rhs) const noexcept {
        // Conceptually: start at lhs, and move halfway towards rhs.
        // (lhs + (rhs - lhs) * 0.5) which simplifies to (lhs + rhs) * 0.5
        return Point<T, N>((this->to_vector() + rhs.to_vector()) * 0.5);
    }
};
 
// --- 类型别名 (Type Aliases) ---
using Pt2 = Point<Float, 2>;
using Pt3 = Point<Float, 3>;
using Pt4 = Point<Float, 4>;
 
} // namespace math