change tool/map_lanetoxodr. add grahpicscene, but not complete.

src/tool/map_lanetoxodr/mainwindow.cpp

@@ -54,6 +54,9 @@ MainWindow::MainWindow(QWidget *parent) :
 
     scene = new QGraphicsScene;
 
+    mpscene = new  QGraphicsScene(-300, -300, 600, 600);
+    mpscene->setBackgroundBrush(Qt::darkGreen);
+
 
  //    painter->begin(image);
 
@@ -370,6 +373,16 @@ void MainWindow::ExecPainter()
 void MainWindow::paintEvent(QPaintEvent *)
 {
 
+    if(mnViewMode == 1)
+    {
+        if(mbRefresh)
+        {
+            UpdateScene();
+        }
+        myview->setScene(mpscene);
+        myview->show();
+        return;
+    }
     if(mbRefresh)
     {
         ExecPainter();
@@ -422,6 +435,21 @@ void MainWindow::CreateTab1View(QTabWidget * p)
     int nLEWidth = mnFontHeight * 6;
     int nLEHeight = mnFontHeight * 3/2;
 
+    pLabel = new QLabel(pGroup);
+    pLabel->setText("View Mode");
+    pLabel->setGeometry(nXPos,nYPos,nLEWidth,nLEHeight);
+    nXPos = nXPos + nSpace;
+
+    pCB = new QComboBox(pGroup);
+    pCB->addItem("Line");
+    pCB->addItem("Scene");
+    pCB->setCurrentIndex(0);
+    pCB->setGeometry(nXPos,nYPos,nLEWidth,nLEHeight);
+    connect(pCB,SIGNAL(currentIndexChanged(int)),this,SLOT(onViewModeChange(int)));
+
+    nXPos = 10;
+    nYPos = nYPos + mnFontHeight * 3;
+
     pLabel = new QLabel(pGroup);
     pLabel->setText("Lat0");
     pLabel->setGeometry(nXPos,nYPos,nLEWidth,nLEHeight);
@@ -5030,3 +5058,199 @@ void MainWindow::on_actionSplit_Road_triggered()
 {
 
 }
+
+void MainWindow::UpdateScene()
+{
+
+    int i;
+    int nsize = mvectorviewitem.size();
+    for(i=0;i<nsize;i++)
+    {
+        mpscene->removeItem(mvectorviewitem.at(i));
+        delete mvectorviewitem.at(i);
+    }
+    mvectorviewitem.clear();
+
+    nsize = mxodr.GetRoadCount();
+    for(i=0;i<nsize;i++)
+    {
+        UpdateSceneRoad(mxodr.GetRoad(i));
+//        qDebug("update road %d",i);
+    }
+    mbRefresh = false;
+}
+
+void MainWindow::UpdateSceneRoad(Road *pRoad)
+{
+    RoadDigit xrd(pRoad,1.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++)
+    {
+        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);
+        }
+    }
+
+    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;
+        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)||(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,mfViewMoveY);
+                mpscene->addItem(pitem);
+                mvectorviewitem.push_back(pitem);
+            }
+
+
+
+
+//               }
+
+        }
+
+
+    }
+
+}
+
+void MainWindow::onViewModeChange(int index)
+{
+    mnViewMode = index;
+    mbRefresh = true;
+    update();
+}

src/tool/map_lanetoxodr/mainwindow.h

@@ -67,6 +67,8 @@ using namespace Eigen;
 
 #include "xodrmake.h"
 
+#include "roaddigit.h"
+
 namespace Ui {
 class MainWindow;
 }
@@ -88,6 +90,9 @@ private:
     QTimer *timer;
     QGraphicsScene *scene;
 
+    QGraphicsScene * mpscene;
+
+
 public:
     static void ComboToString(std::string strroadid,QComboBox * pCB);
 
@@ -185,6 +190,8 @@ private slots:
 
     void on_actionSplit_Road_triggered();
 
+    void onViewModeChange(int index);
+
 private:
 
 
@@ -385,6 +392,13 @@ private:
     void updateCBRoad();
     void updateJunction();
 
+    int mnViewMode = 0; //Use Scene
+
+    void UpdateScene();
+    void UpdateSceneRoad(Road * pRoad);
+
+    std::vector<QGraphicsPathItem *> mvectorviewitem;
+
 
 };
 

src/tool/map_lanetoxodr/map_lanetoxodr.pro

@@ -41,6 +41,7 @@ SOURCES += \
     ivxodrtool.cpp \
         main.cpp \
         mainwindow.cpp \
+    roaddigit.cpp \
     roadeditdialog.cpp \
     roadviewitem.cpp \
     speeddialog.cpp \
@@ -89,6 +90,7 @@ HEADERS += \
     ivxodrtool.h \
         mainwindow.h \
     rawtype.h \
+    roaddigit.h \
     roadeditdialog.h \
     roadviewitem.h \
     speeddialog.h \

src/tool/map_lanetoxodr/roaddigit.cpp

@@ -0,0 +1,254 @@
+#include "roaddigit.h"
+
+#include <math.h>
+#include "xodrfunc.h"
+
+
+RoadDigit::RoadDigit(Road * pRoad,double fspace)
+{
+    mpRoad = pRoad;
+    UpdateSpace(fspace);
+}
+
+std::vector<iv::RoadDigitUnit> * RoadDigit::GetRDU()
+{
+    return &mvectorRDU;
+}
+
+void RoadDigit::UpdateSpace(double fspace)
+{
+    if(mpRoad == 0)return;
+    CalcLine(fspace);
+    CalcLane();
+}
+
+void RoadDigit::CalcLine(double fspace)
+{
+    unsigned int j;
+    iv::RoadDigitUnit rdu;
+
+
+    for(j=0;j<mpRoad->GetGeometryBlockCount();j++)
+    {
+
+        GeometryBlock * pgeob = mpRoad->GetGeometryBlock(j);
+        double x,y;
+        double x_center,y_center;
+        double R;
+        RoadGeometry * pg;
+        GeometryArc * parc;
+        GeometryParamPoly3 * ppp3;
+        GeometrySpiral *pSpiral;
+        double rel_x,rel_y,rel_hdg;
+        pg = pgeob->GetGeometryAt(0);
+        x = pg->GetX();
+        y = pg->GetY();
+
+        switch (pg->GetGeomType()) {
+        case 0:
+        {
+
+            rdu.mS = pg->GetS();
+            rdu.mX = pg->GetX();
+            rdu.mY = pg->GetY();
+            rdu.mfHdg = pg->GetHdg();
+            mvectorRDU.push_back(rdu);
+            int ncount = pg->GetLength() /fspace;
+            if(ncount<2)ncount = 2;
+            double fstep;
+            if(ncount > 0)fstep = pg->GetLength()/ncount;
+            int i;
+            for(i=1;i<ncount;i++)
+            {
+                double xtem,ytem;
+                xtem = x + (i*fstep)*cos(pg->GetHdg());
+                ytem = y + (i*fstep)*sin(pg->GetHdg());
+
+                rdu.mS = pg->GetS() + i*fstep;
+                rdu.mX = xtem;
+                rdu.mY = ytem;
+                rdu.mfHdg = pg->GetHdg();
+                mvectorRDU.push_back(rdu);
+
+            }
+        }
+            break;
+
+        case 1:
+            pSpiral = (GeometrySpiral * )pg;
+            {
+               int ncount = pSpiral->GetLength()/fspace;
+               if(ncount < 5)ncount = 5;
+               double sstep = pSpiral->GetLength()/((double)ncount);
+               int k;
+               double x0,y0,hdg0,s0;
+               x0 = pSpiral->GetX();
+               y0 = pSpiral->GetY();
+               s0 = pSpiral->GetS();
+               hdg0 = pSpiral->GetHdg() ;
+
+               rdu.mS = s0;
+               rdu.mX = x0;
+               rdu.mY = y0;
+               rdu.mfHdg = hdg0;
+               mvectorRDU.push_back(rdu);
+
+
+               pSpiral->GetCoords(s0,rel_x,rel_y,rel_hdg);
+
+               for(k=1;k<=ncount;k++)
+               {
+                   pSpiral->GetCoords(s0+sstep*k,rel_x,rel_y,rel_hdg);
+
+                   rdu.mS = s0 + sstep * k;
+                   rdu.mX = rel_x;
+                   rdu.mY = rel_y;
+                   rdu.mfHdg = rel_hdg;
+                   mvectorRDU.push_back(rdu);
+
+            }
+        }
+
+            break;
+        case 2:
+            {
+            parc = (GeometryArc *)pg;
+            R = abs(1.0/parc->GetCurvature());
+            if(parc->GetCurvature() > 0)
+            {
+                x_center = pg->GetX() + R *cos(pg->GetHdg() + M_PI/2.0);
+                y_center = pg->GetY() + R * sin(pg->GetHdg() + M_PI/2.0);
+            }
+            else
+            {
+                x_center = pg->GetX() + R *cos(pg->GetHdg() -M_PI/2.0);
+                y_center = pg->GetY() + R * sin(pg->GetHdg() - M_PI/2.0);
+            }
+
+            rdu.mS = pg->GetS();
+            rdu.mX = pg->GetX();
+            rdu.mY = pg->GetY();
+            rdu.mfHdg = pg->GetHdg();
+            mvectorRDU.push_back(rdu);
+
+            int k;
+            int ncount = parc->GetLength() /fspace;
+            if(ncount< 5)ncount = 5;
+            double curv = parc->GetCurvature();
+            double hdgstep;
+            double hdg0 = parc->GetHdg();
+            double hdgnow = parc->GetHdg();
+            if(ncount > 0) hdgstep= (parc->GetLength()/R)/ncount;
+
+            double x_draw,y_draw;
+
+            if(curv > 0)
+            {
+                hdgnow =  hdg0 ;
+                x_draw = x_center + R *cos(hdgnow - M_PI/2.0);
+                y_draw = y_center + R * sin(hdgnow - M_PI/2.0);
+            }
+            else
+            {
+                hdgnow = hdg0;
+                x_draw = x_center + R *cos(hdgnow  + M_PI/2.0);
+                y_draw = y_center + R * sin(hdgnow + M_PI/2.0);
+            }
+
+
+            for(k=1;k<=ncount;k++)
+            {
+
+
+                if(curv > 0)
+                {
+                    hdgnow =  hdg0 + k*hdgstep;
+                    x_draw = x_center + R *cos(hdgnow - M_PI/2.0);
+                    y_draw = y_center + R * sin(hdgnow - M_PI/2.0);
+                }
+                else
+                {
+                    hdgnow = hdg0 - k * hdgstep;
+                    x_draw = x_center + R *cos(hdgnow  + M_PI/2.0);
+                    y_draw = y_center + R * sin(hdgnow + M_PI/2.0);
+                }
+
+                rdu.mS = pg->GetS() + hdgstep * k* R;
+                rdu.mX = x_draw;
+                rdu.mY = y_draw;
+                rdu.mfHdg = hdgnow;
+                mvectorRDU.push_back(rdu);
+
+
+
+            }
+            }
+            break;
+        case 4:
+            {
+            ppp3 = (GeometryParamPoly3 * )pg;
+            int ncount = ppp3->GetLength() /fspace;
+            if(ncount < 5)ncount = 5;
+            double sstep;
+            if(ncount > 0)sstep = ppp3->GetLength()/ncount;
+            else sstep = 10000.0;
+            double s = 0;
+            double xtem,ytem;
+            xtem = ppp3->GetuA() +  ppp3->GetuB() * s +  ppp3->GetuC() * s*s +  ppp3->GetuD() * s*s*s;
+            ytem = ppp3->GetvA() + ppp3->GetvB() * s + ppp3->GetvC() * s*s + ppp3->GetvD() * s*s*s;
+            x = xtem*cos(ppp3->GetHdg()) - ytem * sin(ppp3->GetHdg()) + ppp3->GetX();
+            y = xtem*sin(ppp3->GetHdg()) + ytem * cos(ppp3->GetHdg()) + ppp3->GetY();
+            s = s+ sstep;
+
+            rdu.mS = pg->GetS();
+            rdu.mX = pg->GetX();
+            rdu.mY = pg->GetY();
+            rdu.mfHdg = pg->GetHdg();
+            mvectorRDU.push_back(rdu);
+
+            double flastx = pg->GetX();
+            double flasty = pg->GetY();
+            while(s <= ppp3->GetLength())
+            {
+
+                xtem = ppp3->GetuA() +  ppp3->GetuB() * s +  ppp3->GetuC() * s*s +  ppp3->GetuD() * s*s*s;
+                ytem = ppp3->GetvA() + ppp3->GetvB() * s + ppp3->GetvC() * s*s + ppp3->GetvD() * s*s*s;
+                x = xtem*cos(ppp3->GetHdg()) - ytem * sin(ppp3->GetHdg()) + ppp3->GetX();
+                y = xtem*sin(ppp3->GetHdg()) + ytem * cos(ppp3->GetHdg()) + ppp3->GetY();
+
+                rdu.mS = pg->GetS() + s;
+                rdu.mX = x;
+                rdu.mY = y;
+                rdu.mfHdg = xodrfunc::CalcHdg(QPointF(flastx,flasty),QPointF(x,y));
+                mvectorRDU.push_back(rdu);
+
+                s = s+ sstep;
+
+
+            }
+            }
+            break;
+        default:
+            break;
+        }
+
+//         painter->drawPoint((int)(x*mnfac),(int)(y*(-1.0*mnfac)));
+
+    }
+
+}
+
+void RoadDigit::CalcLane()
+{
+    int i;
+    int ncount = mvectorRDU.size();
+    for(i=0;i<ncount;i++)
+    {
+
+        std::vector<iv::LanePoint> xvectorlp2 = xodrfunc::GetAllLanePoint(mpRoad,mvectorRDU[i].mS,
+                                                                          mvectorRDU[i].mX,mvectorRDU[i].mY,mvectorRDU[i].mfHdg);
+        mvectorRDU[i].mvectorLanePoint = xvectorlp2;
+    }
+}
+
+

src/tool/map_lanetoxodr/roaddigit.h

@@ -0,0 +1,56 @@
+#ifndef ROADDIGIT_H
+#define ROADDIGIT_H
+
+#include "OpenDrive/OpenDrive.h"
+
+#include <vector>
+
+#include "xodrfunc.h"
+
+namespace iv {
+
+
+struct lanexy
+{
+    int nLane;
+    double mX;
+    double mY;
+    double mCenterX;
+    double mCenterY;
+    int mType = 0;
+    int mnMarkColor;
+    int mMarkType = -1;  //if -1 no mark
+    int mnChange = 0;
+    std::vector<int> mvectorsignal;
+};
+
+struct RoadDigitUnit
+{
+    double mS;
+    double mX;
+    double mY;
+    double mfHdg;
+    std::vector<iv::LanePoint> mvectorLanePoint;
+};
+
+}
+
+class RoadDigit
+{
+public:
+    RoadDigit(Road * pRoad,double fspace);
+
+private:
+    std::vector<iv::RoadDigitUnit> mvectorRDU;
+    Road * mpRoad = 0;
+
+private:
+    void CalcLine(double fspace);
+    void CalcLane();
+
+public:
+    std::vector<iv::RoadDigitUnit> * GetRDU();
+    void UpdateSpace(double fspace);
+};
+
+#endif // ROADDIGIT_H

src/tool/map_lanetoxodr/roadeditdialog.cpp

@@ -312,6 +312,19 @@ void RoadEditDialog::on_comboBox_Road_activated(const QString &arg1)
 
 }
 
+bool RoadEditDialog::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;
+    }
+}
+
 void RoadEditDialog::on_comboBox_Road_currentIndexChanged(int index)
 {
     Road * pRoad = mpxodr->GetRoad(index);
@@ -332,6 +345,14 @@ void RoadEditDialog::on_comboBox_Road_currentIndexChanged(int index)
     }
     mvectorroadview.clear();
 
+    nsize = mvectorviewitem.size();
+    for(i=0;i<nsize;i++)
+    {
+        scene->removeItem(mvectorviewitem.at(i));
+        delete mvectorviewitem.at(i);
+    }
+    mvectorviewitem.clear();
+
 
     double froad_xmin,froad_ymin,froad_xmax,froad_ymax;
     ServiceXODRTool.GetRoadMaxMin(pRoad,froad_xmin,froad_ymin,froad_xmax,froad_ymax);
@@ -364,9 +385,9 @@ void RoadEditDialog::on_comboBox_Road_currentIndexChanged(int index)
 
     prvw->setPos(mfViewMoveX,mfViewMoveY);
  //       prvw->setPos((froad_xmax - froad_xmin)/2.0, (froad_ymax-froad_ymin)/2.0);
-    mvectorroadview.push_back(prvw);
+//    mvectorroadview.push_back(prvw);
     prvw->setratio(1.0);
-    scene->addItem(prvw);
+//    scene->addItem(prvw);
 
     mnSelGeo = -1;
 
@@ -380,6 +401,190 @@ 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<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);
+        }
+    }
+
+    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;
+        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);
+            }
+
+
+
+
+//               }
+
+        }
+
+
+    }
+
+//    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

@@ -20,6 +20,8 @@
 #include "dialogroadrotate.h"
 #include "dialogroadmirror.h"
 
+#include "roaddigit.h"
+
 namespace Ui {
 class RoadEditDialog;
 }
@@ -60,6 +62,9 @@ private slots:
 
     void on_pushButton_MirrorRoad_clicked();
 
+private:
+    bool IsDrawMark(double s);
+
 private:
     Ui::RoadEditDialog *ui;
     OpenDrive * mpxodr;
@@ -76,6 +81,8 @@ private:
 
     std::vector<roadviewitem *> mvectorroadview;
 
+    std::vector<QGraphicsPathItem *> mvectorviewitem;
+
     double mfViewMoveX = 0;
     double mfViewMoveY = 0;
 };

src/tool/map_lanetoxodr/roadviewitem.cpp

@@ -12,6 +12,8 @@ roadviewitem::roadviewitem(Road * pRoad)
 {
     mpRoad = pRoad;
     mbNeedCalc = true;
+    QGraphicsPathItem x;
+
 }
 
 QRectF roadviewitem::boundingRect() const

src/tool/map_lanetoxodr/roadviewitem.h

@@ -101,8 +101,8 @@ private:
     bool mbShowLane = true;
     bool mbShowLine = false;
     bool mbShowRoadID = true;
-
-    bool IsDrawMark(double s);
+public:
+    static bool IsDrawMark(double s);
 };
 
 #endif // ROADVIEWITEM_H

src/tool/map_lanetoxodr/xodrfunc.cpp

@@ -601,6 +601,7 @@ std::vector<iv::LanePoint> xodrfunc::GetAllLanePoint(Road *pRoad,  const double
     int nLSCount = pRoad->GetLaneSectionCount();
     double s_section = 0;
 
+
     std::vector<iv::LanePoint> xvectorlanepoint;
     for(i=0;i<nLSCount;i++)
     {
@@ -627,7 +628,7 @@ std::vector<iv::LanePoint> xodrfunc::GetAllLanePoint(Road *pRoad,  const double
             int nlanetype = 2; //driving
             int nlanecolor = 0;
             int k;
-            double s_lane = 0;
+            double s_lane = s-s_section;
             for(k=0;k<pLane->GetLaneRoadMarkCount();k++)
             {
                  LaneRoadMark * plrm = pLane->GetLaneRoadMark(k);
@@ -638,6 +639,13 @@ std::vector<iv::LanePoint> xodrfunc::GetAllLanePoint(Road *pRoad,  const double
                          continue;
                      }
                  }
+                 else
+                 {
+                     if(s_lane<plrm->GetS())
+                     {
+                         continue;
+                     }
+                 }
                  if(plrm->GetType() == "solid")
                  {
                      nlanemarktype = 0;