polyhedron.hh

#ifndef VTESTBED_GEOMETRY_POLYHEDRON_HH
#define VTESTBED_GEOMETRY_POLYHEDRON_HH

#include <iosfwd>
#include <vector>

#include <vtestbed/base/bstream.hh>
#include <vtestbed/geometry/face.hh>
#include <vtestbed/geometry/rectangle.hh>
#include <vtestbed/geometry/triangle.hh>
#include <vtestbed/geometry/types.hh>

namespace vtb {

    namespace geometry {

        template <class T>
        class Bounds {

        private:
            T _min{}, _max{};

        public:
            Bounds() = default;
            inline Bounds(T a, T b): _min(a), _max(b) {}
            inline T min() const { return this->_min; }
            inline T max() const { return this->_max; }

        };

        template <class T,int N=3>
        class Polyhedron {

        public:
            static constexpr const int dimensions = N;
            using scalar_type = T;
            using vertex_type = Vertex<T,N>;
            using face_type = Face<3>;
            using vertex_array = std::vector<vertex_type>;
            using face_array = std::vector<face_type>;
            using size_type = size_t;
            using index_type = typename face_type::value_type;
            using box_type = Rectangle<T,N>;
            using triangle_type = Triangle<T,N>;
            using triangle_array = std::vector<triangle_type>;
            using bsp_tree = BSP_tree<T,N>;

        private:
            using index_array = std::vector<index_type>;
            using index_array_2d = std::vector<index_array>;
            using blitz_vertex_array = blitz::Array<vertex_type,1>;
            using blitz_face_array = blitz::Array<face_type,1>;

        private:
            vertex_array _vertices;
            vertex_array _vertex_normals;
            face_array _faces;
            vertex_array _face_normals;

        public:

            Polyhedron() = default;
            ~Polyhedron() = default;
            Polyhedron(const Polyhedron&) = default;
            Polyhedron& operator=(const Polyhedron&) = default;
            Polyhedron(Polyhedron&&) = default;
            Polyhedron& operator=(Polyhedron&&) = default;

            inline explicit
            Polyhedron(const vertex_array& vertices, const face_array& faces):
            _vertices(vertices), _faces(faces) {}

            inline explicit
            Polyhedron(
                const vertex_array& vertices,
                const vertex_array& vertex_normals,
                const face_array& faces
            ):
            _vertices(vertices),
            _vertex_normals(vertex_normals),
            _faces(faces) {}

            explicit
            Polyhedron(
                const blitz_vertex_array& vertices,
                const blitz_face_array& faces
            );

            explicit
            Polyhedron(const triangle_array& triangles);

            explicit
            Polyhedron(const bsp_tree& tree);

            inline const vertex_array&
            vertices() const noexcept {
                return this->_vertices;
            }

            inline const vertex_array&
            vertex_normals() const noexcept {
                return this->_vertex_normals;
            }

            inline const vertex_array&
            face_normals() const noexcept {
                return this->_face_normals;
            }

            inline const face_array&
            faces() const noexcept {
                return this->_faces;
            }

            void clear();
            void clear_normals();
            void shrink_to_fit();
            scalar_type average_face_area() const;
            scalar_type signed_volume() const;
            scalar_type signed_volume_below(int dimension, scalar_type level) const;
            vertex_type centre() const;
            vertex_type centroid() const;
            vertex_type centroid_below(int dimension, scalar_type level) const;
            box_type bounding_box() const;
            Bounds<T> bounds(int dimension) const;
            void swap(Polyhedron& rhs);

            inline scalar_type
            signed_volume_below_centroid(int dimension) const {
                return this->signed_volume_below(dimension,
                        this->centroid()(dimension));
            }

            void normalise();

            void normalise_faces();

            void reorder();

            void unique();

            void merge(const Polyhedron& rhs);

            inline Polyhedron&
            operator+=(const Polyhedron& rhs) {
                this->merge(rhs);
                return *this;
            }

            void cut_duplicate_faces();
            void remove_face(const vertex_type& vertex);
            void remove_face(index_type vertex);

            inline bool
            empty() const {
                return this->vertices().empty() &&
                    this->vertex_normals().empty() &&
                    this->faces().empty() &&
                    this->face_normals().empty();
            }

            triangle_array triangles() const;
            blitz_vertex_array blitz_vertices() const;
            blitz_vertex_array blitz_vertex_normals() const;
            blitz_face_array blitz_faces() const;

            void move_to_centre_of_mass();

            void move_to_centre_of_mass(T draught);

            void move_to_centre_of_bounding_box();

            void move(const vertex_type& delta);

            void scale(const vertex_type& ratio);

            void wall(scalar_type thickness);

            void flip(int dimension);

            void mirror(int dimension);

            void rotate(int dimension, int degrees);

            inline Mass_moments<T,N> mass_moments() const {
                return mass_moments_below(0, std::numeric_limits<T>::max());
            }
            Mass_moments<T,N> mass_moments_below(int dimension, scalar_type level) const;

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

        private:

            index_array_2d
            vertex_faces() const;

            index_array_2d
            component_faces(const index_array_2d& vf) const;

            index_type
            reference_face_index(
                const index_array& indices,
                const vertex_type& origin
            ) const;

            void reorder(index_type reference_face_index, const vertex_type& origin);
            void remove_duplicate_vertices();
            void remove_duplicate_faces();

            template <class X, int M>
            friend vtb::core::bstream&
            operator>>(vtb::core::bstream& in, Polyhedron<X,M>& rhs);

        };

        template <class T, int N>
        inline void
        swap(Polyhedron<T,N>& lhs, Polyhedron<T,N>& rhs) {
            lhs.swap(rhs);
        }

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

        template <class T, int N>
        inline T
        signed_volume(const Polyhedron<T,N>& geometry) {
            return geometry.signed_volume();
        }

        template <class T, int N>
        inline T
        volume(const Polyhedron<T,N>& geometry) {
            return std::abs(signed_volume(geometry));
        }

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

        template <class T, int N>
        vtb::core::bstream&
        operator<<(vtb::core::bstream& out, const Polyhedron<T,N>& rhs);

        template <class T, int N>
        vtb::core::bstream&
        operator>>(vtb::core::bstream& in, Polyhedron<T,N>& rhs);

        template <class T,int N>
        T
        winding_number(const Polyhedron<T,N>& geometry, const Vertex<T,N>& origin);

        template <class T, int N>
        Inertia_tensor<T,N>
        inertia_tensor(const Polyhedron<T,N>& body);

    }

}

template <class T>
struct vtb::base::has_begin_end<std::vector<T>>: public std::true_type {};
template <class T>
struct vtb::base::has_reserve_emplace_back<std::vector<T>>: public std::true_type {};

#endif // vim:filetype=cpp