manhattan_arc.hpp

Go to the documentation of this file.

 
#pragma once
 
// #include <algorithm> // import std::min, std::max
#include <utility>  // import std::move
 
#include "interval.hpp"
#include "point.hpp"
 
namespace recti {
 
#pragma pack(push, 1)
    template <typename T1, typename T2 = T1> class ManhattanArc {
      public:
        Point<T1, T2> impl;
 
      public:
        constexpr ManhattanArc() : impl{T1{}, T2{}} {}
 
        constexpr ManhattanArc(T1 xcoord, T2 ycoord) : impl{std::move(xcoord), std::move(ycoord)} {}
 
        static constexpr auto from_point(const Point<T1, T2>& pt) {
            auto pt_xformed = pt.rotates();
            return ManhattanArc<T1, T2>{pt_xformed.xcoord(), pt_xformed.ycoord()};
        }
 
        static constexpr auto construct(const T1& xcoord, const T2& ycoord) -> ManhattanArc {
            return ManhattanArc{xcoord - ycoord, xcoord + ycoord};
        }
 
 
        template <typename U1, typename U2>
        constexpr auto operator==(const ManhattanArc<U1, U2>& rhs) const -> bool {
            return this->impl == rhs.impl;
        }
 
        template <typename U1, typename U2>
        constexpr auto operator!=(const ManhattanArc<U1, U2>& rhs) const -> bool {
            return this->impl != rhs.impl;
        }
 
        template <typename U1, typename U2>  //
        constexpr auto overlaps(const ManhattanArc<U1, U2>& other) const -> bool {
            return this->impl.overlaps(other.impl);
        }
 
        template <typename U1, typename U2>  //
        constexpr auto intersect_with(const ManhattanArc<U1, U2>& other) const {
            auto xcoord = intersection(this->impl.xcoord(), other.impl.xcoord());
            auto ycoord = intersection(this->impl.ycoord(), other.impl.ycoord());
            return ManhattanArc<decltype(xcoord), decltype(ycoord)>{std::move(xcoord),
                                                                    std::move(ycoord)};
        }
 
        template <typename U1, typename U2>  //
        constexpr auto min_dist_with(const ManhattanArc<U1, U2>& other) const {
            return std::max(min_dist(this->impl.xcoord(), other.impl.xcoord()),
                            min_dist(this->impl.ycoord(), other.impl.ycoord()));
        }
 
        template <typename R>  //
        constexpr auto enlarge_with(const R& alpha) const {
            auto xcoord = enlarge(this->impl.xcoord(), alpha);
            auto ycoord = enlarge(this->impl.ycoord(), alpha);
            return ManhattanArc<decltype(xcoord), decltype(ycoord)>{std::move(xcoord),
                                                                    std::move(ycoord)};
        }
 
        constexpr auto get_center() const {
            auto m = impl.get_center();
            return m.inv_rotates();
        }
 
        constexpr auto get_lower_corner() const {
            auto m = impl.lower_corner();
            return m.inv_rotates();
        }
 
        constexpr auto get_upper_corner() const {
            auto m = impl.upper_corner();
            return m.inv_rotates();
        }
 
        template <typename U1, typename U2>
        constexpr auto nearest_point_to(const Point<U1, U2>& other) const {
            auto ms = ManhattanArc<U1, U2>::from_point(other);
            auto distance = this->min_dist_with(ms);
            auto trr = ms.enlarge_with(distance);
            auto lb = impl.lower_corner();
            auto ub = impl.upper_corner();
            auto m = impl.get_center();
            if (trr.impl.contains(lb)) {
                m = lb;
            } else if (trr.impl.contains(ub)) {
                m = ub;
            }
            return m.inv_rotates();
        }
 
        template <typename U1, typename U2>
        constexpr auto merge_with(const ManhattanArc<U1, U2>& other, int alpha) const {
            auto distance = min_dist_with(other);
            auto trr1 = this->enlarge_with(alpha);
            auto trr2 = other.enlarge_with(distance - alpha);
            auto localimpl = trr1.impl.intersect_with(trr2.impl);
            auto x = localimpl.xcoord();
            auto y = localimpl.ycoord();
            return ManhattanArc<decltype(x), decltype(y)>{std::move(x), std::move(y)};
        }
 
        template <class Stream>
        friend auto operator<<(Stream& out, const ManhattanArc& manhattan_arc) -> Stream& {
            out << "/" << manhattan_arc.impl.xcoord() << ", " << manhattan_arc.impl.ycoord() << "/";
            return out;
        }
    };
#pragma pack(pop)
 
}  // namespace recti