Implemented the Sinal object (get and set functions).

Modified the XML parser and write to read and write Signal objects.

OpenRoadEd/OpenDrive/ObjectSignal.cpp

+#include "ObjectSignal.h"
+
+Signal::Signal()
+{
+  mS=0.0;
+  mT=0.0;
+  mId="-1";
+  mName="";
+  mDynamic=false;
+  mOrientation="none";
+  mZOffset=0.0;
+  mCountry="";
+  mCountryRevision="";
+  mType="";
+  mSubType="";
+  mValue=0.0;
+  mUnit="";
+  mHeight=0.0;
+  mWidth=0.0;
+  mText="";
+  mHeadingOffset=0.0;
+  mPitch=0.0;
+  mRoll=0.0;
+}
+
+Signal::Signal(std::string &name,std::string &id)
+{
+  mS=0.0;
+  mT=0.0;
+  mId=id;
+  mName=name;
+  mDynamic=false;
+  mOrientation="none";
+  mZOffset=0.0;
+  mCountry="";
+  mCountryRevision="";
+  mType="";
+  mSubType="";
+  mValue=0.0;
+  mUnit="";
+  mHeight=0.0;
+  mWidth=0.0;
+  mText="";
+  mHeadingOffset=0.0;
+  mPitch=0.0;
+  mRoll=0.0;
+}
+
+Signal::Signal(const Signal &signal)
+{
+  mS=signal.mS;
+  mT=signal.mT;
+  mId=signal.mId;
+  mName=signal.mName;
+  mDynamic=signal.mDynamic;
+  mOrientation=signal.mOrientation;
+  mZOffset=signal.mZOffset;
+  mCountry=signal.mCountry;
+  mCountryRevision=signal.mCountryRevision;
+  mType=signal.mType;
+  mSubType=signal.mSubType;
+  mValue=signal.mValue;
+  mUnit=signal.mUnit;
+  mHeight=signal.mHeight;
+  mWidth=signal.mWidth;
+  mText=signal.mText;
+  mHeadingOffset=signal.mHeadingOffset;
+  mPitch=signal.mPitch;
+  mRoll=signal.mRoll;
+}
+
+const Signal &Signal::operator=(const Signal &rhs)
+{
+
+}
+
+
+double Signal::GetS(void)
+{
+  return mS;
+}
+
+double Signal::GetT(void)
+{
+  return mT;
+}
+
+std::string Signal::GetId(void)
+{
+  return mId;
+}
+
+std::string Signal::GetName(void)
+{
+  return mName;
+}
+
+bool Signal::IsDynamic(void)
+{
+  return mDynamic;
+}
+
+std::string Signal::GetOrientation(void)
+{
+  return mOrientation;
+}
+
+double Signal::GetZOffset(void)
+{
+  return mZOffset;
+}
+
+std::string Signal::GetCountry(void)
+{
+  return mCountry;
+}
+
+std::string Signal::GetCountryRevision(void)
+{
+  return mCountryRevision;
+}
+
+std::string Signal::GetType(void)
+{
+  return mType;
+}
+
+std::string Signal::GetSubType(void)
+{
+  return mSubType;
+}
+
+double Signal::GetValue(void)
+{
+  return mValue;
+}
+
+std::string Signal::GetUnit(void)
+{
+  return mUnit;
+}
+
+double Signal::GetHeight(void)
+{
+  return mHeight;
+}
+
+double Signal::GetWidth(void)
+{
+  return mWidth;
+}
+
+std::string Signal::GetText(void)
+{
+  return mText;
+}
+
+double Signal::GetHeadingOffset(void)
+{
+  return mHeadingOffset;
+}
+
+double Signal::GetPitch(void)
+{
+  return mPitch;
+}
+
+double Signal::GetRoll(void)
+{
+  return mRoll;
+}
+
+    
+void Signal::SetS(double s)
+{
+  mS=s;
+}
+
+void Signal::SetT(double t)
+{
+  mT=t;
+}
+
+void Signal::SetId(std::string &id)
+{
+  mId=id;
+}
+
+void Signal::SetName(std::string &name)
+{
+  mName=name;
+}
+
+void Signal::SetDynamic(bool dynamic)
+{
+  mDynamic=dynamic;
+}
+
+void Signal::SetOrientation(std::string &orientation)
+{
+  mOrientation=orientation;
+}
+
+void Signal::SetZOffset(double zOffset)
+{
+  mZOffset=zOffset;
+}
+
+void Signal::SetCountry(std::string &country)
+{
+  mCountry=country;
+}
+
+void Signal::SetCountryRevision(std::string &countryRevision)
+{
+  mCountryRevision=countryRevision;
+}
+
+void Signal::SetType(std::string &type)
+{
+  mType=type;
+}
+
+void Signal::SetSubType(std::string &subType)
+{
+  mSubType=subType;
+}
+
+void Signal::SetValue(double value)
+{
+  mValue=value;
+}
+
+void Signal::SetUnit(std::string &unit)
+{
+  mUnit=unit;
+}
+
+void Signal::SetHeight(double height)
+{
+  mHeight=height;
+}
+
+void Signal::SetWidth(double width)
+{
+  mWidth=width;
+}
+
+void Signal::SetText(std::string &text)
+{
+  mText=text;
+}
+
+void Signal::SetHeadingOffset(double headingOffset)
+{
+  mHeadingOffset=headingOffset;
+}
+
+void Signal::SetPitch(double pitch)
+{
+  mPitch=pitch;
+}
+
+void Signal::SetRoll(double roll)
+{
+  mRoll=roll;
+}
+

OpenRoadEd/OpenDrive/ObjectSignal.h

 #ifndef OBJECTSIGNAL_H
 #define OBJECTSIGNAL_H
 
-
+#include <string>
 
 //***********************************************************************************
 //Object
@@ -19,10 +19,74 @@ public:
 //***********************************************************************************
 class Signal
 {
-public:
-	Signal(){}
+  private:
+    double mS;
+    double mT;
+    std::string mId;
+    std::string mName;
+    bool mDynamic;
+    std::string mOrientation;
+    double mZOffset;
+    std::string mCountry;
+    std::string mCountryRevision;
+    std::string mType;
+    std::string mSubType;
+    double mValue;
+    std::string mUnit;
+    double mHeight;
+    double mWidth;
+    std::string mText;
+    double mHeadingOffset;
+    double mPitch;
+    double mRoll;
+  public:
+	  Signal();
+    Signal(std::string &name,std::string &id);
+    Signal(const Signal &signal);
+    const Signal &operator=(const Signal &rhs);
+
+    double GetS(void);
+    double GetT(void);
+    std::string GetId(void); 
+    std::string GetName(void);
+    bool IsDynamic(void);
+    std::string GetOrientation(void);
+    double GetZOffset(void);
+    std::string GetCountry(void);
+    std::string GetCountryRevision(void);
+    std::string GetType(void);
+    std::string GetSubType(void);
+    double GetValue(void);
+    std::string GetUnit(void);
+    double GetHeight(void);
+    double GetWidth(void);
+    std::string GetText(void);
+    double GetHeadingOffset(void);
+    double GetPitch(void);
+    double GetRoll(void);
+
+    void SetS(double s);
+    void SetT(double t);
+    void SetId(std::string &id); 
+    void SetName(std::string &name);
+    void SetDynamic(bool dynamic);
+    void SetOrientation(std::string &orientation);
+    void SetZOffset(double zOffset);
+    void SetCountry(std::string &country);
+    void SetCountryRevision(std::string &countryRevision);
+    void SetType(std::string &type);
+    void SetSubType(std::string &subType);
+    void SetValue(double value);
+    void SetUnit(std::string &unit);
+    void SetHeight(double height);
+    void SetWidth(double width);
+    void SetText(std::string &text);
+    void SetHeadingOffset(double headingOffset);
+    void SetPitch(double pitch);
+    void SetRoll(double roll);
+    
 };
 //----------------------------------------------------------------------------------
 
 
-#endif
\ No newline at end of file
+#endif

OpenRoadEd/OpenDrive/OpenDriveXmlParser.cpp

@@ -864,6 +864,69 @@ bool OpenDriveXmlParser::ReadObjects (Road* road, TiXmlElement *node)
 
 bool OpenDriveXmlParser::ReadSignals (Road* road, TiXmlElement *node)
 {
+	double s,t,zOffset,value,height,width,hOffset,pitch,roll;
+	std::string id,name,dynamic,orientation,country,countryRevision,type,subType,unit,text;
+  Signal *signal;
+	int checker=TIXML_SUCCESS;
+  TiXmlElement *signal_node;
+
+  signal_node=node->FirstChildElement("signal");
+  while(signal_node!=0)
+  {
+	  checker=TIXML_SUCCESS;
+  	checker+=signal_node->QueryDoubleAttribute("s",&s);
+	  checker+=signal_node->QueryDoubleAttribute("t",&t);
+  	checker+=signal_node->QueryStringAttribute("id",&id);
+    checker+=signal_node->QueryStringAttribute("name",&name);
+    checker+=signal_node->QueryStringAttribute("dynamic",&dynamic);
+    checker+=signal_node->QueryStringAttribute("orientation",&orientation);
+  	checker+=signal_node->QueryDoubleAttribute("zOffset",&zOffset);
+    checker+=signal_node->QueryStringAttribute("country",&country);
+//    checker+=signal_node->QueryStringAttribute("countryRevision",&countryRevision);
+    checker+=signal_node->QueryStringAttribute("type",&type);
+    checker+=signal_node->QueryStringAttribute("subtype",&subType);
+	  checker+=signal_node->QueryDoubleAttribute("value",&value);
+//    checker+=signal_node->QueryStringAttribute("unit",&unit);
+//	  checker+=signal_node->QueryDoubleAttribute("height",&height);
+//  	checker+=signal_node->QueryDoubleAttribute("width",&width);
+//    checker+=signal_node->QueryStringAttribute("text",&text);
+//  	checker+=signal_node->QueryDoubleAttribute("hOffset",&hOffset);
+//	  checker+=signal_node->QueryDoubleAttribute("pitch",&pitch);
+//  	checker+=signal_node->QueryDoubleAttribute("roll",&roll);
+	  if (checker!=TIXML_SUCCESS)
+  	{
+	  	cout<<"Error parsing road signal attributes"<<endl;
+		  return false;
+  	}
+
+    std::cout << "read signal " << name << " with id: " << id << std::endl;
+	  road->AddSignal();
+    signal=road->GetLastSignal();
+    signal->SetS(s);
+    signal->SetT(t);
+    signal->SetId(id);
+    signal->SetName(name);
+    if(dynamic=="yes")
+      signal->SetDynamic(true);
+    else
+      signal->SetDynamic(false);
+    signal->SetOrientation(orientation);
+    signal->SetZOffset(zOffset);
+    signal->SetCountry(country);
+    signal->SetCountryRevision(countryRevision);
+    signal->SetType(type);
+    signal->SetSubType(subType);
+    signal->SetValue(value);
+    signal->SetUnit(unit);
+    signal->SetHeight(height);
+    signal->SetWidth(width);
+    signal->SetText(text);
+    signal->SetHeadingOffset(hOffset);
+    signal->SetPitch(pitch);
+    signal->SetRoll(roll);
+
+    signal_node=node->NextSiblingElement("signal");
+  }
 	return true;
 }
 //--------------