modularization/src/common/common/xodr/OpenDrive/ObjectSignal.h

#ifndef OBJECTSIGNAL_H
#define OBJECTSIGNAL_H

#include <vector>
#include <string>

using std::vector;
using std::string;

class Object_outlines_outline
{
private:
    vector<int> mid;
    vector<string> mfillType;
    vector<bool> mouter;
    vector<bool> mclosed;
    vector<string> mlaneTYpe;
public:
    Object_outlines_outline();
};

class Object_outlines
{
private:
    vector<Object_outlines_outline> moutline;

public:
    Object_outlines();
};

class Object_material
{
private:
    vector<string> msurface;
    vector<double> mfriction;
    vector<double> mroughness;

public:
    Object_material();

    int Getsurface(string & surface);
    int Getfriction(double & friction);
    int Getroughness(double & roughness);

    void Setsurface(string surface);
    void Setfriction(double friction);
    void Setroughness(double roughness);
};

class Object_repeat
{
private:
    double ms;
    double mlength;
    double mdistance;
    double mtStart;
    double mtEnd;
    double mheightStart;
    double mheightEnd;
    double mzOffsetStart;
    double mzOffsetEnd;
    vector<double> mwidthStart;
    vector<double> mwidthEnd;
    vector<double> mlengthStart;
    vector<double> mlengthEnd;
    vector<double> mradiusStart;
    vector<double> mradiusEnd;

public:
    Object_repeat(double s,double length,double distance,double tStart,double tEnd,double heightStart,
                  double heightEnd,double zOffsetStart,double zOffsetEnd);

    double Gets();
    double Getlength();
    double Getdistance();
    double GettStart();
    double GettEnd();
    double GetheightStart();
    double GetheightEnd();
    double GetzOffsetStart();
    double GetzOffsetEnd();


    void Sets(double s);
    void Setlength(double length);
    void Setdistance(double distance);
    void SettStart(double tStart);
    void SettEnd(double tEnd);
    void SetheightStart(double heightStart);
    void SetheightEnd(double heightEnd);
    void SetzOffsetStart(double zOffsetStart);
    void SetzOffsetEnd(double zOffsetEnd);


    int GetwidthStart(double & widthStart);
    int GetwidthEnd(double & widthEnd);
    int GetlengthStart(double & lengthStart);
    int GetlengthEnd(double & lengthEnd);
    int GetradiusStart(double & radiusStart);
    int GetradiusEnd(double & radiusEnd);

    void DeletewidthStart();
    void DeletewidthEnd();
    void DeletelengthStart();
    void DeletelengthEnd();
    void DeleteradiusStart();
    void DeleteradiusEnd();

    void SetwidthStart(double  widthStart);
    void SetwidthEnd(double  widthEnd);
    void SetlengthStart(double  lengthStart);
    void SetlengthEnd(double  lengthEnd);
    void SetradiusStart(double  radiusStart);
    void SetradiusEnd(double  radiusEnd);

    bool CheckInterval(double s_check);


};

class Object_parkingSpace
{
private:
    string maccess;
    string mrestrictions;

public:
    Object_parkingSpace();

    void Setaccess(string access);
    void Setrestrictions(string restrictions);

    string Getaccess();
    string Getrestrictions();

    /**
     * Copy constructor
     */
    Object_parkingSpace (const Object_parkingSpace& parkingSpace);

    /**
     * Assignment operator overload
     */
    const Object_parkingSpace& operator=(const Object_parkingSpace& rhs);
};

//***********************************************************************************
//Object
//***********************************************************************************
class Object
{
private:
    double mt;
    double mzOffset;
    string mtype;
    vector<double> mvalidLength;
    string morientation;
    string msubtype;
    string mdynamic;
    vector<double> mhdg;
    string mname;
    vector<double> mpitch;
    string mid;
    vector<double> mroll;
    vector<double> mheight;
    double ms;
    vector<double> mlength;
    vector<double> mwidth;
    vector<double> mradius;

    vector<Object_parkingSpace> mObject_parkingSpace;
    vector<Object_repeat> mObject_repeat;
    vector<Object_material> mObject_material;

    unsigned int mLastAddedObjectrepeat;
    unsigned int mLastAddedObjectmaterial;

public:

    Object(string id,double s,double t, double zOffset);

    double Gett();
    double GetzOffset();
    string Gettype();
    int GetvalidLength(double & validLength);
    string Getorientation();
    string Getsubtype();
    string Getdynamic();
    int Gethdg(double & hdg);
    string Getname();
    int Getpitch(double & pitch);
    string Getid();
    int Getroll(double & roll);
    int Getheight(double & height);
    double Gets();
    int Getlength(double & length);
    int Getwidth(double & width);
    int Getradius(double & radius);

    int GetparkingSpace(Object_parkingSpace & parkingSpace);

    void Sett(double t);
    void SetzOffset(double zOffset);
    void Settype(string type);
    void SetvalidLength(double  validLength);
    void Setorientation(string orientation);
    void Setsubtype(string subtype);
    void Setdynamic(string dynamic);
    void Sethdg(double  hdg);
    void Setname(string name);
    void Setpitch(double pitch);
    void Setid(string id);
    void Setroll(double  roll);
    void Setheight(double height);
    void Sets(double s);
    void Setlength(double length);
    void Setwidth(double width);
    void Setradius(double radius);

    void SetparkingSpace(Object_parkingSpace parkingSpace);

    vector<Object_repeat> * GetObjectrepeatVector();
    Object_repeat* GetObjectrepeat(unsigned int i);
    unsigned int GetObjectrepeatCount();
    Object_repeat*			GetLastObjectrepeat();
    Object_repeat*			GetLastAddedObjectrepeat();
    unsigned int AddObjectrepeat(double s,double length,double distance,double tStart,double tEnd,
                                 double heightStart,double heightEnd,double zOffsetStart,double zOffsetEnd);
    unsigned int CloneObjectrepeat(unsigned int index);
    void DeleteObjectrepeat(unsigned int index);
    int CheckObjectrepeatInterval(double s_check);

    vector<Object_material> * GetObjectmaterialVector();
    Object_material* GetObjectmaterial(unsigned int i);
    unsigned int GetObjectmaterialCount();
    Object_material*			GetLastObjectmaterial();
    Object_material*			GetLastAddedObjectmaterial();
    unsigned int AddObjectmaterial();
    unsigned int CloneObjectmaterial(unsigned int index);
    void DeleteObjectmaterial(unsigned int index);
};
//----------------------------------------------------------------------------------



class signal_positionRoad
{
private:
    double ms;
    double mt;
    double mzOffset;
    double mhOffset;
    double mpitch;
    double mroll;
public:
    signal_positionRoad(double s,double t,double zOffset,double hOffset, double pitch,double roll);
    double Gets();
    double Gett();
    double GetzOffset();
    double GethOffset();
    double Getpitch();
    double Getroll();
    void Sets(double s);
    void Sett(double t);
    void SetzOffset(double zOffset);
    void SethOffset(double hOffset);
    void Setpitch(double pitch);
    void Setroll(double roll);
};

class signal_positionInertial
{
private:
    double mx;
    double my;
    double mz;
    double mhdg;
    double mpitch;
    double mroll;
public:
    signal_positionInertial(double x,double y,double z,double hdg,double pitch,double roll );
    double Getx();
    double Gety();
    double Getz();
    double Gethdg();
    double Getpitch();
    double Getroll();
    void Setx(double x);
    void Sety(double y);
    void Setz(double z);
    void Sethdg(double hdg);
    void Setpitch(double pitch);
    void Setroll(double roll);
};

class signal_laneValidity
{
private:
    int mfromLane;
    int mtoLane;
public:
    signal_laneValidity(int fromLane,int toLane);
    int GetfromLane();
    int GettoLane();
    void SetfromLane(int fromLane);
    void SettoLane(int toLane);
};


//***********************************************************************************
//Signal
//***********************************************************************************
class Signal
{
private:
    double ms;
    double mt;
    string mid;
    string mname;
    bool mdynamic;
    string morientation;
    double mzOffset;
    string mtype;
    string mcountry;
    string mcountryRevision;
    string msubtype;
    double mhOffset;
    double mpitch;
    double mroll;
    double mheight;
    double mwidth;
    signal_positionRoad * mpsignal_positionRoad;
    signal_positionInertial * mpsignal_positionInertial;
    signal_laneValidity * mpsignal_laneValidity;
public:
    Signal(double s,double t,string id,string name,bool dynamic,string orientation,double zOffset,string type,string country,string countryRevision,
           string subtype,double hOffset,double pitch,double roll ,double height,double width);
    Signal();
    ~Signal();
    Signal& operator=(const Signal& x);
    Signal(const Signal & x);
    double Gets();
    double Gett();
    string Getid();
    string Getname();
    bool Getdynamic();
    string Getorientation();
    double GetzOffset();
    string Gettype();
    string Getcountry();
    string GetcountryRevision();
    string Getsubtype();
    double GethOffset();
    double Getpitch();
    double Getroll();
    double Getheight();
    double Getwidth();
    signal_positionRoad * GetpositionRoad();
    signal_positionInertial * GetpositionInertial();
    signal_laneValidity * GetlaneValidity();
    void Sets(double s);
    void Sett(double t);
    void Setid(string id);
    void Setname(string name);
    void Setdynamic(bool dynamic);
    void Setorientation(string orientation);
    void SetzOffset(double zOffset);
    void Settype(string type);
    void Setcountry(string country);
    void SetcountryRevision(string countryRevision);
    void Setsubtype(string subtype);
    void SethOffset(double hOffset);
    void Setpitch(double pitch);
    void Setroll(double roll);
    void Setheight(double height);
    void Setwidth(double width);
    void SetlaneValidity(int fromLane, int toLane);
    void SetpositionRoad(double s,double t, double zOffset,double hOffset,double pitch,double roll);
    void SetpositionInertial(double x,double y, double z, double hdg,double pitch,double roll);


};
//----------------------------------------------------------------------------------


#endif