change map_lanetoxodr, for 1.8 standard, not complete.

src/common/common/xodr/OpenDrive/Junction.cpp

@@ -95,6 +95,20 @@ unsigned int Junction::AddJunctionDirectConnection(	string id,	string linkedRoad
     return mLastAddedJunctionDirectConnection;
 }
 
+unsigned int Junction::AddJunctionCrossingspriority(string high, string low)
+{
+    mJunctionCrossingspriorityVector.push_back(JunctionCrossingspriority(high,low));
+    mLastAddedJunctionCrossingspriority = mJunctionCrossingspriorityVector.size()-1;
+    return mLastAddedJunctionCrossingspriority;
+}
+
+unsigned int Junction::AddJunctionCrossingsroadSection(string id,string roadId,double sStart,double sEnd)
+{
+    mJunctionCrossingsroadSectionVector.push_back(JunctionCrossingsroadSection(id,roadId,sStart,sEnd));
+    mLastAddedJunctionCrossingsroadSection = mJunctionCrossingsroadSectionVector.size()-1;
+    return mLastAddedJunctionCrossingsroadSection;
+}
+
 //--------------
 
 /**
@@ -155,6 +169,26 @@ unsigned int Junction::CloneJunctionDirectConnection(unsigned int index)
     return mLastAddedJunctionDirectConnection;
 }
 
+unsigned int Junction::CloneJunctionCrossingspriority(unsigned int index)
+{
+    if(index<mJunctionCrossingspriorityVector.size()-1)
+        mJunctionCrossingspriorityVector.insert(mJunctionCrossingspriorityVector.begin()+index+1, mJunctionCrossingspriorityVector[index]);
+    else if(index==mJunctionCrossingspriorityVector.size()-1)
+        mJunctionCrossingspriorityVector.push_back(mJunctionCrossingspriorityVector[index]);
+    mLastAddedJunctionCrossingspriority=index+1;
+    return mLastAddedJunctionCrossingspriority;
+}
+
+unsigned int Junction::CloneJunctionCrossingsroadSection(unsigned int index)
+{
+    if(index<mJunctionCrossingsroadSectionVector.size()-1)
+        mJunctionCrossingsroadSectionVector.insert(mJunctionCrossingsroadSectionVector.begin()+index+1, mJunctionCrossingsroadSectionVector[index]);
+    else if(index==mJunctionCrossingsroadSectionVector.size()-1)
+        mJunctionCrossingsroadSectionVector.push_back(mJunctionCrossingsroadSectionVector[index]);
+    mLastAddedJunctionCrossingsroadSection=index+1;
+    return mLastAddedJunctionCrossingsroadSection;
+}
+
 /**
  * Methods used to delete child records from the respective vectors
  */
@@ -181,6 +215,15 @@ void Junction::DeleteJunctionDirectConnection(unsigned int index)
     mJunctionDirectConnectionVector.erase(mJunctionDirectConnectionVector.begin()+index);
 }
 
+void Junction::DeleteJunctionCrossingspriority(unsigned int index)
+{
+    mJunctionCrossingspriorityVector.erase(mJunctionCrossingspriorityVector.begin()+index);
+}
+void Junction::DeleteJunctionCrossingsroadSection(unsigned int index)
+{
+    mJunctionCrossingsroadSectionVector.erase(mJunctionCrossingsroadSectionVector.begin()+index);
+}
+
 /**
 * Return the name of the junction
 */
@@ -364,7 +407,7 @@ JunctionCrossPath* Junction::GetLastAddedJunctionCrossPath()
 
 
 std::vector<JunctionDirectConnection>* Junction::GetJunctionDirectConnectionVector()
-{  return & mJunctionDirectConnectionVector;}
+{  return &mJunctionDirectConnectionVector;}
 
 unsigned int Junction::GetJunctionDirectConnectionCount()
 { return mJunctionDirectConnectionVector.size();}
@@ -388,7 +431,82 @@ JunctionDirectConnection * Junction::GetLastAddedJunctionDirectConnection()
         return NULL;
 }
 
+std::vector<JunctionCrossingspriority>* Junction::GetJunctionCrossingspriorityVector()
+{ return &mJunctionCrossingspriorityVector;}
+
+unsigned int Junction::GetJunctionCrossingspriorityCount()
+{ return mJunctionCrossingspriorityVector.size();}
+
+JunctionCrossingspriority * Junction::GetJunctionCrossingspriority(unsigned int i)
+{ return &mJunctionCrossingspriorityVector.at(i);}
+
+JunctionCrossingspriority * Junction::GetLastJunctionCrossingspriority()
+{
+    if(mJunctionCrossingspriorityVector.size()>0)
+        return &mJunctionCrossingspriorityVector.at(mJunctionCrossingspriorityVector.size()-1);
+    else
+        return NULL;
+}
+
+JunctionCrossingspriority * Junction::GetLastAddedJunctionCrossingspriority()
+{
+    if(mLastAddedJunctionCrossingspriority<mJunctionCrossingspriorityVector.size())
+        return &mJunctionCrossingspriorityVector.at(mLastAddedJunctionCrossingspriority);
+    else
+        return NULL;
+}
+
+std::vector<JunctionCrossingsroadSection>* Junction::GetJunctionCrossingsroadSectionVector()
+{ return &mJunctionCrossingsroadSectionVector;}
+
+unsigned int Junction::GetJunctionCrossingsroadSectionCount()
+{ return mJunctionCrossingsroadSectionVector.size();}
+
+JunctionCrossingsroadSection * Junction::GetJunctionCrossingsroadSection(unsigned int i)
+{ return &mJunctionCrossingsroadSectionVector.at(i);}
+
+JunctionCrossingsroadSection * Junction::GetLastJunctionCrossingsroadSection()
+{
+    if(mJunctionCrossingsroadSectionVector.size()>0)
+        return &mJunctionCrossingsroadSectionVector.at(mJunctionCrossingsroadSectionVector.size()-1);
+    else
+        return NULL;
+}
 
+JunctionCrossingsroadSection * Junction::GetLastAddedJunctionCrossingsroadSection()
+{
+    if(mLastAddedJunctionCrossingsroadSection<mJunctionCrossingsroadSectionVector.size())
+        return &mJunctionCrossingsroadSectionVector.at(mLastAddedJunctionCrossingsroadSection);
+    else
+        return NULL;
+}
+
+
+int Junction::GetJunctionplanView(JunctionplanView & planView)
+{
+    if(mJunctionplanView.size() == 0)return 0;
+    planView = mJunctionplanView[0];
+    return 1;
+}
+
+void Junction::SetJunctionplanView(JunctionplanView planView)
+{
+    mJunctionplanView.clear();
+    mJunctionplanView.push_back(planView);
+}
+
+int Junction::GetJunctionboundary(Junctionboundary & boundary)
+{
+    if(mJunctionboundary.size() == 0)return 0;
+    boundary = mJunctionboundary[0];
+    return 1;
+}
+
+void Junction::SetJunctionboundary(Junctionboundary boundary)
+{
+    mJunctionboundary.clear();
+    mJunctionboundary.push_back(boundary);
+}
 //--------------
 
 
@@ -993,3 +1111,434 @@ JunctionLaneLink* JunctionDirectConnection::GetLastAddedJunctionLaneLink()
     else
         return NULL;
 }
+
+
+JunctionCrossingspriority::JunctionCrossingspriority(string high, string low)
+{
+    mhigh = high;
+    mlow = low;
+}
+
+string JunctionCrossingspriority::Gethigh()
+{
+    return mhigh;
+}
+string JunctionCrossingspriority::Getlow()
+{
+    return mlow;
+}
+
+void JunctionCrossingspriority::Sethigh(string high)
+{
+    mhigh = high;
+}
+
+void JunctionCrossingspriority::Setlow(string low)
+{
+    mlow = low;
+}
+
+JunctionCrossingsroadSection::JunctionCrossingsroadSection(string id,string roadId,double sStart,double sEnd)
+{
+    mid = id;
+    mroadId = roadId;
+    msStart = sStart;
+    msEnd = sEnd;
+}
+
+string JunctionCrossingsroadSection::Getid()
+{
+    return mid;
+}
+
+string JunctionCrossingsroadSection::GetroadId()
+{
+    return mroadId;
+}
+
+double JunctionCrossingsroadSection::GetsStart()
+{
+    return msStart;
+}
+
+double JunctionCrossingsroadSection::GetsEnd()
+{
+    return msEnd;
+}
+
+void JunctionCrossingsroadSection::Setid(string id)
+{
+    mid = id;
+}
+
+void JunctionCrossingsroadSection::SetroadId(string roadId)
+{
+    mroadId = roadId;
+}
+
+void JunctionCrossingsroadSection::SetsStart(double sStart)
+{
+    msStart = sStart;
+}
+
+void JunctionCrossingsroadSection::SetsEnd(double sEnd)
+{
+    msEnd = sEnd;
+}
+
+
+JunctionplanViewgeometry::JunctionplanViewgeometry(double s,double x,double y,double hdg,double length)
+{
+    ms = s;
+    mx = x;
+    my = y;
+    mhdg = hdg;
+    mlength = length;
+}
+
+JunctionplanViewgeometry::JunctionplanViewgeometry()
+{
+
+}
+
+
+double JunctionplanViewgeometry::Gets()
+{
+    return ms;
+}
+
+double JunctionplanViewgeometry::Getx()
+{
+    return mx;
+}
+
+double JunctionplanViewgeometry::Gety()
+{
+    return my;
+}
+
+double JunctionplanViewgeometry::Gethdg()
+{
+    return mhdg;
+}
+
+double JunctionplanViewgeometry::Getlength()
+{
+    return mlength;
+}
+
+void JunctionplanViewgeometry::Sets(double s)
+{
+    ms = s;
+}
+
+void JunctionplanViewgeometry::Setx(double x)
+{
+    mx = x;
+}
+
+void JunctionplanViewgeometry::Sety(double y)
+{
+    my = y;
+}
+
+void JunctionplanViewgeometry::Sethdg(double hdg)
+{
+    mhdg = hdg;
+}
+
+void JunctionplanViewgeometry::Setlength(double length)
+{
+    mlength = length;
+}
+
+
+JunctionplanView::JunctionplanView()
+{
+    mgeometryvector.clear();
+}
+
+
+unsigned int JunctionplanView::Addgeometry(double s,double x,double y,double hdg,double length)
+{
+    mgeometryvector.push_back(JunctionplanViewgeometry(s,x,y,hdg,length));
+    mLastAddedJunctionplanViewgeometry = mgeometryvector.size()-1;
+    return mLastAddedJunctionplanViewgeometry;
+}
+
+unsigned int JunctionplanView::Clonegeometry(unsigned int index)
+{
+    if(index<mgeometryvector.size()-1)
+        mgeometryvector.insert(mgeometryvector.begin()+index+1, mgeometryvector[index]);
+    else if(index==mgeometryvector.size()-1)
+        mgeometryvector.push_back(mgeometryvector[index]);
+    mLastAddedJunctionplanViewgeometry=index+1;
+    return mLastAddedJunctionplanViewgeometry;
+}
+
+void JunctionplanView::Deletegeometry(unsigned int index)
+{
+    mgeometryvector.erase(mgeometryvector.begin()+index);
+}
+
+std::vector<JunctionplanViewgeometry>* JunctionplanView::GetgeometryVector()
+{
+    return &mgeometryvector;
+}
+
+unsigned int JunctionplanView::GetgeometryCount()
+{
+    return mgeometryvector.size();
+}
+
+JunctionplanViewgeometry * JunctionplanView::Getgeometry(unsigned int i)
+{
+    return &mgeometryvector.at(i);
+}
+
+JunctionplanViewgeometry * JunctionplanView::GetLastgeometry()
+{
+    if(mgeometryvector.size()>0)
+        return &mgeometryvector.at(mgeometryvector.size()-1);
+    else
+        return NULL;
+}
+
+JunctionplanViewgeometry * JunctionplanView::GetLastAddedgeometry()
+{
+    if(mLastAddedJunctionplanViewgeometry<mgeometryvector.size())
+        return &mgeometryvector.at(mLastAddedJunctionplanViewgeometry);
+    else
+        return NULL;
+}
+
+
+Junctionboundarysegmentlane::Junctionboundarysegmentlane(int boundaryLane,string roadId,double sEnd,double sStart)
+{
+    mboundaryLane = boundaryLane;
+    mroadId = roadId;
+    msEnd = sEnd;
+    msStart = sStart;
+    mtype = "lane";
+}
+
+int Junctionboundarysegmentlane::GetboundaryLane()
+{
+    return mboundaryLane;
+}
+
+string Junctionboundarysegmentlane::GetroadId()
+{
+    return mroadId;
+}
+
+double Junctionboundarysegmentlane::Junctionboundarysegmentlane::GetsEnd()
+{
+    return msEnd;
+}
+double Junctionboundarysegmentlane::GetsStart()
+{
+    return msStart;
+}
+
+void Junctionboundarysegmentlane::SetboundaryLane(int boundaryLane)
+{
+    mboundaryLane = boundaryLane;
+}
+
+void Junctionboundarysegmentlane::SetroadId(string roadId)
+{
+    mroadId = roadId;
+}
+
+void Junctionboundarysegmentlane::SetsEnd(double sEnd)
+{
+    msEnd = sEnd;
+}
+
+void Junctionboundarysegmentlane::SetsStart(double sStart)
+{
+    msStart = sStart;
+}
+
+Junctionboundarysegmentjoint::Junctionboundarysegmentjoint(string contactPoint,string roadId)
+{
+    mcontactPoint = contactPoint;
+    mroadId = roadId;
+    mjointLaneEnd.clear();
+    mjointLaneStart.clear();
+    mtransitionLength.clear();
+}
+
+string Junctionboundarysegmentjoint::GetcontactPoint()
+{
+    return mcontactPoint;
+}
+
+string Junctionboundarysegmentjoint::GetroadId()
+{
+    return mroadId;
+}
+
+int Junctionboundarysegmentjoint::GetjointLaneEnd(int & jointLaneEnd)
+{
+    if(mjointLaneEnd.size() == 0)return 0;
+    jointLaneEnd = mjointLaneEnd[0];
+    return 1;
+}
+
+int Junctionboundarysegmentjoint::GetjointLaneStart(int & jointLaneStart)
+{
+    if(mjointLaneStart.size() == 0)return 0;
+    jointLaneStart = mjointLaneStart[0];
+    return 1;
+}
+
+int Junctionboundarysegmentjoint::GettransitionLength(double & transitionLength)
+{
+    if(mtransitionLength.size() == 0)return 0;
+    transitionLength = mtransitionLength[0];
+    return 1;
+}
+
+
+void Junctionboundarysegmentjoint::SetcontactPoint(string contactPoint)
+{
+    mcontactPoint = contactPoint;
+}
+
+void Junctionboundarysegmentjoint::SetroadId(string roadId)
+{
+    mroadId = roadId;
+}
+
+void Junctionboundarysegmentjoint::SetjointLaneEnd(int jointLaneEnd)
+{
+    mjointLaneEnd.clear();
+    mjointLaneEnd.push_back(jointLaneEnd);
+}
+
+void Junctionboundarysegmentjoint::SetjointLaneStart(int jointLaneStart)
+{
+    mjointLaneStart.clear();
+    mjointLaneStart.push_back(jointLaneStart);
+}
+
+void Junctionboundarysegmentjoint::SettransitionLength(double transitionLength)
+{
+    mtransitionLength.clear();
+    mtransitionLength.push_back(transitionLength);
+}
+
+Junctionboundary::Junctionboundary()
+{
+
+}
+
+unsigned int Junctionboundary::AddJunctionboundarysegmentlane(int boundaryLane,string roadId,double sEnd,double sStart)
+{
+    mJunctionboundarysegmentlanevector.push_back(Junctionboundarysegmentlane(boundaryLane,roadId,sEnd,sStart));
+    mLastAddedJunctionboundarysegmentlane = mJunctionboundarysegmentlanevector.size()-1;
+    return mLastAddedJunctionboundarysegmentlane;
+}
+
+unsigned int Junctionboundary::CloneJunctionboundarysegmentlane(unsigned int index)
+{
+    if(index<mJunctionboundarysegmentlanevector.size()-1)
+        mJunctionboundarysegmentlanevector.insert(mJunctionboundarysegmentlanevector.begin()+index+1, mJunctionboundarysegmentlanevector[index]);
+    else if(index==mJunctionboundarysegmentlanevector.size()-1)
+        mJunctionboundarysegmentlanevector.push_back(mJunctionboundarysegmentlanevector[index]);
+    mLastAddedJunctionboundarysegmentlane=index+1;
+    return mLastAddedJunctionboundarysegmentlane;
+}
+
+void Junctionboundary::DeleteJunctionboundarysegmentlane(unsigned int index)
+{
+    mJunctionboundarysegmentlanevector.erase(mJunctionboundarysegmentlanevector.begin()+index);
+}
+
+std::vector<Junctionboundarysegmentlane>* Junctionboundary::GetJunctionboundarysegmentlaneVector()
+{
+    return &mJunctionboundarysegmentlanevector;
+}
+
+unsigned int Junctionboundary::GetJunctionboundarysegmentlaneCount()
+{
+    return mJunctionboundarysegmentlanevector.size();
+}
+
+Junctionboundarysegmentlane * Junctionboundary::GetJunctionboundarysegmentlane(unsigned int i)
+{
+    return &mJunctionboundarysegmentlanevector.at(i);
+}
+
+Junctionboundarysegmentlane * Junctionboundary::GetLastJunctionboundarysegmentlane()
+{
+    if(mJunctionboundarysegmentlanevector.size()>0)
+        return &mJunctionboundarysegmentlanevector.at(mJunctionboundarysegmentlanevector.size()-1);
+    else
+        return NULL;
+}
+
+Junctionboundarysegmentlane * Junctionboundary::GetLastAddedJunctionboundarysegmentlane()
+{
+    if(mLastAddedJunctionboundarysegmentlane<mJunctionboundarysegmentlanevector.size())
+        return &mJunctionboundarysegmentlanevector.at(mLastAddedJunctionboundarysegmentlane);
+    else
+        return NULL;
+}
+
+unsigned int Junctionboundary::AddJunctionboundarysegmentjoint(string contactPoint,string roadId)
+{
+    mJunctionboundarysegmentjointvector.push_back(Junctionboundarysegmentjoint(contactPoint,roadId));
+    mLastAddedJunctionboundarysegmentjoint = mJunctionboundarysegmentjointvector.size()-1;
+    return mLastAddedJunctionboundarysegmentjoint;
+}
+
+unsigned int Junctionboundary::CloneJunctionboundarysegmentjoint(unsigned int index)
+{
+    if(index<mJunctionboundarysegmentjointvector.size()-1)
+        mJunctionboundarysegmentjointvector.insert(mJunctionboundarysegmentjointvector.begin()+index+1, mJunctionboundarysegmentjointvector[index]);
+    else if(index==mJunctionboundarysegmentjointvector.size()-1)
+        mJunctionboundarysegmentjointvector.push_back(mJunctionboundarysegmentjointvector[index]);
+    mLastAddedJunctionboundarysegmentjoint=index+1;
+    return mLastAddedJunctionboundarysegmentjoint;
+}
+
+void Junctionboundary::DeleteJunctionboundarysegmentjoint(unsigned int index)
+{
+    mJunctionboundarysegmentjointvector.erase(mJunctionboundarysegmentjointvector.begin()+index);
+}
+
+std::vector<Junctionboundarysegmentjoint>* Junctionboundary::GetJunctionboundarysegmentjointVector()
+{
+    return &mJunctionboundarysegmentjointvector;
+}
+
+unsigned int Junctionboundary::GetJunctionboundarysegmentjointCount()
+{
+    return mJunctionboundarysegmentjointvector.size();
+}
+
+Junctionboundarysegmentjoint * Junctionboundary::GetJunctionboundarysegmentjoint(unsigned int i)
+{
+    return &mJunctionboundarysegmentjointvector.at(i);
+}
+
+Junctionboundarysegmentjoint * Junctionboundary::GetLastJunctionboundarysegmentjoint()
+{
+    if(mJunctionboundarysegmentjointvector.size()>0)
+        return &mJunctionboundarysegmentjointvector.at(mJunctionboundarysegmentjointvector.size()-1);
+    else
+        return NULL;
+}
+
+Junctionboundarysegmentjoint * Junctionboundary::GetLastAddedJunctionboundarysegmentjoint()
+{
+    if(mLastAddedJunctionboundarysegmentjoint<mJunctionboundarysegmentjointvector.size())
+        return &mJunctionboundarysegmentjointvector.at(mLastAddedJunctionboundarysegmentjoint);
+    else
+        return NULL;
+
+}
+

src/common/common/xodr/OpenDrive/Junction.h

@@ -16,6 +16,14 @@ class JunctionCrossPathStartLaneLink;
 class JunctionCrossPathEndLaneLink;
 class JunctionDirectConnection;
 
+class JunctionCrossingspriority;
+class JunctionCrossingsroadSection;
+
+class JunctionplanViewgeometry;
+class JunctionplanView;
+
+class Junctionboundary;
+
 /**
  * Junction class. Holds all the junction information
  *
@@ -44,6 +52,13 @@ private:
 
     std::vector<JunctionDirectConnection> mJunctionDirectConnectionVector;
 
+    std::vector<JunctionCrossingspriority> mJunctionCrossingspriorityVector;
+    std::vector<JunctionCrossingsroadSection> mJunctionCrossingsroadSectionVector;
+
+    std::vector<JunctionplanView> mJunctionplanView;
+
+    std::vector<Junctionboundary> mJunctionboundary;
+
 public:
 
 	/**
@@ -56,6 +71,9 @@ public:
 
     unsigned int mLastAddedJunctionDirectConnection;
 
+    unsigned int mLastAddedJunctionCrossingspriority;
+    unsigned int mLastAddedJunctionCrossingsroadSection;
+
 	/**
 	 * Constructor. Sets basic junction parameters
 	 * @param name Name of the junction
@@ -108,6 +126,11 @@ public:
     unsigned int AddJunctionCrossPath(string id,string crossingRoad, string roadAtStart,string roadAtEnd,JunctionCrossPathStartLaneLink startLaneLink,JunctionCrossPathEndLaneLink endLaneLink);
 
     unsigned int AddJunctionDirectConnection(string id,string linkedRoad);
+
+    unsigned int AddJunctionCrossingspriority(string high, string low);
+
+    unsigned int AddJunctionCrossingsroadSection(string id,string roadId,double sStart,double sEnd);
+
 	/**
 	 * Clone the connection record
 	 * @param index Index of the record to clone
@@ -117,6 +140,8 @@ public:
 	unsigned int CloneJunctionController(unsigned int index);
     unsigned int CloneJunctionPath(unsigned int index);
     unsigned int CloneJunctionDirectConnection(unsigned int index);
+    unsigned int CloneJunctionCrossingspriority(unsigned int index);
+    unsigned int CloneJunctionCrossingsroadSection(unsigned int index);
 
 
 	void DeleteJunctionConnection(unsigned int index);
@@ -124,6 +149,8 @@ public:
 	void DeleteJunctionController(unsigned int index);
     void DeleteJunctionCrossPath(unsigned int index);
     void DeleteJunctionDirectConnection(unsigned int index);
+    void DeleteJunctionCrossingspriority(unsigned int index);
+    void DeleteJunctionCrossingsroadSection(unsigned int index);
 
 	/**
 	 * Return the name of the junction
@@ -244,6 +271,25 @@ public:
     JunctionDirectConnection * GetLastJunctionDirectConnection();
     JunctionDirectConnection * GetLastAddedJunctionDirectConnection();
 
+    std::vector<JunctionCrossingspriority>* GetJunctionCrossingspriorityVector();
+    unsigned int GetJunctionCrossingspriorityCount();
+    JunctionCrossingspriority * GetJunctionCrossingspriority(unsigned int i);
+    JunctionCrossingspriority * GetLastJunctionCrossingspriority();
+    JunctionCrossingspriority * GetLastAddedJunctionCrossingspriority();
+
+    std::vector<JunctionCrossingsroadSection>* GetJunctionCrossingsroadSectionVector();
+    unsigned int GetJunctionCrossingsroadSectionCount();
+    JunctionCrossingsroadSection * GetJunctionCrossingsroadSection(unsigned int i);
+    JunctionCrossingsroadSection * GetLastJunctionCrossingsroadSection();
+    JunctionCrossingsroadSection * GetLastAddedJunctionCrossingsroadSection();
+
+    int GetJunctionplanView(JunctionplanView & planView);
+    void SetJunctionplanView(JunctionplanView planView);
+
+    int GetJunctionboundary(Junctionboundary & boundary);
+    void SetJunctionboundary(Junctionboundary boundary);
+
+
 };
 
 
@@ -717,5 +763,201 @@ public:
 };
 
 
+class JunctionCrossingspriority
+{
+private:
+
+    string mhigh;
+    string mlow;
+
+public:
+    JunctionCrossingspriority(string high, string low);
+
+    string Gethigh();
+    string Getlow();
+
+    void Sethigh(string high);
+    void Setlow(string low);
+};
+
+
+class JunctionCrossingsroadSection
+{
+private:
+
+    string mid;
+    string mroadId;
+    double msStart;
+    double msEnd;
+
+public:
+    JunctionCrossingsroadSection(string id,string roadId,double sStart,double sEnd);
+
+    string Getid();
+    string GetroadId();
+    double GetsStart();
+    double GetsEnd();
+
+    void Setid(string id);
+    void SetroadId(string roadId);
+    void SetsStart(double sStart);
+    void SetsEnd(double sEnd);
+
+};
+
+
+class JunctionplanViewgeometry
+{
+private:
+    double ms;
+    double mx;
+    double my;
+    double mhdg;
+    double mlength;
+
+public:
+    JunctionplanViewgeometry(double s,double x,double y,double hdg,double length);
+    JunctionplanViewgeometry();
+
+    double Gets();
+    double Getx();
+    double Gety();
+    double Gethdg();
+    double Getlength();
+
+    void Sets(double s);
+    void Setx(double x);
+    void Sety(double y);
+    void Sethdg(double hdg);
+    void Setlength(double length);
+
+
+
+};
+
+
+class JunctionplanView
+{
+private:
+
+    std::vector<JunctionplanViewgeometry> mgeometryvector;
+
+    unsigned int mLastAddedJunctionplanViewgeometry;
+
+public:
+    JunctionplanView();
+
+
+    unsigned int Addgeometry(double s,double x,double y,double hdg,double length);
+
+    unsigned int Clonegeometry(unsigned int index);
+
+    void Deletegeometry(unsigned int index);
+
+    std::vector<JunctionplanViewgeometry>* GetgeometryVector();
+    unsigned int GetgeometryCount();
+    JunctionplanViewgeometry * Getgeometry(unsigned int i);
+    JunctionplanViewgeometry * GetLastgeometry();
+    JunctionplanViewgeometry * GetLastAddedgeometry();
+
+
+};
+
+
+class Junctionboundarysegmentlane
+{
+private:
+    int mboundaryLane;
+    string mroadId;
+    double msEnd;
+    double msStart;
+    string mtype;
+
+public:
+
+    Junctionboundarysegmentlane(int boundaryLane,string roadId,double sEnd,double sStart);
+
+    int GetboundaryLane();
+    string GetroadId();
+    double GetsEnd();
+    double GetsStart();
+
+    void SetboundaryLane(int boundaryLane);
+    void SetroadId(string roadId);
+    void SetsEnd(double sEnd);
+    void SetsStart(double sStart);
+
+};
+
+
+class Junctionboundarysegmentjoint
+{
+private:
+    string mcontactPoint;
+    string mroadId;
+
+    std::vector<int> mjointLaneEnd;
+    std::vector<int> mjointLaneStart;
+    std::vector<double> mtransitionLength;
+
+    string mtype;
+
+
+public:
+    Junctionboundarysegmentjoint(string contactPoint,string roadId);
+
+    string GetcontactPoint();
+    string GetroadId();
+    int GetjointLaneEnd(int & jointLaneEnd);
+    int GetjointLaneStart(int & jointLaneStart);
+    int GettransitionLength(double & transitionLength);
+
+
+    void SetcontactPoint(string contactPoint);
+    void SetroadId(string roadId);
+    void SetjointLaneEnd(int jointLaneEnd);
+    void SetjointLaneStart(int jointLaneStart);
+    void SettransitionLength(double transitionLength);
+
+
+};
+
+
+class Junctionboundary
+{
+private:
+    std::vector<Junctionboundarysegmentlane> mJunctionboundarysegmentlanevector;
+    unsigned int mLastAddedJunctionboundarysegmentlane;
+
+    std::vector<Junctionboundarysegmentjoint> mJunctionboundarysegmentjointvector;
+    unsigned int mLastAddedJunctionboundarysegmentjoint;
+
+public:
+
+    Junctionboundary();
+
+    unsigned int AddJunctionboundarysegmentlane(int boundaryLane,string roadId,double sEnd,double sStart);
+    unsigned int CloneJunctionboundarysegmentlane(unsigned int index);
+    void DeleteJunctionboundarysegmentlane(unsigned int index);
+    std::vector<Junctionboundarysegmentlane>* GetJunctionboundarysegmentlaneVector();
+    unsigned int GetJunctionboundarysegmentlaneCount();
+    Junctionboundarysegmentlane * GetJunctionboundarysegmentlane(unsigned int i);
+    Junctionboundarysegmentlane * GetLastJunctionboundarysegmentlane();
+    Junctionboundarysegmentlane * GetLastAddedJunctionboundarysegmentlane();
+
+    unsigned int AddJunctionboundarysegmentjoint(string contactPoint,string roadId);
+    unsigned int CloneJunctionboundarysegmentjoint(unsigned int index);
+    void DeleteJunctionboundarysegmentjoint(unsigned int index);
+    std::vector<Junctionboundarysegmentjoint>* GetJunctionboundarysegmentjointVector();
+    unsigned int GetJunctionboundarysegmentjointCount();
+    Junctionboundarysegmentjoint * GetJunctionboundarysegmentjoint(unsigned int i);
+    Junctionboundarysegmentjoint * GetLastJunctionboundarysegmentjoint();
+    Junctionboundarysegmentjoint * GetLastAddedJunctionboundarysegmentjoint();
+
+};
+
+
+
+
 
 #endif

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

@@ -3031,6 +3031,22 @@ bool OpenDriveXmlParser::ReadJunction (TiXmlElement *node)
     }
     }
 
+    if(type == "crossing")
+    {
+    subNode=node->FirstChildElement("priority");
+    while (subNode)
+    {
+        ReadJunctionCrossingspriority(junction, subNode);
+        subNode=subNode->NextSiblingElement("priority");
+    }
+    subNode=node->FirstChildElement("roadSection");
+    while (subNode)
+    {
+        ReadJunctionCrossingsroadSection(junction, subNode);
+        subNode=subNode->NextSiblingElement("roadSection");
+    }
+    }
+
 
 	//Read connection parameters and add them to the lane if available
 	subNode=node->FirstChildElement("priority");
@@ -3060,6 +3076,13 @@ bool OpenDriveXmlParser::ReadJunction (TiXmlElement *node)
         subNode=subNode->NextSiblingElement("crossPath");
     }
 
+    subNode = node->FirstChildElement("planView");
+
+    if(subNode)
+    {
+        ReadJunctionplanView(junction,subNode);
+    }
+
 
 	return true;
 	
@@ -3175,6 +3198,172 @@ bool OpenDriveXmlParser::ReadJunctionDirectConnection (Junction* junction, TiXml
     return true;
 }
 
+bool OpenDriveXmlParser::ReadJunctionCrossingspriority(Junction* junction, TiXmlElement *node)
+{
+    string high;
+    string low;
+
+
+    int checker=TIXML_SUCCESS;
+    checker+=node->QueryStringAttribute("high",&high);
+    checker+=node->QueryStringAttribute("low",&low);
+
+    if (checker!=TIXML_SUCCESS)
+    {
+        cout<<"Error parsing Junction Crossingspriority attributes"<<endl;
+        return false;
+    }
+
+    junction->AddJunctionCrossingspriority(high,low);
+
+    return true;
+}
+
+bool OpenDriveXmlParser::ReadJunctionCrossingsroadSection(Junction* junction, TiXmlElement *node)
+{
+    string id;
+    string roadId;
+
+    double sStart;
+    double sEnd;
+
+
+    int checker=TIXML_SUCCESS;
+    checker+=node->QueryStringAttribute("id",&id);
+    checker+=node->QueryStringAttribute("roadId",&roadId);
+    checker+=node->QueryDoubleAttribute("sStart",&sStart);
+    checker+=node->QueryDoubleAttribute("sEnd",&sEnd);
+
+    if (checker!=TIXML_SUCCESS)
+    {
+        cout<<"Error parsing Junction CrossingsroadSection attributes"<<endl;
+        return false;
+    }
+
+    junction->AddJunctionCrossingsroadSection(id,roadId,sStart,sEnd);
+
+    return true;
+}
+
+bool OpenDriveXmlParser::ReadJunctionplanView(Junction* junction, TiXmlElement *node)
+{
+
+    JunctionplanView planView;
+
+    TiXmlElement *subNode=node->FirstChildElement("geometry");
+
+    if(subNode == NULL)
+    {
+        std::cout<<" warning, Junction planView no geometry. "<<std::endl;
+        return false;
+    }
+
+
+
+    while (subNode)
+    {
+        ReadJunctionplanViewgeometry(&planView, subNode);
+        subNode=subNode->NextSiblingElement("geometry");
+    }
+
+    if(planView.GetgeometryCount() == 0)
+    {
+        std::cout<<" junction id: "<<junction->GetId()<<" planview geometry size is 0. "<<std::endl;
+        return false;
+    }
+
+    junction->SetJunctionplanView(planView);
+
+    return true;
+}
+
+
+bool OpenDriveXmlParser::ReadJunctionplanViewgeometry(JunctionplanView* planView, TiXmlElement *node)
+{
+    double s;
+    double x;
+    double y;
+    double hdg;
+    double length;
+
+    int checker=TIXML_SUCCESS;
+    checker+=node->QueryDoubleAttribute("s",&s);
+    checker+=node->QueryDoubleAttribute("x",&x);
+    checker+=node->QueryDoubleAttribute("y",&y);
+    checker+=node->QueryDoubleAttribute("hdg",&hdg);
+    checker+=node->QueryDoubleAttribute("length",&length);
+
+    if(checker != TIXML_SUCCESS)
+    {
+        cout<<" Error parsing Junction planViewgeometry attributes"<<endl;
+        return false;
+    }
+
+    planView->Addgeometry(s,x,y,hdg,length);
+    return true;
+
+
+}
+
+
+bool OpenDriveXmlParser::ReadJunctionboundary(Junction* junction, TiXmlElement *node)
+{
+    TiXmlElement *subNode=node->FirstChildElement("boundary");
+
+    if(subNode == NULL)return false;
+
+    Junctionboundary boundary;
+
+
+
+    junction->SetJunctionboundary(boundary);
+    return true;
+}
+
+bool OpenDriveXmlParser::ReadJunctionboundarysegment(Junctionboundary * junctionboundary, TiXmlElement *node)
+{
+    TiXmlElement *subNode=node->FirstChildElement("segment");
+
+    int boundaryLane;
+    string roadId;
+    double sEnd;
+    double sStart;
+
+    string contactPoint;
+    int jointLaneEnd;
+    int jointLaneStart;
+    double transitionLength;
+
+    string type;
+
+    while(subNode)
+    {
+        if(subNode->QueryStringAttribute("type",&type) == TIXML_SUCCESS)
+        {
+            if(type == "lane")
+            {
+                int checker=TIXML_SUCCESS;
+                checker+=node->QueryIntAttribute("boundaryLane",&boundaryLane);
+                checker+=node->QueryStringAttribute("roadId",&roadId);
+                checker+=node->QueryDoubleAttribute("sEnd",&sEnd);
+                checker+=node->QueryDoubleAttribute("sStart",&sStart);
+                if(checker == TIXML_SUCCESS)
+                {
+                    junctionboundary->AddJunctionboundarysegmentlane(boundaryLane,roadId,sEnd,sStart);
+                }
+            }
+            if(type == "joint")
+            {
+
+            }
+        }
+
+        subNode=node->NextSiblingElement("segment");
+    }
+
+    return true;
+}
+
 bool OpenDriveXmlParser::ReadJunctionPriority (Junction* junction, TiXmlElement *node)
 {
 	string high;

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

@@ -132,6 +132,12 @@ public:
 	bool ReadJunctionConnectionLaneLink (JunctionConnection* junctionConnection, TiXmlElement *node);
     bool ReadJunctionDirectConnectionLaneLink (JunctionDirectConnection* junctionDirectConnection, TiXmlElement *node);
     bool ReadJunctionDirectConnection (Junction* junction, TiXmlElement *node);
+    bool ReadJunctionCrossingspriority(Junction* junction, TiXmlElement *node);
+    bool ReadJunctionCrossingsroadSection(Junction* junction, TiXmlElement *node);
+    bool ReadJunctionplanView(Junction* junction, TiXmlElement *node);
+    bool ReadJunctionplanViewgeometry(JunctionplanView* planView, TiXmlElement *node);
+    bool ReadJunctionboundary(Junction* junction, TiXmlElement *node);
+    bool ReadJunctionboundarysegment(Junctionboundary * junctionboundary, TiXmlElement *node);
 	//--------------
 
 	bool ReadJunctionPriority (Junction* junction, TiXmlElement *node);

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

@@ -2422,6 +2422,16 @@ bool OpenDriveXmlWriter::WriteJunction (TiXmlElement *node, Junction *junction)
 
     type = junction->GetType();
 
+
+    if(type == "crossing")
+    {
+        if(junction->GetJunctionCrossingsroadSectionCount()<2)
+        {
+            std::cout<<" junction id: "<<id<<" not have at least 2 roadsection. so not save this junction to file. "<<std::endl;
+            return false;
+        }
+    }
+
 	TiXmlElement *nodeJunction = new TiXmlElement("junction");
 	node->LinkEndChild(nodeJunction);
 
@@ -2440,6 +2450,13 @@ bool OpenDriveXmlWriter::WriteJunction (TiXmlElement *node, Junction *junction)
         WriteJunctionDirectConnection(nodeJunction,junction);
     }
 
+    if(type == "crossing")
+    {
+        nodeJunction->SetAttribute("type",type);
+        WriteJunctionCrossingspriority(node,junction);
+        WriteJunctionCrossingsroadSection(node,junction);
+    }
+
 	//Priorities
 	WriteJunctionPriority(nodeJunction, junction);
 
@@ -2449,6 +2466,8 @@ bool OpenDriveXmlWriter::WriteJunction (TiXmlElement *node, Junction *junction)
     //CrossPass
     WriteJunctionCrossPass(nodeJunction,junction);
 
+    WriteJunctionplanView(nodeJunction,junction);
+
 	return true;
 }
 //--------------
@@ -2692,6 +2711,105 @@ bool OpenDriveXmlWriter::WriteJunctionCrossPassEndLaneLink(TiXmlElement *node, J
     return true;
 }
 
+bool OpenDriveXmlWriter::WriteJunctionCrossingspriority(TiXmlElement *node, Junction *junction)
+{
+    string high;
+    string low;
+
+    unsigned int junctionCrossingspriorityCount = junction->GetJunctionCrossingspriorityCount();
+    for(unsigned int i=0; i<junctionCrossingspriorityCount; i++)
+    {
+        JunctionCrossingspriority *lJunctionCrossingspriority = junction->GetJunctionCrossingspriority(i);
+
+        high = lJunctionCrossingspriority->Gethigh();
+        low = lJunctionCrossingspriority->Getlow();
+
+
+        TiXmlElement *nodeJunctionCrossingspriority = new TiXmlElement("priority");
+        node->LinkEndChild(nodeJunctionCrossingspriority);
+
+        nodeJunctionCrossingspriority->SetAttribute("high",high);
+        nodeJunctionCrossingspriority->SetAttribute("low",low);
+    }
+    return true;
+}
+bool OpenDriveXmlWriter::WriteJunctionCrossingsroadSection(TiXmlElement *node, Junction *junction)
+{
+    string id;
+    string roadId;
+    double sStart;
+    double sEnd;
+
+    unsigned int junctionCrossingsroadSectionCount = junction->GetJunctionCrossingsroadSectionCount();
+    for(unsigned int i=0; i<junctionCrossingsroadSectionCount; i++)
+    {
+        JunctionCrossingsroadSection *lJunctionCrossingsroadSection = junction->GetJunctionCrossingsroadSection(i);
+
+        id = lJunctionCrossingsroadSection->Getid();
+        roadId = lJunctionCrossingsroadSection->GetroadId();
+        sStart = lJunctionCrossingsroadSection->GetsStart();
+        sEnd = lJunctionCrossingsroadSection->GetsEnd();
+
+
+        TiXmlElement *nodeJunctionCrossingsroadSection = new TiXmlElement("roadSection");
+        node->LinkEndChild(nodeJunctionCrossingsroadSection);
+
+        nodeJunctionCrossingsroadSection->SetAttribute("id",id);
+        nodeJunctionCrossingsroadSection->SetAttribute("roadId",roadId);
+        nodeJunctionCrossingsroadSection->SetDoubleAttribute("sStart",sStart);
+        nodeJunctionCrossingsroadSection->SetDoubleAttribute("sEnd",sEnd);
+    }
+    return true;
+}
+
+
+bool OpenDriveXmlWriter::WriteJunctionplanView(TiXmlElement *node,  Junction *junction)
+{
+    JunctionplanView planView;
+    int nplanview = junction->GetJunctionplanView(planView);
+
+    if(nplanview == 0)return true;
+
+    TiXmlElement *nodeJunctionplanView  = new TiXmlElement("planView");
+    node->LinkEndChild(nodeJunctionplanView);
+
+    WriteJunctionplanViewgeometry(nodeJunctionplanView,&planView);
+    return true;
+
+}
+
+bool OpenDriveXmlWriter::WriteJunctionplanViewgeometry(TiXmlElement *node, JunctionplanView *planView)
+{
+    double s;
+    double x;
+    double y;
+    double hdg;
+    double length;
+
+    unsigned int junctionplanViewgeometryCount = planView->GetgeometryCount();
+    for(unsigned int i=0; i<junctionplanViewgeometryCount; i++)
+    {
+        JunctionplanViewgeometry *lJunctionplanViewgeometry = planView->Getgeometry(i);
+
+        s = lJunctionplanViewgeometry->Gets();
+        x = lJunctionplanViewgeometry->Getx();
+        y = lJunctionplanViewgeometry->Gety();
+        hdg = lJunctionplanViewgeometry->Gethdg();
+        length = lJunctionplanViewgeometry->Getlength();
+
+
+        TiXmlElement *nodeJunctionplanViewgeometry = new TiXmlElement("geometry");
+        node->LinkEndChild(nodeJunctionplanViewgeometry);
+
+        nodeJunctionplanViewgeometry->SetDoubleAttribute("s",s);
+        nodeJunctionplanViewgeometry->SetDoubleAttribute("x",x);
+        nodeJunctionplanViewgeometry->SetDoubleAttribute("y",y);
+        nodeJunctionplanViewgeometry->SetDoubleAttribute("hdg",hdg);
+        nodeJunctionplanViewgeometry->SetDoubleAttribute("length",length);
+    }
+    return true;
+}
+
 
 //---------------------------------------------------------------------------
 

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

@@ -127,6 +127,10 @@ public:
     bool WriteJunctionConnectionLaneLink (TiXmlElement *node, JunctionConnection* junctionConnection);
     bool WriteJunctionDirectConnection (TiXmlElement *node, Junction* junction);
     bool WriteJunctionDirectConnectionLaneLink (TiXmlElement *node, JunctionDirectConnection* junctionDirectConnection);
+    bool WriteJunctionCrossingspriority(TiXmlElement *node, Junction *junction);
+    bool WriteJunctionCrossingsroadSection(TiXmlElement *node, Junction *junction);
+    bool WriteJunctionplanView(TiXmlElement *node,  Junction *junction);
+    bool WriteJunctionplanViewgeometry(TiXmlElement *node, JunctionplanView *planView);
 	//--------------
 
 	bool WriteJunctionPriority (TiXmlElement *node, Junction* junction);