line_segment.hh

#ifndef VTESTBED_GEOMETRY_LINE_SEGMENT_HH
#define VTESTBED_GEOMETRY_LINE_SEGMENT_HH

#include <array>
#include <iosfwd>

#include <vtestbed/geometry/plane.hh>
#include <vtestbed/geometry/types.hh>
#include <vtestbed/geometry/vertex.hh>

namespace vtb {

    namespace geometry {

        template <class T, int N>
        class Line_segment: public std::array<Vertex<T,N>,2> {

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

        public:
            static constexpr const int dimensions = N;
            using scalar_type = T;
            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;

        public:

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

            inline
            Line_segment(const_reference a, const_reference b):
            base_type{a,b} {}

            inline bool
            border_contains(const_reference v) const {
                return all(this->front() == v) || all(this->back() == v);
            }

            inline bool
            border_contains(const_reference v, scalar_type eps) const {
                return near(this->front(), v, eps) || near(this->back(), v, eps);
            }

            inline bool
            interior_contains(const_reference v, T eps) const {
                return !this->border_contains(v) && this->contains(v, eps);
            }

            inline bool
            degenerate(scalar_type eps) const {
                return near(this->front(), this->back(), eps);
            }

            inline void
            flip() {
                using std::swap;
                swap(this->front(), this->back());
            }

            inline scalar_type length() const { return distance(this->front(), this->back()); }
            inline value_type centre() const { return T{0.5}*(this->front()+this->back()); }

            bool contains(const_reference c, T eps) const;

            Plane<T,2> plane() const;
            inline void invert() { std::swap(this->front(), this->back()); }

            void gnuplot(std::ostream&) const;

        };

        template <class T, int N>
        inline bool
        near(const Line_segment<T,N>& lhs, const Line_segment<T,N>& rhs, T eps) {
            return near(lhs.front(), rhs.front(), eps) &&
                near(lhs.back(), rhs.back(), eps);
        }

        template <class T, int N>
        inline bool
        operator<(const Line_segment<T,N>& lhs, const Line_segment<T,N>& rhs) {
            Compare_vertex<T,N> cmp;
            return cmp(lhs.back(), rhs.front());
        }

        template <class T, int N>
        inline bool
        operator==(const Line_segment<T,N>& lhs, const Line_segment<T,N>& rhs) {
            return all(lhs.front() == rhs.front()) &&
                all(lhs.back() == rhs.back());
        }

        template <class T, int N>
        inline bool
        operator!=(const Line_segment<T,N>& lhs, const Line_segment<T,N>& rhs) {
            return !operator==(lhs, rhs);
        }

        template <class T, int N>
        inline Vertex<Plane_position,2>
        compare(const Plane<T,N> plane, const Line_segment<T,N>& s, T eps) {
            return {compare(plane, s[0], eps), compare(plane, s[1], eps)};
        }

        template <class T, int N>
        Vertex<T,N>
        intersection_point(
            const Plane<T,N>& plane,
            const Line_segment<T,N>& segment
        );

        template <int dim, class T, int N>
        Vertex<T,N>
        intersection_point(const Line_segment<T,N>& segment, T level) {
            const auto& a = segment.front();
            const auto& b = segment.back();
            Vertex<T,N> extent = b - a;
            T s = (level - a(dim)) / extent(dim);
            return a + s*extent;
        }

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

        template <class T, int N>
        inline Vertex<T,N>
        centroid(const Line_segment<T,N>& s) { return s.centre(); }

    }

}

#endif // vim:filetype=cpp