HullData.h

#ifndef CHullData_h__
#define CHullData_h__
 
#include <limits>
#include <vector>
#include <map>
#include <assert.h>
 
#include <Eigen/Eigen>
 
#include "Section.h"
 
namespace Ship{
    class HullData
    {
    public:
        EIGEN_MAKE_ALIGNED_OPERATOR_NEW
        struct Point
        {
            Point( double _x,double _y, double _z )
            {
                x = _x;
                y = _y;
                z = _z;
            }
    
            Point( const Point &P )
            {
                x = P.x;
                y = P.y;
                z = P.z;
            }
    
            Point(  )
            {
                x = 0;
                y = 0;
                z = 0;
            }
    
            double x;
            double y;
            double z;
    
            double nx;
            double ny;
            double nz;
    
            bool operator ==( const Point &rhs)
            {
                return (this->x == rhs.x) && (this->y == rhs.y) && (this->z == rhs.z);
            }
    
            static bool CompareDraught( const struct Point &lhs, const struct Point &rhs )
            {
                return lhs.z < rhs.z;
            }
        };
    
        
        struct MainDimensions
        {
            double Lpp = std::numeric_limits<double>::quiet_NaN();  // NaN until read from the file
            double T = std::numeric_limits<double>::quiet_NaN();
            double B = std::numeric_limits<double>::quiet_NaN();
            double Sink = std::numeric_limits<double>::quiet_NaN();
            double Trim = std::numeric_limits<double>::quiet_NaN();
            double Disp = std::numeric_limits<double>::quiet_NaN();
            double VCB = std::numeric_limits<double>::quiet_NaN();
            double VCG = std::numeric_limits<double>::quiet_NaN();
            double LCB = std::numeric_limits<double>::quiet_NaN();
            double LCG = std::numeric_limits<double>::quiet_NaN();
            double Cb = std::numeric_limits<double>::quiet_NaN();
            double GMt = std::numeric_limits<double>::quiet_NaN();
            double GMl = std::numeric_limits<double>::quiet_NaN();
        };
    
        struct HullFace
        {
            std::vector<Eigen::Vector3d> Vertices;
            Eigen::Vector3d     Normal;
            Eigen::Vector3d     Center;
            Eigen::Vector3d     BodyPressure;
            Eigen::Vector3d     NEDPressure;        
            double              Pressure;
            double              Area;
    
        };
    
        struct HullGeometry
        {
            std::vector<Eigen::Vector3d>    Vertices;
            std::vector<Eigen::Vector3d>    Normals;
            std::vector<Eigen::Vector3d>    Color;
            std::vector<int>                VertexStation;
            std::vector< HullFace > Faces;
        };
    
        HullData( std::string &fname );
        virtual ~HullData() {}
 
        void SetPosition( double n, double e, double d)
        {
            r(0) = n;
            r(1) = e;
            r(2) = d;
        }
    
        void SetPosition(const  Eigen::Vector3d &vec )
        {
            SetPosition(vec(0),vec(1),vec(2));
        }
    
        void SetRotation( const Eigen::Quaterniond &q)
        {
            this->q = q;
        }
    
        void SetRotation( double w, double x, double y, double z)
        {
            q =  Eigen::Quaterniond(w,x,y,z);
        }
    
        virtual void ReadHullGeometry( std::string& fname )=0;
        virtual void ReadWaterLine( std::string& fname )=0;
    
        void CalculateHullSectionData();
    
        void            AddStation(         const std::vector<double> &  x, const std::vector<double> &  y,const std::vector<double> &  z );
        void            GetStation(         int StationNr,  std::vector<Eigen::Vector3d> &Out);
        double          GetStationArea(     int SectionNr );
        double          GetStationArea(     int SectionNr, double T);
        double          GetStationDraught(  int SectionNr, double T);
        double          GetStationMaxBredth(int SectionNr, double T);
        double          GetStationBredth(   int SectionNr, double T);
        unsigned int    GetNumberOfStations();
        int             GetStationNr(       double DistanceFromZeroStation );
        double          GetStationPosition( int SectionNr );
        void            GetStationLewisData(int SectionNr, double B, double T, double &LewisA1, double &LewisA3, double &LewisScaleFactor );
        int             GetStationSkegPoint( int SectionNr);
    
        double  GetStationInstentaneousDraught( int SecitonNr );
        void    GetVertexGlobalPosition( int vertex, Eigen::Vector3d &vertexpos );
        //void  MakeHull();
        void    MakeHull2();
    
        void AddToHull( std::vector<Eigen::Vector3d> &side1, std::vector<Eigen::Vector3d> side2 , bool mirror = true);
    
        void    SetInterpolationParameters(double HullTop,double HullBottom,double VerticalStep,double HorizontalStep);
    
        virtual double GetParam(std::string p );
    
        struct MainDimensions Main;
        struct HullGeometry Geomtery;
    
    protected:
    
        Eigen::Vector3d r;
        Eigen::Quaterniond q;
    
        double HullBottom;
        double HullTop;
        double HullVerticalStep;
        double HullHorizontalStep;
    
        static bool CompareSections( struct Section const &lhs, struct Section const &rhs );
        
        std::vector< struct Section > Sections;
        std::map<std::string,double> param;
    
    };
}
#endif // CHullData_h__