plane.hh

#ifndef VTESTBED_GEOMETRY_PLANE_HH
#define VTESTBED_GEOMETRY_PLANE_HH

#include <iosfwd>

#include <vtestbed/geometry/math.hh>
#include <vtestbed/geometry/plane_position.hh>
#include <vtestbed/geometry/ray.hh>
#include <vtestbed/geometry/types.hh>

namespace vtb {

    namespace geometry {

        template <class T, int N>
        class Plane {

        public:
            static constexpr const int dimensions = N;
            using scalar_type = T;
            using value_type = Vertex<T,N>;
            using reference = value_type&;
            using const_reference = const value_type&;

        private:
            value_type _normal{T{}};
            value_type _origin{T{}};

        public:

            Plane() = default;

            inline explicit
            Plane(const_reference normal, const_reference origin):
            _normal{normal}, _origin{origin} {}

            inline explicit
            Plane(const_reference normal):
            _normal{normal} {}

            explicit
            Plane(const_reference a, const_reference b, const_reference c);

            inline const_reference normal() const { return this->_normal; }

            inline const_reference origin() const { return this->_origin; }

            inline void invert() { this->_normal = -this->_normal; }

            inline T
            operator()(const_reference point) const {
                return dot(normal(), point-origin());
            }

            inline T operator()() const { return -dot(normal(), origin()); }

            inline value_type
            project(const_reference point) const {
                return point - dot(normal(), point-origin())*normal();
            }

            inline value_type
            project_vector(const_reference vector) const {
                return vector - dot(normal(), vector)*normal();
            }

            int redundant_dimension() const;

            Basis<T,N> basis() const;

            Coordinate_system<T,N> coordinate_system() const;

            inline void
            clear() {
                this->_normal = T{};
                this->_origin = T{};
            }

            void gnuplot(std::ostream& out) const;

        };

        template <class T, int N>
        std::ostream&
        operator<<(std::ostream& out, const Plane<T,N>& rhs);

        template <class T, int N>
        inline Vertex<T,N>
        intersection(const Ray<T,N>& ray, const Plane<T,N>& plane) {
            T num = dot(plane.origin() - ray.origin(), plane.normal());
            T den = dot(ray.direction(), plane.normal());
            return ray.origin() + ray.direction() * num / den;
        }

        template <class T, int N>
        inline Plane_position
        compare(const Plane<T,N> plane, const Vertex<T,N>& point, T eps) {
            T t = plane(point);
            if (t < -eps) { return Plane_position::Back; }
            else if (t > eps) { return Plane_position::Front; }
            else { return Plane_position::Same; }
        }

        template <class T, int N>
        inline Plane_position
        compare(const Plane<T,N> lhs, const Plane<T,N>& rhs, T eps) {
            T t = dot(lhs.normal(), rhs.normal());
            if (t < -eps) { return Plane_position::Back; }
            else if (t > eps) { return Plane_position::Front; }
            else { return Plane_position::Same; }
        }

    }

}

#endif // vim:filetype=cpp