point.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <tuple>    // for std::tie()
#include <utility>  // for std::move
 
#include "generic.hpp"
#include "vector2.hpp"
 
namespace recti {
 
    template <typename T1, typename T2> class Point;
 
    template <typename T1 = int, typename T2 = T1> class Point {
        using Self = Point<T1, T2>;
 
        template <typename, typename> friend class Point;
 
        T1 _xcoord;  
        T2 _ycoord;  
 
      public:
        using value_type = T1;
 
        constexpr Point() : _xcoord{}, _ycoord{} {}
 
        constexpr Point(T1 xcoord, T2 ycoord) noexcept
            : _xcoord{std::move(xcoord)}, _ycoord{std::move(ycoord)} {}
 
        constexpr auto xcoord() const -> const T1& { return this->_xcoord; }
 
        constexpr auto ycoord() const -> const T2& { return this->_ycoord; }
 
 
        template <typename U1, typename U2>
        constexpr auto operator==(const Point<U1, U2>& rhs) const -> bool {
            return std::tie(this->xcoord(), this->ycoord()) == std::tie(rhs.xcoord(), rhs.ycoord());
        }
 
        template <typename U1, typename U2>  //
        constexpr auto operator<(const Point<U1, U2>& rhs) const -> bool {
            return std::tie(this->xcoord(), this->ycoord()) < std::tie(rhs.xcoord(), rhs.ycoord());
        }
 
        template <typename U1, typename U2>
        constexpr auto operator!=(const Point<U1, U2>& rhs) const -> bool {
            return !(*this == rhs);
        }
 
 
 
        template <typename U1, typename U2>
        CONSTEXPR14 auto operator+=(const Vector2<U1, U2>& right_point) -> Self& {
            this->_xcoord += right_point.x();
            this->_ycoord += right_point.y();
            return *this;
        }
 
        template <typename U1, typename U2>  //
        friend constexpr auto operator+(Point lhs, const Vector2<U1, U2>& vector) {
            auto xcoord = lhs.xcoord() + vector.x();
            auto ycoord = lhs.ycoord() + vector.y();
            return Point<decltype(xcoord), decltype(ycoord)>{std::move(xcoord), std::move(ycoord)};
        }
 
        template <typename U1, typename U2>
        CONSTEXPR14 auto operator-=(const Vector2<U1, U2>& right_point) -> Self& {
            this->_xcoord -= right_point.x();
            this->_ycoord -= right_point.y();
            return *this;
        }
 
        template <typename U1, typename U2>  //
        friend constexpr auto operator-(Point lhs, const Vector2<U1, U2>& vector) {
            auto xcoord = lhs.xcoord() - vector.x();
            auto ycoord = lhs.ycoord() - vector.y();
            return Point<decltype(xcoord), decltype(ycoord)>{std::move(xcoord), std::move(ycoord)};
        }
 
        constexpr auto operator-(const Self& other_point) const {
            auto xcoord = this->xcoord() - other_point.xcoord();
            auto ycoord = this->ycoord() - other_point.ycoord();
            return Vector2<decltype(xcoord), decltype(ycoord)>{std::move(xcoord),
                                                               std::move(ycoord)};
        }
 
        constexpr auto measure() const {
            return measure_of(this->xcoord()) * measure_of(this->ycoord());
        }
 
        constexpr auto flip_xy() const -> Point<T2, T1> { return {this->ycoord(), this->xcoord()}; }
 
        constexpr auto flip_y() const -> Point<T1, T2> { return {-this->xcoord(), this->ycoord()}; }
 
        template <typename U1, typename U2>  //
        constexpr auto overlaps(const Point<U1, U2>& other_point) const -> bool {
            return overlap(this->xcoord(), other_point.xcoord())
                   && overlap(this->ycoord(), other_point.ycoord());
        }
 
        template <typename U1, typename U2>  //
        constexpr auto intersect_with(const Point<U1, U2>& other_point) const {
            auto xcoord = intersection(this->xcoord(), other_point.xcoord());
            auto ycoord = intersection(this->ycoord(), other_point.ycoord());
            return Point<decltype(xcoord), decltype(ycoord)>{std::move(xcoord), std::move(ycoord)};
        }
 
        template <typename U1, typename U2>  //
        constexpr auto hull_with(const Point<U1, U2>& other_point) const {
            auto xcoord = hull(this->xcoord(), other_point.xcoord());
            auto ycoord = hull(this->ycoord(), other_point.ycoord());
            return Point<decltype(xcoord), decltype(ycoord)>{std::move(xcoord), std::move(ycoord)};
        }
 
        template <typename U1, typename U2>  //
        constexpr auto contains(const Point<U1, U2>& other_point) const -> bool {
            return contain(this->xcoord(), other_point.xcoord())
                   && contain(this->ycoord(), other_point.ycoord());
        }
 
        template <typename U1, typename U2>  //
        constexpr auto blocks(const Point<U1, U2>& other_point) const -> bool {
            return (contain(this->xcoord(), other_point.xcoord())
                    && contain(other_point.ycoord(), this->ycoord()))
                   || (contain(this->ycoord(), other_point.ycoord())
                       && contain(other_point.xcoord(), this->xcoord()));
        }
 
        template <typename U1, typename U2>  //
        constexpr auto min_dist_with(const Point<U1, U2>& other_point) const {
            return min_dist(this->xcoord(), other_point.xcoord())
                   + min_dist(this->ycoord(), other_point.ycoord());
        }
 
        template <typename U1, typename U2>  //
        constexpr auto min_dist_change_with(Point<U1, U2>& other_point) {
            return min_dist_change(this->_xcoord, other_point._xcoord)
                   + min_dist_change(this->_ycoord, other_point._ycoord);
        }
 
        template <typename T> constexpr auto enlarge_with(const T& value) const {
            auto xb = enlarge(this->xcoord(), value);
            auto yb = enlarge(this->ycoord(), value);
            return Point<decltype(xb), decltype(yb)>{std::move(xb), std::move(yb)};
        }
 
        template <typename U1, typename U2>  //
        constexpr auto nearest_to(const Point<U1, U2>& other_point) const {
            auto xcoord = nearest(this->xcoord(), other_point.xcoord());
            auto ycoord = nearest(this->ycoord(), other_point.ycoord());
            return Point<U1, U2>{std::move(xcoord), std::move(ycoord)};
        }
 
        constexpr auto rotates() const -> Point<T1, T2> {
            if constexpr (std::is_same_v<T1, Point>) {
                auto pt = _xcoord.rotates();
                auto pt2 = Point(pt.ycoord(), _ycoord).rotates();
                auto pt3 = Point(pt.xcoord(), pt2.ycoord()).rotates();
                return Point(Point(pt3.xcoord(), pt2.xcoord()), pt3.ycoord());
            } else {
                auto xcoord = _xcoord - _ycoord;
                auto ycoord = _xcoord + _ycoord;
                return Point<T1, T2>(xcoord, ycoord);
            }
        }
 
        constexpr auto inv_rotates() const -> Point<T1, T2> {
            if constexpr (std::is_same_v<T1, Point>) {
                auto pt = Point(_xcoord.xcoord(), _ycoord).inv_rotates();
                auto pt2 = Point(_xcoord.ycoord(), pt.ycoord()).inv_rotates();
                auto pt3 = Point(pt.xcoord(), pt2.xcoord()).inv_rotates();
                return Point(Point(pt3.xcoord(), pt3.ycoord()), pt2.ycoord());
            } else {
                auto xcoord = (_xcoord + _ycoord) / 2;
                auto ycoord = (-_xcoord + _ycoord) / 2;
                return Point<T1, T2>(xcoord, ycoord);
            }
        }
 
        constexpr auto get_center() const {
            auto xcoord = center(_xcoord);
            auto ycoord = center(_ycoord);
            return Point<decltype(xcoord), decltype(ycoord)>{std::move(xcoord), std::move(ycoord)};
        }
 
        constexpr auto lower_corner() const {
            auto xcoord = lower(_xcoord);
            auto ycoord = lower(_ycoord);
            return Point<decltype(xcoord), decltype(ycoord)>{std::move(xcoord), std::move(ycoord)};
        }
 
        constexpr auto upper_corner() const {
            auto xcoord = upper(_xcoord);
            auto ycoord = upper(_ycoord);
            return Point<decltype(xcoord), decltype(ycoord)>{std::move(xcoord), std::move(ycoord)};
        }
 
        template <class Stream> friend auto operator<<(Stream& output_stream, const Point& obj)
            -> Stream& {
            output_stream << "(" << obj.xcoord() << ", " << obj.ycoord() << ")";
            return output_stream;
        }
 
      protected:
        CONSTEXPR14 auto get_xcoord() -> T1& { return this->_xcoord; }
 
        constexpr auto get_xcoord() const -> const T1& { return this->_xcoord; }
 
        CONSTEXPR14 auto get_ycoord() -> T2& { return this->_ycoord; }
 
        constexpr auto get_ycoord() const -> const T2& { return this->_ycoord; }
    };
 
}  // namespace recti