modularization/src/tool/map_lanetoxodr/mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>

#include "myview.h"

#include "gps_type.h"

#include <iostream>
#include <fstream>

#include <QLineEdit>
#include <QPushButton>
#include <QLabel>
#include <QGroupBox>
#include <QGridLayout>
#include <QTabWidget>
#include <QFileDialog>
#include <QProgressBar>
#include <QSlider>
#include <QComboBox>
#include <QDateTime>
#include <QMessageBox>
#include <QCheckBox>

#include <QSlider>

#include <QMutex>

//#include "linedata.h"

//#include "ttx.pb.h"

#include "OpenDrive/OpenDrive.h"
#include "OpenDrive/OpenDriveXmlWriter.h"

#include "OpenDrive/OpenDriveXmlParser.h"

#ifdef INPILOT

#include "modulecomm.h"

#endif

#include "geofit.h"
#include "autoconnect.h"
#include "speeddialog.h"
#include "trafficlightdialog.h"
#include "roadeditdialog.h"
#include "dialogaddroadfromrtk.h"
#include "dialogcalcs.h"
#include "dialogroadborrow.h"
#include "dialoghideroad.h"
#include "dialogdrawroad.h"
#include "dialogroadnoavoid.h"
#include "dialogaddroadfromnds.h"
#include "dialogaddroadfromcda.h"
#include "dialogroadpriority.h"

#include "filebackup.h"

#include <iostream>
#include <map>
#include <math.h>

#include <vector>
#include <map>
#include <Eigen/Core>
#include <Eigen/QR>

// inlcude iostream and string libraries
#include <iostream>
#include <fstream>
#include <string>

using namespace std;
using namespace Eigen;

#include "rawtype.h"

#include "xodrmake.h"

#include "roaddigit.h"

#include "xodrscenfunc.h"
#include "autoroadcontact.h"

#include "createextendroad.h"

#include "excelapi.h"
#include "cdaproc.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

private:
    Ui::MainWindow *ui;

    QImage *image;
    QPainter *painter;
    MyView *myview;
    QTimer *timer;
    QGraphicsScene *scene;

    QGraphicsScene * mpscene;


public:
    static void ComboToString(std::string strroadid,QComboBox * pCB);

signals:
    void CurrentPosition(double x,double y);
    void CurrentRoadChange(int nroadid);

public:
     void resizeEvent(QResizeEvent *event);

private:
     void AdjustWPos(QSize sizemain);
     void ExecPainter();

private slots:
    virtual void paintEvent(QPaintEvent *);
    void onTimer();

    void onClickXY(double x,double y);

    void onChangeScale(int scale);
    void onChangeMoveX(int scale);
    void onChangeMoveY(int scale);
    void onChangeMark(int scale);

    void onClickDefView();
    void onClickZoomOne();

    void onClickAsStart();
    void onClickAsDst();
    void onClickSetDst();
    void onClickPlan();
    void onClickSetStart();

    void onClickLoadLane();
    void onClickRemoveLane();
    void onClickMarkLane();
    void onClickToRoad();
    void onClickToOpposite();
    void onClickClearRoadLane();
    void onClickAddRoad();
    void onClickRoadContact();
    void onClickAutoRoadContact();

    void onClickLoad();
    void onClickSave();
    void onClickLaneContact();
    void onClickOpLaneContact();
    void onClickClearLaneContact();
    void onClickCreateRoad();
    void onChangeRoadType(int index);

    void onClickRoadDel();
    void onClickRoadMark();

    void onClickCBRoadChange(int index);

    void onClickCBJunctionChange(int index);

    void onClickCBJunctionConnectionChange(int index);

    void onClickCBJunctionIncommingChange(int index);
    void onClickCBJunctionConnectionroadChange(int index);

    void onClickCreateJunction();
    void onClickCreateJunctionLaneLink();
    void onClickDeleteJunctionLaneLink();
    void onClickPreNxtRoadChange(int index);

    void onClickSetRoadPredecessor();
    void onClickSetRoadSuccessor();
    void onClickDelRoadPredecessor();
    void onClickDelRoadSuccessor();

    void onClickAutoConnect();

    void onClickSetMove();
    void onClickReSetMove();


    void on_actionLoad_triggered();

    void on_actionSave_triggered();

    void on_actionAutoConnect_triggered();

    void on_actionSet_Speed_triggered();

    void closeEvent(QCloseEvent * event);

    void on_actionSet_Traffic_Light_triggered();

    void on_actionEdit_Road_Lane_triggered();

    void on_actionEdit_Road_triggered();

    void on_actionAdd_Road_From_RTK_triggered();

    void on_actionSummary_Road_triggered();

    void on_actionSplit_Road_triggered();

    void onViewModeChange(int index);

    void on_actionCalc_Road_S_triggered();

    void on_actionBack_triggered();

    void on_actionEdit_Road_Borrow_triggered();

    void on_actionMake_All_Road_Contact_triggered();

    void on_actionHide_Road_triggered();

    void on_actionHide_Selected_triggered();

    void on_actionDraw_Road_triggered();

    void onDrawNewRoad();

    void on_actionEdit_Road_Noavoid_triggered();

    void on_actionAdd_Road_From_NDS_triggered();

    void on_CreateBefore_triggered();

    void on_CreateAfter_triggered();

    void on_actionAdd_Road_From_CDA_triggered();

    void on_actionDraw_Road_From_CDA_triggered();

    void on_actionAdd_Roads_From_Labels_triggered();

    void on_actionEdit_Road_Priority_triggered();

    void on_actionExport_Current_Road_triggered();

    void on_actionOptimize_Road_triggered();

    void on_actionAdd_ParkSpace_triggered();

private:


private:


    QGroupBox * mgpright;
    QScrollArea * mgpScroll;

    void CreateRightView(QGroupBox * pGroup);

    QTabWidget * mTabMain;
    void CreateTab1View(QTabWidget * p);

    QLineEdit * mpLEMarkPoint;

    int mnMarkPoint = 100;

    QLineEdit * mpLEPointData[3];
    QLineEdit * mpLELineStart,* mpLELineEnd;

    QLineEdit * mpLESampleDis;

    QLineEdit * mpLEMarkGeo;
    QLineEdit * mpLEGeo[9];
    QLineEdit * mpLEMarkGeo_Slider_u;
    QLineEdit * mpLEMarkGeo_Slider_v;
    QSlider * mpSLMarkGeo_u;
    QSlider * mpSLMarkGeo_v;

    QLineEdit * mpLEOff;
    QLineEdit * mpLECurvature;


    int  mnfac = 1;
    double mfSampleDis = 1.0;

    double mClickX,mClickY;
    bool mbClick = false;

    double mfObjX,mfObjY;
    bool mbSetObj = false;

    double mfManualX,mfManualY,mfManualHdg;
    double mfNowX,mfNowY,mfNowHdg;
    bool mbGPSUpdate = true;
    bool mbSetManualStart = false;
    bool mbGPSViewUpdate = false;

    QLineEdit * mpLEConGeoStart, * mpLEConGeoEnd;

    QLineEdit * mpLEConGeo_Slider_u;
    QLineEdit * mpLEConGeo_Slider_v;
    QSlider * mpSLConGeo_u;
    QSlider * mpSLConGeo_v;

//    QLineEdit * mpLERoadName;
//    QComboBox * mpCBRoad;
//    QComboBox * mpCBGeo;

    QLineEdit * mpLERoadGeo;

    QLineEdit * mpLELat0,* mpLELon0,* mpLEHead0;

    QComboBox * mpCBLane;

    QComboBox * mpCBSelLane , *mpCBSelOpLane;

    QComboBox * mpCBRoad;

    QComboBox * mpCBRoad1, * mpCBRC1, * mpCBRoad2, * mpCBRC2;

    QComboBox * mpCBRoadCon;

    QComboBox * mpCBLane1, * mpCBLane2 , * mpCBLane1Lane2, * mpCBLane1Lane2op;

    QComboBox * mpCBRoadType;

    QLineEdit * mpLERoadType;

    QLabel * mpLBRoadType;

    QCheckBox * mpCBStraightType;

    double mx0,my0;

    OpenDrive mxodr;

    bool mbRefresh = true;
    bool mbInit = false;

    QLineEdit *  mpLE_SelX, * mpLE_SelY, * mpLE_SelLat, * mpLE_SelLon;

    QCheckBox * mpCheckFromSel, * mpCheckToSel;

    QComboBox * mpCBViewMode;

    DialogDrawRoad * mpdlgdraw;

 //   QLineEdit * mpLE_StartLat, * mpLE_StartLon, * mpLE_StartHeading;

//    QLineEdit * mpLE_EndLat, * mpLE_EndLon;

    int mnFontHeight;

    int mnMoveX;
    int mnMoveY;

    double mfViewMoveX = 0;
    double mfViewMoveY = 0;

    int mnMarkSize = 5;

    int mnDefmnfac,mnDefMoveX,mnDefMoveY;

    QSlider * mpSlider_Scale, * mpSlider_MoveX, * mpSlider_MoveY;
    QSlider * mpSlider_Mark;
    QLineEdit * mpLE_Scale, * mpLE_MoveX, * mpLE_MoveY, * mpLE_Mark;

    QLineEdit * mpLE_CurLon,*mpLE_CurLat,* mpLE_CurHeading;
    QLineEdit * mpLE_DstLon,* mpLE_DstLat;
    QLineEdit * mpLE_LaneSel;
    QLineEdit * mpLE_StartLon,* mpLE_StartLat,*mpLE_StartHeading;

    QLineEdit * mpLE_RoadName;

    QLabel * mpLabelRoadShowPreType1,* mpLabelRoadShowPreType2,* mpLabelRoadShowPreID;
    QLabel * mpLabelRoadShowNxtType1,* mpLabelRoadShowNxtType2,* mpLabelRoadShowNxtID;
    QComboBox * mpCBRoadShowPre, * mpCBRoadShowNext;

    QComboBox * mpCBJunctionIncommingRoad,  * mpCBJunctionConnectingRoad;
    QComboBox * mpCBJunctionContactPoint;
    QComboBox * mpCBJunctionFromLane, * mpCBJunctionToLane;
    QComboBox * mpCBJunction, * mpCBJunctionConnection;

    QLabel * mpLabelJunctionIncommingRoad, * mpLabelJunctionConnectingRoad;
    QLabel * mpLabelJunctionContactPoint;
    QComboBox * mpCBJunctionFromTo;

    QComboBox  * mpCBPreNxtRoad, * mpCBPreNxtRelLane, * mpCBPreNxtConatact;

    QLabel * mpLabel_Status;

    QLineEdit * mpLEViewMoveX, * mpLEViewMoveY;


    void * mpasrc,*mpadst,*mpatrace;



    QMutex mMutexNavi;
    std::vector<iv::GPSData> m_navigation_data;


    void *    mpagpsimu;

public:
    int CreateRoadID(int ntype = 0); //Create Road ID for new road. default:road  1:not create by lane road.

    static double getoff(Road * p,int nlane,bool bstart = true);
    double getlanewidth(Road * p,int nlane,bool bstart = true);
    std::string getlanetype(Road * p,int nlane,bool bstart = true);

    bool IsHidenRoad(int nroadid);
    void SaveBack();

private:
    void UpdateMap(const char * strdata,const unsigned int nSize,const unsigned int index,const QDateTime * dt,const char * strmemname);
    void UpdateGPSIMU(const char * strdata,const unsigned int nSize,const unsigned int index,const QDateTime * dt,const char * strmemname);

    std::vector<iv::lpunit> mvectorlp;
    std::vector<int> mvectorroadlane;
    std::vector<int> mvectorroadopposite;

    std::vector<iv::roadcontact> mvectorrc;

    bool mbSetOrigin = false;

    int mnRoadIndex = 10001;

    bool mbShowLane = true;
    bool mbShowXODR = true;

    int mnMarkLane = -1;


//    OpenDrive mxodr;
    Road CreateRoad(Eigen::VectorXd xvals, Eigen::VectorXd yvals);


    int CreateJunctionID();

    int GetEndPoint(Road * proad,double & x, double & y, double & hdg);

    std::vector<geobase> CreateLineGeo(double startx,double starty,double starthdg,double endx,double endy,double endhdg);
    std::vector<geobase> CreateTurnGeo(double startx,double starty,double starthdg,double endx,double endy,double endhdg,double R);
    std::vector<geobase> CreateUTurnGeo(double startx,double starty,double starthdg,double endx,double endy,double endhdg,double fextend);




    void ChangeXODRRoadID(OpenDrive * pxodr,int index,int newid);
    void ChangeXODRJunctionID(OpenDrive * pxodr,int index,int newid);
    void MoveXODR(OpenDrive * pxodr,double movex,double movey);

    int FindNewRoadID(OpenDrive * pxodr1,OpenDrive * pxodr2);
    int FindNewJunctionID(OpenDrive * pxodr1,OpenDrive * pxodr2);


    void updateCBRoad();
    void updateJunction();

    int mnViewMode = 0; //Use Scene

    void UpdateScene();
    void UpdateScene_SelectRoadRefGeo();

    std::vector<QGraphicsPathItem *> mvectorviewitem;
    std::vector<QGraphicsPathItem *> mvectorgeoitem;

    std::vector<OpenDrive> mvectorxodrback;



    FileBackup * mpfb;

    int mnNotSave = 0;

    std::vector<int> mvectorhideroadid;

    bool mbHideSelected = false;


};

#endif // MAINWINDOW_H