rpolygon.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <iterator>
#include <span>
#include <vector>
 
#include "point.hpp"
 
namespace recti {
 
    template <typename T> class RPolygonVertexIterator {
      public:
        using iterator_category = std::forward_iterator_tag;
        using value_type = Point<T>;
        using difference_type = std::ptrdiff_t;
        using pointer = const value_type*;
        using reference = value_type;
 
        constexpr RPolygonVertexIterator(const Point<T>* origin, const Vector2<T>* vecs_begin,
                                         std::size_t idx)
            : _origin(origin), _vecs_begin(vecs_begin), _idx(idx) {}
 
        constexpr auto operator*() const -> value_type {
            if (_idx == 0) return *_origin;
            return *_origin + _vecs_begin[_idx - 1];
        }
 
        constexpr auto operator++() -> RPolygonVertexIterator& {
            ++_idx;
            return *this;
        }
 
        constexpr auto operator==(const RPolygonVertexIterator& other) const -> bool {
            return _idx == other._idx;
        }
 
        constexpr auto operator!=(const RPolygonVertexIterator& other) const -> bool {
            return _idx != other._idx;
        }
 
      private:
        const Point<T>* _origin;
        const Vector2<T>* _vecs_begin;
        std::size_t _idx;
    };
 
    template <typename T> class RPolygon {
      private:
        Point<T> _origin{};               
        std::vector<Vector2<T>> _vecs{};  
 
      public:
        using const_iterator = RPolygonVertexIterator<T>;
 
        constexpr RPolygon() = default;
 
        constexpr auto begin() const -> const_iterator {
            return const_iterator(&_origin, _vecs.data(), 0);
        }
 
        constexpr auto end() const -> const_iterator {
            return const_iterator(&_origin, _vecs.data(), _vecs.size() + 1);
        }
 
        constexpr RPolygon(Point<T> origin, std::vector<Vector2<T>> vecs)
            : _origin{origin}, _vecs{std::move(vecs)} {}
 
        explicit constexpr RPolygon(std::span<const Point<T>> pointset)
            : _origin{pointset.front()} {
            if (pointset.size() <= 1) return;
            _vecs.reserve(pointset.size() - 1);
            for (auto iterator = pointset.begin() + 1; iterator != pointset.end(); ++iterator) {
                _vecs.emplace_back(*iterator - _origin);
            }
        }
 
        constexpr bool operator==(const RPolygon& rhs) const {
            return _origin == rhs._origin && _vecs == rhs._vecs;
        }
 
        constexpr bool operator!=(const RPolygon& rhs) const { return !(*this == rhs); }
 
        constexpr auto operator+=(const Vector2<T>& vector_offset) -> RPolygon& {
            this->_origin += vector_offset;
            return *this;
        }
 
        constexpr auto operator-=(const Vector2<T>& vector_offset) -> RPolygon& {
            this->_origin -= vector_offset;
            return *this;
        }
 
        constexpr const Point<T>& origin() const { return _origin; }
 
        constexpr const std::vector<Vector2<T>>& vectors() const { return _vecs; }
 
        constexpr auto vertices() const -> std::vector<Point<T>> {
            std::vector<Point<T>> result;
            result.reserve(_vecs.size() + 1);
            result.emplace_back(_origin);
            for (const auto& vec : _vecs) {
                result.emplace_back(_origin + vec);
            }
            return result;
        }
 
        constexpr auto signed_area() const -> T {
            if (_vecs.empty()) return T{0};
 
            auto iterator = _vecs.begin();
            Vector2<T> first_vec = *iterator++;
            T result = first_vec.x() * first_vec.y();
 
            for (; iterator != _vecs.end(); ++iterator) {
                Vector2<T> second_vec = *iterator;
                result += second_vec.x() * (second_vec.y() - first_vec.y());
                first_vec = second_vec;
            }
            return result;
        }
 
        constexpr auto is_rectilinear() const -> bool { return true; }
    };
 
    template <typename FwIter, typename KeyFn, typename CmpFn>
    auto create_mono_rpolygon(FwIter&& first, FwIter&& last, const KeyFn& dir, const CmpFn& cmp)
        -> bool;
 
    template <typename FwIter> auto create_xmono_rpolygon(FwIter&& first, FwIter&& last) -> bool;
 
    template <typename FwIter> auto create_ymono_rpolygon(FwIter&& first, FwIter&& last) -> bool;
 
    template <typename FwIter> void create_test_rpolygon_old(FwIter&& first, FwIter&& last);
 
    template <typename FwIter> auto create_test_rpolygon(FwIter first, FwIter last)
        -> std::vector<typename std::iterator_traits<FwIter>::value_type>;
 
    template <typename T> auto rpolygon_is_xmonotone(std::span<const Point<T>> pointset) -> bool;
 
    template <typename T> auto rpolygon_is_ymonotone(std::span<const Point<T>> pointset) -> bool;
 
    template <typename T> auto rpolygon_is_convex(std::span<const Point<T>> pointset) -> bool;
 
    template <typename T>
    auto point_in_rpolygon(std::span<const Point<T>> pointset, const Point<T>& query_point) -> bool;
 
    template <typename T> auto rpolygon_is_anticlockwise(std::span<const Point<T>> pointset)
        -> bool;
}  // namespace recti