change map_lanetoxodr. change signal.

src/common/common/xodr/OpenDrive/ObjectSignal.cpp

@@ -2337,6 +2337,82 @@ void signal_laneValidity::SettoLane(int toLane)
     mtoLane = toLane;
 }
 
+signal_dependency::signal_dependency(std::string id)
+{
+    mstrid = id;
+}
+
+std::string signal_dependency::Getid()
+{
+    return mstrid;
+}
+
+void signal_dependency::Setid(std::string strid)
+{
+    mstrid = strid;
+}
+
+int signal_dependency::Gettype(std::string & strtype)
+{
+    if(mtype.size() == 0)return 0;
+    strtype = mtype[0];
+    return 1;
+}
+
+void signal_dependency::Settype(std::string strtype)
+{
+    if(mtype.size() > 0)mtype.clear();
+    mtype.push_back(strtype);
+}
+
+void signal_dependency::Resettype()
+{
+   if(mtype.size() > 0)mtype.clear();
+}
+
+
+signal_reference::signal_reference(std::string elementType,std::string elementId)
+{
+    melementType = elementType;
+    melementId = elementId;
+}
+
+std::string signal_reference::GetelementType()
+{
+    return  melementType;
+}
+
+std::string signal_reference::GetelementId()
+{
+    return melementId;
+}
+
+void signal_reference::SetelementType(std::string elementType)
+{
+    melementType = elementType;
+}
+
+void signal_reference::SetelementId(std::string elementId)
+{
+    melementId = elementId;
+}
+
+void signal_reference::Settype(std::string type)
+{
+    if(mtype.size()>0)mtype.clear();
+    mtype.push_back(type);
+}
+
+void signal_reference::Resettype()
+{
+    if(mtype.size()>0)mtype.clear();
+}
+int signal_reference::Gettype(std::string & type)
+{
+    if(mtype.size() == 0)return 0;
+    type = mtype[0];
+    return 1;
+}
 
 Signal::Signal(double s, double t, std::string id, std::string name, bool dynamic,string orientation,
                double zOffset, string type, std::string country, std::string countryRevision,
@@ -2672,6 +2748,175 @@ void Signal::SetpositionInertial(double x, double y, double z, double hdg, doubl
     }
 }
 
+vector<signal_laneValidity> * Signal::GetlaneValidityVector()
+{
+    return &mlaneValidity;
+}
+
+signal_laneValidity* Signal::GetlaneValidity(unsigned int i)
+{
+    if ((mlaneValidity.size()>0)&&(i<(mlaneValidity.size())))
+        return &(mlaneValidity.at(i));
+    else
+        return NULL;
+}
+
+unsigned int Signal::GetlaneValidityCount()
+{
+    return static_cast<unsigned int >(mlaneValidity.size()) ;
+}
+
+signal_laneValidity*			Signal::GetLastlaneValidity()
+{
+    if (mlaneValidity.size()>0)
+        return &mlaneValidity.at(mlaneValidity.size()-1);
+    else
+        return NULL;
+}
+
+signal_laneValidity*			Signal::GetLastAddedlaneValidity()
+{
+    if(mLastAddedlaneValidity<mlaneValidity.size())
+        return &mlaneValidity.at(mLastAddedlaneValidity);
+    else
+        return NULL;
+}
+
+unsigned int Signal::AddlaneValidity(int fromLane, int toLane)
+{
+    mlaneValidity.push_back(signal_laneValidity(fromLane,toLane));
+    mLastAddedlaneValidity = static_cast<unsigned int>(mlaneValidity.size()-1) ;
+    return mLastAddedlaneValidity;
+}
+
+unsigned int Signal::ClonelaneValidity(unsigned int index)
+{
+    if(index<(mlaneValidity.size()-1))
+        mlaneValidity.insert(mlaneValidity.begin()+index+1, mlaneValidity[index]);
+    else if(index==mlaneValidity.size()-1)
+        mlaneValidity.push_back(mlaneValidity[index]);
+    mLastAddedlaneValidity=index+1;
+    return mLastAddedlaneValidity;
+}
+
+void Signal::DeletelaneValidity(unsigned int index)
+{
+    mlaneValidity.erase(mlaneValidity.begin()+index);
+}
+
+vector<signal_dependency> * Signal::GetDependencyVector()
+{
+    return  &mdependency;
+}
+
+signal_dependency* Signal::GetDependency(unsigned int i)
+{
+    if ((mdependency.size()>0)&&(i<(mdependency.size())))
+        return &(mdependency.at(i));
+    else
+        return NULL;
+}
+
+unsigned int Signal::GetDependencyCount()
+{
+    return static_cast<unsigned int >(mdependency.size()) ;
+}
+
+signal_dependency*			Signal::GetLastDependency()
+{
+    if (mdependency.size()>0)
+        return &mdependency.at(mdependency.size()-1);
+    else
+        return NULL;
+}
+
+signal_dependency*			Signal::GetLastAddedDependency()
+{
+    if(mLastAddedDependency<mdependency.size())
+        return &mdependency.at(mLastAddedDependency);
+    else
+        return NULL;
+}
+
+unsigned int Signal::AddDependency(std::string strid)
+{
+    mdependency.push_back(signal_dependency(strid));
+    mLastAddedDependency = static_cast<unsigned int>(mdependency.size()-1) ;
+    return mLastAddedDependency;
+}
+
+unsigned int Signal::CloneDependency(unsigned int index)
+{
+    if(index<(mdependency.size()-1))
+        mdependency.insert(mdependency.begin()+index+1, mdependency[index]);
+    else if(index==mdependency.size()-1)
+        mdependency.push_back(mdependency[index]);
+    mLastAddedDependency=index+1;
+    return mLastAddedDependency;
+}
+
+void Signal::DeleteDependency(unsigned int index)
+{
+    mdependency.erase(mdependency.begin()+index);
+}
+
+
+vector<signal_reference> * Signal::GetReferenceVector()
+{
+    return  &mreference;
+}
+
+signal_reference* Signal::GetReference(unsigned int i)
+{
+    if ((mreference.size()>0)&&(i<(mreference.size())))
+        return &(mreference.at(i));
+    else
+        return NULL;
+}
+
+unsigned int Signal::GetReferenceCount()
+{
+        return static_cast<unsigned int >(mreference.size()) ;
+}
+
+signal_reference*			Signal::GetLastReference()
+{
+    if (mreference.size()>0)
+        return &mreference.at(mreference.size()-1);
+    else
+        return NULL;
+}
+
+signal_reference*			Signal::GetLastAddedReference()
+{
+    if(mLastAddedReference<mreference.size())
+        return &mreference.at(mLastAddedReference);
+    else
+        return NULL;
+}
+
+unsigned int Signal::AddReference(std::string elementType,std::string elementId)
+{
+    mreference.push_back(signal_reference(elementType,elementId));
+    mLastAddedReference = static_cast<unsigned int>(mreference.size()-1) ;
+    return mLastAddedReference;
+}
+
+unsigned int Signal::CloneReference(unsigned int index)
+{
+    if(index<(mreference.size()-1))
+        mreference.insert(mreference.begin()+index+1, mreference[index]);
+    else if(index==mreference.size()-1)
+        mreference.push_back(mreference[index]);
+    mLastAddedReference=index+1;
+    return mLastAddedReference;
+}
+
+void Signal::DeleteReference(unsigned int index)
+{
+    mreference.erase(mreference.begin()+index);
+}
+
 signal_laneValidity * Signal::GetlaneValidity()
 {
     return mpsignal_laneValidity;

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

@@ -774,6 +774,43 @@ public:
     void SettoLane(int toLane);
 };
 
+class signal_dependency
+{
+private:
+    std::string mstrid;
+    std::vector<std::string> mtype;
+
+public:
+    signal_dependency(std::string id);
+
+    std::string Getid();
+    void Setid(std::string strid);
+
+    int Gettype(std::string & strtype);
+    void Settype(std::string strtype);
+    void Resettype();
+};
+
+class signal_reference
+{
+private:
+    std::string melementType;
+    std::string melementId;
+    std::vector<std::string> mtype;
+
+public:
+    signal_reference(std::string elementType,std::string elementId);
+
+    std::string GetelementType();
+    std::string GetelementId();
+
+    void SetelementType(std::string elementType);
+    void SetelementId(std::string elementId);
+
+    void Settype(std::string type);
+    void Resettype();
+    int Gettype(std::string & type);
+};
 
 //***********************************************************************************
 //Signal
@@ -800,6 +837,16 @@ private:
     signal_positionRoad * mpsignal_positionRoad;
     signal_positionInertial * mpsignal_positionInertial;
     signal_laneValidity * mpsignal_laneValidity;
+
+    std::vector<signal_laneValidity> mlaneValidity;
+    unsigned int mLastAddedlaneValidity;
+
+    std::vector<signal_dependency> mdependency;
+    unsigned int mLastAddedDependency;
+
+    std::vector<signal_reference> mreference;
+    unsigned int mLastAddedReference;
+
 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);
@@ -846,6 +893,34 @@ public:
     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);
 
+    vector<signal_laneValidity> * GetlaneValidityVector();
+    signal_laneValidity* GetlaneValidity(unsigned int i);
+    unsigned int GetlaneValidityCount();
+    signal_laneValidity*			GetLastlaneValidity();
+    signal_laneValidity*			GetLastAddedlaneValidity();
+    unsigned int AddlaneValidity(int fromLane, int toLane);
+    unsigned int ClonelaneValidity(unsigned int index);
+    void DeletelaneValidity(unsigned int index);
+
+    vector<signal_dependency> * GetDependencyVector();
+    signal_dependency* GetDependency(unsigned int i);
+    unsigned int GetDependencyCount();
+    signal_dependency*			GetLastDependency();
+    signal_dependency*			GetLastAddedDependency();
+    unsigned int AddDependency(std::string strid);
+    unsigned int CloneDependency(unsigned int index);
+    void DeleteDependency(unsigned int index);
+
+    vector<signal_reference> * GetReferenceVector();
+    signal_reference* GetReference(unsigned int i);
+    unsigned int GetReferenceCount();
+    signal_reference*			GetLastReference();
+    signal_reference*			GetLastAddedReference();
+    unsigned int AddReference(std::string elementType,std::string elementId);
+    unsigned int CloneReference(unsigned int index);
+    void DeleteReference(unsigned int index);
+
+
 
 };
 //----------------------------------------------------------------------------------

src/ui/ADCIntelligentShow_grpc/adcintelligentshow.cpp

@@ -166,6 +166,7 @@ void ListenTraceMap(const char * strdata,const unsigned int nSize,const unsigned
 #ifdef Android
     void ADCIntelligentShow::AndroidSetMsg(const char * msgname , const char *strdata, const unsigned int nDataLen)
     {
+ //       qDebug("msg: %s ",msgname);
         if(strncmp(msgname,"hcp2_gpsimu",256) == 0)
         {
             Listengpsimu(strdata,nDataLen,0,0,0);
@@ -196,6 +197,7 @@ void ListenTraceMap(const char * strdata,const unsigned int nSize,const unsigned
         }
         if(strncmp(msgname,"li_ra_fusion",256) == 0)
         {
+   //         qDebug("li ra fusion.");
             ListenFusion(strdata,nDataLen,0,0,0);
         }
     }
@@ -209,6 +211,9 @@ ADCIntelligentShow::ADCIntelligentShow(QWidget *parent) :
     ui->setupUi(this);
     ui->pushButton->setEnabled(false);
 
+    mpivmapview = new ivmapview();
+    mpivmapview->start();
+
 
     //样式 3-26
     qApp->setStyleSheet("QPushButton#pushButton_2\n{\nborder-image: url(:/new/pic/restart1.png);\n}"
@@ -313,8 +318,7 @@ ADCIntelligentShow::ADCIntelligentShow(QWidget *parent) :
     connect(this,SIGNAL(signaldection()),this,SLOT(onUpdateDection()));
 
 
-    mpivmapview = new ivmapview();
-    mpivmapview->start();
+
 
     QTimer * timerpainter = new QTimer(this);
     connect(timerpainter,SIGNAL(timeout()),this,SLOT(onTimerPainter()));
@@ -645,7 +649,7 @@ void ADCIntelligentShow::onconnTimer()
             ui->radarimg->setStyleSheet("background-image: url(:/new/pic/red.png);");
             mnstyleradar = 1;
         }
-        if(abs((xTime - mnTimeRADAR)<1000) && (mnstyleradar != 2))
+        if((abs(xTime - mnTimeRADAR)<1000) && (mnstyleradar != 2))
         {
             ui->radarimg->setStyleSheet("background-image: url(:/new/pic/green.png);");
             mnstyleradar = 2;
@@ -1057,9 +1061,8 @@ void ADCIntelligentShow::UpdateMap(const char *mapdata, const int mapdatasize)
             memcpy(&x,mapdata + i*gpsunitsize,gpsunitsize);
             navigation_data.push_back(x);
         }
-
-        mpivmapview->setmap(navigation_data);
         mMutexMap.unlock();
+        mpivmapview->setmap(navigation_data);
 
         //        mpasd->SaveState("map",mapdata,mapdatasize);
     }

src/ui/ADCIntelligentShow_grpc/ivmapview.cpp

@@ -49,6 +49,7 @@ ivmapview::ivmapview()
     painter->end();
     std::vector<iv::ObstacleBasic> * pobs = new std::vector<iv::ObstacleBasic>();
     mobs.reset(pobs);
+    mnavigation_data.clear();
 }
 
 void ivmapview::run()
@@ -268,6 +269,26 @@ void ivmapview::paint()
         }
     }
 
+    if(abs(xTime-mnTimeFusion)<3000)
+    {
+  //      qDebug("update show fusion.");
+        iv::fusion::fusionobjectarray xfusion;
+        mMutexFusion.lock();
+        xfusion.CopyFrom(mfusion);
+        mMutexFusion.unlock();
+
+        painter->setPen(QColor(255,0,0));
+
+        for(int a = 0; a < xfusion.obj_size(); a++)
+        {
+            for(int b = 0; b < xfusion.obj(a).nomal_centroid_size(); b++)
+            {
+                painter->drawPoint((xfusion.obj(a).nomal_centroid(b).nomal_x())*10 + 450, -(xfusion.obj(a).nomal_centroid(b).nomal_y() + 0)*10 + 700);
+            }
+        }
+
+    }
+
     if(abs(xTime-mnTimeRADAR)<3000)
     {
         iv::radar::radarobjectarray xradarobj;
@@ -293,24 +314,7 @@ void ivmapview::paint()
 
         }
 
-        if(abs(xTime-mnTimeFusion)<3000)
-        {
-            iv::fusion::fusionobjectarray xfusion;
-            mMutexFusion.lock();
-            xfusion.CopyFrom(mfusion);
-            mMutexFusion.unlock();
-
-            painter->setPen(QColor(255,0,0));
 
-            for(int a = 0; a < xfusion.obj_size(); a++)
-            {
-                for(int b = 0; b < xfusion.obj(a).nomal_centroid_size(); b++)
-                {
-                    painter->drawPoint((xfusion.obj(a).nomal_centroid(b).nomal_x())*10 + 450, -(xfusion.obj(a).nomal_centroid(b).nomal_y() + 0)*10 + 700);
-                }
-            }
-
-        }
     }
 
     QPixmap pix;
@@ -425,6 +429,7 @@ void ivmapview::setradar(iv::radar::radarobjectarray *pradarobj)
 
 void ivmapview::setfusion(iv::fusion::fusionobjectarray &xfusion)
 {
+//    qDebug("set fusion.");
     mMutexFusion.lock();
     mfusion.CopyFrom(xfusion);
     mMutexFusion.unlock();