modularization/src/ui/ADCIntelligentShow_grpc/adcintelligentshow.cpp

#include "adcintelligentshow.h"
#include "ui_adcintelligentshow.h"

#include <QSound>
#include <QtMath>


#include "pos_def.h"
extern std::vector<iv::pos_def> gvectorpos;

extern std::string gstrdefaultlane;

ADCIntelligentShow * gAShow;


#include "grpcclientthread.h"


#ifdef Android
    extern grpcclientthread * ggt;
#endif


const double PI = 3.1415926535898;

class xodrobj
{
public:
    double flatsrc;
    double flonsrc;
    double fhgdsrc;
    double flat;
    double flon;
    int lane;
};


void Listengpsimu(const char * strdata,const unsigned int nSize,const unsigned int index,const QDateTime * dt,const char * strmemname)
{
    (void)&index;
    (void)dt;
    (void)strmemname;
//        ggpsimu->UpdateGPSIMU(strdata,nSize);

    iv::gps::gpsimu xgpsimu;
    if(!xgpsimu.ParseFromArray(strdata,nSize))
    {
        std::cout<<"ListenRaw Parse error."<<std::endl;
        return;
    }
    gAShow->UpdateGPSIMU(&xgpsimu);
//        qDebug(" gps time is %ld",QDateTime::currentMSecsSinceEpoch());

}


void ListenOBS(const char * strdata,const unsigned int nSize,const unsigned int index,const QDateTime * dt,const char * strmemname)
{
    (void)&index;
    (void)dt;
    (void)strmemname;

    std::shared_ptr<std::vector<iv::ObstacleBasic>> lidar_obs(new std::vector<iv::ObstacleBasic>);


    iv::ObstacleBasic * pdata = (iv::ObstacleBasic *)strdata;
    int nCount = nSize/sizeof(iv::ObstacleBasic);
    int i;
    for(i=0;i<nCount;i++)
    {
        iv::ObstacleBasic temp;
        memcpy(&temp,pdata,sizeof(iv::ObstacleBasic));
        lidar_obs->push_back(temp);
        pdata++;
    }
    gAShow->UpdateOBS(lidar_obs);

  //  gw->UpdateOBS(lidar_obs);
}

void ListenRadar(const char * strdata,const unsigned int nSize,const unsigned int index,const QDateTime * dt,const char * strmemname)
{
    (void)&index;
    (void)dt;
    (void)strmemname;

    if(nSize<1)return;
    iv::radar::radarobjectarray xobj;

    if(false == xobj.ParseFromArray(strdata,nSize))
    {
        std::cout<<"ListenenRadar fail."<<std::endl;
        return;
    }
    gAShow->UpdateRADAR(&xobj);
}

void ListenDection(const char * strdata,const unsigned int nSize,const unsigned int index,const QDateTime * dt,const char * strmemname)
{
    (void)&index;
    (void)dt;
    (void)strmemname;
    iv::brain::decition xdecision;
    if(!xdecision.ParseFromArray(strdata,nSize))
    {
        std::cout<<" ListenDection error.  Parse error."<<std::endl;
        return;
    }

   gAShow->UpdateDection(xdecision);
}

void ListenBrainState(const char * strdata,const unsigned int nSize,const unsigned int index,const QDateTime * dt,const char * strmemname)
{
    (void)&index;
    (void)dt;
    (void)strmemname;
    iv::brain::brainstate xbrainstate;
    if(!xbrainstate.ParseFromArray(strdata,nSize))
    {
        std::cout<<"ListenBrainState Parse error."<<std::endl;
        return;
    }
    gAShow->UpdateBrainState(xbrainstate);
}

void ListenTraceMap(const char * strdata,const unsigned int nSize,const unsigned int index,const QDateTime * dt,const char * strmemname)
{
    (void)&index;
    (void)dt;
    (void)strmemname;
    gAShow->UpdateMap(strdata,nSize);
}

#ifdef Android
    void ADCIntelligentShow::AndroidSetMsg(const char * msgname , const char *strdata, const unsigned int nDataLen)
    {
        if(strncmp(msgname,"hcp2_gpsimu",256) == 0)
        {
            Listengpsimu(strdata,nDataLen,0,0,0);
        }
        if(strncmp(msgname,"tracemap",256) == 0)
        {
            ListenTraceMap(strdata,nDataLen,0,0,0);
        }
        if(strncmp(msgname,"lidar_obs",256) == 0)
        {
            ListenOBS(strdata,nDataLen,0,0,0);
        }
        if(strncmp(msgname,"brainstate",256) == 0)
        {
            ListenBrainState(strdata,nDataLen,0,0,0);
        }
        if(strncmp(msgname,"deciton",256) == 0)
        {
            ListenDection(strdata,nDataLen,0,0,0);
        }
        if(strncmp(msgname,"radar",256) == 0)
        {
            ListenRadar(strdata,nDataLen,0,0,0);
        }
    }
#endif

ADCIntelligentShow::ADCIntelligentShow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::ADCIntelligentShow)
{
    gAShow = this;
    ui->setupUi(this);
    ui->pushButton->setEnabled(false);


    //样式 3-26
    qApp->setStyleSheet("QPushButton#pushButton_2\n{\nborder-image: url(:/new/pic/restart1.png);\n}"
                        "QPushButton#pushButton_2:hover\n{border-image: url(:/new/pic/restart4.png);\n}"
                        "QPushButton#pushButton_2:pressed\n{ border-image: url(:/new/pic/restart3.png); \n}"
                        "QPushButton#park:pressed\n{border-image: url(:/new/pic/park_press.png);\n}"
                        "QPushButton#pushButton_Setting\n{ border-image: url(:/new/pic/setting.png); \n}"
                        "QPushButton#pushButton_Setting:pressed\n{ border-image: url(:/new/pic/setting2.png); \n}"
                        "QCheckBox#checkBox::indicator\n{width: 110px;height: 110px;\n}"
                        "QCheckBox#checkBox::indicator:unchecked\n{ border-image:url(:/new/pic/call_gray1.png);\n}"
                        "QCheckBox#checkBox::indicator:checked\n{ border-image:url(:/new/pic/call1.png);\n}"
                        "QCheckBox#checkBox_2::indicator\n{width: 110px;height: 110px;\n}"
                        "QCheckBox#checkBox_2::indicator:unchecked\n{ border-image:url(:/new/pic/mulcar_gray.png);\n}"
                        "QCheckBox#checkBox_2::indicator:checked\n{ border-image:url(:/new/pic/mulcar.png);\n}");


    QDesktopWidget *desktopWidget = QApplication::desktop();
    QRect screenRect = desktopWidget->screenGeometry();
    resize(screenRect.width(),screenRect.height());
    loadMapFromFile("map.txt");


    image = new QImage(900*2,900*2,QImage::Format_RGB32);
    painter = new QPainter(image);
    myview = new MyView(ui->widget_2);
    myview->setObjectName("graphicsView");
    myview->setGeometry(QRect(100,20,900,1000));

    myview->setCacheMode(myview->CacheBackground);

    scene = new QGraphicsScene;
    myview->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    myview->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    DataUI = new DataToUI;

    socket = new QUdpSocket;
    socket->bind(9999,QUdpSocket::ShareAddress);
 //   connect(socket,SIGNAL(readyRead()),this,SLOT(onRecv()));

    lidarsock = new QUdpSocket;
    lidarsock->bind(9997);
 //   connect(lidarsock,SIGNAL(readyRead()),this,SLOT(onlidarRecv()));


    mbHaveData = false;
    recvFlag = 0;
    connect(&mTimer,SIGNAL(timeout()),this,SLOT(onTimer()));
//    mTimer.start(500);
    connect(&connTimer,SIGNAL(timeout()),this,SLOT(onconnTimer()));
    connTimer.start(1000);
    for(int i = 0;i<128;i++)
    {
        DataUI->mInfo.point[i] = 0.0;
    }
    mlidarpoint.lidar_size = 0;
    for(int i=0;i<10000;i++)
    {
        mlidarpoint.lidar_point[i] = 0.0;
    }
    //DataUI->mInfo.lidar_size = 0;

    ///added by kkcai, 2019-11-28
//    ui->label_3->hide();
//    ui->label_4->hide();
    ///////////////////////////////////////////////////////////////////////////

    ///added by kkcai, 2019-12-02
    soundAlarm = new QSound(":/new/pic/alarm.wav");
    connect(this, SIGNAL(sigAlarm()), this, SLOT(slotAlarm()));
#ifndef Android

    void * pa;
    pa = iv::modulecomm::RegisterRecv("hcp2_gpsimu",Listengpsimu);
    mpagps = pa;
    pa = iv::modulecomm::RegisterRecv("tracemap",ListenTraceMap);
    mpatracemap = pa;
    pa = iv::modulecomm::RegisterRecv("lidar_obs",ListenOBS);
    mpalidarobs = pa;
    pa = iv::modulecomm::RegisterRecv("brainstate",ListenBrainState);
    mpabrainstate = pa;
    pa = iv::modulecomm::RegisterRecv("deciton",ListenDection);
    mpadecision = pa;
    pa = iv::modulecomm::RegisterRecv("radar",ListenRadar);
    mparadar = pa;

    mpadst = iv::modulecomm::RegisterSend("xodrreq",1000,1);



    mpapad = iv::modulecomm::RegisterSend("pad",1000,1);

    mndefaultlane = atoi(gstrdefaultlane.data());


#endif

    connect(this,SIGNAL(signalGPSIMU()),this,SLOT(onUpdateGPSIMU()));
    connect(this,SIGNAL(signalbrainstate()),this,SLOT(onUpdateBrainState()));
    connect(this,SIGNAL(signaldection()),this,SLOT(onUpdateDection()));


    mpivmapview = new ivmapview();
    mpivmapview->start();

    QTimer * timerpainter = new QTimer(this);
    connect(timerpainter,SIGNAL(timeout()),this,SLOT(onTimerPainter()));
    timerpainter->start(100);

    ui->pushButton_go->setStyleSheet("background: green; color: white;");
    ui->pushButton_prestation->setStyleSheet("background: green; color: white;");
    ui->pushButton_nextstation->setStyleSheet("background: green; color: white;");
    ui->label_station->setStyleSheet("background: transparent; color: white;font: 15pt 'Arial';");
    ui->label_station->setText("");



    if(gvectorpos.size()>0)
    {
        mnStationIndex = 0;
        ui->label_station->setText(gvectorpos[0].mstrstationname.data());
    }

    mpDS = new DialogSetting(this);
    connect(mpDS,SIGNAL(signalswith(int)),this,SLOT(onSwitchClick(int)));
    connect(mpDS,SIGNAL(signalMode(int)),this,SLOT(onModeClick(int)));
//    ui->pushButton_go->setStyleSheet("color: red");

    ///////////////////////////////////////////////////////////////////////

    ///added by kkcai, 2019-12-02
//    ui->checkBox->hide();
//    ui->checkBox_2->hide();
//    ui->park->hide();
    ///////////////////////////////////////////////////////////////////////
}

ADCIntelligentShow::~ADCIntelligentShow()
{
    iv::modulecomm::Unregister(mpabrainstate);
    iv::modulecomm::Unregister(mpadecision);
    iv::modulecomm::Unregister(mpagps);
    iv::modulecomm::Unregister(mpalidarobs);
    iv::modulecomm::Unregister(mpapad);
    iv::modulecomm::Unregister(mparadar);
    iv::modulecomm::Unregister(mpatracemap);
    iv::modulecomm::Unregister(mpadst);
//    std::this_thread::sleep_for(std::chrono::milliseconds(50));
    delete ui;

    if(soundAlarm){
        delete soundAlarm;
        soundAlarm = nullptr;
    }
}

void ADCIntelligentShow::resizeEvent(QResizeEvent *event)
{
    (void)event;
    QSize sizemain = ui->centralWidget->size();
    ui->widget_2->setGeometry(730,0,sizemain.width()-730,sizemain.height()-0);
    myview->setGeometry(0,150,sizemain.width()-730-0,sizemain.height()-150);

#ifndef Android
    ui->pushButton_prestation->setGeometry(50,30,100,50);
    ui->label_station->setGeometry(160,30,200,50);
    ui->pushButton_nextstation->setGeometry(380,30,100,50);
    ui->pushButton_go->setGeometry(490,30,100,50);
#else

//    ui->pushButton_prestation->setGeometry(30,30,150,100);
//    ui->label_station->setGeometry(190,30,260,100);
//    ui->pushButton_nextstation->setGeometry(460,30,150,100);
//    ui->pushButton_go->setGeometry(630,30,150,100);


    ui->pushButton_prestation->setGeometry(50,30,200,100);
    ui->label_station->setGeometry(260,30,400,100);
    ui->pushButton_nextstation->setGeometry(680,30,200,100);
    ui->pushButton_go->setGeometry(990,30,200,100);
#endif

}

void ADCIntelligentShow::onTimer()
{
    if(!mbHaveData)
    {
        ui->pushButton->setEnabled(false);
    }

    mbHaveData = false;
    update();
}

void ADCIntelligentShow::on_pushButton_clicked()
{
    std::cout<<"click "<<std::endl;
    iv::hmi::hmimsg xhmi;
    xhmi.set_mbbochemode(false);
    xhmi.set_mbbusmode(false);
    if(mbRunning)
        xhmi.set_mbpause(true);
    else
        xhmi.set_mbpause(false);
    int nsize = xhmi.ByteSize();
    char * str = new char[nsize];
    if(xhmi.SerializeToArray(str,1000))
    {
#ifndef Android
        iv::modulecomm::ModuleSendMsg(mpapad,str,nsize);
#else
        ggt->UpdateData(str,nsize,"pad");
#endif

    }
    else
    {
        std::cout<<"ADCIntelligentShow::on_pushButton_clicked serialize error."<<std::endl;
    }
    delete str;
    QApplication::beep();
    return;
    if(DataUI->mInfo.is_run == 0x00)
    {
        int xRun = 1;
        socket->writeDatagram((char *)&xRun,4,QHostAddress::Broadcast,9998);
    }
    if(DataUI->mInfo.is_run == 0x01)
    {
        int xRun = 0;
        socket->writeDatagram((char *)&xRun,4,QHostAddress::Broadcast,9998);
    }
    QApplication::beep();

}

void ADCIntelligentShow::onRecv()
{

    while(socket->hasPendingDatagrams())
    {
        QByteArray data;
        data.resize(socket->pendingDatagramSize());
        socket->readDatagram(data.data(),data.size());
        recvFlag++;
        //        packageHead packHead;
        qDebug("size = %d",data.size());
        //if(data.size() == sizeof(DataToUI))
        //{
        memcpy(DataUI,data.data(),data.size());
        qDebug("size:%d",DataUI->mHead.size);
        ////////////////////////
        /// 程序状态/////////////
        ///////////////////////
        qDebug("speed:%g",DataUI->mInfo.speed);
        ui->label->setText(QString::number((DataUI->mInfo.speed),'f',1));
        if(DataUI->mInfo.is_mapLoad==0x01)
            ui->mapimg->setStyleSheet("background-image: url(:/new/pic/green.png);");
        else
            ui->mapimg->setStyleSheet("background-image: url(:/new/pic/red.png);");
        if(DataUI->mInfo.is_initSuccess==0x01)
            ui->canimg->setStyleSheet("background-image: url(:/new/pic/green.png);");
        else
            ui->canimg->setStyleSheet("background-image: url(:/new/pic/red.png);");
        ui->acc->setText(QString::number(DataUI->mInfo.accelerate,'f',1));
        ui->swerve->setText(QString::number(DataUI->mInfo.swerve,'f',1));
        ui->lng->setText(QString::number(DataUI->mInfo.gps_lng,'f',6));
        ui->lat->setText(QString::number(DataUI->mInfo.gps_lat,'f',6));
        ui->radarob->setText(QString::number(DataUI->mInfo.radarobs,'f',2));
        ui->lidarob->setText(QString::number(DataUI->mInfo.lidarobs,'f',2));
        ui->allob->setText(QString::number(DataUI->mInfo.obs,'f',2));
        //add
        ui->break_1->setText(QString::number(DataUI->mInfo.brake,'f',2));

        if(DataUI->mInfo.lidarStatus == 0x01)
            ui->lidarimg->setStyleSheet("background-image: url(:/new/pic/red.png);");
        else
            ui->lidarimg->setStyleSheet("background-image: url(:/new/pic/green.png);");

        /*
        if(DataUI->mInfo.radarStatus == 0x01)
            ui->radarimg->setStyleSheet("background-image: url(:/new/pic/green.png);");
        else
            ui->radarimg->setStyleSheet("background-image: url(:/new/pic/red.png);");
        */
        if(DataUI->mInfo.radarStatus == 0x01)
            ui->radarimg->setStyleSheet("background-image: url(:/new/pic/red.png);");
        else
            ui->radarimg->setStyleSheet("background-image: url(:/new/pic/green.png);");

        if(DataUI->mInfo.RTKstatus == 6)
        {
            ui->local->setText(QStringLiteral("定位：")+QString::number(DataUI->mInfo.RTKstatus));
            ui->local->setStyleSheet("color: rgb(220, 220, 220); font: 15pt 'Arial';");
            ui->localimg->setStyleSheet("background-image: url(:/new/pic/green.png);");
        }
        else
        {
            ui->local->setText(QStringLiteral("定位：")+QString::number(DataUI->mInfo.RTKstatus));
            ui->local->setStyleSheet("color: rgb(220, 220, 220); font: 15pt 'Arial';");
            ui->localimg->setStyleSheet("background-image: url(:/new/pic/red.png);");
        }


        if(DataUI->mInfo.is_mapLoad==0x00||DataUI->mInfo.is_initSuccess==0x00)
        {
            ui->pushButton->setEnabled(false);
            ui->pushButton->setStyleSheet("border-image: url(:/new/pic/button_gray.png);");
        }
        else
        {
            ui->pushButton->setEnabled(true);
            ui->pushButton->setStyleSheet("border-image: url(:/new/pic/button_green.png);");
            if(DataUI->mInfo.is_run==0x01)
            {
                ui->runimg->setStyleSheet("background-image: url(:/new/pic/green.png);");
                ui->pushButton->setStyleSheet("border-image: url(:/new/pic/button_stop.png);");
            }
            else
            {
                ui->runimg->setStyleSheet("background-image: url(:/new/pic/red.png);");
                ui->pushButton->setStyleSheet("border-image: url(:/new/pic/button_green.png);");
            }
        }
        if(DataUI->mInfo.parkSatus == 0x00)
        {
            ui->park->setText(QStringLiteral("不可泊车"));
             ui->park->setStyleSheet("background-image: url(:/new/pic/red.png);");
            ui->park->setEnabled(false);
            ui->park->setStyleSheet("border-image: url(:/new/pic/park_gray.png)");
        }
        else if(DataUI->mInfo.parkSatus == 0x01)
        {
            ui->park->setText(QStringLiteral("可泊车"));
             ui->park->setStyleSheet("background-image: url(:/new/pic/green.png);");
            ui->park->setEnabled(true);
            ui->park->setStyleSheet("border-image: url(:/new/pic/park.png)");
        }
        else if(DataUI->mInfo.parkSatus == 0x02)
        {
            ui->park->setText(QStringLiteral("泊车"));
            ui->park->setStyleSheet("background-color: rgb(211, 211, 0); font: 15pt 'Arial';");
            ui->park->setEnabled(false);
            ui->park->setStyleSheet("border-image: url(:/new/pic/park_gray.png)");
        }
        mbHaveData = true;
        //            if(p->mInfo.)
        data.clear();
        // }
        //        memcpy(&packHead,data.data(),sizeof(packHead));

    }
    update();
}

void ADCIntelligentShow::onconnTimer()
{
    qint64 xTime = QDateTime::currentMSecsSinceEpoch();
    if(recvFlag!=0)
    {
        //ui->connect->setText(QStringLiteral("已连接"));
        ui->connect->setStyleSheet("image: url(:/new/pic/connect.png);");
        if(((xTime - mnTimeGPS)>1000) &&(mnstylegps != 0))
        {
            ui->lng->setText(" ");
            ui->lat->setText(" ");
            ui->label->setText(QString::number(0));
            ui->localimg->setStyleSheet("background-image: url(:/new/pic/red.png);");
            mnstylegps = 0;
        }

        if(((xTime - mnTimeLidar)>1000) &&(mnstylelidar != 1))
        {
            ui->lidarimg->setStyleSheet("background-image: url(:/new/pic/red.png);");
            mnstylelidar = 1;
        }
        if(((xTime - mnTimeLidar)<1000) &&(mnstylelidar != 2))
        {
            ui->lidarimg->setStyleSheet("background-image: url(:/new/pic/green.png);");
            mnstylelidar = 2;
        }

        if(((xTime - mnTimeRADAR)>1000) && (mnstyleradar != 1))
        {
            ui->radarimg->setStyleSheet("background-image: url(:/new/pic/red.png);");
            mnstyleradar = 1;
        }
        if(((xTime - mnTimeRADAR)<1000) && (mnstyleradar != 2))
        {
            ui->radarimg->setStyleSheet("background-image: url(:/new/pic/green.png);");
            mnstyleradar = 2;
        }

        if((xTime- mnTimeDection)>1000)
        {
            ui->acc->setText(" ");
            ui->swerve->setText(" ");
            ui->break_1->setText(" ");
            if(mnstylepark != 0)
            {
                ui->park->setText(QStringLiteral("不可泊车"));
                ui->park->setStyleSheet("background-image: url(:/new/pic/red.png);");
                ui->park->setEnabled(false);
                ui->park->setStyleSheet("border-image: url(:/new/pic/park_gray.png)");
                mnstylepark = 0;
            }
        }

        if(navigation_data.size()>0)
        {
            ui->mapimg->setStyleSheet("background-image: url(:/new/pic/green.png);");
        }
        else
        {
            ui->mapimg->setStyleSheet("background-image: url(:/new/pic/red.png);");
        }

    }
    else
    {
        //ui->connect->setText(QStringLiteral("未连接"));
        ui->connect->setStyleSheet("image: url(:/new/pic/connect_grey.png);");
        ui->pushButton->setEnabled(false);
        ui->pushButton->setStyleSheet("border-image: url(:/new/pic/button_gray.png);");
        ui->label->setText(QString::number(0));
        ui->runimg->setStyleSheet("background-image: url(:/new/pic/blue.png);");
        ui->mapimg->setStyleSheet("background-image: url(:/new/pic/blue.png);");
        ui->canimg->setStyleSheet("background-image: url(:/new/pic/blue.png);");
        ui->localimg->setStyleSheet("background-image: url(:/new/pic/blue.png);");
        ui->acc->setText(" ");
        ui->swerve->setText(" ");
        ui->lng->setText(" ");
        ui->lat->setText(" ");
        ui->radarob->setText(" ");
        ui->lidarob->setText(" ");
        ui->allob->setText(" ");
        ui->lidarimg->setStyleSheet("background-image: url(:/new/pic/blue.png);");
        ui->radarimg->setStyleSheet("background-image: url(:/new/pic/blue.png);");

        ui->park->setText(QStringLiteral("不可泊车"));
        ui->park->setStyleSheet("background-image: url(:/new/pic/red.png);");
        ui->park->setEnabled(false);
        ui->park->setStyleSheet("border-image: url(:/new/pic/park_gray.png)");

        mnstylegps = 0;
        mnstylelidar = 0;
        mnstylebrain = 0;
        mnstyleradar = 0;
        mnstylepark = 0;

    }
    recvFlag = 0;
}

void ADCIntelligentShow::onTimerPainter()
{
    update();
}
//刷新
void ADCIntelligentShow::paintEvent(QPaintEvent *)
{
    // 绘制背景图
    mpainter_background  = new QPainter(this);
    mpainter_background->drawPixmap(0, 0, this->width(), this->height(), QPixmap(":/new/pic/background2.jpg"));
    delete mpainter_background;


    if(mpivmapview->IsHaveNew())
    {
        QImage image = mpivmapview->GetImage();
        scene->clear();
        scene->addPixmap(QPixmap::fromImage(image));
        myview->setScene(scene);
        myview->show();
    }
    return;

}


bool ADCIntelligentShow::loadMapFromFile(std::string fileName) {
    std::ifstream fis(fileName);//获取文件
    std::string line;
    std::vector<std::string> des;

    if (fis.is_open() == false)
        return false;

    try {
        while (getline(fis, line)) {//开始一行一行的读数据
            des.clear();
            SplitString(line,des,"\t");
            //boost::split(des, line, boost::is_any_of("\t"));

            //if (des.size() != 10)
            //    throw "error";


            if(des.size() < 10)
                throw "error";

            GPS_INS *data =new GPS_INS;
            data->index = atoi(des[0].c_str());
            data->gps_lng = atof(des[1].c_str());
            data->gps_lat = atof(des[2].c_str());
            data->speed_mode = atoi(des[3].c_str());
            data->mode2 = atoi(des[4].c_str());
            data->ins_heading_angle = atof(des[5].c_str());
            data->runMode = atoi(des[6].c_str());
            data->roadMode = atoi(des[7].c_str());
            data->roadSum = atoi(des[8].c_str());
            data->roadOri = atoi(des[9].c_str());
            //des[10].c_str() is the width of the road, and is no use.
            //Modified by map. 2019-12-02

            //	gps2xy(data->gps_lat, data->gps_lng, &data->gps_x, &data->gps_y);
            GaussProjCal(data->gps_lng, data->gps_lat, &data->gps_x, &data->gps_y);
            //data->speed = 5;	//调试用  所有点速度都设为5km/h
            //LOG2(data->gps_x, data->gps_y);
            //ODS("x %.20lf   y %.20lf\n", data->gps_x, data->gps_y);

            //	iv::decition::BLH2XYZ(*data);   //重新转下大地坐标

//            navigation_data.push_back(data);
        }

    }
    catch (...) {
        fis.close();
        return false;
    }

    fis.close();
    return true;
}



//高斯投影由经纬度(Unit:DD)反算大地坐标(含带号，Unit:Metres)
void ADCIntelligentShow::GaussProjCal(double longitude, double latitude, double *X, double *Y)
{
    int ProjNo = 0; int ZoneWide; ////带宽
    double longitude1, latitude1, longitude0, X0, Y0, xval, yval;
    double a, f, e2, ee, NN, T, C, A, M, iPI;
    iPI = 0.0174532925199433; ////3.1415926535898/180.0;
    ZoneWide = 6; ////6度带宽
    a = 6378245.0; f = 1.0 / 298.3; //54年北京坐标系参数
    ////a=6378140.0; f=1/298.257; //80年西安坐标系参数
    ProjNo = (int)(longitude / ZoneWide);
    longitude0 = ProjNo * ZoneWide + ZoneWide / 2;
    longitude0 = longitude0 * iPI;
    //latitude0 = 0;
    longitude1 = longitude * iPI; //经度转换为弧度
    latitude1 = latitude * iPI; //纬度转换为弧度
    e2 = 2 * f - f * f;
    ee = e2 * (1.0 - e2);
    NN = a / sqrt(1.0 - e2 * sin(latitude1)*sin(latitude1));
    T = tan(latitude1)*tan(latitude1);
    C = ee * cos(latitude1)*cos(latitude1);
    A = (longitude1 - longitude0)*cos(latitude1);
    M = a * ((1 - e2 / 4 - 3 * e2*e2 / 64 - 5 * e2*e2*e2 / 256)*latitude1 -
             (3 * e2 / 8 + 3 * e2*e2 / 32 + 45 * e2*e2*e2 / 1024)*sin(2 * latitude1)
             + (15 * e2*e2 / 256 + 45 * e2*e2*e2 / 1024)*sin(4 * latitude1) -
             (35 * e2*e2*e2 / 3072)*sin(6 * latitude1));
    xval = NN * (A + (1 - T + C)*A*A*A / 6 + (5 - 18 * T + T * T + 72 * C - 58 * ee)*A*A*A*A*A / 120);
    yval = M + NN * tan(latitude1)*(A*A / 2 + (5 - T + 9 * C + 4 * C*C)*A*A*A*A / 24
                                    + (61 - 58 * T + T * T + 600 * C - 330 * ee)*A*A*A*A*A*A / 720);
    X0 = 1000000L * (ProjNo + 1) + 500000L;
    Y0 = 0;
    xval = xval + X0; yval = yval + Y0;
    *X = xval;
    *Y = yval;
}

void ADCIntelligentShow::SplitString(const string& s, vector<string>& v, const string& c)
{
    string::size_type pos1, pos2;
    pos2 = s.find(c);
    pos1 = 0;
    while(string::npos != pos2)
    {
        v.push_back(s.substr(pos1, pos2-pos1));

        pos1 = pos2 + c.size();
        pos2 = s.find(c, pos1);
    }
    if(pos1 != s.length())
        v.push_back(s.substr(pos1));
}

void ADCIntelligentShow::on_park_clicked()
{
    int xRun = 2;
    socket->writeDatagram((char *)&xRun,4,QHostAddress::Broadcast,9998);
    QApplication::beep();
}

void ADCIntelligentShow::onlidarRecv()
{

    while(lidarsock->hasPendingDatagrams())
    {
        QByteArray data;
        data.resize(lidarsock->pendingDatagramSize());
        lidarsock->readDatagram(data.data(),data.size());
        //        packageHead packHead;
        qDebug("size = %d",data.size());
        //if(data.size() == sizeof(DataToUI))
        //{
        memcpy(&mlidarpoint,data.data(),data.size());
        qDebug("size:%d",DataUI->mHead.size);

    }
}

////一键叫车
//void ADCIntelligentShow::on_onekey_clicked()
//{
//    int res =  QMessageBox::warning(NULL,"警告","确认是否一键叫车",QMessageBox::Yes,QMessageBox::No);
//    if(res==QMessageBox::Yes)
//    {
//        int xRun = 3;
//        socket->writeDatagram((char *)&xRun,4,QHostAddress::Broadcast,9998);

//    }
//    else
//    {
//        int xRun = 4;
//        socket->writeDatagram((char *)&xRun,4,QHostAddress::Broadcast,9998);
//    }
//}


void ADCIntelligentShow::on_pushButton_2_clicked()
{

    std::cout<<"click "<<std::endl;
    iv::hmi::hmimsg xhmi;
    xhmi.set_mbbochemode(true);
    xhmi.set_mbbusmode(false);
    if(mbRunning)
        xhmi.set_mbpause(false);
    else
        xhmi.set_mbpause(true);
    int nsize = xhmi.ByteSize();
    char * str = new char[nsize];
    if(xhmi.SerializeToArray(str,1000))
    {
#ifndef Android
        iv::modulecomm::ModuleSendMsg(mpapad,str,nsize);
#else
        ggt->UpdateData(str,nsize,"pad");
#endif
    }
    else
    {
        std::cout<<"ADCIntelligentShow::on_pushButton_clicked serialize error."<<std::endl;
    }
    delete str;
    QApplication::beep();
    return;
    //QMessageBox::styleSheet("background-color: rgb(140, 140, 140);");
    int res =  QMessageBox::warning(NULL,"警告","确认是否重新启动",QMessageBox::Yes,QMessageBox::No);
    if(res==QMessageBox::Yes)
    {
        int xRun = 9;
        socket->writeDatagram((char *)&xRun,4,QHostAddress::Broadcast,9998);
    }
}


void ADCIntelligentShow::slotAlarm()
{
    if(soundAlarm->isFinished())
        soundAlarm->play();
}

void ADCIntelligentShow::UpdateGPSIMU(iv::gps::gpsimu *pgpsimu)
{
    iv::gps::gpsimu xgpsimu;
    xgpsimu.CopyFrom(*pgpsimu);
    mMutexGPSIMU.lock();
    mgpsimu.CopyFrom(*pgpsimu);
    mMutexGPSIMU.unlock();
    emit signalGPSIMU();

    mnTimeGPS = QDateTime::currentMSecsSinceEpoch();
}

void ADCIntelligentShow::UpdateOBS(std::shared_ptr<std::vector<iv::ObstacleBasic> > xobs)
{
    recvFlag = 1;
    mpivmapview->setobs(xobs);
    mnTimeLidar = QDateTime::currentMSecsSinceEpoch();
}

void ADCIntelligentShow::onUpdateGPSIMU()
{
    recvFlag = 1;
    iv::gps::gpsimu xgpsimu;
    mMutexGPSIMU.lock();
    xgpsimu.CopyFrom(mgpsimu);
    mMutexGPSIMU.unlock();
    mpivmapview->setgps(&xgpsimu);
    ui->lng->setText(QString::number(xgpsimu.lon(),'f',7));
    ui->lat->setText(QString::number(xgpsimu.lat(),'f',7));
    if(xgpsimu.rtk_state() == 6)
    {
        ui->local->setText(QStringLiteral("定位：")+QString::number(xgpsimu.rtk_state()));
        if(mnstylegps != 1)
        {
            ui->local->setStyleSheet("color: rgb(220, 220, 220); font: 15pt 'Arial';");
            ui->localimg->setStyleSheet("background-image: url(:/new/pic/green.png);");
            mnstylegps = 1;
        }
    }
    else
    {
        ui->local->setText(QStringLiteral("定位：")+QString::number(xgpsimu.rtk_state()));
        if(mnstylegps != 2)
        {
            ui->local->setStyleSheet("color: rgb(220, 220, 220); font: 15pt 'Arial';");
            ui->localimg->setStyleSheet("background-image: url(:/new/pic/red.png);");
            mnstylegps = 2;
        }
    }
    ui->label->setText(QString::number((sqrt(pow(xgpsimu.ve(),2)+pow(xgpsimu.vn(),2))*3.6),'f',1));
}

void ADCIntelligentShow::UpdateMap(const char *mapdata, const int mapdatasize)
{
        std::cout<<"update map "<<std::endl;
    int gpsunitsize = sizeof(iv::MAP_GPS_INS);
    int nMapSize = mapdatasize/gpsunitsize;
    //    std::cout<<"map size is "<<nMapSize<<std::endl;

    if(nMapSize < 1)return;

    bool bUpdate = false;
    if(nMapSize != navigation_data.size())
    {
        bUpdate = true;
    }
    else
    {
        iv::MAP_GPS_INS * p = (iv::MAP_GPS_INS *)mapdata;
        if((p->gps_lat == navigation_data.at(0).gps_lat)&&(p->ins_heading_angle == navigation_data.at(0).ins_heading_angle))
        {
            //           qDebug("same map");
            bUpdate = false;
        }
        else
        {
            bUpdate = true;
        }
    }

    if(bUpdate)
    {

        int i;
        mMutexMap.lock();
        navigation_data.clear();
        for(i=0;i<nMapSize;i++)
        {
            iv::MAP_GPS_INS x;
            memcpy(&x,mapdata + i*gpsunitsize,gpsunitsize);
            navigation_data.push_back(x);
        }

        mpivmapview->setmap(navigation_data);
        mMutexMap.unlock();

        //        mpasd->SaveState("map",mapdata,mapdatasize);
    }
    else
    {
        //       qDebug("not need update");
    }
}

void ADCIntelligentShow::UpdateBrainState(iv::brain::brainstate xbrainstate)
{
    recvFlag = 1;
    mMutexBrain.lock();
    mbrainstate.CopyFrom(xbrainstate);
    mMutexBrain.unlock();
    mnTimeBrain = QDateTime::currentMSecsSinceEpoch();
    emit signalbrainstate();
}

void ADCIntelligentShow::onUpdateBrainState()
{
    recvFlag = 1;
    iv::brain::brainstate xbrainstate;
    mMutexBrain.lock();
    xbrainstate.CopyFrom(mbrainstate);
    mMutexBrain.unlock();

    ui->pushButton->setEnabled(true);
    if(xbrainstate.mbbrainrunning())
    {
        mbRunning = true;
        if(mnstylebrain != 2)
        {
            ui->runimg->setStyleSheet("background-image: url(:/new/pic/green.png);");
            ui->pushButton->setStyleSheet("border-image: url(:/new/pic/button_stop.png);");
            mnstylebrain = 2;
        }
        ui->radarob->setText(QString::number(xbrainstate.mfradarobs(),'f',2));
        ui->lidarob->setText(QString::number(xbrainstate.mflidarobs(),'f',2));
        ui->allob->setText(QString::number(xbrainstate.mfobs(),'f',2));

    }
    else
    {
        mbRunning = false;
        if(mnstylebrain != 1)
        {
            ui->runimg->setStyleSheet("background-image: url(:/new/pic/red.png);");
            ui->pushButton->setStyleSheet("border-image: url(:/new/pic/button_green.png);");
            mnstylebrain = 1;
        }
        ui->radarob->setText(" ");
        ui->lidarob->setText(" ");
        ui->allob->setText(" ");
    }

    if(xbrainstate.mbbocheenable())
    {
        if(mnstylepark != 2)
        {
            mnstylepark = 2;
            ui->park->setText(QStringLiteral("可泊车"));
            ui->park->setStyleSheet("background-image: url(:/new/pic/green.png);");
            ui->park->setEnabled(true);
            ui->park->setStyleSheet("border-image: url(:/new/pic/park.png)");
        }
    }
    else
    {
        if(mnstylepark != 1)
        {
            ui->park->setText(QStringLiteral("不可泊车"));
            ui->park->setStyleSheet("background-image: url(:/new/pic/red.png);");
            ui->park->setEnabled(false);
            ui->park->setStyleSheet("border-image: url(:/new/pic/park_gray.png)");
            mnstylepark = 1;
        }
    }
}

void ADCIntelligentShow::UpdateDection(iv::brain::decition xdecision )
{
    mMutexDecision.lock();
    mdecision.CopyFrom(xdecision);
    mMutexDecision.unlock();
    emit signaldection();
    mnTimeDection = QDateTime::currentMSecsSinceEpoch();
}

void ADCIntelligentShow::onUpdateDection()
{
    iv::brain::decition xdecision;
    mMutexDecision.lock();
    xdecision.CopyFrom(mdecision);
    mMutexDecision.unlock();

    ui->acc->setText(QString::number(xdecision.torque(),'f',1));
    ui->swerve->setText(QString::number(xdecision.wheelangle(),'f',1));
    ui->break_1->setText(QString::number(xdecision.brake(),'f',2));
}

void ADCIntelligentShow::UpdateRADAR(iv::radar::radarobjectarray *pxobj)
{
    recvFlag = 1;
    mMutexRadar.lock();
    mradarobj.CopyFrom(*pxobj);
    mMutexRadar.unlock();
    mnTimeRADAR = QDateTime::currentMSecsSinceEpoch();
    mpivmapview->setradar(pxobj);
}


void ADCIntelligentShow::on_pushButton_nextstation_clicked()
{
    if(gvectorpos.size()<1)return;
    mnStationIndex++;
    if(mnStationIndex>=gvectorpos.size())mnStationIndex = 0;
    ui->label_station->setText(gvectorpos[mnStationIndex].mstrstationname.data());
}

void ADCIntelligentShow::on_pushButton_prestation_clicked()
{
    if(gvectorpos.size()<1)return;
    mnStationIndex--;
    if(mnStationIndex<0)mnStationIndex = gvectorpos.size()-1;
    ui->label_station->setText(gvectorpos[mnStationIndex].mstrstationname.data());
}

void ADCIntelligentShow::on_pushButton_go_clicked()
{
    if(gvectorpos.size()<1)return;

    xodrobj xo;
    xo.flon = gvectorpos[mnStationIndex].mflon;
    xo.flat = gvectorpos[mnStationIndex].mflat;
    xo.lane = mndefaultlane;

#ifndef Android
    iv::modulecomm::ModuleSendMsg(mpadst,(char *)&xo,sizeof(xodrobj));
#else
    ggt->UpdateData((char *)&xo,sizeof(xodrobj),"xodrreq");
#endif
}

void ADCIntelligentShow::onSwitchClick(int nswitch)
{
    qDebug("click");
}

void ADCIntelligentShow::onModeClick(int nMode)
{

}
void ADCIntelligentShow::on_pushButton_Setting_clicked()
{
    mpDS->show();
}