change tool/map_lanetoxdr. complete scene show.

src/tool/map_lanetoxodr/mainwindow.cpp

@@ -5076,182 +5076,46 @@ void MainWindow::UpdateScene()
     mvectorviewitem.clear();
 
     nsize = mxodr.GetRoadCount();
+
+    std::vector<RoadDigit> xvectorrd;
     for(i=0;i<nsize;i++)
     {
-        UpdateSceneRoad(mxodr.GetRoad(i));
+        RoadDigit xrd(mxodr.GetRoad(i),10.0);
+        xvectorrd.push_back(xrd);
+ //       UpdateSceneRoad(mxodr.GetRoad(i));
 //        qDebug("update road %d",i);
     }
-    mbRefresh = false;
-}
-
-void MainWindow::UpdateSceneRoad(Road *pRoad)
-{
-    RoadDigit xrd(pRoad,3.0);
-    std::vector<iv::RoadDigitUnit> * pvectorrdu =  xrd.GetRDU();
-    int nsize = pvectorrdu->size();
-    int i;
-    double flmw = 0.15;
-    for(i=0;i<(nsize-1);i++)
+    for(i=0;i<nsize;i++)
     {
-        std::vector<iv::LanePoint> xvepre = pvectorrdu->at(i).mvectorLanePoint;
-        std::vector<iv::LanePoint> xvenxt = pvectorrdu->at(i+1).mvectorLanePoint;
-        if((xvepre.size()<2)||(xvenxt.size()<2)||(xvenxt.size() != xvepre.size()))
-        {
-            continue;
-        }
-        unsigned int k;
-        for(k=0;k<(xvepre.size()-1);k++)
+        std::vector<QGraphicsPathItem *> xvectorlanepath = xodrscenfunc::GetRoadLaneItem(&(xvectorrd[i]));
+        int j;
+        int ncount = xvectorlanepath.size();
+        for(j=0;j<ncount;j++)
         {
-            QPainterPath xpath;
-            xpath.moveTo(xvepre.at(k).mfX,xvepre.at(k).mfY*(-1));
-            xpath.lineTo(xvenxt.at(k).mfX,xvenxt.at(k).mfY*(-1));
-            xpath.lineTo(xvenxt.at(k+1).mfX,xvenxt.at(k+1).mfY*(-1));
-            xpath.lineTo(xvepre.at(k+1).mfX,xvepre.at(k+1).mfY*(-1));
-            xpath.closeSubpath();
-            QGraphicsPathItem * pitem = new QGraphicsPathItem;
-            pitem->setPath(xpath);
+            QGraphicsPathItem * pitem = xvectorlanepath[j];
             pitem->setPos(mfViewMoveX +VIEW_WIDTH/2,-mfViewMoveY+VIEW_HEIGHT/2);
-            int nlanetype = xvepre.at(k).mnlanetype;
-            if(xvepre.at(k).mnlane<=0)nlanetype = xvepre.at(k+1).mnlanetype;
-            QColor brushcolor = Qt::darkGray;
-            switch (nlanetype) {
-            case 2:
-                brushcolor = Qt::darkGray;
-                break;
-            case 8:
-                brushcolor = Qt::red;
-                break;
-            case 9:
-                brushcolor = QColor(0xB2,0xB2,0xD6);
-                break;
-            default:
-                brushcolor = Qt::darkGreen;
-                break;
-            }
-            pitem->setBrush(brushcolor);
-            pitem->setPen(QPen(brushcolor,0.001));
             mpscene->addItem(pitem);
             mvectorviewitem.push_back(pitem);
         }
     }
 
-    for(i=0;i<(nsize-1);i++)
+    for(i=0;i<nsize;i++)
     {
-        std::vector<iv::LanePoint> xvepre = pvectorrdu->at(i).mvectorLanePoint;
-        std::vector<iv::LanePoint> xvenxt = pvectorrdu->at(i+1).mvectorLanePoint;
-        if(xvenxt.size() != xvepre.size())
-        {
-            continue;
-        }
-        unsigned int k;
-        for(k=0;k<(xvepre.size());k++)
+        std::vector<QGraphicsPathItem *> xvectormarkpath = xodrscenfunc::GetRoadMarkItem(&(xvectorrd[i]));
+        int j;
+        int ncount = xvectormarkpath.size();
+        for(j=0;j<ncount;j++)
         {
-            QPainterPath xpath;
-            int ncolor = -3;
-            int nmarktype = xvepre[k].mnlanemarktype;
-            if(nmarktype >= 0)
-            {
-                if(nmarktype<2)
-                {
-                    if((nmarktype == 0)||(roadviewitem::IsDrawMark(xvepre[k].mS)))
-                    {
-                        xpath.moveTo(xvepre[k].mfX + 0.5*flmw * cos(xvenxt[k].mfhdg - M_PI/2.0),
-                                     (xvepre[k].mfY+0.5*flmw * sin(xvenxt[k].mfhdg - M_PI/2.0))*(-1.0));
-                        xpath.lineTo(xvenxt[k].mfX+ 0.5*flmw * cos(xvepre[k].mfhdg - M_PI/2.0),
-                                     (xvenxt[k].mfY+0.5*flmw * sin(xvepre[k].mfhdg - M_PI/2.0))*(-1.0));
-                        xpath.lineTo(xvenxt[k].mfX + 0.5*flmw * cos(xvenxt[k].mfhdg + M_PI/2.0),
-                                     (xvenxt[k].mfY+0.5*flmw * sin(xvenxt[k].mfhdg + M_PI/2.0))*(-1.0));
-                        xpath.lineTo(xvepre[k].mfX+ 0.5*flmw * cos(xvepre[k].mfhdg + M_PI/2.0),
-                                     (xvepre[k].mfY+0.5*flmw * sin(xvepre[k].mfhdg + M_PI/2.0))*(-1.0));
-                        xpath.closeSubpath();
-                        ncolor = xvepre[k].mnlanecolor;
-
-
-                    }
-                }
-                else
-                {
-                    if((nmarktype == 2)||(nmarktype == 3)||(roadviewitem::IsDrawMark(xvepre[k].mS)))
-                    {
-                        xpath.moveTo(xvepre[k].mfX + flmw * cos(xvenxt[k].mfhdg + M_PI/2.0),
-                                     (xvepre[k].mfY+flmw * sin(xvenxt[k].mfhdg + M_PI/2.0))*(-1.0));
-                        xpath.lineTo(xvenxt[k].mfX+ flmw * cos(xvepre[k].mfhdg + M_PI/2.0),
-                                     (xvenxt[k].mfY+flmw * sin(xvepre[k].mfhdg + M_PI/2.0))*(-1.0));
-
-                        xpath.lineTo(xvenxt[k].mfX + 2*flmw * cos(xvenxt[k].mfhdg + M_PI/2.0),
-                                     (xvenxt[k].mfY+2*flmw * sin(xvenxt[k].mfhdg + M_PI/2.0))*(-1.0));
-                        xpath.lineTo(xvepre[k].mfX+ 2*flmw * cos(xvepre[k].mfhdg + M_PI/2.0),
-                                     (xvepre[k].mfY+2*flmw * sin(xvepre[k].mfhdg + M_PI/2.0))*(-1.0));
-                        xpath.closeSubpath();
-                        ncolor = xvepre[k].mnlanecolor;
-                    }
-                    if((nmarktype == 2)||(nmarktype == 4)||(roadviewitem::IsDrawMark(xvepre[k].mS)))
-                    {
-                        xpath.moveTo(xvepre[k].mfX + flmw * cos(xvenxt[k].mfhdg - M_PI/2.0),
-                                     (xvepre[k].mfY+flmw * sin(xvenxt[k].mfhdg - M_PI/2.0))*(-1.0));
-                        xpath.lineTo(xvenxt[k].mfX+ flmw * cos(xvepre[k].mfhdg - M_PI/2.0),
-                                     (xvenxt[k].mfY+flmw * sin(xvepre[k].mfhdg - M_PI/2.0))*(-1.0));
-
-                        xpath.lineTo(xvenxt[k].mfX + 2*flmw * cos(xvenxt[k].mfhdg - M_PI/2.0),
-                                     (xvenxt[k].mfY+2*flmw * sin(xvenxt[k].mfhdg - M_PI/2.0))*(-1.0));
-                        xpath.lineTo(xvepre[k].mfX+ 2*flmw * cos(xvepre[k].mfhdg - M_PI/2.0),
-                                     (xvepre[k].mfY+2*flmw * sin(xvepre[k].mfhdg - M_PI/2.0))*(-1.0));
-                        xpath.closeSubpath();
-                        ncolor = xvepre[k].mnlanecolor;
-                    }
-                }
-            }
-
-            if(ncolor != -3)
-            {
-                QGraphicsPathItem * pitem = new QGraphicsPathItem;
-                pitem->setPath(xpath);
-                QColor brushcolor;
-                switch (ncolor) {
-                case 0:
-                    brushcolor = Qt::white;
-                    break;
-                case 1:
-                    brushcolor = Qt::blue;
-                    break;
-                case 2:
-                    brushcolor = Qt::green;
-                    break;
-                case 3:
-                    brushcolor = Qt::red;
-                    break;
-                case 4:
-                    brushcolor = Qt::white;
-                    break;
-                case 5:
-                    brushcolor = Qt::yellow;
-                    break;
-                case 6:
-                    brushcolor = Qt::yellow; //orange use yellow replace
-                    break;
-                default:
-                    brushcolor = Qt::white;
-                    break;
-                }
-                pitem->setBrush(brushcolor);
-                pitem->setPen(QPen(brushcolor,0.001));
-                pitem->setPos(mfViewMoveX + VIEW_WIDTH/2,-mfViewMoveY +VIEW_HEIGHT/2);
-                mpscene->addItem(pitem);
-                mvectorviewitem.push_back(pitem);
-            }
-
-
-
-
-//               }
-
+            QGraphicsPathItem * pitem = xvectormarkpath[j];
+            pitem->setPos(mfViewMoveX +VIEW_WIDTH/2,-mfViewMoveY+VIEW_HEIGHT/2);
+            mpscene->addItem(pitem);
+            mvectorviewitem.push_back(pitem);
         }
-
-
     }
-
+    mbRefresh = false;
 }
 
+
 void MainWindow::onViewModeChange(int index)
 {
     if(index == 1)

src/tool/map_lanetoxodr/mainwindow.h

@@ -69,6 +69,8 @@ using namespace Eigen;
 
 #include "roaddigit.h"
 
+#include "xodrscenfunc.h"
+
 namespace Ui {
 class MainWindow;
 }
@@ -395,7 +397,6 @@ private:
     int mnViewMode = 0; //Use Scene
 
     void UpdateScene();
-    void UpdateSceneRoad(Road * pRoad);
 
     std::vector<QGraphicsPathItem *> mvectorviewitem;
 

src/tool/map_lanetoxodr/map_lanetoxodr.pro

@@ -74,7 +74,8 @@ SOURCES += \
     geofit.cpp \
     circlefitting.cpp \
     xodrfunc.cpp \
-    xodrmake.cpp
+    xodrmake.cpp \
+    xodrscenfunc.cpp
 
 HEADERS += \
     autoconnect.h \
@@ -120,7 +121,8 @@ HEADERS += \
     geofit.h \
     circlefitting.h \
     xodrfunc.h \
-    xodrmake.h
+    xodrmake.h \
+    xodrscenfunc.h
 
 FORMS += \
         dialogaddroadfromrtk.ui \

src/tool/map_lanetoxodr/roaddigit.cpp

@@ -143,6 +143,8 @@ void RoadDigit::CalcLine(double fspace)
             int ncount = parc->GetLength() /fspace;
             if(ncount< 5)ncount = 5;
             double curv = parc->GetCurvature();
+            double arcrange = parc->GetLength()/R;
+            if((arcrange/0.1)>ncount)ncount = arcrange/0.1;
             double hdgstep;
             double hdg0 = parc->GetHdg();
             double hdgnow = parc->GetHdg();

src/tool/map_lanetoxodr/roadeditdialog.cpp

@@ -356,7 +356,7 @@ void RoadEditDialog::on_comboBox_Road_currentIndexChanged(int index)
 
     double froad_xmin,froad_ymin,froad_xmax,froad_ymax;
     ServiceXODRTool.GetRoadMaxMin(pRoad,froad_xmin,froad_ymin,froad_xmax,froad_ymax);
-    roadviewitem * prvw = new roadviewitem(pRoad);
+//    roadviewitem * prvw = new roadviewitem(pRoad);
 
     int nfac;
     int nkeep = 30;
@@ -383,10 +383,10 @@ void RoadEditDialog::on_comboBox_Road_currentIndexChanged(int index)
     mfViewMoveX = 0 - froad_xmin - (froad_xmax - froad_xmin)/2.0;
     mfViewMoveY = 0 + froad_ymin  + (froad_ymax-froad_ymin)/2.0;
 
-    prvw->setPos(mfViewMoveX,mfViewMoveY);
+//    prvw->setPos(mfViewMoveX,mfViewMoveY);
  //       prvw->setPos((froad_xmax - froad_xmin)/2.0, (froad_ymax-froad_ymin)/2.0);
 //    mvectorroadview.push_back(prvw);
-    prvw->setratio(1.0);
+ //   prvw->setratio(1.0);
 //    scene->addItem(prvw);
 
     mnSelGeo = -1;
@@ -401,190 +401,30 @@ void RoadEditDialog::on_comboBox_Road_currentIndexChanged(int index)
         ui->comboBox_Geo->addItem(QString("Geo ")+QString::number(i));
     }
 
-    double flmw = 0.15;
 
     RoadDigit xrd(mpCurRoad,0.1);
-    std::vector<iv::RoadDigitUnit> * pvectorrdu =  xrd.GetRDU();
-    nsize = pvectorrdu->size();
 
-    for(i=0;i<(nsize-1);i++)
+    std::vector<QGraphicsPathItem *> xvectorlanepath = xodrscenfunc::GetRoadLaneItem(&xrd);
+    int j;
+    int ncount = xvectorlanepath.size();
+    for(j=0;j<ncount;j++)
     {
-        std::vector<iv::LanePoint> xvepre = pvectorrdu->at(i).mvectorLanePoint;
-        std::vector<iv::LanePoint> xvenxt = pvectorrdu->at(i+1).mvectorLanePoint;
-        if((xvepre.size()<2)||(xvenxt.size()<2)||(xvenxt.size() != xvepre.size()))
-        {
-            continue;
-        }
-        unsigned int k;
-        for(k=0;k<(xvepre.size()-1);k++)
-        {
-            QPainterPath xpath;
-            xpath.moveTo(xvepre.at(k).mfX,xvepre.at(k).mfY*(-1));
-            xpath.lineTo(xvenxt.at(k).mfX,xvenxt.at(k).mfY*(-1));
-            xpath.lineTo(xvenxt.at(k+1).mfX,xvenxt.at(k+1).mfY*(-1));
-            xpath.lineTo(xvepre.at(k+1).mfX,xvepre.at(k+1).mfY*(-1));
-            xpath.closeSubpath();
-            QGraphicsPathItem * pitem = new QGraphicsPathItem;
-            pitem->setPath(xpath);
-            pitem->setPos(mfViewMoveX,mfViewMoveY);
-            int nlanetype = xvepre.at(k).mnlanetype;
-            if(xvepre.at(k).mnlane<=0)nlanetype = xvepre.at(k+1).mnlanetype;
-            QColor brushcolor = Qt::darkGray;
-            switch (nlanetype) {
-            case 2:
-                brushcolor = Qt::darkGray;
-                break;
-            case 8:
-                brushcolor = Qt::red;
-                break;
-            case 9:
-                brushcolor = QColor(0xB2,0xB2,0xD6);
-                break;
-            default:
-                brushcolor = Qt::darkGreen;
-                break;
-            }
-            pitem->setBrush(brushcolor);
-            pitem->setPen(QPen(brushcolor,0.001));
-            scene->addItem(pitem);
-            mvectorviewitem.push_back(pitem);
-        }
+        QGraphicsPathItem * pitem = xvectorlanepath[j];
+        pitem->setPos(mfViewMoveX,mfViewMoveY);
+        scene->addItem(pitem);
+        mvectorviewitem.push_back(pitem);
     }
 
-    for(i=0;i<(nsize-1);i++)
+    std::vector<QGraphicsPathItem *> xvectormarkpath = xodrscenfunc::GetRoadMarkItem(&xrd);
+    ncount = xvectormarkpath.size();
+    for(j=0;j<ncount;j++)
     {
-        std::vector<iv::LanePoint> xvepre = pvectorrdu->at(i).mvectorLanePoint;
-        std::vector<iv::LanePoint> xvenxt = pvectorrdu->at(i+1).mvectorLanePoint;
-        if(xvenxt.size() != xvepre.size())
-        {
-            continue;
-        }
-        unsigned int k;
-        for(k=0;k<(xvepre.size());k++)
-        {
-            QPainterPath xpath;
-            int ncolor = -3;
-            int nmarktype = xvepre[k].mnlanemarktype;
-            if(nmarktype >= 0)
-            {
-                if(nmarktype<2)
-                {
-                    if((nmarktype == 0)||(IsDrawMark(xvepre[k].mS)))
-                    {
-                        xpath.moveTo(xvepre[k].mfX + 0.5*flmw * cos(xvenxt[k].mfhdg - M_PI/2.0),
-                                     (xvepre[k].mfY+0.5*flmw * sin(xvenxt[k].mfhdg - M_PI/2.0))*(-1.0));
-                        xpath.lineTo(xvenxt[k].mfX+ 0.5*flmw * cos(xvepre[k].mfhdg - M_PI/2.0),
-                                     (xvenxt[k].mfY+0.5*flmw * sin(xvepre[k].mfhdg - M_PI/2.0))*(-1.0));
-                        xpath.lineTo(xvenxt[k].mfX + 0.5*flmw * cos(xvenxt[k].mfhdg + M_PI/2.0),
-                                     (xvenxt[k].mfY+0.5*flmw * sin(xvenxt[k].mfhdg + M_PI/2.0))*(-1.0));
-                        xpath.lineTo(xvepre[k].mfX+ 0.5*flmw * cos(xvepre[k].mfhdg + M_PI/2.0),
-                                     (xvepre[k].mfY+0.5*flmw * sin(xvepre[k].mfhdg + M_PI/2.0))*(-1.0));
-                        xpath.closeSubpath();
-                        ncolor = xvepre[k].mnlanecolor;
-
-
-                    }
-                }
-                else
-                {
-                    if((nmarktype == 2)||(nmarktype == 3)||(IsDrawMark(xvepre[k].mS)))
-                    {
-                        xpath.moveTo(xvepre[k].mfX + flmw * cos(xvenxt[k].mfhdg + M_PI/2.0),
-                                     (xvepre[k].mfY+flmw * sin(xvenxt[k].mfhdg + M_PI/2.0))*(-1.0));
-                        xpath.lineTo(xvenxt[k].mfX+ flmw * cos(xvepre[k].mfhdg + M_PI/2.0),
-                                     (xvenxt[k].mfY+flmw * sin(xvepre[k].mfhdg + M_PI/2.0))*(-1.0));
-
-                        xpath.lineTo(xvenxt[k].mfX + 2*flmw * cos(xvenxt[k].mfhdg + M_PI/2.0),
-                                     (xvenxt[k].mfY+2*flmw * sin(xvenxt[k].mfhdg + M_PI/2.0))*(-1.0));
-                        xpath.lineTo(xvepre[k].mfX+ 2*flmw * cos(xvepre[k].mfhdg + M_PI/2.0),
-                                     (xvepre[k].mfY+2*flmw * sin(xvepre[k].mfhdg + M_PI/2.0))*(-1.0));
-                        xpath.closeSubpath();
-                        ncolor = xvepre[k].mnlanecolor;
-                    }
-                    if((nmarktype == 2)||(nmarktype == 4)||(IsDrawMark(xvepre[k].mS)))
-                    {
-                        xpath.moveTo(xvepre[k].mfX + flmw * cos(xvenxt[k].mfhdg - M_PI/2.0),
-                                     (xvepre[k].mfY+flmw * sin(xvenxt[k].mfhdg - M_PI/2.0))*(-1.0));
-                        xpath.lineTo(xvenxt[k].mfX+ flmw * cos(xvepre[k].mfhdg - M_PI/2.0),
-                                     (xvenxt[k].mfY+flmw * sin(xvepre[k].mfhdg - M_PI/2.0))*(-1.0));
-
-                        xpath.lineTo(xvenxt[k].mfX + 2*flmw * cos(xvenxt[k].mfhdg - M_PI/2.0),
-                                     (xvenxt[k].mfY+2*flmw * sin(xvenxt[k].mfhdg - M_PI/2.0))*(-1.0));
-                        xpath.lineTo(xvepre[k].mfX+ 2*flmw * cos(xvepre[k].mfhdg - M_PI/2.0),
-                                     (xvepre[k].mfY+2*flmw * sin(xvepre[k].mfhdg - M_PI/2.0))*(-1.0));
-                        xpath.closeSubpath();
-                        ncolor = xvepre[k].mnlanecolor;
-                    }
-                }
-            }
-
-            if(ncolor != -3)
-            {
-                QGraphicsPathItem * pitem = new QGraphicsPathItem;
-                pitem->setPath(xpath);
-                QColor brushcolor;
-                switch (ncolor) {
-                case 0:
-                    brushcolor = Qt::white;
-                    break;
-                case 1:
-                    brushcolor = Qt::blue;
-                    break;
-                case 2:
-                    brushcolor = Qt::green;
-                    break;
-                case 3:
-                    brushcolor = Qt::red;
-                    break;
-                case 4:
-                    brushcolor = Qt::white;
-                    break;
-                case 5:
-                    brushcolor = Qt::yellow;
-                    break;
-                case 6:
-                    brushcolor = Qt::yellow; //orange use yellow replace
-                    break;
-                default:
-                    brushcolor = Qt::white;
-                    break;
-                }
-                pitem->setBrush(brushcolor);
-                pitem->setPen(QPen(brushcolor,0.001));
-                pitem->setPos(mfViewMoveX,mfViewMoveY);
-                scene->addItem(pitem);
-                mvectorviewitem.push_back(pitem);
-            }
-
-
-
-
-//               }
-
-        }
-
-
+        QGraphicsPathItem * pitem = xvectormarkpath[j];
+        pitem->setPos(mfViewMoveX,mfViewMoveY);
+        scene->addItem(pitem);
+        mvectorviewitem.push_back(pitem);
     }
 
-//    for(i=0;i<(nsize-1);i++)
-//    {
-//        QPainterPath xpath;
-//        std::vector<iv::LanePoint> * pvectorLP1 = &pvectorrdu->at(i).mvectorLanePoint;
-//        std::vector<iv::LanePoint> * pvectorLP2 = &pvectorrdu->at(i+1).mvectorLanePoint;
-//        xpath.moveTo(pvectorLP1->at(0).mfX,pvectorLP1->at(0).mfY*(-1));
-//        xpath.lineTo(pvectorLP2->at(0).mfX,pvectorLP2->at(0).mfY*(-1));
-//        xpath.lineTo(pvectorLP2->at(pvectorLP2->size()-1).mfX,pvectorLP2->at(pvectorLP2->size()-1).mfY*(-1));
-//        xpath.lineTo(pvectorLP1->at(pvectorLP1->size()-1).mfX,pvectorLP1->at(pvectorLP1->size()-1).mfY*(-1));
-//        xpath.closeSubpath();
-//        QGraphicsPathItem * pitem = new QGraphicsPathItem;
-//        pitem->setPath(xpath);
-//        pitem->setPos(mfViewMoveX,mfViewMoveY);
-//        pitem->setBrush(Qt::darkGray);
-//        pitem->setPen(QPen(Qt::darkGray,0.001));
-//        scene->addItem(pitem);
-//        mvectorviewitem.push_back(pitem);
-//    }
-
     update();
 }
 

src/tool/map_lanetoxodr/roadeditdialog.h

@@ -21,6 +21,7 @@
 #include "dialogroadmirror.h"
 
 #include "roaddigit.h"
+#include "xodrscenfunc.h"
 
 namespace Ui {
 class RoadEditDialog;

src/tool/map_lanetoxodr/xodrscenfunc.cpp

@@ -0,0 +1,226 @@
+#include "xodrscenfunc.h"
+
+xodrscenfunc::xodrscenfunc()
+{
+
+}
+
+std::vector<QGraphicsPathItem *> xodrscenfunc::GetRoadLaneItem(RoadDigit *prd)
+{
+    std::vector<QGraphicsPathItem *> xvectorgrapath;
+    std::vector<iv::RoadDigitUnit> * pvectorrdu =  prd->GetRDU();
+    int nsize = pvectorrdu->size();
+    int i;
+    for(i=0;i<(nsize-1);i++)
+    {
+        std::vector<iv::LanePoint> xvepre = pvectorrdu->at(i).mvectorLanePoint;
+        std::vector<iv::LanePoint> xvenxt = pvectorrdu->at(i+1).mvectorLanePoint;
+        if((xvepre.size()<2)||(xvenxt.size()<2)||(xvenxt.size() != xvepre.size()))
+        {
+            continue;
+        }
+        unsigned int k;
+        for(k=0;k<(xvepre.size()-1);k++)
+        {
+            QPainterPath xpath;
+            xpath.moveTo(xvepre.at(k).mfX,xvepre.at(k).mfY*(-1));
+            xpath.lineTo(xvenxt.at(k).mfX,xvenxt.at(k).mfY*(-1));
+            xpath.lineTo(xvenxt.at(k+1).mfX,xvenxt.at(k+1).mfY*(-1));
+            xpath.lineTo(xvepre.at(k+1).mfX,xvepre.at(k+1).mfY*(-1));
+            xpath.closeSubpath();
+            QGraphicsPathItem * pitem = new QGraphicsPathItem;
+            pitem->setPath(xpath);
+//            pitem->setPos(mfViewMoveX +VIEW_WIDTH/2,-mfViewMoveY+VIEW_HEIGHT/2);
+            int nlanetype = xvepre.at(k).mnlanetype;
+            if(xvepre.at(k).mnlane<=0)nlanetype = xvepre.at(k+1).mnlanetype;
+            QColor brushcolor = Qt::darkGray;
+            switch (nlanetype) {
+            case 2:
+                brushcolor = Qt::darkGray;
+                break;
+            case 8:
+                brushcolor = Qt::red;
+                break;
+            case 9:
+                brushcolor = QColor(0xB2,0xB2,0xD6);
+                break;
+            default:
+                brushcolor = Qt::darkGreen;
+                break;
+            }
+            pitem->setBrush(brushcolor);
+            pitem->setPen(QPen(brushcolor,0.001));
+  //          mpscene->addItem(pitem);
+            xvectorgrapath.push_back(pitem);
+        }
+    }
+
+    return xvectorgrapath;
+
+
+}
+
+std::vector<QGraphicsPathItem *> xodrscenfunc::GetRoadMarkItem(RoadDigit *prd)
+{
+    std::vector<QGraphicsPathItem *> xvectorgrapath;
+    std::vector<iv::RoadDigitUnit> * pvectorrdu =  prd->GetRDU();
+    int nsize = pvectorrdu->size();
+    int i;
+    double flmw = 0.15;
+
+    for(i=0;i<(nsize-1);i++)
+    {
+        std::vector<iv::LanePoint> xvepre = pvectorrdu->at(i).mvectorLanePoint;
+        std::vector<iv::LanePoint> xvenxt = pvectorrdu->at(i+1).mvectorLanePoint;
+        if(xvenxt.size() != xvepre.size())
+        {
+            continue;
+        }
+        unsigned int k;
+        int noldmarktype = -1;
+        double foldx1,foldy1,foldx2,foldy2;
+//        double foldx1_2,foldy1_2,foldx2_2,foldy2_2;
+        double fx1,fx2,fx3,fx4,fy1,fy2,fy3,fy4;
+        for(k=0;k<(xvepre.size());k++)
+        {
+            QPainterPath xpath;
+            int ncolor = -3;
+            int nmarktype = xvepre[k].mnlanemarktype;
+            if(nmarktype >= 0)
+            {
+                if(nmarktype<2)
+                {
+                    if((nmarktype == 0)||(IsDrawMark(xvepre[k].mS)))
+                    {
+                        fx1 = xvepre[k].mfX + 0.5*flmw * cos(xvepre[k].mfhdg - M_PI/2.0);
+                        fy1 = (xvepre[k].mfY+0.5*flmw * sin(xvepre[k].mfhdg - M_PI/2.0))*(-1.0);
+                        fx2 = xvenxt[k].mfX+ 0.5*flmw * cos(xvenxt[k].mfhdg - M_PI/2.0);
+                        fy2 = (xvenxt[k].mfY+0.5*flmw * sin(xvenxt[k].mfhdg - M_PI/2.0))*(-1.0);
+                        fx3 = xvenxt[k].mfX + 0.5*flmw * cos(xvenxt[k].mfhdg + M_PI/2.0);
+                        fy3 = (xvenxt[k].mfY+0.5*flmw * sin(xvenxt[k].mfhdg + M_PI/2.0))*(-1.0);
+                        fx4 = xvepre[k].mfX+ 0.5*flmw * cos(xvepre[k].mfhdg + M_PI/2.0);
+                        fy4 = (xvepre[k].mfY+0.5*flmw * sin(xvepre[k].mfhdg + M_PI/2.0))*(-1.0);
+                        if(noldmarktype != nmarktype)
+                        {
+                        xpath.moveTo(fx1,fy1);
+                        xpath.lineTo(fx2,fy2);
+                        xpath.lineTo(fx3,fy3);
+                        xpath.lineTo(fx4,fy4);
+                        xpath.closeSubpath();
+                        }
+                        else
+                        {
+                            xpath.moveTo(foldx1,foldy1);
+                            xpath.lineTo(fx2,fy2);
+                            xpath.lineTo(fx3,fy3);
+                            xpath.lineTo(foldx2,foldy2);
+                            xpath.closeSubpath();
+                            foldx1 = fx2;
+                            foldy1 = fy2;
+                            foldx2 = fx3;
+                            foldy2 = fy3;
+                            noldmarktype = nmarktype;
+                        }
+                        ncolor = xvepre[k].mnlanecolor;
+
+
+                    }
+                }
+                else
+                {
+                    if((nmarktype == 2)||(nmarktype == 3)||(IsDrawMark(xvepre[k].mS)))
+                    {
+                        xpath.moveTo(xvepre[k].mfX + flmw * cos(xvenxt[k].mfhdg + M_PI/2.0),
+                                     (xvepre[k].mfY+flmw * sin(xvenxt[k].mfhdg + M_PI/2.0))*(-1.0));
+                        xpath.lineTo(xvenxt[k].mfX+ flmw * cos(xvepre[k].mfhdg + M_PI/2.0),
+                                     (xvenxt[k].mfY+flmw * sin(xvepre[k].mfhdg + M_PI/2.0))*(-1.0));
+
+                        xpath.lineTo(xvenxt[k].mfX + 2*flmw * cos(xvenxt[k].mfhdg + M_PI/2.0),
+                                     (xvenxt[k].mfY+2*flmw * sin(xvenxt[k].mfhdg + M_PI/2.0))*(-1.0));
+                        xpath.lineTo(xvepre[k].mfX+ 2*flmw * cos(xvepre[k].mfhdg + M_PI/2.0),
+                                     (xvepre[k].mfY+2*flmw * sin(xvepre[k].mfhdg + M_PI/2.0))*(-1.0));
+                        xpath.closeSubpath();
+                        ncolor = xvepre[k].mnlanecolor;
+                    }
+                    if((nmarktype == 2)||(nmarktype == 4)||(IsDrawMark(xvepre[k].mS)))
+                    {
+                        xpath.moveTo(xvepre[k].mfX + flmw * cos(xvenxt[k].mfhdg - M_PI/2.0),
+                                     (xvepre[k].mfY+flmw * sin(xvenxt[k].mfhdg - M_PI/2.0))*(-1.0));
+                        xpath.lineTo(xvenxt[k].mfX+ flmw * cos(xvepre[k].mfhdg - M_PI/2.0),
+                                     (xvenxt[k].mfY+flmw * sin(xvepre[k].mfhdg - M_PI/2.0))*(-1.0));
+
+                        xpath.lineTo(xvenxt[k].mfX + 2*flmw * cos(xvenxt[k].mfhdg - M_PI/2.0),
+                                     (xvenxt[k].mfY+2*flmw * sin(xvenxt[k].mfhdg - M_PI/2.0))*(-1.0));
+                        xpath.lineTo(xvepre[k].mfX+ 2*flmw * cos(xvepre[k].mfhdg - M_PI/2.0),
+                                     (xvepre[k].mfY+2*flmw * sin(xvepre[k].mfhdg - M_PI/2.0))*(-1.0));
+                        xpath.closeSubpath();
+                        ncolor = xvepre[k].mnlanecolor;
+                    }
+
+                }
+            }
+
+            if(ncolor != -3)
+            {
+                QGraphicsPathItem * pitem = new QGraphicsPathItem;
+                pitem->setPath(xpath);
+                QColor brushcolor;
+                switch (ncolor) {
+                case 0:
+                    brushcolor = Qt::white;
+                    break;
+                case 1:
+                    brushcolor = Qt::blue;
+                    break;
+                case 2:
+                    brushcolor = Qt::green;
+                    break;
+                case 3:
+                    brushcolor = Qt::red;
+                    break;
+                case 4:
+                    brushcolor = Qt::white;
+                    break;
+                case 5:
+                    brushcolor = Qt::yellow;
+                    break;
+                case 6:
+                    brushcolor = Qt::yellow; //orange use yellow replace
+                    break;
+                default:
+                    brushcolor = Qt::white;
+                    break;
+                }
+                pitem->setBrush(brushcolor);
+                pitem->setPen(QPen(brushcolor,0.001));
+//                pitem->setPos(mfViewMoveX + VIEW_WIDTH/2,-mfViewMoveY +VIEW_HEIGHT/2);
+//                mpscene->addItem(pitem);
+                xvectorgrapath.push_back(pitem);
+            }
+            else
+            {
+                noldmarktype = -1;
+            }
+
+
+        }
+
+    }
+
+    return xvectorgrapath;
+
+
+}
+
+bool xodrscenfunc::IsDrawMark(double s)
+{
+    const double dotdis = 10.0;
+    const double dotlen = 5.0;
+
+    double  y = fmod(s,dotdis);
+    if(y>dotlen)return true;
+    else
+    {
+        return false;
+    }
+}

src/tool/map_lanetoxodr/xodrscenfunc.h

@@ -0,0 +1,26 @@
+#ifndef XODRSCENFUNC_H
+#define XODRSCENFUNC_H
+
+#include <QGraphicsScene>
+
+#include <QGraphicsPathItem>
+
+#include "xodrmake.h"
+
+#include "roaddigit.h"
+
+
+class xodrscenfunc
+{
+public:
+    xodrscenfunc();
+
+public:
+    static std::vector<QGraphicsPathItem *> GetRoadLaneItem(RoadDigit * prd);
+    static std::vector<QGraphicsPathItem *> GetRoadMarkItem(RoadDigit * prd);
+
+public:
+    static bool IsDrawMark(double s);
+};
+
+#endif // XODRSCENFUNC_H