change map_lanetoxodr. add some Object code.

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

@@ -2,6 +2,98 @@
 
 #include <iostream>
 
+Objects_bridge::Objects_bridge(double s,double length,std::string strid,std::string strtype)
+{
+    mS = s;
+    mlength = length;
+    mstrid = strid;
+    mstrtype = strtype;
+}
+
+double Objects_bridge::GetS()
+{
+    return mS;
+}
+
+double Objects_bridge::Getlength()
+{
+    return mlength;
+}
+
+int Objects_bridge::GetName(std::string name)
+{
+    if(mname.size() == 0)return 0;
+    name = mname[0];
+    return 1;
+}
+
+std::string Objects_bridge::Getid()
+{
+    return mstrid;
+}
+
+std::string Objects_bridge::Gettype()
+{
+    return mstrtype;
+}
+
+void Objects_bridge::SetS(double s)
+{
+    mS = s;
+}
+
+void Objects_bridge::Setlength(double length)
+{
+    mlength = length;
+}
+
+void Objects_bridge::Setname(std::string name)
+{
+    if(mname.size() == 0)mname.clear();
+    mname.push_back(name);
+}
+
+void Objects_bridge::Resetname()
+{
+    if(mname.size() == 0)mname.clear();
+}
+
+void Objects_bridge::Setid(std::string id)
+{
+    mstrid = id;
+}
+
+void Objects_bridge::Settype(std::string type)
+{
+    mstrtype = type;
+}
+
+Object_laneValidity::Object_laneValidity(int fromLane,int toLane)
+{
+    mfromLane = fromLane;
+    mtoLane = toLane;
+}
+
+int Object_laneValidity::GetfromLane()
+{
+    return  mfromLane;
+}
+
+int Object_laneValidity::GettoLane()
+{
+    return mtoLane;
+}
+
+void Object_laneValidity::SetfromLane(int fromLane)
+{
+    mfromLane = fromLane;
+}
+
+void Object_laneValidity::SettoLane(int toLane)
+{
+    mtoLane = toLane;
+}
+
 Object_borders_border::Object_borders_border(double width,std::string borderType,int outlineid)
 {
     mwidth = width;
@@ -81,7 +173,7 @@ Object_markings_marking_cornerReference * Object_borders_border::GetcornerRefere
 
 unsigned int Object_borders_border::GetcornerReferenceCount()
 {
-    return mcornerReference.size();
+    return static_cast<unsigned int >(mcornerReference.size())  ;
 }
 
 Object_markings_marking_cornerReference *	Object_borders_border::GetLastcornerReference()
@@ -92,7 +184,7 @@ Object_markings_marking_cornerReference *	Object_borders_border::GetLastcornerRe
 
 unsigned int Object_borders_border::AddcornerReference(unsigned int id)
 {
-    unsigned int index = mcornerReference.size();
+    unsigned int index = static_cast<unsigned int>(mcornerReference.size()) ;
     mcornerReference.push_back(Object_markings_marking_cornerReference(id));
     mnLastAddedcornerReference = index;
     return index;
@@ -1308,6 +1400,12 @@ Object_markings * Object::Getmarkings()
     return &(mObject_markings[0]);
 }
 
+Object_borders * Object::Getborders()
+{
+    if(mObject_borders.size()<1)return NULL;
+    return &(mObject_borders[0]);
+}
+
 void Object::Sett(double t)
 {
     mt = t;
@@ -1433,6 +1531,17 @@ void Object::Resetmarkings()
     if(mObject_markings.size()>0) mObject_markings.clear();
 }
 
+void Object::Setborders(Object_borders & xObject_borders)
+{
+    if(mObject_borders.size()>0)mObject_borders.clear();
+    mObject_borders.push_back(xObject_borders);
+}
+
+void Object::Resetborders()
+{
+    if(mObject_borders.size()>0)mObject_borders.clear();
+}
+
 vector<Object_repeat> * Object::GetObjectrepeatVector()
 {
     return &mObject_repeat;
@@ -1581,7 +1690,7 @@ Object_outlines_outline* Object::GetObjectoutline(unsigned int i)
 }
 unsigned int Object::GetObjectoutlineCount()
 {
-    return mObject_outlines_outline.size();
+    return static_cast<unsigned int >(mObject_outlines_outline.size()) ;
 }
 
 Object_outlines_outline*			Object::GetLastObjectoutline()
@@ -1603,7 +1712,7 @@ Object_outlines_outline*			Object::GetLastAddedObjectoutline()
 unsigned int Object::AddObjectoutline()
 {
     mObject_outlines_outline.push_back(Object_outlines_outline());
-    mLastAddedObjectoutline = mObject_outlines_outline.size()-1;
+    mLastAddedObjectoutline = static_cast<unsigned int>(mObject_outlines_outline.size()-1) ;
     return mLastAddedObjectoutline;
 }
 
@@ -1622,6 +1731,61 @@ void Object::DeleteObjectoutline(unsigned int index)
     mObject_outlines_outline.erase(mObject_outlines_outline.begin()+index);
 }
 
+vector<Object_laneValidity> * Object::GetObjectlaneValidityVector()
+{
+    return &mObject_laneValidity;
+}
+
+Object_laneValidity* Object::GetObjectlaneValidity(unsigned int i)
+{
+    if ((mObject_laneValidity.size()>0)&&(i<(mObject_laneValidity.size())))
+        return &(mObject_laneValidity.at(i));
+    else
+        return NULL;
+}
+
+unsigned int Object::GetObjectlaneValidityCount()
+{
+    return static_cast<unsigned int>(mObject_laneValidity.size());
+}
+
+Object_laneValidity*			Object::GetLastObjectlaneValidity()
+{
+    if (mObject_laneValidity.size()>0)
+        return &mObject_laneValidity.at(mObject_laneValidity.size()-1);
+    else
+        return NULL;
+}
+
+Object_laneValidity*			Object::GetLastAddedObjectlaneValidity()
+{
+    if(mLastAddedObjectlaneValidity<mObject_laneValidity.size())
+        return &mObject_laneValidity.at(mLastAddedObjectlaneValidity);
+    else
+        return NULL;
+}
+
+unsigned int Object::AddObjectlaneValidity(int fromLane, int toLane)
+{
+    mObject_laneValidity.push_back(Object_laneValidity(fromLane,toLane));
+    mLastAddedObjectlaneValidity = static_cast<unsigned int>(mObject_laneValidity.size()-1) ;
+    return mLastAddedObjectlaneValidity;
+}
+
+unsigned int Object::CloneObjectlaneValidity(unsigned int index)
+{
+    if(index<(mObject_laneValidity.size()-1))
+        mObject_laneValidity.insert(mObject_laneValidity.begin()+index+1, mObject_laneValidity[index]);
+    else if(index==mObject_laneValidity.size()-1)
+        mObject_laneValidity.push_back(mObject_laneValidity[index]);
+    mLastAddedObjectlaneValidity=index+1;
+    return mLastAddedObjectlaneValidity;
+}
+void Object::DeleteObjectlaneValidity(unsigned int index)
+{
+    mObject_laneValidity.erase(mObject_laneValidity.begin()+index);
+}
+
 
 signal_positionRoad::signal_positionRoad(double s, double t, double zOffset, double hOffset, double pitch, double roll)
 {

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

@@ -10,6 +10,48 @@ using std::string;
 
 class Object_markings_marking_cornerReference;
 
+
+class Objects_bridge
+{
+private:
+    double mS;
+    double mlength;
+    std::vector<std::string> mname;
+    std::string mstrid;
+    std::string mstrtype;
+
+public:
+    Objects_bridge(double s,double length,std::string strid,std::string strtype);
+    double GetS();
+    double Getlength();
+    int GetName(std::string name);
+    std::string Getid();
+    std::string Gettype();
+
+    void SetS(double s);
+    void Setlength(double length);
+    void Setname(std::string name);
+    void Resetname();
+    void Setid(std::string id);
+    void Settype(std::string type);
+};
+
+class Object_laneValidity
+{
+private:
+    int mfromLane;
+    int mtoLane;
+
+public:
+   Object_laneValidity(int fromLane,int toLane);
+   int GetfromLane();
+   int GettoLane();
+
+   void SetfromLane(int fromLane);
+   void SettoLane(int toLane);
+
+};
+
 class Object_borders_border
 {
 private:
@@ -443,10 +485,13 @@ private:
     vector<Object_outlines> mObject_outlines;
     vector<Object_outlines_outline> mObject_outlines_outline;
     vector<Object_markings> mObject_markings;
+    vector<Object_borders> mObject_borders;
+    vector<Object_laneValidity> mObject_laneValidity;
 
     unsigned int mLastAddedObjectrepeat;
     unsigned int mLastAddedObjectmaterial;
     unsigned int mLastAddedObjectoutline;
+    unsigned int mLastAddedObjectlaneValidity;
 
 public:
 
@@ -474,6 +519,7 @@ public:
 
     Object_outlines * Getoutlines();
     Object_markings * Getmarkings();
+    Object_borders * Getborders();
 
     void Sett(double t);
     void SetzOffset(double zOffset);
@@ -502,6 +548,9 @@ public:
     void Setmarkings(Object_markings & xObject_markings);
     void Resetmarkings();
 
+    void Setborders(Object_borders & xObject_borders);
+    void Resetborders();
+
     vector<Object_repeat> * GetObjectrepeatVector();
     Object_repeat* GetObjectrepeat(unsigned int i);
     unsigned int GetObjectrepeatCount();
@@ -531,6 +580,15 @@ public:
     unsigned int CloneObjectoutline(unsigned int index);
     void DeleteObjectoutline(unsigned int index);
 
+    vector<Object_laneValidity> * GetObjectlaneValidityVector();
+    Object_laneValidity* GetObjectlaneValidity(unsigned int i);
+    unsigned int GetObjectlaneValidityCount();
+    Object_laneValidity*			GetLastObjectlaneValidity();
+    Object_laneValidity*			GetLastAddedObjectlaneValidity();
+    unsigned int AddObjectlaneValidity(int fromLane,int toLane);
+    unsigned int CloneObjectlaneValidity(unsigned int index);
+    void DeleteObjectlaneValidity(unsigned int index);
+
 };
 //----------------------------------------------------------------------------------
 

src/common/common/xodr/OpenDrive/OpenDriveXmlParser.cpp

@@ -1488,12 +1488,111 @@ bool OpenDriveXmlParser::ReadObjectMarkingsMarkingcornerReference(Object_marking
         cout<<"Error parsing Object Marking cornerReference id attributes"<<endl;
         return false;
     }
-    pObject_Marking->AddcornerReference((unsigned int)id);
+    pObject_Marking->AddcornerReference(static_cast<unsigned int>(id));
     return true;
 }
 
 //--------------
 
+
+bool OpenDriveXmlParser::ReadObjectBorders(Object * pObject,TiXmlElement * node)
+{
+    Object_borders xObject_Border;
+
+    TiXmlElement *subNode = node->FirstChildElement("border");
+
+    if(subNode == NULL)
+    {
+        std::cout<<"OpenDriveXmlParser::ReadObjectBoders borders have one border at least"<<std::endl;
+        return false;
+    }
+
+    while(subNode)
+    {
+        ReadObjectBordersBorder(&xObject_Border,subNode);
+        subNode = subNode->NextSiblingElement("border");
+    }
+
+    pObject->Setborders(xObject_Border);
+}
+
+//--------------
+
+bool OpenDriveXmlParser::ReadObjectBordersBorder(Object_borders * pObject_Borders,TiXmlElement * node)
+{
+    std::string strtype;
+    double width;
+    int outlineId;
+    std::string struseCompleteOutline;
+
+
+    int checker=TIXML_SUCCESS;
+    checker+=node->QueryDoubleAttribute("width",&width);
+    if(checker != TIXML_SUCCESS)
+    {
+        cout<<"Error parsing Object Border width attributes"<<endl;
+        return false;
+    }
+    checker+=node->QueryStringAttribute("type",&strtype);
+    if(checker != TIXML_SUCCESS)
+    {
+        cout<<"Error parsing Object Border type attributes"<<endl;
+        return false;
+    }
+    checker+=node->QueryIntAttribute("outlineId",&outlineId);
+    if(checker != TIXML_SUCCESS)
+    {
+        cout<<"Error parsing Object Border outlineId attributes"<<endl;
+        return false;
+    }
+
+    pObject_Borders->AddBorder(width,strtype,outlineId);
+
+    Object_borders_border * pObject_Borders_Border = pObject_Borders->GetLastBorder();
+
+    if(node->QueryStringAttribute("useCompleteOutline",&struseCompleteOutline) == TIXML_SUCCESS)
+    {
+        if(struseCompleteOutline == "true")
+        {
+            pObject_Borders_Border->SetuserCompleteOutline(true);
+        }
+        else
+        {
+            pObject_Borders_Border->SetuserCompleteOutline(false);
+        }
+    }
+
+
+    TiXmlElement *subNode = node->FirstChildElement("cornerReference");
+    while (subNode)
+    {
+        ReadObjectBordersBordercornerReference(pObject_Borders_Border, subNode);
+        subNode = subNode->NextSiblingElement("cornerReference");
+    }
+
+
+    return true;
+}
+
+//--------------
+
+bool OpenDriveXmlParser::ReadObjectBordersBordercornerReference(Object_borders_border * pObject_Border,TiXmlElement * node)
+{
+    int id;
+    int checker=TIXML_SUCCESS;
+    checker+=node->QueryIntAttribute("id",&id);
+    if(checker != TIXML_SUCCESS)
+    {
+        cout<<"Error parsing Object Marking cornerReference id attributes"<<endl;
+        return false;
+    }
+    pObject_Border->AddcornerReference(static_cast<unsigned int>(id));
+    return true;
+}
+
+//--------------
+//
+
 bool OpenDriveXmlParser::ReadObjectOutlines(Object * pObject,TiXmlElement *node)
 {
     Object_outlines xoutlines;
@@ -1871,8 +1970,41 @@ bool OpenDriveXmlParser::ReadObject(Road *road, TiXmlElement *node)
         ReadObjectMarkings(pobject,subNode);
     }
 
+    subNode = node->FirstChildElement("borders");
+    if(subNode)
+    {
+        ReadObjectBorders(pobject,subNode);
+    }
+
+    subNode = node->FirstChildElement("validity");
+    while(subNode)
+    {
+        ReadObjectvalidity(pobject,subNode);
+        subNode = subNode->NextSiblingElement("validity");
+    }
+
+    return true;
+}
+//--------------
+
+bool OpenDriveXmlParser::ReadObjectvalidity(Object * pObject,TiXmlElement * node)
+{
+    int fromLane,toLane;
+    int checker=TIXML_SUCCESS;
+    checker+=node->QueryIntAttribute("fromLane",&fromLane);
+    checker+=node->QueryIntAttribute("toLane",&toLane);
+
+    if (checker!=TIXML_SUCCESS)
+    {
+        cout<<"Error parsing Object validity attributes"<<endl;
+        return false;
+    }
+
+    pObject->AddObjectlaneValidity(fromLane,toLane);
+
     return true;
 }
+
 //--------------
 
 bool OpenDriveXmlParser::ReadRoadBorrows(Road *road, TiXmlElement *node)

src/common/common/xodr/OpenDrive/OpenDriveXmlParser.h

@@ -93,6 +93,10 @@ public:
     bool ReadObjectMarkings(Object * pObject,TiXmlElement * node);
     bool ReadObjectMarkingsMarking(Object_markings * pObject_Markings,TiXmlElement * node);
     bool ReadObjectMarkingsMarkingcornerReference(Object_markings_marking * pObject_Marking,TiXmlElement * node);
+    bool ReadObjectBorders(Object * pObject,TiXmlElement * node);
+    bool ReadObjectBordersBorder(Object_borders * pObject_Borders,TiXmlElement * node);
+    bool ReadObjectBordersBordercornerReference(Object_borders_border * pObject_Border,TiXmlElement * node);
+    bool ReadObjectvalidity(Object * pObject,TiXmlElement * node);
 
 	//--------------
 

src/common/common/xodr/OpenDrive/OpenDriveXmlWriter.cpp

@@ -1313,14 +1313,14 @@ bool OpenDriveXmlWriter::WriteObject(TiXmlElement *node, Object *pObject)
 
     unsigned int i;
 
-    unsigned nrepeatcount = pObject->GetObjectrepeatCount();
+    unsigned int nrepeatcount = pObject->GetObjectrepeatCount();
     for(i=0;i<nrepeatcount;i++)
     {
         Object_repeat * pObject_repeat = pObject->GetObjectrepeat(i);
         WriteObjectrepeat(nodeObject,pObject_repeat);
     }
 
-    unsigned nmaterialcount = pObject->GetObjectmaterialCount();
+    unsigned int nmaterialcount = pObject->GetObjectmaterialCount();
     for(i=0;i<nmaterialcount;i++)
     {
         Object_material * pObject_material = pObject->GetObjectmaterial(i);
@@ -1334,7 +1334,7 @@ bool OpenDriveXmlWriter::WriteObject(TiXmlElement *node, Object *pObject)
         WriteObjectOutlines(nodeObject,pObject_outlines);
     }
 
-    unsigned noutlinecount = pObject->GetObjectoutlineCount();
+    unsigned int noutlinecount = pObject->GetObjectoutlineCount();
     for(i=0;i<noutlinecount;i++)
     {
         Object_outlines_outline * pObject_outlines_outline = pObject->GetObjectoutline(i);
@@ -1347,6 +1347,19 @@ bool OpenDriveXmlWriter::WriteObject(TiXmlElement *node, Object *pObject)
         WriteObjectMarkings(nodeObject,pObject_markings);
     }
 
+    Object_borders * pObject_borders = pObject->Getborders();
+    if(pObject_borders != NULL)
+    {
+        WriteObjectborders(nodeObject,pObject_borders);
+    }
+
+    unsigned int nvaliditycount = pObject->GetObjectlaneValidityCount();
+    for(i=0;i<nvaliditycount;i++)
+    {
+        Object_laneValidity * pObject_lanevalidity = pObject->GetObjectlaneValidity(i);
+        WriteObjectlaneValidity(nodeObject,pObject_lanevalidity);
+    }
+
 
     return true;
 }
@@ -1608,7 +1621,82 @@ bool OpenDriveXmlWriter::WriteObjectMarkingsMarkingcornerReference(TiXmlElement
     TiXmlElement * nodecornerReference = new TiXmlElement("cornerReference");
     node->LinkEndChild(nodecornerReference);
 
-    nodecornerReference->SetAttribute("id",pObject_markings_marking_cornerReference->Getid());
+    nodecornerReference->SetAttribute("id",static_cast<int>( pObject_markings_marking_cornerReference->Getid()));
+
+    return true;
+}
+
+//--------------
+
+bool OpenDriveXmlWriter::WriteObjectborders(TiXmlElement * node,Object_borders * pObject_borders)
+{
+    TiXmlElement * nodeObjectboders = new TiXmlElement("borders");
+    node->LinkEndChild(nodeObjectboders);
+
+    unsigned int lbordercount = pObject_borders->GetBorderCount();
+    if(lbordercount == 0)
+    {
+        std::cout<<"borders must have at least 1 border"<<std::endl;
+        return false;
+    }
+    unsigned int i;
+    for(i=0;i<lbordercount;i++)
+    {
+        WriteObjectbordersborder(nodeObjectboders,pObject_borders->GetBorder(i));
+    }
+
+    return true;
+}
+
+//--------------
+
+
+bool OpenDriveXmlWriter::WriteObjectbordersborder(TiXmlElement * node,Object_borders_border * pObject_borders_border)
+{
+    TiXmlElement * nodeborder = new TiXmlElement("border");
+    node->LinkEndChild(nodeborder);
+
+    double width;
+    std::string strtype;
+    int outlineId;
+    bool useCompletOutline;
+
+    width = pObject_borders_border->Getwidth();
+    nodeborder->SetDoubleAttribute("width",width);
+
+    strtype = pObject_borders_border->GetborderType();
+    nodeborder->SetAttribute("type",strtype);
+
+    outlineId = pObject_borders_border->Getoutlineid();
+    nodeborder->SetAttribute("outlineId",outlineId);
+
+    if(pObject_borders_border->GetuserCompleteOutline(useCompletOutline) == 1)
+    {
+        if(useCompletOutline == true)
+            nodeborder->SetAttribute("useCompleteOutline","true");
+        else
+            nodeborder->SetAttribute("useCompleteOutline","false");
+    }
+
+    unsigned int lcornerCount = pObject_borders_border->GetcornerReferenceCount();
+    unsigned int i;
+    for(i=0;i<lcornerCount;i++)
+    {
+        WriteObjectbordersbordercornerReference(nodeborder,pObject_borders_border->GetcornerReference(i));
+    }
+
+    return true;
+}
+
+//--------------
+
+
+bool OpenDriveXmlWriter::WriteObjectbordersbordercornerReference(TiXmlElement * node,Object_markings_marking_cornerReference * pObject_markings_marking_cornerReference)
+{
+    TiXmlElement * nodecornerReference = new TiXmlElement("cornerReference");
+    node->LinkEndChild(nodecornerReference);
+
+    nodecornerReference->SetAttribute("id",static_cast<int>( pObject_markings_marking_cornerReference->Getid()));
 
     return true;
 }
@@ -1634,6 +1722,17 @@ bool OpenDriveXmlWriter::WriteObjectOutlinesOutlinecornerRoad(TiXmlElement *node
     return true;
 }
 
+bool OpenDriveXmlWriter::WriteObjectlaneValidity(TiXmlElement * node,Object_laneValidity * pObject_laneValidity)
+{
+    TiXmlElement * nodelaneValidity = new TiXmlElement("validity");
+    node->LinkEndChild(nodelaneValidity);
+
+    nodelaneValidity->SetAttribute("fromLane",pObject_laneValidity->GetfromLane());
+    nodelaneValidity->SetAttribute("toLane",pObject_laneValidity->GettoLane());
+
+    return true;
+}
+
 //--------------
 
 bool OpenDriveXmlWriter::WriteObjectOutlinesOutlinecornerLocal(TiXmlElement *node, Object_outlines_outline_cornerLocal *pObject_outlines_outline_cornerLocal)

src/common/common/xodr/OpenDrive/OpenDriveXmlWriter.h

@@ -91,6 +91,10 @@ public:
     bool WriteObjectMarkings(TiXmlElement * node,Object_markings * pObject_markings);
     bool WriteObjectMarkingsMarking(TiXmlElement * node,Object_markings_marking * pObject_markings_marking);
     bool WriteObjectMarkingsMarkingcornerReference(TiXmlElement * node,Object_markings_marking_cornerReference * pObject_markings_marking_cornerReference);
+    bool WriteObjectborders(TiXmlElement * node,Object_borders * pObject_borders);
+    bool WriteObjectbordersborder(TiXmlElement * node,Object_borders_border * pObject_borders_border);
+    bool WriteObjectbordersbordercornerReference(TiXmlElement * node,Object_markings_marking_cornerReference * pObject_markings_marking_cornerReference);
+    bool WriteObjectlaneValidity(TiXmlElement * node,Object_laneValidity * pObject_laneValidity);
 
     //--------------
 

src/tool/RemoteCtrl_Wide/mainwindow.cpp

@@ -237,7 +237,7 @@ void MainWindow::CreateView()
     mpVehSpeed->settitle(QStringLiteral("车速(km/h)"));
     mpVehSpeed->updatevalue(0);
     mpVehSpeed->setminvalue(0);
-    mpVehSpeed->setmaxvalue(30);
+    mpVehSpeed->setmaxvalue( mnSpeedMax);
 
     mmyview = new MyView(ui->centralwidget);
     mmyview->setObjectName(QStringLiteral("graphicsView"));
@@ -982,7 +982,28 @@ void MainWindow::onTimerUpdateView()
         mstrGPSTime =  QDateTime::fromMSecsSinceEpoch(xgpsimu.msgtime()).toString("GPS: yyyy-MM-dd hh:mm:ss  ");
         setWindowTitle(mstrProgName + mstrVIN + mstrGPSTime + mstrPicTime);
 
-        mpVehSpeed->updatevalue(xgpsimu.speed()*3.6);
+        double fVehSpeed = xgpsimu.speed()*3.6;
+
+
+        if(fVehSpeed>30)
+        {
+            if(mnSpeedMax != 130)
+            {
+                mnSpeedMax = 130;
+                mpVehSpeed->setmaxvalue(130);
+            }
+        }
+
+        if(fVehSpeed<20)
+        {
+            if(mnSpeedMax != 30)
+            {
+                mnSpeedMax = 30;
+                mpVehSpeed->setmaxvalue(130);
+            }
+        }
+
+        mpVehSpeed->updatevalue(fVehSpeed);
     }
 
 

src/tool/RemoteCtrl_Wide/mainwindow.h

@@ -129,6 +129,8 @@ private:
 
     Speed * mpVehSpeed;
 
+    int mnSpeedMax = 30.0;
+
      QSet<int> mPressKeys;
 
      QTimer * mpTimerManual;