vessel.hh

#ifndef VTESTBED_VSL_VESSEL_HH
#define VTESTBED_VSL_VESSEL_HH

#include <iosfwd>
#include <string>
#include <vector>

#include <blitz/array.h>

#include <vtestbed/geometry/polygon.hh>
#include <vtestbed/iges/types.hh>
#include <vtestbed/vsl/description.hh>
#include <vtestbed/vsl/name.hh>

namespace vtb {

    namespace vsl {

        template <class T> class Section;
        template <class T> class Vessel;

        template <class T>
        class Section {

        private:
            using vec2 = blitz::TinyVector<T,2>;
            using vec3 = blitz::TinyVector<T,3>;
            using vertex_array = std::vector<vec3>;
            using frame_container = std::vector<vertex_array>;
            using polygon_type = vtb::geometry::Polygon<T,2>;

        private:
            frame_container _frames;
            frame_container _bottom_frames;
            frame_container _top_frames;
            vertex_array _arr;
            vertex_array _terminal_frame;
            polygon_type _polygon;
            vertex_array _width;

        public:
            inline const frame_container& bottom_frames() const { return this->_bottom_frames; }
            inline const frame_container& top_frames() const { return this->_top_frames; }
            inline const frame_container& frames() const { return this->_frames; }
            inline const vertex_array& terminal_frame() const { return this->_terminal_frame; }
            inline const vertex_array& polyline() const { return this->_arr; }
            void clear();

            friend class Vessel<T>;

        private:
            void read_vertices_zx(std::istream& in);
            void read_vertices_zy(std::istream& in);
            void read_frame(std::istream& in);
            void aft_width();
            void bow_width();
            void aft_polygon();
            void bow_polygon();
            void clip_to_polygon(size_t begin_offset, size_t end_offset);
            void aft_generate_horizontal_frames();
            void bow_generate_horizontal_frames();
            void bow_terminal_frame();
            void main_generate_horizontal_frames();

        };

        template <class T>
        class Vessel {

        private:
            using vec2 = blitz::TinyVector<T,2>;
            using vec3 = blitz::TinyVector<T,3>;
            using vertex_array = std::vector<vec3>;
            using frame_container = std::vector<vertex_array>;
            using section_type = Section<T>;

        private:
            enum class Reading {
                Name, Size, Extents,
                Aft, AftWidth,
                FrameStart, Frame, FrameEnd,
                BowWidth, Bow,
                End
            };

        private:
            std::string _filename;
            Name _name;
            Description _description;
            size_t _nframes = 0;
            size_t _middleframe = 0;
            T _length{0};
            T _beam{0};
            T _draught{0};
            vertex_array _aft_width;
            vertex_array _bow_width;
            section_type _aft_section;
            section_type _bow_section;
            section_type _main_section;

        public:
            void read(std::istream& in);
            void clear();
            void dump(std::ostream& out) const;
            void dump_gnuplot(std::ostream& out) const;
            void gnuplot_sections(std::ostream& out) const;
            void gnuplot_bow(std::ostream& out) const;

            inline const Name& name() const { return this->_name; }
            inline T length() const { return this->_length; }
            inline T beam() const { return this->_beam; }
            inline T draught() const { return this->_draught; }
            inline const section_type& aft() const { return this->_aft_section; }
            inline const section_type& bow() const { return this->_bow_section; }
            inline const section_type& main_section() const { return this->_main_section; }
            inline void filename(const std::string& filename) { this->_filename = filename; }
            inline const std::string& filename() const { return this->_filename; }
            inline const Description& description() const { return this->_description; }

        private:
            void read_line(std::istream& str, Reading& state);
            void read_size(std::istream& in);
            void read_extents(std::istream& in);
            void set_bow_and_aft_x_coordinates();
            void decompose();
            void detach_aft(T max_x);
            void detach_bow(T min_x);
            void sculpt_main();
            void sculpt_aft();
            void sculpt_bow();
            std::string frame_string() const;

        };

        template <class T>
        inline std::istream&
        operator>>(std::istream& in, Vessel<T>& rhs) {
            rhs.read(in);
            return in;
        }

    }

}

#endif // vim:filetype=cpp