polygon.hh

#ifndef VTESTBED_GEOMETRY_POLYGON_HH
#define VTESTBED_GEOMETRY_POLYGON_HH

#include <algorithm>
#include <iosfwd>
#include <vector>

#include <vtestbed/geometry/line_segment.hh>
#include <vtestbed/geometry/math.hh>
#include <vtestbed/geometry/plane.hh>
#include <vtestbed/geometry/types.hh>

namespace vtb {

    namespace geometry {

        template <class T, int N>
        class Polygon: public std::vector<Vertex<T,N>> {

        private:
            using base_type = std::vector<Vertex<T,N>>;

        public:
            using scalar_type = T;
            static constexpr const int dimensions = N;
            using value_type = typename base_type::value_type;
            using pointer = typename base_type::pointer;
            using const_pointer = typename base_type::const_pointer;
            using reference = typename base_type::reference;
            using const_reference = typename base_type::const_reference;
            using iterator = typename base_type::iterator;
            using const_iterator = typename base_type::const_iterator;
            using size_type = typename base_type::size_type;
            using difference_type = typename base_type::difference_type;
            using reverse_iterator = typename base_type::reverse_iterator;
            using const_reverse_iterator = typename base_type::const_reverse_iterator;
            using triangle_array = std::vector<Triangle<T,N>>;

        public:

            using base_type::base_type;
            using base_type::operator=;
            using base_type::operator[];

            inline bool
            closed() const {
                return !this->empty() && all(this->front() == this->back());
            }

            inline void
            make_closed() {
                if (this->empty()) { return; }
                if (all(this->front() == this->back())) { return; }
                this->emplace_back(this->front());
            }

            inline size_t
            find(const value_type& vertex) const {
                const auto& vertices = *this;
                const auto nvertices = vertices.size();
                for (size_t i=0; i<nvertices; ++i) {
                    const auto& v = vertices[i];
                    if (all(v == vertex)) {
                        return i;
                    }
                }
                return std::numeric_limits<size_t>::max();
            }

            inline void flip() { std::reverse(this->begin(), this->end()); }

            Plane<T,N> plane() const;
            Polyline<T,N> polyline() const;
            bool degenerate(scalar_type eps) const;
            void triangle_fan(triangle_array& triangles) const;
            triangle_array triangle_fan() const;

            triangle_array triangles() const;

            void simplify(T eps);
            void gift_wrap(scalar_type eps, size_type count);
            void gnuplot(std::ostream& out) const;

        };

        template <class T, int N>
        struct is_figure<Polygon<T,N>>: public std::true_type {};

        template <class T> Vertex<T,2> centroid(const Polygon<T,2>& p);

    }

}

#endif // vim:filetype=cpp