add testipgroad for backup.

src/test/testipgroad/main.cpp

@@ -0,0 +1,589 @@
+#include <QCoreApplication>
+
+#include <QProcess>
+
+#include "stdarg.h"
+
+#include "road.h"
+#include "roadbuilder.h"
+
+#include <iostream>
+
+#include <getopt.h>
+
+#include <iostream>
+
+#include "rd5route.h"
+
+
+static char gstr_inputpath[256];
+static char gstr_outputpath[256];
+
+static char gstr_fromroad[256];
+static char gstr_fromlane[256];
+
+static char gstr_toroad[256];
+static char gstr_tolane[256];
+
+/**
+ * @brief print_useage
+ */
+void print_useage()
+{
+    std::cout<<" -i --input $xodrfile : set  input file path. eq.  -i d:/lk.xodr"<<std::endl;
+    std::cout<<" -o --output $outputfile : set output file. eq.  -o d:/test.rd5"<<std::endl;
+    std::cout<<" -h --help print help"<<std::endl;
+}
+
+int  GetOptLong(int argc, char *argv[]) {
+    int nRtn = 0;
+    int opt; // getopt_long() 的返回值
+    int digit_optind = 0; // 设置短参数类型及是否需要参数
+    (void)digit_optind;
+
+    // 如果option_index非空，它指向的变量将记录当前找到参数符合long_opts里的
+    // 第几个元素的描述，即是long_opts的下标值
+    int option_index = 0;
+    // 设置短参数类型及是否需要参数
+    const char *optstring = "i:o:a:b:c:d:h";
+
+    // 设置长参数类型及其简写，比如 --reqarg <==>-r
+    /*
+    struct option {
+             const char * name;  // 参数的名称
+             int has_arg; // 是否带参数值，有三种：no_argument， required_argument，optional_argument
+             int * flag; // 为空时，函数直接将 val 的数值从getopt_long的返回值返回出去，
+                     // 当非空时，val的值会被赋到 flag 指向的整型数中，而函数返回值为0
+             int val; // 用于指定函数找到该选项时的返回值，或者当flag非空时指定flag指向的数据的值
+        };
+    其中：
+        no_argument(即0)，表明这个长参数不带参数（即不带数值，如：--name）
+            required_argument(即1)，表明这个长参数必须带参数（即必须带数值，如：--name Bob）
+            optional_argument(即2)，表明这个长参数后面带的参数是可选的，（即--name和--name Bob均可）
+     */
+    static struct option long_options[] = {
+        {"input", required_argument, NULL, 'v'},
+        {"output", required_argument, NULL, 'o'},
+        {"fromroad", required_argument, NULL, 'a'},
+        {"fromlane", required_argument, NULL, 'b'},
+        {"toroad", required_argument, NULL, 'c'},
+        {"tolane", required_argument, NULL, 'd'},
+        {"help",  no_argument,       NULL, 'h'},
+ //       {"optarg", optional_argument, NULL, 'o'},
+        {0, 0, 0, 0}  // 添加 {0, 0, 0, 0} 是为了防止输入空值
+    };
+
+    while ( (opt = getopt_long(argc,
+                               argv,
+                               optstring,
+                               long_options,
+                               &option_index)) != -1) {
+//        printf("opt = %c\n", opt); // 命令参数，亦即 -a -b -n -r
+//        printf("optarg = %s\n", optarg); // 参数内容
+//        printf("optind = %d\n", optind); // 下一个被处理的下标值
+//        printf("argv[optind - 1] = %s\n",  argv[optind - 1]); // 参数内容
+//        printf("option_index = %d\n", option_index);  // 当前打印参数的下标值
+//        printf("\n");
+        switch(opt)
+        {
+        case 'i':
+            strncpy(gstr_inputpath,optarg,255);
+            break;
+        case 'o':
+            strncpy(gstr_outputpath,optarg,255);
+            break;
+        case 'a':
+            strncpy(gstr_fromroad,optarg,255);
+            break;
+        case 'b':
+            strncpy(gstr_fromlane,optarg,255);
+            break;
+        case 'c':
+            strncpy(gstr_toroad,optarg,255);
+            break;
+        case 'd':
+            strncpy(gstr_tolane,optarg,255);
+            break;
+        case 'h':
+            print_useage();
+            nRtn = 1; //because use -h
+            break;
+        default:
+            break;
+        }
+
+    }
+
+    return nRtn;
+}
+
+
+
+
+int
+ipgErrorExit(tRoad *road)
+{
+    int nErrMsg;
+    tRoadMessageList msgList;
+
+    nErrMsg = RoadGetMessageList(road, RMT_Error, &msgList);
+    while (--nErrMsg>=0)  fprintf(stderr, "%s\n", msgList.msg[nErrMsg].msg);
+    RoadDeleteMessageList(road,&msgList);
+    RoadClearMessageBuffer(road, RMT_Error);
+
+    return ROAD_Error;
+}
+
+void
+ipgWarnMsg(tRoad *road)
+{
+    int nWarn;
+    tRoadMessageList msgList;
+
+    nWarn = RoadGetMessageList(road, RMT_Warn, &msgList);
+    while (--nWarn>=0)  fprintf(stderr, "%s\n", msgList.msg[nWarn].msg);
+    RoadDeleteMessageList(road,&msgList);
+    RoadClearMessageBuffer(road, RMT_Warn);
+}
+
+int
+createRoadFile (tRoad *road, char* fname)
+{
+    tObjId lObjId0,lObjId1,lObjId2, lsObjId, jObjId, segObjId, jArmObjId0,jArmObjId1,jArmObjId2;
+    tRoadLink rLink;
+    tRoadJunction rJunc;
+    tRoadJunctionArm rJArm;
+    tRoadSegment rSeg;
+    tRoadLaneSection rLS;
+    tRoadLane rLane,rBorderLane;
+    tRoadZP rZP;
+    double angle,length;
+
+
+    // Creating the first Link
+    memset(&rLink,0,sizeof(rLink));
+
+    // The start (position and angle) is defined explicitly by rLink.xyz0={0,0,0} and rLink.angle0=0
+    rLink.xyz0[0]  = 0;
+    rLink.xyz0[1]  = 0;
+    rLink.xyz0[2]  = 0;
+    rLink.angle0   = 0;
+    rLink.rst      = RST_Countryroad;
+    rLink.material = NULL;
+
+    if ((lObjId0=RoadAddLink(road,&rLink))==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+
+    // Creating the Reference line of the Link by adding a list of Segments
+    memset(&rSeg,0,sizeof(rSeg));
+
+    rSeg.type     = RST_Straight;
+    rSeg.param[0] = 50;
+
+    if ((segObjId=RoadAddSegment(road,lObjId0,&rSeg,ROAD_InvalidObjId))==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+
+    rSeg.type     = RST_ClothRight;
+    rSeg.param[0] = 1000;
+    rSeg.param[1] = 100;
+    rSeg.param[2] = 20;
+
+    if ((segObjId=RoadAddSegment(road,lObjId0,&rSeg,ROAD_InvalidObjId))==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+
+    rSeg.type     = RST_TurnRight;
+    rSeg.param[0] = 100;
+    rSeg.param[1] = 15;
+    rSeg.param[2] = 0;
+
+    if ((segObjId=RoadAddSegment(road,lObjId0,&rSeg,ROAD_InvalidObjId))==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+
+    rSeg.type     = RST_ClothRight;
+    rSeg.param[0] = 100;
+    rSeg.param[1] = 1000;
+    rSeg.param[2] = 20;
+
+    if ((segObjId=RoadAddSegment(road,lObjId0,&rSeg,ROAD_InvalidObjId))==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+
+    rSeg.type     = RST_Straight;
+    rSeg.param[0] = 15;
+    rSeg.param[1] = 0;
+    rSeg.param[2] = 0;
+
+    if ((segObjId=RoadAddSegment(road,lObjId0,&rSeg,ROAD_InvalidObjId))==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+
+    // Creating an Elevation profile
+    memset(&rZP,0,sizeof(rZP));
+
+    rZP.isAbsolute = 0;
+    rZP.n = 6;
+    rZP.node = (tRoadNode1D*) calloc(rZP.n,sizeof(tRoadNode1D));
+    rZP.node[0].type = RTT_Cubic;
+    rZP.node[0].s    = 0;
+    rZP.node[0].c[0] = 0;
+    rZP.node[0].c[1] = 0;
+    rZP.node[1].s    = 15;
+    rZP.node[1].c[0] = -0.03;
+    rZP.node[1].c[1] = ROAD_UNDEFINED;
+    rZP.node[2].s    = 50;
+    rZP.node[2].c[0] = 0.5;
+    rZP.node[2].c[1] = ROAD_UNDEFINED;
+    rZP.node[3].s    = 80;
+    rZP.node[3].c[0] = 0.0;
+    rZP.node[3].c[1] = ROAD_UNDEFINED;
+    rZP.node[4].lonR = RLR_Node1; //1;
+    rZP.node[4].s    = 50;
+    rZP.node[4].c[0] = -0.5;
+    rZP.node[4].c[1] = ROAD_UNDEFINED;
+    rZP.node[5].lonR =RLR_Node1;//  1;
+    rZP.node[5].s    = 5;
+    rZP.node[5].c[0] = -1.5;
+    rZP.node[5].c[1] = ROAD_UNDEFINED;
+    rZP.smooth = 0.0;
+
+    if (RoadAddZProfile(road,lObjId0, ROT_LonZPElevation,&rZP)==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+
+    free(rZP.node);
+
+    // Adding a Lane section to the Link
+    memset(&rLS,0,sizeof(rLS));
+
+    rLS.s = 0;
+
+    if ((lsObjId=RoadAddLaneSection(road,lObjId0,&rLS))==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+
+    // Update of the internal road structure
+    if (RoadBuilderUpdate(road)<0)
+        return ipgErrorExit(road);
+
+    // Adding a border lane on both sides
+    memset(&rBorderLane,0,sizeof(rBorderLane));
+
+    rBorderLane.type      = RTT_Cubic;
+    rBorderLane.w0        = 0.5;
+    rBorderLane.w1        = 0.5;
+    rBorderLane.attr.type = RLT_Border;
+
+    if (RoadAddLane(road,lsObjId,R_RIGHT,&rBorderLane,ROAD_InvalidObjId)==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+    if (RoadAddLane(road,lsObjId,R_LEFT, &rBorderLane,ROAD_InvalidObjId)==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+
+    // Getting the length of the Link
+    length = RoadGetLinkLength(road,lObjId0);
+
+    // Adding a new Lane section at the end of the Link
+    rLS.s = length-50;
+
+    if ((lsObjId=RoadAddLaneSection(road,lObjId0,&rLS))==ROAD_InvalidObjId)
+         return ipgErrorExit(road);
+
+    // Adding Lanes to the new Lane section
+    // First delete all default Lanes of this Lane section
+    RoadDeleteAllLSLanes(road,lsObjId);
+
+    memset(&rLane,0,sizeof(rLane));
+
+    rLane.type      = RTT_Cubic;
+    rLane.w0        = 0;
+    rLane.w1        = 4;
+    rLane.attr.type = RLT_Road;
+    rLane.n         = 1;
+    rLane.width = (tRoadNode1D*) calloc(rLane.n,sizeof(tRoadNode1D));
+    rLane.width[0].lonR = RLR_Node0;
+    rLane.width[0].s    = 25;
+    rLane.width[0].type = RTT_Cubic;
+    rLane.width[0].c[0] = 4;
+
+    if (RoadAddLane(road,lsObjId,R_RIGHT,&rLane,ROT_Invalid)==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+
+    free(rLane.width);
+
+    rLane.n     = 0;
+    rLane.width = NULL;
+    rLane.w0    = 3.5;
+    rLane.w1    = 3.5;
+
+    if (RoadAddLane(road,lsObjId,R_RIGHT,&rLane,ROT_Invalid)==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+    if (RoadAddLane(road,lsObjId,R_LEFT, &rLane,ROT_Invalid)==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+    if (RoadAddLane(road,lsObjId,R_RIGHT,&rBorderLane,ROT_Invalid)==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+    if (RoadAddLane(road,lsObjId,R_LEFT, &rBorderLane,ROT_Invalid)==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+
+    // Update of the internal road structure
+    if (RoadBuilderUpdate(road)<0)
+        return ipgErrorExit(road);
+
+
+    RoadGetLink(road,lObjId0,&rLink);
+    angle = RoadGetLinkHeading(road,lObjId0,length);
+    angle = angle>180 ? angle-180 : angle+180;
+
+    // Preparing to add a Junction to the end of the first Link
+    memset(&rJunc,0,sizeof(rJunc));
+
+    // The knot is defined explicitly using the position of the first Link's end
+    rJunc.rjt      = RJT_Simple;
+    rJunc.knot[0]  = rLink.xyz1[0];
+    rJunc.knot[1]  = rLink.xyz1[1];
+    rJunc.knot[2]  = rLink.xyz1[2];
+    rJunc.rst      = RST_Urban;
+
+
+    // Creating the second Link
+    memset(&rLink,0,sizeof(rLink));
+
+    // The start (position and angle) is defined explicitly using the position of the Junction's knot
+    rLink.xyz0[0]  = rJunc.knot[0];
+    rLink.xyz0[1]  = rJunc.knot[1];
+    rLink.xyz0[2]  = rJunc.knot[2];
+    rLink.angle0   = angle<200 ? angle+160 : angle+160-360;
+    rLink.rst      = RST_Countryroad;
+    rLink.material = NULL;
+
+    if ((lObjId1=RoadAddLink(road,&rLink))==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+
+    // Creating the Reference line of the Link by adding a list of Segments
+    memset(&rSeg,0,sizeof(rSeg));
+
+    rSeg.type     = RST_Straight;
+    rSeg.param[0] = 50;
+
+    if ((segObjId=RoadAddSegment(road,lObjId1,&rSeg,ROAD_InvalidObjId))==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+
+    // Adding a Lane section to the Link
+    memset(&rLS,0,sizeof(rLS));
+
+    rLS.s = 0;
+
+    if ((lsObjId=RoadAddLaneSection(road,lObjId1,&rLS))==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+
+    // Update of the internal road structure
+    if (RoadBuilderUpdate(road)<0)
+        return ipgErrorExit(road);
+
+    // Adding a border lane on both sides
+    if (RoadAddLane(road,lsObjId,R_RIGHT,&rBorderLane,ROAD_InvalidObjId)==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+    if (RoadAddLane(road,lsObjId,R_LEFT,&rBorderLane,ROAD_InvalidObjId)==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+
+
+    // Creating the third Link
+    memset(&rLink,0,sizeof(rLink));
+
+    // The start (position and angle) is defined explicitly using the position of the Junction's knot
+    rLink.xyz0[0]  = rJunc.knot[0];
+    rLink.xyz0[1]  = rJunc.knot[1];
+    rLink.xyz0[2]  = rJunc.knot[2];
+    rLink.angle0   = angle>70  ? angle-70 : angle-70+360;
+    rLink.rst      = RST_Countryroad;
+    rLink.material = NULL;
+
+    if ((lObjId2=RoadAddLink(road,&rLink))==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+
+    // Creating the Reference line of the Link by adding a list of Segments
+    memset(&rSeg,0,sizeof(rSeg));
+
+    rSeg.type     = RST_Straight;
+    rSeg.param[0] = 50;
+
+    if ((segObjId=RoadAddSegment(road,lObjId2,&rSeg,ROAD_InvalidObjId))==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+
+    // Adding a Lane section to the Link
+    memset(&rLS,0,sizeof(rLS));
+
+    rLS.s = 0;
+
+    if ((lsObjId=RoadAddLaneSection(road,lObjId2,&rLS))==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+
+    // Update of the internal road structure
+    if (RoadBuilderUpdate(road)<0)
+        return ipgErrorExit(road);
+
+    // Adding a border lane on both sides
+    if (RoadAddLane(road,lsObjId,R_RIGHT,&rBorderLane,ROAD_InvalidObjId)==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+    if (RoadAddLane(road,lsObjId,R_LEFT,&rBorderLane,ROAD_InvalidObjId)==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+
+
+    // Adding a Junction to connect the three Links
+    if ((jObjId=RoadAddJunction(road,&rJunc))==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+
+    // Adding Junction arms to the Junction
+    memset(&rJArm,0,sizeof(rJArm));
+
+    rJArm.lengthOnLink      = 10;   // Defines the junction entry distance
+
+    if ((jArmObjId0=RoadAddJunctionArm(road,jObjId,&rJArm))==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+
+    if ((jArmObjId1=RoadAddJunctionArm(road,jObjId,&rJArm))==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+
+    if ((jArmObjId2=RoadAddJunctionArm(road,jObjId,&rJArm))==ROAD_InvalidObjId)
+        return ipgErrorExit(road);
+
+    RoadJunctionSetMainArms(road,jObjId,jArmObjId0,jArmObjId1);
+
+    // Connecting the Links to the Junction arms
+    if (RoadJunctionArmConnectLink(road,jArmObjId0,lObjId0,1,ROAD_JUNC_FORCE_CONNECT)<0)
+        return ipgErrorExit(road);
+
+    if (RoadJunctionArmConnectLink(road,jArmObjId1,lObjId1,0,ROAD_JUNC_FORCE_CONNECT)<0)
+        return ipgErrorExit(road);
+
+    if (RoadJunctionArmConnectLink(road,jArmObjId2,lObjId2,0,ROAD_JUNC_FORCE_CONNECT)<0)
+        return ipgErrorExit(road);
+
+
+    // Creating Road markings automatically using the built-in function
+    RoadBuilderAutoCompletion(road, AC_RoadMarkings);
+
+
+    // Finishing update of the internal road structure
+    RoadSetAllUpdateFlags(road);
+    if (RoadBuilderFinish(road)<0)
+        return ipgErrorExit(road);
+
+    RoadWriteFile(road,fname,NULL);
+
+
+    // Writing the road InfoFile
+//    if (RoadWriteFile(road, fname ? fname:"Example.rd5", NULL)<0)
+//        return ipgErrorExit(road);
+
+
+    // Print all messages
+    ipgWarnMsg(road);
+
+    return ROAD_Ok;
+}
+
+#include <QFileInfo>
+
+int main(int argc, char *argv[])
+{
+    QCoreApplication a(argc, argv);
+
+
+    snprintf(gstr_fromroad,256,"1");
+    snprintf(gstr_toroad,256,"3");
+    snprintf(gstr_fromlane,256,"-1");
+    snprintf(gstr_tolane,256,"-1");
+
+    int nRtn = GetOptLong(argc,argv);
+    if(nRtn == 1)  //show help,so exit.
+    {
+        return 0;
+    }
+
+
+#ifdef TESTC
+    snprintf(gstr_inputpath,255,"D:/lk.xlsx");
+    snprintf(gstr_outputpath,255,"D:/lk.rd5");
+#endif
+
+    if(strncmp(gstr_inputpath , "",255) == 0)
+    {
+        std::cout<<"Please use -i set input file path."<<std::endl;
+        print_useage();
+        return 0;
+    }
+
+    char strout[1000];
+    snprintf(strout,1000,"Input File Path: %s",gstr_inputpath);
+    std::cout<<strout<<std::endl;
+
+    if(strncmp(gstr_outputpath , "",255) == 0)
+    {
+        std::cout<<"Please use -o set output file path."<<std::endl;
+        print_useage();
+        return 0;
+    }
+
+    snprintf(strout,1000,"Output File Path: %s",gstr_outputpath);
+    std::cout<<strout<<std::endl;
+
+
+
+
+    char stroutxodrname[256];
+    snprintf(stroutxodrname,255,"%s.xodr",gstr_outputpath);
+
+    char strproccmd[600];
+    snprintf(strproccmd,600,"cdaproc.exe -i %s -o %s",gstr_inputpath,stroutxodrname);
+    std::cout<<" cmd : "<<strproccmd<<std::endl;
+
+    QProcess * pProc = new QProcess();
+
+    pProc->start(strproccmd);
+    pProc->waitForFinished();
+
+    QFileInfo fileinfo(stroutxodrname);
+    if(!fileinfo.isFile())
+    {
+        std::cout<<" convert to cda FAIL."<<std::endl;
+        return -1;
+    }
+
+    tRoad * pRoad;
+
+    pRoad = RoadNew();
+
+    if(pRoad == NULL)
+    {
+        std::cout<<" Road New Fail."<<std::endl;
+        return -1;
+    }
+    else
+    {
+        std::cout<<" Road New Successfully."<<std::endl;
+    }
+
+
+//    createRoadFile(pRoad,"D:/z.rd5");
+
+    int nrtn = RoadReadOpenDRIVE(pRoad,stroutxodrname);
+
+    if(nrtn<0)
+    {
+        ipgErrorExit(pRoad);
+        return -1;
+    }
+
+
+    rd5route * proute = new rd5route(pRoad);
+//    proute->route();
+
+    int nfromroad = atoi(gstr_fromroad);
+    int ntoroad = atoi(gstr_toroad);
+    int nfromlane = atoi(gstr_fromlane);
+    int ntolane = atoi(gstr_tolane);
+    proute->route(nfromroad,nfromlane,ntoroad,ntolane);
+ //   proute->route(1,-3,2,3);
+ //   proute->route(1,-1,1,-1);
+    delete proute;
+
+    RoadWriteFile(pRoad,gstr_outputpath,NULL);
+
+    return 0;
+    return a.exec();
+}

src/test/testipgroad/rd5route.cpp

@@ -0,0 +1,457 @@
+#include "rd5route.h"
+
+#include <iostream>
+
+#include <string.h>
+
+rd5route::rd5route(tRoad * pRoad)
+{
+    mpRoad = pRoad;
+}
+
+void rd5route::route()
+{
+    tObjId * pObj;
+    int nObj = RoadGetAllChildObjIds(mpRoad,-1,&pObj);
+
+    if(nObj == 5)
+    {
+       std::cout<<" route cross. "<<std::endl;
+       routetypecross();
+    }
+}
+
+void rd5route::printchildobj(int nObjId)
+{
+    tObjId * pObj;
+    int nObj = RoadGetAllChildObjIds(mpRoad,nObjId,&pObj);
+    int i;
+
+    for(i=0;i<nObj;i++)
+    {
+        int type = RoadGetObjectType(mpRoad,pObj[i]);
+        std::cout<<nObjId<<" Child: "<<i<<" id: "<<pObj[i]<<" type:"<<type<<std::endl;
+    }
+}
+
+tObjId rd5route::GetObjByxodrRoadid(tObjId * pObjId,int nObj,int nordid)
+{
+    int i;
+ //   std::cout<<" obj size: "<<nObj<<std::endl;
+    char strodrtag[256];
+    snprintf(strodrtag,256,"odrRoadId:%d",nordid);
+ //   std::cout<<" need tag:"<<strodrtag<<std::endl;
+    for(i=0;i<nObj;i++)
+    {
+        char * strtag = RoadGetObjectTag(mpRoad,pObjId[i]);
+        if(strtag != NULL)
+        {
+//            std::cout<<" strtag: "<<strtag<<std::endl;
+        }
+        else continue;
+        if(strncmp(strodrtag,strtag,256) == 0)
+        {
+//            std::cout<<"rd5route::GetObjByxodrRoadid  road id: "<<pObjId[i]<<std::endl;
+            return  pObjId[i];
+        }
+    }
+    return -1;
+}
+
+tObjId rd5route::GetJunctionId(tObjId * pObjId, int nObj)
+{
+    int i;
+    for(i=0;i<nObj;i++)
+    {
+        int ntype = RoadGetObjectType(mpRoad,pObjId[i]);
+        if(ntype == ROT_Junction)
+        {
+            return  pObjId[i];
+        }
+    }
+
+    return -1;
+
+}
+
+std::vector<tObjId> rd5route::GetLanePath(tObjId nLinkID,int nLeftRight)
+{
+    std::vector<tObjId> xvectorpath;
+
+    tObjId * pObj;
+    int nObj = RoadGetLaneSectionObjIds(mpRoad,nLinkID,&pObj);
+
+    if(nObj>0)
+    {
+        int nLSid = pObj[0];
+        tObjId * pLaneIDs;
+        int nLaneCount = RoadGetLaneObjIds(mpRoad,nLSid,nLeftRight,&pLaneIDs);
+//        std::cout<<" lane id count: "<<nLaneCount<<std::endl;
+
+        int i;
+        for(i=0;i<nLaneCount;i++)
+        {
+            double tCenter,width;
+            RoadGetLaneTW(mpRoad,pLaneIDs[i],0,&tCenter,&width);
+
+            tRoadLane xLane;
+            int side;
+            RoadGetLane(mpRoad,pLaneIDs[i],&xLane,&side);
+//            std::cout<<i<<" : id:"<<pLaneIDs[i]<<" tCenter: "<<tCenter<<" width: "<<width<<" TYPE: "<<xLane.attr.type<<std::endl;
+
+            if(xLane.attr.type == RLT_Road)
+            {
+                tObjId * pObjPath;
+                int nObjCh = RoadGetAllChildObjIds(mpRoad,pLaneIDs[i],&pObjPath);
+                int j;
+
+                for(j=0;j<nObjCh;j++)
+                {
+                    int type = RoadGetObjectType(mpRoad,pObjPath[j]);
+                    if(type == ROT_LanePath)
+                    {
+                        xvectorpath.push_back(pObjPath[j]);
+                        break;
+                    }
+                }
+            }
+
+
+        }
+
+
+    }
+    return xvectorpath;
+
+}
+
+std::vector<tObjId> rd5route::GetConPath(tObjId nJunctionID)
+{
+    std::vector<tObjId> xvectorConPath;
+    tObjId * pObj;
+    int nObj = RoadGetAllChildObjIds(mpRoad,nJunctionID,&pObj);
+    int i;
+
+    for(i=0;i<nObj;i++)
+    {
+        int type = RoadGetObjectType(mpRoad,pObj[i]);
+        if(type == ROT_ConPath)
+        {
+            xvectorConPath.push_back(pObj[i]);
+//            tRoadConPath xConPath;
+//            RoadGetConPath(mpRoad,pObj[i],&xConPath);
+ //           std::cout<<" id0: "<<xConPath.objId0<<" id1: "<<xConPath.objId1<<std::endl;
+        }
+    }
+    return xvectorConPath;
+}
+
+tRoadLane rd5route::GetLane(tObjId nLinkID,int nlane)
+{
+
+}
+
+void rd5route::CreateNewRouteName(char * strroutename)
+{
+    std::vector<char *> xvectorroutename;
+
+    tObjId * pObj;
+    int nObj = RoadGetAllChildObjIds(mpRoad,-1,&pObj);
+
+    int i;
+
+    for(i=0;i<nObj;i++)
+    {
+        int type = RoadGetObjectType(mpRoad,pObj[i]);
+        if(type == ROT_Route)
+        {
+
+            char * strname = RoadRouteGetNameByObjId(mpRoad,pObj[i]);
+            if(strname != NULL)xvectorroutename.push_back(strname);
+//            tRoadConPath xConPath;
+//            RoadGetConPath(mpRoad,pObj[i],&xConPath);
+ //           std::cout<<" id0: "<<xConPath.objId0<<" id1: "<<xConPath.objId1<<std::endl;
+        }
+    }
+
+
+    snprintf(strroutename,255,"Route_0");
+
+    if(xvectorroutename.size() == 0)return;
+
+    int nroutesize = static_cast<int>(xvectorroutename.size());
+
+    bool bSame = true;
+    int nindex = 0;
+    while(bSame)
+    {
+        nindex++;
+        snprintf(strroutename,255,"Route_%d",nindex);
+        bSame = false;
+        for(i=0;i<nroutesize;i++)
+        {
+            if(strncmp(strroutename,xvectorroutename[static_cast<unsigned int>(i)],255) == 0)
+            {
+                bSame = true;
+                break;
+            }
+        }
+    }
+
+    return;
+
+
+
+}
+
+int rd5route::CreateDrivePath(std::vector<tObjId> xvectorConPath, tObjId nfrom, tObjId nto)
+{
+    unsigned int nConPath = static_cast<unsigned int>(xvectorConPath.size()) ;
+    unsigned int i;
+    bool bCreate = false;
+
+    for(i=0;i<nConPath;i++)
+    {
+        tRoadConPath xConPath;
+        RoadGetConPath(mpRoad,xvectorConPath[i],&xConPath);
+
+        if((xConPath.objId0 == nfrom) &&(xConPath.objId1 == nto))
+        {
+
+
+            tObjId routeid = RoadAddRoute(mpRoad);
+            char strroutname[256];
+            CreateNewRouteName(strroutname);
+ //           snprintf(strroutname,256,"Route_%d",mnRoute);mnRoute++;
+
+            tObjId drivepathid = RoadRouteAddDrvPath(mpRoad,routeid);
+            std::cout<<" route id: "<<routeid<<" drive id: "<<drivepathid<<std::endl;
+            RoadAddPath2DrvPath(mpRoad,drivepathid,nfrom);
+            RoadAddPath2DrvPath(mpRoad,drivepathid,xvectorConPath[i]);
+            RoadAddPath2DrvPath(mpRoad,drivepathid,nto);
+            RoadRouteObjSetName(mpRoad,routeid,strroutname);
+
+            RoadRouteFinish(mpRoad,routeid);
+            bCreate = true;
+                  //      RoadRouteUpdate(mpRoad);
+                        break;
+        }
+    }
+
+    if(bCreate == false)
+    {
+        return -1;
+    }
+
+    return 0;
+}
+
+
+void rd5route::CreateDrivePath(std::vector<tObjId> xvectorConPath,std::vector<tObjId> xvectorFromPath,std::vector<tObjId> xvectorToPath)
+{
+    unsigned int nConPath = static_cast<unsigned int>(xvectorConPath.size()) ;
+    unsigned int i;
+    bool bSaveMain = false;
+
+    for(i=0;i<nConPath;i++)
+    {
+        tRoadConPath xConPath;
+        RoadGetConPath(mpRoad,xvectorConPath[i],&xConPath);
+        bool bCon = false;
+        unsigned int j;
+        unsigned int k;
+        for(j=0;j<xvectorFromPath.size();j++)
+        {
+            if(xvectorFromPath[j] == xConPath.objId0)
+            {
+                for(k=0;k<xvectorToPath.size();k++)
+                {
+                    if(xvectorToPath[k] == xConPath.objId1)
+                    {
+                        bCon = true;
+                        std::cout<<" a drive path: "<<xvectorFromPath[j]<< " "<<xvectorConPath[i]<<" "<<xvectorToPath[k]<<std::endl;
+                        tObjId routeid = RoadAddRoute(mpRoad);
+                        char strroutname[256];
+                        CreateNewRouteName(strroutname);
+                        std::cout<<"route name : "<<strroutname<<std::endl;
+   //                     snprintf(strroutname,256,"Route_%d",mnRoute);mnRoute++;
+
+                        tObjId drivepathid = RoadRouteAddDrvPath(mpRoad,routeid);
+                        std::cout<<" route id: "<<routeid<<" drive id: "<<drivepathid<<std::endl;
+                        RoadAddPath2DrvPath(mpRoad,drivepathid,xvectorFromPath[j]);
+                        RoadAddPath2DrvPath(mpRoad,drivepathid,xvectorConPath[i]);
+                        RoadAddPath2DrvPath(mpRoad,drivepathid,xvectorToPath[k]);
+                        RoadRouteObjSetName(mpRoad,routeid,strroutname);
+                        if(bSaveMain == false)
+                        {
+                            RoadRouteSetMain(mpRoad,routeid);
+                            bSaveMain = true;
+                        }
+                        RoadRouteFinish(mpRoad,routeid);
+                  //      RoadRouteUpdate(mpRoad);
+                        break;
+                    }
+                }
+                if(bCon)break;
+            }
+        }
+    }
+
+}
+
+void rd5route::routetypecross_road(int fromroad,int leftright, int toroad,int leftright2)
+{
+    tObjId * pObj;
+    int nObj = RoadGetAllChildObjIds(mpRoad,-1,&pObj);
+
+    tObjId xlinkidFrom =  GetObjByxodrRoadid(pObj,nObj,fromroad);
+    tObjId xlinkidTo =  GetObjByxodrRoadid(pObj,nObj,toroad);
+
+    std::cout<<" from link id: "<<xlinkidFrom<<" to link id: "<<xlinkidTo<<std::endl;
+
+    std::vector<tObjId> xvectorfrompath = GetLanePath(xlinkidFrom,leftright);
+
+    std::vector<tObjId> xvectortopath = GetLanePath(xlinkidTo,leftright2);
+
+    tObjId xJunctionID = GetJunctionId(pObj,nObj);
+
+//    std::cout<<" Junction ID: "<<xJunctionID<<std::endl;
+
+    printchildobj(xJunctionID);
+
+    std::vector<tObjId> xvectorconpath = GetConPath(xJunctionID);
+
+    CreateDrivePath(xvectorconpath,xvectorfrompath,xvectortopath);
+}
+
+void rd5route::routetypecross()
+{
+
+    routetypecross_road(1,R_RIGHT, 2,R_LEFT);
+    routetypecross_road(1,R_RIGHT,3,R_RIGHT);
+    routetypecross_road(1,R_RIGHT, 4,R_RIGHT);
+}
+
+void rd5route::routetypeoneroad(int nfromroad,int nfromlane)
+{
+    tObjId * pObj;
+    int nObj = RoadGetAllChildObjIds(mpRoad,-1,&pObj);
+
+    tObjId xlinkidFrom =  GetObjByxodrRoadid(pObj,nObj,nfromroad);
+
+    if(xlinkidFrom<0)
+    {
+        std::cout<<" routetypeoneroad can't find fromroad."<<std::endl;
+        return;
+    }
+
+    int leftright1;
+    if(nfromlane<0)
+    {
+        leftright1 = R_RIGHT;
+    }
+    else
+    {
+        leftright1 = R_LEFT;
+    }
+
+    std::vector<tObjId> xvectorfrompath = GetLanePath(xlinkidFrom,leftright1);
+
+    if(abs(nfromlane)>static_cast<int>(xvectorfrompath.size()))
+    {
+        std::cout<<"routetypeoneroad nfromlane error. nfrom lane: "<<nfromlane<<" lane total: "<<xvectorfrompath.size()<<std::endl;
+        return;
+    }
+
+    tObjId routeid = RoadAddRoute(mpRoad);
+    char strroutname[256];
+    CreateNewRouteName(strroutname);
+    std::cout<<"route name : "<<strroutname<<std::endl;
+//                     snprintf(strroutname,256,"Route_%d",mnRoute);mnRoute++;
+
+    tObjId drivepathid = RoadRouteAddDrvPath(mpRoad,routeid);
+    std::cout<<" route id: "<<routeid<<" drive id: "<<drivepathid<<std::endl;
+    RoadAddPath2DrvPath(mpRoad,drivepathid,xvectorfrompath[abs(nfromlane)-1]);
+    RoadRouteObjSetName(mpRoad,routeid,strroutname);
+    RoadRouteFinish(mpRoad,routeid);
+}
+
+void rd5route::routetypecross_road_lane(int nfromroad, int nfromlane, int ntoroad, int ntolane)
+{
+    tObjId * pObj;
+    int nObj = RoadGetAllChildObjIds(mpRoad,-1,&pObj);
+
+    tObjId xlinkidFrom =  GetObjByxodrRoadid(pObj,nObj,nfromroad);
+    tObjId xlinkidTo =  GetObjByxodrRoadid(pObj,nObj,ntoroad);
+
+    if(xlinkidFrom<0)
+    {
+        std::cout<<" routetypecross_road_lane can't find fromroad."<<std::endl;
+        return;
+    }
+
+    if(xlinkidTo<0)
+    {
+        std::cout<<" routetypecross_road_lane can't find toroad."<<std::endl;
+        return;
+    }
+
+    int leftright1,leftright2;
+    if(nfromlane<0)
+    {
+        leftright1 = R_RIGHT;
+    }
+    else
+    {
+        leftright1 = R_LEFT;
+    }
+
+    if(ntolane<0)
+    {
+        leftright2 = R_RIGHT;
+    }
+    else
+    {
+        leftright2 = R_LEFT;
+    }
+
+    std::vector<tObjId> xvectorfrompath = GetLanePath(xlinkidFrom,leftright1);
+
+    std::vector<tObjId> xvectortopath = GetLanePath(xlinkidTo,leftright2);
+
+    tObjId xJunctionID = GetJunctionId(pObj,nObj);
+
+    if(abs(nfromlane)>static_cast<int>(xvectorfrompath.size()))
+    {
+        std::cout<<"routetypecross_road_lane nfromlane error. nfrom lane: "<<nfromlane<<" lane total: "<<xvectorfrompath.size()<<std::endl;
+        return;
+    }
+
+    if(abs(ntolane)>static_cast<int>(xvectortopath.size()))
+    {
+        std::cout<<"routetypecross_road_lane ntolane error. nfrom lane: "<<ntolane<<" lane total: "<<xvectortopath.size()<<std::endl;
+        return;
+    }
+
+    std::vector<tObjId> xvectorconpath = GetConPath(xJunctionID);
+    tObjId nfromid = xvectorfrompath[static_cast<unsigned int>(abs(nfromlane))-1];
+    tObjId ntoid = xvectortopath[static_cast<unsigned int>(abs(ntolane))-1];
+    int nrtn = CreateDrivePath(xvectorconpath,nfromid,ntoid);
+
+    if(nrtn<0)
+    {
+        std::cout<<" Create route from road: "<<nfromroad<<" lane: "<<nfromlane<<" to road: "<<ntoroad<<" lane: "<<ntolane<<" FAIL. "<<std::endl;
+    }
+}
+
+void rd5route::route(int nfromroad, int nfromlane, int ntoroad, int ntolane)
+{
+    if(nfromroad != ntoroad)
+    {
+        routetypecross_road_lane(nfromroad,nfromlane,ntoroad,ntolane);
+    }
+    else
+    {
+        routetypeoneroad(nfromroad,nfromlane);
+    }
+}

src/test/testipgroad/rd5route.h

@@ -0,0 +1,47 @@
+#ifndef RD5ROUTE_H
+#define RD5ROUTE_H
+
+#include "road.h"
+#include "roadbuilder.h"
+
+#include <vector>
+
+class rd5route
+{
+private:
+    tRoad * mpRoad;
+
+    void routetypeoneroad(int nfromroad,int nfromlane);
+    void routetypecross_road_lane(int nfromroad,int nfromlane,int ntoroad,int ntolane);
+
+    void routetypecross_road(int fromroad, int nleftright,int toroad,int nleftright2);
+    void routetypecross();
+
+    tObjId GetObjByxodrRoadid(tObjId * pObjId,int nObj,int nordid);
+
+    tObjId GetJunctionId(tObjId * pObjId, int nObj);
+
+    tRoadLane GetLane(tObjId nLinkID,int nlane);
+
+    std::vector<tObjId> GetLanePath(tObjId nLinkID,int nLeftRight); //0 Left 1 right
+
+    std::vector<tObjId> GetConPath(tObjId nJunctionID);
+
+    void CreateDrivePath(std::vector<tObjId> xvectorConPath,std::vector<tObjId> xvectorFromPath,std::vector<tObjId> xvectorToPath);
+
+    int CreateDrivePath(std::vector<tObjId> xvectorConPath, tObjId nfrom, tObjId nto);
+
+    void CreateNewRouteName(char * strroutename);
+
+    void printchildobj(tObjId nObjId);
+
+private:
+    int mnRoute = 0;
+public:
+    rd5route(tRoad * pRoad);
+    void route();
+    void route(int nfromroad,int nfromlane,int ntoroad,int ntolane);
+
+};
+
+#endif // RD5ROUTE_H

src/test/testipgroad/road.h

@@ -0,0 +1,8325 @@
+/*
+** IPGRoad - Version 10.0
+** Copyright (C) IPG Automotive GmbH
+**               Bannwaldallee 60, D-76185 Karlsruhe, Germany
+**               Tel. +49 (0)721 98520-0, Fax +49 (0)721 98520-99
+*/
+
+#ifndef	ROAD_H__
+#define	ROAD_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** \file road.h
+ * This header file mainly contains the functions, structs, enumerations and
+ * macros that are used to evaluate a road scenario.
+ */ 
+      
+    
+/** \cond
+ */
+#if !defined(__GNUC__)
+# if !defined(__inline__)
+#  if defined(_MCCPPC)
+#   define __inline__		inline
+#  else
+#   define __inline__		/**< nothing
+				 */
+#  endif
+# endif
+#  if !defined(__attribute__)
+#   define __attribute__(x)	/**< nothing
+				 */
+#  endif
+#endif /* end Global.h */
+
+extern char RoadLibVersion[];
+extern char RoadLibArch[];
+extern char RoadLibCompileDate[];
+extern char RoadLibCompileTime[];
+extern char RoadLibCompileFlags[];
+extern char RoadLicSerialNo[16];
+extern char RoadLibVersionMajor;
+extern char RoadLibVersionMinor;
+extern int  RoadLicExpiration;
+
+typedef struct tRoad               tRoad;
+typedef struct tRoadEval           tRoadEval;
+typedef struct tRoadMarkerEval     tRoadMarkerEval;
+typedef struct tRoadRouteSpeedEval tRoadRouteSpeedEval;
+typedef struct tRoadTrackEval      tRoadTrackEval;
+typedef struct tRoadTrfSignEval    tRoadTrfSignEval;
+typedef struct tRoadLimEval        tRoadLimEval;
+typedef struct tRoadPath           tRoadPath;
+
+typedef struct tSpline   tSpline;
+typedef struct tSpline2D tSpline2D;
+typedef struct tSpline3D tSpline3D;
+
+/** \endcond
+ */
+/** \addtogroup ObjectsEdit
+ * @{
+ */
+
+/*** Object id ***/
+
+/** Error code: Invalid object id\n
+ *  Used to flag invalid object ids of type #tObjId.
+ */
+#define ROAD_InvalidObjId -1
+/** Datatype tObjId:\n
+ *  Object ids are of type <em>int</em>, but the negative numbers aren't used.
+ */
+#define tObjId int
+
+
+
+/** @} */
+/******************************************************************************/
+/* === General ============================================================== */
+/******************************************************************************/
+
+
+/** \addtogroup General
+ * @{
+ */
+/** Lateral references:\n
+ *  The lateral position of an object is given relative to a specific position
+ *  on the <em>Link</em>.
+ */
+typedef enum tRoadLatRef {
+    RLR_RMAX       = -32,/**< <b>-32</b> &nbsp; Maximum number of right
+                          * <em>Lanes</em> starting with the center line
+                          * (negative sign for right <em>Lanes</em>)
+    		 	 */
+    RLR_R29        = -31,/**< <b>-31</b> &nbsp; Middle of the thirtieth
+                          * <em>Lane</em> right of the <em>Reference line</em>
+		 	 */
+    RLR_R28        = -30,/**< <b>-30</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R27        = -29,/**< <b>-29</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R26        = -28,/**< <b>-28</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R25        = -27,/**< <b>-27</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R24        = -26,/**< <b>-26</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R23        = -25,/**< <b>-25</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R22        = -24,/**< <b>-24</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R21        = -23,/**< <b>-23</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R20        = -22,/**< <b>-22</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */       
+    RLR_R19        = -21,/**< <b>-21</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R18        = -20,/**< <b>-20</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R17        = -19,/**< <b>-19</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R16        = -18,/**< <b>-18</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R15        = -17,/**< <b>-17</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R14        = -16,/**< <b>-16</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R13        = -15,/**< <b>-15</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R12        = -14,/**< <b>-14</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R11        = -13,/**< <b>-13</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R10        = -12,/**< <b>-12</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R9         = -11,/**< <b>-11</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R8         = -10,/**< <b>-10</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R7         =  -9,/**< <b>-9</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R6         =  -8,/**< <b>-8</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R5         =  -7,/**< <b>-7</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R4         =  -6,/**< <b>-6</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R3         =  -5,/**< <b>-5</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R2         =  -4,/**< <b>-4</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R1         =  -3,/**< <b>-3</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_R0         =  -2,/**< <b>-2</b> &nbsp; Middle of the first <em>Lane</em>
+                          * right of the <em>Reference line</em>
+			 */
+    RLR_Right      =  -1,/**< <b>-1</b> &nbsp; Right <em>Road border</em>
+    			  */
+    RLR_Center     =   0,/**< <b>0</b> &nbsp; Center line: divides left and
+                          * right <em>Lanes</em>
+    			  */
+    RLR_Left       =   1,/**< <b>1</b> &nbsp; Left <em>Road border</em>
+			  */
+    RLR_L0,	    	/**< <b>2</b> &nbsp; Middle of the first <em>Lane</em>
+                         * left of the <em>Reference line</em>
+    			 */
+    RLR_L1,		/**< <b>3</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L2,		/**< <b>4</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L3,		/**< <b>5</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L4,		/**< <b>6</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L5,		/**< <b>7</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L6,		/**< <b>8</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L7,		/**< <b>9</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L8,		/**< <b>10</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L9,		/**< <b>11</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L10,	    	/**< <b>12</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L11,		/**< <b>13</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L12,		/**< <b>14</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L13,		/**< <b>15</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L14,		/**< <b>16</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L15,		/**< <b>17</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L16,		/**< <b>18</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L17,		/**< <b>19</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L18,		/**< <b>20</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L19,		/**< <b>21</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L20,	    	/**< <b>22</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L21,		/**< <b>23</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L22,		/**< <b>24</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L23,		/**< <b>25</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L24,		/**< <b>26</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L25,		/**< <b>27</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L26,		/**< <b>28</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L27,		/**< <b>29</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L28,		/**< <b>30</b> &emsp;&emsp;&emsp;&emsp;&emsp;. . .
+                         */
+    RLR_L29,		/**< <b>31</b> &nbsp; Middle of the thirtieth
+                         * <em>Lane</em> left of the <em>Reference line</em>
+			 */
+    RLR_LMAX,		/**< <b>32</b> &nbsp; Maximum number of left
+                         * <em>Lanes</em> starting with the center line
+                         * (positive sign for left <em>Lanes</em>)
+    			 */
+            
+    RLR_Pole0	   =  98,/**< <b>98</b> &nbsp; Lateral position relative to
+                         * <em>Pole 0</em> of a gantry
+    			 */    
+    RLR_Pole1	   =  99,/**< <b>99</b> &nbsp; Lateral position relative to
+                         * <em>Pole 1</em> of a gantry
+    			 */      
+    RLR_RefLine	   = 100,/**< <b>100</b> &nbsp; Lateral position relative to the
+                         * <em>Reference line</em>
+    			 */
+    RLR_PosUnknown = -99,/**< <b>-99</b> &nbsp; Unknown position
+                         * \deprecated See \ref RLR_RefUnknown.
+    			 */
+    RLR_RefUnknown = -99/**< <b>-99</b> &nbsp; Unknown lateral reference
+                         * \note Internal use only.
+    			 */
+} tRoadLatRef;
+
+/** Longitudinal references:\n
+ *  The longitudinal position of an object is given relative to a specific
+ *  position on the <em>Link</em>.
+ *  \note This enumeration is also used for <em>Reference lines</em>,
+ *   <em>Segments</em>, <em>Lane sections</em>, <em>Lanes</em> and
+ *   <em>Paths</em>. In these cases, #RLR_Node0 refers to the starting point
+ *   and #RLR_Node1 to the end point of the respective reference object, the
+ *   other two options are not allowed.
+ */
+typedef enum tRoadLonRef {
+    RLR_Node0 = 0,	/**< <b>0</b> &nbsp; Starting point <em>Node0</em> of
+                         * the <em>Link</em>
+			 */
+    RLR_Node1 = 1,	/**< <b>1</b> &nbsp; End point <em>Node1</em> of the
+                         * <em>Link</em>
+    			 */
+    RLR_JE0   = 2,	/**< <b>2</b> &nbsp; Entry of the <em>Junction</em> at
+                         * <em>Node0</em>
+    			 */
+    RLR_JE1   = 3	/**< <b>3</b> &nbsp; Entry of the <em>Junction</em> at
+                         * <em>Node1</em>
+    			 */
+} tRoadLonRef;
+
+/** Kinds of positions:\n
+ *  A distinction is made not only between on and off the road: It is also
+ *  differentiated whether the vehicle has left the entire road or is still on
+ *  the left or right <em>Road side</em>.
+ */
+typedef enum tRoadPosKind {
+    RPK_OffRoad = 0,	/**< <b>0</b> &nbsp; Off the road
+			 */
+    RPK_OnRoad,		/**< <b>1</b> &nbsp; On the road
+			 */
+    RPK_LeftMargin,	/**< <b>2</b> &nbsp; On the left road side
+			 */
+    RPK_RightMargin	/**< <b>3</b> &nbsp; On the right road side
+			 */
+} tRoadPosKind;
+
+
+/** @} */
+/******************************************************************************/
+/* +++ Initialization Functions +++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup Init
+ * @{
+ */
+/** Function to generate and initialize a new instance of the road
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *      <td> handle of the new road instance\n
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see RoadDelete() \see RoadSetApplication()
+ */
+tRoad *RoadNew(void);
+/** Function to delete an instance of the road
+ * \param[in] road Handle of the road instance
+ * \see RoadNew()
+ */
+void   RoadDelete(tRoad *road);
+
+/** IPG application:\n
+ *  The application IPGRoad is used with may have an influence on its behaviour.
+ *  Currently, the only effect occurs in the context of <em>Traffic lights</em>:
+ *  If the IPGRoad library is used with \ref RA_CarMaker "CarMaker", only the
+ *  <em>Traffic light controllers</em> actually referenced by a <em>Traffic
+ *  light</em> are considered by \ref RoadCtrlGetAllCtrlTL().
+ */
+typedef enum tRoadApplication {
+    RA_ScenarioEditor = 1,	/**< <b>1</b> &nbsp; Scenario Editor
+			         */
+    RA_CarMaker,	        /**< <b>2</b> &nbsp; CarMaker
+			         */
+    RA_Movie,	                /**< <b>3</b> &nbsp; Movie
+			         */
+    RA_Roadutil	                /**< <b>4</b> &nbsp; Roadutil
+			         */
+} tRoadApplication;
+
+/** Function to set the IPG application using the IPGRoad library
+ * \note The IPG application must be set directly after calling \ref RoadNew().
+ * \param[in] road Handle of the road instance
+ * \param[in] app IPG application
+ * \see RoadNew()
+ */
+void   RoadSetApplication(tRoad *road, tRoadApplication app);
+
+/** Function to get the prefix of the error messages of a road instance
+ * \param[in] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *      <td> prefix of the error messages\n
+ *  <tr><td> In case of failure: <td> ""
+ *  </table>
+ * \see RoadSetErrorMsgPrefix()
+ * \see ErrMsg
+ * \warning Do not free the returned pointer!
+ */
+char  *RoadGetErrorMsgPrefix(tRoad *road);
+/** Function to set the prefix for the error messages of a road instance\n
+ *  Default: "Road: "
+ * \param[in,out] road Handle of the road instance
+ * \param[in] errMsgPre Prefix for the error messages chosen
+ * \see RoadGetErrorMsgPrefix()
+ * \see ErrMsg
+ */
+void   RoadSetErrorMsgPrefix(tRoad *road, const char *errMsgPre);
+
+/** Function to set a list of search directories for the road data
+ * \param[in] dirs List of search directories: The first entry has the highest
+ *  priority, the last entry has to be the NULL pointer.
+ */
+void   RoadSetDataDirectories(const char **dirs);
+
+
+/** @} */
+/******************************************************************************/
+/* +++ Path Mode ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup PathMode
+ * @{
+ */
+/** Path mode:\n 
+ *  The <em>Path mode</em> determines the position and the direction of the
+ *  automatically generated <em>Lane paths</em> on the road.
+ */
+typedef enum tRoutePathMode {
+    RPM_Right   =  -1,	/**< <b>-1</b> &nbsp; Driving on the right-hand side of
+			 * the road (default)
+			 */
+    RPM_Center  =   0,	/**< <b>0</b> &nbsp; Driving in the center of the road,
+			 * e.g. for race courses
+			 */
+    RPM_Left    =   1,	/**< <b>1</b> &nbsp; Driving on the left-hand side of
+                         * the road
+			 */
+    RPM_Unknown = -99	/**< <b>-99</b> &nbsp; Unknown <em>Path mode</em>
+			 */
+} tRoutePathMode;
+
+/** Function to get the <em>Path mode</em> of an instance of the road
+ * \param[in] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> <em>Path mode</em> of the road instance
+ *  <tr><td> In case of failure: <td> \ref RPM_Unknown "unknown Path mode"
+ *  </table>
+ * \see RoadSetPathMode()
+ */
+int    RoadGetPathMode(tRoad *road);
+/** Function to set the <em>Path mode</em> of an instance of the road\n
+ *  Default: \ref RPM_Right "driving on the right-hand side of the road"
+ * \param[in,out] road Handle of the road instance
+ * \param[in] mode <em>Path mode</em> of the road instance
+ * \see RoadGetPathMode()
+ */
+void   RoadSetPathMode(tRoad *road, tRoutePathMode mode);
+
+
+/** @} */
+/******************************************************************************/
+/* +++ Country Settings  ++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup Country
+ * @{
+ */
+/** Function to get the country of the country-specific <em>Traffic signs</em>
+ * \param[in] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *      <td> short cut of the country:
+ *  <tr><td><td>
+ *  - AUT &harr; Austria
+ *  - CHN &harr; China
+ *  - DEU &harr; Germany
+ *  - FRA &harr; France
+ *  - GBR &harr; Great Britain
+ *  - JPN &harr; Japan
+ *  - KOR &harr; Korea
+ *  - USA &harr; United States of America
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see RoadSetCountry() \see RoadGetCountryFB()
+ */
+char*  RoadGetCountry  (tRoad *road);
+/** Function to set the country for the country-specific <em>Traffic signs</em>
+ *  \n Default: DEU
+ * \param[in,out] road Handle of the road instance
+ * \param[in] country Short cut of the country:
+ *  - AUT &harr; Austria
+ *  - CHN &harr; China
+ *  - DEU &harr; Germany
+ *  - FRA &harr; France
+ *  - GBR &harr; Great Britain
+ *  - JPN &harr; Japan
+ *  - KOR &harr; Korea
+ *  - USA &harr; United States of America
+ * \see RoadGetCountry() \see RoadSetCountryFB()
+ */
+void   RoadSetCountry  (tRoad *road, char *country);
+
+/** Function to get the country from which <em>Traffic signs</em> not existing
+ *  in the chosen \ref RoadGetCountry() "country" are taken
+ * \param[in] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> short cut of the fallback country:
+ *  <tr><td><td>
+ *  - AUT &harr; Austria
+ *  - CHN &harr; China
+ *  - DEU &harr; Germany
+ *  - FRA &harr; France
+ *  - GBR &harr; Great Britain
+ *  - JPN &harr; Japan
+ *  - KOR &harr; Korea
+ *  - USA &harr; United States of America
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see RoadSetCountryFB() \see RoadGetCountry()
+ */
+char*  RoadGetCountryFB(tRoad *road);
+/** Function to set the country from which <em>Traffic signs</em> not existing
+ *  in the chosen \ref RoadGetCountry() "country" are taken
+ * \param[in] road Handle of the road instance
+ * \param[in] country Short cut of the fallback country:
+ *  - AUT &harr; Austria
+ *  - CHN &harr; China
+ *  - DEU &harr; Germany
+ *  - FRA &harr; France
+ *  - GBR &harr; Great Britain
+ *  - JPN &harr; Japan
+ *  - KOR &harr; Korea
+ *  - USA &harr; United States of America
+ * \see RoadGetCountryFB() \see RoadSetCountry()
+ */
+void   RoadSetCountryFB(tRoad *road, char *country);
+
+
+/** @} */
+/******************************************************************************/
+/* +++ Road dependent GCS +++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup RDGCS
+ * @{
+ */
+/** GCS Projection Mode:\n
+ *  Used for the conversion of geocoded road data from WGS84 to the
+ *  IPGRoad internal (x,y,z)-coordinate system.
+ */
+typedef enum tGCSMode {
+    GCS_FlatEarth = 0,	/**< <b>0</b> &nbsp; Projection assuming the earth being
+                         * flat
+			 */
+    GCS_GaussKrueger,   /**< <b>1</b> &nbsp; Gauss-Krueger projection
+			 */
+    GCS_Unknown,	/**< <b>2</b> &nbsp; Unknown projection mode
+			 */
+    GCS_Count	        /**< <b>3</b> &nbsp; Number of projection modes
+                         * including #GCS_Unknown
+			 */
+} tGCSMode;
+
+/** Function to get the default GCS projection mode of a road instance
+ * \param[in] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> default GCS projection mode
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadSetGCSDefaultMode()
+ */
+tGCSMode RoadGetGCSDefaultMode(tRoad *road);
+/** Function to set the default GCS projection mode of a road instance\n
+ *  Default: <em>\ref GCS_FlatEarth "FlatEarth"</em>.
+ * \note This function must be called before the first <em>\ref SegmentsEdit
+ *  "Segment"</em> of type <em>File</em> containing (lat,long,elev)-data is
+ *  added.In case it is called after a call of RoadSetGCS() with a different
+ *  GCS projection mode, it returns <em>#ROAD_GCSError</em>.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] mode GCS projection mode chosen as default mode
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetGCSDefaultMode()
+ */
+int      RoadSetGCSDefaultMode(tRoad *road, tGCSMode mode);
+
+/** Function to get the GCS projection mode and the reference position of the
+ *  GCS module of a road instance in IPGRoad and WGS84 coordinates
+ * \param[in] road Handle of the road instance
+ * \param[out] mode GCS projection mode
+ * \param[out] xyz Reference position in the IPGRoad coordinate system (Fr0):
+ *  (x,y,z)-coordinates &nbsp; [m,m,m]
+ * \param[out] lle Reference position in WGS84:
+ *  (lat,lon,elev)-coordinates &nbsp; [deg, deg, m]
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadSetGCS() \see RoadDeleteGCS()
+ */
+int    RoadGetGCS   (tRoad *road, tGCSMode *mode, double xyz[3], double lle[3]);
+/** Function to initialize the GCS module of a road instance\n
+ *  This function sets the GCS projection mode and the reference position of the
+ *  GCS module of a road instance in IPGRoad and WGS84 coordinates. There is
+ *  only one global GCS module concerning the conversion of all positions from
+ *  xyz to lle or vice versa using the current valid GCS module settings.\n
+ * \note Resetting the GCS module is allowed, but it only causes the conversion
+ *  of files read in the future.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] mode GCS projection mode
+ * \param[in] xyz Reference position in the IPGRoad coordinate system (Fr0):
+ *  (x,y,z)-coordinates &nbsp; [m,m,m]
+ * \param[in] lle Reference position in WGS84:
+ *  (lat,lon,elev)-coordinates &nbsp; [deg, deg, m]
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetGCS() \see RoadDeleteGCS()
+ */
+int    RoadSetGCS   (tRoad *road, tGCSMode mode,  double xyz[3], double lle[3]);
+/** Function to delete the GCS module of a road instance
+ * \param[in] road Handle of the road instance
+ * \see RoadGetGCS() \see RoadSetGCS()
+ */
+void   RoadDeleteGCS(tRoad *road);
+
+/** Function to convert a given position in WGS84 to the corresponding position
+ *  in the IPGRoad coordinate system using the internal GCS module of a road
+ *  instance
+ * \param[in] road Handle of the road instance
+ * \param[in] lle Position in WGS84: 
+ *  (lat,lon,elev)-coordinates &nbsp; [deg,deg,m]
+ * \param[out] xyz Position in the IPGRoad coordinate system (Fr0):
+ *  (x,y,z)-coordinates &nbsp; [m,m,m]
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see Roadxyz2lle()
+ */
+int    Roadlle2xyz (tRoad *road, double lle[3], double xyz[3]);
+/** Function to convert a given position in the IPGRoad coordinate system to the
+ *  corresponding position in WGS84 using the internal GCS module of a road
+ *  instance
+ * \param[in] road Handle of the road instance
+ * \param[in] xyz Position in the IPGRoad coordinate system (Fr0):
+ *  (x,y,z)-coordinates &nbsp; [m,m,m]
+ * \param[out] lle Position in WGS84:
+ *  (lat,lon,elev)-coordinates &nbsp; [deg,deg,m]
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see Roadlle2xyz()
+ */
+int    Roadxyz2lle (tRoad *road, double xyz[3], double lle[3]);
+
+
+/** @} */
+/******************************************************************************/
+/* +++ Road Speed Types +++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup Speed
+ * @{
+ */
+/** Unlimited speed:\n
+ *  Macro used to indicate that there is no speed limit on a certain type of
+ *  road.
+ */
+#define ROAD_SPEED_UNLIMITED -1
+
+/** Road speed types:\n
+ *  Used to define general speed limits.
+ */
+typedef enum tRoadSpeedType {
+    RST_Urban,		/**< <b>0</b> &nbsp; Urban: default speed limit 50km/h
+			 */
+    RST_Countryroad,	/**< <b>1</b> &nbsp; Country: default speed limit
+                         *  100km/h
+			 */
+    RST_Motorway,	/**< <b>2</b> &nbsp; Motorway: default speed unlimited
+			 */
+    RST_Roundabout,	/**< <b>3</b> &nbsp; Roundabout: default speed limit
+                         * 30km/h
+    			 */
+    RST_Ramp,		/**< <b>4</b> &nbsp; Ramp: default speed limit 70km/h
+    			 */
+    RST_Dirttrack,	/**< <b>5</b> &nbsp; Dirt-track: default speed limit
+                         * 30km/h
+    			 */
+    RST_User,		/**< <b>6</b> &nbsp; User defined: default speed
+                         * unlimited
+    			 */
+    RST_Undefined,	/**< <b>7</b> &nbsp; Undefined: default speed unlimited
+    			 */
+    RST_Count		/**< <b>8</b> &nbsp; Number of <em>Road speed types</em>
+                         * including #RST_Undefined
+			 */
+} tRoadSpeedType;
+
+/** Function to get the unit of the speed limits for the different <em>Road
+ *  speed types</em>
+ * \param[in] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> unit of the speed limits for the <em>Road speed types</em>:
+ *  <em>kmh</em> and <em>mph</em>
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see RoadSetSpeedByTypeUnit()
+ */
+char  *RoadGetSpeedByTypeUnit(tRoad *road);
+/** Function to set the unit for the speed limits for the different <em>Road
+ *  speed types</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] unit Unit chosen for the speed limits for the <em>Road speed
+ *  types</em>: Supported units are <em>kmh</em> and <em>mph</em>.
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetSpeedByTypeUnit()
+ */
+int    RoadSetSpeedByTypeUnit(tRoad *road, const char *unit);
+
+/** Function to get the <em>Road speed type</em> of a <em>Link</em> or
+ *  <em>Junction</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the <em>Link</em> or <em>Junction</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> <em>Road speed type</em> of the <em>Link</em> or <em>Junction</em>
+ *  <tr><td><td> default: \ref RST_Undefined "Undefined"
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadSetSpeedType()
+ */
+tRoadSpeedType RoadGetSpeedType(tRoad *road, tObjId objId);
+/** Function to set the <em>Road speed type</em> of a <em>Link</em> or
+ *  <em>Junction</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the <em>Link</em> or <em>Junction</em>
+ * \param[in] rst <em>Road speed type</em> chosen for the <em>Link</em> or
+ *  <em>Junction</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetSpeedType()
+ */
+int            RoadSetSpeedType(tRoad *road, tObjId objId, tRoadSpeedType rst);
+
+/** Function to get the speed limit of a given <em>Road speed type</em> in the unit
+ *  chosen by the user
+ *  \note Internally the speed is saved in m/s.
+ * \param[in] road Handle of the road instance
+ * \param[in] rst <em>Road speed type</em> 
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> speed limit of the given <em>Road speed type</em>
+ *  <tr><td><td> special value: -1 &harr; no speed restriction
+ *  <tr><td> In case of failure: <td> 0.0
+ *  </table>
+ * \see RoadGetSpeedByTypeMS() \see RoadSetSpeedByType()
+ */
+double RoadGetSpeedByType  (tRoad *road, tRoadSpeedType rst);
+/** Function to get the speed limit of a given <em>Road speed type</em> in the
+ *  unit m/s
+ * \param[in] road Handle of the road instance
+ * \param[in] rst <em>Road speed type</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> speed limit of the given <em>Road speed type</em>
+ *  <tr><td><td> special value: -1.0 &harr; no speed restriction\n
+ *  <tr><td> In case of failure: <td> 0.0
+ *  </table>
+ * \see RoadGetSpeedByType() \see RoadSetSpeedByType()
+ */
+double RoadGetSpeedByTypeMS(tRoad *road, tRoadSpeedType rst);
+/** Function to set the speed limit of a given <em>Road speed type</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] rst <em>Road speed type</em>
+ * \param[in] speed Speed limit in the unit chosen by the user
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetSpeedByType() \see RoadGetSpeedByTypeMS()
+ */
+int    RoadSetSpeedByType  (tRoad *road, tRoadSpeedType rst, double speed);
+
+
+/** @} */
+/******************************************************************************/
+/* +++ Movie Settings +++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+/** \addtogroup Movie
+ * @{
+ */
+//! Movie settings
+/** Struct for the <em>Visualization parameters</em> of a road instance
+ */
+typedef struct tRoadMovie {
+    double ds;			/**< Step size in longitudinal direction in
+                                 *  meters
+				 */
+    double dt;			/**< Step size in lateral direction in meters
+				 */
+    double maxErr;		/**< Maximum viewing error: absolute value in
+                                 *  x- and y-direction
+				 */
+    double bWidth[2];		/**< Shown road side width left/right in meters
+				 */
+    double bSlope[2];		/**< Shown slope angle left/right in percentage
+				 */
+    char   *bgGeoFName;		/**< Name of the TclGeo file included in order
+                                 * to change the environment in the background
+				 */
+    char   *bgGeoOptions;	/**< Options for the TclGeo file
+				 */
+    char   *terrainFName;	/**< Name of the <em>.obj</em> file used for the
+                                 * representation of the landscape in IPGMovie
+				 */
+} tRoadMovie;
+
+/** Function to get the general movie settings of a road instance
+ * \param[in] road Handle of the road instance
+ * \param[out] movie Pointer to a struct for the movie settings
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadSetMovie() \see RoadGetLinkMovie()
+ */
+int    RoadGetMovie(tRoad *road, tRoadMovie *movie);
+/** Function to set the general movie settings of a road instance\n
+ *  Default: \ref tRoadMovie::ds "ds" = 0.2, \ref tRoadMovie::dt "dt" = 1.0,
+ *  \ref tRoadMovie::maxErr "maxErr" = 0.01, \ref tRoadMovie::bWidth "bWidth"
+ *   = [1.5,1.5], \ref tRoadMovie::bSlope "bSlope" = [1.0,1.0]
+ * \param[in,out] road Handle of the road instance
+ * \param[in] movie Struct with the movie settings
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetMovie() \see RoadSetLinkMovie()
+ */
+int    RoadSetMovie(tRoad *road, tRoadMovie movie);
+/** Function to get a <em>Link's</em> individual movie settings
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[out] movie Pointer to a struct for the <em>Link's</em> individual
+ *  movie settings
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadSetLinkMovie() \see RoadGetMovie()
+ */
+int    RoadGetLinkMovie(tRoad *road, tObjId lObjId, tRoadMovie *movie);
+/** Function to set a <em>Link's</em> individual movie settings
+ * \param[in,out] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[in] movie Struct with the movie settings
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetLinkMovie() \see RoadSetMovie()
+ */
+int    RoadSetLinkMovie(tRoad *road, tObjId lObjId, tRoadMovie movie);
+
+/** Movie object types:\n
+ *  There are different types of objects relevant for the movie, which are for
+ *  example used to set the standard texture for objects.
+ */
+typedef enum tRoadMovieObjectType {
+    RMOT_Road = 0,      /**< <b>0</b> &nbsp; Road surface area
+			 */
+    RMOT_Terrain,       /**< <b>1</b> &nbsp; Terrain
+			 */
+    RMOT_Max,           /**< <b>2</b> &nbsp; Number of movie object types
+                         */
+} tRoadMovieObjectType;
+
+/** Function to set the movie standard texture of all objects of a certain
+ *  movie object type\n
+ * \param[in,out] road Handle of the road instance
+ * \param[in] type Movie object type 
+ * \param[in] texture Name of the image file to use for the texture
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetMovieTexture() 
+ */
+int    RoadSetMovieTexture(tRoad *road, tRoadMovieObjectType type, 
+                                                           const char *texture);
+/** Function to get the movie standard texture of all objects of a certain
+ *  movie object type
+ * \note The user is responsible to free the memory allocated by this function.
+ * \param[in] road Handle of the road instance
+ * \param[in] type Movie object type 
+ * \param[in] texture Pointer to a string with the name of the image file to use
+ *  for the texture
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetMovieTexture() 
+ */
+int    RoadGetMovieTexture(tRoad *road, tRoadMovieObjectType type, 
+                                                                char **texture);
+
+
+/** @} */
+/******************************************************************************/
+/* +++ IO Functions +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup IO
+ * @{
+ */
+struct tInfos;
+
+/** Function to read the info data struct of a TestRun or an <em>.rd5</em>
+ *  InfoFile and store the information in a road handle
+ * \param[out] road Handle of the road instance
+ * \param[in] inf Pointer to the info data struct 
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadWriteInf() \see RoadReadInfoFile()
+ */
+int    RoadReadInf     (tRoad *road, struct tInfos *inf);
+/** Function to read a TestRun or an <em>.rd5</em> InfoFile and store the
+ *  information in a road handle
+ * \param[out] road Handle of the road instance
+ * \param[in] infoFName Name of the InfoFile
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadWriteFile() \see RoadReadInf()
+ */
+int    RoadReadInfoFile(tRoad *road, char *infoFName);
+
+/** Function to write the information about a road instance to an info data 
+ *  struct of a TestRun or an <em>.rd5</em> InfoFile
+ * \param[in,out] road Handle of the road instance
+ * \param[out] inf Pointer to the info data struct 
+ * \param[in] prefix Prefix "Road" in case the information about the road is
+ * written to the info data struct of a TestRun InfoFile
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadReadInf() \see RoadWriteFile()
+ */
+int    RoadWriteInf (tRoad *road, struct tInfos *inf, const char *prefix);
+/** Function to write the information about a road instance to a TestRun or an
+ *  <em>.rd5</em> InfoFile
+ * \param[in,out] road Handle of the road instance
+ * \param[in] fName Name of the InfoFile the information should be written to
+ * \param[in] prefix Prefix "Road" in case the information about the road is
+ * written to a TestRun InfoFile
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadReadInfoFile() \see RoadWriteInf()
+ */
+int    RoadWriteFile(tRoad *road, char *fName,        const char *prefix);
+
+/** Function to import an OpenDRIVE<sup>&reg;</sup> road definition to IPGRoad
+ * \note Because of the differences between the internal structures of IPGRoad
+ * and OpenDRIVE<sup>&reg;</sup>, there are certain limitations to the import,
+ * which are described in the CarMaker User's Guide.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] fname Name of the <em>.xodr</em> file containing the road
+ * definition
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadReadInfoFile() \see RoadOpenDRIVELane2Path()
+ */
+int    RoadReadOpenDRIVE     (tRoad *road, const char *fname);
+/** Function to determine the object id of the corresponding <em>Path</em> and
+ * the offset on this <em>Path</em> from the identifier of a certain road in an
+ * OpenDRIVE<sup>&reg;</sup> road definition, the offset on this road and the
+ * lane identifier\n
+ * \note In OpenDRIVE<sup>&reg;</sup> junctions also consist of roads with
+ * lanes. These lanes are imported to IPGRoad as <em>Connector paths</em>.
+ * \param[in] road Handle of the road instance
+ * \param[in] odrRoadId Identifier of the OpenDRIVE<sup>&reg;</sup> road
+ * \param[in] odrLaneId OpenDRIVE<sup>&reg;</sup> lane identifier
+ * \param[in] odrS Offset in s-direction on the OpenDRIVE<sup>&reg;</sup> road
+ * \param[out] pathObjId Object id of the corresponding <em>Path</em>
+ * \param[out] sPathRef Offset in s-direction on the <em>Path</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadReadOpenDRIVE()
+ */
+int    RoadOpenDRIVELane2Path(tRoad *road, int odrRoadId, int odrLaneId,
+                              double odrS, tObjId *pathObjId, double *sPathRef);
+
+
+
+/** @} */
+/******************************************************************************/
+/* --- Compatibility to Road 4.5 -------------------------------------------- */
+/******************************************************************************/
+
+/** \addtogroup Format45
+ * @{
+ */
+/** Function to check whether the road definition uses the former road 4.5
+ *  format
+ * \param[in] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> flag indicating the format of the road definition:
+ *  <tr><td><td>
+ * - 0 &harr; current road format
+ * - 1 &harr; former road 4.5 format
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadSetDefIs45()
+ */
+int    RoadDefIs45       (tRoad *road);
+/** Function to set the variable indicating the format of the road definition
+ * \param[in,out] road Handle of the road instance
+ * \param[in] is45 Parameter determining the format of the road definition:
+ * - 0 &harr; current road format
+ * - 1 &harr; former road 4.5 format
+ * \see RoadDefIs45()
+ */
+void   RoadSetDefIs45    (tRoad *road, int is45);
+
+/** Function to read an info data struct of the former road 4.5 format and
+ *  store the information in a road handle
+ * \param[out] road Handle of the road instance
+ * \param[out] inf Pointer to an info data struct 
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table> 
+ */
+int    RoadReadDefIs45Inf(tRoad *road, struct tInfos *inf);
+
+/** Function to read a road definition in the former road 4.5 format given in
+ *  form of the "Road."-block in a TestRun InfoFile or the digitized road
+ *  definition in an extra file and store the information in a road handle
+ * \param[out] road Handle of the road instance
+ * \param[in] FName Name of the TestRun InfoFile
+ * \param[in,out] DigFileName Name of the file containing the digitized road
+ *  definition
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadReadTxt()
+ */
+int    RoadReadFile(tRoad *road, const char *FName, const char *DigFileName);
+/** Function to read a road definition in the former road 4.5 format given in
+ *  form of a string containing a "Road."-block or a digitized road definition
+ *  in an extra file and store the information in a road handle
+ * \param[out] road Handle of the road instance
+ * \param[in] Txt String with the "Road."-block
+ * \param[in,out] DigFileName Name of the file containing the digitized road
+ *  definition
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadReadFile()
+ */
+int    RoadReadTxt (tRoad *road, char *const *Txt,  const char *DigFileName);
+
+
+
+/** @} */
+/******************************************************************************/
+/* +++ General functions for editing a road instance ++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup GeneralEdit
+ * @{
+ */
+/** Function to set a road instance invalid
+ * \param[in,out] road Handle of the road instance
+ * \see RoadIsValid()
+ */
+void   RoadSetInvalid(tRoad *road);
+/** Function to check whether a road instance is valid or not
+ * \param[in] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> flag indicating whether the road instance is valid:
+ *  <tr><td><td>
+ * - 0 &harr; invalid
+ * - 1 &harr; valid
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadSetInvalid()
+ */
+int    RoadIsValid   (tRoad *road);
+/** Function to check whether a road instance has a <em>Link</em> or
+ *  <em>Junction</em>
+ * \param[in] road Handle of the road instance
+ * \return Flag indicating whether the road instance is empty:
+ * - 0 &harr; road instance is not empty
+ * - 1 &harr; road instance is empty
+ */
+int    RoadIsEmpty   (tRoad *road);
+
+
+/** Function to set the running mode for a given road instance\n
+ * \param[in,out] road Handle of the road instance
+ * \param[in] mode Running mode
+ * \deprecated Formerly applied in order to enable the use of the IPGRoad 7.0
+ * Library as IPGRoad 6.0 Library.
+ */
+void   RoadSetRunningMode(tRoad *road, int mode);
+
+
+/** Function to check whether grade and slope are given in the unit m/m or
+ *  percentage
+ * \param[in] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> flag indicating the unit of grade and slope:
+ *  <tr><td><td>
+ *  - 0 &harr; m/m
+ *  - 1 &harr; percentage
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGradeAndSlopeInPercentage(tRoad *road);
+
+
+
+/** @} */
+/******************************************************************************/
+/* === Eval ================================================================= */
+/******************************************************************************/
+
+
+/******************************************************************************/
+/* +++ General ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+/** \addtogroup GeneralEval
+ * @{
+ */
+//! Evaluation statistics
+/** Struct for the storage of the numbers of evaluation and global search calls
+ * \see RoadEvalGetStat()
+ */
+typedef struct tRoadEvalStat {
+    int nEvalCalls;		/**< Total number of evaluation calls
+				 */
+    int nGlobalSearchCalls;	/**< Total number of global search calls:\n
+                                 * In case the evaluation in a local area of the
+                                 * road doesn't work, the coordinates of a
+                                 * position are searched globally resulting in
+                                 * an increased expense.
+				 */
+} tRoadEvalStat;
+
+/** Function to get the statistics of the evaluation and global search calls
+ * \param[in] re Road evaluation handle
+ * \param[out] stat Pointer to a struct for the evaluation statistics
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadEvalGetStat(tRoadEval *re, tRoadEvalStat *stat);
+
+
+/*** Bump mask options ***/
+
+/** No bumps:\n
+ *  Flag indicating that no <em>Bumps</em> should be considered.
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_BUMP_NONE		   (0)
+/** All bumps:\n
+ *  Flag indicating that all <em>Bumps</em> should be considered.
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_BUMP_ALL		(1<<0)
+/** Friction patches:\n
+ *  Flag indicating that <em>Bumps</em> of type <em>Friction</em> should be
+ *  considered.
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_BUMP_FRIC		(1<<1)
+/** Beams:\n
+ *  Flag indicating that <em>Bumps</em> of type <em>Beam</em> should be
+ *  considered.
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_BUMP_BEAM		(1<<2)
+/** Waves:\n
+ *  Flag indicating that <em>Bumps</em> of type <em>Wave</em> should be
+ *  considered.
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_BUMP_WAVE		(1<<3)
+/** Cones:\n
+ *  Flag indicating that <em>Bumps</em> of type <em>Cone</em> should be
+ *  considered.
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_BUMP_CONE		(1<<4)
+/** CRG-files:\n
+ *  Flag indicating that <em>Bumps</em> of type <em>CRG</em> should be
+ *  considered.
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_BUMP_CRG		(1<<5)
+/** Meshes:\n
+ *  Flag indicating that <em>Bumps</em> of type <em>Mesh</em> should be
+ *  considered.
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_BUMP_MESH	        (1<<6)
+/** Lateral profiles:\n
+ *  Flag indicating that <em>Bumps</em> of type <em>Lateral profile</em> should
+ *  be considered.
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_BUMP_LATP		(1<<7)
+/** Raised profiles:\n
+ *  Flag indicating that <em>Bumps</em> of type <em>Raised profile</em> should
+ *  be considered.
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_BUMP_RAISEDP	(1<<8)
+
+/** No Elevation profiles:\n
+ * Flag indicating that <em>Elevation profiles</em> should not be considered.
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_ZP_NO_ELEV        (1<<10)
+/** No Slope profiles:\n
+ *  Flag indicating that <em>Slope profiles</em> should not be considered.
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_ZP_NO_SLOPE       (1<<11)
+/** No Camber profiles:\n
+ *  Flag indicating that <em>Camber profiles</em> should not be considered.
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_ZP_NO_CAMBER      (1<<12)
+/** No Junctions:\n
+ *  Flag indicating that <em>Junctions</em> should not be explicitly considered
+ *  when evaluating a <em>Link</em>.
+ *  \note Only valid for the evaluation of a <em>Link</em> by
+ *  \ref RoadLinkGeoEval() using \ref tRoadLinkIn::useST "local coordinates": \n
+ *  For the calculation of \ref tRoadLinkOut::xyz "z" and \ref tRoadLinkOut::nuv
+ *  "nuv" at positions on the <em>Junction</em> at in the <em>Link's</em> start
+ *  or end the height profile of the junction area is not considered.
+ *  \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_LINK_NO_JUNCTION  (1<<13)
+
+
+/*** Output mask options ***/
+
+/** Minimum output:\n
+ *  Flag indicating minimum output: Output of the calculated position in the
+ *  global and in the local coordinate system.
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_OT_MIN		   (0)
+/** Normal unit vector:\n
+ *  Flag indicating the output of the road surface normal unit vector.
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_OT_NUV		(1<<0)
+/** Longitudinal unit vector:\n
+ *  Flag indicating the output of the unit vector in s-direction.
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_OT_SUV		(1<<1)
+/** Lateral unit vector:\n
+ *  Flag indicating the output of the unit vector in t-direction.
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_OT_TUV		(1<<2)
+/** Longitudinal gradient:\n
+ *  Flag indicating the output of the gradient of the z-coordinate in
+ *  s-direction (dz/ds).
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_OT_GRADE		(1<<3)
+/** Lateral gradient:\n
+ *  Flag indicating the output of the gradient of the z-coordinate in
+ *  t-direction (dz/dt).
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_OT_SLOPE		(1<<4)
+/** Lateral curvature:\n
+ *  Flag indicating the output of the curvature of the curve in the (x,y)-plane.
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_OT_CURVE_XY	(1<<5)
+/** Longitudinal z-curvature:\n
+ *  Flag indicating the output of the curvature of the curve in the (s,z)-plane
+ *  (change of \ref ROAD_OT_GRADE "grade" in s-direction).
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_OT_CURVE_Z		(1<<6)
+/** Friction:\n
+ *  Flag indicating the output of the friction coefficient.
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_OT_FRIC		(1<<7)
+/** Width:\n
+ *  Flag indicating the output of the width between the position and the
+ *  left/right border of the road.
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_OT_WIDTH           (1<<8)
+/** Lanes:\n
+ *  Flag indicating the output of the <em>Lanes</em>.
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_OT_LANES           (1<<9)
+/** Extended output:\n
+ *  Flag indicating the output of all members of the extended struct.
+ * \see RoadNewRoadEval() \see RoadResetMaskRoadEval()
+ */
+#define ROAD_OT_EXT	       (1<<10)
+
+
+/** Function to generate and initialize a new road evaluation handle for a road
+ *  instance
+ * \param[in] road Handle of the road instance
+ * \param[in] bumpMask Mask indicating which types of the <em>Bumps</em> and
+ *  <em>Height profiles</em> should be considered by the new road evaluation
+ *  handle:\n
+ *  The binary system is used to generate combinations of the bump mask options
+ *  #ROAD_BUMP_FRIC, #ROAD_BUMP_BEAM, #ROAD_BUMP_WAVE, #ROAD_BUMP_CONE, 
+ *  #ROAD_BUMP_CRG, #ROAD_BUMP_MESH  and #ROAD_BUMP_LATP (special macros:
+ *  #ROAD_BUMP_NONE/#ROAD_BUMP_ALL), as well as #ROAD_ZP_NO_ELEV,
+ *  #ROAD_ZP_NO_SLOPE and #ROAD_ZP_NO_CAMBER.
+ * \param[in] outMask Mask indicating which quantities are considered for the
+ *  output of the new road evaluation handle:\n
+ *  The binary system is used to generate combinations of the output mask
+ *  options #ROAD_OT_MIN, #ROAD_OT_NUV, #ROAD_OT_SUV, #ROAD_OT_TUV,
+ *  #ROAD_OT_GRADE, #ROAD_OT_SLOPE, #ROAD_OT_CURVE_XY, #ROAD_OT_CURVE_Z,
+ *  #ROAD_OT_FRIC, #ROAD_OT_WIDTH, #ROAD_OT_LANES and #ROAD_OT_EXT.
+ * \param[in] module Internal use only: Set this parameter to NULL.
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> new road evaluation handle
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see RoadDeleteRoadEval() \see RoadResetRoadEval()
+ * \see RoadResetMaskRoadEval() \see RoadSetRoadEvalObjId
+ * \see RoadGetRoadEvalObjId
+ */
+tRoadEval *RoadNewRoadEval      (tRoad *road,
+			         int bumpMask, int outMask, const char *module);
+/** Function to delete a road evaluation handle
+ * \param[in] re Road evaluation handle that should be deleted
+ * \see RoadNewRoadEval() \see RoadResetRoadEval() \see RoadResetMaskRoadEval()
+ * \see RoadSetRoadEvalObjId \see RoadGetRoadEvalObjId
+ */
+void       RoadDeleteRoadEval   (tRoadEval *re);
+/** Function to reset a road evaluation handle:\n
+ *  The handle of the road instance is linked to the road evaluation handle.
+ * \param[in,out] re Road evaluation handle
+ * \param[in] road Handle of the road instance
+ * \see RoadNewRoadEval() \see RoadDeleteRoadEval() \see RoadResetMaskRoadEval()
+ * \see RoadSetRoadEvalObjId \see RoadGetRoadEvalObjId
+ */
+void       RoadResetRoadEval    (tRoadEval *re, tRoad *road);
+/** Function to reset a road evaluation handle:\n
+ *  Besides the handle of the road instance, the bump mask and the output mask
+ *  are linked to the road evaluation handle.
+ * \param[in,out] re Road evaluation handle
+ * \param[in] road Handle of the road instance
+ * \param[in] bumpMask Mask indicating which types of the <em>Bumps</em> and
+ *  <em>Height profiles</em> should be considered by the new road evaluation
+ *  handle:\n
+ *  The binary system is used to generate combinations of the bump mask options
+ *  #ROAD_BUMP_FRIC, #ROAD_BUMP_BEAM, #ROAD_BUMP_WAVE, #ROAD_BUMP_CONE, 
+ *  #ROAD_BUMP_CRG, #ROAD_BUMP_MESH  and #ROAD_BUMP_LATP (special macros:
+ *  #ROAD_BUMP_NONE/#ROAD_BUMP_ALL), as well as #ROAD_ZP_NO_ELEV,
+ *  #ROAD_ZP_NO_SLOPE and #ROAD_ZP_NO_CAMBER.
+ * \param[in] outMask Mask indicating which quantities are considered for the
+ *  output of the new road evaluation handle:\n
+ *  The binary system is used to generate combinations of the output mask
+ *  options #ROAD_OT_MIN, #ROAD_OT_NUV, #ROAD_OT_SUV, #ROAD_OT_TUV,
+ *  #ROAD_OT_GRADE, #ROAD_OT_SLOPE, #ROAD_OT_CURVE_XY, #ROAD_OT_CURVE_Z,
+ *  #ROAD_OT_FRIC, #ROAD_OT_WIDTH, #ROAD_OT_LANES and #ROAD_OT_EXT.
+ * \see RoadNewRoadEval() \see RoadDeleteRoadEval() \see RoadResetRoadEval()
+ * \see RoadSetRoadEvalObjId \see RoadGetRoadEvalObjId
+ */
+void       RoadResetMaskRoadEval(tRoadEval *re, tRoad *road,
+				 int bumpMask, int outMask);
+/** Function to limit the road evaluation to a certain <em>Link</em> or
+ *  <em>Junction</em>
+ * \param[in,out] re Road evaluation handle
+ * \param[in] objId Object id of the <em>Link</em> or <em>Junction</em> the
+ * evaluation should be limited to
+ * \see RoadGetRoadEvalObjId \see RoadNewRoadEval() \see RoadDeleteRoadEval()
+ * \see RoadResetRoadEval() \see RoadResetMaskRoadEval() \see RoadLinkGeoEval()
+ * \see RoadRefLineGeoEval() \see RoadGeoEvalExt()
+ */
+void       RoadSetRoadEvalObjId (tRoadEval *re, tObjId objId);
+/** Function to get the object Id of the <em>Link</em> or <em>Junction</em> to
+ *  which the road evaluation is limited
+ * \param[in] re Road evaluation handle
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> Object Id of the <em>Link</em> or <em>Junction</em> the evaluation is
+ *  limited to
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadSetRoadEvalObjId \see RoadNewRoadEval() \see RoadDeleteRoadEval()
+ * \see RoadResetRoadEval() \see RoadResetMaskRoadEval() \see RoadLinkGeoEval()
+ * \see RoadRefLineGeoEval() \see RoadGeoEvalExt()
+ */
+tObjId     RoadGetRoadEvalObjId (tRoadEval *re);
+//! Global evaluation: output
+/** Struct for the output parameters of RoadGlobalEval()
+ */
+typedef struct tRoadGlobalOut {
+    double	 xyz[3];	/**< Calculated position in the global IPGRoad
+				 * coordinate system (Fr0)
+				 */
+    double	 nuv[3];	/**< Road surface normal unit vector at
+                                 * \ref tRoadGlobalOut::xyz "xyz"
+				 */
+    tRoadPosKind onRoad;	/**< Kind of position:\n
+				 * On or (in some extent) off the road
+				 */
+    int		 onJunction;	/**< Flag indicating whether (x,y) is on a
+                                 *  <em>Link</em> or on a <em>Junction</em>:\n
+				 * - 0 &harr; <em>Link</em>
+				 * - 1 &harr; <em>Junction</em>
+				 */
+    int		 id;		/**< Identifier of the <em>Link</em> or
+                                 * <em>Junction</em>\n Special value:
+				 * -1 &harr; (x,y) is not on the road
+				 */
+} tRoadGlobalOut;
+
+/** Function to evaluate a given position without using a road evaluation
+ * handle
+ * \param[in] road Handle of the road instance
+ * \param[in] xyz Position in the global IPGRoad coordinate system (Fr0) with an
+ * estimated z-coordinate
+ * \param[out] out Pointer to a struct for the output parameters
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGeoEval()
+ */
+int    RoadGlobalEval(tRoad *road, double xyz[3], tRoadGlobalOut *out);
+
+//! General evaluation: input
+/** Struct for the input parameters of RoadGeoEval()
+ */
+typedef struct tRoadGeoIn {
+    double xyz[3];		/**< Given position in the global IPGRoad
+				 * coordinate system (Fr0)\note
+				 * An estimation of the z-coordinate is given
+				 * in order to simplify the evaluation (if no
+				 * reasonable estimation is known, initialize
+				 * the z-coordinate with zero).
+				 */
+} tRoadGeoIn;
+//! General evaluation: output
+/** Struct for the output parameters of RoadGeoEval()
+ */
+typedef struct tRoadGeoOut {
+    double	 xyz[3];	/**< Calculated position in the global IPGRoad
+				 * coordinate system (Fr0)
+				 */
+    double	 nuv[3];	/**< Road surface normal unit vector at
+                                 * \ref tRoadGeoOut::xyz "xyz"
+				 */
+    tRoadPosKind onRoad;	/**< Kind of position:\n
+				 * On or (in some extent) off the road
+				 */
+    int		 onJunction;	/**< Flag indicating whether (x,y) is on a
+                                 *  <em>Link</em> or on a <em>Junction</em>:\n
+				 * - 0 &harr; on a <em>Link</em>
+				 * - 1 &harr; on a <em>Junction</em>
+				 */
+    double	 fric;		/**< Friction coefficient at
+				 * \ref tRoadGeoOut::xyz "xyz"
+				 */
+} tRoadGeoOut;
+
+/** Function to evaluate a given position using a road evaluation handle
+ * \param[in] re Evaluation handle of the road instance
+ * \param[in] errMsgPre Prefix for the error messages
+ * \param[in] in Pointer to a struct for the input parameters
+ * \param[out] out Pointer to a struct for the output parameters
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \note It is recommended to use the extended version RoadGeoEvalExt() of this
+ * function.
+ * \see RoadGlobalEval()
+ */
+int    RoadGeoEval(tRoadEval *re, const char *errMsgPre, const tRoadGeoIn *in,
+							    tRoadGeoOut   *out);
+
+//! General evaluation: input (extended version)
+/** Struct for the input parameters of RoadGeoEvalExt()
+ */
+typedef struct tRoadGeoInExt {
+    double xyz[3];	/**< Given position in the global IPGRoad coordinate
+			 * system (Fr0)\note
+			 * An estimation of the z-coordinate is given in order
+			 * to simplify the evaluation (if no reasonable
+			 * estimation is known, initialize the z-coordinate with
+			 * zero).
+			 */
+    double suv[2];	/**< Longitudinal unit vector at
+                         * \ref tRoadGeoInExt::xyz "xyz":\n
+			 * Unit vector in viewing direction
+			 * \note This vector is used to determine whether the
+                         * results should be calculated in (default in case this
+                         * vector is zero) or counter
+                         * \ref tRoadGeoOutExt::inLinkDir "link direction".
+			 */
+} tRoadGeoInExt;
+//! General evaluation: output (extended version)
+/** Struct for the input parameters of RoadGeoEvalExt()
+ */
+typedef struct tRoadGeoOutExt {
+    double	 xyz[3];	/**< Calculated position in the global IPGRoad
+				 * coordinate system (Fr0)
+				 */
+    double	 st[2];		/**< Calculated position in the <em>Link's</em>
+				 * local coordinate system
+				 * \note Only valid if \ref tRoadGeoOutExt::xyz
+                                 * "xyz" is not \ref tRoadGeoOutExt::onJunction
+                                 * "on a Junction".
+				 */
+    double	 nuv[3];	/**< Road surface normal unit vector at
+                                 * \ref tRoadGeoOutExt::xyz "xyz"
+				 */
+    double	 suv[3];	/**< Longitudinal unit vector at
+                                 * \ref tRoadGeoOutExt::xyz "xyz":\n
+				 * Unit vector \ref tRoadGeoOutExt::inLinkDir
+                                 * "in or counter" s-direction of the
+                                 * <em>Link</em>
+				 */
+    double	 tuv[3];	/**< Lateral unit vector at
+                                 * \ref tRoadGeoOutExt::xyz "xyz":\n
+				 * Unit vector \ref tRoadGeoOutExt::inLinkDir
+                                 * "in or counter" t-direction of the
+				 * <em>Link</em>
+				 */
+    double	 fric;		/**< Friction coefficient at
+                                 * \ref tRoadGeoOutExt::xyz "xyz"
+				 */
+    tRoadPosKind onRoad;	/**< Kind of position:\n
+				 * On or (in some extent) off the road
+				 */ 
+    tObjId	 laneObjId;	/**< Object id of the current <em>Lane</em>
+				 */
+    tObjId	 linkObjId;	/**< - <b>xyz</b> on <em>Link</em>:
+                                 * object id of the current <em>Link</em>
+                                 *   - <b>xyz</b> on <em>Junction</em>:
+                                 * object id of the last <em>Link</em>
+				 */
+    tObjId	 juncObjId;	/**< - <b>xyz</b> on <em>Link</em>:
+                                 * object id of the last <em>Junction</em>
+                                 *   - <b>xyz</b> on <em>Junction</em>:
+                                 * object id of the current <em>Junction</em>
+				 */
+/**
+ * \name
+ * The following parameters need the #ROAD_OT_EXT flag to be set.
+ * @{
+ */
+/* --- the following parameters need the ROAD_OT_EXT flag to be set --------- */
+    double	 nextJuncDist;	/**< Distance to the next junction entry on the
+                                 * <em>Link</em>
+				 * \note Only valid if \ref tRoadGeoOutExt::xyz
+                                 * "xyz" is not \ref tRoadGeoOutExt::onJunction
+                                 * "on a Junction".
+				 */
+    double	 lastJuncDist;	/**< Distance to the last junction entry on the
+                                 * <em>Link</em>
+				 * \note Only valid if \ref tRoadGeoOutExt::xyz
+                                 * "xyz" is not \ref tRoadGeoOutExt::onJunction
+                                 * "on a Junction".
+				 */
+    double	 t2Ref;		/**< Distance to the <em>Reference line</em>
+				 * \note This parameter corresponds to \ref
+                                 *  tRoadGeoOutExt::st "st[1]", but the sign is
+                                 *  changed in case the output is calculated
+                                 *  counter \ref tRoadGeoOutExt::inLinkDir
+                                 *  "link direction". 
+				 * \note Only valid if \ref tRoadGeoOutExt::xyz
+                                 * "xyz" is not \ref tRoadGeoOutExt::onJunction
+                                 * "on a Junction".
+				 */
+    int		 onJunction;	/**< Flag indicating whether (x,y) is on a
+                                 * <em>Link</em> or on a <em>Junction</em>:\n
+				 * - 0 &harr; on a <em>Link</em>
+				 * - 1 &harr; on a <em>Junction</em>
+				 */ 
+    int		 inLinkDir;  	/**< Flag indicating whether the output is
+                                 * calculated in link direction (default) or
+                                 * counter link direction:\n
+				 * - 0 &harr; counter link direction
+				 * - 1 &harr; in link direction
+                                 *
+                                 * \note This is determined by the \ref
+                                 * tRoadGeoInExt::suv "longitudinal unit vector"
+                                 * of the input struct indicating the
+                                 * viewing direction.
+				 */  
+    tObjId	 nextJuncObjId;	/**< Object id of the next <em>Junction</em>
+				 * \note Set to #ROAD_InvalidObjId if \ref
+                                 *  tRoadGeoOutExt::xyz "xyz" is \ref
+                                 * tRoadGeoOutExt::onJunction "on a Junction".
+				 */
+/** @} */
+    
+} tRoadGeoOutExt;
+
+/** Function to evaluate a given position using a road evaluation handle:
+ *  extended version
+ * \param[in] re Evaluation handle of the road instance
+ * \param[in] errMsgPre Prefix for the error messages
+ * \param[in] in Pointer to a struct for the input parameters
+ * \param[out] out Pointer to a struct for the output parameters
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGlobalEval()
+ */
+int    RoadGeoEvalExt(tRoadEval *re, const char *errMsgPre, 
+				  const tRoadGeoInExt *in, tRoadGeoOutExt *out);
+
+
+/** Input type:\n
+ * Type of input used for RoadPathGeoEval(), RoadRouteEval() and
+ * RoadRouteEvalExt()
+ */
+typedef enum tRoadInType {
+    RIT_ST,	/**< <b>0</b> &nbsp; Input type: The (s,t)-coordinates of the
+                 * <em>Path</em> or <em>Route</em> must be given.\n
+		 * This option is useful for the calculation of a <em>Driving
+                 * plan</em> along a predefined <em>Route</em>
+                 * (IPGDriver/IPGTraffic).
+		 */
+    RIT_XY_S,	/**< <b>1</b> &nbsp; Input type: The (x,y)-coordinates of the
+                 * <em>Path</em> or <em>Route</em> must be given. Moreover, an
+                 * estimation for the s-coordinate is recommended.\note
+                 * If no reasonable estimation can be given, the z-coordinate
+                 * should be initialized as zero.
+		 */
+    RIT_XY_SZ,	/**< <b>2</b> &nbsp; Input type: The (x,y)-coordinates of the
+                 * <em>Path</em> or <em>Route</em> and an estimated z-coordinate
+                 * must be given.
+		 */
+} tRoadInType;
+
+
+/** @} */
+/******************************************************************************/
+/* +++ Objects ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup ObjectsEval
+ * @{
+ */
+/** Function to get the internal identifier of an object from its object id
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the object
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> internal identifier of the object\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadJuncIdGetJuncObjId() \see RoadJuncObjIdGetJuncId()
+ * \see RoadLinkIdGetLinkObjId() \see RoadLinkObjIdGetLinkId()
+ * \see RoadRouteIdGetRouteObjId() \see RoadRouteObjIdGetRouteId()
+ */
+int    RoadObjIdGetInternalId(tRoad *road, tObjId objId);
+/** Function to get the largest object id of a road instance
+ * \param[in] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> largest object id of the road instance
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ */
+tObjId RoadGetMaxUsedObjectId(tRoad *road);
+
+
+/** Types of road objects
+ * \see RoadGetObjectType() \see RoadGetParentObjectType()
+ */
+typedef enum tRoadObjectType {
+/* --- General object types --------------------------------------- */
+    ROT_Invalid         =   -1,		/**< <b>-1</b> &nbsp;
+                                         * Invalid road object type
+					 */
+            
+/* --- Object types relating to junctions ------------------------- */
+    ROT_Junction        =   20,		/**< <b>20</b> &nbsp;
+                                         * \ref tRoadJunction "Junction"
+					 */
+    ROT_JunctionArm,			/**< <b>21</b> &nbsp;
+                                         * \ref tRoadJunctionArm "Junction arm"
+					 */
+            
+/* --- Object types relating to links ----------------------------- */
+    ROT_Link            =   40,		/**< <b>40</b> &nbsp;
+                                         * \ref tRoadLink "Link"
+					 */
+
+/* --- Object types relating to xy-Reference lines ---------------- */
+    ROT_RefLine         =   50,		/**< <b>50</b> &nbsp;
+                                         * \ref tRoadRefLine "Reference line"
+					 */
+    ROT_Segment         =   60,		/**< <b>60</b> &nbsp;
+                                         * \ref tRoadSegment "Segment"
+					 */
+
+/* --- Object types relating to z profiles ------------------------ */
+    ROT_LonZPElevation  =   80, 	/**< <b>80</b> &nbsp; \ref tRoadZP
+                                        * "Longitudinal elevation profile"
+					*/
+    ROT_LatZPSlope,     		/**< <b>81</b> &nbsp; \ref tRoadZP
+                                         * "Lateral slope profile"
+					 */
+    ROT_LatZPCamber,    		/**< <b>82</b> &nbsp; \ref tRoadZP
+                                         * "Lateral camber profile"
+					 */
+    ROT_Node1DProfile   =   85,         /**< <b>85</b> &nbsp; \ref
+                                         * tRoadNode1DProfile
+                                         * "One dimensional node profile"
+					 */
+    ROT_Node1D          =   90, 	/**< <b>90</b> &nbsp; \ref tRoadNode1D
+                                         * "One-dimensional nodes",
+					 * used for lane width, connector path
+                                         * width, lateral offset, height
+                                         * profiles and general one-dimensional
+                                         * node profiles.
+					 */
+    ROT_Node2D          =   91, 	/**< <b>91</b> &nbsp; \ref tRoadNode2D
+                                         * "Two-dimensional nodes",
+                                         * used for the point lists
+                                         * defining <em>Segments</em>.
+					 */
+    ROT_PathNode        =   93, 	/**< <b>93</b> &nbsp;
+                                         * \ref tRoadPathSTNode "User path node"
+					 */       
+    ROT_AlignedRefPoint =   95, 	/**< <b>95</b> &nbsp; \ref LanesEdit
+                                         * "Aligned reference point"
+					 */
+
+/* --- Object types relating to Lanes ----------------------------- */
+    ROT_LaneSection     =  100,		/**< <b>100</b> &nbsp;
+                                         * \ref tRoadLaneSection "Lane section"
+					 */
+    ROT_Lane,				/**< <b>101</b> &nbsp;
+                                         * \ref tRoadLane "Lane"
+					 */
+    ROT_LateralOffset,			/**< <b>102</b> &nbsp; \ref
+                                         * tRoadLateralOffset "Lateral offset"
+					 */
+
+/* --- Object types relating to Bumps ----------------------------- */
+    ROT_BBeam           =  200,		/**< <b>200</b> &nbsp; \ref
+                                         * tRoadBumpBeam "Bump of type Beam"
+					 */
+    ROT_BCone,				/**< <b>201</b> &nbsp; \ref
+                                         * tRoadBumpCone "Bump of type Cone"
+					 */
+    ROT_BFric,				/**< <b>202</b> &nbsp; \ref
+                                         * tRoadBumpFric "Bump of type Friction"
+					 */
+    ROT_BMesh,				/**< <b>203</b> &nbsp; \ref
+                                         * tRoadBumpMesh "Bump of type Mesh"
+					 */
+    ROT_BLatP,				/**< <b>204</b> &nbsp; \ref 
+                                         * tRoadBumpLatProfile
+                                         * "Bump of type Lateral profile"
+					 */
+    ROT_BRaisedP,			/**< <b>205</b> &nbsp; \ref
+                                         * tRoadBumpRaisedProfile
+                                         * "Bump of type Raised profile"
+					 */
+    ROT_BWave,				/**< <b>206</b> &nbsp; \ref
+                                         * tRoadBumpWave "Bump of type Wave"
+					 */
+
+/* --- Object types relating to markers ---------------------------  */
+/* --- Driver instructions --- */
+    ROT_MDrvSpeed       =  400,		/**< <b>400</b> &nbsp;
+                                         * \ref tRoadMarkerDrvSpeed 
+                                         * "Marker of type Driver speed"
+					 */
+    ROT_MDrvStop,			/**< <b>401</b> &nbsp;
+                                         * \ref tRoadMarkerDrvStop 
+                                         * "Marker of type Driver stop"
+					 */
+    ROT_MDrvPylon,			/**< <b>402</b> &nbsp;
+                                         * \ref tRoadMarkerDrvPylon 
+                                         * "Marker of type Pylon alley"
+					 */
+
+/* --- DrivMan instructions --- */
+    ROT_MDrivManCmd     =  420,		/**< <b>420</b> &nbsp;
+                                         * \ref tRoadMarkerDrivManCmd 
+                                         * "Marker of type DrivMan command"
+					 */
+    ROT_MDrivManJump,			/**< <b>421</b> &nbsp;
+                                         * \ref tRoadMarkerDrivManJump
+                                         * "Marker of type DrivMan jump"
+					 */
+    ROT_MDrivManTrigger,		/**< <b>422</b> &nbsp;
+                                         * \ref tRoadMarkerDrivManTrigger 
+                                         * "Marker of type Trigger point"
+					 */
+
+/* --- Environment --- */
+    ROT_MEnvWind        =  440,		/**< <b>440</b> &nbsp;
+                                         * \ref tRoadMarkerEnvWind 
+                                         * "Marker of type Wind"
+					 */
+
+/* --- User-defined --- */
+    ROT_MUserDefined    =  460,		/**< <b>460</b> &nbsp;
+                                         * \ref tRoadMarkerUser
+                                         * "Marker of type User-defined"
+					 */
+
+/* --- Object types relating to detectable objects ---------------- */
+/* --- Road furniture --- */
+    ROT_Mount           =  600,		/**< <b>600</b> &nbsp;
+                                         * \ref tRoadMount "Mount"
+					 */
+    ROT_TrfSign,			/**< <b>601</b> &nbsp;
+                                         * \ref tRoadTrafficSign "Traffic sign"
+					 */
+    ROT_TrfLight,			/**< <b>602</b> &nbsp; \ref
+                                         * tRoadTrafficLight "Traffic light"
+					 */
+    ROT_TrfBarrier,			/**< <b>603</b> &nbsp; \ref
+                                         * tRoadTrafficBarrier "Traffic barrier"
+					 */
+    ROT_RoadMarking,			/**< <b>604</b> &nbsp;
+                                         * \ref tRoadRoadMarking "Road marking"
+					 */
+    ROT_RoadPainting,			/**< <b>605</b> &nbsp; \ref
+                                         * tRoadRoadPainting "Road painting"
+					 */
+    ROT_GuidePost,			/**< <b>606</b> &nbsp;
+                                         * \ref tRoadGuidePost "Guide posts"
+					 */
+    ROT_Bridge,				/**< <b>607</b> &nbsp;
+                                         * \ref tRoadBridge "Bridge"
+					 */
+    ROT_Tunnel,				/**< <b>608</b> &nbsp;
+                                         * \ref tRoadTunnel "Tunnel"
+					 */
+    
+    ROT_CTL             =  650, 	/**< <b>650</b> &nbsp;
+                                         * \ref RoadAdoptParamsForCTL
+                                         * "Connected trajectory list":\n
+                                         * In order to achieve a continuous road
+                                         * marking, adjacent <em>Road markings
+                                         * </em> can be merged into one common
+                                         * object of type <em>Connected
+                                         * trajectory list</em>.
+					 */
+    ROT_Ctrl_TrfLight   =  670,         /**< <b>670</b> &nbsp;
+                                         * \ref tRoadCtrlTrfLight
+                                         * "Traffic light controller"
+					 */
+            
+/* --- Scenery --- */
+    ROT_TreeStrip       =  700,		/**< <b>700</b> &nbsp;
+                                         * \ref tRoadTreeStrip "Tree strip"
+					 */
+    ROT_SignPlate,			/**< <b>701</b> &nbsp;
+                                         * \ref tRoadSignPlate "Sign plate"
+					 */
+    ROT_Geometry,   			/**< <b>702</b> &nbsp;
+                                         * \ref tRoadGeoObject "Geometry object"
+					 */
+    ROT_RoadSurface,			/**< <b>703</b> &nbsp;
+                                         * \ref tRoadRoadSurface "Road surface"
+					 */
+            
+/* --- Route and Path --------------------------------------------- */
+    ROT_Route           = 1000,		/**< <b>1000</b> &nbsp;
+                                         * \ref RoadAddRoute "Route"
+					 */
+    ROT_DrvPath,			/**< <b>1001</b> &nbsp; \ref
+                                         * RoadRouteAddDrvPath "Driving path"
+					 */
+    ROT_LanePath,			/**< <b>1002</b> &nbsp;
+                                         * \ref tRoadLanePath "Lane path"
+					 */
+    ROT_UserPath,			/**< <b>1003</b> &nbsp;
+                                         * \ref tRoadUserPath "User path"
+					 */
+    ROT_ConPath,			/**< <b>1004</b> &nbsp;
+                                         * \ref tRoadConPath "Connector path"
+					 */
+
+/* --- Terrain ---------------------------------------------------- */
+    ROT_Area            = 1100,		/**< <b>1100</b> &nbsp;
+                                         * \ref tRoadArea "Area"
+					 */
+    ROT_Polygon		= 1200,		/**< <b>1200</b> &nbsp;
+                                         * \ref tRoadPolygon "Polygon"
+					 */
+
+/* --- Background image ------------------------------------------- */
+    ROT_BgImage         = 1300,		/**< <b>1300</b> &nbsp; Background image
+                                         * displayed in the Scenario Editor
+					 */
+
+} tRoadObjectType;
+
+/** Function to get the type of a given object
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the object
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> \ref tRoadObjectType "Object type" of the given object
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetParentObjectType() \see RoadGetObjectUserType()
+ */
+int    RoadGetObjectType(tRoad *road, tObjId objId);
+
+/** Function to get the identifier for the user-defined type of a given object
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the object
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> identifier for the user-defined type of the given object
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetObjectType() \see RoadSetObjectUserType()
+ */
+int    RoadGetObjectUserType(tRoad *road, tObjId objId);
+/** Function to set the identifier for the user-defined type of a given object
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the object
+ * \param[in] userType Identifier for the user-defined type
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetObjectUserType()
+ */
+int    RoadSetObjectUserType(tRoad *road, tObjId objId, int userType);
+
+/** Function to convert a given position in an object's local coordinate system
+ *  to the corresponding position in the (x,y)-plane of the global IPGRoad
+ *  coordinate system (Fr0)
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the given object
+ * \param[in] pos Position in the object's local coordinate system:
+ *  start &harr; 0...1 &harr; end
+ * \param[out] xy Position in the (x,y)-plane of the global IPGRoad coordinate
+ *  system
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetObjectXY(tRoad *road, tObjId objId, double pos, double xy[2]);
+
+/** Function to get the type of a given object's parent object
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the given object
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> \ref tRoadObjectType "Object Type" of the object's parent object
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetParentObjectId() \see RoadGetObjectType()
+ */
+int    RoadGetParentObjectType(tRoad *road, tObjId objId);
+/** Function to get the object id and the type of a given object's parent
+ * object
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the given object
+ * \param[out] parentType Object type of the object's parent object
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the parent object
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadGetParentObjectType()
+ */
+tObjId RoadGetParentObjectId  (tRoad *road, tObjId objId,
+                                                   tRoadObjectType *parentType);
+
+/** Function to get the tag of a given object\n
+ * The tag of an object is an internally not evaluated string that can be used
+ * to add further information about an object.
+ * \warning It is not allowed to free the memory of the return value!
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the object
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> tag of the object\n
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see RoadSetObjectTag()
+ */
+char  *RoadGetObjectTag(tRoad *road, tObjId objId);
+/** Function to set the tag of a given object\n
+ *  The tag of an object is an internally not evaluated string that can be used
+ *  to add further information about an object.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the object
+ * \param[in] tag Tag for the object
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetObjectTag()
+ */
+int    RoadSetObjectTag(tRoad *road, tObjId objId, char *tag);
+
+//! Bounding box
+/** Struct for the extents of a road instance in x-, y- and z-direction
+ */
+typedef struct tRoadBBox {
+    double min[3];	/**< Minimum x/y/z-coordinate of the road instance
+			 */
+    double max[3];	/**< Maximum x/y/z-coordinate of the road instance
+			 */
+} tRoadBBox;
+
+
+/** Function to get the information about a given <em>Link</em> or
+ *  <em>Junction</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the <em>Link</em> or <em>Junction</em>
+ * \param[in] type Type of the object: <em>\ref ROT_Link "Link"</em> or <em>\ref
+ *  ROT_Junction "Junction"</em>
+ * \param[out] info Pointer to the struct for the information about the
+ *  <em>\ref tRoadLinkInfo "Link"</em> or <em>\ref tRoadJunctionInfo
+ *  "Junction"</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadObjIdGetInfo(tRoad *road, tObjId objId, tRoadObjectType type,
+                                                                    void *info);
+
+/** Function to get the direction vector of a given object at a certain offset
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the object that can be either a <em>Link</em>,
+ *  <em>Reference line</em>, <em>Route</em> or <em>Path</em>
+ * \param[in] s Offset in s-direction on the object
+ * \param[out] suv Normalized direction vector in the (x,y)-plane of the 
+ *  associated <em>Reference line</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadObjIdGetRefLineSUV (tRoad *road, tObjId objId, double s, 
+                                                                 double suv[2]);
+
+/** @} */
+/******************************************************************************/
+/* +++ Junctions ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup JunctionsEval
+ * @{
+ */
+/** Maximum number of <em>Junction arms</em>:\n
+ * For each <em>Junction</em> at most sixteen arms can be defined.
+ */
+#define ROAD_JUNC_MAX_ARMS 16
+
+/** Types of <em>Junctions</em>
+ * \see RoadJunctionGetType()
+ */
+ typedef enum tRoadJunctionType {
+     RJT_Simple = 0,	/**< <b>0</b> &nbsp; Standard junction
+			 */
+     RJT_Extended,	/**< <b>1</b> &nbsp; Extended junction
+			 */
+     RJT_Virtual,	/**< <b>2</b> &nbsp; Virtual junction
+			 */
+     RJT_Direct,	/**< <b>3</b> &nbsp; Direct junction
+			 */
+     RJT_Unknown,	/**< <b>4</b> &nbsp; Unknown junction type
+			 */
+     RJT_Count	        /**< <b>5</b> &nbsp; Number of junction types
+                         * including #RJT_Unknown
+			 */
+ } tRoadJunctionType;
+
+/** Function to get the type of a <em>Junction</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] jObjId Object id of the <em>Junction</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> \ref tRoadJunctionType "type" of the <em>Junction</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+tRoadJunctionType RoadJunctionGetType(tRoad *road, tObjId jObjId);
+
+/** Function to get the object id of a <em>Junction</em> from its internal
+ *  identifier
+ * \param[in] road Handle of the road instance
+ * \param[in] juncId Identifier of the <em>Junction</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the <em>Junction</em>
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadJuncObjIdGetJuncId()
+ */
+tObjId RoadJuncIdGetJuncObjId(tRoad *road, int juncId);
+/** Function to get the internal identifier of a <em>Junction</em> from its
+ *  object id
+ * \param[in] road Handle of the road instance
+ * \param[in] jObjId Object id of the <em>Junction</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> identifier of the <em>Junction</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadObjIdGetInternalId() \see RoadJuncIdGetJuncObjId()
+ */
+int    RoadJuncObjIdGetJuncId(tRoad *road, tObjId jObjId);
+
+//! Junction information
+/** Struct for the information about a <em>Junction</em>
+ * \deprecated Do not use with RoadObjIdGetInfo().\n
+ * Use #tRoadJunctionInfo() for the information about a <em>Junction</em>
+ */
+typedef struct tRoadJuncInfo {
+    tObjId objId;                       /**< Object id of the <em>Junction</em>
+                                         */ 
+    int    nArm;                        /**< Number of arms of the
+                                         *  <em>Junction</em>
+                                         */
+    int    jArmObjId[ROAD_JUNC_MAX_ARMS];/**< Array containing the object ids of
+                                         * the <em>Junction arms</em> of the
+                                         * <em>Junction</em>
+                                         */
+    int    lObjId[ROAD_JUNC_MAX_ARMS];	/**< Array containing the object ids of
+                                         * the <em>Links</em> the <em>Junction
+                                         * arms</em> are connected to\n
+                                         * Special value: \ref ROAD_InvalidObjId
+                                         * &harr; unconnected <em>Junction
+                                         * arm</em>
+                                         */
+    double angle[ROAD_JUNC_MAX_ARMS];	/**< Array containing the directions of
+                                         * the <em>Junction arm</em> in degrees
+                                         * (counter-clockwise with respect to
+                                         * the z-axis)
+                                         */
+} tRoadJuncInfo;
+//! Junction information
+/** Struct for the object information about a <em>Junction</em>
+ * \see RoadObjIdGetInfo()
+ */
+typedef struct tRoadJunctionInfo {
+    tObjId objId;		/**< Object id of the <em>Junction</em> or
+                                 * <em>Junction arm</em>
+                                 * (\ref tRoadJunctionInfo::arm "arm::objId")
+				 */
+    int    nArm;		/**< Number of arms of the <em>Junction</em>
+				 */
+    tObjId mObjId0;             /**< Object id of the first main arm of the
+                                 * <em>Junction</em>
+                                 */
+    tObjId mObjId1;     	/**< Object id of the second main arm of the
+                                 * <em>Junction</em>
+				 */
+    double knot[3];		/**< Position of the junction knot in the
+                                 * (x,y,z)-coordinates of the global IPGRoad
+                                 * coordinate system (Fr0)
+				 */
+    struct {
+	tObjId objId;		/**<
+				 */
+	tObjId lObjId;          /**< Object id of the <em>Link</em> connected
+                                 * to the <em>Junction arm</em> \n
+                                 * Special value: \ref ROAD_InvalidObjId &harr;
+                                 * unconnected  <em>Junction arm</em>
+				 */
+	double lenOnLink;       /**< Length on the connected link which is used
+                                 * by the <em>Junction arm</em> in meters
+                                 */
+    } arm[ROAD_JUNC_MAX_ARMS];	/**< Array containing the structs for the
+                                 * information about the <em>Junction arms</em>
+				 */
+} tRoadJunctionInfo;
+
+/** Function to get the information about a given <em>Junction</em>\n
+ * The <em>Junction</em> is identified by its internal identifier.
+ * \param[in] road Handle of the road instance
+ * \param[in] jObjId Object id of the <em>Junction</em>
+ * \param[out] jInfo Pointer to a struct for the information about the
+ *  <em>Junction</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \deprecated Use RoadObjIdGetInfo() to get the information about a
+ *  <em>Junction</em>.
+ */
+int    RoadGetJuncInfo (tRoad *road, int jObjId, tRoadJuncInfo *jInfo);
+
+
+/** Function to evaluate a <em>Junction arm</em>\n
+ * For the calculation of the surface of a <em>Junction arm</em> it is
+ * differentiated according to whether it is a main arm or not.
+ * \note Only valid for the <em>Junction arms</em> of \ref RJT_Simple
+ *  "standard" <em>Junctions</em>.
+ * \param[in] road Handle of the road instance
+ * \param[in] jArmObjId Object id of the <em>Junction arm</em>
+ * \param[in] uv Position on the <em>Junction arm</em> given in the coordinate
+ *  system of its BPM \n
+ *  Whereas the two main arms share a BPM that is rather straight, all further
+ *  arms have their own rather distorted BPM.
+ * \param[out] xyz Calculated position in the global IPGRoad coordinate system
+ *  (Fr0)
+ * \param[out] nuv Road surface normal unit vector at <b>xyz</b>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadJunctionArmGeoEval(tRoad *road, tObjId jArmObjId, double uv[2], 
+						  double xyz[3], double nuv[3]);
+
+/** Function to activate an algorithm to optimize the shape of the junction area
+ * \note Only valid for \ref RJT_Simple "standard" <em>Junctions</em>.
+ * \param[in] road Handle of the road instance
+ * \param[in] flag Switch to activate/deactivate the algorithm:
+ * - 0 &harr; deactivate
+ * - 1 &harr; activate
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+void   RoadSetAutomaticJunctionAreaAdaption  (tRoad *road, int flag);
+
+/** Function to fit the height map of a <em>Junction</em> to a given set of
+ * points
+ * \param[in,out] road Handle of the road instance
+ * \param[in] jObjId Object id of the <em>Junction</em>
+ * \param[in] n Number of points
+ * \param[in] xyz Sample points the height map should be fitted to
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadJunctionFitHM2Samples             (tRoad *road, tObjId jObjId,
+                                                  const int n, double xyz[][3]);
+/** Function to fit the height map of a <em>Junction</em> to the connected
+ * link nodes
+ * \param[in,out] road Handle of the road instance
+ * \param[in] jObjId Object id of the <em>Junction</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadJunctionFitSurf2ConnectedLinkNodes(tRoad *road, tObjId jObjId);
+
+
+/** @} */
+/******************************************************************************/
+/* +++ Links ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup LinksEval
+ * @{
+ */
+/** Function to get the object id of a <em>Link</em> from its internal
+ *  identifier
+ * \param[in] road Handle of the road instance
+ * \param[in] linkId Identifier of the <em>Link</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the <em>Link</em>
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadLinkObjIdGetLinkId()
+ */
+tObjId RoadLinkIdGetLinkObjId(tRoad *road, int linkId);
+/** Function to get the internal identifier of a <em>Link</em> from its object
+ *  id
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> identifier of the <em>Link</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadObjIdGetInternalId() \see RoadLinkIdGetLinkObjId()
+ */
+int    RoadLinkObjIdGetLinkId(tRoad *road, tObjId lObjId);
+
+/** Function to get the object id of the <em>Reference line</em> of a
+ *  <em>Link</em>\n
+ * The <em>Link</em> is identified by its internal identifier.
+ * \param[in] road Handle of the road instance
+ * \param[in] linkId Identifier of the <em>Link</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the <em>Link's</em> <em>Reference line</em>
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ *  \deprecated Use RoadGetLinkRefLineObjId() to get the object id of a
+ *  <em>Link's Reference line</em>.
+ */
+tObjId RoadLinkIdGetRefLineObjId(tRoad *road, int linkId);
+
+//! Link information
+/** Struct for the object information about a <em>Link</em>
+ * \see RoadObjIdGetInfo()
+ */
+typedef struct tRoadLinkInfo {
+    tObjId	    objId;	/**< Object id of the <em>Link</em>
+				 */
+    tObjId          jObjId0;	/**< Object id of the <em>Junction</em> to
+                                 * which the <em>Link's</em> starting point
+                                 * <em>Node0</em> is connected\n
+                                 * Special value: \ref ROAD_InvalidObjId
+                                 * &nbsp;&harr;&nbsp; <em>Node0</em> is not
+                                 * connected to a <em>Junction</em>.
+                                 */
+    tObjId          jObjId1;	/**< Object id of the <em>Junction</em> to
+                                 * which the <em>Link's</em> end point
+                                 * <em>Node1</em> is connected\n
+                                 * Special value: \ref ROAD_InvalidObjId
+                                 * &nbsp;&harr;&nbsp; <em>Node1</em> is not
+                                 * connected to a <em>Junction</em>.
+                                 */
+    tObjId          jArmObjId0;	/**< Object id of the <em>Junction arm</em> to
+                                 * which the <em>Link's</em> starting point
+                                 * <em>Node0</em> is connected\n
+                                 * Special value: \ref ROAD_InvalidObjId
+                                 * &nbsp;&harr;&nbsp; <em>Node0</em> is not
+                                 * connected to a <em>Junction</em>.
+				 */
+    tObjId          jArmObjId1;	/**< Object id of the <em>Junction arm</em> to
+                                 * which the <em>Link's</em> end point
+                                 * <em>Node1</em> is connected\n
+                                 * Special value: \ref ROAD_InvalidObjId
+                                 * &nbsp;&harr;&nbsp; <em>Node1</em> is not
+                                 * connected to a <em>Junction</em>.
+				 */
+    tRoadSpeedType  rst;        /**< Road speed type of the <em>Link</em>
+				 */
+    double	    len;        /**< Length of the <em>Link</em> (distance
+                                 * between <em>Node0</em> and <em>Node1</em>)
+                                 * in meters 
+				 */
+} tRoadLinkInfo;
+
+/** Function to get the information about a given <em>Link</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[out] lInfo Pointer to a struct for the information about the
+ *  <em>Link</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \deprecated Use RoadObjIdGetInfo() to get the information about a
+ *  <em>Link</em>.
+ */
+int    RoadGetLinkInfo (tRoad *road, tObjId lObjId, tRoadLinkInfo *lInfo);
+
+//! Link evaluation: input
+/** Struct for the input parameters of RoadLinkGeoEval()
+ */
+typedef struct tRoadLinkIn {
+    tObjId      lObjId;		/**< Object id  of the <em>Link</em>
+				 */
+    int         useST;	 	/**< Flag indicating whether the global IPGRoad
+                                 * or the local coordinate system of the
+                                 * <em>Link</em> is used:
+				 * - 0 &harr; use \ref tRoadLinkIn::xyz "xyz"
+				 * - 1 &harr; use \ref tRoadLinkIn::st "st"
+				 */
+    double      st[2];		/**< Given position in the local coordinate
+                                 * system of the <em>Link</em>
+				 */
+    double      xyz[3];		/**< Given position in the global IPGRoad
+				 * coordinate system (Fr0)\note
+				 * An estimation of the z-coordinate is given
+				 * in order to simplify the evaluation (if no
+				 * reasonable estimation is known, initialize
+				 * the z-coordinate with zero).
+				 */
+} tRoadLinkIn;
+//! Link evaluation: output
+/** Struct for the output parameters of RoadLinkGeoEval()
+ */
+typedef struct tRoadLinkOut {
+    double	 xyz[3];	/**< Calculated position in the global IPGRoad
+				 * coordinate system (Fr0)
+				 */
+    double	 nuv[3];	/**< Road surface normal unit vector at \ref
+                                 * tRoadLinkOut::xyz "xyz"
+				 */
+    double	 suv[3];	/**< Longitudinal unit vector at \ref
+                                 *  tRoadLinkOut::xyz "xyz":\n
+				 * Unit vector in s-direction of the
+                                 * <em>Link</em>
+				 */
+    double	 tuv[3];	/**< Lateral unit vector at \ref
+                                 * tRoadLinkOut::xyz "xyz":\n
+				 * Unit vector in t-direction of the
+				 * <em>Link</em>
+				 */ 
+    double	 st[2];		/**< Calculated position in the local coordinate
+                                 * system of the <em>Link</em>
+				 */
+    double	 curveXY;	/**< Curvature of the curve in the (x,y)-plane
+                                 * at \ref tRoadLinkOut::xyz "xyz"
+				 */
+    double	 width[2];	/**< Distance between the left/right road border
+                                 * and the <em>Link's</em> <em>Center line</em>
+                                 * at \ref tRoadLinkOut::st "s" in meters
+				 */
+    tRoadPosKind onRoad;	/**< Kind of position:\n
+				 * On or (in some extent) off the road
+				 */
+/**
+ * \name
+ * The following output variables do not consider <em>Bumps</em>.
+ * @{
+ */
+/* --- The following outputs do not consider Bumps ---------------- */
+    double	 grade;		/**< Longitudinal gradient at \ref
+                                 * tRoadLinkOut::xyz "xyz":\n
+                                 * Gradient of the z-coordinate in s-direction
+                                 * of the <em>Link</em>
+                                 * \note <em>Bumps</em> are not considered.
+				 */
+    double	 slope;		/**< Lateral gradient at \ref
+                                 * tRoadLinkOut::xyz "xyz":\n
+                                 * Gradient of the z-coordinate in t-direction
+                                 * of the <em>Link</em>
+                                 * \note <em>Bumps</em> are not considered.
+				 */
+    double	 curveZ;	/**< Longitudinal z-curvature at \ref
+                                 * tRoadLinkOut::xyz "xyz":\n
+                                 * Curvature of the curve in the (s,z)-plane
+                                 * (change of \ref tRoadLinkOut::grade "grade"
+                                 * in s-direction of the <em>Link</em>).
+                                 * \note <em>Bumps</em> are not considered.
+				 */
+/** @} */
+} tRoadLinkOut;
+
+/** Function to evaluate a <em>Link</em>
+ * \param[in,out] re Evaluation handle of the road instance
+ * \param[in] errMsgPre Prefix for the error messages
+ * \param[in] in Pointer to a struct for the input parameters
+ * \param[out] out Pointer to a struct for the output parameters
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadLinkGeoEval(tRoadEval *re, const char *errMsgPre,
+				      const tRoadLinkIn *in, tRoadLinkOut *out);
+
+
+/** @} */
+/******************************************************************************/
+/* --- Lane sections -------------------------------------------------------- */
+/******************************************************************************/
+
+
+/******************************************************************************/
+/*     Lanes                                                                  */
+/******************************************************************************/
+
+
+/** \addtogroup LanesEval
+ * @{
+ */
+/** Maximum number of <em>Lanes</em>:\n
+ * At most thirty <em>Lanes</em> can be defined on each side of the
+ * <em>Reference line</em>.
+ */
+#define ROAD_MAX_LANES 30
+
+
+/** Lane types:\n
+ *  Used to describe the attributes of different <em>Lanes</em>
+ */
+typedef enum tRoadLaneType {
+    RLT_Road	      =  0,	/**< <b>0</b> &nbsp; Driving lane:\n
+				 * Legally drivable lane
+				 */
+    RLT_Border	      =  4,	/**< <b>4</b> &nbsp; Road border:\n
+				 * Drivable left or right extension of the road
+				 */
+    RLT_Margin	      =  5,	/**< <b>5</b> &nbsp; Road side:\n
+				 * Defines a zone left or right of the road
+                                 * which actually does not belong to the road,
+                                 * but still delivers reasonable
+                                 * (x,y)-coordinates values for requests
+				 * e.g. for <em>Road side Bumps</em>
+                                 * \note Only the outermost <em>Lane</em> can be
+                                 *  of this type! 
+				 */
+    RLT_RoadSide      =  5,	/**< <b>5</b> &nbsp; Road side: see
+				 * \ref tRoadLaneType::RLT_Margin "RLT_Margin"
+				 */
+    RLT_Bicycle	      = 10,	/**< <b>10</b> &nbsp; Bicycle lane
+				 */
+    RLT_Pedestrian    = 11,	/**< <b>11</b> &nbsp; Pedestrian path
+				 */
+    RLT_TrafficIsland = 12,	/**< <b>12</b> &nbsp; Traffic island
+				 */
+    RLT_ParkingArea   = 13,	/**< <b>13</b> &nbsp; Parking area
+				 */
+    RLT_Bus           = 14,	/**< <b>14</b> &nbsp; Bus lane
+				 */
+    RLT_HOV           = 15,	/**< <b>15</b> &nbsp; High-occupancy vehicle
+                                 * lane
+				 */
+    RLT_Emergency     = 16,	/**< <b>16</b> &nbsp; Emergency lane
+				 */
+    RLT_Vegetation    = 20,	/**< <b>20</b> &nbsp; Vegetation lane
+				 */ 
+    RLT_Undefined     = 99	/**< <b>99</b> &nbsp; Undefined lane type
+				 */
+} tRoadLaneType;
+
+//! Lane evaluation: input
+/** Struct for the input parameters of RoadLaneEval() and RoadLaneEvalExt()
+ */
+typedef struct tRoadLaneIn {
+    double xyz[3];		/**< Given position in the global IPGRoad
+				 * coordinate system (Fr0)\note
+				 * An estimation of the z-coordinate is given
+				 * in order to simplify the evaluation(if no
+				 * reasonable estimation is known, initialize
+				 * the z-coordinate with zero).
+				 */
+    double suv[3];		/**< Longitudinal unit vector at \ref
+                                 * tRoadLaneIn::xyz "xyz":\n
+				 * Unit vector in viewing direction
+                                 * \note This vector is used to determine
+                                 * whether the results should be calculated in
+                                 * or counter link direction.
+                                 */
+} tRoadLaneIn;
+//! Lane evaluation: output
+/** Struct for the output parameters of RoadLaneEval()\n
+ *  \note The difference between this struct and tRoadLaneOutExt is that the
+ *  <em>Lanes</em> in the tRoadLaneInfo structs are identified by their
+ *  internal identifiers.
+ */
+typedef struct tRoadLaneOut {
+    int    nLanesL;		/**< Number of left <em>Lanes</em>\note
+                                 * The term "left" refers to the direction
+                                 * specified by the \ref tRoadLaneIn::suv
+                                 * "viewing direction", which can be either in
+                                 * or counter link direction.
+				 */
+    int    nLanesR;		/**< Number of right <em>Lanes</em>\note
+                                 * The term "right" refers to the direction
+                                 * specified by the \ref tRoadLaneIn::suv
+                                 * "viewing direction", which can be either in
+                                 * or counter link direction.
+				 */
+    int    laneIdx;		/**< Index of the <em>Lane</em> \ref
+                                 * tRoadLaneIn::xyz "xyz" is located on
+                                 * in struct \ref tRoadLaneOut::left "left"
+                                 * or \ref tRoadLaneOut::right "right" (consider
+                                 * \ref tRoadLaneOut::isRight "isRight")
+                                 */
+    int    isRight;		/**< Flag indicating the side of the current
+                                 * <em>Lane</em>:
+                                 * - 0 &harr; left
+                                 * - 1 &harr; right
+                                 * 
+                                 * \note The terms "left" and "right" refer to
+                                 * the direction specified by the \ref
+                                 * tRoadLaneIn::suv "viewing direction", which
+                                 * can be either in or counter link direction.
+                                 */
+    tObjId lObjId;		/**< Object id of the current <em>Link</em>
+                                 */
+    tObjId lsObjId;		/**< Object id of the current <em>Lane
+                                 * section</em>
+				 */
+    tObjId laneObjId;		/**< Object id of the current <em>Lane</em>
+				 */
+    double lsLenAhead;		/**< Length of the <em>Lane</em> ahead:
+                                 * \n Distance between the current position 
+                                 * \ref tRoadLaneIn::xyz "xyz" and the end of
+                                 * the <em>Lane</em>\note
+                                 * The term "end" refers to the direction
+                                 * specified by the \ref tRoadLaneIn::suv
+                                 * "viewing direction", which can be either in
+                                 * or counter link direction.
+				 */
+    double lsLenBehind;		/**< Length of the <em>Lane</em> behind:
+                                 * \n Distance between the start of the
+                                 * <em>Lane</em> and the current position 
+                                 * \ref tRoadLaneIn::xyz "xyz" \note
+                                 * The term "start" refers to the direction
+                                 * specified by the \ref tRoadLaneIn::suv
+                                 * "viewing direction", which can be either in
+                                 * or counter link direction.
+				 */
+    double distToLeftBorder;	/**< Distance between the left border of
+                                 * the road and the current position \ref
+                                 * tRoadLaneIn::xyz "xyz" \note
+                                 * The term "left" refers to the direction
+                                 * specified by the \ref tRoadLaneIn::suv
+                                 * "viewing direction", which can be either in
+                                 * or counter link direction.
+				 */
+    double distToRightBorder;	/**< Distance between the right border of
+                                 * the road and the current position \ref
+                                 * tRoadLaneIn::xyz "xyz" \note
+                                 * The term "right" refers to the direction
+                                 * specified by the \ref tRoadLaneIn::suv
+                                 * "viewing direction", which can be either in
+                                 * or counter link direction.
+				 */
+    struct tRoadLaneInfo {
+	double        width;	/**< Width of the <em>Lane</em>
+				 */
+	double        tMidLane;	/**< Lateral offset of the middle of the
+                                 * <em>Lane</em> from the <em>Link's</em>
+                                 * <em>Reference line</em>\note
+                                 * The sign of the variable refers to the
+                                 * direction specified by the \ref
+                                 * tRoadLaneIn::suv "viewing direction", which
+                                 * can be either in or counter link direction.
+				 */
+	tRoadLaneType type;	/**< Type of the <em>Lane</em>
+				 */
+	int           laneId;	/**< Internal identifier of the <em>Lane</em>
+				 */
+    } left[ROAD_MAX_LANES],	/**< Array of structs containing the information
+                                 * about all left <em>Lanes</em> of the current
+                                 * <em>Lane section</em>\note
+                                 * The term "left" refers to the direction
+                                 * specified by the \ref tRoadLaneIn::suv
+                                 * "viewing direction", which can be either in
+                                 * or counter link direction.
+                                 */
+      right[ROAD_MAX_LANES];    /**< Array of structs containing the information
+                                 * about all right <em>Lanes</em> of the current
+                                 * <em>Lane section</em>\note
+                                 * The term "right" refers to the direction
+                                 * specified by the \ref tRoadLaneIn::suv
+                                 * "viewing direction", which can be either in
+                                 * or counter link direction.
+                                 */
+} tRoadLaneOut;
+
+/** Function to evaluate a <em>Lane</em>
+ * \param[in,out] re Evaluation handle of the road instance
+ * \param[in] errMsgPre Prefix for the error messages
+ * \param[in] in Pointer to a struct for the input parameters
+ * \param[out] out Pointer to a struct for the output parameters
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ *  \see RoadLaneEvalExt()
+ */
+int    RoadLaneEval(tRoadEval *re, const char *errMsgPre,
+				      const tRoadLaneIn *in, tRoadLaneOut *out);
+
+//! Lane evaluation: output (extended version)
+/** Struct used as member in the structs tRoadPathOut and tRoadRouteOutExt and
+ *  for the output parameters of RoadLaneEvalExt()\n
+ *  \note The difference between this struct and tRoadLaneOut is that the
+ *  <em>Lanes</em> in the tRoadLaneInfoExt structs are identified by their
+ *  object ids.
+ */
+typedef struct tRoadLaneOutExt {
+    int    nLanesL;		/**< Number of left <em>Lanes</em>\note
+                                 * The term "left" refers to the direction
+                                 * specified by the viewing direction, which can
+                                 * be either in or counter link direction. 
+				 */
+    int    nLanesR;		/**< Number of right <em>Lanes</em>\note
+                                 * The term "right" refers to the direction
+                                 * specified by the viewing direction, which can
+                                 * be either in or counter link direction.
+				 */
+    int    laneIdx;		/**< Index of the current <em>Lane</em> in
+                                 * struct \ref tRoadLaneOut::left "left" or
+                                 * \ref tRoadLaneOut::right "right" (consider
+                                 * \ref tRoadLaneOut::isRight "isRight")
+                                 */
+    int    isRight;		/**< Flag indicating the side of the current
+                                 * <em>Lane</em>:
+                                 * - 0 &harr; left
+                                 * - 1 &harr; right
+                                 * 
+                                 * \note The terms "left" and "right" refer to
+                                 * the direction specified by the viewing
+                                 * direction, which can be either in or counter
+                                 * link direction.
+                                 */
+    tObjId lObjId;		/**< Object id of the current <em>Link</em>
+                                 */
+    tObjId lsObjId;		/**< Object id of the current <em>Lane
+                                 * section</em>
+				 */
+    tObjId laneObjId;		/**< Object id of the current <em>Lane</em>
+				 */
+    double lsLenAhead;		/**< Length of the <em>Lane</em> ahead:
+                                 * \n Distance between the current position
+                                 * and the end of the <em>Lane</em>\note
+                                 * The term "end" refers to the direction
+                                 * specified by the viewing direction, which can
+                                 * be either in or counter link direction.
+				 */
+    double lsLenBehind;		/**< Length of the <em>Lane</em> behind:
+                                 * \n Distance between the start of the
+                                 * <em>Lane</em> and the current position \note
+                                 * The term "start" refers to the direction
+                                 * specified by the viewing direction, which can
+                                 * be either in or counter link direction.
+				 */
+    double distToLeftBorder;	/**< Distance between the left border of the
+                                 * road and the current position \note
+                                 * The term "left" refers to the direction
+                                 * specified by the viewing direction, which can
+                                 * be either in or counter link direction.
+				 */
+    double distToRightBorder;	/**< Distance between the right border of the
+                                 * road and the current position \note
+                                 * The term "right" refers to the direction
+                                 * specified by the viewing direction, which can
+                                 * be either in or counter link direction.
+				 */
+    struct tRoadLaneInfoExt {
+	double        width;	/**< Width of the <em>Lane</em>
+				 */
+	double	      tMidLane;	/**< Lateral offset of the middle of the
+                                 * <em>Lane</em> from the <em>Link's</em>
+                                 * <em>Reference line</em>\note
+                                 * The sign of the variable refers to the
+                                 * direction specified by the viewing direction,
+                                 * which can be either in or counter link
+                                 * direction.
+				 */
+	tRoadLaneType type;	/**< Type of the <em>Lane</em>
+				 */
+	int           laneObjId;/**< Object id of the <em>Lane</em>
+				 */
+    } left[ROAD_MAX_LANES],	/**< Array of structs containing the information
+                                 * about all left <em>Lanes</em> of the current
+                                 * <em>Lane section</em>\note
+                                 * The term "left" refers to the direction
+                                 * specified by the viewing direction, which can
+                                 * be either in or counter link direction.
+                                 */
+      right[ROAD_MAX_LANES];    /**< Array of structs containing the information
+                                 * about all right <em>Lanes</em> of the current
+                                 * <em>Lane section</em>\note
+                                 * The term "right" refers to the direction
+                                 * specified by the viewing direction, which can
+                                 * be either in or counter link direction.
+                                 */
+} tRoadLaneOutExt;
+
+/** Function to evaluate a <em>Lane</em>
+ * \param[in,out] re Evaluation handle of the road instance
+ * \param[in] errMsgPre Prefix for the error messages
+ * \param[in] in Pointer to a struct for the input parameters
+ * \param[out] out Pointer to a struct for the output parameters
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ *  \see RoadLaneEval()
+ */
+int    RoadLaneEvalExt(tRoadEval *re, const char *errMsgPre,
+                                   const tRoadLaneIn *in, tRoadLaneOutExt *out);
+
+
+/** @} */
+/******************************************************************************/
+/* +++ Reference Lines ++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+/** \addtogroup RefLinesEval
+ * @{
+ */
+//! Reference line evaluation: input
+/** Struct for the input parameters of RoadRefLineGeoEval()
+ */
+typedef struct tRoadRefLineIn {
+    tObjId rlObjId;		/**< Object id of the <em>Reference line</em>
+				 */
+    int    useST;		/**< Flag indicating whether the global IPGRoad
+                                 * or the <em>Reference line's</em> local
+                                 * coordinate system is used:
+				 * - 0 &harr; use \ref tRoadRefLineIn::xyz "xyz"
+				 * - 1 &harr; use \ref tRoadRefLineIn::st "st"
+				 */
+    double st[2];		/**< Given position in the <em>Reference
+				 * line's</em> local coordinate system
+				 */
+    double xyz[3];		/**< Given position in the global IPGRoad
+				 * coordinate system (Fr0)\note
+				 * An estimation of the z-coordinate is given
+				 * in order to simplify the evaluation (if no
+				 * reasonable estimation is known, initialize
+				 * the z-coordinate with zero).
+				 */
+} tRoadRefLineIn;
+//! Reference line evaluation: output
+/** Struct for the output parameters of RoadRefLineGeoEval()
+ */
+typedef struct tRoadRefLineOut {
+    double       xyz[3];	/**< Calculated position in the global IPGRoad
+				 * coordinate system (Fr0)
+				 */
+    double       nuv[3];	/**< Road surface normal unit vector at
+                                 * \ref tRoadRefLineOut::xyz "xyz"
+				 */
+    double       suv[3];	/**< Longitudinal unit vector at
+                                 * \ref tRoadRefLineOut::xyz "xyz":\n
+				 * Unit vector in s-direction of the
+				 * <em>Reference Line</em>
+				 */
+    double       tuv[3];	/**< Lateral unit vector at
+                                 * \ref tRoadRefLineOut::xyz "xyz":\n
+				 * Unit vector in t-direction of the 
+				 * <em>Reference Line</em>
+				 */
+    double       st[2];		/**< Calculated position in the <em>Reference
+                                 * line's</em> local coordinate system
+				 */
+    double       curveXY;	/**< Curvature of the curve in the (x,y)-plane
+                                 * at \ref tRoadRefLineOut::xyz "xyz"
+				 */
+    double       width[2];	/**< Distance between the left/right road border
+                                 * and the <em>Center line</em> at
+                                 * \ref tRoadRefLineOut::st "s" in meters \note
+				 * Only valid if \ref tRoadRefLineOut::xyz
+                                 * "xyz" is not on a Junction.
+				 */
+    tRoadPosKind onRoad;	/**< Kind of position:\n
+				 * On or (in some extent) off the road
+				 */
+/**
+ * \name
+ * The following output variables do not consider <em>Bumps</em>.
+ * @{
+ */
+/* --- The following outputs do not consider Bumps ---------------- */
+    double       grade;		/**< Longitudinal gradient at
+                                 * \ref tRoadRefLineOut::xyz "xyz":\n
+                                 * Gradient of the z-coordinate in s-direction
+                                 * of the <em>Reference line</em>
+                                 * \note <em>Bumps</em> are not considered.
+				 */
+    double       slope;		/**< Lateral gradient at
+                                 * \ref tRoadRefLineOut::xyz "xyz":\n
+                                 * Gradient of the z-coordinate in t-direction
+                                 * of the <em>Reference line</em>
+                                 * \note <em>Bumps</em> are not considered.
+				 */
+    double       curveZ;	/**< Longitudinal z-curvature:\n
+                                 * Curvature of the curve in the (s,z)-plane at
+                                 * \ref tRoadRefLineOut::xyz "xyz" (change of
+                                 * \ref tRoadRefLineOut::grade "grade" in
+                                 * s-direction of the <em>Reference line</em>).
+                                 * \note <em>Bumps</em> are not considered.
+				 */
+/** @} */
+    
+} tRoadRefLineOut;
+
+/** Function to evaluate a <em>Reference line</em>
+ * \param[in,out] re Evaluation handle of the road
+ * \param[in] errMsgPre Prefix for the error messages
+ * \param[in] in Pointer to a struct for the input parameters
+ * \param[out] out Pointer to a struct for the output parameters
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadRefLineGeoEval(tRoadEval *re, const char *errMsgPre,
+				const tRoadRefLineIn *in, tRoadRefLineOut *out);
+
+
+/** @} */
+/******************************************************************************/
+/* --- Additional objects --------------------------------------------------- */
+/******************************************************************************/
+
+
+/******************************************************************************/
+/*     Bumps                                                                  */
+/******************************************************************************/
+
+/** \addtogroup BumpsEval
+ * @{
+ */
+//! Bump evaluation: input
+/** Struct for the input parameters of RoadBumpEval()
+ */
+typedef struct tRoadBumpIn {
+    double u;		/**< Given position in the <em>Bump's</em> local 
+                         * coordinate system: u-coordinate (u = 0..1)
+			 */
+    double v;		/**< Given position in the <em>Bump's</em> local 
+                         * coordinate system: v-coordinate (v = 0..1)
+			 */
+    tObjId bObjId;	/**< Object Id of the <em>Bump</em>
+			 */
+    int    bumpOnly;	/**< Flag indicating what should be taken into account
+                         * for the calculation of the z-coordinate:
+                         * - 0 &harr; The z-coordinate is calculated considering
+                         * the road's <em>Height profile</em>.
+                         * - 1 &harr; The z-coordinate of only the <em>Bump</em>
+                         * is calculated.
+			 */
+} tRoadBumpIn;
+//! Bump evaluation: output
+/** Struct for the output parameters of RoadBumpEval()
+ */
+typedef struct tRoadBumpOut {
+    double xyz[3];	/**< Calculated position in the global IPGRoad
+                         * coordinate system (Fr0)
+                         */  
+    double nuv[3];	/**< Road surface normal unit vector at
+                         * \ref tRoadBumpOut::xyz "xyz"
+			 */
+} tRoadBumpOut;
+
+/**
+ */
+/** Function to evaluate a <em>Bump</em>
+ * \param[in,out] re Evaluation handle of the road instance
+ * \param[in] in Pointer to a struct for the input parameters
+ * \param[out] out Pointer to a struct for the output parameters
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadBumpEval(tRoadEval *re, tRoadBumpIn *in, tRoadBumpOut *out);
+
+
+/** @} */
+/******************************************************************************/
+/*     Markers                                                                */
+/******************************************************************************/
+
+
+/** \addtogroup MarkersEval
+ * @{
+ */
+/** Maximum number of marker types:\n
+ *  There can be defined at most thirty-two different types of <em>Markers</em>
+ *  including those not defined by the user.
+ */
+#define ROAD_MAX_MARKER_TYPES  32
+/** Maximum number of marker parameters:\n
+ *  At most thirty-two different parameters can be defined for a
+ *  <em>Marker</em>.
+ */
+#define ROAD_MAX_MARKER_PARAMS 32
+
+
+/** Types of <em>Markers</em>
+ */
+typedef enum tRoadMarkerType {
+    RMT_DrvSpeed       = 0,	/**< <b>0</b> &nbsp; Driver speed
+				 */
+    RMT_DrvStop        = 1,	/**< <b>1</b> &nbsp; Driver stop
+				 */
+    RMT_DrvPylon       = 2,     /**< <b>2</b> &nbsp; Pylon alley
+				 */
+    RMT_EnvWind        = 3,	/**< <b>3</b> &nbsp; Wind
+				 */
+    RMT_DrivManTrigger = 4,	/**< <b>4</b> &nbsp; Trigger point
+				 */
+    RMT_DrivManCmd     = 5,	/**< <b>5</b> &nbsp; DrivMan command
+				 */
+    RMT_DrivManJump    = 6,	/**< <b>6</b> &nbsp; DrivMan jump
+				 */
+    RMT_Unknown        = 7	/**< <b>7</b> &nbsp; User-defined
+				 */
+} tRoadMarkerType;
+
+
+/** @} */
+/** \addtogroup MarkersEdit
+ * @{
+ */
+/** Function to add a new class of <em>Markers</em> to an instance of the road\n
+ *  &rarr; \subpage MarkerTypeNamesIds
+ * "List of all initially defined marker types"
+ * \param[in,out] road Handle of the road instance
+ * \param[in] name Name of the new class of <em>Markers</em>
+ * \param[in] parFormat Data types of the associated parameters of the new class 
+ * of <em>Markers</em>: \n s(S) &harr; string (with spaces),
+ *  d &harr; double, f &harr; float, i &harr; integer
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> identifier of the new class of <em>Markers</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetMarkerType() \see RoadGetMarkerName() \see RoadAddMarker()
+ */
+int         RoadAddMarkerType(tRoad *road, const char *name,
+                                                         const char *parFormat);
+/** Function retrieving the identifier of a class of <em>Markers
+ * </em> from its name\n &rarr;
+ *  \subpage MarkerTypeNamesIds "List of all initially defined marker types"
+ * \param[in] road Handle of the road instance
+ * \param[in] name Name of the class of <em>Markers</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> identifier of the class of <em>Markers</em>
+ *  <tr><td> In case failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddMarkerType() \see RoadGetMarkerName()
+ */
+int         RoadGetMarkerType(tRoad *road, const char *name);
+/** @} */
+/** \addtogroup MarkersEval
+ * @{
+ */
+/** Function retrieving the name of a class of <em>Markers</em> from its
+ *  identifier
+ * \param[in] road Handle of the road instance
+ * \param[in] type Identifier of the class of <em>Markers</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> name of the class of <em>Markers</em>
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see RoadGetMarkerType() \see RoadGetMarkerTypeInfoByName()
+ */
+const char *RoadGetMarkerName(tRoad *road, int type);
+
+//! Marker type information
+/** Struct for the information about a class of <em>Markers</em>
+ * \see RoadGetMarkerTypeInfoByName() \see RoadGetMarkerTypeInfoByType()
+ */
+typedef struct tRMT_Info {
+    int	 type;			/**< \subpage MarkerTypeNamesIds "Identifier" of
+                                 * the class of <em>Markers</em>
+				 */
+    int	 parBlockLen;		/**< Length of the entire parameter block of an
+                                 * instance of the class of <em>Markers</em>:\n
+                                 * depending on datatype and number of the
+                                 * different parameters
+				 */
+    int	 nPar;			/**< Number of parameters of an instance of the
+                                 * class of <em>Markers</em>
+				 */
+    char *name;			/**< \subpage MarkerTypeNamesIds "Name" of the
+                                 * class of <em>Markers</em>
+				 */
+    char *parFormat;		/**< Data types of the associated parameters of
+                                 * an instance of the class of <em>Markers</em>:
+                                 * \n s(S) &harr; string (with spaces), d &harr;
+                                 * double, f &harr; float, i &harr; integer
+				 */
+    struct {
+	char  datatype;		/**< Datatype of the parameter:\n
+                                 * s(S) &harr; string (with spaces), d &harr;
+                                 * double, f &harr; float, i &harr; integer
+				 */
+	short offset;		/**< Offset of the start of the parameter in the
+                                 * parameter block
+				 */
+    } par[ROAD_MAX_MARKER_PARAMS];/**< Array for the information about datatype
+                                 * and position of each parameter of an
+                                 * instance of the class of <em>Markers</em>
+				 */
+} tRMT_Info;
+
+/** Function retrieving the information about a class of <em>Markers</em> from
+ *  its name
+ * \param[in] road Handle of the road instance
+ * \param[in] name Name of the class of <em>Markers</em> 
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> pointer to a struct with the information about the class of
+ *  <em>Markers</em>
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see RoadGetMarkerName() \see RoadGetMarkerTypeInfoByType()
+ */
+tRMT_Info *RoadGetMarkerTypeInfoByName (tRoad *road, const char *name);
+/** Function retrieving the information about a class of <em>Markers</em> from
+ *  its identifier
+ * \param[in] road Handle of the road instance
+ * \param[in] type Identifier of the class of <em>Markers</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> pointer to a struct with the information about the class of
+ *  <em>Markers</em>
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see RoadGetMarkerType() \see RoadGetMarkerTypeInfoByName()
+ */
+tRMT_Info *RoadGetMarkerTypeInfoByType (tRoad *road, int type);
+
+
+/*** Output options for a marker evaluation handle ***/
+
+/** Output option for a marker evaluation handle: \n
+ * The offset of the <em>Marker</em> (\ref tRoadMarkerOut::s "s") is given 
+ * relative to the <em>Link</em>
+ * considering the direction validity of the <em>Marker</em>.
+ * \see RoadLinkGetMarkerEvalExt()\see RoadLinkObjFindMarker()
+ * \see RoadLinkNextMarker()
+ */
+#define ROAD_LME_REL_TO_LINK_1 1
+/** Output option for a marker evaluation handle: \n
+ * The offset of the <em>Marker</em> (\ref tRoadMarkerOut::s "s") is given 
+ * relative to the <em>Link's</em> starting point <em>Node0</em>.
+ * \see RoadLinkGetMarkerEvalExt()\see RoadLinkObjFindMarker()
+ * \see RoadLinkNextMarker()
+ */
+#define ROAD_LME_REL_TO_LINK_2 2
+/** Output option for a marker evaluation handle: \n
+ * The offset of the <em>Marker</em> (\ref tRoadMarkerOut::s "s")
+ * is given relative to the start offset s0 of the
+ * search area of the <em>Link</em> considering the direction validity of the
+ * <em>Marker</em>.
+ * \see RoadLinkGetMarkerEvalExt()\see RoadLinkObjFindMarker()
+ * \see RoadLinkNextMarker()
+ */
+#define ROAD_LME_REL_TO_SO     3
+
+//! Marker of type Driver speed: output
+/** Struct for the parameters of a <em>Marker</em> of type <em>Driver speed</em>
+ *  used as member of tRoadMarkerOut
+ */
+typedef struct tRM_DrvSpeed {
+    double limit;	/**< Speed limit in m/s
+			 */
+    char   *unit;	/**< Unit of the speed selected by the user: kmh or mph
+			 */
+} tRM_DrvSpeed;
+
+/** Types of <em>Stop markers</em>:\n
+ * Used to control the behaviour of a <em>Stop marker</em>.
+ */
+typedef enum tRoadDrvStopType {
+    RDST_Stop=0,        /**< <b>0</b> &nbsp; Used to simulate the 
+                         * behaviour at a stop sign
+			 */        
+    RDST_GiveWay,        /**< <b>1</b> &nbsp; \warning Not yet supported!
+			 */
+    RDST_TrfLight,       /**< <b>2</b> &nbsp; Used to observe
+                          * a <em>Traffic light contoller</em>
+			 */
+    RDST_Junction,       /**< <b>3</b> &nbsp; \warning Not yet supported!
+			 */
+    RDST_Unknown         /**< <b>4</b> &nbsp; Unknown stop marker type
+			 */       
+} tRoadDrvStopType;
+//! Marker of type Driver stop: output
+/** Struct for the parameters of a <em>Marker</em> of type <em>Driver stop</em>
+ *  used as member of tRoadMarkerOut
+ */
+typedef struct tRM_DrvStop {
+    double duration;        /**< Duration of the stop in seconds
+                             */
+    tRoadDrvStopType type;  /**< Type of the <em>Stop marker</em>
+                             */
+    tObjId refObjId;        /**< Object id of the reference object of the
+                             * <em>Marker</em>
+                             * \note This parameter is only considered for
+                             * <em>Stop markers</em> of type #RDST_TrfLight or
+                             * #RDST_Junction.
+                             */
+} tRM_DrvStop;
+//! Marker of type Pylon alley: output
+/** Struct for the parameters of a <em>Marker</em> of type <em>Pylon alley</em>
+ *  used as member of tRoadMarkerOut
+ */
+typedef struct tRM_Pylon {
+    double width;	/**< Width between the two pylons in meters
+			 */
+} tRM_Pylon;
+//! Marker of type Wind: output
+/** Struct for the parameters of a <em>Marker</em> of type <em>Wind</em> used
+ *  as member of tRoadMarkerOut
+ */
+typedef struct tRM_Wind {
+    double speed;	/**< Speed of the wind in m/s
+			 */
+    double angle;	/**< Direction of the wind in degrees
+			 */
+    char   *unit;	/**< Unit of the wind speed selected by the user:
+                         * kmh or ms
+			 */
+} tRM_Wind;
+//! Marker of type Trigger point: output
+/** Struct for the parameters of a <em>Marker</em> of type <em>Trigger
+ *  point</em> used as member of tRoadMarkerOut
+ */
+typedef struct tRM_Trigger {
+    int mode;		/**< Mode of the <em>Trigger point</em>:
+                         * - 1 &harr; define a new reference point
+                         * - 2 &harr; take all measurements
+                         * - 3 &harr; take all measurements and define a new
+                         * reference point
+			 */
+    int id;		/**< Positive integer value for the identification of
+                         * the <em>Marker</em>: Should be numbered
+                         * consecutively.
+			 */
+} tRM_Trigger;
+//! Marker of type DrivMan command: output
+/** Struct for the parameters of a <em>Marker</em> of type <em>DrivMan
+ *  command</em> used as member of tRoadMarkerOut
+ */
+typedef struct tRM_DrivManCmd {
+    char *expr;		/**< Minimaneuver command of the <em>Marker</em>
+			 */
+} tRM_DrivManCmd;
+//! Marker of type DrivMan jump: output
+/** Struct for the parameters of a <em>Marker</em> of type <em>DrivMan jump</em>
+ *  used as member of tRoadMarkerOut
+ */
+typedef struct tRM_DrivManJump {
+    char *level;	/**< Target label of the <em>Marker</em>
+			 */
+} tRM_DrivManJump;
+//! User-defined Marker: output
+/** Struct for the parameters of a <em>Marker</em> of type <em>User-defined</em>
+ *  used as member of tRoadMarkerOut
+ */
+typedef struct tRM_User {
+    void *v;            /**< List of parameters assigned to the <em>Marker</em>
+			 */
+} tRM_User;
+//! Marker evaluation: output
+/** Struct for the output parameters of the functions evaluating the
+ *  <em>Markers</em> of a road instance:
+ *  - RoadLinkObjFindMarker(),
+ *  - RoadLinkNextMarker(),
+ *  - RoadRouteFindMarker(),
+ *  - RoadRouteNextMarker(),
+ *  - RoadLinkGetAllMarkerByObjId()\n &emsp; and
+ *  - RoadGetAllMarkerByObjId().
+ */
+typedef struct tRoadMarkerOut {
+    double s;               	/**< Offset of the detected <em>Marker</em>
+                                 * in s-direction in meters\note
+                                 * In case the marker evaluation is executed
+                                 * with respect to a <em>Link</em>, the output
+                                 * option of the marker evaluation handle
+                                 *  (#ROAD_LME_REL_TO_LINK_1,
+                                 * #ROAD_LME_REL_TO_LINK_2 or
+                                 * #ROAD_LME_REL_TO_SO) is considered.
+				 */
+    double t;			/**< Lateral offset of the detected <em>Marker
+                                 * </em> in meters
+				 */
+    double xyz[3];		/**< Position of the detected <em>Marker</em> in
+                                 * the global IPGRoad coordinate system (Fr0)
+				 */
+    int	   latRef;		/**< Integer value for the \ref tRoadLatRef
+                                 * "lateral reference" of \ref tRoadMarkerOut::t
+                                 * "t"
+				 */
+    int	   type;		/**< \subpage MarkerTypeNamesIds
+                                 * "Identifier of the class" of the detected
+                                 * <em>Marker</em>
+				 */
+    int	   objId;		/**< Object id of the detected <em>Marker</em>
+				 */
+    int	   valid;		/**< Flag indication whether the detected
+                                 * <em>User-defined Marker</em> signals the
+                                 * start or the end of a validity zone:
+                                 * - 0 &harr; End of the validity zone.
+                                 * - 1 &harr; Start of the validity zone.
+				 */
+    int	   dirValidity;		/**< \ref tRoadDirValidity "Direction validity"
+                                 * of the detected <em>Marker</em>
+                                 */
+    union {
+	void		*par;	/**< Special parameters of a <em>Marker</em> of
+                                 * arbitrary type
+				 */
+	tRM_DrvSpeed	*speed;	/**< Special parameters of a <em>Marker</em>
+                                 * of type <em>Driver speed</em>
+				 */
+	tRM_DrvStop	*stop;	/**< Special parameters of a <em>Marker</em>
+                                 * of type <em>Driver stop</em>
+				 */
+	tRM_Pylon	*pylon;	/**< Special parameters of a <em>Marker</em>
+                                 * of type <em>Pylon alley</em>
+				 */
+	tRM_Wind	*wind;	/**< Special parameters of a <em>Marker</em>
+                                 * of type <em>Wind</em>
+				 */
+	tRM_Trigger	*trigger;/**< Special parameters of a <em>Marker</em>
+                                 * of type <em>Trigger point</em>
+				 */
+	tRM_DrivManCmd	*cmd;	/**< Special parameters of a <em>Marker</em>
+                                 * of type <em>DrivMan command</em>
+				 */
+	tRM_DrivManJump *jmp;	/**< Special parameters of a <em>Marker</em>
+                                 * of type <em>DrivMan jump</em>
+				 */
+        tRM_User	 user;	/**< Special parameters of a <em>Marker</em>
+                                 * of type <em>User-defined</em>
+				 */
+    };				/**< Struct for the special parameters of the
+                                 * <em>Marker</em> depending on its type
+				 */
+} tRoadMarkerOut;
+
+
+/** Function to generate and initialize a marker evaluation handle\n
+ * The output option of the handle is set to #ROAD_LME_REL_TO_LINK_1.
+ * \param[in] road Handle of the road instance
+ * \param[in] mask Mask for the types of <em>Markers</em> that should be
+ *  evaluated by the new marker evaluation handle:\n
+ *  The binary system is used to generate combinations of the different marker
+ *  types by summarizing 1 << \subpage MarkerTypeNamesIds "typeId".
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> new marker evaluation handle
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see RoadLinkGetMarkerEvalExt() \see RoadLinkDeleteMarkerEval()
+ * \see RoadRouteObjGetMarkerEval()
+ */
+tRoadMarkerEval *RoadLinkGetMarkerEval   (tRoad *road, int mask);
+/** Function to generate and initialize a marker evaluation handle\n
+ *  <b><em>Extended version:</em></b> The output option of the handle can be
+ *  set.
+ * \param[in] road Handle of the road instance
+ * \param[in] mask Mask for the types of <em>Markers</em> that should be
+ *  evaluated by the new marker evaluation handle: \n
+ *  The binary system is used to generate combinations of the different marker
+ *  types by summarizing 1 << \subpage MarkerTypeNamesIds "typeId".
+ * \param[in] options Output option for the new marker evaluation handle:\n
+ *  #ROAD_LME_REL_TO_LINK_1, #ROAD_LME_REL_TO_LINK_2 or #ROAD_LME_REL_TO_SO
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> new marker evaluation handle\n
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see RoadLinkGetMarkerEval() \see RoadLinkDeleteMarkerEval()
+ * \see RoadRouteObjGetMarkerEval()
+ */
+tRoadMarkerEval *RoadLinkGetMarkerEvalExt(tRoad *road, int mask, int options);
+/** Function to free the memory of a marker evaluation handle
+ * \param[in] rme Marker evaluation handle that should be deleted
+ * \see RoadLinkGetMarkerEval() \see RoadLinkGetMarkerEvalExt()
+ * \see RoadRouteDeleteMarkerEval()
+ */
+void             RoadLinkDeleteMarkerEval(tRoadMarkerEval *rme);
+
+/** Function to get a <em>Marker</em> from a given section of a <em>Link</em>
+ * (if there is one)\n
+ * The <em>Link</em> is identified by its internal identifier.
+ * 
+ * This function searches for <em>Markers</em> defined on the section of the
+ * <em>Link</em> given by the parameters <b>s0</b> and <b>s1</b>:
+ * - <b>s0</b> < <b>s1</b>: Only <em>Markers</em> valid in link direction are
+ *  taken into account. The <em>Marker</em> that is nearest to <b>s0</b> is
+ *  retrieved.
+ * - <b>s0</b> > <b>s1</b>: Only <em>Markers</em> valid counter link direction
+ *  are taken into account. The <em>Marker</em> that is nearest to <b>s1</b> is
+ *  retrieved.
+ * 
+ * \param[in,out] rme Marker evaluation handle
+ * \param[in] linkId Identifier of the <em>Link</em>
+ * \param[in] s0 Start offset of the search area on the <em>Link</em>
+ * \param[in] s1 End offset of the search area on the <em>Link</em>
+ * \param[out] out Pointer to a struct for the parameters of the detected
+ *  <em>Marker</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Markers</em> found: 0 or 1
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \deprecated Use RoadLinkObjFindMarker() to get a <em>Marker</em> from a given
+ * section of a <em>Link</em>.
+ */
+int    RoadLinkFindMarker   (tRoadMarkerEval *rme, int linkId,
+				     double s0, double s1, tRoadMarkerOut *out);
+/** Function to get a <em>Marker</em> from a given section of a <em>Link</em>
+ * (if there is one)
+ * 
+ * This function searches for <em>Markers</em> defined on the section of the
+ * <em>Link</em> given by the parameters <b>s0</b> and <b>s1</b>:
+ * - <b>s0</b> < <b>s1</b>: Only <em>Markers</em> valid in link direction are
+ *  taken into account. The <em>Marker</em> that is nearest to <b>s0</b> is
+ *  retrieved.
+ * - <b>s0</b> > <b>s1</b>: Only <em>Markers</em> valid counter link direction
+ *  are taken into account. The <em>Marker</em> that is nearest to <b>s1</b> is
+ *  retrieved.
+ * 
+ * \param[in,out] rme Marker evaluation handle
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[in] s0 Start offset of the search area on the <em>Link</em>
+ * \param[in] s1 End offset of the search area on the <em>Link</em>
+ * \param[out] out Pointer to a struct for the parameters of the detected
+ *  <em>Marker</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Markers</em> found: 0 or 1
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road. 
+ *  </table>
+ * \see RoadRouteFindMarker()
+ */
+int    RoadLinkObjFindMarker(tRoadMarkerEval *rme, tObjId lObjId,
+				     double s0, double s1, tRoadMarkerOut *out);
+/** Function to get the <em>Marker</em> succeeding a given one on a
+ *  <em>Link</em> (if there is one)\n
+ *  The information about the position of the given <em>Marker</em> and the
+ *  chosen search direction stored in the marker evaluation handle are used.
+ * \param[in,out] rme Marker evaluation handle
+ * \param[out] out Pointer to a struct for the parameters of the detected
+ *  <em>Marker</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Markers</em> found: 0 or 1
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadLinkObjFindMarker() \see RoadLinkGetAllMarkerByObjId()
+ * \see RoadRouteNextMarker()
+ */
+int    RoadLinkNextMarker   (tRoadMarkerEval *rme,         tRoadMarkerOut *out);
+
+
+/** Function to generate and initialize a marker evaluation handle\n
+ * The <em>Route</em> is identified by its internal identifier. It is assigned
+ * to the appropriate member of the marker evaluation struct.
+ * \param[in] road Handle of the road instance
+ * \param[in] routeId Identifier of the <em>Route</em>
+ * \param[in] mask Mask for the types of <em>Markers</em> that should be
+ *  evaluated by the new marker evaluation handle:\n
+ *  The binary system is used to generate combinations of the different marker
+ *  types by summarizing 1 << \subpage MarkerTypeNamesIds "typeId".
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> new marker evaluation handle
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \deprecated Use RoadRouteObjGetMarkerEval() to generate and initialize a
+ * marker evaluation handle.
+ */
+tRoadMarkerEval *RoadRouteGetMarkerEval   (tRoad *road, int routeId, int mask);
+/** Function to generate and initialize a marker evaluation handle\n
+ * The <em>Route</em> is assigned to the appropriate member of the marker
+ * evaluation struct.
+ * \param[in] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \param[in] mask Mask for the types of <em>Markers</em> that should be
+ *  evaluated by the new marker evaluation handle:\n
+ *  The binary system is used to generate combinations of the different marker
+ *  types by summarizing 1 << \subpage MarkerTypeNamesIds "typeId".
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> new marker evaluation handle
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see RoadRouteDeleteMarkerEval()
+ */
+tRoadMarkerEval *RoadRouteObjGetMarkerEval(tRoad *road, tObjId rObjId,
+								     int mask);
+/** Function to free the memory of a marker evaluation handle
+ * \param[in] rme Marker evaluation handle that should be deleted
+ * \see RoadRouteObjGetMarkerEval() \see RoadLinkDeleteMarkerEval()
+ */
+void             RoadRouteDeleteMarkerEval(tRoadMarkerEval *rme);
+
+/** Function to get a <em>Marker</em> from a given section of a <em>Route</em>
+ * (if there is one)\n
+ *  The <em>Route</em> stored in the marker evaluation handle (see
+ *  RoadRouteObjGetMarkerEval()) is used.
+ * 
+ * This function searches for <em>Markers</em> defined on the section of a
+ * <em>Route</em> given by the parameters <b>s0</b> and <b>s1</b>:
+ * - <b>s0</b> < <b>s1</b>: The <em>Marker</em> that is nearest to <b>s0</b> is
+ *   retrieved.
+ * - <b>s0</b> > <b>s1</b>: The <em>Marker</em> that is nearest to <b>s1</b> is
+ *   retrieved.
+ * 
+ * Only <em>Markers</em> valid in route direction are taken into account. 
+ * \param[in,out] rme Marker evaluation handle
+ * \param[in] s0 Start offset of the search area on the <em>Route</em>
+ * \param[in] s1 End offset of the search area on the <em>Route</em>
+ * \param[out] out Pointer to a struct for the parameters of the detected
+ *  <em>Marker</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of Markers found: 0 or 1 
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadLinkObjFindMarker()
+ */
+int    RoadRouteFindMarker(tRoadMarkerEval *rme,
+				     double s0, double s1, tRoadMarkerOut *out);
+/** Function to get the <em>Marker</em> succeeding a given one on a
+ *  <em>Route</em> (if there is one)\n
+ *  The information about the position of the given <em>Marker</em> and the
+ *  chosen search direction stored in the marker evaluation handle are used.
+ *  Only <em>Markers</em> valid in route direction are taken into account. 
+ * \param[in,out] rme Marker evaluation handle
+ * \param[out] out Pointer to a struct for the parameters of the detected
+ *  <em>Marker</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of Markers found: 0 or 1 
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadRouteFindMarker() \see RoadGetAllMarkerByObjId()
+ * \see RoadLinkNextMarker()
+ */
+int    RoadRouteNextMarker(tRoadMarkerEval *rme,           tRoadMarkerOut *out);
+
+
+
+/** @} */
+/*** Not realtime capable Functions - not to be called in realtime context  ***/
+
+
+/** \addtogroup NRTMarkersEval
+ * @{
+ */
+/** Function to get all <em>Markers</em> along a given <em>Link</em>\n
+ *  The <em>Link</em> is identified by its internal identifier.
+ * \param[in] road Handle of the road instance
+ * \param[in] linkId Identifier of the <em>Link</em>
+ * \param[in] mask Mask for the types of <em>Markers</em> that should be
+ *  detected:\n
+ *  The binary system is used to generate combinations of the different marker
+ *  types by summarizing 1 << \subpage MarkerTypeNamesIds "typeId".
+ * \param[out] out Pointer to an array of structs for the parameters of the
+ *  detected <em>Markers</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Markers</em> attached to the <em>Link</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \deprecated Use RoadLinkGetAllMarkerByObjId() to get all <em>Markers</em>
+ * along a given <em>Link</em>.
+ */
+int    RoadLinkGetAllMarker          (tRoad *road, int linkId,   int mask,
+							  tRoadMarkerOut **out);
+/** Function to get all <em>Markers</em> along a given <em>Link</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[in] mask Mask for the types of <em>Markers</em> that should be
+ *  detected:\n
+ *  The binary system is used to generate combinations of the different marker
+ *  types by summarizing 1 << \subpage MarkerTypeNamesIds "typeId".
+ * \param[out] out  Pointer to an array of structs for the parameters of the
+ *  detected <em>Markers</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Markers</em> attached to the <em>Link</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadRefLineGetAllMarkerByObjId() \see RoadGetAllMarkerByObjId()
+ */
+int    RoadLinkGetAllMarkerByObjId   (tRoad *road, tObjId lObjId, int mask,
+							  tRoadMarkerOut **out);
+
+/** Function to get all <em>Markers</em> along a given <em>Reference Line</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] rlObjId Object id of the <em>Reference Line</em>
+ * \param[in] mask Mask for the types of <em>Markers</em> that should be
+ *  detected:\n
+ *  The binary system is used to generate combinations of the different marker
+ *  types by summarizing 1 << \subpage MarkerTypeNamesIds "typeId".
+ * \param[out] out  Pointer to an array of structs for the parameters of the
+ *  detected <em>Markers</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Markers</em> attached to the <em>Reference line</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadLinkGetAllMarkerByObjId() \see RoadGetAllMarkerByObjId()
+ */
+int    RoadRefLineGetAllMarkerByObjId(tRoad *road, tObjId rlObjId, int mask, 
+                                                          tRoadMarkerOut **out);
+
+/** Function to get all <em>Markers</em> along a given <em>Route</em>\n
+ *  The <em>Route</em> is identified by its internal identifier. In case the
+ *  identifier is negative, all <em>Markers</em> of the road instance are
+ *  retrieved.
+ * \param[in] road Handle of the road instance
+ * \param[in] routeId Identifier of the <em>Route</em>
+ * \param[in] mask Mask for the types of <em>Markers</em> that should be
+ *  detected:\n
+ *  The binary system is used to generate combinations of the different marker
+ *  types by summarizing 1 << \subpage MarkerTypeNamesIds "typeId".
+ * \param[out] out  Pointer to an array of structs for the parameters of the
+ *  detected <em>Markers</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Markers</em> attached to the <em>Route</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \deprecated Use RoadGetAllMarkerByObjId() to get all <em>Markers</em> along a
+ * given <em>Route</em>
+ */
+int    RoadGetAllMarker              (tRoad *road, int routeId, int mask,
+							  tRoadMarkerOut **out);
+/** Function to get all markers along a given <em>Route</em>\n
+ *  In case the object id is \ref ROAD_InvalidObjId "invalid", all
+ *  <em>Markers</em> of the road instance are retrieved.
+ * \param[in] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \param[in] mask Mask for the types of <em>Markers</em> that should be
+ *  detected:\n
+ *  The binary system is used to generate combinations of the different marker
+ *  types by summarizing 1 << \subpage MarkerTypeNamesIds "typeId".
+ * \param[out] out Pointer to an array of structs for the parameters of the
+ *  detected <em>Markers</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Markers</em> attached to the <em>Route</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadLinkGetAllMarkerByObjId() \see RoadRefLineGetAllMarkerByObjId()
+ */
+int    RoadGetAllMarkerByObjId       (tRoad *road, tObjId rObjId, int mask,
+						          tRoadMarkerOut **out);
+
+
+/** @} */
+/******************************************************************************/
+/*     Accessories and scenery                                                */
+/******************************************************************************/
+
+
+/** \addtogroup SOEval
+ * @{
+ */
+/** Number of traffic light phases:\n
+ *  There are five different phases of a <em>Traffic light</em> whose durations
+ *  need to be set:
+ *  off phase, green phase, yellow phase, red phase and red+yellow phase.
+ */
+#define ROAD_NUM_TL_TIMING 5
+/** Maximum number of shape points for the \ref tRoadTrfSignsIn::p
+ *  "traffic sign", \ref tRoadTracksIn::p "track" and \ref tRoadLaneLimiterIn::p
+ *  "limiter" detection:\n
+ *  At most ten points can be used to describe the shape of a sensor area which 
+ *  is defined as the road surface and the.
+ */
+#define ROAD_MAX_SHAPE_PTS 10
+
+
+
+/***   CarMaker Sensor object evaluation   ************************************/
+
+
+/** \cond
+ */
+typedef struct tRoadSensorObjEval tRoadSensorObjEval;
+
+
+/** \endcond
+ */
+/** Sensor object types
+ */
+typedef enum tRoadSensObjType {
+    RSOT_Unknown              = -1,	/**< <b>-1</b> &nbsp;
+                                         * Unknown sensor object type
+					 */
+    RSOT_Mount                = 10,	/**< <b>10</b> &nbsp; Mount
+					 */
+    RSOT_TrfSign,     			/**< <b>11</b> &nbsp; Traffic sign
+					 */
+    RSOT_TrfLight,       		/**< <b>12</b> &nbsp; Traffic light
+					 */
+    RSOT_TrfBarrierPostSquare = 20,	/**< <b>20</b> &nbsp; Traffic barrier
+                                         * pole of type <em>Square</em>
+					 */
+    RSOT_TrfBarrierPostSigma,		/**< <b>21</b> &nbsp; Traffic barrier
+                                         * pole of type <em>Sigma</em>
+					 */
+    RSOT_TrfBarrierPostJersey, 		/**< <b>22</b> &nbsp; Traffic barrier
+                                         * of type <em>Jersey barrier</em>
+                                         * (segmented)
+					 */
+    RSOT_TrfBarrierPostWall,    	/**< <b>23</b> &nbsp; Traffic barrier
+                                         * of type <em>Wall</em> (segmented)
+					 */
+    RSOT_TrfBarrierGuard      = 30,	/**< <b>30</b> &nbsp; Traffic barrier of
+					 * type <em>Guardrail</em>
+					 */
+    RSOT_TrfBarrierJersey,		/**< <b>31</b> &nbsp; Traffic barrier of
+                                         * type <em>Jersey barrier</em>
+					 */
+    RSOT_TrfBarrierWall,		/**< <b>32</b> &nbsp; Traffic barrier of
+                                         * type <em>Wall</em>
+					 */
+    RSOT_GuidePost            = 40,	/**< <b>40</b> &nbsp; Guide posts
+					 */
+    RSOT_Tree                 = 50,	/**< <b>50</b> &nbsp; Tree strip
+					 */
+    RSOT_Geometry             = 60 	/**< <b>60</b> &nbsp; Geometry object
+					 */
+} tRoadSensObjType;
+
+
+/*** Sensor object mask ***/
+
+/** Mount:\n
+ *  Flag indicating that <em>Mounts</em> should be considered.
+ *  \see RoadGetSensorObjEval()
+ */
+#define ROAD_SO_MOUNT           (1<<0)
+/** Traffic sign:\n
+ *  Flag indicating that <em>Traffic signs</em> should be considered.
+ *  \see RoadGetSensorObjEval()
+ */
+#define ROAD_SO_TRFSIGN         (1<<1)
+/** Traffic light:\n
+ *  Flag indicating that <em>Traffic lights</em> should be considered.
+ *  \see RoadGetSensorObjEval()
+ */
+#define ROAD_SO_TRFLIGHT        (1<<2)
+/** Traffic barrier:\n
+ *  Flag indicating that <em>Traffic barriers</em> should be considered.
+ *  \see RoadGetSensorObjEval()
+ */
+#define ROAD_SO_TRFBARRIER      (1<<3)
+/** Road marking:\n
+ *  Flag indicating that <em>Road markings</em> should be considered.
+ *  \see RoadGetSensorObjEval()
+ */
+#define ROAD_SO_ROADMARKING     (1<<4)
+/** Tree:\n
+ *  Flag indicating that <em>Tree strips</em> should be considered.
+ *  \see RoadGetSensorObjEval()
+ */
+#define ROAD_SO_TREESTRIP       (1<<5)
+/** Geometry object:\n
+ *  Flag indicating that <em>Geometry objects</em> should be considered.
+ *  \see RoadGetSensorObjEval()
+ */
+#define ROAD_SO_GEOOBJECT       (1<<6)
+/** Guide posts:\n
+ *  Flag indicating that <em>Guide posts</em> should be considered.
+ *  \see RoadGetSensorObjEval()
+ */
+#define ROAD_SO_GUIDEPOST       (1<<7)
+/** Road painting:\n
+ *  Flag indicating that <em>Road painting</em> should be considered.
+ *  \see RoadGetSensorObjEval()
+ */
+#define ROAD_SO_ROADPAINTING    (1<<8)
+/** Sign plate:\n
+ *  Flag indicating that <em>Sign plates</em> should be considered.
+ *  \see RoadGetSensorObjEval()
+ */
+#define ROAD_SO_SIGNPLATE       (1<<9)
+/** Traffic barrier pole:\n
+ *  Flag indicating that the poles of <em>Traffic barriers</em> should be
+ *  considered.
+ *  \see RoadGetSensorObjEval()
+ */
+#define ROAD_SO_TB_POLE         (1<<10)
+/** Traffic barrier guard rail:\n
+ *  Flag indicating that the barrier of <em>Traffic barriers</em> should be
+ *  considered.
+ *  \see RoadGetSensorObjEval()
+ */
+#define ROAD_SO_TB_GUARD        (1<<11) 
+
+
+/** Function to generate and initialize a new sensor object evaluation handle\n
+ *  It is specified which types of <em>Sensor objects</em> are of interest for
+ *  the evaluation executed with the new sensor object evaluation handle.
+ * \param[in] road Handle of the road instance
+ * \param[in] rsoMask Mask for the types of <em>Sensor objects</em> that should
+ *  be considered:\n
+ *  The binary system is used to generate combinations of the macros
+ *  #ROAD_SO_MOUNT, #ROAD_SO_TRFSIGN, #ROAD_SO_TRFLIGHT, #ROAD_SO_TRFBARRIER
+ *  #ROAD_SO_ROADMARKING, #ROAD_SO_TREESTRIP, #ROAD_SO_GEOOBJECT,
+ *  #ROAD_SO_GUIDEPOST, #ROAD_SO_ROADPAINTING, #ROAD_SO_SIGNPLATE,
+ *  #ROAD_SO_TB_POLE and #ROAD_SO_TB_GUARD.
+ * \param[in] maxLen Unused
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> sensor object evaluation handle
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see RoadDeleteSensorObjEval()
+ */
+tRoadSensorObjEval* RoadGetSensorObjEval   (tRoad *road, int rsoMask,
+							         double maxLen);
+/** Function to free the memory of a sensor object evaluation handle
+ * \param[in] rsoe Sensor object evaluation handle that should be deleted
+ * \see RoadGetSensorObjEval()
+ */
+void                RoadDeleteSensorObjEval(tRoadSensorObjEval *rsoe);
+
+//! Sensor Object evaluation: input
+/** Struct for the input parameters of RoadGetSensorObjs()
+ */
+typedef struct tRoadSensorObjIn {
+    double xyz[3];                  /**< Position of the <em>Sensor</em> in the
+                                     * global IPGRoad coordinate system (Fr0)
+                                     */
+    double p[ROAD_MAX_SHAPE_PTS][2];/**< Shape of the two-dimensional sensor
+                                     * area in the (x,y)-plane of the global
+                                     * IPGRoad coordinate system (Fr0)
+                                     */
+    int    nP;                      /**< Number of points used to define the
+                                     * shape of the sensor array
+                                     */
+    int    nMax;                    /**< Maximum number of <em>Sensor
+                                     * objects</em> considered for the sensor
+                                     * object detection
+                                     */
+} tRoadSensorObjIn;
+//! Sensor Object
+/** Struct for the attributes of a <em>Sensor object</em> used as member in the
+ *  struct tRoadSensorObjOut
+ *  \note The rectangular cuboid building the <em>Sensor object's</em> minimum
+ *   bounding box is considered.
+ */
+typedef struct tRoadSensorObj {
+    double	     l;		/**< Length of the <em>Sensor object</em> in
+                                 * meters
+				 */
+    double 	     w;		/**< Width of the <em>Sensor object</em> in
+                                 * meters
+				 */
+    double	     h;		/**< Height of the <em>Sensor object</em> in
+                                 * meters
+				 */
+    double	     nuv_lh[3];	/**< Normal unit vector of the rectangular
+                                 * surface defined by length and height of the
+                                 * <em>Sensor object</em>
+				 */
+    double	     nuv_wh[3];	/**< Normal unit vector of the rectangular
+                                 * surface defined by width and height of the
+                                 * <em>Sensor object</em>
+				 */
+    double	     xyz[3];	/**< Position of the center of the <em>Sensor
+                                 * object</em> in the global IPGRoad coordinate
+                                 * system (Fr0)
+				 */
+    tObjId	     objId;	/**< Object id of the <em>Sensor object</em>
+				 */
+    tRoadSensObjType rsot;	/**< Type of the <em>Sensor object</em>
+				 */ 
+} tRoadSensorObj;
+//! Sensor Object evaluation: output
+/** Struct for the output parameters of RoadGetSensorObjs()
+ */
+typedef struct tRoadSensorObjOut {
+    int		   n;		/**< Number of detected <em>Sensor objects</em>:
+                                 * <b>n</b> < \ref tRoadSensorObjIn::nMax "nMax"
+				 */
+    tRoadSensorObj **sensorObjs;/**< List of pointers to the detected
+                                 * <em>Sensor objects</em>
+				 */
+} tRoadSensorObjOut;
+
+/** Function to get the <em>Sensor objects</em> of specific types that fall
+ *  within a chosen sensor area
+ * \param[in] rsoe Sensor object evaluation handle
+ * \param[in] in Pointer to a struct for the input parameters
+ * \param[out] out Pointer to a struct for the output parameters
+ * \return Number of detected <em>Sensor objects</em>
+ */
+int    RoadGetSensorObjs(tRoadSensorObjEval *rsoe,
+                                tRoadSensorObjIn *in, tRoadSensorObjOut *out);
+
+
+
+/***   Road limiter evaluation: Tunnel or Traffic barrier   *******************/
+
+//! Limiter evaluation: input
+/** Struct for the input parameters of RoadLimEval()
+ */
+typedef struct tRoadLimIn {
+    double xyz[3];	/**< Given position in the global IPGRoad
+			 * coordinate system (Fr0)\note
+			 * An estimation of the z-coordinate is given in order
+			 * to simplify the evaluation (if no reasonable
+			 * estimation is known, initialize the z-coordinate with
+		         * zero).
+			 */
+    double dir[2];	/**< Longitudinal unit vector at \ref tRoadLimIn::xyz
+			 * "xyz":\n
+                         * Unit vector in viewing direction
+                         * \note This vector is used to determine whether the
+                         *  results should be calculated in or counter link
+                         * direction.
+                         */
+} tRoadLimIn;
+//! Limiter evaluation: output
+/** Struct for the output parameters of RoadLimEval()
+ */
+typedef struct tRoadLimOut {
+    double st[2]; 	/**< Calculated position in the <em>Link's</em> local
+                         * coordinate system
+			 */
+    double lim[2];	/**< Distance to the limiters at the left/right side
+                         * in meters\note
+                         * The road can be limited by a <em>Tunnel</em> or by
+                         * <em>Traffic barriers</em>.
+                         * \note The terms "left" and "right" refer to the
+                         *  direction specified by the \ref tRoadLimIn::dir
+                         *  "viewing direction", which can be either in or
+                         *  counter link direction. 
+			 */
+    double suv[2];	/**< Longitudinal unit vector at \ref tRoadLimIn::xyz
+			 * "xyz":\n
+			 * Unit vector \ref tRoadLimIn::dir "in or counter"
+                         * s-direction of the <em>Link</em>
+			 */
+    double tuv[2];	/**< Lateral unit vector at \ref tRoadLimIn::xyz
+			 * "xyz":\n
+			 * Unit vector \ref tRoadLimIn::dir "in or counter"
+                         * t-direction of the <em>Link</em>
+			 */
+    tObjId limObjId[2];	/**< Object ids of the limiters on the left/right
+                         * side:\note
+                         * The road can be limited by a <em>Tunnel</em> or by
+                         * <em>Traffic barriers</em>.
+                         * \note The terms "left" and "right" refer to the
+                         *  direction specified by the \ref tRoadLimIn::dir
+                         *  "viewing direction", which can be either in or
+                         *  counter link direction. 
+                         */
+} tRoadLimOut;
+
+/** Function to evaluate the limiters of a <em>Link</em> at a certain position
+ *  \note The road can be limited by a <em>Tunnel</em> or by <em>Traffic
+ *  barriers</em>.
+ * \param[in,out] re Evaluation handle of the road instance
+ * \param[in] in Pointer to a struct for the input parameters
+ * \param[out] out Pointer to a struct for the output parameters
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadLimEval(tRoadEval *re, tRoadLimIn *in, tRoadLimOut *out);
+
+
+
+/***   Traffic Sign evaluation   **********************************************/
+
+
+/** Maximum number of <em>Traffic signs</em>:\n
+ *  At most forty <em>Traffic signs</em> can be evaluated.
+ */
+#define ROAD_MAX_TRFSIGNS          40
+/** Maximum length of \ref tRoadSign::sign "traffic sign keys":\n
+ *  The key of a traffic sign type can be at most thirty-two characters long.
+ */
+#define ROAD_MAX_TRFSIGN_KEY_LEN   32
+/** Maximum length of \ref tRoadSign::attr "traffic signs attributes":\n
+ *  A traffic sign attribute can be at most two hundred and fifty-six characters
+ *  long.
+ */
+#define ROAD_MAX_TRFSIGN_ATTR_LEN 256
+
+
+/** Function retrieving the identifier of a type of <em>Traffic sign</em> from
+ * its key
+ * \param[in] road Handle of the road instance
+ * \param[in] Name Key of the type of <em>Traffic sign</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> identifier of the type of <em>Traffic sign</em>\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetTrfSignTypeId (tRoad *road, const char *Name);
+
+//! Single Traffic sign: detection
+/** Struct used to define a single <em>Traffic sign</em> in the struct 
+ *  tRoadTrfSign
+ */
+typedef struct tRoadSign {
+    char  sign[ROAD_MAX_TRFSIGN_KEY_LEN]; /**< Key of the type of <em>Traffic
+                                           * sign</em>
+                                           */
+    char  attr[ROAD_MAX_TRFSIGN_ATTR_LEN];/**< Attributes communicated to the
+                                           * <em>Traffic Sign Sensor</em>
+                                           */
+    int   signId;                         /**< Identifier for the type of the
+                                           * <em>Traffic sign</em>
+                                           */
+    float val[2];                         /**< Values 0 / 1 displayed on
+                                           * <em>Traffic signs</em> of
+                                           * appropriate \ref tRoadSign::sign
+                                           * "type"
+                                           */
+    char  isTwoSided;                     /**< Flag indicating whether the sign
+                                           * has a texture on both sides:
+                                           * - 0 &harr; The sign is one-sided.
+                                           * - 1 &harr; The sign is two-sided.
+                                           */
+} tRoadSign;
+//! Traffic sign: detection
+/** Struct for the parameters of a <em>Traffic sign</em>
+ * \see RoadGetAllTrfSigns() \see tRoadTrfSignList
+ */
+typedef struct tRoadTrfSign {
+    int       objId;                /**< Object id of the <em>Traffic sign</em>
+                                     */
+    int       isInRouteDir;         /**< Flag indicating the direction validity
+                                     * of the sign:
+                                     * - 0 &harr; counter route direction
+                                     * - 1 &harr; in route direction 
+                                     */
+    double    sRoute;               /**< Offset of the <em>Traffic sign</em> on
+                                     * the <em>Route</em> in meters
+                                     * \note Only available if the <em>Traffic
+                                     *  signs</em> along a given <em>Route</em>
+                                     * are evaluated (see RoadGetAllTrfSigns()).
+                                     */
+    double    pos[3];               /**< Position of the sign's center in the
+                                     * (x,y,z)-coordinates of the global IPGRoad
+                                     * coordinate system (Fr0)
+                                     */
+    double    nuv[3];               /**< Road surface normal unit vector at
+                                     * \ref tRoadTrfSign::pos "pos"
+                                     */
+    double    height;               /**< Height of the sign's center above the
+                                     * ground in meters
+                                     */
+    double    sqrDistSensor2Sign;   /**< Square distance between sign and sensor
+                                     */
+    double    vecSensor2Sign[3];    /**< Vector from sensor to sign
+                                     */
+    float     detectability;        /**< Probability of detection by the
+                                     * <em>Traffic Sign Sensor</em>
+                                     * (range: 0..1)
+                                     */
+    tRoadSign main;                 /**< Main traffic sign
+                                     */
+    tRoadSign suppl1;               /**< First optional supplementary sign
+                                     */
+    tRoadSign suppl2;               /**< Second optional supplementary sign
+                                     */
+} tRoadTrfSign;
+//! Traffic sign list: detection
+/** Struct for a list of <em>Traffic signs</em>
+ * \see RoadGetAllTrfSigns()
+ */
+typedef struct tRoadTrfSignList {
+   tRoadTrfSign *ts;		/**< List of <em>Traffic signs</em>
+				 */
+   int		nTS;		/**< Number of the <em>Traffic signs</em> listed
+				 */
+} tRoadTrfSignList;
+
+/** Function to get a certain <em>Traffic sign</em> 
+ * \param[in] road Handle of the road instance
+ * \param[in] tsObjId Object id of the <em>Traffic sign</em>
+ * \param[out] trfSign Pointer to a struct for the parameters of the
+ * <em>Traffic sign</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetAllTrfSigns()
+ */
+int    RoadGetTrfSign(tRoad *road, tObjId tsObjId, tRoadTrfSign  *trfSign);
+/** Function to get all <em>Traffic signs</em> along a given <em>Route</em> or
+ *  all <em>Traffic signs</em> of a given road instance
+ * \param[in] road Handle of the road instance
+ * \param[in] rObjId Object Id of the <em>Route</em>\n
+ *  Special value: <0 &harr; All signs of the road instance are retrieved
+ *  linkwise.
+ * \param[out] tsList Pointer to a struct for the parameters of the detected
+ *  <em>Traffic signs</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Traffic signs</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetAllTrfSigns(tRoad *road, tObjId rObjId, tRoadTrfSignList  *tsList);
+
+/** Function to get the object id of the <em>Controller</em> of a <em>Traffic
+ * light</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] tlObjId Object id of the <em>Traffic light</em>\n
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> Object id of the controller
+ *  <tr><td> In case of failure:
+ *  <td> #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadCtrlGetTrfLights() \see RoadCtrlGetDrvStop()
+ */
+tObjId RoadGetTrfLightCtrl(tRoad *road, tObjId tlObjId);
+
+/** Function to generate and initialize a traffic sign evaluation handle\n
+ *  It is specified which types of <em>Traffic signs</em> are of interest for
+ *  the evaluation executed with the new traffic sign evaluation handle.
+ * \param[in] road Handle of the road instance
+ * \param[in] rObjId Currently unused
+ * \param[in] nSOI Number of sign types of interest
+ * \param[in] soi Array with the identifiers of the sign types of interest
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> traffic sign evaluation handle
+ * <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see RoadDeleteTrfSignEval()
+ */
+tRoadTrfSignEval* RoadGetTrfSignEval   (tRoad *road, tObjId rObjId, int nSOI,
+								      int *soi);
+/** Function to free the memory of a traffic sign evaluation handle
+ * \param[in] rtse Traffic sign evaluation handle that should be deleted
+ * \see RoadGetTrfSignEval()
+ */
+void              RoadDeleteTrfSignEval(tRoadTrfSignEval *rtse);
+
+//! Traffic sign evaluation: input
+/** Struct for the input parameters of RoadGetTrfSigns()
+ */
+typedef struct tRoadTrfSignsIn {
+    double p[ROAD_MAX_SHAPE_PTS][2];/**< Shape of the two-dimensional sensor
+                                     * area in the (x,y)-plane of the global
+                                     * IPGRoad coordinate system (Fr0)
+                                     */
+    int    nP;			    /**< Number of points used to define the
+                                     * shape of the sensor array
+                                     */
+    double xyz[3];                  /**< Position of the <em>Sensor</em> in the
+                                     * global IPGRoad coordinate system (Fr0)
+                                     */
+} tRoadTrfSignsIn;
+//! Traffic sign evaluation: output
+/** Struct for the output parameters of RoadGetTrfSigns()
+ */
+typedef struct tRoadTrfSignsOut {
+   tRoadTrfSign sign[ROAD_MAX_TRFSIGNS];/**< List of <em>Traffic signs</em>
+                                         */
+   int 		nSigns;                 /**< Number of <em>Traffic signs</em>
+                                         * listed
+                                         */
+} tRoadTrfSignsOut;
+
+/** Function retrieving the <em>Traffic signs</em> that fall within a chosen
+ *  sensor area 
+ * \param[in] rtse Traffic sign evaluation handle
+ * \param[in] in Pointer to a struct for the input parameters
+ * \param[out] out Pointer to a struct for the output parameters
+ * \return Number of found <em>Traffic signs</em>
+ * \see RoadPathGetTrfLights()
+ */
+int    RoadGetTrfSigns (tRoadTrfSignEval *rtse,
+				    tRoadTrfSignsIn *in, tRoadTrfSignsOut *out);
+
+
+
+/***   Traffic light evaluation   *********************************************/
+
+//! Traffic light: detection
+/** Struct for the parameters of an element of the list of <em>Traffic
+ *  lights</em> in tRoadTrfLightList
+ * \see RoadGetAllTrfLights() \see tRoadTrfLightExt
+ * \deprecated <em>Traffic lights</em> are detected using the corresponding
+ * <em>\ref RoadRouteGetAllDrvStops "Stop markers"</em>.
+ */
+typedef struct tRoadTrfLight {
+    char   *name;		/**< Name of the <em>Traffic light
+                                 * controller</em>
+				 */
+    char   *startCond;		/**< Condition to trigger the starting of the
+                                 * <em>Traffic light controller</em>
+                		 */
+    int    objId;		/**< Object id of the <em>Traffic light 
+                                 * controller</em>
+				 */
+    int	   type;		/**< \ref tRoadTLType "Type" of the
+                                 * <em>Traffic light</em>
+				 */
+    int	   facing;		/**< Flag indicating the direction validity
+                                 * of the traffic light:
+                                 * - -1 &harr; counter route direction
+				 * - 1 &harr; in route direction
+				 */
+    int	   consider;		/**< Relevant for the driver:
+                                 * - 0 &harr; not relevant
+				 * - 1 &harr; relevant
+				 */
+    int	   initialPhase;	/**< Integer value for the initial phase of the 
+                                 * <em>Traffic light controller</em>:
+                                 * - 0 &harr; off phase
+                                 * - 1 &harr; green phase
+                                 * - 2 &harr; yellow phase
+                                 * - 3 &harr; red phase
+                                 * - 4 &harr; red+yellow phase
+				 */
+    double sRoute;		/**< Offset of the <em>Traffic light's</em> stop
+                                 * line on the <em>Route</em> in meters:\n The
+                                 * stop line is internally defined two meters
+                                 * in front of the traffic light and not
+                                 * visualized.
+                                 * \note Only available if the <em>Traffic
+                                 *  lights</em> along a given <em>Route</em> are
+                                 *  evaluated (see RoadGetAllTrfLights()).
+				 */
+    double xyz[3];		/**< Position of the traffic light's center in
+                                 * the global IPGRoad coordinate system (Fr0)
+				 */
+    double timing[ROAD_NUM_TL_TIMING]; /**< Duration of the different phases in
+                                 * seconds: 
+                                 * - 0 &harr; off phase
+                                 * - 1 &harr; green phase
+                                 * - 2 &harr; yellow phase
+                                 * - 3 &harr; red phase
+                                 * - 4 &harr; red+yellow phase
+                                 */
+} tRoadTrfLight;
+//! Traffic light list: detection
+/** Struct for a list of <em>Traffic lights</em>
+ * \see RoadGetAllTrfLights() \see tRoadTrfLightExtList
+ * \deprecated <em>Traffic lights</em> are detected using the corresponding
+ * <em>\ref RoadRouteGetAllDrvStops "Stop markers"</em>.
+ */
+typedef struct tRoadTrfLightList {
+   tRoadTrfLight *tl;		/**< List of <em>Traffic lights</em>
+				 */
+   int		 nTL;		/**< Number of the <em>Traffic lights</em>
+                                 * listed
+				 */
+} tRoadTrfLightList;
+
+/** Function to get all <em>Traffic lights</em> along a given <em>Route</em> or
+ *  all <em>Traffic lights</em> of a given road instance. This function will 
+ *  only deliver <em>Traffic lights</em> connected to a valid <em> Traffic 
+ *  light controller</em>\n
+ * The <em>Route</em> is identified by its internal identifier.
+ * \param[in] road Handle of the road instance
+ * \param[in] routeId Identifier of the <em>Route</em>\n
+ *  Special value: <0 &harr; All traffic lights of the road instance are
+ *  retrieved linkwise.
+ * \param[out] tlList Pointer to a struct for the parameters of the detected
+ *  <em>Traffic lights</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Traffic lights</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \deprecated Use RoadCtrlGetAllCtrlTL() and RoadCtrlGetTrfLights() to get all
+ *  <em>Traffic lights</em> of a given road instance. Moreover, the function
+ *  RoadRouteGetAllDrvStops() might be a good replacement.
+ */
+int    RoadGetAllTrfLights       (tRoad *road, int routeId,
+                                                     tRoadTrfLightList *tlList);
+//! Traffic light evaluation: input
+/** Struct for the input parameters of RoadPathGetTrfLights()
+ */
+typedef struct tRoadPathTrfLightIn {
+    tObjId *objId;	/**< List of the object ids of all <em>Paths</em>
+                         * belonging to the <em>Driving path</em> starting with
+                         * the current <em>Path</em>
+                         * \note The last entry has to be a negative value.
+			 */
+    double sOnRef;	/**< Offset in s-direction on the <em>Reference
+                         * line</em> relative to the current <em>Path's</em>
+                         * start where the search for <em>Traffic lights</em> is
+                         * started
+			 */
+    double range;	/**< Range in s-direction on the <em>Reference
+                         * lines</em> along the <em>Paths</em> where it is
+                         * searched for <em>Traffic lights</em>
+			 */
+} tRoadPathTrfLightIn;
+//! Traffic light evaluation: output
+/** Struct for the output parameters of RoadPathGetTrfLights()
+ */
+typedef struct tRoadPathTrfLightOut {
+    tObjId objId;		/**< Object id of the <em>Traffic light</em>
+				 */
+    double sOnRefOff;		/**< Offset of the <em>Traffic light's</em>
+                                 * stop line in s-direction on the <em>Reference
+                                 * line</em> along the <em>Paths</em> relative
+                                 * to the \ref tRoadPathTrfLightIn::sOnRef
+                                 * "input offset":\n The stop line is internally
+                                 * defined two meters in front of the traffic
+                                 * light and not visualized.
+				 */
+} tRoadPathTrfLightOut;
+
+/** Function retrieving the <em>Traffic lights</em> of the <em>Paths</em> of a
+ *  certain <em>Driving path</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] in Pointer to a struct for the input parameters
+ * \param[out] out Array of structs for the parameters of the three next
+ *  <em>Traffic lights</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of found <em>Traffic lights</em> (at most three)
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetTrfSigns() \see RoadPathGetDrvStops() \see RoadPathGetSpeed()
+ */
+int    RoadPathGetTrfLights(tRoad *road,
+			  tRoadPathTrfLightIn *in, tRoadPathTrfLightOut out[3]);
+
+
+
+/** @} */
+/** \addtogroup MarkersEval
+ * @{
+ */
+/***   Stop marker evaluation   ***********************************************/
+
+//! Stop marker evaluation: input
+/** Struct for the input parameters of \ref RoadPathGetDrvStops() and 
+ *  \ref RoadRouteGetDrvStops()
+ */
+typedef struct tRoadDrvStopIn {
+    tObjId *objId;	/**< List of objects belonging to the <em>Driving
+                         * path</em>:
+                         * - \ref RoadPathGetDrvStops(): List of the object ids
+                         * of all <em>Paths</em> belonging to the <em>Driving
+                         * path</em> starting with the current <em>Path</em>.
+                         * The last entry has to be a negative value.
+                         * - \ref RoadRouteGetDrvStops(): The first element of
+                         * the list, which is the only one read, must be the
+                         * object id of the <em>Route</em>.
+			 */
+    int mask;           /**< Mask for the types of <em>Stop markers</em>
+                         * evaluated:\n
+                         * The binary system is used to generate combinations of
+			 * the types #RDST_Stop, #RDST_GiveWay, #RDST_TrfLight,
+                         * #RDST_Junction and #RDST_Unknown.
+			 */
+    double s;           /**< Offset in s-direction
+                         * - \ref RoadPathGetDrvStops(): Offset in s-direction
+                         * on the <em>Reference line</em> relative to the
+                         * current <em>Path's</em> start where the search for
+                         * <em>Stop markers</em> is started
+                         * - \ref RoadRouteGetDrvStops(): Offset in s-direction
+                         * on the <em>Route</em>
+			 */
+    double range;	/**< Range in s-direction on the <em>Reference
+                         * lines</em> along the <em>Paths</em> where it is
+                         * searched for <em>Stop markers</em>
+			 */
+} tRoadDrvStopIn;
+//! Stop marker evaluation: output
+/** Struct for the output parameters of \ref RoadPathGetDrvStops() and
+ *  \ref RoadRouteGetDrvStops() and an element of the list of <em>Stop
+ *  markers</em> in tRoadDrvStopOutList
+ * \see RoadRouteGetAllDrvStops()
+ */
+typedef struct tRoadDrvStopOut {
+    tObjId objId;		/**< Object id of the <em>Stop marker</em>
+				 */
+    tObjId ctrlObjId;           /**< Object id of a <em>Traffic light
+                                 *  controller</em> regulating the functionality
+                                 *  of the <em>Marker</em> if available
+                                 */
+    double s;                   /**< Offset of the <em>Stop marker</em>
+                                 * in s-direction on the <em>Reference
+                                 * line</em> along the <em>Paths</em> relative
+                                 * to the \ref tRoadDrvStopIn::s "input offset"
+				 */
+} tRoadDrvStopOut;
+
+//! Stop marker evaluation: output
+/** Struct for the output parameters of \ref RoadRouteGetAllDrvStops()
+ */
+typedef struct tRoadDrvStopOutList {
+    tRoadDrvStopOut *stop;  /**< List of <em>Stop markers</em>
+                             */
+    int nStop;              /**< Number of <em>Stop markers</em> found
+                             */
+} tRoadDrvStopOutList;
+
+/** Function retrieving all <em>Stop markers</em> of a <em>Route</em> 
+ * \param[in] road Handle of the road instance
+ * \param[in] routeObjId Object id of the <em>Route</em> 
+ * \param[in] mask Mask for the types of <em>Stop markers</em> evaluated:\n
+ * The binary system is used to generate combinations of the types #RDST_Stop,
+ * #RDST_GiveWay, #RDST_TrfLight, #RDST_Junction and #RDST_Unknown.
+ * \param[out] out Pointer to a struct for the output parameters
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of found <em>Stop markers</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadRouteGetDrvStops()
+*/
+int    RoadRouteGetAllDrvStops(tRoad *road, tObjId routeObjId, int mask,
+                                                      tRoadDrvStopOutList *out);
+ /** Function retrieving the next three <em>Stop markers</em> of a
+ * <em>Route</em> 
+ * \param[in] road Handle of the road instance
+ * \param[in] in Pointer to a struct for the input parameters
+ * \param[out] out Array of structs for the parameters of the three next
+ *  <em>Stop markers</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of found <em>Stop markers</em> (at most three)
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadPathGetDrvStops() \see RoadRouteGetAllDrvStops()
+ */                                                     
+int    RoadRouteGetDrvStops(tRoad *road, tRoadDrvStopIn *in, 
+                                                        tRoadDrvStopOut out[3]);
+/** Function retrieving the next three <em>Stop markers</em> of the
+ *  <em>Paths</em> of a given <em>Driving path</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] in Pointer to a struct for the input parameters
+ * \param[out] out Array of structs for the parameters of the three next
+ *  <em>Stop markers</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of found <em>Stop markers</em> (at most three)
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadRouteGetDrvStops() \see RoadPathGetTrfLights()
+ */                                                     
+int    RoadPathGetDrvStops (tRoad *road, tRoadDrvStopIn *in, 
+                                                        tRoadDrvStopOut out[3]);
+
+
+
+/** @} */
+/** \addtogroup ControllersEval
+ * @{
+ */
+/***   Control object evaluation   ********************************************/
+
+//! Traffic light controller: detection
+/** Struct for the parameters of an element of the list of <em>Traffic light
+ * controllers</em> in tRoadCtrlTLList
+ * \see RoadCtrlGetAllCtrlTL()
+ */
+typedef struct tRoadCtrlTL {
+    char   *name;		/**< Name of the <em>Traffic light
+                                 * controller</em>
+				 */
+    char   *startCond;		/**< Condition to trigger the starting of the
+                                 * <em>Traffic light controller</em>
+                		 */
+    int    objId;		/**< Object id of the <em>Traffic light
+                                 * controller</em>
+				 */
+    int	   type;		/**< \ref tRoadTLType "Type" of the
+                                 * <em>Traffic light</em>
+                                 * \deprecated Is always set to #RTLT_Unknown.
+				 */
+    int	   initialPhase;	/**< Integer value for the initial phase of the 
+                                 * <em>Traffic light controller</em>:
+                                 * - 0 &harr; off phase
+                                 * - 1 &harr; green phase
+                                 * - 2 &harr; yellow phase
+                                 * - 3 &harr; red phase
+                                 * - 4 &harr; red+yellow phase
+				 */
+    double timing[ROAD_NUM_TL_TIMING]; /**< Duration of the different phases in
+                                 * seconds: 
+                                 * - 0 &harr; off phase
+                                 * - 1 &harr; green phase
+                                 * - 2 &harr; yellow phase
+                                 * - 3 &harr; red phase
+                                 * - 4 &harr; red+yellow phase
+                                 */
+} tRoadCtrlTL;
+//! Traffic light controller list: detection
+/** Struct for a list of <em>Traffic light controllers</em>
+ * \see RoadCtrlGetAllCtrlTL()
+ */
+typedef struct tRoadCtrlTLList {
+    tRoadCtrlTL *ctrlTL;    /**< List of <em>Traffic light controllers</em>
+                            */
+    int         nCtrlTL;    /**< Number of the <em>Traffic light
+                             * controllers</em> listed
+                             */
+} tRoadCtrlTLList;
+
+ /** Function retrieving all <em>Traffic light controllers</em>
+ * \param[in] road Handle of the road instance
+ * \param[out] ctrlTLList Pointer to a struct for the output parameters
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of found <em>Traffic light controllers</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */   
+int    RoadCtrlGetAllCtrlTL(tRoad *road, tRoadCtrlTLList *ctrlTLList);
+
+/** Function to get the object ids of all control objects of a road instance
+ * \param[in] road Handle of the road instance
+ * \param[out] objIds Pointer to an array for the object ids of the
+ *  control objects
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of control objects
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadCtrlGetCtrlObjIds(tRoad *road, tObjId **objIds);
+
+//! Traffic light: detection
+/** Struct for the parameters of an element of the list of <em>Traffic
+ *  lights</em> in tRoadTLList
+ * \see \ref RoadCtrlGetTrfLights()
+ */
+typedef struct tRoadTL {
+    double xyz[3];          /**< Position of the <em>Traffic light's</em> center
+                             * in the global IPGRoad coordinate system (Fr0)
+                             */         
+    double nuv[3];          /**< Normal vector of the <em>Traffic light's</em>
+                             * center in the global IPGRoad coordinate system
+                             * (Fr0)
+                             */
+    int type;               /**< \ref tRoadTLType "Type" of the 
+                             * <em>Traffic light</em>
+                             */              
+    tObjId objId;           /**< Object id of the <em>Traffic light</em>
+                             */
+} tRoadTL;
+//! Traffic light list: detection
+/** Struct for a list of <em>Traffic lights</em>
+ * \see \ref RoadCtrlGetTrfLights()
+ */
+typedef struct tRoadTLList {
+   tRoadTL *tl;             /**< List of <em>Traffic lights</em>
+                             */
+   int	    nTL;            /**< Number of the <em>Traffic lights</em>
+                             * listed
+                             */
+} tRoadTLList;
+
+ /** Function retrieving all <em>Traffic lights </em> of a given <em>Traffic
+  * light controller</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] ctrlTLObjId Object id of the <em>Traffic light controller</em>
+ * \param[out] tlList Pointer to a struct for the output parameters
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of found <em>Traffic lights</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see \ref RoadCtrlGetDrvStop()
+ */ 
+int    RoadCtrlGetTrfLights(tRoad *road, tObjId ctrlTLObjId, tRoadTLList *tlList);
+//! Stop marker: detection
+/** Struct for the parameters of an element of the list of 
+ * <em>Stop markers</em> in tRoadDrvStopList
+ * \see RoadCtrlGetDrvStop()
+ */
+typedef struct tRoadDrvStop {
+    tObjId objId;       /**< Object id of the <em>Stop marker</em>
+                         */
+} tRoadDrvStop;
+//! Stop marker list: detection
+/** Struct for a list of <em>Stop markers</em>
+ * \see RoadCtrlGetDrvStop()
+ */
+typedef struct tRoadDrvStopList {
+   tRoadDrvStop *stop;  /**< List of <em>Stop markers</em>
+			 */
+   int	    nStop;	/**< Number of the <em>Stop markers</em>
+                         * listed
+                         */
+} tRoadDrvStopList;
+
+/** Function retrieving all <em>Stop markers</em> of a given <em>Traffic light
+ *  controller</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] ctrlTLObjId Object id of the <em>Traffic light controller</em>
+ * \param[out] stopList Pointer to a struct for the output parameters
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of found <em>Stop markers</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see \ref RoadCtrlGetTrfLights()
+ */   
+int    RoadCtrlGetDrvStop(tRoad *road, tObjId ctrlTLObjId, 
+                                                    tRoadDrvStopList *stopList);
+
+
+
+/** @} */
+/** \addtogroup SOEval
+ * @{
+ */
+/***   Track evaluation   *****************************************************/
+
+
+/*** Options for the length of a track ***/
+
+/** Offset on the track: \n
+ *  The length of a track is defined as its real length.
+ */
+#define ROAD_S_ON_TRACK   0
+/** Offset on the <em>Reference line</em>:\n
+ *  The length of a track is defined as its projection on the <em>Reference
+ *  line</em>. This is allowed only if the line is \ref RLK_Offset
+ *  "parallel to its lateral reference".
+ *  \warning Not yet supported!
+ */
+#define ROAD_S_ON_REFLINE 1
+
+/** Function to get the total length of the track of a <em>Road Marking</em> or
+ *  <em>Traffic barrier</em> and the number and the lengths of the trajectories
+ *  forming the track
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the <em>Road Marking</em> or <em>Traffic
+ *  barrier</em>
+ * \param[in] respect Option for the length: \ref ROAD_S_ON_REFLINE 
+ *  "offset on track" (\ref ROAD_S_ON_TRACK "offset on Reference line" is not
+ *  yet supported)
+ * \param[out] trackLen Length of the track considering <b>respect</b> in meters
+ * \param[out] n Number of trajectories forming the track
+ * \param[out] len Pointer to an array for the lengths of the trajectories
+ *  forming the track
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetTrackList(tRoad *road, tObjId objId, int respect,
+					double *trackLen, int *n, double **len);
+
+
+/** Maximum number of track points:\n
+ *  At most two hundred track points are considered for the detection of 
+ *  <em>Road markings</em> and <em>Traffic barriers</em>.
+ */
+#define ROAD_MAX_TRACK_PTS 200
+/** Maximum number of tracks:\n
+ *  At most twenty-five tracks are considered for the detection of <em>Road
+ *  markings</em> and <em>Traffic barriers</em>.
+ */
+#define ROAD_MAX_TRACKS     25
+
+
+/** <em>Road markings</em> and <em>Traffic barriers</em>:\n
+ *  Flag indicating that all <em>Road markings</em> and <em>Traffic
+ *  barriers</em> should be considered.
+ *  \see RoadNewTrackEval() \see RoadNewTrackEvalExt()
+ */
+#define ROAD_TD_ALL		    0
+/** <em>Road markings</em>:\n
+ *  Flag indicating that all <em>Road markings</em> should be considered.
+ *  \see RoadNewTrackEval() \see RoadNewTrackEvalExt()
+ */
+#define ROAD_TD_MARKINGS	(1<<0)
+/** <em>Traffic barriers</em>:\n
+ *  Flag indicating that all <em>Traffic barriers</em> should be considered.
+ *  \see RoadNewTrackEval() \see RoadNewTrackEvalExt()
+ */
+#define ROAD_TD_BARRIERS	(1<<1)
+
+
+/** Line types:\n
+ *  There are various types of lines that can be used to describe a <em>Road
+ *  marking</em>.
+ */
+typedef enum tRoadLineType {
+    RLT_UnknownLine = 0,	/**< <b>0</b> &nbsp; Unknown line type
+				 */
+    RLT_Line,			/**< <b>1</b> &nbsp; Single line
+				 */
+    RLT_LineDshd,		/**< <b>2</b> &nbsp; Broken line
+				 */
+    RLT_LineSqrDot,		/**< <b>3</b> &nbsp; Dotted line
+				 */
+    RLT_DblLine,		/**< <b>4</b> &nbsp; Double line
+				 */
+    RLT_DblLineDshd,		/**< <b>5</b> &nbsp; Double broken line
+				 */
+    RLT_DblLineSqrDot,		/**< <b>6</b> &nbsp; Double dotted line
+				 */
+    RLT_DblLineDshdL,		/**< <b>7</b> &nbsp; Left-broken double line
+				 */
+    RLT_DblLineDshdR,		/**< <b>8</b> &nbsp; Right-broken double line
+				 */
+    RLT_DblLineSqrDotL,		/**< <b>9</b> &nbsp; Left-dotted double line
+				 */
+    RLT_DblLineSqrDotR,		/**< <b>10</b> &nbsp; Right-dotted double line
+				 */
+    RLT_RoadBoundary,		/**< <b>11</b> &nbsp; Internal use only
+				 */
+    RLT_GuardRail,		/**< <b>12</b> &nbsp; Internal use only
+				 */
+    RLT_Max			/**< <b>13</b> &nbsp; Number of line types
+				 */
+} tRoadLineType;
+
+
+/** Function to generate and initialize a new track evaluation handle\n
+ *  It is specified whether <em>Road markings</em> and <em>Traffic barriers</em>
+ *  are of interest for the evaluation executed with the new track evaluation
+ *  handle. Moreover, the radius of a circle enclosing the sensor area and the
+ *  step size of the track points is set.
+ *  \note This function prepares the detection of tracks: To simplify the
+ *   evaluation, a circle enclosing the sensor area is defined.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] rObjId Currently unused
+ * \param[in] ds Sampling distance of the track points in meters
+ * \param[in] radius Radius of the circle around the vehicle where tracks are
+ *  detected\n The radius is restricted by the step size <b>ds</b>: It is set to
+ *  0.5*<b>ds</b>*#ROAD_MAX_TRACK_PTS in case it exceeds this value.
+ * \param[in] mask Mask for the types of tracks that should be detected:\n
+ *  #ROAD_TD_MARKINGS, #ROAD_TD_BARRIERS or #ROAD_TD_ALL
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> pointer to the new track evaluation handle
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see RoadNewTrackEvalExt() \see RoadDeleteTrackEval()
+ */
+tRoadTrackEval* RoadNewTrackEval   (tRoad *road, tObjId rObjId, double ds,
+		    double radius, int mask);
+/** Function to generate and initialize a new track evaluation handle\n
+ *  It is specified whether <em>Road markings</em> and <em>Traffic barriers</em>
+ *  are of interest for the evaluation executed with the new track evaluation
+ *  handle. Moreover, the radius of a circle enclosing the sensor area and the
+ *  step size of the track points is set.\n
+ *  <em><b>Extended version:</b></em> Instead of using the macros, the
+ *  \ref ROAD_MAX_TRACKS "maximum number of tracks" considered by the
+ *  evaluation handle and the \ref ROAD_MAX_SHAPE_PTS
+ *  "maximum number of shape points" used to define the sensor area can be set
+ *  individually.
+ *  \note This function prepares the detection of tracks: To simplify the
+ *   evaluation, a circle enclosing the sensor area is defined.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] rObjId Currently unused
+ * \param[in] ds Sampling distance of the track points in meters
+ * \param[in] radius Radius of the circle around the vehicle where tracks are
+ *  detected\n The radius is restricted by the step size <b>ds</b>: It is set to
+ *  0.5*<b>ds</b>*#ROAD_MAX_TRACK_PTS in case it exceeds this value.
+ * \param[in] mask Mask for the types of tracks that should be detected:\n
+ *  #ROAD_TD_MARKINGS, #ROAD_TD_BARRIERS or #ROAD_TD_ALL
+ * \param[in] maxTracks Maximum number of tracks considered
+ * \param[in] maxShapePoints Maximum number of shape points allowed
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> pointer to the new track evaluation handle
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see RoadNewTrackEval() \see RoadDeleteTrackEval()
+ */
+tRoadTrackEval* RoadNewTrackEvalExt(tRoad *road, tObjId rObjId, double ds,
+		    double radius, int mask, int maxTracks, int maxShapePoints);
+/** Function to free the memory of a track evaluation handle
+ * \param[in] rte Track evaluation handle that should be deleted
+ * \see RoadNewTrackEval()
+ */
+void            RoadDeleteTrackEval(tRoadTrackEval *rte);
+
+//! Track evaluation: input
+/** Struct for the input parameters of RoadEvalTrack()
+ */
+typedef struct tRoadTrackIn {
+    double s;		/**< Offset of the given position on the track in meters
+			 */
+    double estZ;	/**< Estimated z-coordinate of the given position
+			 */
+    tObjId objId;	/**< Object id of the <em>Road marking</em> or
+                         * <em>Traffic barrier</em>
+			 */
+    int    id;		/**< Internal identifier of the trajectory the given
+                         * position is on
+                         * \note In case the wrong identifier is handed over, 
+                         *  the correct trajectory is determined and used.
+			 */
+    int    respect;	/**< Reference for the length of the track:
+                         * \ref ROAD_S_ON_TRACK "offset on track"
+                         * (\ref ROAD_S_ON_REFLINE
+                         * "offset on the Reference line" is not yet supported)
+			 */
+} tRoadTrackIn;
+//! Track evaluation: output
+/** Struct for the output parameters of RoadEvalTrack()
+ */
+typedef struct tRoadTrackOut {
+    double xyz[3];	/**< Calculated position in the global IPGRoad
+			 * coordinate system (Fr0)
+			 */
+    double nuv[3];	/**< Road surface normal unit vector at
+                         *  \ref tRoadTrackOut::xyz "xyz"
+			 */
+    double suv[3];	/**< Longitudinal unit vector at \ref tRoadTrackOut::xyz
+                         * "xyz":\n
+			 * Unit vector in s-direction of the track
+			 */
+    double tuv[3];	/**< Lateral unit vector at \ref tRoadTrackOut::xyz
+                         * "xyz":\n
+			 * Unit vector in t-direction of the track
+			 */
+    double curvature;	/**< Curvature of the track in the (x,y)-plane in
+                         * \ref tRoadTrackOut::xyz "xyz"
+			 */
+} tRoadTrackOut;
+
+/** Function to evaluate a track
+ * \note This function is used to prepare the visualization of a track.
+ * \param[in,out] re Evaluation handle of the road instance
+ * \param[in] in Pointer to a struct for the input parameters
+ * \param[out] out Pointer to a struct for the output parameters
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadEvalTrack(tRoadEval *re, tRoadTrackIn *in, tRoadTrackOut *out);
+
+//! Track: detection
+/** Struct used to describe the tracks in tRoadTracksOut and tRoadTracksOutExt
+ */
+typedef struct tRoadTrack {
+	double    p[ROAD_MAX_TRACK_PTS][3];/**< Point list of 3D track points
+                                         * with respect to the global
+                                         * coordinate system (Fr0)
+					 */
+	int       nP;			/**< Number of track points
+					 */
+	int	  id;			/**< Object id of the <em>Road
+                                         * Marking</em>, <em>Traffic
+                                         * barrier</em> or <em>Connected
+                                         * trajectory list</em> the track
+                                         * belongs to
+					 */
+	float     width;		/**< Width of the <em>Road marking</em>
+                                         * or <em>Traffic barrier</em> in meters
+					 */
+	float     height;		/**< Height of the <em>Road marking</em>
+                                         * or <em>Traffic barrier</em> in meters
+					 */
+	tRoadLineType type;		/**< Type of line
+					 */
+	int       colorCode;		/**< User definable id for the track
+					 */
+	int	  isOnRoute;		/**< Unused
+					 */
+} tRoadTrack;
+
+//! Tracks evaluation: input
+/** Struct for the input parameters of RoadGetTracks()\n
+ *  The difference between this struct and tRoadTracksInExt is that the member
+ *  \ref tRoadTracksIn::p "p" is an array of fixed size, not a pointer.
+ */
+typedef struct tRoadTracksIn {
+    double p[ROAD_MAX_SHAPE_PTS][2];/**< Shape of the two-dimensional sensor
+                                 * area in the (x,y)-plane of the global IPGRoad
+                                 * coordinate system (Fr0). The shape has to be
+                                 * defined in a clockwise order.
+				 */
+    int    nP;			/**< Number of points defining the shape of the
+                                 * sensor area
+                                 * \note There have to be at least two points.
+				 * If only one point is given, the sensor shape
+                                 * algorithm is switched off and the track
+                                 * point list consists of points in a circle
+                                 * around the vehicle position with a radius
+                                 * given by the radius parameter of the road
+                                 * track eval handle <b>\ref RoadGetTracks
+                                 * "rte"</b>.
+				 */
+    double xyz[3];   		/**< Position of the <em>Sensor</em> in the
+                                 * global IPGRoad coordinate system (Fr0)\note
+				 * This position is used to reduce the expenses
+                                 * of the calculation. If more than one
+                                 * <em>Sensor</em> of a vehicle is evaluated,
+                                 * all of them should be given the same position
+                                 * (e.g. the vehicle position).
+				 */
+} tRoadTracksIn;
+//! Tracks evaluation: output
+/** Struct for the output parameters of RoadGetTracks()\n
+ *  The difference between this struct and tRoadTracksOutExt is that the member
+ *  \ref tRoadTracksOut::track "track" is an array of fixed size and no pointer.
+ */
+typedef struct tRoadTracksOut {
+    tRoadTrack track[ROAD_MAX_TRACKS];/**< List of tracks
+                                     */
+    int        nTracks;             /**< Number of tracks found
+                                     */
+} tRoadTracksOut;
+
+/** Function to get the tracks of specific types that fall within a chosen
+ *  sensor area
+ * \param[in,out] rte Evaluation handle of a track
+ * \param[in] In Pointer to a struct for the input parameters
+ * \param[out] Out Pointer to a struct for the output parameters
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetTracksExt()
+ */
+int    RoadGetTracks   (tRoadTrackEval *rte,
+				  tRoadTracksIn *In,    tRoadTracksOut *Out);
+
+//! Tracks evaluation: input (extended version)
+/** Struct for the input parameters of RoadGetTracksExt() \n
+ *  The difference between this struct and tRoadTracksIn is that the member
+ *  \ref tRoadTracksInExt::p "p" is a pointer.
+ */
+typedef struct tRoadTracksInExt {
+    double (*p)[2];	/**< Shape of the two-dimensional sensor area in the
+                         * (x,y)-plane of the global IPGRoad coordinate system
+                         * (Fr0). The shape has to be defined in a clockwise
+                         * order.
+			 */
+    int    nP;		/**< Number of points defining the shape of the sensor
+                         * area
+                         * \note There have to be at least three points. \n
+                         * If only one point is given, the sensor shape
+                         * algorithm is switched off and the track
+                         * point list consists of points in a circle
+                         * around the vehicle position with a radius
+                         * given by the radius parameter of the road
+                         * track eval handle <b>\ref RoadGetTracks
+                         * "rte"</b>.
+			 */
+    double xyz[3];	/**< Position of the <em>Sensor</em> in the global
+                         * IPGRoad coordinate system (Fr0)\note
+			 * This position is used to reduce the expenses of the
+                         * calculation. If more than one <em>Sensor</em> of a
+                         * vehicle is evaluated, all of them should be given the
+                         * same position (e.g. the vehicle position).
+                         */
+} tRoadTracksInExt;
+//! Tracks evaluation: output (extended version)
+/** Struct for the output parameters of RoadGetTracksExt()\n
+ * The difference between this struct and tRoadTracksOut is that the member 
+ * \ref tRoadTracksOutExt::track "track" is a pointer.
+ */
+typedef struct tRoadTracksOutExt {
+    tRoadTrack 	*track;		/**< List of the tracks
+				 */
+    int 	nTracks;	/**< Number of tracks found
+				 */
+} tRoadTracksOutExt;
+
+/** Function to get the tracks of specific types that fall within a chosen
+ *  sensor area: extended version
+ * \param[in,out] rte Evaluation handle of a track
+ * \param[in] In Pointer to a struct for the input parameters
+ * \param[out] Out Pointer to a struct for the output parameters
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetTracks()
+ */
+int    RoadGetTracksExt(tRoadTrackEval *rte,
+				  tRoadTracksInExt *In, tRoadTracksOutExt *Out);
+
+
+
+/***   Lane limiter evaluation   **********************************************/
+
+//! Lane limiter evaluation: input
+/** Struct for the input parameters of RoadGetLaneLimiter()
+ */
+typedef struct tRoadLaneLimiterIn {
+    double p[ROAD_MAX_SHAPE_PTS][2];/**< Shape of the two-dimensional sensor
+                                 * area in the (x,y)-plane of the global IPGRoad
+                                 * coordinate system (Fr0)
+				 */
+    int    nP;			/**< Number of points defining the shape of the
+                                 * sensor area
+                                 * \note There have to be at least two points.
+				 * If only one point is given, the sensor shape
+                                 * algorithm is switched off and the track
+                                 * point list consists of points in the range
+                                 * from vehicle position + p[0][0] to
+                                 * vehicle position + p[0][1] in moving
+                                 * direction.
+				 */
+    double maxLineDerivation;   /**< Maximum derivation of the track:\n
+                                 * If the derivation of the track exceeds this
+                                 * value, the track evaluation is stopped and
+                                 * only a part of the track is considered.
+                                 * \note Since the track will be described by
+                                 *  a function, the derivation mustn't be too
+                                 *  large.
+				 */
+    double xyz[3];		/**< Position of the <em>Sensor</em> in the
+                                 * global IPGRoad coordinate system (Fr0)
+				 */
+    double vhclXYZ[3];		/**< Vehicle position in the global IPGRoad
+				 * coordinate system (Fr0)
+				 */
+    double vhclRotMat[3][3];	/**< Rotation matrix for the conversion of a
+                                 * position in the vehicle's coordinate system
+                                 * to a position in the global IPGRoad
+                                 * coordinate system (Fr0)
+				 */
+} tRoadLaneLimiterIn;
+//! Limiters of a Lane
+/** Struct used to describe the limiters of the <em>Lanes</em> in
+ *  tRoadLaneLimiter
+ */
+typedef struct tRoadLaneLimiter {
+    double    c[5];  		/**< Coefficients of a fourth-order polynomial
+                                 * representing the detected track in the local
+                                 * coordinate system of the vehicle determined
+                                 * by the given \ref tRoadLaneLimiterIn::vhclXYZ
+                                 * "position" and
+                                 * \ref tRoadLaneLimiterIn::vhclRotMat
+                                 * "rotation":\n
+                                 * The track's course is defined by 
+                                 * &emsp; \f$y(x) = c[0] + c[1]x + c[2]x^2 +
+                                 * c[3]x^3 + c[4]x^4 + c[5]x^5,\f$ &emsp;
+                                 * \f$x\in\f$[\ref tRoadLaneLimiter::x "x"[0],
+                                 * \ref tRoadLaneLimiter::x "x"[2]].
+                                 * \note The graph of this function is split
+                                 *  into two parts that can be described by
+                                 *  third-order polynomials. In case the whole
+                                 *  track can be represented properly by only
+                                 *  one third-order polynomials, there is no
+                                 *  second one.
+				 */
+    double    c1[4]; 		/**< Coefficients of a third-order polynomial
+                                 * representing the first part of the detected
+                                 * \ref tRoadLaneLimiter::c "track"
+				 */
+    double    c2[4];		/**< Coefficients of a third-order polynomial
+                                 * representing the second part of the detected
+                                 * \ref tRoadLaneLimiter::c "track"
+				 */
+    double    x[3];		/**< X-coordinate of the start, split and end
+                                 * point of the track in the local coordinate
+				 * system of the vehicle
+				 */
+    int       n;      		/**< Number of third order polynomials used to
+                                 * represent the track
+                                 * \note Depending on the form of the track this
+                                 *  might be 0, 1 or 2.
+				 */
+    int       id;		/**< Internal identifier 
+				 */
+    float     width;		/**< Width of the <em>Road marking</em> or
+                                 * <em>Traffic barrier</em> in meters
+				 */
+    float     height;		/**< Height of the <em>Road marking</em> or
+                                 * <em>Traffic barrier</em> in meters
+				 */
+    tRoadLineType type;		/**< Type of line
+				 */
+    int       userID;		/**< User definable id for the track
+				 */
+    int	      isOnRoute;	/**< Unused
+				 */
+} tRoadLaneLimiter;
+//! Lane limiter evaluation: output
+/** Struct for the output parameters of RoadGetLaneLimiter()
+ */
+typedef struct tRoadLaneLimiterOut {
+    tRoadLaneLimiter    laneLimiter[ROAD_MAX_TRACKS];/**< List of the limiters
+                                                      * of the <em>Lane</em>
+						      */
+    int                 nLL;			/**< Number of limiters found
+						 */
+} tRoadLaneLimiterOut;
+
+/** Function to evaluate the limiters of a <em>Lane</em>\n
+ *  A <em>Lane</em> can be limited either by a <em>Road marking</em> or by a
+ *  <em>Traffic barrier</em>
+ * \param[in] rte Track evaluation handle
+ * \param[in] In Pointer to a struct for the input parameters
+ * \param[out] Out Pointer to a struct for the output parameters
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetLaneLimiter (tRoadTrackEval *rte, 
+                        tRoadLaneLimiterIn *In, tRoadLaneLimiterOut *Out);
+
+
+/** @} */
+/******************************************************************************/
+/* +++ Paths ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup PathsEval
+ * @{
+ */
+/*** Path types ***/
+
+/** Lane path:\n
+ *  Flag indicating that <em>Paths</em> of type <em>Lane path</em> should be
+ *  considered.
+ * \see RoadPathGetPathObjIdsFromParent()
+ */
+#define ROAD_LPATH   (1<<0)
+/** User path:\n
+ *  Flag indicating that <em>Paths</em> of type <em>User path</em> should be
+ *  considered.
+ * \see RoadPathGetPathObjIdsFromParent()
+ */
+#define ROAD_UPATH   (1<<1)
+/** Connector path:\n
+ *  Flag indicating that <em>Paths</em> of type <em>Connector path</em> should
+ *  be considered.
+ * \see RoadPathGetPathObjIdsFromParent()
+ */
+#define ROAD_CPATH   (1<<2)
+
+
+/** Function to get the object id of the <em>Lane path</em> of a <em>Lane</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] laneObjId Object id of the <em>Lane</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the <em>Lane path</em>
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadPathGetPathObjIdsFromParent()
+ */
+tObjId RoadLaneGetLanePathObjId       (tRoad *road, tObjId laneObjId);
+/** Function to get the object ids of all <em>Paths</em> of a certain type 
+ *  running on a given root object\n
+ *  The root object of an object is always a <em>Link</em> or a
+ *  <em>Junction</em>.
+ * \param[in] road Handle of the road instance
+ * \param[in] parentObjId Object id of the root object
+ * \param[in] mask Mask for the path types that should be considered:\n
+ *  The binary system is used to generate combinations of the macros
+ *  #ROAD_CPATH, #ROAD_UPATH and #ROAD_LPATH.
+ * \param[out] objIds Pointer to an array for the object ids of the
+ *  <em>Paths</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadLaneGetLanePathObjId()
+ */
+int    RoadPathGetPathObjIdsFromParent(tRoad *road, tObjId parentObjId,
+						     int mask, tObjId **objIds);
+/** Function to get the object id of the <em>Reference line</em> a given
+ *  <em>Connector path</em> on a <em>Junction</em> runs along
+ * \param[in] road Handle of the road instance
+ * \param[in] pathObjId Object id of the <em>Connector path</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> Object id of the <em>Reference line</em>
+ *  <tr><td> In case of failure:
+ *  <td> #ROAD_InvalidObjId
+ *  </table>
+ */
+tObjId RoadPathGetTrajectoryRefLine   (tRoad *road, tObjId pathObjId);
+
+
+/*** Vehicle classes ***/
+
+/** Vehicle class car:\n
+ *  Flag indicating that cars are allowed on a <em>Path</em>.
+ *  \see tRoadPath \see tRoadConPath
+ */
+#define ROAD_VC_CAR      (1<<0)
+/** Vehicle class truck:\n
+ *  Flag indicating that trucks are allowed on a <em>Path</em>.
+ *  \see tRoadPath \see tRoadConPath
+ */
+#define ROAD_VC_TRUCK    (1<<1)
+/** Vehicle class bus:\n
+ *  Flag indicating that busses are allowed on a <em>Path</em>.
+ *  \see tRoadPath \see tRoadConPath
+ */
+#define ROAD_VC_BUS      (1<<2)
+/** Vehicle class motorcycle:\n
+ *  Flag indicating that motorcycles are allowed on a <em>Path</em>.
+ *  \see tRoadPath \see tRoadConPath
+ */
+#define ROAD_VC_MCYCLE   (1<<3)
+/** Vehicle class bicycles:\n
+ *  Flag indicating that bicycles are allowed on a <em>Path</em>.
+ *  \see tRoadPath \see tRoadConPath
+ */
+#define ROAD_VC_BICYCLE  (1<<4)
+
+/** All vehicle classes:\n
+ *  Flag indicating that all vehicle classes are allowed on a <em>Path</em>.
+ *  \see tRoadPath \see tRoadConPath
+ */
+#define ROAD_VC_ALL (ROAD_VC_CAR | ROAD_VC_TRUCK | ROAD_VC_BUS | ROAD_VC_MCYCLE | ROAD_VC_BICYCLE)
+
+//! Path IO
+/** Struct for the parameters of a <em>Path</em> merging with or splitting off
+ *  from another <em>Path</em>
+ * \note This struct is READ ONLY!
+ * \see tRoadPathIOList
+ */
+typedef struct tRoadPathIO {
+        tRoadPath *path;	/**< Pointer to a struct with the parameters
+                                 * describing the in- or out-path
+				 */
+        double	  sPath;	/**< Offset on the considered <em>Path</em>
+                                 * where the other <em>\ref tRoadPathIO::path
+                                 *  "Path"</em> enters or leaves it
+				 */
+} tRoadPathIO;
+//! Path IO list
+/** Struct for the parameters of a list of <em>Paths</em> merging with or
+ *  splitting off from another <em>Path</em>
+ * \note This struct is READ ONLY!
+ * \see tRoadPath
+ */
+typedef struct tRoadPathIOList {
+    int		n;		/**< Number of the in- and out-paths listed
+				 */ 
+    tRoadPathIO *list;		/**< List of the in- and out-paths
+				 */ 
+} tRoadPathIOList;
+//! Path
+/** Struct for the parameters of a <em>Path</em>
+ * \note This struct is READ ONLY!
+ * \see RoadGetRoadPathByObjId()
+ */
+struct tRoadPath {
+    double	   lenOnRef;	  /**< Length of the <em>Path's</em> projection
+                                   * on the <em>Reference line</em> in meters
+				   */
+    double	   len;		  /**< Real length of the <em>Path</em>
+                                   * in meters
+				   * \warning Not fully supported yet! If the
+                                   *  <em>Path</em> is defined on a
+                                   * <em>Link</em>, this parameter is simply set
+                                   * to \ref tRoadPath::lenOnRef "lenOnRef".
+				   */
+    double	    wf;		  /**< Weight factor: Attribute for autonomous
+                                   * traffic\n
+            			   * Higher weight factors will result in a
+                                   * higher probability that this <em>Path</em>
+                                   * will be used. A <em>Path</em> with a weight
+                                   * factor < = 0 will not be used by
+                                   * IPGTraffic.
+                                   */
+    double	    pL;		  /**< Probability for a lane change to the
+                                   * left: Attribute for autonomous traffic.
+                                   */ 
+    double	    pR;		  /**< Probability for a lane change to the
+                                   * right: Attribute for autonomous traffic.
+            			   */
+    double	    xyz0[3];	  /**< Position of the start point of the
+                                   * <em>Path</em> in the global IPGRoad
+                                   * coordinate system (Fr0)
+				   */ 
+    double	    xyz1[3];	  /**< Position of the end point of the
+                                   * <em>Path</em> in the global IPGRoad
+                                   * coordinate system (Fr0)
+				   */
+    double	    suv0[2];	  /**< Longitudinal unit vector at the start:\n
+				   * Unit vector in s-direction of the 
+				   * <em>Path</em> in global coordinates
+				   */ 
+    double	    suv1[2];	  /**< Longitudinal unit vector at the end:\n
+				   * Unit vector in s-direction of the 
+				   * <em>Path</em> in global coordinates
+				   */     
+    tObjId	    objId;	  /**< Object id of the <em>Path</em>
+				   */
+    tObjId	    rootObjId;	  /**< Object id of the root object of the
+                                   * <em>Path</em>
+                                   * (<em>Junction</em> or <em>Link</em>)
+				   */
+    int		    inRefDir;	  /**< Flag indicating whether the <em>Path</em>
+                                   * runs in the direction of the <em>Reference
+                                   * line</em>:
+				   * - -1 &harr; counter reference line
+                                   *   direction
+				   * - 1 &harr; in reference line direction
+				   */
+    int		    vhclClass;	  /**< Vehicle classes allowed to use the 
+                                   * <em>Path</em>:\n
+                                   * The binary system is used to generate
+				   * combinations of the vehicle classes
+			           * #ROAD_VC_CAR, #ROAD_VC_TRUCK, #ROAD_VC_BUS,
+				   * #ROAD_VC_MCYCLE and #ROAD_VC_BICYCLE
+				   * (special macro: #ROAD_VC_ALL).
+				   */
+    tRoadObjectType pathType;	  /**< Type of the <em>Path</em>
+				   */ 
+    int		    nDrv;	  /**< Number of drivable and non-drivable
+                                   * sections of the <em>Path</em>
+                                   * \note Only used for <em>Lane paths</em>: In
+                                   * case the width of a <em>Lane</em> falls
+                                   * below its <em>Path width limit</em>, this
+                                   * section of the <em>Lane</em> is marked as
+                                   * non-drivable. For <em>User</em> and
+                                   * <em>Connector paths</em> the parameter is
+                                   * set to 0.
+				   */
+    int		    startsWithDrv;/**< Flag indicating whether the <em>Path</em>
+                                   * starts with a drivable section:
+                                   * - 0 &harr; non-drivable section at the
+                                   * <em>Path's</em> start
+                                   * - 1 &harr; drivable section at the
+                                   * <em>Path's</em> start
+                                   * 
+                                   * \note Only used for <em>Lane paths</em>: In
+                                   * case the width of a <em>Lane</em> falls
+                                   * below its <em>Path width limit</em>, this
+                                   * section of the <em>Lane</em> is marked as
+                                   * non-drivable. For <em>User</em> and
+                                   * <em>Connector paths</em> the parameter is
+                                   * set to -1.
+				   */
+    double	    *sDrv;	  /**< Array with the start offsets of all
+                                   * drivable and non-drivable sections on the
+                                   * <em>Path</em>
+                                   * \note Only used for <em>Lane paths</em>: In
+                                   * case the width of a <em>Lane</em> falls
+                                   * below its <em>Path width limit</em>, this
+                                   * section of the <em>Lane</em> is marked as
+                                   * non-drivable. For <em>User</em> and
+                                   * <em>Connector paths</em> the parameter is
+                                   * set to NULL.
+				   */  
+    tSpline2D	    *pathXY;	  /**< Currently unused:
+                                   * Reserved for future use.
+				   */
+    tRoadPath	    *left;	  /**< Pointer to a struct for the <em>Path</em>
+                                   * left of the considered one 
+				   */ 
+    tRoadPath	    *right;	  /**< Pointer to a struct for the <em>Path</em>
+                                   * right of the considered one 
+				   */ 
+    tRoadPathIOList in;		  /**< List of all <em>Paths</em> merging with
+                                   * the considered <em>Path</em>
+				   */ 
+    tRoadPathIOList out;	  /**< List of all <em>Paths</em> splitting from
+                                   * the considered <em>Path</em>
+				   */ 
+};
+
+/** Function to get a <em>Path</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] pathObjId Object id of the <em>Path</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> pointer to the <em>Path</em>\n
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ */
+tRoadPath *RoadGetRoadPathByObjId(tRoad *road, tObjId pathObjId);
+
+
+/** Function to check whether a given <em>Path</em> runs in or counter link
+ *  direction
+ * \param[in] road Handle of the road instance
+ * \param[in] pathObjId Object id of the <em>Path</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> flag indicating the direction of the <em>Path</em>: <tr><td><td>
+ *  - -1 &harr; counter link direction
+ *  - 1 &harr; in link direction\n
+ *  <tr><td> In case of failure:
+ *  <td> possible error codes: <tr><td><td>
+ *  - 0 &harr; invalid pathObjId or given pathObjId does not belong to a path
+ *  object
+ *  - -151 &harr; using a rd5 file with an old route definition\n
+ *  </table>
+ */
+int    RoadPathGetInLinkDir(tRoad *road, tObjId pathObjId);
+/** Function delivering the distances between a given position on a
+ * <em>Path</em> and the next and the last <em>Junction</em> or <em>Link</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] pathObjId Object id of the <em>Path</em>
+ * \param[in] sPath Offset of the given position on the <em>Path</em>
+ * \param[out] dist2last
+ * - <em>Path</em> on <em>Link</em>: Distance to the last <em>Junction</em> 
+ * - <em>Path</em> on <em>Junction</em>: Distance to the last <em>Link</em>
+ * \param[out] dist2next 
+ * - <em>Path</em> on <em>Link</em>: Distance to the next <em>Junction</em> 
+ * - <em>Path</em> on <em>Junction</em>: Distance to the next <em>Link</em> 
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadPathGetDistances(tRoad *road, tObjId pathObjId,
+			    double sPath, double *dist2last, double *dist2next);
+
+//! Path evaluation: input
+/** Struct for the input parameters of RoadPathGeoEval()\n
+ * \note See \ref tRoadInType "input options".
+ */
+typedef struct tRoadPathIn {
+    double st[2];		/**< Given position in the <em>Path's</em>
+				 * local coordinate system
+				 */ 
+    double xyz[3];		/**< Given position in the global IPGRoad
+				 * coordinate system (Fr0)
+				 */
+    tObjId actObjId;		/**< Object id of the current <em>Path</em>
+				 */ 
+    tObjId nextObjId;		/**< Object id of the next <em>Path</em>
+				 */ 
+} tRoadPathIn;
+//! Path evaluation: output
+/** Struct for the output parameters of RoadPathGeoEval()
+ */
+typedef struct tRoadPathOut {
+    double	    xyz[3];	  /**< Calculated position in the IPGRoad
+				   * coordinate system (Fr0)
+				   */
+    double	    nuv[3];	  /**< Road surface normal unit vector at
+                                   * \ref tRoadPathOut::xyz "xyz"
+				   */
+    double	    suv[3];	  /**< Longitudinal unit vector at
+                                   * \ref tRoadPathOut::xyz "xyz":\n
+				   * Unit vector in s-direction of the
+				   * <em>Path</em>
+				   */
+    double	    tuv[3];	  /**< Lateral unit vector at
+                                   * \ref tRoadPathOut::xyz "xyz":\n
+				   * Unit vector in t-direction of the 
+				   * <em>Path</em>
+				   */
+    double	    st[2];	  /**< Calculated position in the <em>Path's
+				   * </em> local coordinate system
+				   */
+    double	    sOnRef;	  /**< Projection of the \ref tRoadPathOut::st 
+                                   * "s-coordinate" on the <em>Reference line
+                                   * </em>
+				   */
+    double	    pathT;	  /**< Lateral offset from the <em>Reference
+                                   * line</em> at \ref tRoadPathOut::st "s"
+                                   * \note The sign of the variable refers to
+                                   * the <em>Path's</em> direction, not to the
+                                   * direction of the <em>Reference line</em>.
+                                   * \note This parameter is only valid in case
+                                   *  the <em>Path's</em> root object is a
+                                   *  <em>Link</em>.
+				   */
+    double	    pathDT;	  /**< Derivation of the lateral offset from the
+                                   * <em>Reference line</em> with respect to the
+                                   * t-coordinate at \ref tRoadPathOut::st "s"
+                                   * \note This parameter is only valid in case
+                                   *  the <em>Path's</em> root object is a
+                                   *  <em>Link</em>.
+				   */
+    double	    curveXY;	  /**< Curvature of the curve in the (x,y)-plane
+                                   * at \ref tRoadPathIn::xyz "xyz"
+				   */
+    double	    width[2];	  /**< Width of the <em>Path</em> at \ref
+                                   * tRoadPathOut::st "s" left/right in meters\n
+                                   * For <em>Lane paths</em> the width of the
+                                   * associated <em>Lane</em>
+                                   * is divided in half, for <em>Connector</em>
+                                   * or <em>User paths</em> the path width is
+                                   * used.
+                                   * \note There are special values for the
+                                   * width of <em>Connector</em> and <em>User
+                                   * paths</em>:
+                                   * - -2 &harr; The distance to the left/right
+                                   * road border is used (only valid on a
+                                   *  <em>Link</em>).
+                                   * - -1 &harr; The width of the associated
+                                   * <em>Lane</em> is used.
+				   */
+    tRoadPosKind    onRoad;	  /**< Kind of position:\n
+				   * On or (in some extent) off the road
+				   */ 
+/**
+ * \name
+ * The following output variables do not consider <em>Bumps</em>.
+ * @{
+ */
+/* --- The following outputs do not consider Bumps ---------------- */
+    double	    grade;	  /**< Longitudinal gradient at 
+                                   *  \ref tRoadPathOut::xyz "xyz":\n
+                                   * Gradient of the z-coordinate in s-direction
+                                   * of the <em>Path</em>
+                                   * \note <em>Bumps</em> are not considered.
+				   */
+    double	    slope;	  /**< Lateral gradient  at 
+                                   *  \ref tRoadPathOut::xyz "xyz":\n
+                                   * Gradient of the z-coordinate in t-direction
+                                   * of the <em>Path</em>
+                                   * \note <em>Bumps</em> are not considered.
+				   */
+    double	    curveZ;	  /**< Longitudinal z-curvature at 
+                                   *  \ref tRoadPathOut::xyz "xyz":\n
+                                   * Curvature of the curve in the (s,z)-plane
+                                   * (change of \ref tRoadPathOut::grade
+                                   * "grade" in s-direction of the
+                                   * <em>Path</em>)
+                                   * \note <em>Bumps</em> are not considered.
+				   */
+/** @} */
+    
+/* ---------------------------------------------------------------- */
+    double	    fric;	  /**< Friction coefficient at
+                                   * \ref tRoadPathOut::xyz "xyz"\note
+                                   * <em>Bumps</em> are not considered.
+				   */
+    double	    nextDist;	  /**< - <b>xyz</b> on <em>Link</em>:
+                                   * distance to the next junction entry
+                                   *   - <b>xyz</b> on <em>Junction</em>:
+                                   * distance to the next <em>Link</em>
+				   */
+    double	    lastDist;	  /**< - <b>xyz</b> on <em>Link</em>:
+                                   * distance to the last junction entry
+                                   *   - <b>xyz</b> on <em>Junction</em>:
+                                   * distance to the last <em>Link</em>
+				   */
+    int		    onJunction;	  /**< Flag indicating whether
+                                   * \ref tRoadPathOut::xyz "xyz" is on a
+                                   * <em>Link</em> or on a <em>Junction</em>:
+				   * - 0 &harr; <em>Link</em>
+				   * - 1 &harr; <em>Junction</em>\n
+				   */
+    tObjId	    linkObjId;	  /**< - <b>xyz</b> on <em>Link</em>:
+                                   * object id of the current <em>Link</em>
+                                   *   - <b>xyz</b> on <em>Junction</em>:
+                                   * object id of the last <em>Link</em>
+				   */
+    tObjId	    juncObjId;	  /**< - <b>xyz</b> on <em>Link</em>:
+                                   * object id of the last <em>Junction</em>
+                                   *   - <b>xyz</b> on <em>Junction</em>:
+                                   * object id of the current <em>Junction</em>
+				   */
+    tObjId	    nextJuncObjId;/**< Object id of the next <em>Junction</em>
+                                   * \note Set to #ROAD_InvalidObjId if \ref
+                                   *  tRoadPathOut::xyz "xyz" is \ref
+                                   * tRoadPathOut::onJunction "on a Junction".
+                                   */
+    tRoadLaneOutExt lanes;	  /**< Struct with the <em>Lanes</em> defined
+                                   * at the calculated \ref tRoadPathOut::st
+                                   * "s-offset"
+				   */
+    tRoadPath	    *path;	  /**< Pointer to a struct with the parameters
+                                   * of the <em>Path</em>
+				   */
+} tRoadPathOut;
+
+/** Function to evaluate a <em>Path</em>
+ * \param[in,out] re Evaluation handle of the road instance
+ * \param[in] errMsgPre Prefix for the error messages
+ * \param[in] it Input type describing which variables of <b>in</b> are used 
+ * \param[in] in Pointer to a struct for the input parameters
+ * \param[out] out Pointer to a struct for the output parameters
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadPathGeoEval(tRoadEval *re, const char *errMsgPre, tRoadInType it,
+				      const tRoadPathIn *in, tRoadPathOut *out);
+
+//! Path speed evaluation: input
+/** Struct for the input parameters of RoadPathGetSpeed()
+ */
+typedef struct tRoadPathSpeedIn {
+    tObjId *objId;	/**< List of the object ids of all <em>Paths</em>
+                         * belonging to the <em>Driving path</em> starting with
+                         * the current <em>Path</em>
+                         * \note The last entry has to be a negative value.
+			 */
+    double sOnRef;	/**< Offset in s-direction on the <em>Reference 
+                         * line</em> relative to the current
+                         * <em>Path's</em> start where the search for speed
+                         * limits is started
+			 */
+    double range;	/**< Range in s-direction on the <em>Reference lines
+                         * </em> along the <em>Paths</em> where it is searched
+                         * for speed limits
+			 */
+} tRoadPathSpeedIn;
+//! Path speed evaluation: output
+/** Struct for the output parameters of RoadPathGetSpeed()
+ * \see tRoadSpeedOut()
+ */
+typedef struct tRoadPathSpeedOut {
+    double speed;		/**< Speed limit in m/s
+				 */
+    double sOnRefOff;		/**< Offset of the speed limit in s-direction on
+                                 * the <em>Reference lines</em> along the
+                                 * <em>Paths</em> relative to the
+                                 * \ref tRoadPathSpeedIn::sOnRef
+                                 *  "input offset"
+				 */
+} tRoadPathSpeedOut;
+
+/** Function to get the next three speed limits of the <em>Paths</em> of a given
+ *  <em>Driving path</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] in Pointer to a struct for the input parameters
+ * \param[out] out Array of structs for the parameters of the three next speed
+ * sections
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of found speed sections (at most three)
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadRouteGetSpeed() \see RoadPathGetTrfLights()
+ */
+int    RoadPathGetSpeed(tRoad *road,
+			       tRoadPathSpeedIn *in , tRoadPathSpeedOut out[3]);
+
+
+/** Function to get the actual wind speed and angle on a <em>Path</em> at a 
+ *  given offset in s-direction
+ * \param[in] road Handle of the road instance
+ * \param[in] pathObjId Object id of the <em>Path</em>
+ * \param[in] sPath Offset of the given position on the <em>Path</em>
+ * \param[out] wind Pointer to a struct for the parameters of the
+ *  <em>Marker</em> of type <em>Wind</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadPathGetWind (tRoad *road, tObjId pathObjId, double sPath,
+                                                                tRM_Wind *wind);
+
+/** Function to get the actual values of a marker on a <em>Path</em> at a 
+ *  given offset in s-direction. This function works only for markers with a an
+ *  extension, e.g. RMT_DrvSpeed, RMT_EnvWind and UserDefined markers
+ * \param[in] road Handle of the road instance
+ * \param[in] pathObjId Object id of the <em>Path</em>
+ * \param[in] sPath Offset of the given position on the <em>Path</em>
+ * \param[in] type Type of the <em>Marker</em> \see RoadGetMarkerType()
+ * \param[out] valid  Flag indicating if the marker is valid at the position
+ *                    given by <em>sPath</em>  
+ * \param[out] marker Void pointer to a struct for the parameters of the
+ *  <em>Marker</em> depending on the marker type
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadPathGetMarker (tRoad *road, tObjId pathObjId, double sPath, int type,
+                                                      int *valid, void *marker);
+
+
+/** @} */
+/******************************************************************************/
+/* +++ Routes +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup RoutesEval
+ * @{
+ */
+/** Function to get the object id of a certain <em>Route</em> from its internal
+ * identifier
+ * \param[in] road Handle of the road instance
+ * \param[in] routeId Identifier of the <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the <em>Route</em>
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadRouteObjIdGetRouteId()
+ */
+tObjId RoadRouteIdGetRouteObjId(tRoad *road, int routeId);
+/** Function to get the identifier of a certain <em>Route</em> from its object id
+ * \param[in] road Handle of the road instance
+ * \param[in] routeObjId Object id of the <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> identifier of the <em>Route</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadObjIdGetInternalId() \see RoadRouteIdGetRouteObjId()
+ */ 
+int    RoadRouteObjIdGetRouteId(tRoad *road, tObjId routeObjId);
+/** Function to get the object ids of all <em>Routes</em> of a road instance
+ * \param[in] road Handle of the road instance
+ * \param[out] objIds Pointer to an array for the object ids of the
+ *  <em>Routes</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Routes</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadRouteGetRouteObjIds (tRoad *road, tObjId **objIds);
+
+/** Function to get the name of a given <em>Route</em>\n
+ * The <em>Route</em> is identified by its internal identifier.
+ * \param[in] road Handle of the road instance
+ * \param[in] routeId Identifier of the <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> name of the <em>Route</em>
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \deprecated Use RoadRouteGetNameByObjId() to get the name of a given
+ * <em>Route</em>.
+ */
+char*  RoadRouteGetNameById   (tRoad *road, int routeId);
+/** Function to get the name of a given <em>Route</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> name of the <em>Route</em>
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see RoadRouteObjSetName() \see RoadRouteGetObjIdByName()
+ */
+char*  RoadRouteGetNameByObjId(tRoad *road, tObjId rObjId);
+/** Function to get the internal identifier of a certain <em>Route</em> from its
+ *  name
+ * \param[in] road Handle of the road instance
+ * \param[in] name Name of the <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> identifier of the <em>Route</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \deprecated Use RoadRouteGetObjIdByName() to get the object id of a certain
+ * <em>Route</em> from its name.
+ */   
+int    RoadRouteGetIdByName   (tRoad *road, const char *name);
+/** Function to get the object id of a certain <em>Route</em> from its name
+ * \param[in] road Handle of the road instance
+ * \param[in] name Name of the <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the <em>Route</em>
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadRouteObjSetName() \see RoadRouteGetNameByObjId()
+ */
+tObjId RoadRouteGetObjIdByName(tRoad *road, const char *name);
+/** Function to set the name of a <em>Route</em>\n
+ * The <em>Route</em> is identified by its internal identifier.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] routeId Identifier of the <em>Route</em>
+ * \param[in] name Name of the <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \deprecated Use RoadRouteObjSetName() to set the name of a <em>Route</em>.
+ */
+int    RoadRouteSetName       (tRoad *road, int routeId,   const char *name);
+/** Function to set the name of a <em>Route</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \param[in] name Name of the <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadRouteGetNameByObjId()
+ */
+int    RoadRouteObjSetName    (tRoad *road, tObjId rObjId, const char *name);
+
+
+/** Function to get the length of a given <em>Route</em>\n
+ * The <em>Route</em> is identified by its internal identifier.
+ * \param[in] road Handle of the road instance
+ * \param[in] routeId Identifier of the <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> length of the <em>Route</em> in meters
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \deprecated Use RoadRouteObjGetLength() to get the length of a given
+ * <em>Route</em>.
+ */
+double RoadRouteGetLength   (tRoad *road, int routeId);
+/** Function to get the length of a given <em>Route</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> length of the <em>Route</em> in meters
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadRouteGetWidth() \see RoadRouteGetBorderT()
+ */
+double RoadRouteObjGetLength(tRoad *road, tObjId rObjId);
+
+/** Function to get the width at a certain offset of a <em>Route</em>\n
+ *  The <em>Route</em> \ref RoadEvalSetRouteByObjId "stored" in the road
+ *  evaluation handle is used.
+ * \param[in] re Evaluation handle of the instance of the road
+ * \param[in] s Offset given in the <em>Route's</em> coordinate system
+ * \param[out] width Width of the <em>Route</em> or the <em>Path</em> left/right
+ *  at <b>s</b> in meters\n
+ *  Depending on the \ref RoadEvalSetRouteByObjId "output mask" of the road
+ *  evaluation handle either the <em>Route</em> or the <em>Path</em> are used as
+ *  reference:
+ * - <em>Route</em>: The distance between the left/right road border and the
+ * <em>Center line</em> is calculated.\n
+ * <b>Note:</b> Only valid if the given position is not on a Junction.
+ * - <em>Path</em>: For <em>Lane paths</em> the width of the associated
+ * <em>Lane</em> is divided in half, for <em>Connector</em> or <em>User
+ * paths</em> the path width is used.\n
+ * <b>Note:</b> There are special values for the width of <em>Connector</em> and
+ *  <em>User paths</em>:
+ *   - -2 &harr; The distance to the left/right road border is used
+ *  (only valid on a <em>Link</em>).
+ *   - -1 &harr; The width of the associated <em>Lane</em> is used.
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadRouteObjGetLength() \see RoadRouteGetBorderT()
+ */
+int    RoadRouteGetWidth  (tRoadEval *re, double s, double width[2]);
+/** Function to get the lateral offset to the road border at a certain offset
+ *  of a <em>Route</em>\n
+ *  The <em>Route</em> \ref RoadEvalSetRouteByObjId "stored" in the road
+ *  evaluation handle is used.
+ * \param[in] re Evaluation handle of the instance of the road
+ * \param[in] s Offset given in the <em>Route's</em> coordinate system
+ * \param[out] t Lateral offset of the left/right road border from the
+ *  <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadRouteObjGetLength() \see RoadRouteGetWidth()
+ */
+int    RoadRouteGetBorderT(tRoadEval *re, double s, double t[2]);
+
+/** Function to check whether a given <em>Route</em> is closed and in that case
+ *  get the loop's start offset and length\n
+ *  The <em>Route</em> is identified by its internal identifier.
+ * \param[in] road Handle of the road instance
+ * \param[in] routeId Identifier of the <em>Route</em>
+ * \param[out] start Start of the loop
+ * \param[out] length Length of the loop
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> flag indicating whether the <em>Route</em> is closed:
+ *  <tr><td><td>
+ *  - 0 &harr; The <em>Route</em> is not closed.
+ *  - 1 &harr; The <em>Route</em> is closed.
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \deprecated Use RoadRouteObjClosed() to check whether a given <em>Route</em>
+ * is closed.
+ */
+int    RoadRouteClosed   (tRoad *road, int routeId,  double *start,
+								double *length);
+/** Function to check whether a given <em>Route</em> is closed and in that case
+ *  get the loop's start offset and length
+ * \param[in] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \param[out] start Start of the loop
+ * \param[out] length Length of the loop
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> flag indicating whether the <em>Route</em> is closed:
+ *  <tr><td><td>
+ *  - 0 &harr; The <em>Route</em> is not closed.
+ *  - 1 &harr; The <em>Route</em> is closed.
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadRouteObjClosed(tRoad *road, tObjId rObjId, double *start,
+								double *length);
+
+/** Function to get the object id of the <em>Driving path</em> corresponding to
+ *  a given <em>Route</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] routeObjId Object id of the <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the <em>Driving path</em>
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ */
+tObjId RoadRouteGetDrvPathObjId(tRoad *road, tObjId routeObjId);
+/** Function to get a list of the <em>Paths</em> belonging to a given driving
+ *  path
+ * \param[in] road Handle of the road instance
+ * \param[in] drvPathObjId Object id of the <em>Driving path</em>
+ * \param[out] objIds Pointer to an array for the object ids of the
+ *  <em>Paths</em>
+ * \param[out] s0 Pointer to an array for the offsets on the <em>Paths</em>
+ *  where they become part of the <em>Driving path</em>
+ * \param[out] s1 Pointer to an array for the offsets on the <em>Paths</em>
+ *  where they cease to be part of the <em>Driving path</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Paths</em> belonging to the <em>Driving path</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadDrvPathGetPathList  (tRoad *road, tObjId drvPathObjId,
+				     tObjId **objIds, double **s0, double **s1);
+
+/** Function to get the number of <em>Links</em> a given <em>Route</em> runs
+ *  along\n
+ * The <em>Route</em> is identified by its internal identifier.
+ * \param[in] road Handle of the road instance
+ * \param[in] routeId Identifier of the <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Links</em> the <em>Route</em> runs along
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \deprecated Use RoadRouteObjGetLinkCount() to get the number of
+ *  <em>Links</em> a given <em>Route</em> runs along.
+ */
+int    RoadRouteGetNumOfLinks  (tRoad *road, int routeId);
+/** Function to get the number of <em>Links</em> a given <em>Route</em> runs
+ *  along\n
+ * The <em>Route</em> is identified by its internal identifier.
+ * \param[in] road Handle of the road instance
+ * \param[in] routeId  Identifier of the <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Links</em> the <em>Route</em> runs along
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table> 
+ * \deprecated Use RoadRouteObjGetLinkCount() to get the number of
+ * <em>Links</em> a given <em>Route</em> runs along.
+ */
+int    RoadRouteGetLinkCount   (tRoad *road, int routeId);
+/** Function to get the number of <em>Links</em> a given <em>Route</em> runs
+ *  along
+ * \param[in] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Links</em> the <em>Route</em> runs along
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadRouteObjGetJuncCount() \see RoadRouteObjGetLinkList()
+ */
+int    RoadRouteObjGetLinkCount(tRoad *road, tObjId rObjId);
+/** Function to get the number of <em>Junctions</em> a given <em>Route</em>
+ *  runs through\n
+ * The <em>Route</em> is identified by its internal identifier.
+ * \param[in] road Handle of the road instance
+ * \param[in] routeId Identifier of the <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Junctions</em> the <em>Route</em> runs through
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \deprecated Use RoadRouteObjGetJuncCount() to get the number of
+ * <em>Junctions</em> a given <em>Route</em> runs through.
+ */
+int    RoadRouteGetJuncCount   (tRoad *road, int routeId);
+/** Function to get the number of <em>Junctions</em> a given <em>Route</em>
+ *  runs through
+ * \param[in] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Junctions</em> the <em>Route</em> runs through
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadRouteObjGetLinkCount() \see RoadRouteObjGetJuncList()
+ */
+int    RoadRouteObjGetJuncCount(tRoad *road, tObjId rObjId);
+
+//! Link with regard to a Route
+/** Struct for the parameters describing how a <em>Route</em> runs along a
+ *  <em>Link</em>\n
+ * \see RoadRouteObjGetLinkList()
+ * \see tRoadRouteJunc \see tRoadRouteLanes
+ */
+typedef struct tRoadRouteLink {
+    int		  isInDir;/**< Flag indicating whether the <em>Route</em> runs
+                           * in the same direction as the <em>Link</em>:
+			   * - 0 &harr; counter link direction
+                           * - 1 &harr; in link direction
+			   */
+    double	  s0;	  /**< Offset of the <em>Link's</em> start
+                           * (junction entry) on the <em>Route</em>\n
+			   * Negative values indicate that the <em>Route</em>
+                           * starts within the <em>Link</em>.
+			   */ 
+    double	  s1;	  /**< Offset of the <em>Link's</em> end
+                           * (junction entry) on the <em>Route</em>\n
+                           * Negative values indicate that the <em>Route</em>
+                           * ends within the <em>Link</em>.
+			   */ 
+    tRoadLinkInfo info;	  /**< Struct with information about the <em>Link</em>
+			   */
+} tRoadRouteLink;
+
+/** Function delivering a list of the <em>Links</em> a given <em>Route</em> runs
+ *  along\n
+ *  The <em>Route</em> is identified by its internal identifier.
+ * \note The user is responsible to free the memory allocated by this function.
+ * \param[in] road Handle of the road instance
+ * \param[in] routeId Identifier of the <em>Route</em>
+ * \param[out] link Pointer to a list of the <em>Links</em> the <em>Route</em>
+ *  runs along
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Links</em> the <em>Route</em> runs along
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \deprecated Use RoadRouteObjGetLinkList() to get a list of the <em>Links</em>
+ * a given <em>Route</em> runs along.
+ */
+int    RoadRouteGetLinkList   (tRoad *road, int routeId, tRoadRouteLink **link);
+/** Function delivering a list of the <em>Links</em> a given <em>Route</em> runs
+ *  along
+ * \note The user is responsible to free the memory allocated by this function.
+ * \param[in] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \param[out] link Pointer to a list of the <em>Links</em> the <em>Route</em>
+ *  runs along
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Links</em> the <em>Route</em> runs along
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddRouteByLinkList() \see RoadRouteObjGetJuncList()
+ * \see RoadRouteObjGetLinkCount()
+ */
+int    RoadRouteObjGetLinkList(tRoad *road, tObjId rObjId,
+							 tRoadRouteLink **link);
+/** Function to add a new <em>Route</em> given by a list of the <em>Links</em>
+ * it runs along
+ * \param[in,out] road Handle of the road instance
+ * \param[in] addPath Currently unused: Reserved for future use.
+ * \param[in] link List of <em>Links</em> defining the new <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the new <em>Route</em>
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadRouteObjGetLinkList()
+ */
+tObjId RoadAddRouteByLinkList (tRoad *road, int addPath, tRoadRouteLink **link);
+
+//! Junction with regard to a Route
+/** Struct for the parameters describing a <em>Route's</em> way through a
+ * <em>Junction</em>
+ * \see RoadRouteObjGetJuncList()
+ * \see tRoadRouteLink \see tRoadRouteLanes
+ */
+typedef struct tRoadRouteJunc {
+    tRoadJuncInfo info;		/**< Struct with information about the
+                                 * <em>Junction</em>
+				 */
+    tObjId     jArmObjIdIn;	/**< Object id of the <em>Junction arm</em>
+                                 * the <em>Route</em> follows into the
+                                 * <em>Junction</em>
+                                 */
+    tObjId     jArmObjIdOut;	/**< Object id of the <em>Junction arm</em>
+                                 * the <em>Route</em> follows out of the
+                                 * <em>Junction</em>
+				 */
+    tObjId      lObjIdIn;	/**< Object id of the <em>Link</em> the
+                                 * <em>Route</em> follows into the
+                                 * <em>Junction</em>
+				 */
+    tObjId      lObjIdOut;	/**< Object id of the <em>Link</em> the
+                                 * <em>Route</em> follows out of the
+                                 * <em>Junction</em>
+				 */
+} tRoadRouteJunc;
+
+/** Function delivering a list of the <em>Junctions</em> a given <em>Route</em>
+ * runs through\n
+ * The <em>Route</em> is identified by its internal identifier.
+ * \note The user is responsible to free the memory allocated by this function.
+ * \param[in] road Handle of the road instance
+ * \param[in] routeId Identifier of the <em>Route</em>
+ * \param[out] junc Pointer to a list of the <em>Junctions</em> the
+ *  <em>Route</em> runs through
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Junctions</em> the <em>Route</em> runs through
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \deprecated Use RoadRouteObjGetJuncList() to get a list of the
+ * <em>Junctions</em> a given <em>Route</em> runs through.
+ */ 
+int    RoadRouteGetJuncList   (tRoad *road, int routeId, tRoadRouteJunc **junc);
+/** Function to get the list of the <em>Junctions</em> a given <em>Route</em>
+ * runs through
+ * \note The user is responsible to free the memory allocated by this function.
+ * \param[in] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \param[out] junc Pointer to a list of the <em>Junctions</em> the
+ *  <em>Route</em> runs through
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Junctions</em> the <em>Route</em> runs through
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadRouteObjGetLinkList() \see RoadRouteObjGetJuncCount()
+ */
+int    RoadRouteObjGetJuncList(tRoad *road, tObjId rObjId,
+							 tRoadRouteJunc **junc);
+
+//! Lanes with regard to a Route
+/** Struct used to describe the <em>Lanes</em> in tRoadRouteOut
+ * \see tRoadRouteLink \see tRoadRouteJunc 
+ */
+typedef struct tRoadRouteLanes {
+    int nLanesL;                /**< Number of left <em>Lanes</em>
+                                 * \note The term "left" refers to the
+                                 *  <em>Route's</em> direction, which can be
+                                 *  either in or counter link direction.
+				 */
+    int nLanesR;        	/**< Number of right <em>Lanes</em> in route
+                                 * \note The term "right" refers to the
+                                 *  <em>Route's</em> direction, which can be
+                                 *  either in or counter link direction.
+				 */
+    int laneIdx;                /**< Index of the current <em>Lane</em>
+                                 * in struct \ref tRoadRouteLanes::left "left"
+                                 * or \ref tRoadRouteLanes::right "right"
+                                 */
+    int isRight;		/**< Flag indicating the side of the current
+                                 * <em>Lane</em>:
+                                 * - 0 &harr; left
+                                 * - 1 &harr; right
+                                 * 
+                                 * \note The terms "left" and "right" refer to
+                                 *  the <em>Route's</em> direction, which can be
+                                 *  either in or counter link direction.
+                                 */
+    struct tRoadRouteLane {
+        double        width;	/**< Width of the <em>Lane</em> in meters
+				 */
+        double        tMidLane;	/**< Lateral offset of the middle of the
+                                 * <em>Lane</em> from the <em>Link's</em> 
+                                 * <em>Reference line</em>
+                                 * \note The sign of the variable refers to the
+                                 *  <em>Route's</em> direction, which can be
+                                 *  either in or counter link direction.
+				 */
+        tRoadLaneType type;	/**< Type of the <em>Lane</em>
+				 */
+        int           drvDir;	/**< Driving direction of the <em>Lane</em>:
+                                 * - -1 &harr; contrary to route direction
+                                 * - 1 &harr; in route direction
+				 */
+        int           laneId;	/**< Internal identifier of the <em>Lane</em>
+				 */
+    } left[ROAD_MAX_LANES],	/**< Array of structs containing the information
+                                 * about all left <em>Lanes</em> of the current
+                                 * <em>Lane section</em> 
+                                 * \note The term "left" refers to the
+                                 *  <em>Route's</em> direction, which can be
+                                 *  either in or counter link direction.
+				 */
+      right[ROAD_MAX_LANES];    /**< Array of structs containing the
+                                 * information about all right <em>Lanes</em>
+                                 * of the current <em>Lane section</em> 
+                                 * \note The term "right" refers to the
+                                 *  <em>Route's</em> direction, which can be
+                                 *  either in or counter link direction.
+				 */
+} tRoadRouteLanes;
+//! Route evaluation: input
+/** Struct for the input parameters of RoadRouteEval() and RoadRouteEvalExt()
+ * \note See \ref tRoadInType "input options".
+ */
+typedef struct tRoadRouteIn {
+    double st[2];		/**< Given position in the <em>Route's</em>
+                                 * local coordinate system
+				 */
+    double xyz[3];		/**< Given position in the global IPGRoad
+				 * coordinate system (Fr0)
+				 */
+} tRoadRouteIn;
+//! Route evaluation: output
+/** Struct for the output parameters of RoadRouteEval()
+ * \note It is recommended to use tRoadRouteOutExt and RoadRouteEvalExt().
+ */
+typedef struct tRoadRouteOut {
+    double	    xyz[3];	/**< Calculated position in the global IPGRoad
+                                 * coordinate system (Fr0)
+				 */
+    double	    nuv[3];	/**< Road surface normal unit vector at
+				 * \ref tRoadRouteOut::xyz "xyz"
+				 */
+    double	    suv[3];	/**< Longitudinal unit vector at
+				 * \ref tRoadRouteOut::xyz "xyz":\n
+				 * Unit vector in s-direction of the 
+				 * <em>Route</em>
+				 */
+    double	    tuv[3];	/**< Lateral unit vector at
+				 * \ref tRoadRouteOut::xyz "xyz":\n
+				 * Unit vector in t-direction of the 
+				 * <em>Route</em>
+				 */
+    double	    st[2];	/**< Calculated position in the <em>Route's</em>
+				 * local coordinate system
+				 */
+    double	    curveXY;	/**< Curvature of the curve of the
+                                 *  <em>Route</em> or the <em>Path</em> in the
+                                 * (x,y)-plane at \ref tRoadRouteOut::xyz "xyz"
+                                 * \note The \ref RoadEvalSetRouteByObjId
+                                 * "usePath" option is considered.
+				 */
+    double	    width[2];	/**< Width of the <em>Route</em> or the
+                                 * <em>Path</em> left/right at \ref
+                                 * tRoadRouteOut::st "s" in meters\n
+                                 * Depending on the \ref RoadEvalSetRouteByObjId
+                                 * "output mask" of the road evaluation handle
+                                 * either the <em>Route</em> or the
+                                 * <em>Path</em> are used as reference:
+                                 * - <em>Route</em>: The distance between the
+                                 * left/right road border and the
+                                 * <em>Center line</em> is calculated. 
+				 * \note Only valid if \ref tRoadRouteOut::xyz
+                                 * "xyz" is not on a Junction.
+                                 * - <em>Path</em>: For <em>Lane paths</em>
+                                 * the width of the associated <em>Lane</em>
+                                 * is divided in half, for <em>Connector</em>
+                                 * or <em>User paths</em> the path width is
+                                 * used.
+                                 * \note There are special values for the
+                                 * width of <em>Connector</em> and <em>User
+                                 * paths</em>:
+                                 *   - -2 &harr; The distance to the
+                                 * left/right road border is used
+                                 * (only valid on a <em>Link</em>).
+                                 *   - -1 &harr; The width of the associated
+                                 * <em>Lane</em> is used.
+				 */
+    tRoadPosKind    onRoad;	/**< Kind of position:\n
+				 * On or (in some extent) off the road
+				 */
+/**
+ * \name
+ * The following output variables do not consider <em>Bumps</em>.
+ * @{
+ */
+/* --- The following outputs do not consider Bumps ---------------- */
+    double	    grade;	/**< Longitudinal gradient at
+				 * \ref tRoadRouteOut::xyz "xyz":\n
+                                 * Gradient of the z-coordinate in s-direction
+                                 * of the <em>Route</em>
+                                 * \note <em>Bumps</em> are not considered.
+				 */
+    double	    slope;	/**< Lateral gradient at
+				 * \ref tRoadRouteOut::xyz "xyz":\n
+                                 * Gradient of the z-coordinate in t-direction
+                                 * of the <em>Route</em>
+                                 * \note <em>Bumps</em> are not considered.
+				 */
+    double	    curveZ;	/**< Longitudinal z-curvature at
+				 * \ref tRoadRouteOut::xyz "xyz":\n
+                                 * Curvature of the curve in the (s,z)-plane 
+                                 * (change of \ref tRoadRouteOut::grade
+                                 * "grade" in s-direction of the <em>Route</em>)
+                                 * \note <em>Bumps</em> are not considered.
+				 */
+/** @} */
+    
+/* ---------------------------------------------------------------- */
+    double	    fric;	/**< Friction coefficient at 
+				 * \ref tRoadRouteOut::xyz "xyz"
+				 */
+    tRoadRouteLanes lanes;	/**< Struct for the information about the
+                                 * <em>Lanes</em>
+				 */
+} tRoadRouteOut;
+
+/** Function to evaluate a <em>Route</em>
+ * \param[in,out] re Evaluation handle of the road instance
+ * \param[in] errMsgPre Prefix for the error messages
+ * \param[in] it Input type describing which variables of <b>in</b> are used
+ * \param[in] in Pointer to a struct for the input parameters
+ * \param[out] out Pointer to a struct for the output parameters
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ * <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \note It is recommended to use RoadRouteEvalExt().
+ */
+int    RoadRouteEval(tRoadEval *re, const char *errMsgPre, tRoadInType it,
+				    const tRoadRouteIn *in, tRoadRouteOut *out);
+
+//! Route evaluation: output (extended version)
+/** Struct for the output parameters of RoadRouteEvalExt()\n
+ */
+typedef struct tRoadRouteOutExt {
+    double	     xyz[3];	  /**< Calculated position in the global IPGRoad
+				   * coordinate system (Fr0)
+				   */
+    double	     nuv[3];	  /**< Road surface normal unit vector at
+                                   * \ref tRoadRouteOutExt::xyz "xyz"
+				   */
+    double	     suv[3];	  /**< Longitudinal unit vector at 
+                                   * \ref tRoadRouteOutExt::xyz "xyz":\n
+				   * Unit vector in s-direction of the 
+				   * <em>Route</em>
+				   */
+    double	     tuv[3];	  /**< Lateral unit vector at 
+                                   * \ref tRoadRouteOutExt::xyz "xyz":\n
+				   * Unit vector in t-direction of the 
+				   * <em>Route</em>
+				   */
+    double	     st[2];	  /**< Calculated position in the <em>Route's
+				   * </em> local coordinate system
+				   */
+    double	     curveXY;	  /**< Curvature of the curve of the
+                                   * <em>Route</em> or the <em>Path</em> in the
+                                   * (x,y)-plane at \ref tRoadRouteOutExt::xyz
+                                   * "xyz"
+                                   * \note The \ref RoadEvalSetRouteByObjId
+                                   * "usePath" option is considered.
+				   */
+    double	     width[2];	  /**< Width of the <em>Route</em> or the
+                                   * <em>Path</em> left/right at \ref
+                                   * tRoadRouteOutExt::st "s" in meters\n
+                                   * Depending on the \ref
+                                   * RoadEvalSetRouteByObjId "output mask" of
+                                   * the road evaluation handle either the
+                                   * <em>Route</em> or the <em>Path</em> are
+                                   * used as reference:
+                                   * - <em>Route</em>: The distance between the
+                                   * left/right road border and the <em>Center
+                                   * line</em> is calculated.
+				   * \note Only valid if
+                                   * \ref tRoadRouteOutExt::xyz "xyz" is not
+                                   * \ref tRoadRouteOutExt::onJunction
+                                   * "on a Junction".
+                                   * - <em>Path</em>: For <em>Lane paths</em>
+                                   * the width of the associated <em>Lane</em>
+                                   * is divided in half, for <em>Connector</em>
+                                   * or <em>User paths</em> the path width is
+                                   * used.
+                                   * \note There are special values for the
+                                   * width of <em>Connector</em> and <em>User
+                                   * paths</em>:
+                                   *   - -2 &harr; The distance to the
+                                   * left/right road border is used
+                                   * (only valid on a <em>Link</em>).
+                                   *   - -1 &harr; The width of the associated
+                                   * <em>Lane</em> is used.
+				   */
+/**
+ * \name
+ * The following output variables do not consider <em>Bumps</em>.
+ * @{
+ */
+/* --- The following outputs do not consider Bumps ---------------- */
+    double	     grade;	  /**< Longitudinal gradient at
+                                   * \ref tRoadRouteOutExt::xyz "xyz":\n
+                                   * Gradient of the z-coordinate in s-direction
+                                   * of the <em>Route</em>
+                                   * \note <em>Bumps</em> are not considered.
+				   */
+    double	     slope;	  /**< Lateral gradient at
+                                   * \ref tRoadRouteOutExt::xyz "xyz":\n
+                                   * Gradient of the z-coordinate in t-direction
+                                   * of the <em>Route</em>
+                                   * \note <em>Bumps</em> are not considered.
+				   */
+    double	     curveZ;	  /**< Longitudinal z-curvature at
+                                   * \ref tRoadRouteOutExt::xyz "xyz":\n
+                                   * Curvature of the curve in the (s,z)-plane
+                                   * (change of \ref tRoadRouteOutExt::grade
+                                   * "grade" in s-direction of the
+                                   * <em>Route</em>).
+                                   * \note <em>Bumps</em> are not considered.
+				   */
+/** @} */
+/* ---------------------------------------------------------------- */
+    double	     fric;	  /**< Friction coefficient at
+                                   * \ref tRoadRouteOutExt::xyz "xyz"
+				   */
+    double	     pathT;	  /**< Lateral offset from the <em>Reference
+                                   * line</em> at \ref tRoadRouteOutExt::st "s"
+                                   * \note The sign of the variable refers to
+                                   * the <em>Route's</em> direction, not to the
+                                   * direction of the <em>Reference line</em>.
+                                   * \note This parameter is only valid in case
+                                   *  the <em>Route's</em> root object is a
+                                   *  <em>Link</em>.
+				   */
+    double	     nextJuncDist;/**< Distance to the next junction entry
+				   */
+    double	     lastJuncDist;/**< Distance to the last junction entry
+				   */
+    double	     links0;	  /**< - <b>xyz</b> on <em>Link</em>:
+                                   * Offset of the start (junction entry) of the
+                                   * current <em>Link</em> on the <em>Route</em>
+                                   *   - <b>xyz</b> on <em>Junction</em>:
+                                   * Offset of the start (junction entry) of the
+                                   * last <em>Link</em> on the <em>Route</em>
+				   */
+    double	     links1;	  /**< - <b>xyz</b> on <em>Link</em>:
+                                   * Offset of the end (junction entry) of the
+                                   * current <em>Link</em> on the <em>Route</em>
+                                   *   - <b>xyz</b> on <em>Junction</em>:
+                                   * Offset of the end (junction entry) of the
+                                   * last <em>Link</em> on the <em>Route</em>
+				   */
+    tRoadPosKind     onRoad;	  /**< Kind of position:\n
+				   * On or (in some extent) off the road
+				   */
+    tRoadLaneOutExt  lanes;	  /**< Struct with the <em>Lanes</em> defined
+                                   * at the calculated \ref tRoadRouteOutExt::st
+                                   * "s-offset"
+				   * \note Only valid if
+                                   * \ref tRoadRouteOutExt::xyz "xyz" is not
+                                   * \ref tRoadRouteOutExt::onJunction
+                                   * "on a Junction".
+				   */
+    int		     onJunction;  /**< Flag indicating whether
+                                   * \ref tRoadRouteOutExt::xyz "xyz" is on a
+                                   *  <em>Link</em> or on a <em>Junction</em>:\n
+				   * - 0 &harr; <em>Link</em>
+				   * - 1 &harr; <em>Junction</em>
+				   */
+    int		     linkObjId;	  /**< - <b>xyz</b> on <em>Link</em>:
+                                   * object id of the current <em>Link</em>
+                                   *   - <b>xyz</b> on <em>Junction</em>:
+                                   * object id of the last
+                                   * <em>Link</em>
+				   */
+    int		     juncObjId;	  /**< - <b>xyz</b> on <em>Link</em>:
+                                   * object id of the last <em>Junction</em>
+                                   *   - <b>xyz</b> on <em>Junction</em>:
+                                   * object id identifier of the current
+                                   * <em>Junction</em>
+				   */
+    int		     nextJuncObjId;  /**< Object id of the next <em>Junction</em>
+                                   * \note Set to #ROAD_InvalidObjId if \ref
+                                   *  tRoadRouteOutExt::xyz "xyz" is \ref
+                                   *  tRoadRouteOutExt::onJunction
+                                   *  "on a Junction". 
+				   */
+    struct tRoadPath *path;	  /**< Pointer to a struct with the parameters
+                                   * of the current <em>Path</em>
+				   */
+} tRoadRouteOutExt;
+
+/** Function to evaluate a <em>Route</em>: extended version
+ * \param[in,out] re Evaluation handle of the road instance
+ * \param[in] errMsgPre Prefix for the error messages
+ * \param[in] it Input type describing which variables of <b>in</b> are used
+ * \param[in] in Pointer to a struct for the input parameters
+ * \param[out] out Pointer to a struct for the output parameters
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadRouteEvalExt(tRoadEval *re, const char *errMsgPre, tRoadInType it,
+				 const tRoadRouteIn *in, tRoadRouteOutExt *out);
+
+
+/** Function to set the <em>Route</em> of a road evaluation handle and adjust
+ *  its output mask\n
+ *  The <em>Route</em> is identified by its internal identifier.
+ *  \note Whereas <em>Routes</em> run along the <em>Reference lines</em>,
+ *   <em>Paths</em> have a lateral offset from them. Therefore, the longitudinal
+ *   and the lateral direction of the local coordinate systems of a
+ *   <em>Path</em> and the <em>Route</em> it belongs to can be entirely
+ *   different. However, since the length of a <em>Path</em> is considered as
+ *   the length of its projection on the <em>Reference line</em>, the
+ *   s-coordinate is the same in both cases.
+ * \param[in,out] re Road evaluation handle
+ * \param[in] routeId Identifier of the <em>Route</em>.
+ * \param[in] usePath Parameter determining whether the <em>Route</em> or its
+ *  <em>Paths</em> are used as reference for the output calculated with the road
+ *  evaluation handle:
+ *  - 0 &harr; The <em>Route</em> is used as reference for the output. 
+ *  - 1 &harr; The <em>Paths</em> are used as reference for the output.
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \deprecated Use  RoadEvalSetRouteByObjId() to set the <em>Route</em> of a
+ * road evaluation handle.
+ */
+int    RoadEvalSetRoute       (tRoadEval *re, int routeId,       int usePath);
+/** Function to set the <em>Route</em> of a road evaluation handle and adjust
+ *  its output mask
+ *  \note Whereas <em>Routes</em> run along the <em>Reference lines</em>,
+ *   <em>Paths</em> have a lateral offset from them. Therefore, the longitudinal
+ *   and the lateral direction of the local coordinate systems of a
+ *   <em>Path</em> and the <em>Route</em> it belongs to can be entirely
+ *   different. However, since the length of a <em>Path</em> is considered as
+ *   the length of its projection on the <em>Reference line</em>, the
+ *   s-coordinate is the same in both cases.
+ * \param[in,out] re Road evaluation handle
+ * \param[in] routeObjId Object id of the <em>Route</em>
+ * \param[in] usePath Parameter determining whether the <em>Route</em> or its
+ *  <em>Paths</em> are used as reference for the output calculated with the road
+ *  evaluation handle:
+ *  - 0 &harr; The <em>Route</em> is used as reference for the output. 
+ *  - 1 &harr; The <em>Paths</em> are used as reference for the output.
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadEvalSetRouteByName() \see RoadEvalGetRouteObjId()
+ */
+int    RoadEvalSetRouteByObjId(tRoadEval *re, tObjId routeObjId, int usePath);
+/** Function to set the <em>Route</em> of a road evaluation handle and adjust
+ *  its output mask\n
+ *  The <em>Route</em> is identified by its name.
+ *  \note Whereas <em>Routes</em> run along the <em>Reference lines</em>,
+ *   <em>Paths</em> have a lateral offset from them. Therefore, the longitudinal
+ *   and the lateral direction of the local coordinate systems of a
+ *   <em>Path</em> and the <em>Route</em> it belongs to can be entirely
+ *   different. However, since the length of a <em>Path</em> is considered as
+ *   the length of its projection on the <em>Reference line</em>, the
+ *   s-coordinate is the same in both cases.
+ * \param[in,out] re Road evaluation handle
+ * \param[in] name Name of the <em>Route</em>
+ * \param[in] usePath Parameter determining whether the <em>Route</em> or its
+ *  <em>Paths</em> are used as reference for the output calculated with the road
+ *  evaluation handle:
+ *  - 0 &harr; The <em>Route</em> is used as reference for the output. 
+ *  - 1 &harr; The <em>Paths</em> are used as reference for the output.
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadEvalSetRouteByObjId() \see RoadEvalGetRouteObjId()
+ */
+int    RoadEvalSetRouteByName (tRoadEval *re, const char* name,  int usePath);
+/** Function to get the internal identifier of the <em>Route</em> attached to a
+ *  given road evaluation handle
+ * \param[in] re Road evaluation handle
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> internal identifier of the <em>Route</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \deprecated Use RoadEvalGetRouteObjId() to get the object id of the
+ * <em>Route</em> attached to a given road evaluation handle.
+ */
+int    RoadEvalGetRoute       (tRoadEval *re);
+/** Function to get the object id of the <em>Route</em> attached to a given road
+ * evaluation handle
+ * \param[in] re Road evaluation handle
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> Object id of the <em>Route</em>
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadEvalSetRouteByObjId() \see RoadEvalSetRouteByName()
+ */
+tObjId RoadEvalGetRouteObjId  (tRoadEval *re);
+
+
+/** Function to generate and initialize a route speed evaluation handle\n
+ *  The <em>Route</em> is identified by its internal identifier.
+ * \param[in] road Handle of the road instance
+ * \param[in] routeId Identifier of the <em>Route</em>
+ * \param[in] range Range in s-direction along the <em>Route</em> where it is
+ *  searched for speed limits
+ * \param[in] module Internal use only. Set this parameter to NULL.
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ * <td> route speed evaluation handle
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \deprecated Use RoadRouteObjGetSpeedEval() to generate and initialize a route
+ * speed evaluation handle.
+ */
+tRoadRouteSpeedEval *RoadRouteGetSpeedEval   (tRoad *road, int routeId,
+				              double range, const char *module);
+/** Function to generate and initialize a route speed evaluation handle
+ * \param[in] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \param[in] range Range in s-direction along the <em>Route</em> where it is
+ *  searched for speed limits
+ * \param[in] module Internal use only. Set this parameter to NULL.
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ * <td> route speed evaluation handle
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see RoadRouteDeleteSpeedEval() \see RoadRouteResetSpeedEval()
+ */
+tRoadRouteSpeedEval *RoadRouteObjGetSpeedEval(tRoad *road, tObjId rObjId,
+					      double range, const char *module);
+/** Function to reset a route speed evaluation handle
+ * \param[in,out] rse Route speed evaluation handle
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \param[in] range Range in s-direction along the <em>Route</em> where it is
+ *  searched for speed limits
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ * <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadRouteDeleteSpeedEval()\see RoadRouteObjGetSpeedEval()
+ */
+int                  RoadRouteResetSpeedEval (tRoadRouteSpeedEval *rse,
+						   tObjId rObjId, double range);
+/** Function to free the memory of a route speed evaluation handle
+ * \param[in] rse Route speed evaluation handle that should be deleted
+ * \see RoadRouteObjGetSpeedEval() \see RoadRouteResetSpeedEval()
+ */
+void                 RoadRouteDeleteSpeedEval(tRoadRouteSpeedEval *rse);
+
+//! Route speed evaluation: output
+/** Struct for the output parameters of RoadRouteGetSpeed()
+ * \see tRoadPathSpeedOut
+ */
+typedef struct tRoadSpeedOut {
+    double speed;	/**< Speed limit in m/s
+			 */
+    double sRoute;	/**< Offset of the speed limit in s-direction on the
+                         * <em>Route</em>
+			 */
+} tRoadSpeedOut;
+
+/** Function to get the next three speed limits of a <em>Route</em>
+ * \param[in] rse Route speed evaluation handle
+ * \param[in] s Offset in s-direction on the <em>Route</em>
+ * \param[out] out Array of structs for the three next speed sections
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ * <td> number of found speed sections (at most three)
+ *  <tr><td> In case of failure:
+ * <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadPathGetSpeed()
+ */
+int    RoadRouteGetSpeed   (tRoadRouteSpeedEval *rse, double s,
+							  tRoadSpeedOut out[3]);
+
+
+
+/** @} */
+/******************************************************************************/
+/* --- Routes of version 6.0.X and lower ------------------------------------ */
+/******************************************************************************/
+
+
+/** \addtogroup Routes6Eval
+ * @{
+ */
+/** Function to convert the offset in s-direction given on a 8.0-<em>Route</em>
+ *  to the offset in s-direction on a 6.0-<em>Route</em>\note
+ *  The calculation method for the offset on a <em>Route</em> has changed
+ *  which can lead to minor differences regarding the s-offsets.
+ * \param[in] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \param[in] sRoute Offset in s-direction calculated using the 8.0-method
+ * \param[out] sRoute6 Offset in s-direction calculated using the 6.0-method
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadRoute6GetSOnRoute()
+ */
+int    RoadRouteGetSOnRoute6(tRoad *road, tObjId rObjId,
+						double sRoute, double *sRoute6);
+/** Function to convert the offset in s-direction given on a 6.0-<em>Route</em>
+ *  to the offset in s-direction on a 8.0-<em>Route</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \param[in] sRoute6 Offset in s-direction calculated using the 6.0-method
+ * \param[out] sRoute Offset in s-direction calculated using the 8.0-method
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadRouteGetSOnRoute6()
+ */
+int    RoadRoute6GetSOnRoute(tRoad *road, tObjId rObjId,
+						double sRoute6, double *sRoute);
+ 
+/** Function to get the distance between a given offset on a <em>Route</em> and
+ *  the next <em>Junction</em>
+ * \param[in] re Evaluation handle of the instance of the road
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> distance to the next <em>Junction</em> in meters
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \deprecated Use RoadRouteEvalExt() to get the distance between a given offset
+ *  on a <em>Route</em> and the next <em>Junction</em>.
+ */
+double RoadRouteGetDistToNextJunction(tRoadEval *re);
+
+
+
+/** @} */
+/******************************************************************************/
+/* === Additional functions ================================================= */
+/******************************************************************************/ 
+
+
+/******************************************************************************/
+/* +++ Statistics +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup Statistics
+ * @{
+ */
+/** Function to print the <em>Road Statistics</em>:
+ *  Number of <em>Links</em>, number of <em>Junctions</em> and length of the
+ *  <em>Road network</em>
+ * \note The information is displayed using the function pointer #RoadLogInfo().
+ * \param[in] road Handle of the road instance
+ * \see RoadPrintInfo()
+ */
+void   RoadPrintStatistics(tRoad *road);
+
+/** Function to get the number of <em>Links</em> of a road instance
+ * \param[in] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Links</em> of the road instance
+ *  <tr><td> In case of failure: <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetJunctionCount() \see RoadGetObjectCount()
+ * \see RoadGetRouteCount()
+ */
+int    RoadGetLinkCount    (tRoad *road);
+/** Function to count the number of <em>Junctions</em> of a road instance
+ * \param[in] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Junctions</em> of the road instance
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetLinkCount() \see RoadGetObjectCount() \see RoadGetRouteCount()
+ */
+int    RoadGetJunctionCount(tRoad *road);
+/** Function to count the number of objects of a road instance
+ * \param[in] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of objects of the road instance
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetLinkCount() \see RoadGetJunctionCount() \see RoadGetRouteCount()
+ */
+int    RoadGetObjectCount  (tRoad *road);
+/** Function to count the number of <em>Routes</em> of the road instance
+ * \param[in] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Routes</em> of the road instance
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \deprecated Use RoadGetRouteCount() to get the number of <em>Routes</em>
+ *  of a road instance.
+ */
+int    RoadGetNumOfRoutes  (tRoad *road);
+/** Function to count the number of <em>Routes</em> of a road instance
+ * \param[in] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Routes</em> of the road instance
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetLinkCount() \see RoadGetJunctionCount() \see RoadGetObjectCount() 
+ */
+int    RoadGetRouteCount   (tRoad *road);
+
+/** Function to determine the total length of the <em>Road network</em> of a
+ *  road instance
+ * \param[in] road Handle of the road instance
+ * \return Total length of the <em>Road network</em>
+ */
+double RoadGetNetworkLength(tRoad *road);
+/** Function to get the bounding box of a road instance
+ * \param[in] road Handle of the road instance
+ * \param[out] min Minimum x/y/z-coordinate of the road instance
+ * \param[out] max Maximum x/y/z-coordinate of the road instance
+ * \see RoadGetBBCount()
+ */
+void   RoadGetBoundingBox  (tRoad *road, double min[3], double max[3]);
+/** Function to get the number of look-up bounding boxes of a road instance\n
+ *  In order to simplify the evaluation of a road instance, every <em>Link</em>
+ *  and <em>Junction</em> is covered with slightly overlapping rectangles,
+ *  so-called look-up boxes.
+ * \param[in] road Handle of the road instance
+ * \return Number of look-up bounding boxes of the road instance
+ * \see RoadGetBoundingBox()
+ */
+int    RoadGetBBCount      (tRoad *road);
+
+/** Function to get the total number of B&eacute;zier Patch Mappings of a road
+ *  instance\n
+ *  The surface of a road instance is depicted with so-called B&eacute;zier
+ *  Patch Mappings. These are patches with four B&eacute;zier curves as boundary
+ *  curves.
+ * \param[in] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of B&eacute;zier Patch Mappings used for the road instance
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetInvalidBPMCount()
+ */
+int    RoadGetBPMCount       (tRoad *road);
+/** Function to get the number of invalid B&eacute;zier Patch Mappings of a road
+ *  instance\n
+ *  Sometimes the parameters chosen for a part of a road instance don't allow to
+ *  depict this part's boundary with B&eacute;zier curves (e.g. the area between
+ *  two arms of a junction that are defined too close to each other). The
+ *  B&eacute;zier Patch Mapping of this part is then marked and included in the
+ *  statistics as invalid.
+ * \param[in] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of invalid B&eacute;zier Patch Mappings\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetBPMCount()
+ */
+int    RoadGetInvalidBPMCount(tRoad *road);
+
+
+/** @} */
+/******************************************************************************/
+/* +++ Log Function Pointers ++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \cond
+ */
+extern void (*RoadLogInfo) (const char* fmt,...)
+	__attribute__((format(printf,1,2)));
+extern void (*RoadLogWarn) (unsigned type, const char* fmt,...)
+	__attribute__((format(printf,2,3)));
+extern void (*RoadLogErr)  (unsigned type, const char* fmt,...)
+	__attribute__((format(printf,2,3)));
+
+
+/** \endcond
+ */
+/******************************************************************************/
+/* +++ Error Functions ++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup ErrMsg
+ * @{
+ */
+
+/** Message types
+ */
+typedef enum tRoadMsgType {
+    RMT_Error   = (1<<0),   /**< <b>1</b> &nbsp; Error
+                             */
+    RMT_Warn    = (1<<1),   /**< <b>2</b> &nbsp; Warning
+                             */
+    RMT_Info    = (1<<2),   /**< <b>4</b> &nbsp; Information
+                             */
+    RMT_Debug   = (1<<3),   /**< <b>8</b> &nbsp; Debug
+                            */
+    RMT_Ext     = (1<<4),   /**< <b>16</b> &nbsp; External                        
+                            */
+} tRoadMsgType;
+
+/** All message types:\n
+ *  Flag indicating that messages of all types except the \ref RMT_Ext
+ *  "external messages" are considered.
+ *  \see tRoadMessage \see RoadGetMsgList() \see RoadClearMsgList()
+ *  \see RoadAddMessage() \see RoadAddMsg()
+ */
+#define RMT_ALL         RMT_Error|RMT_Warn|RMT_Info|RMT_Debug
+//! Message
+/** Struct for the parameters of a message
+ */
+typedef struct tRoadMessage {
+    tRoadMsgType rmt;           /**< Message type
+                                 */
+    int code;                   /**< \ref ErrorCodes "Error code" of the message
+                                 */
+    char *msg;                  /**< Text of the message
+                                 */
+} tRoadMessage;
+
+//! Message list
+/** Struct for a list of messages
+ */
+typedef struct tRoadMessageList {
+    tRoadMessage *msg;          /**< List of messages
+                                 */
+    int nMsgList;               /**< Number of the messages listed
+                                 */    
+} tRoadMessageList;
+
+//! Error
+/** Struct for the parameters of an error
+ * \deprecated Use a \ref tRoadMessage "message" of \ref tRoadMsgType "type"
+ * \ref RMT_Error for an error message.
+ */
+typedef struct tRoadError {
+    int  code;		/**< Error code
+			 */
+    char *err;		/**< Error message
+			 */
+} tRoadError;
+
+/** Function to get a list with all errors collected for a given road instance
+ * \param[in] road Handle of the road instance
+ * \param[in] errList List of errors
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> number of errors
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \warning Do not free **errList or *errList!
+ * \deprecated Use \ref RoadGetMessageList() to get a list of all errors of a
+ * road instance.
+ */
+int  RoadGetErrorList  (tRoad *road, tRoadError **errList);
+/** Function to clear the error list of a given road instance
+ * \param[in] road Handle of the road instance
+ * \deprecated The errors of a road instance are handled in a new \ref
+ * RoadClearMessageBuffer "message buffer".
+ */
+void RoadClearErrorList(tRoad *road);
+
+/** Function to get a list with all messages of a given type collected for a
+ *  given road instance
+ * \param[in] road Handle of the road instance
+ * \param[in] rmt Type of message
+ * \param[out] msgList List of messages
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of messages of the given type
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \warning Do not free **msgList or *msgList!
+ * \deprecated Use \ref RoadGetMessageList() to get a list of all messages of a
+ * certain type.
+ */
+int  RoadGetMsgList  (tRoad *road, tRoadMsgType rmt, char ***msgList);
+/** Function to clear the list of a certain type of messages of a given road
+ *  instance
+ * \param[in] road Handle of the road instance
+ * \param[in] rmt Type of message
+ * \see RoadGetMsgList()
+ * \deprecated The messages of a road instance are handled in a new \ref
+ * RoadClearMessageBuffer "message buffer".
+ */
+void RoadClearMsgList(tRoad *road, tRoadMsgType rmt);
+
+/** Function to add a message to the internal message list of a given road
+ *  instance
+ * \param[in] road Handle of the road instance
+ * \param[in] msgType Type of the message
+ * \param[in] msg Text of the message
+ * \param[in] errCode \ref ErrorCodes "Error code" of the message
+ * \return Pass through of <b>errCode</b>
+ * \see RoadAddMsg() \see RoadClearMessageBuffer() \see RoadGetMessageList()
+ * \see RoadDeleteMessageList()
+ */
+int  RoadAddMessage        (tRoad *road, tRoadMsgType msgType,
+                                                  const char *msg, int errCode);
+/** Function to add a formatted message to the internal message list of a given
+ *  road instance
+ * \param[in] road Handle of the road instance
+ * \param[in] msgType Type of the message
+ * \param[in] errCode \ref ErrorCodes "Error code" of the message
+ * \param[in] msgfmt Formatted text of the message
+ * \return Pass through of <b>errCode</b>
+ * \see RoadAddMessage() \see RoadClearMessageBuffer() \see RoadGetMessageList()
+ * \see RoadDeleteMessageList()
+ */
+int  RoadAddMsg            (tRoad *road, tRoadMsgType msgType,     int errCode, 
+                                                  const char *msgfmt, ...);
+/** Function to clear all messages of the specified types for a given road
+ *  instance
+ * \param[in] road Handle of the road instance
+ * \param[in] msgTypes Message types which will be deleted: The binary system is
+ *  used to generate combinations of the message types #RMT_Error, #RMT_Warn, 
+ *  #RMT_Info and #RMT_Debug.
+ * \see RoadAddMsg() \see RoadAddMessage() \see RoadGetMessageList()
+ * \see RoadDeleteMessageList()
+ */
+void RoadClearMessageBuffer(tRoad *road, int msgTypes);
+/** Function to get a list with all messages of the specified types collected 
+ * for a given road instance
+ * \note The user is responsible to free the memory of the the message list
+ *  after usage via \ref RoadDeleteMessageList().
+ * \param[in] road Handle of the road instance
+ * \param[in] msgTypes Message types which will be considered: The binary system
+ *  is used to generate combinations of the message types #RMT_Error, #RMT_Warn, 
+ *  #RMT_Info and #RMT_Debug.
+ * \param[out] msgList Pointer to the struct in which the messages will be
+ * stored
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> Number of elements in the message list
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddMsg() \see RoadAddMessage() \see RoadClearMessageBuffer()
+ * \see RoadDeleteMessageList()
+ */
+int  RoadGetMessageList    (tRoad *road, int msgTypes,
+                                         tRoadMessageList *msgList);
+/** Function to delete a message list which was prior allocated by
+ * \ref RoadGetMessageList()
+ * \param[in] road Handle of the road instance
+ * \param[in] msgList Pointer to the message list
+ * \see RoadAddMsg() \see RoadAddMessage() \see RoadClearMessageBuffer()
+ * \see RoadGetMessageList()
+ */
+void RoadDeleteMessageList (tRoad *road, tRoadMessageList *msgList);
+
+/** Function to set which types of message are suppress by the internal message
+ *  handler. By default no message are suppressed. It is not possible to
+ *  suppress messages of type #RMT_Ext. To create messages of all types set
+ *  <em>typeMask</em> to 0.
+ * \param[in] road Handle of the road instance
+ * \param[in] typeMask mask of message types \see tRoadMsgType
+ * \see RoadAddMsg() \see RoadAddMessage() \see RoadClearMessageBuffer()
+ * \see RoadGetMessageList()
+ */
+void RoadSetMsgTypesToSuppress (tRoad *road, int typeMask);
+
+
+/** @} */
+/******************************************************************************/
+/* +++ Binary File Functions ++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup BinFileInfo
+ * @{
+ */
+/*** Binary file information options ***/
+
+/** Binary file information: \n
+ *  The name of a track is at most 32 bits long.
+ */
+#define	ROAD_BIN_NAME_SIZE	 32
+/** Binary file information: \n
+ *  The size of the version number covers at most 8 bits.
+ */
+#define	ROAD_BIN_VER_SIZE	  8
+/** Binary file information:\n
+ *  The size of a comment is limited to 256 bits.
+ */
+#define	ROAD_BIN_TXT_SIZE	256
+
+//! Binary file information
+/** Struct for the information about a binary file describing a <em>\ref
+ *  SegmentsEdit "Segment"</em> of type <em>File</em>
+ *  \see RoadGetBinFileInfo()
+ */
+typedef struct tRoadBinInfo {
+    double gcs_xyz[3];		 /**< GCS position in the IPGRoad coordinate
+                                  * system (Fr0): (x,y,z)-coordinates &nbsp;
+                                  * [m,m,m]
+				  */
+    double gcs_lle[3];		 /**< GCS position in WGS84: latitude, longitude
+                                  * and elevation of the global coordinates
+                                  * &nbsp; [deg, deg, m]
+				  */
+    double width[2];		 /**< Width left/right [m]
+				  */
+    double startDir;		 /**< Start direction [deg]
+				  */
+    double smooth[3];		 /**< Smoothing factors (xy,z,q)
+				  */
+    int    gcs_mode;		 /**< \ref tGCSMode "GCS projection mode" 
+				  */
+    int    nPts;		 /**< Number of digitized points
+				  */
+    char   name[ROAD_BIN_NAME_SIZE]; /**< Name of the track
+				  */
+    char   version[ROAD_BIN_VER_SIZE];/**< Version number
+				  */
+    char   comment[ROAD_BIN_TXT_SIZE];/**< Comment
+				  */
+} tRoadBinInfo;
+
+/** Function to get the information about a binary file\n
+ *  Used to display the information about binary files containing the
+ *  description of a <em>Segment</em> of type <em>File</em>
+ * \param[in] binFName Name of the binary file
+ * \param[out] info Pointer to a struct for the information about the binary
+ *  file
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetBinFileInfo(const char *binFName, tRoadBinInfo *info);
+
+
+
+/** @} */
+/******************************************************************************/
+/* === Road Independent Functions =========================================== */
+/******************************************************************************/
+
+
+/******************************************************************************/
+/* +++ GCS ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup RIGCS
+ * @{
+ */
+
+#ifndef  GCS_UNKNOWN_ELEVATION
+/** Unknown elevation of GCS:\n
+ *  Return value for GCSGetHM_Z() indicating that a given position is not within
+ *  the range of the given <em>Height map's</em> GCS module.
+ */
+#define GCS_UNKNOWN_ELEVATION 0x80000000
+
+#endif
+
+
+/** GCS module:\n
+ *  Besides some parameters for the GCS projection mode, this struct includes a
+ *  reference position in IPGRoad and WGS84 coordinates.
+ */
+typedef struct tGCS	tGCS;
+
+/** Function to generate and initialize a new GCS module\n
+ *  This function sets the GCS projection mode and the reference position of the
+ *  GCS module in IPGRoad and WGS84 coordinates.
+ * \param[in] xyzRef Reference position in the IPGRoad coordinate system (Fr0):
+ * (x,y,z)-coordinates of the reference point &nbsp; [m,m,m]
+ * \param[in] lleRef Reference position in WGS84: 
+ * (lat,lon,elev)-coordinates of the reference point &nbsp; [deg, deg, m]
+ * \param[in] mode GCS projection mode
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> pointer to the new GCS module\n
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see GCSDelete()
+ */
+tGCS   *GCSNew    (double xyzRef[3], double lleRef[3], tGCSMode mode);
+/** Function to delete a GCS module
+ * \param[in] gcs Pointer to the GCS module that should be deleted
+ * \see GCSNew() \see RoadDeleteGCS()
+ */
+void    GCSDelete (tGCS *gcs);
+/** Function to convert a given position in WGS84 to the corresponding position
+ *  in the IPGRoad coordinate system using a given GCS module
+ * \param[in] gcs Pointer to the GCS module
+ * \param[in] lle Position in WGS84: (lat,lon,elev)-coordinates &nbsp;
+ *  [deg,deg,m]
+ * \param[out] xyz Position in the IPGRoad coordinate system (Fr0):
+ * (x,y,z)-coordinates &nbsp; [m,m,m]
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see GCSxyz2lle() \see Roadlle2xyz()
+ */
+int	GCSlle2xyz(tGCS *gcs, double lle[3], double xyz[3]);
+/** Function to convert a given position in the IPGRoad coordinate system to the
+ * corresponding position in WGS84 using a given GCS module
+ * \param[in] gcs Pointer to the GCS module
+ * \param[in] xyz Position in the IPGRoad coordinate system (Fr0):
+ * (x,y,z)-coordinates &nbsp; [m,m,m]
+ * \param[out] lle Position in WGS84: (lat,lon,elev)-coordinates &nbsp;
+ *  [deg,deg,m]
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see GCSlle2xyz() \see Roadxyz2lle()
+ */
+int	GCSxyz2lle(tGCS *gcs, double xyz[3], double lle[3]);
+
+
+/** Height map:\n
+ *  In case the height data stored in <em>.srtm</em> files should be used for
+ *  the terrain generation, it is included in form of a <em>Height map</em>.
+ *  The struct has a GCS module as a member.
+ *  \note <em>Height maps</em> are NOT suitable for the generation of a
+ *   <em>Height profile</em> for the road.
+ */
+typedef struct tHM	tHM;
+
+/** Function to generate and initialize a new <em>Height map</em>\n
+ *  This function sets the directory of the <em>Height map's</em> files and its
+ *  GCS module.
+ * \note To use this function special <em>Height map</em> files are needed.
+ * \param[in] fpath Path of the <em>Height map</em> files
+ * \param[in] lleRef Reference position in WGS84: latitude, longitude and
+ *  elevation of the global coordinates of the reference point &nbsp;
+ *  [deg, deg, m]
+ * \param[in] xyzRef Reference position in the IPGRoad coordinate system (Fr0):
+ *  (x,y,z)-coordinates of the reference point &nbsp; [m,m,m]
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> pointer to the new <em>Height map</em>
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see GCSDeleteHM()
+ */
+tHM*   GCSNewHM   (char *fpath, double lleRef[3], double xyzRef[3]);
+/** Function to delete a <em>Height map</em>
+ * \param[in] hm Pointer to the <em>Height map</em> that should be deleted
+ * \see GCSNewHM()
+ */
+void   GCSDeleteHM(tHM **hm);
+/** Function to read the files of a <em>Height map</em>
+ * \note To use this function special <em>Height map</em> files are needed.
+ * \param[in] hm Pointer to the <em>Height map</em> that should be read
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    GCSReadHM  (tHM **hm);
+/** Function to get the z-coordinate of a <em>Height map</em> at a given
+ *  position in the (x,y)-plane of the global IPGRoad coordinate system (Fr0)
+ * \note To use this function special <em>Height map</em> files are needed.
+ * \param[in] hm Pointer to the <em>Height map</em>
+ * \param[in] x X-coordinate of the given position
+ * \param[in] y Y-coordinate of the given position
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> z-coordinate of the <em>Height map</em> at (<b>x</b>,<b>y</b>)
+ *  <tr><td> In case of failure: <td> #GCS_UNKNOWN_ELEVATION
+ *  </table>
+ */
+double GCSGetHM_Z (tHM  *hm, double x, double y);
+
+
+/** @} */
+/******************************************************************************/
+/* +++ Splines ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup Splines
+ * @{
+ */
+/** Types of spline:\n
+ *  It is distinguished between <b>interpolation</b>, where the spline is
+ *  passing through all nodes, and <b>approximation</b>, where a spline
+ *  approximating the nodes permitting a maximum deviation is used.
+ */
+typedef enum tSplineType {
+
+    ST_IntPol_NaturalCubic = 0,		/**< <b>0</b> &nbsp;
+                                         * Interpolation with a natural cubic
+                                         * spline:\n
+					 * S'(0) = S'(n) = S''(0) = S''(n) 
+					 * = S'''(0) = S'''(n) = 0
+					 */
+    ST_IntPol_GivenBorderCurvature,	/**< <b>1</b> &nbsp;
+                                         * Interpolation with a cubic spline
+                                         * with given border curvature:\n
+					 * S'(0) = a,  S'(n)=b
+					 * \warning Not yet implemented! 
+					 */
+    ST_IntPol_GivenBorderTangent,	/**< <b>2</b> &nbsp;
+                                         * Interpolation with a cubic spline
+                                         * with given border tangent:\n
+					 * S''(0) = a, S''(n)=b
+					 */
+    ST_IntPol_GivenThirdBorderDeriv,	/**< <b>3</b> &nbsp;
+                                         * Interpolation with a cubic spline:
+					 * \n S'''(0)= a, S'''(n)=b
+					 * \warning Not yet implemented! 
+					 */
+    ST_IntPol_Periodic,			/**< <b>4</b> &nbsp; Interpolation with
+                                         * a periodic cubic spline
+					 * \warning Not yet implemented! 
+					 */
+    ST_IntPol_NotANode,			/**< <b>5</b> &nbsp;
+                                         * Interpolation with a cubic spline
+                                         * with not-a-node condition
+					 * \warning Not yet implemented!  
+					 */
+    ST_Approx_NaturalCubic,		/**< <b>6</b> &nbsp;
+                                         * Approximation with a natural cubic
+                                         * spline\n
+					 * S'(0) = S'(n) = S''(0) = S''(n) 
+					 * = S'''(0) = S'''(n) = 0
+					 */
+    ST_Approx_GivenBorderTangent,	/**< <b>7</b> &nbsp;
+                                         * Approximation with a cubic spline
+                                         * with given border tangent:\n
+					 * S''(0) = a, S''(n)=b
+                                         */
+    ST_Approx_GivenBorderCurvature,	/**< <b>8</b> &nbsp;
+                                         * Approximation with a cubic spline
+                                         * with given border curvature:\n
+					 * S'(0) = a,  S'(n)=b
+					 * \warning Not yet implemented! 
+					 */
+    ST_Approx_GivenThirdBorderDeriv,	/**< <b>9</b> &nbsp;
+                                         * Approximation with a cubic spline:
+					 * \n S'''(0)= a, S'''(n)=b
+					 * \warning Not yet implemented! 
+					 */
+    ST_Approx_Periodic,                 /**< <b>10</b> &nbsp; Approximation with
+                                         * a periodic cubic spline
+					 * \warning Not yet implemented! 
+					 */
+    ST_NSTypes				/**< <b>11</b> &nbsp;
+                                         *  Maximum number of spline types  
+					 */
+} tSplineType;
+
+
+/** @} */
+/******************************************************************************/
+/* --- One-dimensional splines ---------------------------------------------- */
+/******************************************************************************/
+
+
+/** \addtogroup OneDimSplines
+ * @{
+ */
+/** Function to generate a one-dimensional spline
+ * \param[in] n Number of nodes:
+ *  The resulting number of intervals is <b>n</b>-1.
+ * \param[in] s List of distances between the nodes (array of size <b>n</b>)
+ * \param[in] fs Values at the nodes (array of size <b>n</b>)
+ * \param[in] type Type of the spline
+ * \param[in] w List of the weights of the nodes (array of size <b>n</b>)
+ * \param[in] ds0 Derivation at the first node <b>s</b>[0]
+ * \param[in] ds1 Derivation at the last node <b>s</b>[<b>n</b>-1]
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> pointer to a struct containing the data of the new spline
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see SplineDelete()
+ */
+tSpline *SplineNew   (int n, double *s, double *fs, tSplineType type,
+				    double *w, double ds0, double ds1);
+/** Function to delete a one-dimensional spline\n
+ *  The memory of the spline is freed and the pointer to it is set to NULL.
+ * \param[in] sp Spline that should be deleted
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see SplineNew()
+ */
+int      SplineDelete(tSpline **sp);
+
+/** Function to get the number of nodes of a  one-dimensional spline
+ * \param[in] sp Pointer to the one-dimensional spline
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of nodes of the spline
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \deprecated Use SplineGetNodeCount() to get the number of nodes of a
+ *  one-dimensional spline.
+ */
+int    SplineGetNumOfNodes(tSpline  *sp);
+/** Function to get the number of nodes of a one-dimensional spline
+ * \param[in] sp Pointer to the one-dimensional spline
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of nodes of the spline
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    SplineGetNodeCount (tSpline  *sp);
+/** Function to get the length of a one-dimensional spline
+ * \param[in] sp Pointer to a one-dimensional spline
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> length of the spline in meters
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+double SplineLength       (tSpline *sp);
+
+/** Function to calculate the value of a one-dimensional spline at a given
+ *  offset
+ * \param[in] sp Pointer to the one-dimensional spline
+ * \param[in] s Given offset
+ * \param[out] fs Pointer to the value at <b>s</b>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> index of the interval of the spline <b>s</b> belongs to
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    SplineCalc(tSpline  *sp, double s, double *fs);
+
+/** Function to get the coefficients of a one-dimensional spline in the interval
+ *  a given offset belongs to
+ * \param[in] sp Pointer to the one-dimensional spline
+ * \param[in] s Given offset
+ * \param[out] si Offset of <b>s</b> from the start of the interval <b>s</b>
+ *  belongs to
+ * \param[out] c Array for the coefficients of the spline in the interval
+ *  <b>s</b> belongs to
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> index of the interval <b>s</b> belongs to
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see SplineGetCoeffByIdx()
+ */
+int    SplineGetCoefficients(tSpline  *sp, double s, double *si, double c[4]);
+/** Function to get the inclination of a one-dimensional spline in the interval
+ *  a given offset belongs to
+ * \param[in] sp Pointer to the one-dimensional spline
+ * \param[in] s Given offset
+ * \param[out] inclination Inclination of the spline in the interval <b>s</b>
+ *  belongs to
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> index of the interval <b>s</b> belongs to
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    SplineGetInclination (tSpline  *sp, double s, double *inclination);
+
+/** Function to get the offset of a certain node of a given one-dimensional
+ *  spline
+ * \param[in] sp Pointer to the one-dimensional spline
+ * \param[in] idx Index of the given node
+ * \param[out] s Offset of the node
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> index of the node
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    SplineGetSByIdx    (tSpline  *sp, int idx, double *s);
+/** Function to get the coefficients of a given one-dimensional spline in a
+ *  certain interval
+ * \param[in] sp Pointer to the one-dimensional spline
+ * \param[in] idx Index of the given interval
+ * \param[out] c Array for the coefficients of the spline in the given interval
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> index of the interval
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    SplineGetCoeffByIdx(tSpline  *sp, int idx, double c[4]);
+
+
+/** @} */
+/******************************************************************************/
+/* --- Parametric splines --------------------------------------------------- */
+/******************************************************************************/
+
+
+/** \addtogroup TwoThreeDimSplines
+ * @{
+ */
+/** Types of parametrization:\n
+ *  Parametrization types used for two- and three-dimensional splines.
+ */
+typedef enum tSplineParametrisationType {
+    SPT_Chordal,		/**< <b>0</b> &nbsp;
+                                 * Using the Euclidean distance
+				 */
+    SPT_ArcLength,		/**< <b>1</b> &nbsp;
+                                 * Using an estimation of the arc length
+				 */
+    SPT_ChordalXY,		/**< <b>2</b> &nbsp;
+                                 * Using the Euclidean distance in XY
+                                 * \note
+                                 * This type allows to use a three dimensional
+                                 * spline, but the parametrization is done in
+                                 * the (x,y)-plane (not considering z).
+				 */
+    SPT_ArcLengthXY,		/**< <b>3</b> &nbsp;
+                                 * Using an estimation of the arc length in XY
+                                 * \note
+                                 * This type allows to use a three dimensional
+                                 * spline, but the parametrization is done in
+                                 * the (x,y)-plane (not considering z).
+				 */
+    SPT_Integrated,		/**< <b>4</b> &nbsp;
+                                 * Using the polygonal chain through vertices
+                                 * at a distance of 0.25 meters: The lengths of
+                                 * all line segments is summarized.
+				 */
+    SPT_IntegratedXY,		/**< <b>5</b> &nbsp;
+                                 * Using the polygonal chain through vertices
+                                 * at a distance of 0.25 meters in XY:
+                                 * The lengths of
+                                 * all line segments is summarized.
+                                 * \note
+                                 * This type allows to use a three dimensional
+                                 * spline, but the parametrization is done in
+                                 * the (x,y)-plane (not considering z).
+				 */
+} tSplineParametrisationType;
+
+/** Function to generate a new two-dimensional spline
+ * \param[in] n Number of nodes: The resulting number of intervals is
+ *  <b>n</b>-1.
+ * \param[in] xy List of nodes in the two-dimensional plane
+ *  (array of size <b>n</b>)
+ * \param[in] sType Type of spline
+ * \param[in] pType Type of parametrization
+ * \param[in] w List of weights of the nodes (array of size <b>n</b>):
+ *  depending on the spline type
+ * \param[in] dv0 Direction vector for the first node <b>xy</b>[0]:
+ *  depending on the spline type
+ * \param[in] dv1 Direction vector for the last node <b>xy</b>[<b>n</b>-1]:
+ *  depending on the spline type
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> pointer to a struct containing the data of the new spline
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see Spline2DNewExt() \see Spline2DDelete()
+ */
+tSpline2D *Spline2DNew   (int n, double (*xy)[2],
+			  tSplineType sType, tSplineParametrisationType pType,
+				       double *w, double dv0[2], double dv1[2]);
+/** Function to generate a new two-dimensional spline\n
+ *  <em><b>Extended version:</b></em> A given parametrization can be used.
+ * \param[in] n Number of nodes: The resulting number of intervals is
+ *  <b>n</b>-1.
+ * \param[in] xy List of nodes in the two-dimensional plane
+ *  (array of size <b>n</b>)
+ * \param[in] s Pointer to the given parametrization (array of size <b>n</b>)\n
+ *  If this parameter is the NULL pointer, the parametrization is done
+ *  considering the parametrization type.
+ * \param[in] sType Type of spline
+ * \param[in] pType Type of parametrization (only relevant if no parametrization
+ *  is given)
+ * \param[in] w List of weights of the nodes (array of size <b>n</b>):
+ *  depending on the spline type
+ * \param[in] dv0 Direction vector for the first node <b>xy</b>[0]:
+ *  depending on the spline type
+ * \param[in] dv1 Direction vector for the last node <b>xy</b>[<b>n</b>-1]:
+ *  depending on the spline type
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> pointer to a struct containing the data of the new spline
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see Spline2DNew()
+ */
+tSpline2D *Spline2DNewExt(int n, double (*xy)[2], double *s,
+			  tSplineType sType, tSplineParametrisationType pType,
+				       double *w, double dv0[2], double dv1[2]);
+/** Function to delete a two-dimensional spline\n
+ *  The memory of the spline is freed and the pointer to it is set to NULL. 
+ * \param[in] sp Two-dimensional spline that should be deleted
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    Spline2DDelete(tSpline2D **sp);
+
+/** Function to get the number of nodes of a given two-dimensional
+ *  spline
+ * \param[in] sp Pointer to the two-dimensional spline
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of nodes of the spline
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \deprecated Use Spline2DNodeCount() get the number of nodes of a 
+ *  two-dimensional spline.
+ */
+int    Spline2DNumOfNodes(tSpline2D *sp);
+/** Function to get the number of nodes of a given two-dimensional spline
+ * \param[in] sp Pointer to the two-dimensional spline
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of nodes of the spline
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    Spline2DNodeCount (tSpline2D *sp);
+/** Function to get the length of a given two-dimensional spline
+ * \param[in] sp Pointer to the two-dimensional spline
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> length of the spline in meters
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+double Spline2DLength    (tSpline2D *sp);
+
+/** Function to calculate the value and the direction vector of a
+ *  two-dimensional spline at a given offset
+ * \param[in] sp Pointer to the two-dimensional spline
+ * \param[in] s Given offset
+ * \param[out] xy Value of the spline at <b>s</b>
+ * \param[out] dvXY Direction vector of the spline at <b>s</b>\n 
+ *  <em><b>Note</b></em>: Discarded in case this parameter is the NULL pointer.
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> index of the interval <b>s</b> belongs to
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    Spline2DCalc(tSpline2D *sp, double s, double xy[2], double dvXY[2]);
+
+/** Function to convert a given position in the (x,y)-plane of the global
+ *  IPGRoad coordinate system (Fr0) to the corresponding position in the local
+ *  coordinate system of a given two-dimensional spline
+ * \param[in] sp Pointer to the two-dimensional spline
+ * \param[in] dir Given search direction
+ * \param[in] s Given s-offset on the spline
+ * \param[in] xy Given position in the (x,y)-plane of the global IPGRoad
+ *  coordinate system (Fr0) 
+ * \param[out] st Calculated position in the local coordinate system of the
+ *  spline
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> index of the interval <b>st</b>[0] belongs to
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    Spline2DXY2ST (tSpline2D  *sp, int dir, double s,
+                                                    double xy[2], double st[2]);
+
+/** Function to set the coefficients of a two-dimensional spline in a given
+ *  interval
+ * \param[in] sp Pointer to the two-dimensional spline
+ * \param[in] idx Index of the given interval
+ * \param[in] s Offset of the interval relative to the start of the spline
+ * \param[in] cx Array with the coefficients of the two-dimensional spline in
+ *  the interval in x-direction
+ * \param[in] cy Array with the coefficients of the two-dimensional spline in
+ *  the interval in y-direction
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> index of the given interval
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    Spline2DSetCoefficients (tSpline2D *sp, int idx, double s,
+                                                    double cx[4], double cy[4]);
+/** Function to get the coefficients of a two-dimensional spline in the interval
+ *  a given offset belongs to
+ * \param[in] sp Pointer to the two-dimensional spline
+ * \param[in] s Given s-offset on the spline
+ * \param[out] si Offset of <b>s</b> from the start of the interval <b>s</b>
+ *  belongs to
+ * \param[out] cx Array for the coefficients of the two-dimensional spline in
+ *  the interval <b>s</b> belongs to in x-direction
+ * \param[out] cy Array for the coefficients of the two-dimensional spline in
+ *  the interval <b>s</b> belongs to in y-direction
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> index of the interval <b>s</b> belongs to
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    Spline2DGetCoefficients       (tSpline2D *sp, double s, double *si, 
+                                                    double cx[4], double cy[4]);
+
+/** Function to get position and s-offset of a certain node of a two-dimensional
+ *  spline
+ * \param[in] sp Pointer to the two-dimensional spline
+ * \param[in] idx Index of the interval starting with the node
+ * \param[out] s Offset of the node on the spline
+ * \param[out] x x-coordinate of the node
+ * \param[out] y y-coordinate of the node
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> index of the given interval
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */                                    
+int    Spline2DGetNode               (tSpline2D *sp, int idx, double *s, 
+                                                          double *x, double *y);
+/** Function to get the normal unit vector and the curvature of a
+ *  two-dimensional spline at a given offset
+ * \param[in] sp Pointer to the two-dimensional spline
+ * \param[in] s Given offset
+ * \param[out] normVec Normal unit vector of the spline at <b>s</b>
+ * \param[out] curvature Curvature of the spline at <b>s</b>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> index of the interval <b>s</b> belongs to
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    Spline2DGetNormVecAndCurvature(tSpline2D *sp, double s,
+					  double normVec[2], double *curvature);
+/** Function to get the normal unit vector and the curvature of a
+ *  two-dimensional spline at a given node
+ * \param[in] sp Pointer to the two-dimensional spline
+ * \param[in] nodeIdx Index of the given node
+ * \param[out] normVec Normal unit vector of the spline at the given node
+ * \param[out] curvature Curvature of the spline at the given node
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    Spline2DGetNormVecAndCurvatureAtNode ( tSpline2D *sp, int nodeIdx,
+                                          double normVec[2], double *curvature);
+/** Function to get the normalized direction vector of a two-dimensional spline
+ *  at a given node
+ * \param[in] sp Pointer to the two-dimensional spline
+ * \param[in] nodeIdx Index of the given node
+ * \param[out] dir Normalized direction vector
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    Spline2DGetNormDirectionVectorAtNode (tSpline2D *sp, int nodeIdx,
+                                          double dir[2]);
+
+
+/** Function to generate a new three-dimensional spline
+ * \param[in] n Number of nodes: The resulting number of intervals is
+ *  <b>n</b>-1.
+ * \param[in] xyz List of nodes in the three-dimensional space
+ *  (array of size <b>n</b>)
+ * \param[in] sType Type of spline
+ * \param[in] pType Type of parametrization
+ * \param[in] w List of weights of the nodes (array of size <b>n</b>:
+ *  depending on the spline type 
+ * \param[in] dv0 Direction vector for the first node <b>xyz</b>[0]:
+ *  depending on the spline type
+ * \param[in] dv1 Direction vector for the last node <b>xyz</b>[<b>n</b>-1]:
+ *  depending on the spline type
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> pointer to a struct containing the data of the new spline
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see Spline3DNewExt() \see Spline3DDelete()
+ */
+tSpline3D *Spline3DNew   (int n, double (*xyz)[3],
+			  tSplineType sType, tSplineParametrisationType pType,
+				       double *w, double dv0[3], double dv1[3]);
+/** Function to generate a new three-dimensional spline\n
+ *  <em><b>Extended version:</b></em> A given parametrization can be used.
+ * \param[in] n Number of nodes: The resulting number of intervals is
+ *  <b>n</b>-1.
+ * \param[in] xyz List of nodes in the three-dimensional space
+ *  (array of size <b>n</b>)
+ * \param[in] s Pointer to the given parametrization (array of size <b>n</b>)\n
+ *  If this parameter is the NULL pointer, the parametrization is done
+ *  considering the parametrization type.
+ * \param[in] sType Type of spline
+ * \param[in] pType Type of parametrization (only relevant if no parametrization
+ *  is given)
+ * \param[in] w List of weights of the nodes (array of size <b>n</b>):
+ *  depending on the spline type;
+ * \param[in] dv0 Direction vector for the first node <b>xyz</b>[0]:
+ *  depending on the spline type
+ * \param[in] dv1 Direction vector for the last node<b>xyz</b>[0]:
+ *  depending on the spline type
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> pointer to a struct containing the data of the new spline
+ *  <tr><td> In case of failure: <td> NULL pointer
+ *  </table>
+ * \see Spline3DNew()
+ */
+tSpline3D *Spline3DNewExt(int n, double (*xyz)[3], double *s, 
+			  tSplineType sType, tSplineParametrisationType pType,
+				       double *w, double dv0[3], double dv1[3]);
+/** Function to delete a three-dimensional spline\n
+ * The memory of the spline is freed and the pointer to it is set to NULL. 
+ * \param[in] sp Three-dimensional spline that should be deleted
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see Spline3DNew()
+ */
+int        Spline3DDelete(tSpline3D **sp);
+
+/** Function to get the number of nodes of a given three-dimensional spline
+ * \param[in] sp Pointer to the three-dimensional spline
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of nodes of the spline
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \deprecated Use Spline3DNodeCount() to get the number of nodes of a three-
+ *  dimensional spline.
+ */
+int    Spline3DNumOfNodes(tSpline3D *sp);
+/** Function to get the number of nodes of a given three-dimensional spline
+ * \param[in] sp Pointer to the three-dimensional spline
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of nodes of the spline
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    Spline3DNodeCount (tSpline3D *sp);
+/** Function to get the length of a given three-dimensional spline
+ * \param[in] sp Pointer to a three-dimensional spline
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> length of the spline in meters
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+double Spline3DLength    (tSpline3D *sp);
+
+/** Function to calculate the value and the direction vector of a
+ *  three-dimensional spline at a given offset
+ * \param[in] sp Pointer to the three-dimensional spline
+ * \param[in] s Given offset
+ * \param[out] xyz Value of the spline at <b>s</b>
+ * \param[out] dvXYZ Direction vector of the spline at <b>s</b>\n 
+ *  <em><b>Note</b></em>: Discarded in case this parameter is the NULL pointer.
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> index of the interval <b>s</b> belongs to
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road. 
+ *  </table>
+ */
+int    Spline3DCalc(tSpline3D *sp, double s, double xyz[3], double dvXYZ[3]);
+
+/** Function to get the coefficients of a three-dimensional spline
+ *  in the interval a given offset belongs to
+ * \param[in] sp Pointer to the three-dimensional spline
+ * \param[in] s Given offset
+ * \param[out] si Offset of <b>s</b> from the end of the interval <b>s</b>
+ *  belongs to
+ * \param[out] cx Array for the coefficients of the three-dimensional spline in
+ *  the interval <b>s</b> belongs to in x-direction
+ * \param[out] cy Array for the coefficients of the three-dimensional spline in
+ *  the interval <b>s</b> belongs to in y-direction
+ * \param[out] cz Array for the coefficients of the three-dimensional spline in
+ *  the interval <b>s</b> belongs to in z-direction
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> index of the interval <b>s</b> belongs to
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    Spline3DGetCoefficients       (tSpline3D *sp, double s, double *si,
+				      double cx[4], double cy[4], double cz[4]);
+/** Function to get the normal unit vector and the curvature of a 
+ *  three-dimensional spline at a given offset
+ * \param[in] sp Pointer to the three-dimensional spline
+ * \param[in] s Given offset
+ * \param[out] normVec Normal unit vector of the spline at <b>s</b>
+ * \param[out] curvature Curvature of the spline at <b>s</b>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> index of the interval <b>s</b> belongs to
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    Spline3DGetNormVecAndCurvature(tSpline3D *sp, double s,
+					  double normVec[3], double *curvature);
+
+
+
+/** @} */
+/******************************************************************************/
+/* === Error Codes ========================================================== */
+/******************************************************************************/
+
+
+/** \addtogroup ErrorCodes
+ * @{
+ */
+
+/*** General Errors ***/
+
+/** General error: no builder finish necessary\note
+ *  Possible return value of #RoadBuilderFinish().
+ */
+#define ROAD_NoBF			 2
+/** General error: cancel 
+ */
+#define ROAD_Cancel			 1
+/** General error: all correct
+ */
+#define ROAD_Ok				 0
+/** General error: general error
+ */
+#define ROAD_Error			-1
+/** General error: warning
+ */
+#define ROAD_Warn			-2
+/** General error: license error
+ */
+#define ROAD_LicError			-3
+/** General error: memory error
+ */
+#define ROAD_MemError			-4
+/** General error: invalid road handle
+ * \see ROAD_RoadHandleError
+ */
+#define ROAD_BadRoad			-5
+/** General error: invalid road\n
+ *  Builder finish necessary
+ */
+#define ROAD_InvalidRoad		-6
+/** General error: object id error\n
+ * \see ROAD_InvalidObjId
+ */
+#define ROAD_ObjIdErr			-7
+/** General error: maximum number of errors reached
+ */
+#define ROAD_ReachedMaxError		-8
+/** General error: empty road\n
+ *  An instance of the road is called empty, if no <em>Link</em> is defined.
+ */
+#define ROAD_EmptyRoad			-9
+
+
+/*** Road Definition Errors ***/
+
+/** Road definition error: data error
+ * \see ROAD_ParamError
+ */
+#define ROAD_DataError		       -10
+/** Road definition error: external file error
+ */
+#define ROAD_ExtFileError	       -11
+/** Road definition error: Link error
+ */
+#define ROAD_LinkError		       -12
+/** Road definition error: Junction error
+ */
+#define ROAD_JuncError		       -13
+/** Road definition error: Segment error
+ */
+#define ROAD_SegmentError	       -14
+/** Road definition error: Lane section error
+ */
+#define ROAD_LaneSectionError	       -15
+/** Road definition error: Lane error
+ */
+#define ROAD_LaneError		       -25
+/** Road definition error: Height profile error
+ */
+#define ROAD_LaneZProfileError	       -16
+/** Road definition error: Bump error
+ */
+#define ROAD_BumpError		       -17
+/** Road definition error: Marker error
+ */
+#define ROAD_MarkerError	       -18
+/** Road definition error: Sensor object error
+ */
+#define ROAD_SensorObjectError	       -19
+/** Road definition error: object list error
+ */
+#define ROAD_ObjectListError	       -20
+/** Road definition error: Route error
+ */
+#define ROAD_RouteError		       -21
+/** Road definition error: Path error
+ */
+#define ROAD_PathError		       -22
+/** Road definition error: parameter error
+ * \see ROAD_DataError
+ */
+#define ROAD_ParamError		       -23
+
+
+/*** Road File IO Errors ***/
+
+/** Road file IO error: file not found
+ */
+#define ROAD_FileNotFound	       -30
+/** Road file IO error: unknown file format
+ */
+#define ROAD_FileUnknownFormat	       -31
+/** Road file IO error: error reading from a file
+ */
+#define ROAD_FileReadError	       -32
+/** Road file IO error: error writing on a file
+ */
+#define ROAD_FileWriteError	       -33
+/** Road file IO error: error reading from a road 4.5 file
+ */
+#define ROAD_File45Error	       -34
+/** Road file IO error: file ident error
+ */
+#define ROAD_FileIdentError	       -35
+/** Road file IO error: invalid binary file
+ */
+#define ROAD_BadBinFile		       -36
+/** Road file IO error: invalid external file
+ */
+#define ROAD_BadDigFile		       -37
+/** Road file IO error: error opening a file
+ */
+#define ROAD_FileOpenError	       -38
+/** Road file IO error: file name error
+ */
+#define ROAD_FileNameError	       -39
+
+
+/*** Road InfoFile Errors ***/
+
+/** Road InfoFile error: InfoFile error
+ */
+#define ROAD_InfError		       -40
+/** Road InfoFile error: InfoFile warning
+ */
+#define ROAD_InfWarn		       -41
+/** Road InfoFile error: missing key in InfoFile
+ */
+#define ROAD_InfMissingKey	       -42
+
+
+/*** Road Spline Errors ***/
+
+/** Road spline error: spline error
+ */
+#define ROAD_SplineError	       -50
+
+
+/*** Road GCS Errors ***/
+
+/** Road GCS error: GCS error
+ */
+#define ROAD_GCSError		       -60
+
+
+/*** Road Update Errors ***/
+
+/** Update error: error updating a <em>Link</em>
+ */
+#define ROAD_UpdateLinkError	       -70
+/** Update error: error updating a <em>Segment</em> of a <em>Link</em>
+ */
+#define ROAD_UpdateLinkSegError	       -71
+/** Update error: error updating a <em>Lane section</em> of a <em>Link</em>
+ */
+#define ROAD_UpdateLinkLSError	       -72
+/** Update error: error updating the <em>Elevation profile</em> of a
+ *  <em>Link</em>
+ */
+#define ROAD_UpdateLinkZElevError      -73
+/** Update error: error updating the <em>Slope profile</em> of a <em>Link</em>
+ */
+#define ROAD_UpdateLinkZSlopeError     -74
+/** Update error: error updating the <em>Camber profile</em> of a <em>Link</em>
+ */
+#define ROAD_UpdateLinkZCamberError    -75
+/** Update error: error updating a <em>Bump</em> of a <em>Link</em>
+ */
+#define ROAD_UpdateLinkBumpError       -76
+/** Update error: error updating a marker of a <em>Link</em>
+ */
+#define ROAD_UpdateLinkMarkerError     -77
+/** Update error: error updating a sensor object of a <em>Link</em>
+ */
+#define ROAD_UpdateLinkSensorObjError  -78
+
+/** Update error: error updating a <em>Junction</em>
+ */
+#define ROAD_UpdateJuncError	       -80
+
+
+/*** Road Connect Errors ***/
+
+/** Connect error: error connecting a <em>Link</em> to a <em>Junction</em>\n
+ *  The <em>Link</em> is already connected.\note
+ *  Possible return value of #RoadJunctionArmConnectLink().
+ */
+#define ROAD_JuncConnectError	       -90
+/** Connect error: position error connecting a <em>Link</em> and a
+ *  <em>Junction</em>\n
+ *  Link node and junction knot don't match or the <em>Reference line</em>
+ *  failed to be updated. \note 
+ *  Possible return value of #RoadJunctionArmConnectLink().
+ */
+#define ROAD_JuncConnectXYError	       -91
+/** Connect error: z-offset error connecting a <em>Link</em> and a
+ *  <em>Junction</em>\n
+ *  The update of the <em>Link's</em> <em>Elevation profile</em> failed or the
+ *  elevation in the link node and the junction knot don't match. \note
+ *  Possible return value of #RoadJunctionArmConnectLink().
+ */
+#define ROAD_JuncConnectZError	       -92
+/** Connect error: angle error connecting a <em>Link</em> and a
+ *  <em>Junction</em>\note
+ *  Possible return value of #RoadJunctionArmConnectLink().
+ */
+#define ROAD_JuncConnectAngleError     -93
+
+/** Connect error: general connect error\note
+ *  Possible return value of #RoadConnect().
+ */
+#define ROAD_ConnectError             -100
+
+
+/*** Handle Errors ***/
+
+/** Handle error: road handle error
+ */
+#define ROAD_RoadHandleError          -110
+/** Handle error: evaluation handle error
+ */
+#define ROAD_EvalHandleError          -111
+/** Handle error: Route handle error
+ */
+#define ROAD_RouteHandleError         -112
+
+
+/*** Evaluation Errors ***/
+
+/** Evaluation error: general evaluation error
+ */
+#define ROAD_EvalError                -120
+/** Evaluation error: invalid <em>Link</em>\note
+ *  Possible return value of #RoadLinkGeoEval().
+ */
+#define ROAD_EvalInvalidLink          -121
+/** Evaluation error: invalid <em>Reference line</em>\note
+ *  Possible return value of #RoadRefLineGeoEval().
+ */
+#define ROAD_EvalInvalidRefline       -122
+/** Evaluation error: invalid <em>Route</em>
+ */
+#define ROAD_EvalInvalidRoute         -123
+/** Evaluation error: invalid <em>Lane</em>
+ */
+#define ROAD_EvalInvalidLane          -124
+/** Evaluation error: not a number
+ */
+#define ROAD_EvalNANError             -125
+
+
+/*** Route Errors ***/
+
+/** Route error: Route version 6
+ */
+#define ROAD_Route6Error              -150
+/** Route error: Route version 7
+ */
+#define ROAD_Route7Error              -151
+
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/test/testipgroad/roadbuilder.h

@@ -0,0 +1,7615 @@
+/*
+** IPGRoad - Version 10.0
+** Copyright (C) IPG Automotive GmbH
+**               Bannwaldallee 60, D-76185 Karlsruhe, Germany
+**               Tel. +49 (0)721 98520-0, Fax +49 (0)721 98520-99
+*/
+
+#ifndef ROADBUILDER_H
+#define	ROADBUILDER_H
+
+#include "road.h"
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/** \file roadbuilder.h
+ * This header file mainly contains the functions, structs, enumerations and
+ * macros that are used to create a road scenario.
+ */ 
+      
+/******************************************************************************/
+/* === General ============================================================== */
+/******************************************************************************/
+
+
+/** \addtogroup General
+ * @{
+ */
+/** Undefined road parameter:\n
+ *  Macro used to flag parameters of road objects as undefined.
+ */
+#define ROAD_UNDEFINED -999
+
+    
+/** General transition types:\n
+ *  The transition type describes how supporting points are interpolated to
+ *  construct new data points between them.
+ *  This is used to describe lane width, connector path width, lateral offset,
+ *  height profiles and general one-dimensional node profiles as well as for
+ *  some of the additional objects and <em>Segments</em> of type <em>File</em>.
+ */
+typedef enum tRoadTransitionType {    
+    RTT_Cubic  = 0,	/**< <b>0</b> &nbsp; Cubic interpolation:\n
+			 * Two points are connected by a third-degree polynomial
+                         * (cubic spline).
+			 */
+    RTT_Linear = 1,	/**< <b>1</b> &nbsp; Linear interpolation:\n
+			 * Two points are connected by a first-degree polynomial
+                         * (straight line).
+			 */
+    RTT_Step0  = 2,	/**< <b>2</b> &nbsp; Step interpolation:\n
+			 * The function value between two points is the same as
+                         * in the point with minor argument value.
+			 */
+    RTT_Step1  = 3,	/**< <b>3</b> &nbsp; Step reverse interpolation:\n
+			 * The function value between two points is the same as
+                         * in the point with major argument value.
+			 */
+    RTT_None   = 4	/**< <b>4</b> &nbsp; Polynomial interpolation:\n
+			 * Two points are connected by the third-degree
+                         * polynomial defined by the coefficients given by the
+                         * user.\n
+                         * \note Only for the use with \ref tRoadLane::type
+                         * "lane" or \ref tRoadConPath "connector path width"
+                         * and \ref tRoadNode1DProfile.type
+                         * "one-dimensional node profile".
+			 * \warning This might lead to a saltus in the width or
+			 * height profile.
+			 */
+} tRoadTransitionType;
+
+/** Line kinds:\n
+ *  Used for <em>Road markings</em>, <em>Traffic barriers</em> and
+ *  <em>Raised profiles</em>
+ */
+typedef enum tRoadLineKind {
+    RLK_Offset = 0,	/**< <b>0</b> &nbsp; Parallel to the lateral reference
+			 */
+    RLK_Polyline,	/**< <b>1</b> &nbsp; Point list represents a polyline:
+			 * \note Only used for <em>Road markings</em>.
+			 */
+    RLK_Spline,		/**< <b>2</b> &nbsp; Point list represents spline nodes
+			 */
+    RLK_Unknown		/**< <b>3</b> &nbsp; Unknown line kind
+			 */
+} tRoadLineKind;
+
+
+/** Function to check whether the path of a file is correct\n
+ *  In case no path is given and the file belongs to the road directory, its
+ *  absolute path is saved. 
+ * \param[in] fnameIn Name and absolute or relative path of a file or name of a
+ *  file in the road directory
+ * \param[out] fnameOut Pointer to the file name including its path: If the file 
+ *  belongs to the road directory, its absolute path is saved. 
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> 1\n
+ *  <tr><td> In case of failure: <td> 0
+ *  </table>
+ */
+int    RoadCheckPath(const char *fnameIn, char **fnameOut);
+
+
+/** @} */
+/******************************************************************************/
+/* +++ Material +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup Material
+ * @{
+ */
+/** Fitting modes for the material:\n
+ *  Used for the \ref tRoadMaterial::fitMode "fitting" of a texture.
+ */
+typedef enum tRoadMaterialFitMode {
+    RMFM_Scale2Fit,     /**< <b>0</b> &nbsp;
+                         * The texture is mapped to the entire surface.   
+			 */
+    RMFM_Absolute,      /**< <b>1</b> &nbsp; The texture is mapped to a surface
+                         * of size \ref tRoadMaterial.fitFac "fitFac".
+			 */
+    RMFM_Relative,      /**< <b>2</b> &nbsp; The surface width/length is divided
+                         * by \ref tRoadMaterial.fitFac "fitFac".
+			 */
+} tRoadMaterialFitMode;
+
+/** Fitting positions for the material:\n
+ *  Used for the \ref tRoadMaterial::fitPos "alignment" of a texture.
+ */
+typedef enum tRoadMaterialFitPos {    
+    RMFP_Center = 0,	/**< <b>0</b> &nbsp; The center of the texture is mapped
+			 * to the center of the surface.
+			 */
+    RMFP_Left,		/**< <b>1</b> &nbsp; The left side of the texture is
+			 * mapped to the left side of the surface.
+			 */
+    RMFP_Right		/**< <b>2</b> &nbsp; The right side of the texture is
+			 * mapped to the right side of the surface.
+			 */
+} tRoadMaterialFitPos;
+
+//! Material
+/** Struct for the parameters of the material added to a road object
+ */
+typedef struct tRoadMaterial {    
+    char  *file;	/**< Name of a texture file or string representing a
+			 * color
+			 */
+    int   mirror[2];	/**< Mirroring the texture along the x-and y-axes:
+                         * - 0 &harr; The texture is not mirrored along the
+                         * x/y-axis.
+                         * - 1 &harr; The texture is mirrored along the x/y-axis.
+			 */
+    int   fitMode[2];	/**< \ref tRoadMaterialFitMode 
+                         * "Material fitting mode" in (x,y)-direction  
+			 */
+    int   fitPos[2]; 	/**< \ref tRoadMaterialFitPos
+                         * "Material fitting position" in (x,y)-direction
+                         */
+    float fitFac[2];	/**< Scaling factors for the \ref tRoadMaterial::fitMode
+                         * "fitting modes" \ref RMFM_Relative "relative" and
+                         * \ref RMFM_Absolute "absolute" in (x,y)-direction
+			 */
+    float fitOff[2]; 	/**< Offset to move the texture relative to the 
+                         * \ref tRoadMaterial.fitPos "fitting position" in
+			 * (x,y)-direction
+			 */
+    float angle;	/**< Rotation angle for the orientation of the texture
+			 * in degrees
+			 */
+} tRoadMaterial;
+
+
+/** Function to get the material of a road object
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the road object
+ * \param[in] surface Additional variable for
+ * - <em>\ref tRoadTrafficBarrier "Traffic barrier"</em>:
+ *   - 0 &harr; material for the barrier
+ *   - 1 &harr; material for the pole
+ * - <em>\ref tRoadBumpRaisedProfile "Raised profile"</em>:
+ *   - 0 &harr; material for the gutter
+ *   - 1 &harr; material for the curb
+ *   - 2 &harr; material for the sidewalk
+ *   - 3 &harr; material for the inner area
+ * \param[out] mat Pointer to a struct for the material of the road object
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadObjectSetMaterial()
+ */
+int    RoadObjectGetMaterial(tRoad *road, tObjId objId, int surface,
+							    tRoadMaterial *mat);
+/** Function to set the material of a road object
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the road object
+ * \param[in] surface Additional variable for
+ * - <em>\ref tRoadTrafficBarrier "Traffic barrier"</em>:
+ *   - 0 &harr; material for the barrier
+ *   - 1 &harr; material for the pole
+ * - <em>\ref tRoadBumpRaisedProfile "Raised profile"</em>:
+ *   - 0 &harr; material for the gutter
+ *   - 1 &harr; material for the curb
+ *   - 2 &harr; material for the sidewalk
+ *   - 3 &harr; material for the inner area
+ * \param[in] mat Pointer to a struct with the material
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadObjectGetMaterial()
+ */
+int    RoadObjectSetMaterial(tRoad *road, tObjId objId, int surface,
+							    tRoadMaterial *mat);
+
+
+
+/** @} */
+/******************************************************************************/
+/* === Edit ================================================================= */
+/******************************************************************************/
+
+
+/******************************************************************************/
+/* +++ General ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup GeneralEdit
+ * @{
+ */
+/** Function to set the string for the road parameter <em>FileCreator</em> of a
+ * road instance
+ * \param[in,out] road Handle of the road instance
+ * \param[in] creatorStr String with a description how the file was created
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadSetCreatorStr    (tRoad *road, const char *creatorStr);
+
+/** Function to set the string for the road parameter <em>Description</em> of a
+ * road instance
+ * \param[in,out] road Handle of the road instance
+ * \param[in] description String array with a description: The last array entry
+ *  must be the NULL pointer.
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadSetDescription (tRoad *road, char *const *description);
+/** Function to get the string for the road parameter <em>Description</em> of a
+ * road instance
+ * \note The user is responsible to free allocated memory,
+ *  e.g. free(description[0..n]) , free(description).
+ * \param[in] road Handle of the road instance
+ * \param[out] description String array with a description: The last array entry
+ *  is a NULL pointer. 
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetDescription (tRoad *road, char ***description);
+
+/** Function to force the recalculation of all objects of a road instance with
+ *  the next builder update:\n
+ *  The road instance is marked as invalid.
+ * \param[in,out] road Handle of the road instance
+ */
+void   RoadSetAllUpdateFlags(tRoad *road);
+/** Function to do a builder update: All objects of a road instance that are
+ *  flagged accordingly are recalculated.
+ * \param[in,out] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadBuilderUpdate    (tRoad *road);
+/** Function to do a builder finish: A final completion is carried out in
+ *  preparation for the evaluation of a road instance.
+ * \param[in,out] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadBuilderFinish    (tRoad *road);
+
+/** Function to check whether a road instance needs to be saved
+ * \param[in] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> flag indicating whether the saving of the road instance is necessary:
+ *  <tr><td><td> 
+ *  - 0 &harr; no saving necessary
+ *  - 1 &harr; saving necessary
+ *  - 2 &harr; no saving necessary, but the road instance could be updated to
+ *  the current version of the IPGRoad Library
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadSetDirty()
+ */
+int    RoadIsDirty (tRoad *road);
+/** Function to specify whether a road instance needs to be saved
+ * \param[in,out] road Handle of the road instance
+ * \param[in] dirty Parameter determining whether the saving of the road
+ *  instance is necessary:
+ *  - 0 &harr; saving not necessary
+ *  - 1 &harr; saving necessary
+ * \see RoadIsDirty()
+ */
+void   RoadSetDirty(tRoad *road, int dirty);
+/** Function to mark a road instance as saved\n
+ *  \note Since the saving of a road instance is only possible in the current
+ *   version of the IPGRoad Library, the flags for the file format version of
+ *   the road instance are set accordingly.
+ * \param[in,out] road Handle of the road instance
+ */
+void   RoadSetSaved(tRoad *road);
+
+/** Function to add a new mapping list to a road instance\n
+ * A mapping list contains two arrays of strings and the type of object they 
+ * are related to.
+ * Currently this is only used to assign the old names of the <em>Traffic
+ * signs</em> to the new ones.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] type Type of road object the list is related to
+ * \param[in] old Pointer to an array with the "old" strings
+ * \param[in] act Pointer to an array with the "new" strings
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadDeleteMappingLists()
+ */
+int    RoadAddMappingList    (tRoad *road, tRoadObjectType type,
+                                            const char **old, const char **act);
+/** Function to delete all mapping lists of a road instance
+ * \param[in,out] road Handle of the road instance
+ * \see RoadAddMappingList()
+ */
+void   RoadDeleteMappingLists(tRoad *road);
+
+
+/** @} */
+/******************************************************************************/
+/* --- One-dimensional nodes ------------------------------------------------ */
+/******************************************************************************/
+
+/** \addtogroup OneDNodesEdit
+ * @{
+ */
+//! One-dimensional node
+/** Struct for the parameters of a one-dimensional node used for the width of
+ *  <em>\ref tRoadLane.width "Lanes"</em> and <em>\ref tRoadConPath
+ *  "Connector paths"</em>, <em>\ref tRoadLateralOffset "Lateral offsets"</em>,
+ *  <em>\ref tRoadZP "Height profiles"</em> and general \ref tRoadNode1DProfile
+ *  "one-dimensional profiles"
+ */
+typedef struct tRoadNode1D {    
+    double              s;	/**< Offset in s-direction in meters
+				 */
+    double              c[4];	/**< Polynomial coefficients for the
+                                 * interpolation:\n
+				 * The meaning of the first two variables 
+				 * depends on the use case.
+                                 * <div style="padding:0.5em"><table>
+<tr><th style="width:133px">
+                        <th> c[0] <th> c[1]
+<tr><td> Lane width /\n connector path width <td> Width in meters
+<td> Gradient with respect to the s-coordinate
+\n Special value: \ref ROAD_UNDEFINED &harr;
+The deviation of the width in this node is calculated internally.
+<tr><td> Lateral offset <td> Lateral offset in meters
+<td> Gradient with respect to the s-coordinate
+\n Special value: \ref ROAD_UNDEFINED &harr;
+The deviation of the lateral offset in this node is calculated internally.
+<tr><td> Elevation      <td> Height in meters
+\n Special value: \ref ROAD_UNDEFINED &harr;
+The height in this node is calculated internally.
+<td> Grade in meters/meters \n Special value: \ref ROAD_UNDEFINED &harr;
+The deviation of the height in this node is calculated internally.
+<tr><td> Slope          <td> Grade in meters/meters
+\n Special value:\ref ROAD_UNDEFINED &harr;
+The grade in this node is calculated internally.
+<td> Gradient with respect to the s-coordinate
+\n Special value: \ref ROAD_UNDEFINED &harr;
+The deviation of the grade in this node is calculated internally.
+<tr><td> Camber         <td> Camber in meters/meters<sup>2</sup>
+\n Special value: \ref ROAD_UNDEFINED &harr;
+The camber in this node is calculated internally.
+<td> Gradient with respect to the s-coordinate
+\n Special value: \ref ROAD_UNDEFINED &harr;
+The deviation of the camber in this node is calculated internally.
+<tr><td> General <td> Value
+\n Special value: \ref ROAD_UNDEFINED &harr;
+The value in this node is calculated internally.
+<td> Gradient with respect to the s-coordinate
+\n Special value: \ref ROAD_UNDEFINED &harr;
+The deviation in this node is calculated internally.
+</table></div>
+				 * The last two variables are only used if \ref 
+				 * RTT_None "polynomial interpolation" is used
+				 * as transition type and set to \ref
+                                 * ROAD_UNDEFINED otherwise.
+				 */
+    tRoadLonRef         lonR;	/**< Integer value for the longitudinal
+				 * reference of \ref tRoadNode1D::s "s"
+				 */
+    tRoadTransitionType type;	/**< Transition type:\n
+                                 * Mode of interpolation used in this node
+                                 * \note In case the struct belongs to a
+                                 * <em>Height profile</em>, only \ref RTT_Cubic
+                                 * "cubic interpolation" is allowed.
+				 */
+} tRoadNode1D;
+//! List of one-dimensional nodes
+/** Struct for a list of one-dimensional nodes
+ */
+typedef struct tRoadNode1DList {    
+    int 	n;		/**< Number of the one-dimensional nodes listed
+				 */
+    tRoadNode1D *node;		/**< List of one-dimensional nodes
+				 */
+} tRoadNode1DList;
+
+
+/** Function to add a one-dimensional node to a given <em>Lane</em>,
+ * <em>Connector path</em> (only on <em>Junctions</em>), <em>Lateral
+ * offset</em>, <em>Height profile</em> or a general one-dimensional node
+ * profile
+ * \param[in,out] road Handle of the road instance
+ * \param[in] parentObjId Object id of the parent object of the new node
+ * \param[in] node Pointer to a struct containing the data of the new node
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the new one-dimensional node\n
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \note In case another object than its parent object should be used as
+ *  reference for the parameters of a one-dimensional node, the function
+ *  RoadAddObject() can be used. 
+ * \see RoadGetNode1D() \see RoadSetNode1D() \see RoadDeleteNode1D()
+ */
+tObjId RoadAddNode1D   (tRoad *road, tObjId parentObjId, tRoadNode1D *node);
+/** Function to get a one-dimensional node
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the node
+ * \param[out] node Pointer to a struct for the data of the node
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddNode1D() \see RoadSetNode1D() \see RoadDeleteNode1D()
+ */
+int    RoadGetNode1D   (tRoad *road, tObjId objId,       tRoadNode1D *node);
+/** Function to set a one-dimensional node
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the node
+ * \param[in] node Pointer to a struct containing the data of the node
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddNode1D() \see RoadGetNode1D() \see RoadDeleteNode1D()
+ */
+int    RoadSetNode1D   (tRoad *road, tObjId objId,       tRoadNode1D *node);
+/** Function to delete a one-dimensional node
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the node
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddNode1D() \see RoadGetNode1D() \see RoadSetNode1D()
+ */
+int    RoadDeleteNode1D(tRoad *road, tObjId objId);
+
+
+/*** Derivation options ***/
+
+/** Keep derivation:\n
+ *  Macro used as mode in RoadReduceNode1D(): The derivation in the considered
+ *  nodes is kept.
+ */
+#define ROAD_N1D_KEEP_DERIVATION               0
+/** Set derivation to zero:\n
+ *  Macro used to as mode in RoadReduceNode1D(): The derivation in the
+ *  considered nodes is set to zero.
+ */
+#define ROAD_N1D_SET_DERIVATION_TO_ZERO        1
+/** Set derivation to undefined:\n
+ *  Macro used as mode in RoadReduceNode1D(). The derivation in the considered
+ *  nodes is set to \ref ROAD_UNDEFINED "undefined" and a spline is used to
+ *  interpolate them.
+ */
+#define ROAD_N1D_SET_DERIVATION_TO_UNDEFINED   2
+
+
+/** Function to reduce the list of one-dimensional nodes describing a given
+ *  object
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the object\n Special value: < 0 &harr;
+ *  The list of all objects described by one-dimensional nodes are reduced.
+ * \param[in] type Type of the road object the list of one-dimensional nodes
+ *  belongs to: \n<em>\ref ROT_Lane "Lane"</em>, <em>\ref ROT_LateralOffset
+ *  "Lateral offset" </em> or <em>\ref ROT_LonZPElevation "Elevation"</em>,
+ *  <em>\ref ROT_LatZPSlope "Slope"</em> or <em>\ref ROT_LatZPCamber
+ *  "Camber profile"</em> 
+ * \param[in] maxErr Tolerance for the deviation between the curve with the
+ *  original and the curve with the reduced node list
+ * \param[in] mode Mode for the reduction: \ref ROAD_N1D_KEEP_DERIVATION
+ *  "keep derivation", \ref ROAD_N1D_SET_DERIVATION_TO_ZERO 
+ *  "set derivation to zero" or \ref ROAD_N1D_SET_DERIVATION_TO_UNDEFINED
+ *  "set derivation to undefined"
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadReduceNode1D(tRoad *road, tObjId objId, tRoadObjectType type,
+						       double maxErr, int mode);
+
+/** Function retrieving a list with the object ids of the one-dimensional nodes
+ *  used to define the width of a given <em>Lane</em> or a <em>Lateral
+ *  offset</em> or <em>Height profile</em> given
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the <em>Lane</em>, <em>Lateral offset</em> or
+ *   <em>Height profile</em>
+ * \param[out] node1DObjIds Pointer to an array for the object ids of the one
+ * -dimensional nodes
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> size of the list of one-dimensional nodes
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadObjectGetNode1DObjIds(tRoad *road, tObjId objId,
+							 tObjId **node1DObjIds);
+
+
+/** @} */
+/******************************************************************************/
+/* --- One-dimensional node profiles ---------------------------------------- */
+/******************************************************************************/
+
+/** \addtogroup OneDNodePsEdit
+ * @{
+ */
+//! Profile of one-dimensional nodes
+/** Struct for a general profile of one-dimensional nodes containing the minimum
+ *  definition of the profile to which one-dimensional nodes can be added
+ */
+typedef struct tRoadNode1DProfile {
+    tRoadTransitionType type;  /**< Transition type: Mode of interpolation at
+                                * the start of the profile
+				*/
+    double c0;		       /**< Value at the start of the profile
+                                */
+    double dc0;                /**< Derivative at the start of the profile
+                                */
+    double c1;                 /**< Value at the end of the profile
+                                */
+    double dc1;		       /**< Derivative at the end of the profile
+                                */
+    double smooth;             /**< Smoothing factor for the nodes:\n
+                                * no smoothing &harr; 0..1 &harr; maximum
+                                * smoothing
+                                * \warning Not yet supported!
+				*/
+} tRoadNode1DProfile;
+
+
+/** Function to add a one-dimensional node profile to a given <em>Raised
+ * profile</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] parentObjId Object id of the parent object of the new profile
+ * \param[in] addParam Type of the new profile:
+ *    - 0 &harr; width profile
+ *    - 1 &harr; inner height profile
+ *    - 2 &harr; outer height profile
+ * \param[in] rProfile Pointer to a struct containing the data of the new
+ * profile
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the new one-dimensional node profile\n
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadGetNode1DProfile() \see RoadSetNode1DProfile()
+ * \see RoadDeleteNode1DProfile()
+ */
+tObjId RoadAddNode1DProfile(tRoad *road, tObjId parentObjId,
+                                    int addParam, tRoadNode1DProfile *rProfile);
+/** Function to get a one-dimensional node profile
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the profile
+ * \param[out] rProfile Pointer to a struct for the data of the profile
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddNode1DProfile() \see RoadSetNode1DProfile()
+ * \see RoadDeleteNode1DProfile()
+ */
+int    RoadGetNode1DProfile(tRoad *road, tObjId objId,
+                                                  tRoadNode1DProfile *rProfile);
+/** Function to set a one-dimensional node profile
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the profile
+ * \param[in] rProfile Pointer to a struct containing the data of the profile
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddNode1DProfile() \see RoadGetNode1DProfile()
+ * \see RoadDeleteNode1DProfile()
+ */
+int    RoadSetNode1DProfile(tRoad *road, tObjId objId,
+                                                 tRoadNode1DProfile  *rProfile);
+/** Function to delete a one-dimensional node profile
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the profile
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddNode1DProfile() \see RoadGetNode1DProfile()
+ * \see RoadSetNode1DProfile()
+ */
+int    RoadDeleteNode1DProfile(tRoad *road, tObjId objId);
+
+
+/** @} */
+/******************************************************************************/
+/* --- Two-dimensional nodes ------------------------------------------------ */
+/******************************************************************************/
+
+/** \addtogroup TwoDNodesEdit
+ * @{
+ */
+//! Two-dimensional node
+/** Struct for the parameters of a two-dimensional node used for
+ *  <em>Segments</em> of type <em>\ref RST_PointList "Point list"</em>
+ */
+typedef struct tRoadNode2D {    
+    double              s;	/**< Offset in s-direction relative to the start
+                                 * of the <em>Segment</em> in meters
+				 */
+    double              xy[2];	/**< Position of the point in the global IPGRoad
+                                 * coordinate system (Fr0)
+                                 */
+} tRoadNode2D;
+//! List of two-dimensional nodes
+/** Struct for a list of two-dimensional nodes
+ */
+typedef struct tRoadNode2DList {    
+    int 	n;		/**< Number of the two-dimensional nodes listed
+				 */
+    tRoadNode2D *node;		/**< List of two-dimensional nodes
+				 */
+} tRoadNode2DList;
+
+
+/** Function to add a two-dimensional node to a given <em>Segment</em> of type
+ * <em>\ref RST_PointList "Point list"</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] parentObjId Object id of the <em>Segment</em>
+ * \param[in] node Pointer to a struct containing the data of the new node
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the new two-dimensional node\n
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadGetNode2D() \see RoadSetNode2D() \see RoadDeleteNode2D()
+ * \see RoadAddNode1D()
+ */
+tObjId RoadAddNode2D   (tRoad *road, tObjId parentObjId, tRoadNode2D *node);
+/** Function to get a two-dimensional node
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the node
+ * \param[out] node Pointer to a struct for the data of the node
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddNode2D() \see RoadSetNode2D() \see RoadDeleteNode2D()
+ * \see RoadGetNode1D()
+ */
+int    RoadGetNode2D   (tRoad *road, tObjId objId,       tRoadNode2D *node);
+/** Function to set a two-dimensional node
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the node
+ * \param[in] node Pointer to a struct containing the data of the node
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddNode2D() \see RoadGetNode2D() \see RoadDeleteNode2D()
+ * \see RoadSetNode1D()
+ */
+int    RoadSetNode2D   (tRoad *road, tObjId objId,       tRoadNode2D *node);
+/** Function to delete a two-dimensional node
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the node
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddNode2D() \see RoadGetNode2D() \see RoadSetNode2D()
+ * \see RoadDeleteNode1D()
+ */
+int    RoadDeleteNode2D(tRoad *road, tObjId objId);
+
+
+/** @} */
+/******************************************************************************/
+/* +++ Objects ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup ObjectsEdit
+ * @{
+ */
+/** Function to add a new road object of arbitrary type to a road instance
+ * \param[in,out] road Handle of the road instance
+ * \param[in] addToObjId Object id of the parent object of the new road object
+ * \param[in] addParam Additional parameter used in case a <em>Lane</em>,
+ *  a <em>Connector path</em> or a profile of one dimensional nodes is added:\n
+ *  - <em>Lane</em>: side of the <em>Link</em> (see #RoadAddLane()):
+ *    - 0 &harr; \ref R_LEFT "left"
+ *    - 1 &harr; \ref R_RIGHT "right"
+ *  - <em>Connector path</em>: parameter determining whether the new <em>Connector
+ *    path</em> is compared to the already existing <em>Connector paths</em> on
+ *    a <em>Junction</em>:
+ *    - 0 &harr; add to <em>Junction</em> in any case
+ *    - 1 &harr; add to <em>Junction</em> only if no corresponding <em>Connector
+ *               path</em> exists already
+ *  - <em>One-dimensional node profile</em>: type of the profile (see
+ *    #RoadAddNode1DProfile()):
+ *    - 0 &harr; width profile
+ *    - 1 &harr; inner height profile
+ *    - 2 &harr; outer height profile
+ * \param[in] type \ref tRoadObjectType "Type" of the new road object
+ * \param[in] obj Pointer to a struct containing the data for the new road
+ *  object
+ * \param[in] addBeforeObjId Additional parameter used in case a <em>Junction
+ *  arm</em>, a <em>Segment</em>, a one-dimensional node or a <em>Lane</em> is
+ *  added:
+ *  - <em>Segment</em>: object id of the previous segment
+ *  (see #RoadAddSegment())
+ *  - one-dimensional node: object id of the object the parameters of the
+ *  one-dimensional node refer to (see #RoadAddNode1D())
+ *  - <em>Lane</em>: Object id of the <em>Lane</em> that should be successive to
+ *  the new one\n
+ *  special value: \ref ROAD_InvalidObjId &harr; The <em>Lane</em> is added
+ *  next to the outermost <em>Lane</em>.\n (see #RoadAddLane())
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the new road object\n
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadGetObject() \see RoadSetObject() \see RoadDeleteObject()
+ */
+tObjId RoadAddObject   (tRoad *road, tObjId addToObjId, int addParam,
+		        tRoadObjectType type, void *obj, tObjId addBeforeObjId);
+/** Function to get a road object of arbitrary type
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the road object required
+ * \param[in] type Type of the road object required
+ * \param[out] obj Pointer to a struct for the data of the road object required
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddObject() \see RoadSetObject() \see RoadDeleteObject()
+ */
+int    RoadGetObject   (tRoad *road, tObjId objId,
+			tRoadObjectType type, void *obj);
+/** Function to set a road object of arbitrary type
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the road object to be set
+ * \param[in] type Type of the road object to be set
+ * \param[in] obj Pointer to a struct containing the data for the road object to
+ *  be set
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddObject() \see RoadGetObject() \see RoadDeleteObject()
+ */
+int    RoadSetObject   (tRoad *road, tObjId objId,
+			tRoadObjectType type, void *obj);
+/** Function to delete a road object of arbitrary type
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the road object that should be deleted
+ * \see RoadAddObject() \see RoadGetObject() \see RoadSetObject()
+ */
+void   RoadDeleteObject(tRoad *road, tObjId objId);
+
+//! Object information
+/** Struct for the general information about a road object of arbitrary type\n
+ *  \note This struct can be retrieved using the function RoadObjectGetInfo().
+ */
+typedef struct tRoadObjectInfo {    
+    tRoadObjectType type;	 /**< Type of the road object
+				  */
+    tObjId          parentObjId; /**< Object id of the road object's parent
+                                  * object 
+				  */
+    double          xyz[3];	 /**< Location of the road object (or the road
+                                  * object's starting point) in the global
+                                  * IPGRoad coordinate system (Fr0)
+                                  * (if available)
+				  */
+    double          suv[3];	 /**< Orientation of the of the road object (or
+                                  * the road object's starting point) in the
+                                  * global IPGRoad coordinate system (Fr0):
+                                  * \n Unit vector in longitudinal direction of 
+				  * the object's local coordinate system
+                                  * (if available)
+				  */
+    struct {	
+      double min[3];		 /**< Minimum x/y/z-coordinate of the road
+                                  * object (if available)
+				  */
+      double max[3];		 /**< Maximum x/y/z-coordinate of the road
+                                  * object (if available)
+				  */
+    } bb;			 /**< Struct for the bonding box of the
+				  * road object (if available)
+                                  * \note A bounding box is available for
+                                  * <em>Links</em> and <em>Junctions</em>.
+				  */
+    double 	    st[2];	 /**< Location of the road object (or the road
+                                  * object's starting point) in the
+                                  * <em>Reference line's</em> local coordinate
+                                  * system (if available)
+				  */
+    double 	    length;	 /**< Length of the road object in meters
+                                  * (if available)
+				  */
+} tRoadObjectInfo;
+
+/** Function delivering information concerning a given road object
+ *  \note This function can be applied to any road object, but the output
+ *   depends strongly on the object's type: For some objects only the
+ *   \ref tRoadObjectInfo::type "type" and the \ref tRoadObjectInfo::parentObjId
+ *   "object id of the parent object" are determined.
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the road object
+ * \param[out] info Struct for the information about the road object
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadObjectGetInfo(tRoad *road, tObjId objId, tRoadObjectInfo *info); 
+
+
+/** Function retrieving the root object of a given road object
+ * \note The root object of an object is either a <em>Link</em> or a
+ * <em>Junction</em>. It is determined by repeatedly retrieving the parent
+ * object until it is no longer possible, because the determined parent object
+ * is a <em>Link</em> or <em>Junction</em> and therefore has no parent object.
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the road object
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the object's root object\n
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ */
+tObjId RoadObjIdGetRootObjId (tRoad *road, tObjId objId);
+/** Function retrieving all child objects of a given road object 
+ * \param[in] road Handle of the road instance
+ * \param[in] parentObjId Object id of the road object\n
+ *  Special value: \ref ROAD_InvalidObjId &harr; All <em>Links</em> and
+ *  <em>Junctions</em> of the road instance are treated as child objects.
+ * \param[out] childObjIds Pointer to an array for the child objects' object ids
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> Number of child objects
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetAllChildObjIds (tRoad *road, tObjId parentObjId,
+							  tObjId **childObjIds);
+/** Function retrieving the object id of a <em>Lane section</em> or
+ *  <em>Segment</em> next to a given object of this type
+ * \param[in] road Handle of the road instance
+ * \param[in] type Type of the road object: <em>\ref ROT_LaneSection
+ *  "Lane section"</em> or <em>\ref ROT_Segment "Segment"</em>
+ * \param[in] option Parameter determining which object is next:
+ *  - > 0 &harr; succeeding object
+ *  - < 0 &harr; preceding object
+ * \param[in] objId Object id of the given road object
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the succeeding/preceding object
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ */
+tObjId RoadObjIdGetNextObjId (tRoad *road, tRoadObjectType type, int option, 
+								  tObjId objId);
+
+/** Function to get the object id of the object a given road object depends on\n
+ *  \note The road object can be of type \ref ROT_Node1D "one-dimensional node"
+ *   or of any type of <em>\ref ROT_BBeam "Bump"</em> or <em>\ref ROT_MDrvSpeed
+ *   "Marker"</em>. Moreover, the function can be applied to all <em>Accessories
+ *   </em> and <em>Scenery</em> objects except <em>\ref ROT_CTL
+ *   "Connected trajectory lists"</em>, <em>\ref ROT_TrfSign
+ *   "Traffic signs"</em> and <em>\ref ROT_TrfLight "Traffic lights"</em>.
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the given road object
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the object the given road object depends on
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadObjectSetDependsOn()
+ */
+tObjId RoadObjectDependsOn   (tRoad *road, tObjId objId);
+/** Function to set the object id of the object a given road object depends on
+ *  and optionally convert the respective parameters so that there given in
+ *  reference of this object
+ *  \note The road object can be of type \ref ROT_Node1D "one-dimensional node"
+ *   or of any type of <em>\ref ROT_BBeam "Bump"</em> or <em>\ref ROT_MDrvSpeed
+ *   "Marker"</em>. Moreover, the function can be applied to all <em>Accessories
+ *   </em> and <em>Scenery</em> objects except <em>\ref ROT_CTL
+ *   "Connected trajectory lists"</em>, <em>\ref ROT_TrfSign
+ *   "Traffic signs"</em> and <em>\ref ROT_TrfLight "Traffic lights"</em>.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the given road object
+ * \param[in] dependsOnObjId Object id of the object the given road object
+ *  depends on
+ * \param[in] keepPosOnRefLine Parameter determining whether the parameters of
+ *  the object should be kept or converted:
+ *  - 0 &harr; change the reference object but keep the parameters: the position
+ *  on the <em>Reference line</em> is changed
+ *  - 1 &harr; change the reference object and convert the parameters: the
+ *  position on the <em>Reference line</em> is kept
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadObjectDependsOn()
+ */
+int    RoadObjectSetDependsOn(tRoad *road, tObjId objId, tObjId dependsOnObjId,
+							  int keepPosOnRefLine);
+
+
+/** Function to convert an s-offset from one longitudinal reference to another
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the reference object
+ * \param[in] s Offset with respect to the longitudinal reference <b>src</b>
+ * \param[in] src Integer value for the initial longitudinal reference:\n
+ * - In case of a <em>Reference line</em>, <em>Segment</em>, <em>Lane section
+ *   </em>, <em>Lane path</em>, <em>User path</em> or <em>Connector path</em>:
+ *   Only <em>\ref RLR_Node0 "start point"</em> and <em>\ref RLR_Node1 
+ *   "end point" </em> are allowed as reference.
+ * - In case of a <em>Link</em>: All options are possible.
+ * \param[in] dst Integer value for the new longitudinal reference:\n
+ * - In case of a <em>Reference line</em>, <em>Segment</em>, <em>Lane section
+ *   </em>, <em>Lane path</em>, <em>User path</em> or <em>Connector path</em>:
+ *   Only <em>\ref RLR_Node0 "start point"</em> and <em>\ref RLR_Node1
+ *   "end point" </em> are allowed as reference.
+ * - In case of a <em>Link</em>: All options are possible.
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> offset with respect to the longitudinal reference <b>dst</b>\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadObjectConvertT()
+ */
+double RoadObjectConvertS(tRoad *road, tObjId objId, double s,
+			   tRoadLonRef src,     tRoadLonRef dst);
+/** Function to convert a t-offset from one reference to another
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the reference object
+ * \param[in] s Offset in s-direction
+ * \param[in] srcLatR Integer value for the initial lateral reference
+ * \param[in] dstLatR Integer value for the new lateral reference
+ * \param[in,out] t Pointer to the offset with respect to the lateral reference
+ *  <b>srcLatR</b> which is converted to the offset with respect to the lateral
+ *  reference <b>dstLatR</b>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadObjectConvertS()
+ */
+int    RoadObjectConvertT(tRoad *road, tObjId objId, double s,
+                           tRoadLatRef srcLatR, tRoadLatRef dstLatR, double *t);
+
+/** Function delivering the range of a given road object
+ * \note The road object can be of type <em>\ref ROT_Link "Link"</em>, <em>\ref
+ *  ROT_RefLine "Reference line"</em>, <em>\ref ROT_Segment "Segment"</em>,
+ * <em>\ref ROT_LonZPElevation "Elevation"</em>, <em>\ref ROT_LatZPSlope "Slope"
+ * </em> or <em>\ref ROT_LatZPCamber "Camber profile"</em>,
+ * <em>\ref ROT_LaneSection "Lane section"</em>, <em>\ref ROT_Lane "Lane"</em>,
+ * <em>\ref ROT_LateralOffset "Lateral offset"</em>, 
+ * <em>\ref ROT_Route "Route"</em>, <em>\ref ROT_DrvPath "Driving path"</em> or 
+ * <em>\ref ROT_LanePath "Lane"</em>, <em>\ref ROT_UserPath "User"</em> or
+ * <em>\ref ROT_ConPath "Connector Path"</em>.
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the given road object
+ * \param[in] mode Parameter determining the meaning of the term "range":
+ * - 0 &harr; total range
+ * - 1 &harr; range without considering the part of the object that is inside a
+ *   <em>Junction</em>
+ * \param[out] s0 Pointer to the s-offset of the object's starting point
+ * \param[out] s1 Pointer to the s-offset of the object's end point
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadObjectGetRange(tRoad *road, tObjId objId, int mode,
+							double *s0, double *s1);
+
+/** Function to get the z-coordinate of a given position in the (x,y)-plane
+ * \param[in] road Handle of the road instance
+ * \param[in] xy Given position in the (x,y)-plane of the global IPGRoad
+ *  coordinate system (Fr0)
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> z-coordinate in xy
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+double RoadGetZForXY     (tRoad *road, double xy[2]);
+
+
+/** Function to connect two objects of type <em>Link</em> or <em>Junction</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objIdA Object id of the first road object
+ * \param[in] idA Identifier of <em>Link node</em> or <em>Junction arm</em> of
+ *  the first object to which the second should be connected
+ * \param[in] objIdB Object id of the second road object
+ * \param[in] idB Identifier of <em>Link node</em> or <em>Junction arm</em> of
+ *  the second object to which the first should be connected
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadConnect(tRoad *road, tObjId objIdA, int idA, tObjId objIdB, int idB);
+
+/** Function to free the memory allocated for the pointers of a given struct
+ *  containing the parameters of a road object of a certain type
+ * \param[in] road Handle of the road instance
+ * \param[in] type Type of the given road object
+ * \param[in] obj Pointer to a struct containing the data of the given road
+ *  object
+ */
+void   RoadFreeObjectContent   (tRoad *road, tRoadObjectType type, void *obj);
+
+/** Types of height maps
+ */
+typedef enum tRoadHeightMapType {
+    RHMT_Simple = 0,	/**< <b>0</b> &nbsp; Simple height map
+			 */
+    RHMT_CRG,          	/**< <b>1</b> &nbsp; CRG height map
+			 */
+    RHMT_Unknown,	/**< <b>2</b> &nbsp; Unknown height map type
+			 */
+    RHMT_Count,	        /**< <b>3</b> &nbsp; Number of known height map types
+                        * including #RHMT_Unknown
+			 */
+} tRoadHeightMapType;
+
+/** Function to free the memory allocated for the pointers of a given struct
+ *  containing the parameters of a height map of a certain type
+ *  \note This function ist called by \ref RoadFreeObjectContent() to free
+ *  a junction's height map.
+ * \param[in] type Type of the given height map
+ * \param[in] obj Pointer to a struct containing the data of the given height
+ * map
+ */
+void   RoadFreeHeightMapContent(tRoadHeightMapType type, void *obj);
+
+
+/** @} */
+/******************************************************************************/
+/* +++ Junctions ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup JunctionsEdit
+ * @{
+ */
+/*** Junction flag options ***/
+
+/** Special simple <em>Junction</em> 0:\n
+ *  Flag indicating that a <em>Junction</em> and the <em>Links</em> connected to
+ *  it form a circle with a tangentially attached line. In order to generate a
+ *  suitable junction area for such a <em>Junction</em> a special treatment is
+ *  necessary.
+ */
+#define ROAD_RJT_SIMPLE_JUNCTION_SPECIAL_0       (1<<0)
+
+//! Junction height map: simple
+/** Struct for the parameters of a simple height map for a <em>Junction</em>
+ *  \see tRoadJunction \see tRoadJuncHMCRG
+ */
+typedef struct tRoadJuncHMSimple {
+    double  angle;             /**< Rotation of the local (u,v)-coordinate
+                                * system of the <em>Junction</em>\n
+                                * Default: 0
+                                */
+    double  gradient;          /**< Gradient along the u-axis of the local
+                                * (u,v)-coordinate system of the
+                                * <em>Junction</em>\n
+                                * Default: 0
+                                */
+    double  slope;             /**< Gradient along the v-axis of the local
+                                * (u,v)-coordinate system of the
+                                * <em>Junction</em>\n
+                                * Default: 0
+                                */
+    double  slopeDer;          /**< Derivation of the gradient along the v-axis
+                                * of the local (u,v)-coordinate system of the
+                                * <em>Junction</em>\n
+                                * Default: \ref ROAD_UNDEFINED
+                                */
+    double  camber;            /**< Camber along the v-axis of the local
+                                * (u,v)-coordinate system of the
+                                * <em>Junction</em>\n
+                                * Default: 0
+                                */
+    double  camberDer;         /**< Derivation of camber along the v-axis
+                                * of the local (u,v)-coordinate system of the
+                                * <em>Junction</em>\n
+                                * Default: \ref ROAD_UNDEFINED
+                                */
+} tRoadJuncHMSimple;
+//! Junction height map: CRG
+/** Struct for the parameters of a CRG height map for a <em>Junction</em>
+ *  \see tRoadJunction \see tRoadJuncHMSimple
+ */
+typedef struct tRoadJuncHMCRG {
+    char    *fname;            /**< Name of the external file containing the
+                                * height map, e.g. a crg file
+                                */
+    int     rlObjId;           /**< Object id of the <em>Reference line</em>
+                                * used for the CRG
+                                * \note If no <em>Reference line</em> is used,
+                                * set this parameter to \ref ROAD_InvalidObjId.
+                                * \warning Not yet supported!
+                                */
+    double  xyz[3];            /**< Offset of the origin of the local (u,v)-
+                                * coordinate system of the CRG to the
+                                * <em>Junction's</em> center.
+                                */
+    double  angle;             /**< Rotation of the local (u,v)-coordinate
+                                * system of the CRG around its origin
+                                */
+    double  tOff;	       /**< Lateral offset of the CRG's u-axis from the
+                                * given <em>\ref tRoadJuncHMCRG.rlObjId
+                                * "Reference line"</em>
+                                * \note If no <em>Reference line</em> is used,
+                                * this parameter is ignored.
+                                * \warning Not yet supported!
+				*/
+    double  uScale;	       /**< Grid scale factor in u-direction
+				*/
+    double  vScale;	       /**< Grid scale factor in v-direction
+				*/
+    double  zScale;	       /**< Grid scale factor in z-direction
+                                */
+    int	    tType;	       /**< \ref tRoadTransitionType "Transition type"
+                                * for the file data
+				*/
+    int     useMesh;	       /**< Flag indicating whether a mesh, e.g. crg
+                                * files, should be used if available.
+                                * - 0 &harr; The mesh is not used.
+				* - 1 &harr; The mesh is used.
+				*
+                                * \warning Not yet supported!
+				*/
+    int     useZProfile[3];    /**< Flag indicating whether <em>Elevation</em>,
+                                * <em>Slope</em> and <em>Camber profiles</em>
+                                * should be used if available.
+                                * - 0 &harr; The height profile is not used.
+				* - 1 &harr; The height profile is used.
+				*
+                                * \warning Not yet supported!
+				*/
+    int     useRaw;            /**< Flag indicating whether the raw crg data
+                                * should be used.
+                                * - 0 &harr; The raw data is not used.
+				* - 1 &harr; The raw data is used.
+				*/
+    int     reverse;	       /**< Flag indicating whether the file data should
+                                * be reversed.
+                                * - 0 &harr; The file data is not reversed.
+				* - 1 &harr; The file data is reversed.
+				*
+                                * \warning Not yet supported!
+                                */
+} tRoadJuncHMCRG;
+
+//! Junction
+/** Struct for the parameters of a <em>Junction</em>
+ *  \see tRoadJunctionPOI \see tRoadJunctionArm
+ */
+typedef struct tRoadJunction {    
+    double 	       knot[3];    /**< Location of the junction knot in the
+                                    * (x,y,z)-coordinates of the global IPGRoad
+                                    * coordinate system (Fr0)
+				    */
+    double	       fric;	   /**< Friction value on the junction surface
+                                    */
+    int                flags;      /**< Flags of the <em>Junction</em>:
+                                    * Currently only
+                                    * #ROAD_RJT_SIMPLE_JUNCTION_SPECIAL_0 is
+                                    * supported.
+                                    */
+    tRoadJunctionType  rjt;	   /**< Type of the <em>Junction</em>
+                                    */
+    tRoadSpeedType     rst;	   /**< Road speed type of the <em>Junction</em>
+				    */
+    tRoadHeightMapType rhmt;       /**< Type of the height map used for the
+                                    * <em>Junction</em>
+                                    * \note Only used for \ref RJT_Extended
+                                    * "extended" <em>Junctions</em>.
+                                    * \ref RJT_Direct "Direct"
+                                    * <em>Junctions</em> always have a
+                                    * \ref RHMT_Simple "simple" height map while
+                                    * the height map of \ref RJT_Virtual
+                                    * "virtual" and \ref RJT_Simple "standard"
+                                    * <em>Junctions</em> is completely
+                                    * determined by the connected
+                                    * <em>Links</em>.
+				    */
+    tRoadJuncHMSimple  *hmSimple;  /**< Struct for the parameters of the
+                                    * <em>Junction's</em> height map in case it
+                                    * is a \ref RHMT_Simple "simple" height map
+                                    * \note Only used for \ref RJT_Extended
+                                    * "extended" and \ref RJT_Direct "direct"
+                                    * <em>Junctions</em>.
+				    */
+    tRoadJuncHMCRG     *hmCRG;     /**< Struct for the parameters of the
+                                    * <em>Junction's</em> height map in case it
+                                    * is a \ref RHMT_CRG "CRG" height map
+                                    * \note Only used for \ref RJT_Extended
+                                    * "extended" <em>Junctions</em>.
+				    */
+} tRoadJunction;
+
+/** Function to add a new <em>Junction</em> to a road instance
+ * \param[in,out] road Handle of the road instance
+ * \param[in] rJunction Pointer to a struct containing the data of the new
+ *  <em>Junction</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the new <em>Junction</em>\n
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadGetJunction() \see RoadSetJunction() \see RoadDeleteJunction()
+ * \see RoadAddJunctionArm() \see RoadAddJunctionArmExt()
+ */
+tObjId RoadAddJunction   (tRoad *road,                tRoadJunction *rJunction);
+/** Function to get a <em>Junction</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] jObjId Object id of the <em>Junction</em>
+ * \param[out] rJunction Pointer to a struct for the data of the
+ *  <em>Junction</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddJunction() \see RoadSetJunction() \see RoadDeleteJunction()
+ */
+int    RoadGetJunction   (tRoad *road, tObjId jObjId, tRoadJunction *rJunction);
+/** Function to set a <em>Junction</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] jObjId Object id of the <em>Junction</em>
+ * \param[in] rJunction Pointer to a struct containing the data for the
+ *  <em>Junction</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddJunction() \see RoadGetJunction() \see RoadDeleteJunction()
+ */
+int    RoadSetJunction   (tRoad* road, tObjId jObjId, tRoadJunction *rJunction);
+/** Function to delete a <em>Junction</em>\n
+ * \note All objects attached to the <em>Junction</em> are deleted as well.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] jObjId Object id of the <em>Junction</em> that should be deleted
+ * \see RoadAddJunction() \see RoadGetJunction() \see RoadSetJunction()
+ */
+void   RoadDeleteJunction(tRoad* road, tObjId jObjId);
+
+
+/*** Junction arm flag options ***/
+
+/** No special treatment:\n
+ *  Flag indicating that no special treatment is considered for the
+ *  <em>Junction arm</em>.
+ *  \note This particularly means that for both
+ *  \ref ROAD_JARM_DO_NOT_ADJUST_LINK_ELEVATION "elevation" and
+ *  \ref ROAD_JARM_DO_NOT_ADJUST_LINK_SLOPE "slope" of the connected
+ *  <em>Link</em> the <em>Junction's</em> elevation and slope, respectively, is
+ *  considered.
+ */
+#define ROAD_JARM_NONE		                    (0)
+/** Do not adjust elevation of the connected <em>Link</em>:\n
+ *  The <em>Junction's</em> elevation is not considered for the elevation of the
+ *  <em>Link</em> connected to the <em>Junction arm</em>.
+ */
+#define ROAD_JARM_DO_NOT_ADJUST_LINK_ELEVATION   (1<<0)
+/** Do not adjust slope of the connected <em>Link</em>:\n
+ *  The <em>Junction's</em> slope is not considered for the slope of the
+ *  <em>Link</em> connected to the <em>Junction arm</em>.
+ */
+#define ROAD_JARM_DO_NOT_ADJUST_LINK_SLOPE       (1<<1)
+
+//! Junction arm
+/** Struct for the parameters of a <em>Junction arm </em>
+ *  \see tRoadJunctionArmPOI \see tRoadJunction
+ */
+typedef struct tRoadJunctionArm {
+    double  lengthOnLink;      /**< Distance on the connected <em>Link</em>
+                                * belonging to the <em>Junction arm</em>
+                                */
+    double  transWidth;        /**< Width of the section on the <em>Junction
+                                * arm</em> considered for the transition from
+                                * the connected <em>Link</em> to the
+                                * <em>Junction's</em> surface
+                                *\note Only used for the <em>Junction arms</em>
+                                * of \ref RJT_Extended "extended"
+                                * <em>Junctions</em> and the subordinate arm of
+                                * \ref RJT_Virtual "virtual" <em>Junctions</em>.
+                                */
+    int     flags;             /**< Flags of the <em>Junction arm</em>:\n
+                                * The binary system is used to generate
+				* combinations of the data options
+				* #ROAD_JARM_NONE,
+				* #ROAD_JARM_DO_NOT_ADJUST_LINK_ELEVATION and
+				* #ROAD_JARM_DO_NOT_ADJUST_LINK_SLOPE.
+                                */
+} tRoadJunctionArm;
+
+/** Function to add a <em>Junction arm</em> to a <em>Junction</em>\n
+ *  The new <em>Junction arm</em> is added after the last one.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] jObjId Object id of the <em>Junction</em>
+ * \param[in] rJArm Pointer to a struct containing the data of the new
+ *  <em>Junction arm</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the new <em>Junction arm</em>\n
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadAddJunctionArmExt() \see RoadGetJunctionArm()
+ * \see RoadSetJunctionArm() \see RoadDeleteJunctionArm()
+ */
+tObjId RoadAddJunctionArm   (tRoad *road, tObjId jObjId,
+						       tRoadJunctionArm *rJArm);
+/** Function to get a <em>Junction arm</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] jArmObjId Object id of the <em>Junction arm</em>
+ * \param[out] rJArm Pointer to a struct for the data of the <em>Junction
+ *  arm</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddJunctionArm() \see RoadSetJunctionArm()
+ * \see RoadDeleteJunctionArm()
+ */
+int    RoadGetJunctionArm   (tRoad *road, tObjId jArmObjId, 
+						       tRoadJunctionArm *rJArm);
+/** Function to set a <em>Junction arm</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] jArmObjId Object id of the <em>Junction arm</em>
+ * \param[in] rJArm Pointer to a struct containing the data for the
+ *  <em>Junction arm</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddJunctionArm() \see RoadGetJunctionArm()
+ * \see RoadDeleteJunctionArm()
+ */
+int    RoadSetJunctionArm   (tRoad *road, tObjId jArmObjId, 
+						       tRoadJunctionArm *rJArm);
+/** Function to delete a <em>Junction arm</em>\n
+ *  \note All objects attached to the <em>Junction arm</em> are deleted as well.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] jArmObjId Object id of the <em>Junction arm</em> that should be
+ *  deleted
+ * \see RoadAddJunctionArm() \see RoadGetJunctionArm() \see RoadSetJunctionArm()
+ */
+void   RoadDeleteJunctionArm(tRoad *road, tObjId jArmObjId);
+
+/** Function to get the internally calculated angle of a <em>Junction arm</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] jArmObjId Object id of the <em>Junction arm</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> angle of the <em>Junction arm</em> in degrees\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetPreviousJunctionArm() \see RoadGetSuccessiveSegment()
+ * \see RoadGetJunctionArmRefline()
+ */
+double RoadGetJunctionArmAngle     (tRoad *road, tObjId jArmObjId);
+/** Function to get the <em>Junction arm</em> preceding a given <em>Junction
+ *  arm</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] jArmObjId Object id of the <em>Junction arm</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the previous <em>Junction arm</em>
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadGetSuccessiveJunctionArm() \see RoadGetJunctionArmAngle()
+ */
+tObjId RoadGetPreviousJunctionArm  (tRoad *road, tObjId jArmObjId);
+/** Function to get the <em>Junction arm</em> succeeding a given <em>Junction
+ * arm</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] jArmObjId Object id of the <em>Junction arm</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the successive <em>Junction arm</em>\n
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadGetPreviousJunctionArm() \see RoadGetJunctionArmAngle()
+ */
+tObjId RoadGetSuccessiveJunctionArm(tRoad *road, tObjId jArmObjId);
+
+/** Function to get the object id of the <em>Reference line</em> describing
+ *  the boundary curve of a <em>Junction arm</em>, which belongs to a
+ *  <em>Junction</em> of type \ref RJT_Simple "standard" or \ref RJT_Extended
+ *  "extended"
+ * \param[in] road Handle of the road instance
+ * \param[in] jArmObjId Object id of the <em>Junction arm</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td>object id of the <em>Reference line </em>\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetJunctionArmAngle()
+ */
+tObjId RoadGetJunctionArmRefline(tRoad *road, tObjId jArmObjId);
+
+/** Function to get the angle between two B&eacute;zier curves of a <em>Junction
+ *  arm</em> and the offset from their intersection point in u-direction\n
+ *  The surface of a road instance is depicted with so-called B&eacute;zier
+ *  Patch Mappings. These are patches with four B&eacute;zier curves as boundary
+ *  curves. Each patch has its own local (u,v)-coordinate system: The points
+ *  where the curves meet are given the coordinates (0,0), (0,1), (1,0)
+ *  and (1,1) and either the u- or the v-coordinate is 0 or 1 along each of
+ *  these curves, which are named accordingly <b>bezU</b>0, <b>bezU</b>1,
+ *  <b>bezV</b>0 or <b>bezV</b>1.
+ *  \note Only valid for the <em>Junction arms</em> of \ref RJT_Simple
+ *  "standard" <em>Junctions</em> and the subordinate arm of \ref RJT_Virtual
+ *  "virtual" <em>Junctions</em>.
+ * \param[in] road Handle of the road instance
+ * \param[in] jArmObjId Object id of the <em>Junction arm</em>
+ * \param[in] uId Identifier of the <b>bezU</b> curve: 0 or 1
+ * \param[in] vId Identifier of the <b>bezV</b> curve: 0 or 1
+ * \param[out] u Offset from the vertex (uId,vId) on the given <b>bezV</b>
+ *  curve: u-coordinate relative to the curve's length
+ * \param[out] angle Angle between the given B&eacute;zier curves in degrees
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road
+ *  </table>
+ * \see RoadJunctionArmSetBoundary()
+ * \see RoadJunctionArmGetBoundaryXYZ()
+ */
+int    RoadJunctionArmGetBoundary(tRoad *road, tObjId jArmObjId,
+                                  int uId, int vId, double *u, double *angle);
+/** Function to set the angle between two B&eacute;zier curves of a <em>Junction
+ *  arm</em> and the offset from their intersection point in u-direction\n
+ *  The surface of a road instance is depicted with so-called B&eacute;zier
+ *  Patch Mappings. These are patches with four B&eacute;zier curves as boundary
+ *  curves. Each patch has its own local (u,v)-coordinate system: The points
+ *  where the curves meet are given the coordinates (0,0), (0,1), (1,0)
+ *  and (1,1) and either the u- or the v-coordinate is 0 or 1 along each of
+ *  these curves, which are named accordingly <b>bezU</b>0, <b>bezU</b>1,
+ *  <b>bezV</b>0 or <b>bezV</b>1.
+ *  \note Only valid for the <em>Junction arms</em> of \ref RJT_Simple
+ *  "standard" <em>Junctions</em> and the subordinate arm of \ref RJT_Virtual
+ *  "virtual" <em>Junctions</em>.
+ * \param[in] road Handle of the road instance
+ * \param[in] jArmObjId Object id of the <em>Junction arm</em>
+ * \param[in] uId Identifier of the <b>bezU</b> curve: 0 or 1
+ * \param[in] vId Identifier of the <b>bezV</b> curve: 0 or 1
+ * \param[in] u Offset from the vertex (uId,vId) on the given <b>bezV</b> curve:
+ *  u-coordinate relative to the curve's length
+ * \param[in] angle Angle between the given B&eacute;zier curves in degrees
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road
+ *  </table>
+ * \see RoadJunctionArmGetBoundary()
+ * \see RoadJunctionArmGetBoundaryXYZ()
+ */
+int    RoadJunctionArmSetBoundary(tRoad *road, tObjId jArmObjId,
+                                  int uId, int vId, double u, double angle);
+/** Function to get position and angle of a certain B&eacute;zier patch vertex\n
+ *  The surface of a road instance is depicted with so-called B&eacute;zier
+ *  Patch Mappings. These are patches with four B&eacute;zier curves as boundary
+ *  curves. Each patch has its own local (u,v)-coordinate system: The points
+ *  where the curves meet are given the coordinates (0,0), (0,1), (1,0)
+ *  and (1,1) and either the u- or the v-coordinate is 0 or 1 along each of
+ *  these curves, which are named accordingly <b>bezU</b>0, <b>bezU</b>1,
+ *  <b>bezV</b>0 or <b>bezV</b>1.
+ *  \note Only valid for the <em>Junction arms</em> of \ref RJT_Simple
+ *  "standard" <em>Junctions</em> and the subordinate arm of \ref RJT_Virtual
+ *  "virtual" <em>Junctions</em>.
+ * \param[in] road Handle of the road instance
+ * \param[in] jArmObjId Object id of the <em>Junction arm</em>
+ * \param[in] uId Identifier of the <b>bezU</b> curve: 0 or 1
+ * \param[in] vId Identifier of the <b>bezV</b> curve: 0 or 1
+ * \param[out] xyz Position of the vertex (uId,vId)
+ * \param[out] angle Absolut angle in the vertex (uId,vId) in degrees
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road
+ *  </table>
+ * \see RoadJunctionArmSetBoundary()
+ * \see RoadJunctionArmGetBoundary()
+ */
+int    RoadJunctionArmGetBoundaryXYZ(tRoad *road, tObjId jArmObjId,
+                                     int uId, int vId, double *xyz, double *angle);
+
+/** Function to get the main arms of a <em>Junction</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] jObjId Object id of the <em>Junction</em>
+ * \param[out] jArm0ObjId Object id of the first main arm of the
+ *  <em>Junction</em>
+ * \param[out] jArm1ObjId Object id of the second main arm of the
+ *  <em>Junction</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadJunctionSetMainArms()
+ */
+int    RoadJunctionGetMainArms   (tRoad *road, tObjId jObjId,
+                                        tObjId *jArm0ObjId, tObjId *jArm1ObjId);
+/** Function to set the main arms of a <em>Junction</em>
+ *  \note Not valid for \ref RJT_Virtual "virtual" <em>Junctions</em>, since the
+ *  main arms of such a <em>Junction</em> must not be changed.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] jObjId Object id of the <em>Junction</em>
+ * \param[in] jArm0ObjId Object id of the first <em>Junction arm</em>
+ * \param[in] jArm1ObjId Object id of the second <em>Junction arm</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadJunctionGetMainArms()
+ */
+int    RoadJunctionSetMainArms   (tRoad *road, tObjId jObjId,
+					tObjId  jArm0ObjId, tObjId  jArm1ObjId);
+
+//! Points of interest of a Junction arm
+/** Struct for the parameters of the points of interest of a <em>Junction arm
+ * </em>
+ */
+typedef struct tRoadJunctionArmPOI {    
+    double  xyzC[3];                 /**< Location of the center of the 
+                                     * <em>Junction arm</em> at the junction
+                                     * entry in the global IPGRoad coordinate
+                                     * system (Fr0)
+                                     */
+    double  xyzRL[3];                /**< Position of the <em>Link's</em>
+                                     * <em>Reference line</em> at the
+                                     * junction entry in the global IPGRoad
+                                     * coordinate system (Fr0)
+                                     */
+    tObjId  lObjId;                  /**< Object id of the <em>Link</em> the
+                                     * <em>Junction arm</em> is connected to.\n
+                                     * Special value: #ROAD_InvalidObjId
+                                     * &harr; unconnected <em>Junction arm</em>
+                                     */
+    int     nLanesIn;                /**< Number of <em>Lanes</em> leading into
+                                     * the <em>Junction</em> along this arm
+                                     */
+    int     nLanesOut;               /**< Number of <em>Lanes</em> leading out
+                                     * of the <em>Junction</em> along this arm
+                                     */
+    tObjId  laneObjIdIn[ROAD_MAX_LANES];/**< Object ids of the <em>Lanes</em>
+                                     * leading into the <em>Junction</em>
+                                     */
+    tObjId  laneObjIdOut[ROAD_MAX_LANES];/**< Object ids of the <em>Lanes</em>
+                                     * leading out of the <em>Junction</em>
+                                     */
+    double  xyzCIn[ROAD_MAX_LANES][3];/**< Locations of the centers of the
+                                     * <em>Lanes</em> leading into the
+                                     * <em>Junction</em> in the global IPGRoad
+                                     * coordinate system (Fr0)
+                                     */
+    double  xyzCOut[ROAD_MAX_LANES][3];/**< Locations of the centers of the 
+                                     * <em>Lanes</em> leading out of the
+                                     * <em>Junction</em> in the global IPGRoad
+                                     * coordinate system (Fr0)
+                                     */
+    double  xyzBIn[ROAD_MAX_LANES][3];/**< Locations of the outer borders of the 
+                                     * <em>Lanes</em> leading into the
+                                     * <em>Junction</em> in the global IPGRoad
+                                     * coordinate system (Fr0)
+                                     */
+    double  xyzBOut[ROAD_MAX_LANES][3];/**< Locations of the outer borders of the 
+                                     * <em>Lanes</em> leading out of the
+                                     * <em>Junction</em> in the global IPGRoad
+                                     * coordinate system (Fr0)
+                                     */
+} tRoadJunctionArmPOI;
+//! Points of interest of a Junction
+/** Struct for the parameters of the points of interest of a <em>Junction</em>
+ */
+typedef struct tRoadJunctionPOI {    
+    double 		xyz[3];		/**< Location of the <em>Junction's</em>
+                                         * center point in the global IPGRoad
+                                         * coordinate system (Fr0)
+					 */
+    int 		nArm;		/**< Number of arms of the
+                                         * <em>Junction</em>
+					 */
+    tRoadJunctionArmPOI arm[ROAD_JUNC_MAX_ARMS];	/**< Structs for the parameters of the  
+					 * points of interest of the
+                                         * <em>Junction</em> arms
+					 */
+} tRoadJunctionPOI;
+
+/** Function to get the points of interest of a <em>Junction</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] jObjId Object id of the <em>Junction</em>
+ * \param[out] jPOI Pointer to a struct for the points of interest of the
+ * <em>Junction</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetJunctionArmPOI()
+ */
+int    RoadGetJunctionPOI   (tRoad* road, tObjId jObjId,
+						  tRoadJunctionPOI *jPOI);
+/** Function to get the points of interest of a <em>Junction arm</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] jArmObjId Object id of the <em>Junction arm</em>
+ * \param[out] jArmPOI Pointer to a struct for the points of interest of the
+ *  <em>Junction arm</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetJunctionPOI()
+ */
+int    RoadGetJunctionArmPOI(tRoad* road, tObjId jArmObjId, 
+						  tRoadJunctionArmPOI *jArmPOI);
+
+/** Function to detect a <em>Junction</em> in an environment of a given search
+ *  point
+ * \param[in] road Handle of the road instance
+ * \param[in] x Search point: x-coordinate
+ * \param[in] y Search point: y-coordinate
+ * \param[in] z Search point: z-coordinate
+ * \param[in] maxXYErr Maximum deviation in x- and y-direction
+ * \param[in] maxZErr Maximum deviation in z-direction
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the <em>Junction</em>\n
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ */
+tObjId RoadFindJunction(tRoad *road, double x, double y, double z,
+					       double maxXYErr, double maxZErr);
+
+/** Function to check the area validity of a <em>Junction</em> or a single
+ * <em>Junction arm</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the <em>Junction</em> or the single
+ *  <em>Junction arm</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> flag indicating whether (all) area(s) is/are valid:
+ *  <tr><td><td>
+ *  - 0 &harr; invalid
+ *  - 1 &harr; valid
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadJunctionAreaIsValid(tRoad *road, tObjId objId);
+
+
+/** @} */
+/******************************************************************************/
+/* --- Connect and disconnect ----------------------------------------------- */
+/******************************************************************************/
+
+
+/** \addtogroup ConnectEdit
+ * @{
+ */
+/** Forced connection:\n
+ *  Flag for the function RoadJunctionArmConnectLink() indicating whether a
+ *  <em>Junction arm</em> and a <em>Link</em> should be connected by a
+ *  <em>Segment</em> of type <em>\ref RST_Connect "Connect"</em> if they can't
+ *  be connected otherwise.
+ * \see RoadJunctionArmConnectLink()
+ */
+#define ROAD_JUNC_FORCE_CONNECT	(1<<0)
+
+
+/** Function to connect a <em>Junction arm</em> and a <em>Link</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] jArmObjId Object id of the <em>Junction arm</em>
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[in] nodeId Identifier of the node of the <em>Link</em> the
+ *  <em>Junction arm</em> should be connected to
+ * \param[in] mask Mask used for a parameter determining whether <em>Link</em>
+ *  and <em>Junction arm</em> should be connected by
+ *  \ref ROAD_JUNC_FORCE_CONNECT "force" if necessary
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadJunctionArmDisconnectLink() \see RoadJunctionArmGetConnectedLink()
+ * \see RoadLinkGetConnectedJunctionArm()
+ */
+int    RoadJunctionArmConnectLink     (tRoad *road, tObjId jArmObjId,
+					   tObjId lObjId, int nodeId, int mask);
+/** Function to disconnect a <em>Junction arm</em> and a <em>Link</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] jArmObjId Object id of the <em>Junction arm</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadJunctionArmConnectLink() \see RoadJunctionArmGetConnectedLink()
+ * \see RoadLinkGetConnectedJunctionArm()
+ */
+int    RoadJunctionArmDisconnectLink  (tRoad *road, tObjId jArmObjId);
+/** Function to get the object id of the <em>Link</em> connected to a specific
+ *  <em>Junction arm</em> and the identifier of the node it is connected to
+ * \param[in] road Handle of the road instance
+ * \param[in] jArmObjId Object id of the <em>Junction arm</em>
+ * \param[out] nodeId Identifier of the node of the <em>Link</em> the
+ *  <em>Junction arm</em> is connected to
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the <em>Link</em> connected to the <em>Junction arm</em>
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadJunctionArmConnectLink() \see RoadJunctionArmDisconnectLink()
+ * \see RoadLinkGetConnectedJunctionArm()
+ */
+tObjId RoadJunctionArmGetConnectedLink(tRoad *road, tObjId jArmObjId, int *nodeId);
+/** Function to get the object id of the <em>Junction arm</em> connected to a
+ *  specific node of a <em>Link</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[out] nodeId Identifier of the node of the <em>Link</em> the
+ *  <em>Junction arm</em> is connected to
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the <em>Junction arm</em> connected to the <em>Link</em>
+ *  at the specified node
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadJunctionArmConnectLink() \see RoadJunctionArmDisconnectLink()
+ *  \see RoadJunctionArmGetConnectedLink()
+ */
+tObjId RoadLinkGetConnectedJunctionArm(tRoad *road, tObjId lObjId, int nodeId);
+
+/** Function to get all <em>Links</em> connected to the <em>Junction</em> at the
+ *  start of a given <em>Link</em>. For \ref RJT_Direct "direct junctions" the
+ *  <em>Links</em> connected to <em>Junction arms</em> pointing in the same
+ *  direction as the one the considered <em>Link</em> is connected to are
+ *  omitted.
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[out] objIds Pointer to an array for the object ids of the
+ *  <em>Links</em> connected to the given one's start
+ * \param[out] nodeIds Pointer to an array for the node ids of the ends of the
+ *  <em>Links</em> connected to the given one's start
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Links</em> connected to the given <em>Link's</em> start
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadLinkGetPossibleOutLinks()
+ */
+int    RoadLinkGetPossibleInLinks(tRoad *road, tObjId lObjId,
+						tObjId **objIds, int **nodeIds);
+/** Function to get all <em>Links</em> connected to the <em>Junction</em> at the
+ *  end of a given <em>Link</em>. For \ref RJT_Direct "direct junctions" the
+ *  <em>Links</em> connected to <em>Junction arms</em> pointing in the same
+ *  direction as the one the considered <em>Link</em> is connected to are
+ *  omitted.
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[out] objIds Pointer to an array for the object ids of the
+ *  <em>Links</em> connected to the given one's end
+ * \param[out] nodeIds Pointer to an array for the node ids of the ends of the
+ *  <em>Links</em> connected to the given one's end
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Links</em> connected to the given <em>Link's</em> end
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadLinkGetPossibleInLinks()
+ */
+int    RoadLinkGetPossibleOutLinks(tRoad *road, tObjId lObjId,
+						tObjId **objIds, int **nodeIds);
+
+/** @} */
+/******************************************************************************/
+/* +++ Links ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup LinksEdit
+ * @{
+ */
+//! Link
+/** Struct for the parameters of a <em>Link</em>
+ * \attention At least one <em>Segment</em> must be defined!
+ */
+typedef struct tRoadLink {    
+    double 	   xyz0[3];	/**< Position of the <em>Link's</em> starting
+                                 * point <em>Node0</em>
+				 */
+    double 	   xyz1[3];	/**< Position of the <em>Link's</em> end point
+                                 * <em>Node1</em>
+				 */
+    double 	   angle0;	/**< Angle of the <em>Link</em> at its starting
+				 * point <em>Node0</em> relative to the x-axis
+                                 * in degrees
+				 */
+    double 	   angle1;	/**< Angle of the <em>Link</em> at its end point
+                                 * <em>Node1</em> relative to the x-axis in
+                                 * degrees
+				 */
+    double 	   fric;	/**< Friction value on the <em>Link</em> surface
+				 */
+    tRoadSpeedType rst;		/**< Road speed type of the <em>Link</em>
+				 */
+    char 	   *material;	/**< \deprecated Set this parameter to NULL.\n
+				 * Use RoadObjectGetMaterial() / 
+				 * RoadObjectSetMaterial() for the definition of
+				 * the material of the <em>Link</em>.
+				 */
+} tRoadLink;
+
+/** Function to add a new <em>Link</em> to a road instance
+ * \param[in,out] road Handle of the road instance
+ * \param[in] link Pointer to a struct containing the data of the new
+ *  <em>Link</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the new <em>Link</em>
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadGetLink() \see RoadSetLink() \see RoadDeleteLink()
+ * \see RoadAddSegment()
+ * \see RoadAddLaneSection() \see RoadAddLateralOffset() \see RoadAddZProfile()
+ */
+tObjId RoadAddLink   (tRoad *road,                tRoadLink *link);
+/** Function to get a <em>Link</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[out] link Pointer to a struct for the data of the <em>Link</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddLink() \see RoadSetLink() \see RoadDeleteLink()
+ */
+int    RoadGetLink   (tRoad *road, tObjId lObjId, tRoadLink *link);
+/** Function to set a <em>Link</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[in] link Pointer to a struct containing the data for the <em>Link</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddLink() \see RoadGetLink() \see RoadDeleteLink()
+ */
+int    RoadSetLink   (tRoad *road, tObjId lObjId, tRoadLink *link);
+/** Function to delete a <em>Link</em>\n
+ *  \note All objects attached to the <em>Link</em> are deleted as well.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em> that should be deleted
+ * \see RoadAddLink() \see RoadGetLink() \see RoadSetLink()
+ */
+void   RoadDeleteLink(tRoad *road, tObjId lObjId);
+
+/** Function to get the object id of a <em>Link's</em> <em>Reference line</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the <em>Reference line</em> of the <em>Link</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+tObjId RoadGetLinkRefLineObjId (tRoad *road, tObjId lObjId);
+
+/** Function to get the length of a <em>Link</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> length of the <em>Link</em> in meters
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+double RoadGetLinkLength       (tRoad *road, tObjId lObjId);
+/** Function to get the heading of a given <em>Link</em> at a certain offset\n
+ *  The heading is the angle between the x-axis of the global IPGRoad coordinate
+ *  system (Fr0) and the s-axis of the local coordinate system of the
+ *  <em>Link</em> (couterclockwise).
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[in] s Offset on the <em>Link</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> heading of the <em>Link</em> in degrees
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetRefLineHeading()
+ */
+double RoadGetLinkHeading      (tRoad *road, tObjId lObjId, double s);
+
+/** Function to get the width of a <em>Link</em> at a given offset on its
+ *  <em>Reference line</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[in] s Offset on the <em>Reference line</em> in meters
+ * \param[in] side Side of the road: \ref R_LEFT "left" or \ref R_RIGHT "right"
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> width of the <em>Link</em> in meters
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+double RoadGetLinkWidth        (tRoad *road, tObjId lObjId, double s, int side);
+/** Function to get the lateral offset of the border of a <em>Link</em> at a
+ *  given offset on its <em>Reference line</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[in] s Offset on the <em>Reference line</em> in meters
+ * \param[in] side Side of the road: \ref R_LEFT "left" or \ref R_RIGHT "right"
+ * \param[out] t Lateral offset of the border of the <em>Link</em> at <b>s</b>
+ *  in meters
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetLSBorderT()
+ */
+int    RoadGetLinkBorderT      (tRoad *road, tObjId lObjId, double s, int side,
+                                                                     double *t);
+/** Function to get the width of a <em>Link's</em> <em>Road side</em> at a given
+ *  offset on its <em>Reference line</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[in] s Offset on the <em>Reference line</em> in meters
+ * \param[in] side Side of the road: \ref R_LEFT "left" or \ref R_RIGHT "right"
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> width of the <em>Link's</em> <em>Road side</em> in meters
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+double RoadGetLinkRoadsideWidth(tRoad *road, tObjId lObjId, double s, int side);
+
+/** Function to get the node of a <em>Link</em> that is nearest to a given
+ *  position in the (x,y)-plane of the global IPGRoad coordinate system (Fr0)
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[in] xy Position in the (x,y)-plane of the global IPGRoad coordinate
+ *  system (Fr0)
+ * \param[out] node Integer distinguishing between the two link ends:
+ *  - 0 &harr; starting point <em>Node0</em>
+ *  - 1 &harr; end point <em>Node1</em>
+ * \param[out] ds Offset of the position on the <em>Reference line</em> with
+ *  reference to the node nearest to it
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetLinkNode         (tRoad *road, tObjId lObjId,
+					   double xy[2], int *node, double *ds);
+
+/** Function to get the distance between the node of a <em>Link</em> and the
+ *  corresponding junction entry
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[in] node Integer distinguishing between the two link ends:
+ *  - 0 &harr; starting point <em>Node0</em>
+ *  - 1 &harr; end point <em>Node1</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> junction extent at the link end
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+double RoadGetLinkJEntryDist   (tRoad *road, tObjId lObjId, int node);
+
+//! Virtual Junction: Link information
+/** Struct for the information about a virtual <em>Junction</em>
+ */
+typedef struct tRoadLinkVirJunction {
+    double s0;		/**< Start offset on the main <em>Link</em> in meters
+			 */
+    double s1;		/**< End offset on the main <em>Link</em> in meters
+			 */
+    tObjId virJObjId;	/**< Object id of the virtual <em>Junction</em>
+			 */
+    int side;		/**< Side of the virtual <em>Junction</em>:
+                         *  \ref R_LEFT "left" or \ref R_RIGHT "right" of the
+                         *  <em>Reference line</em> of the main <em>Link</em>
+			 */
+} tRoadLinkVirJunction;
+
+/** Function to get the parameters of the virtual <em>Junctions</em> defined
+ *  on a given <em>Link</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[out] linkVirJ Pointer to an array for the parameters of the virtual
+ *  <em>Junctions</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of virtual <em>Junctions</em> defined on the <em>Link</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetLinkVirJunctions (tRoad *road, tObjId lObjId,
+                                               tRoadLinkVirJunction **linkVirJ);
+
+/** Function to convert a given position in the (x,y)-plane of the global
+ *  IPGRoad coordinate system (Fr0) to the corresponding position in the local
+ *  coordinate system of a given <em>Link</em>
+ *  \note In order to determine the position in the local coordinate system,
+ *   Newton's method is applied. As start value the s-coordinate of <b>st</b> is
+ *   used, so it is possible to benefit from additional information about the
+ *   given position. Moreover, it is necessary to restrict the lateral offset
+ *   allowed left and right of the <em>Link's</em> <em>Reference line</em> in
+ *   order to prevent the association of the position with the wrong offset on a
+ *   curved <em>Reference line</em>. If a lateral offset beyond the
+ *   <em>Link's</em> road borders should be allowed, it can be extend using the
+ *   parameter <b>tOff</b>.
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[in] tOff Additional lateral offset allowed left and right of the
+ *  <em>Link's</em> road border
+ * \param[in] xy Given position in the (x,y)-plane of the global IPGRoad
+ *  coordinate system (Fr0)
+ * \param[in,out] st Determined position in the local coordinate system of the
+ *  <em>Link</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetLinkSTExt() \see RoadGetReflineST() \see RoadPathXY2S()
+ */
+int    RoadGetLinkST   (tRoad *road, tObjId lObjId, double tOff,
+			      double xy[2], double st[2]);
+/** Function to convert a given position in the (x,y)-plane of the global
+ *  IPGRoad coordinate system (Fr0) to the corresponding position in the local
+ *  coordinate system of a given <em>Link</em>\n\n
+
+ *  <b><em>Extended version:</em></b>\n
+ *  The position is determined taking into account the longitudinal
+ *  reference positions of the <em>Link</em>: Either the <em>Link's</em>
+ *  start and end, their junction entries or all four of them can be allowed
+ *  (see <b>limLonR</b>).\n
+ *  If the given position <b>xy</b> is in an environment of one of these allowed
+ *  reference positions, the offset on the <em>Link</em> with reference to this
+ *  position is considered as zero and the determined (s,t)-position <b>st</b>
+ *  and the given (x,y,z)-position <b>xy</b> are corrected accordingly.\n
+ *  The offset with reference to the determined reference position is returned
+ *  using the additional parameters <b>s</b> and <b>lonR</b>. In case the given
+ *  position is not in the environment of one of the allowed reference
+ *  positions, <b>lonR</b> is set to <em>Node0</em> or the junction entry of
+ *  <em>Node0</em>, if only the junction entries are allowed as reference
+ *  positions, and <b>s</b> is set to the offset on the <em>Link's</em>
+ *  <em>Reference line</em> with reference to <b>lonR</b>.
+ *  \note In order to determine the position in the local coordinate system,
+ *   Newton's method is applied. As start value the s-coordinate of <b>st</b> is
+ *   used, so it is possible to benefit from additional information about the
+ *   given position. Moreover, it is necessary to restrict the lateral offset
+ *   allowed left and right of the <em>Link's</em> <em>Reference line</em> in
+ *   order to prevent the association of the position with the wrong offset on a
+ *   curved <em>Reference line</em>. If a lateral offset beyond the
+ *   <em>Link's</em> road borders should be allowed, it can be extend using the
+ *   parameter <b>limT</b>.
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[in] limT Additional lateral offset allowed left and right of the
+ *  <em>Link's</em> road border 
+ * \param[in] limLonR Parameter determining which positions are allowed as
+ *  longitudinal reference:
+ *  - 0 &harr; all possible \ref tRoadLonRef "longitudinal references"
+ *  - 1 &harr; starting point \ref RLR_Node0 "Node0" and end point \ref
+ *  RLR_Node1 "Node1"
+ *  - 2 &harr; \ref RLR_JE0 "junction entry of Node0" and \ref RLR_JE1
+ *  "junction entry of Node1"
+ * \param[in] eps Range before and after the allowed reference positions
+ *  restricting the environment where the given position is considered
+ *  as equal to the reference position
+ * \param[in,out] xy Given position in the (x,y)-plane of the global IPGRoad
+ *  coordinate system (Fr0):\n
+ *  In case the position is considered as equal to an allowed reference
+ *  position, the (x,y,z)-coordinates are adapted accordingly.
+ * \param[in,out] st Determined position in the local coordinate system of the
+ *  <em>Link</em>:\n
+ *  In case the position is considered as equal to an allowed reference
+ *  position, the (st)-coordinates are adapted accordingly.
+ * \param[out] s Offset on the <em>Link</em> with reference to <b>lonR</b>
+ * \param[in,out] lonR Longitudinal reference of <b>s</b>:\n
+ *  The parameter <b>limLonR</b> determines which reference positions are
+ *  allowed. In case the given position is in an environment of one of these,
+ *  this reference position is used, otherwise it is set to \ref RLR_Node0
+ *  "Node0" or the \ref RLR_JE0 "junction entry of Node0", if only the junction
+ *   entries are allowed.
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetLinkST() \see RoadGetRefLineSTExt() \see  \see RoadPathXY2SExt()
+ */
+int    RoadGetLinkSTExt(tRoad *road, tObjId lObjId, double limT, int limLonR,
+		  double eps, double xy[2], double st[2], double *s, int *lonR);
+
+/** Function to reverse a <em>Link</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadLinkReverse(tRoad *road, tObjId lObjId);
+/** Function to split a <em>Link</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[in] s Offset on the <em>Link</em> in meters
+ *  where the <em>Link</em> should be split
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadSplitLink  (tRoad *road, tObjId lObjId, double s);
+
+
+/** @} */
+/******************************************************************************/
+/* --- Lane sections -------------------------------------------------------- */
+/******************************************************************************/
+
+/** \addtogroup LSEdit
+ * @{
+ */
+//! Lane section
+/** Struct for the parameters of a <em>Lane section</em>
+ */
+typedef struct tRoadLaneSection {
+    double s;		/**< Offset of the start of the <em>Lane section</em> on
+			 * the <em>Link</em> in meters
+			 */
+} tRoadLaneSection;
+
+/** Function to add a new <em>Lane section</em> to a <em>Link</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[in] ls Pointer to a struct containing the data of the new <em>Lane
+ *  section</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the new <em>Lane section</em>\n
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadGetLaneSection() \see RoadSetLaneSection()
+ * \see RoadDeleteLaneSection() \see RoadAddLane() \see RoadAddLateralOffset()
+ */
+tObjId RoadAddLaneSection   (tRoad *road, tObjId lObjId,  tRoadLaneSection *ls);
+/** Function to get a <em>Lane section</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] lsObjId Object id of the <em>Lane section</em>
+ * \param[out] ls Pointer to a struct for the data of the <em>Lane section</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddLaneSection() \see RoadSetLaneSection()
+ * \see RoadDeleteLaneSection()
+ */
+int    RoadGetLaneSection   (tRoad *road, tObjId lsObjId, tRoadLaneSection *ls);
+/** Function to set a <em>Lane section</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] lsObjId Object id of the <em>Lane section</em>
+ * \param[in] ls Pointer to a struct containing the data for the <em>Lane
+ *  section</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddLaneSection() \see RoadGetLaneSection()
+ * \see RoadDeleteLaneSection()
+ */
+int    RoadSetLaneSection   (tRoad *road, tObjId lsObjId, tRoadLaneSection *ls);
+/** Function to delete a <em>Lane section</em>\n
+ *  \note All objects attached to the <em>Lane section</em> are deleted as well.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] lsObjId Object id of the <em>Lane section</em> that should be
+ *  deleted
+ * \see RoadAddLaneSection() \see RoadGetLaneSection() \see RoadSetLaneSection()
+ */
+void   RoadDeleteLaneSection(tRoad *road, tObjId lsObjId);
+
+/** Function to get the start of a given <em>Lane section</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] lsObjId Object id of the <em>Lane section</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> offset of the <em>Lane section's</em> start on the <em>Link's</em>
+ *  <em>Reference line</em> in meters
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetLaneStart()
+ */
+double RoadGetLSStart         (tRoad *road, tObjId lsObjId);
+/** Function to get the length of a given <em>Lane section</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] lsObjId Object id of the <em>Lane section</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> length of the <em>Lane section</em> in meters\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetLaneLength()
+ */
+double RoadGetLSLength        (tRoad *road, tObjId lsObjId);
+
+/** Function to get the lateral offset of the road border at a certain offset on
+ *  a given <em>Lane section</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] lsObjId Object id of the <em>Lane section</em>
+ * \param[in] sLS Offset on the <em>Lane section</em> in meters
+ * \param[in] side Side of the road: \ref R_LEFT "left" or \ref R_RIGHT "right"
+ * \param[out] t Lateral offset of the road border relative to the <em>Reference
+ *  line</em> at <b>sLS</b> in meters
+ * \param[out] dt Derivation of <b>t</b> at <b>sLS</b>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetLinkBorderT()
+ */
+int    RoadGetLSBorderT(tRoad *road, tObjId lsObjId, double sLS, int side, 
+                                                         double *t, double *dt);
+
+/** Function to get the object id of the <em>Lane section</em> a given offset on
+ *  the <em>Reference line</em> of a <em>Link</em> belongs to
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[in] s Offset on the <em>Link</em> in meters
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the <em>Lane section</em> the given offset belongs to
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ */
+tObjId RoadGetLaneSectionObjId(tRoad *road, tObjId lObjId, double s);
+
+/** Function to get the object id of the <em>Lane section</em> preceding or
+ *  succeeding a given one
+ * \param[in] road Handle of the road instance
+ * \param[in] lsObjId Object id of the <em>Lane section</em>
+ * \param[in] sib Parameter determining which of the <em>Lane sections</em> is
+ *  required:
+ *  - <0 &harr; previous <em>Lane section</em>
+ *  - >0 &harr; successive <em>Lane section</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the previous/successive <em>Lane section</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadLaneGetSibling()
+ */
+tObjId RoadLaneSectionGetSibling(tRoad *road, tObjId lsObjId, int sib);
+
+
+/** @} */
+/******************************************************************************/
+/*    Lanes                                                                   */
+/******************************************************************************/
+
+
+/** \addtogroup LanesEdit
+ * @{
+ */
+/*** Side definition ***/
+
+/** Left side of the road:\n
+ *  Macro used to distinguish between \ref R_RIGHT "right" and left lanes.
+ */
+#define R_LEFT  0
+/** Right side of the road:\n
+ *  Macro used to distinguish between right and \ref R_LEFT "left" lanes.
+ */
+#define R_RIGHT 1
+
+//! Lane attributes
+/** Struct for the attributes of a <em>Lane</em> used as member in the struct
+ *  tRoadLane
+ */
+typedef struct tRoadLaneAttr {
+    tRoadLaneType type;	/**< Type of the <em>Lane</em>
+				 */
+    int 	  i[3];	/**< Unused
+			 */
+} tRoadLaneAttr;
+//! Lane
+/** Struct for the parameters of a <em>Lane</em>
+ */
+typedef struct tRoadLane {    
+    double 	    w0;		/**< Width of the <em>Lane</em> at the start of
+                                 * the <em>Lane section</em>
+				 *
+				 */
+    double 	    w1;		/**< Width of the <em>Lane</em> at the end of
+                                 * the <em>Lane section</em>
+				 *
+				 */
+    tRoadTransitionType type;	/**< Transition type: Mode of interpolation for
+                                 * the lane width at the start of the
+                                 * <em>Lane section</em>
+				 */
+    tRoadLaneAttr   attr;	/**< Struct with the attributes of the
+                                 * <em>Lane</em>
+				 */
+    int 	    n;		/**< Additional width definition:\n
+                                 * Number of one-dimensional nodes used for an
+                                 * additional definition of the lane width
+				 */
+    tRoadNode1D     *width;	/**< Additional width definition:\n
+                                 * List of one-dimensional nodes used for an
+                                 * additional definition of the lane width
+				 * \note
+				 * If there is a one-dimensional node with
+                                 * \ref tRoadNode1D::s "width[i].s"==0 and \ref
+                                 * tRoadNode1D::lonR "width[i].lonR"==RLR_Node0,
+				 * \ref tRoadNode1D::c "width[i].c[0]" will
+                                 * overwrite \ref tRoadLane::w0 "w0". 
+				 * Similarly, if there is a one-dimensional node
+                                 * with \ref tRoadNode1D::s "width[i].s"==0 and
+                                 * \ref tRoadNode1D::lonR
+                                 * "width[i].lonR"==RLR_Node1, \ref
+                                 * tRoadNode1D::c "width[i].c[0]" will overwrite
+                                 * \ref tRoadLane::w1 "w1".
+				 */
+} tRoadLane;
+
+/** Function to add a <em>Lane</em> to a <em>Lane section</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] lsObjId Object id of the <em>Lane section</em>
+ * \param[in] side Side of the <em>Lane section</em>: \ref R_LEFT "left" or
+ *  \ref R_RIGHT "right"
+ * \param[in] lane Pointer to a struct containing the data of the new
+ *  <em>Lane</em>
+ * \param[in] laneObjId Object id of the <em>Lane</em> that should be
+ *  successive to the new one\n
+ *  special value: \ref ROAD_InvalidObjId &harr; The <em>Lane</em> is added
+ *  next to the outermost <em>Lane</em>.
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the new <em>Lane</em>\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetLane() \see RoadSetLane() \see RoadDeleteLane()
+ */
+tObjId RoadAddLane   (tRoad *road, tObjId lsObjId,
+				   int side, tRoadLane *lane, tObjId laneObjId);
+/** Function to get a <em>Lane</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] laneObjId Object id of the <em>Lane</em>
+ * \param[out] lane Pointer to a struct for the data of the <em>Lane</em>
+ * \param[out] side Pointer to an integer value for the side of the <em>Lane
+ *  section</em>: \ref R_LEFT "left" or \ref R_RIGHT "right"
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddLane() \see RoadSetLane() \see RoadDeleteLane()
+ */
+int    RoadGetLane   (tRoad *road, tObjId laneObjId, tRoadLane *lane,
+				   int *side);
+/** Function to set a <em>Lane</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] laneObjId Object id of the <em>Lane</em>
+ * \param[in] lane Pointer to a struct containing the data for the <em>Lane</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddLane() \see RoadGetLane() \see RoadDeleteLane()
+ */
+int    RoadSetLane   (tRoad *road, tObjId laneObjId, tRoadLane *lane);
+/** Function to delete a <em>Lane</em> \n
+ *  \note All objects attached to the <em>Lane</em> are deleted as well.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] laneObjId Object id of the <em>Lane</em> that should be deleted
+ * \see RoadAddLane() \see RoadGetLane() \see RoadSetLane()
+ */
+void   RoadDeleteLane(tRoad *road, tObjId laneObjId);
+
+/** Function to get the start of a given <em>Lane</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] laneObjId Object id of the <em>Lane</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> offset of the <em>Lane's</em> start on the <em>Link's</em>
+ *  <em>Reference line</em> in meters
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetLSStart()
+ */
+double RoadGetLaneStart (tRoad *road, tObjId laneObjId);
+/** Function to get the length of a given <em>Lane</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] laneObjId Object id of the <em>Lane</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> length of the <em>Lane</em> in meters\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetLSLength()
+ */
+double RoadGetLaneLength(tRoad *road, tObjId laneObjId);
+/** Function to get the width of a <em>Lane</em> and the lateral offset of
+ *  its center line from the <em>Link's</em> <em>Reference line</em> at a given
+ *  offset on the <em>Lane</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] laneObjId Object id of the <em>Lane</em>
+ * \param[in] sLane Offset on the <em>Lane</em> in s-direction in meters
+ * \param[out] tCenter Lateral offset of the <em>Lane's</em> center line from
+ *  the <em>Link's</em> <em>Reference line</em> at <b>sLane</b> in meters
+ * \param[out] width Width of the <em>Lane</em> at <b>sLane</b> in meters
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetLaneTW    (tRoad *road, tObjId laneObjId,
+				  double sLane, double *tCenter, double *width);
+
+/** Function to get the lateral offset of a given position in the (x,y)-plane of
+ *  the global IPGRoad coordinate system (Fr0) relative to the width of the
+ *  <em>Lane</em> on which it is located
+ * \param[in] road Handle of the road instance
+ * \param[in] laneObjId Object id of the <em>Lane</em>
+ * \param[in] xy Given position in the (x,y)-plane of the global IPGRoad
+ *  coordinate system (Fr0)
+ * \param[out] width Width of the <em>Lane</em> at the given offset\n
+ *  <em><b>Note</b></em>: Discarded in case this parameter is the NULL pointer. 
+ * \param[out] t Lateral offset from the <em>Lane's</em> center line divided by
+ *  the width of half of the <em>Lane</em>:
+ *  If the given position is left/right of this center line, the
+ *  relative lateral offset is given a positive/negative sign.
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadLaneGetRelLatPosOfXY(tRoad *road, tObjId laneObjId, 
+				double xy[2], double *width, double *t);
+
+/** Function to get the object id of the <em>Lane</em> preceding or succeeding a
+ *  given one
+ * \param[in] road Handle of the road instance
+ * \param[in] laneObjId Object id of the <em>Lane</em>
+ * \param[in] sib Parameter determining which of the <em>Lanes</em> is required:
+ *  - <0 &harr; previous <em>Lane</em>
+ *  - >0 &harr; successive <em>Lane</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the previous/successive <em>Lane</em>
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadLaneSectionGetSibling()
+ */
+tObjId RoadLaneGetSibling(tRoad *road, tObjId laneObjId, int sib);
+
+/** Function to get the number of <em>Lanes</em> on one side of a given
+ *  <em>Lane section</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] lsObjId Object id of the <em>Lane section</em>
+ * \param[in] side Side of the <em>Lane section</em>:
+ *  \ref R_LEFT "left" or \ref R_RIGHT "right"
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Lanes</em> on the given side of the <em>Lane section</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetLSLanesCount (tRoad *road, tObjId lsObjId, int side);
+/** Function to delete all <em>Lanes</em> of a given <em>Lane section</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] lsObjId Object id of the <em>Lane section</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadDeleteAllLSLanes(tRoad *road, tObjId lsObjId);
+
+/** Function to copy the <em>Lanes</em> of a <em>Lane section</em> to another 
+ *  <em>Lane section</em>. Already existing <em>Lanes</em> of the destination 
+ *  <em>Lane section</em> must be deleted first.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] lsSrcObjId Object id of the source <em>Lane section</em>
+ * \param[in] lsDstObjId Object id of the destination <em>Lane section</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table> 
+ */
+int    RoadCpyLSLanes(tRoad *road, tObjId lsSrcObjId, tObjId lsDstObjId);
+
+/** Function to get the lateral offsets of the borders between the
+ *  <em>Lanes</em> of the <em>Lane section</em> at a certain offset on a given
+ *  <em>Link</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] lObjId Object id of the given <em>Link</em>
+ * \param[in] s Given offset on the <em>Link</em> in s-direction
+ * \param [out] t Pointer to an array for the lateral offsets of the lane
+ *  borders
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table> 
+ * \see RoadLaneSectionGetLaneBorders() 
+ */
+int RoadLinkGetLaneBorders (tRoad *road, tObjId lObjId, double s, double **t);
+/** Function to get the lateral offsets of the borders between the
+ *  <em>Lanes</em> of the given <em>Lane section</em> at a certain offset
+ * \param[in,out] road Handle of the road instance
+ * \param[in] lsObjId Object id of the given <em>Lane section</em>
+ * \param[in] s Given offset on the <em>Lane section</em> in s-direction
+ * \param [out] t Pointer to an array for the lateral offsets of the lane
+ *  borders
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadLinkGetLaneBorders() 
+ */
+int RoadLaneSectionGetLaneBorders (tRoad *road, tObjId lsObjId,
+                                                        double s, double **t);
+
+/** Function to convert a given offset on a <em>Link</em> to the corresponding
+ *  offset in s-direction with respect to the <em>Lane</em> on which it is
+ *  located
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of either the <em>Lane</em> or the
+ *  <em>Lane section</em> it belongs to
+ * \param[in] linkS Given offset on the <em>Link</em> in s-direction
+ * \param[in] lonR Integer value for the longitudinal reference of the offset
+ *  with respect to the <em>Lane</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> offset in s-direction with respect to the <em>Lane</em> considering
+ *  the chosen longitudinal reference
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadLaneS2LinkS()
+ */
+double RoadLinkS2LaneS(tRoad *road, tObjId objId, double linkS, tRoadLonRef lonR);
+/** Function to convert a given offset in s-direction with respect to the
+ *  <em>Lane</em> to the corresponding offset on the <em>Link</em> it belongs to
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of either the <em>Lane</em> or the
+ *  <em>Lane section</em> it belongs to
+ * \param[in] laneS Given offset in s-direction on the <em>Lane</em> with
+ *  respect to given longitudinal reference
+ * \param[in] lonR Integer value for the longitudinal reference of <b>laneS</b>:
+ *  \n Only \ref RLR_Node0 "start point" and \ref RLR_Node1 "end point" are
+ *  allowed as reference.
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> offset in s-direction with respect to the <em>Link</em> 
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadLinkS2LaneS()
+ */
+double RoadLaneS2LinkS(tRoad *road, tObjId objId, double laneS, tRoadLonRef lonR);
+
+/** Positions of the aligned reference points of a <em>Lane</em>
+ */
+typedef enum tRoad_ARP_LanePos {
+    ARP_L0 = 0,	/**< <b>0</b> &nbsp; Front left
+		 */
+    ARP_C0,	/**< <b>1</b> &nbsp; Front center
+		 */
+    ARP_R0,	/**< <b>2</b> &nbsp; Front right
+		 */
+    ARP_L1,	/**< <b>3</b> &nbsp; Rear left
+		 */
+    ARP_C1,	/**< <b>4</b> &nbsp; Rear center
+		 */
+    ARP_R1,	/**< <b>5</b> &nbsp; Rear right
+		 */
+    ARP_MAX,	/**< <b>6</b> &nbsp; Maximum number of aligned reference points
+		 */
+} tRoad_ARP_LanePos;
+
+/** Function to get the object id of the aligned reference point on a certain
+ *  position of a given <em>Lane</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] laneObjId Object id of the <em>Lane</em>
+ * \param[in] arpPos Position of the required aligned reference point
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the aligned reference point\n
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ */
+tObjId RoadLaneGetARP(tRoad *road, tObjId laneObjId, tRoad_ARP_LanePos arpPos);
+/** Function to get the position of an aligned reference point
+ * \param[in] road Handle of the road instance
+ * \param[in] arpObjId Object id of the aligned reference point
+ * \param[out] xy Calculated position of the aligned reference point in the
+ *  (x,y)-plane of the global IPGRoad coordinate system (Fr0)
+ * \param[out] angle Direction vector of the aligned reference point in degrees
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetARP    (tRoad *road, tObjId arpObjId,
+						   double xy[2], double *angle);
+
+
+/** @} */
+/******************************************************************************/
+/* --- Lateral offset ------------------------------------------------------- */
+/******************************************************************************/
+ 
+/** \addtogroup LatOffEdit
+ * @{
+ */
+//! Lateral offset 
+/** Struct for the parameters of the <em>Lateral offset</em> of the center line
+ *  from the <em>Link's</em> <em>Reference line</em>
+ */
+typedef struct tRoadLateralOffset {    
+    int 	n;	/**< Number of one-dimensional nodes used to define the
+			 * <em>Lateral offset</em>
+			 */
+    tRoadNode1D *node;	/**< List of one-dimensional nodes used to define the
+			 * <em>Lateral offset</em>
+			 */    
+} tRoadLateralOffset;
+
+/** Function to add a new <em>Lateral offset</em> to a <em>Link</em> or
+ *  <em>Lane section</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] paObjId Object id of the parent object that can be either a
+ *  <em>Link</em> or a <em>Lane section</em>
+ * \param[in] lo Pointer to a struct containing the data of the new
+ *  <em>Lateral offset</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the new <em>Lateral offset</em>
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadGetLateralOffset() \see RoadSetLateralOffset()
+ * \see RoadDeleteLateralOffset()
+ */
+tObjId RoadAddLateralOffset   (tRoad *road, tObjId paObjId,
+							tRoadLateralOffset *lo);
+/** Function to get a <em>Lateral offset</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] loObjId Object id of the <em>Lateral offset</em>
+ * \param[out] lo Pointer to a struct for the data of the
+ *  <em>Lateral offset</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddLateralOffset() \see RoadSetLateralOffset()
+ * \see RoadDeleteLateralOffset()
+ */
+int    RoadGetLateralOffset   (tRoad *road, tObjId loObjId, 
+							tRoadLateralOffset *lo);
+/** Function to set a <em>Lateral offset</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] loObjId Object id of the <em>Lateral offset</em>
+ * \param[in] lo Pointer to a struct containing the data for the
+ *  <em>Lateral offset</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddLateralOffset() \see RoadGetLateralOffset()
+ * \see RoadDeleteLateralOffset()
+ */
+int    RoadSetLateralOffset   (tRoad *road, tObjId loObjId,
+							tRoadLateralOffset *lo);
+/** Function to delete a <em>Lateral offset</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] loObjId Object id of the <em>Lateral offset</em> that should be
+ *  deleted
+ * \see RoadAddLateralOffset() \see RoadGetLateralOffset()
+ * \see RoadSetLateralOffset
+ */
+void   RoadDeleteLateralOffset(tRoad *road, tObjId loObjId);
+
+/** Function to get the object id of the <em>Lateral offset</em> belonging to a
+ *  given <em>Link</em> or <em>Lane section</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] parentObjId Object id of the parent object that can be either a
+ *  <em>Link</em> or a <em>Lane section</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the <em>Lateral offset</em>\n
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ */
+tObjId RoadGetLateralOffsetObjId(tRoad *road, tObjId parentObjId);
+
+
+/** @} */
+/******************************************************************************/
+/* --- Height profiles ------------------------------------------------------ */
+/******************************************************************************/
+
+
+/** \addtogroup ZprofilesEdit
+ * @{
+ */
+
+//! Height profile
+/** Struct for the parameters of a height profile
+ */
+typedef struct tRoadZP {    
+    int 	n;		/**< Number of one-dimensional nodes used to
+				 * define the  height profile
+				 */
+    tRoadNode1D *node;		/**< List of the one-dimensional nodes used to
+				 * define the height profile
+				 * \note At the moment only \ref RTT_Cubic
+				 * "cubic interpolation" is allowed.
+				 */
+    int 	isAbsolute;     /**< Flag indicating whether the values are
+                                 * absolute:
+                                 * - 0 &harr; The given values are considered
+                                 * relative to the value in the <em>Link's</em>
+                                 * starting point <em>Node0</em>.
+				 * - 1 &harr; The given values are considered
+                                 * absolute.
+				 * 
+                                 * \note Only for <em>Elevation profiles</em>.
+                                 * Relative values are NOT supported yet
+				 */
+    double 	smooth;		/**< Smoothing factor for the nodes:\n
+                                 * no smoothing &harr; 0..1 &harr; maximum
+                                 * smoothing
+				 */
+} tRoadZP;
+
+/** Function to add a new <em>Height profile</em> to a <em>Link</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[in] type Type of the new <em>Height profile</em>:
+ *  <em>\ref ROT_LonZPElevation "elevation"</em>, <em> \ref ROT_LatZPSlope
+ *  "slope"</em> or <em>\ref ROT_LatZPCamber "camber"</em>
+ * \param[in] zp Pointer to a struct containing the data of the new
+ *  <em>Height profile</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the new <em>Height profile</em>\n
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadGetZProfile() \see RoadSetZProfile() \see RoadDeleteZProfile()
+ */
+tObjId RoadAddZProfile   (tRoad *road, tObjId lObjId, int type, tRoadZP *zp);
+/** Function to get a <em>Height profile</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] zpObjId Object id of the <em>Height profile</em>
+ * \param[out] zp Pointer to a struct for the data of the
+ *  <em>Height profile</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of nodes of the <em>Height profile</em>\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddZProfile() \see RoadSetZProfile() \see RoadDeleteZProfile()
+ */
+int    RoadGetZProfile   (tRoad *road, tObjId zpObjId,          tRoadZP *zp);
+/** Function to set a <em>Height profile</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] zpObjId Object id of the <em>Height profile</em>
+ * \param[in] zp Pointer to a struct containing the data for the
+ *  <em>Height profile</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road. 
+ *  </table>
+ * \see RoadAddZProfile() \see RoadGetZProfile() \see RoadDeleteZProfile()
+ */
+int    RoadSetZProfile   (tRoad *road, tObjId zpObjId,          tRoadZP *zp);
+/** Function to delete a <em>Height profile</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] zpObjId Object id of the <em>Height profile</em> that should be
+ *  deleted
+ * \see RoadAddZProfile() \see RoadGetZProfile() \see RoadSetZProfile()
+ */
+void   RoadDeleteZProfile(tRoad *road, tObjId zpObjId);
+
+/** Function retrieving the bounding box of an <em>Elevation profile</em> along
+ *  a given <em>Link</em> or <em>Route</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the <em>Link</em> or <em>Route</em>
+ * \param[out] bb Pointer to the bounding box:\n
+ *  The <em>Elevation profile</em> is given as function of the offset on the
+ *  <em>Link</em> or <em>Route</em>. Therefore, the bounding box is used for its
+ *  s- and the z-coordinate (the third dimension is unused).
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetElevationBBox(tRoad *road, tObjId objId, tRoadBBox *bb);
+
+
+/** @} */
+/******************************************************************************/
+/* +++ Reference Lines ++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+/** \addtogroup RefLinesEdit
+ * @{
+ */
+//! Reference line
+/** Struct for the parameters of a <em>Reference line</em>
+ */
+typedef struct tRoadRefLine {    
+    double xyz0[3];	/**< Position of the starting point <em>Node0</em> of
+                         * the <em>Reference line</em>
+                         * \note If the <em>Reference line</em> belongs to a
+                         * <em>Link</em> or a \ref tRoadRefLine::objId0
+                         * "reference object" is used for <em>Node0</em>, the
+                         * position is given in the global IPGRoad coordinate
+                         * system (Fr0). Otherwise, the local coordinate system
+                         * of the <em>Junction</em> the <em>Reference line</em>
+                         * belongs to is used.
+			 */
+    double xyz1[3];	/**< Position of the end point <em>Node1</em> of the
+                         * <em>Reference line</em>
+                         * \note If the <em>Reference line</em> belongs to a
+                         * <em>Link</em> or a \ref tRoadRefLine::objId1
+                         * "reference object" is used for <em>Node1</em>, the
+                         * position is given in the global IPGRoad coordinate
+                         * system (Fr0). Otherwise, the local coordinate system
+                         * of the <em>Junction</em> the <em>Reference line</em>
+                         * belongs to is used.
+			 */
+    double angle0;	/**< Angle of the first <em>Segment</em> of the
+                         * <em>Reference line</em> relative to the x-axis in
+			 * degrees
+			 */
+    double angle1;	/**< Angle of the last <em>Segment</em> of the
+                         * <em>Reference line</em> relative to the x-axis in
+			 * degrees
+			 */
+    double l0;		/**< Unused
+			 */
+    double l1;		/**< Unused
+			 */
+    tObjId objId0;	/**< Object id of the reference object for the starting
+			 * point <em>Node0</em> of the <em>Reference line</em>
+                         * that can be a <em>Junction arm</em>, an aligned
+                         * reference point, a <em>Lane path</em> or a <em>User
+                         * path</em>.\n
+                         * Special value: \ref ROAD_InvalidObjId &harr;
+                         * The position is determined by the previous variables. 
+			 * \note Optional parameter used for <em>Reference
+                         *  lines</em> which do not belong to a <em>Link</em>.\n
+                         *  Default: ROAD_InvalidObjId
+			 */
+    tObjId objId1;	/**< Object id of the reference object for the end
+			 * point <em>Node1</em> of the <em>Reference line</em>
+                         * that can be a <em>Junction arm</em>, an aligned
+                         * reference point, a <em>Lane path</em> or a <em>User
+                         * path</em>.\n
+                         * Special value: \ref ROAD_InvalidObjId &harr;
+                         * The position is determined by the previous variables. 
+			 * \note Optional parameter used for <em>Reference
+                         *  lines</em> which do not belong to a <em>Link</em>.\n
+                         *  Default: ROAD_InvalidObjId
+			 */
+} tRoadRefLine;
+
+/** Function to add a <em>Reference line</em> to a <em>Junction</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the <em>Junction</em> the <em>Reference
+ *  line</em> is added to
+ * \param[in] rl Pointer to a struct containing the data of the new
+ *  <em>Reference line</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the new <em>Reference line</em>\n
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadGetRefLine() \see RoadSetRefLine() \see RoadDeleteRefLine()
+ * \see RoadAddSegment()
+ * \see RoadAddBump() \see RoadAddMarker() \see RoadAddSensorObject()  
+ */
+tObjId RoadAddRefLine   (tRoad *road, tObjId objId,   tRoadRefLine *rl);
+/** Function to get a <em>Reference line</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] rlObjId Object id of the <em>Reference line</em>
+ * \param[out] rl Pointer to a struct for the data of the <em>Reference
+ *  line</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddRefLine() \see RoadSetRefLine() \see RoadDeleteRefLine()
+ */
+int    RoadGetRefLine   (tRoad *road, tObjId rlObjId, tRoadRefLine *rl);
+/** Function to set a <em>Reference line</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] rlObjId Object id of the <em>Reference line</em>
+ * \param[in] rl Pointer to a struct containing the data for the <em>Reference
+ *  line</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddRefLine() \see RoadGetRefLine() \see RoadDeleteRefLine()
+ */
+int    RoadSetRefLine   (tRoad *road, tObjId rlObjId, tRoadRefLine *rl);
+/** Function to delete a <em>Reference line</em>
+ *  \note All objects attached to the <em>Reference line</em> are deleted as
+ *   well.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] rlObjId Object id of the <em>Reference line</em> that should be
+ *  deleted
+ * \see RoadAddRefLine() \see RoadGetRefLine() \see RoadSetRefLine()
+ */
+void   RoadDeleteRefLine(tRoad *road, tObjId rlObjId);
+
+/** Function to internally update a <em>Reference line</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] rlObjId Object id of the <em>Reference line</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadUpdateRefLine(tRoad *road, tObjId rlObjId);
+
+/** Function to get the length of a <em>Reference line</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] rlObjId Object id of the <em>Reference line</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> length of the <em>Reference line</em> in meters
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+double RoadGetRefLineLength (tRoad *road, tObjId rlObjId);
+/** Function to get the heading of a <em>Reference line</em> at a certain offset
+ *  \n The heading is the angle between the x-axis of the global IPGRoad
+ *  coordinate system (Fr0) and the s-axis of the local coordinate system of the
+ *  <em>Reference line</em> (couterclockwise). 
+ * \param[in] road Handle of the road instance
+ * \param[in] rlObjId Object id of the <em>Reference line</em>
+ * \param[in] s  Offset on the <em>Reference line</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> heading of the <em>Reference line</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetLinkHeading()
+ */
+double RoadGetRefLineHeading(tRoad *road, tObjId rlObjId, double s);
+
+/** Function to convert a given position in the (x,y)-plane of the global
+ *  IPGRoad coordinate system (Fr0) to the corresponding position in the local
+ *  coordinate system of a given <em>Reference line</em>
+ *  \note In order to determine the position in the local coordinate system,
+ *   Newton's method is applied. As start value the s-coordinate of <b>st</b> is
+ *   used, so it is possible to benefit from additional information about the
+ *   given position. Moreover, it is necessary to restrict the lateral offset
+ *   allowed left and right of the <em>Reference line</em> in order to prevent
+ *   the association of the position with the wrong offset on a curved
+ *  <em>Reference line</em>.
+ * \param[in] road Handle of the road instance
+ * \param[in] rlObjId Object id of the <em>Reference line</em>
+ * \param[in] tOff Lateral offset allowed left and right of the
+ *  <em>Reference line</em>
+ * \param[in] xy Given position in the (x,y)-plane of the global IPGRoad
+ *  coordinate system (Fr0) 
+ * \param[in,out] st Determined position in the local coordinate system of the
+ *  <em>Reference line</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetRefLineSTExt() \see RoadGetLinkST() \see RoadPathXY2S()
+ */
+int    RoadGetReflineST   (tRoad *road, tObjId rlObjId, double tOff, 
+			     double xy[2], double st[2]);
+/** Function to convert a given position in the (x,y)-plane of the global
+ *  IPGRoad coordinate system (Fr0) to the corresponding position in the local
+ *  coordinate system of a given <em>Reference line</em>\n\n
+ *  <b><em>Extended version:</em></b>\n
+ *  The position is determined taking into account the longitudinal
+ *  reference positions of the <em>Reference line</em>: Either the
+ *  <em>Reference line's</em> start and end or, in case it belongs to a
+ *  <em>Link</em>, their junction entries or all four of them can be allowed
+ *  (see <b>limLonR</b>).\n
+ *  If the given position <b>xy</b> is in an environment of one of these allowed
+ *  reference positions, the offset on the <em>Reference line</em> with
+ *  reference to this position is considered as zero and the determined
+ *  (s,t)-position <b>st</b> and the given (x,y,z)-position <b>xy</b>
+ *  are corrected accordingly.\n
+ *  The offset with reference to the determined reference position is returned
+ *  using the additional parameters <b>s</b> and <b>lonR</b>. In case the given
+ *  position is not in the environment of one of the allowed reference
+ *  positions, <b>lonR</b> is set to <em>Node0</em> or the junction entry of
+ *  <em>Node0</em>, if only the junction entries are allowed as reference
+ *  positions, and <b>s</b> is set to the offset on the <em>Reference line</em>
+ *  with reference to <b>lonR</b>.
+ *  \note In order to determine the position in the local coordinate system,
+ *   Newton's method is applied. As start value the s-coordinate of <b>st</b> is
+ *   used, so it is possible to benefit from additional information about the
+ *   given position. Moreover, it is necessary to restrict the lateral offset
+ *   allowed left and right of the <em>Reference line</em> in order to prevent
+ *   the association of the position with the wrong offset on a curved
+ *  <em>Reference line</em>.
+ * \param[in] road Handle of the road instance
+ * \param[in] rlObjId Object id of the <em>Reference line</em>
+ * \param[in] limT Lateral offset allowed left and right of the
+ *  <em>Reference line</em>
+ * \param[in] limLonR Parameter determining which positions are allowed as
+ *  longitudinal reference:
+ *  - 0 &harr; all possible \ref tRoadLonRef "longitudinal references"
+ *  - 1 &harr; starting point \ref RLR_Node0 "Node0" and end point
+ *  \ref RLR_Node1 "Node1"
+ *  - 2 &harr; \ref RLR_JE0 "junction entry of Node0" and \ref RLR_JE1
+ *  "junction entry of Node1"
+ * \param[in] eps Range before and after the allowed reference positions
+ *  restricting the environment where the given position is considered
+ *  as equal to the reference position
+ * \param[in,out] xy Given position in the (x,y)-plane of the global IPGRoad
+ *  coordinate system (Fr0):\n
+ *  In case the position is considered as equal to an allowed reference
+ *  position, the (x,y,z)-coordinates are adapted accordingly.
+ * \param[in,out] st Determined position in the local coordinate system of the
+ *  <em>Reference line</em>:\n
+ *  In case the position is considered as equal to an allowed reference
+ *  position, the (st)-coordinates are adapted accordingly.
+ * \param[out] s Offset on the <em>Reference line</em> with reference to
+ *  <b>lonR</b>
+ * \param[in,out] lonR  Longitudinal reference of <b>s</b>:\n
+ *  The parameter <b>limLonR</b> determines which reference positions are
+ *  allowed. In case the given position is in an environment of one of these,
+ *  this reference position is used, otherwise it is set to \ref RLR_Node0
+ *  "Node0" or the \ref RLR_JE0 "junction entry of Node0", if only the junction
+ *   entries are allowed.
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetReflineST() \see RoadGetLinkSTExt() \see RoadPathXY2SExt()
+ */
+int    RoadGetRefLineSTExt(tRoad *road, tObjId rlObjId,
+			     double limT, int limLonR, double eps,
+			     double xy[2], double st[2], double *s, int *lonR);
+
+/** Reference line evaluation mode:\n
+ * Mode controlling which of a number of possible positions in the local
+ * coordinate system of a <em>Reference line</em> a position in the (x,y)-plane
+ * of the global IPGRoad coordinate system (Fr0) is converted to by
+ * \ref RoadGetRefLineST()
+ */
+typedef enum tRoadRefLineEvalMode {
+    RRLEM_0=0,      /**< <b>0</b> &nbsp; No special action,
+                     * <b>\ref RoadGetRefLineST "param"</b> is not considered
+                     * at all.
+                     */
+    RRLEM_1,        /**< <b>1</b> &nbsp; If there are multiple solutions 
+                     * for a given x,y coordinate, the function will deliver 
+                     * the one with the shortest distance to a given 
+                     * <em>s</em>, either before <em>s</em> in case <em>dir</em><0 
+                     * or behind <em>s</em> in case <em>dir</em>>0
+                     */
+    RRLEM_2,        /**< <b>2</b> &nbsp; If there are multiple solutions 
+                     * for a given x,y coordinate, the function will deliver 
+                     * the one with the shortest distance between the found 
+                     * <em>t</em> and a given <em>tOffset</em>, either before 
+                     * <em>s</em> in case <em>dir</em><0 or behind <em>s</em> 
+                     * in case <em>dir</em>>0
+                     */
+    RRLEM_Unknown,  /**< <b>3</b> &nbsp; Unknown reference line evaluation mode
+                     */
+} tRoadRefLineEvalMode;
+
+/** Function to convert a given position in the (x,y)-plane of the global
+ *  IPGRoad coordinate system (Fr0) to the corresponding position in the local
+ *  coordinate system of a given <em>Reference line</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] rlObjId Object id of the <em>Reference line</em>
+ * \param[in] mode \ref tRoadRefLineEvalMode "Evaluation mode" to be used
+ * \param[in] param Optional parameters depending on <b>mode</b>
+ * - <b>param</b>[0]: Direction
+ * - <b>param</b>[1]: Side
+ * - <b>param</b>[2]: Maximum allowed distance in t-direction between found st[1] and 
+ * <em>tOffset</em>
+ * - <b>param</b>[3]: s coordinate for starting the search
+ * - <b>param</b>[4]: Given tOffset
+ * \param[in] xy Given position in the (x,y)-plane of the global IPGRoad
+ *  coordinate system (Fr0) 
+ * \param[in,out] st Determined position in the local coordinate system of the
+ *  <em>Reference line</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetRefLineST   (tRoad *road, tObjId rlObjId, int mode,
+                                   double param[5], double xy[2], double st[2]);
+
+/** Function to check whether a given <em>Reference line</em> is one of the
+ * <em>Reference lines</em> used to define the course of <em>Routes</em> across
+ * a <em>Junction</em>\n
+ * For each arm of a <em>Junction</em> there exist automatically created
+ * <em>Reference lines</em> connecting it with each of the other arms. Such
+ * <em>Reference lines</em> are necessary for the definition of a <em>Route</em>
+ * leading across a <em>Junction</em>, since they serve the same purpose as the
+ * <em>Reference lines</em> of <em>Links</em> do for the parts of a
+ * <em>Route</em> leading along <em>Links</em>. Therefore, these <em>Junction
+ * Route Reference lines</em> must not be deleted.
+ * \param[in] road Handle of the road instance
+ * \param[in] rlObjId Object id of the <em>Reference line</em>
+ * \return Flag indicating whether the given object is one of the <em>Reference
+ * lines</em> necessary for the definition of <em>Routes</em> across a
+ * <em>Junction</em>:
+ *  - 0 &harr; The object is no <em>Junction Route Reference line</em>.
+ *  - 1 &harr; The object is a <em>Junction Route Reference line</em>.
+ */
+int    RoadRefLineIsJunctionRouteRefLine(tRoad *road, tObjId rlObjId);
+
+
+/** @} */
+/******************************************************************************/
+/* --- Segments ------------------------------------------------------------- */
+/******************************************************************************/
+
+
+/** \addtogroup SegmentsEdit
+ * @{
+ */
+/** Maximum number of parameters of a <em>Segment</em>:\n
+ *  For each <em>Segment</em> at most eight parameters are defined.
+ */
+#define ROAD_SEG_MAXPARAM  8
+/** Maximum number of points of a <em>Segment</em>:\n
+ *  For each <em>Segment</em> at most fifty points can be defined.
+ */
+#define ROAD_SEG_MAXPTS   50
+
+
+/** Types of <em>Segments</em>
+ */
+typedef enum tRoadSegmentType {    
+    RST_Straight = 0,	/**< <b>0</b> &nbsp; Straight segment
+			 */
+    RST_TurnLeft,	/**< <b>1</b> &nbsp; Circular segment turning left
+			 */
+    RST_TurnRight,	/**< <b>2</b> &nbsp; Circular segment turning right
+			 */
+    RST_ClothLeft,	/**< <b>3</b> &nbsp; Clothoitical segment turning left
+			 */
+    RST_ClothRight,	/**< <b>4</b> &nbsp; Clothoitical segment turning right
+			 */
+    RST_Polynom,	/**< <b>5</b> &nbsp; Cubic polynomial of form 
+                         * y=ax<sup>3</sup>+bx<sup>2</sup>+cx+d
+			 * \warning Not yet supported!
+			 */
+    RST_PointList,	/**< <b>6</b> &nbsp; Point list
+			 */
+    RST_File,		/**< <b>7</b> &nbsp; Point list read from a file
+			 */
+    RST_Connect,	/**< <b>8</b> &nbsp; Connect segments using a cubic polynomial
+			 */
+    RST_Unknown		/**< <b>9</b> &nbsp; Unknown segment type
+			 */
+} tRoadSegmentType;
+//! Segment
+/** Struct for the parameters of a <em>Segment</em>
+ */
+typedef struct tRoadSegment {    
+    tRoadSegmentType type;		/**< Type of the <em>Segment</em>
+					 */
+    double 	 param[ROAD_SEG_MAXPARAM];/**< Parameters of the
+					 * <em>Segment</em>: The meaning depends
+                                         * on the segment type.
+ * - \ref RST_Straight "Straight": Only the length of the <em>Segment</em> needs
+ * to be defined.
+ * - \ref RST_TurnLeft "TurnLeft"/\ref RST_TurnRight "TurnRight": Radius and
+ * angle of the turn have to be set.
+ * - \ref RST_ClothLeft "ClothLeft"/\ref RST_ClothRight "ClothRight": Besides
+ * the turn angle, start and end radius of the clothoid must be defined.
+ * - \ref RST_Polynom "Polynom": The four coefficients of the cubic polynomial
+ * have to be defined: y=ax<sup>3</sup>+bx<sup>2</sup>+cx+d.
+ * - \ref RST_PointList "PointList": The end direction vector and the smoothing
+ * factor needs to be specified. Moreover, it is necessary to indicate whether
+ * the \ref tRoadSegment::p "points" are given relative to the start point or
+ * absolute. 
+ * - \ref RST_File "File": Smoothing factors for xy, z and q and a scaling
+ * factor for the <em>Elevation profile</em> have to be set. Furthermore, it is
+ * necessary to determine whether the (x,y)-coordinates and the different types
+ * of <em>Height profiles</em> are given absolute or relative to the insertion
+ * point.
+ * - \ref RST_Connect "Connect": Since a <em>Segment</em> of this type is
+ * flexible and only defined by the properties of the two parts of the <em>Road
+ * network</em> it connects, there are no parameters to be set.
+ * 
+ * \n
+<table>
+<tr><th> param <th> Straight <th> Turn <th> Clothoid <th> Polynom 
+    <th> Point list <th> File <th> Connect
+<tr><td> [0] <td> length <td> radius  
+                       <td> rStart <td> a <td> suv1x   <td> xyIsAbs     <td> 
+<tr><td> [1] <td>        <td> angle   
+                       <td> rEnd  <td> b <td> suv1y    <td> smoothXY    <td> 
+<tr><td> [2] <td> <td> <td> angle <td> c <td> isAbs    <td> smoothZ     <td>
+<tr><td> [3] <td> <td> <td>       <td> d <td> smoothXY <td> smoothQ     <td>
+<tr><td> [4] <td> <td> <td>       <td>   <td> pType    <td> zIsAbs      <td>
+<tr><td> [5] <td> <td> <td>       <td>   <td>          <td> zScale      <td>
+<tr><td> [6] <td> <td> <td>       <td>   <td>          <td> slopeIsAbs  <td>
+<tr><td> [7] <td> <td> <td>       <td>   <td>          <td> camberIsAbs <td>
+</table>
+ * \n
+ * \note
+ *  - Length and radii are given in meters.
+ *  - Angles are given in degrees.
+ *  - Smoothing values must be in the range of 0..1.
+ * 
+ * \note Set all unused parameters to zero!
+ */ 
+/* --- Type RST_File only ------------------------------------------ */
+/**
+ * \name File parameters:
+ * The following parameters are only used in case the segment is of type
+ * <em>\ref RST_File "File"</em>.
+ * @{
+ */
+    char   *fname;		/**< <em>Type RST_File only:</em>\n
+                                 * Name of the file
+				 */
+    char   *fMaterial;		/**< <em>Type RST_File only:</em>\n
+                                 * Material of the <em>Segment</em>
+                                 * \deprecated Set this parameter to NULL.\n 
+                                 * Use RoadObjectGetMaterial()/
+                                 * RoadObjectSetMaterial() for the definition of
+                                 * the material of the <em>Segment</em>.
+				 */
+    double fTexX;		/**< <em>Type RST_File only:</em>\n
+				 * Scaling factor for the image texture in
+                                 * x-direction
+                                 * \deprecated Use RoadObjectGetMaterial()/
+                                 * RoadObjectSetMaterial() for the definition of
+                                 * the material of the <em>Segment</em>.
+				 */
+    double fTexY;		/**< <em>Type RST_File only:</em>\n
+				 * Scaling factor for the image texture in
+                                 * y-direction
+                                 * \deprecated Use RoadObjectGetMaterial()/
+                                 * RoadObjectSetMaterial() for the definition of
+                                 * the material of the <em>Segment</em>.
+				 */
+    double fRampU[2];		/**< <em>Type RST_File only:</em>\n
+				 * Transition ramp before and after the mesh
+				 */
+    double fRampV[2];		/**<<em>Type RST_File only:</em>\n
+				 * Transition ramp right and left of the mesh
+				 */
+    double fTOff;		/**< <em>Type RST_File only:</em>\n
+                                 * Lateral offset of a mesh or crg
+				 */
+    double fZScale;		/**< <em>Type RST_File only:</em>\n
+				 * Grid scale factor in z-direction for a mesh
+                                 * or crg
+                                 * \note Not used if \ref tRoadSegment::param
+                                 *  "xyisAbs" is chosen.
+				 */
+    double fUScale;		/**< <em>Type RST_File only:</em>\n
+				 * Grid scale factor in u-direction for a mesh
+				 * or crg
+				 */
+    double fVScale;		/**< <em>Type RST_File only:</em>\n
+				 * Grid scale factor in v-direction for a mesh
+                                 * or crg
+				 */
+    int    fUseMesh;		/**< <em>Type RST_File only:</em>\n
+				 * Flag indicating whether a mesh, e.g. crg
+                                 * files, should be used if available.
+                                 * - 0 &harr; The mesh is not used.
+				 * - 1 &harr; The mesh is used.
+				 */
+    int    fUseZProfile[3];	/**< <em>Type RST_File only:</em>\n
+                                 * Flag indicating whether <em>Elevation</em>,
+                                 * <em>Slope</em> and <em>Camber profiles</em>
+                                 * should be used if available.
+                                 * - 0 &harr; The height profile is not used.
+				 * - 1 &harr; The height profile is used.
+				 */
+    int	   fTType;		/**< <em>Type RST_File only:</em>\n
+				 * \ref tRoadTransitionType "Transition type"
+                                 * for the file data
+				 */
+    int    fReverse;		/**< <em>Type RST_File only:</em>\n
+                                 * Flag indicating whether the file data should
+                                 * be reversed.
+                                 * - 0 &harr; The file data is not reversed.
+				 * - 1 &harr; The file data is reversed
+                                 */
+    int    fType;		/**< <em>Type RST_File only:</em>\n
+                                 * \ref tRoadDataFileType "File type": Ascci,
+                                 * kml or crg \note Output only!
+				 */
+    int    fAvailableData;      /**< <em>Type RST_File only:</em>\n
+                                 * Available file data: 
+				 * The binary system is used to generate
+				 * combinations of the data options
+				 * #ROAD_FD_XY, #ROAD_FD_LATLON,
+				 * #ROAD_FD_ELEVATION, #ROAD_FD_SLOPE,
+				 * #ROAD_FD_CAMBER and #ROAD_FD_MESH.
+				 * \note Output only!
+				 */
+/** @} */
+/* --- Type RST_PointList only ------------------------------------- */
+ /**
+ * \name Point list parameters:
+ * The following parameters are only used in case the <em>Segment</em> is of
+ * type <em>\ref RST_PointList "Point list"</em>.
+ * @{
+ */
+    int    nP;                   /**< <em>Type RST_PointList only:</em>\n
+				  * Number of points in the point list
+				  */
+    double (*p)[3];              /**< <em>Type RST_PointList only:</em>\n
+				  * List with the (x,y)-coordinates and the
+                                  * s-coordinate of the points defining the
+                                  * <em>Segment</em>
+				  * \note The user is responsible to allocate
+                                  *  and free the memory for this variable
+				  * (use for example
+                                  * p=(double*()[3])calloc(nP,sizeof(double[3]))).
+				  */
+/** @} */
+} tRoadSegment;
+
+
+/** Types of data files:\n
+ *  Used e.g. for the <em>Segments</em> read from a file.
+ */
+typedef enum tRoadDataFileType {    
+    RDFT_ASCCI_XY = 0,	/**< <b>0</b> &nbsp; ASCCI XY format
+			 */
+    RDFT_ASCCI_LL,	/**< <b>1</b> &nbsp; ASCCI LL format
+			 */
+    RDFT_BIN,		/**< <b>2</b> &nbsp; Binary format
+    			 */
+    RDFT_KML,		/**< <b>3</b> &nbsp; KML format\note
+			 * This file format is created for example by route
+			 * export from google earth.
+			 */
+    RDFT_CRG,		/**< <b>4</b> &nbsp; OpenCRG format
+    			 */
+    RDFT_RD5,           /**< <b>4</b> &nbsp; IPGRoad rd5 format\note
+                         * This file format is NOT allowed for <em>Segments</em>
+                         * of type <em>File</em>.
+    			 */
+    RDFT_XODR,          /**< <b>4</b> &nbsp; OpenDRIVE format\note
+                         * This file format is NOT allowed for <em>Segments</em>
+                         * of type <em>File</em>.
+    			 */
+    RDFT_Unknown,	/**< <b>5</b> &nbsp; Unknown file format
+    			 */
+} tRoadDataFileType;
+
+
+/*** File data options ***/
+
+/** File data (x,y)-coordinates:\n
+ *  Flag for <em>Segments</em> of type <em>File</em> indicating the \ref
+ *  tRoadSegment::fAvailableData "availability" of (x,y)-coordinates in a file.
+ */
+#define ROAD_FD_XY           (1<<0)
+/** File data (lat,lon)-coordinates:\n
+ *  Flag for <em>Segments</em> of type <em>File</em> indicating the
+ *  \ref tRoadSegment::fAvailableData "availability" of (lat,lon)-coordinates in
+ *  the file\n
+ *  In case this data is available, \ref tRoadSegment::param "xyIsAbs"
+ *  is set to 1 internally.
+ */
+#define ROAD_FD_LATLON       (1<<1)  
+/** File data elevation profile:\n
+ *  Flag for <em>Segments</em> of type <em>File</em> indicating the
+ *  \ref tRoadSegment::fAvailableData "availability" of an <em>Elevation
+ *  profile</em> in the file.
+ */
+#define ROAD_FD_ELEVATION    (1<<2)
+/** File data slope profile:\n
+ *  Flag for <em>Segments</em> of type <em>File</em> indicating the
+ *  \ref tRoadSegment::fAvailableData "availability" of a <em>Slope profile</em>
+ *  in the file.
+ */
+#define ROAD_FD_SLOPE        (1<<3)
+/** File data camber profile:\n
+ *  Flag for <em>Segments</em> of type <em>File</em> indicating the
+ *  \ref tRoadSegment::fAvailableData "availability" of a <em>Camber
+ *  profile</em> in the file.
+ */
+#define ROAD_FD_CAMBER       (1<<4)
+/** File data mesh:\n
+ *  Flag for <em>Segments</em> of type <em>File</em> indicating the
+ *  \ref tRoadSegment::fAvailableData "availability" of a mesh in the file.
+ */
+#define ROAD_FD_MESH         (1<<5)
+
+
+/*** Point list Segment parametrization options ***/
+
+
+/** Calculation of s parametrization necessary:\n
+ *  Flag for <em>Segments</em> of type <em>Point list</em> indicating that the
+ *  calculation of the s parametrization is done using internal functions
+ *  considering the parametrization method given by \ref tRoadSegment::param
+ *  "pType".
+ *  It is set internally after each change of the <em>Segment</em> either by
+ *  \ref RoadAddSegment(), \ref RoadSetSegment(), \ref RoadAddNode2D(),
+ *  \ref RoadSetNode2D or \ref RoadDeleteNode2D(). Consequently, the externally
+ *  given parametrization of the <em>Segment's</em> point list is ignored.
+ */
+#define ROAD_PL_INIT                (1<<0)
+/** Parametrization available:\n
+ *  Flag for <em>Segments</em> of type <em>Point list</em> indicating that a
+ *  valid s parametrization of the spline is available.
+ */
+#define ROAD_PL_S_AVAILABLE         (1<<1)
+/** External parameterization available:\n
+ *  Flag for <em>Segments</em> of type <em>Point list</em> indicating whether
+ *  <b>all</b> given points have a valid externally given s position. This is
+ *  the case if none of these points has a negative s value and there are no two
+ *  points with the same s position. If this flag is set, the external s values
+ *  are used for the s parametrization of the <em>Segment's</em> spline.
+ */
+#define ROAD_PL_EXTERN_S_AVAILABLE   (1<<2)
+/** Length difference detected:\n
+ *  Flag for <em>Segments</em> of type <em>Point list</em> indicating that a
+ *  change of any point or the start or end angle of the <em>Segment</em> can
+ *  lead to a dramatic change in its total length and thus also to a change in
+ *  all objects defined on the associated <em>Reference line</em>.
+ *  If a valid external parametrization is available, it is checked whether the
+ *  s position of the last point of the <em>Segment</em> corresponds to the
+ *  internally calculated spline length. The flag is set if the difference is
+ *  more than 1m.
+ */
+#define ROAD_PL_LEN_DIFF_DETECTED      (1<<3)
+
+/** Function to add a new <em>Segment</em> to a <em>Link</em> or a
+ *  <em>Junction's</em> <em>Reference line</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the <em>Link</em> or <em>Reference line</em>
+ *  the <em>Segment</em> should be added to
+ * \param[in] seg Pointer to a struct containing the data of the new
+ *  <em>Segment</em>
+ * \param[in] segObjId Object id of the <em>Segment</em> successive to the new
+ *  <em>Segment</em>\n
+ *  special value: \ref ROAD_InvalidObjId &harr; The <em>Segment</em> is added
+ *  to the end of the last <em>Segment</em>.
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the new <em>Segment</em>\n
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadGetSegment() \see RoadSetSegment() \see RoadDeleteSegment()
+ */
+tObjId RoadAddSegment   (tRoad *road, tObjId objId,    tRoadSegment *seg,
+                                                               tObjId segObjId);
+/** Function to get a <em>Segment</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] segObjId Object id of the <em>Segment</em>
+ * \param[out] seg Pointer to a struct for the data of the <em>Segment</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddSegment() \see RoadSetSegment() \see RoadDeleteSegment()
+ */
+int    RoadGetSegment   (tRoad *road, tObjId segObjId, tRoadSegment *seg);
+/** Function to set a <em>Segment</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] segObjId Object id of the <em>Segment</em>
+ * \param[in] seg Pointer to a struct containing the data for the
+ *  <em>Segment</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddSegment() \see RoadGetSegment() \see RoadDeleteSegment()
+ */
+int    RoadSetSegment   (tRoad *road, tObjId segObjId, tRoadSegment *seg);
+/** Function to delete a <em>Segment</em>\n
+ *  \note All objects attached to the <em>Segment</em> are deleted as well.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] segObjId Object id of the <em>Segment</em> that should be deleted
+ * \see RoadAddSegment() \see RoadGetSegment() \see RoadSetSegment()
+ */
+void   RoadDeleteSegment(tRoad *road, tObjId segObjId);
+
+/** Function to get the length of a <em>Segment</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] segObjId Object id of the <em>Segment</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> length of the <em>Segment</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+double RoadGetSegmentLength(tRoad *road, tObjId segObjId);
+
+/** Function to get the <em>Segment</em> preceding a given <em>Segment</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] segObjId Object id of the <em>Segment</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the previous <em>Segment</em>
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadGetSuccessiveSegment()
+ */
+tObjId RoadGetPreviousSegment    (tRoad *road, tObjId segObjId);
+/** Function to get the <em>Segment</em> succeeding a given <em>Segment</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] segObjId Object id of the <em>Segment</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the successive <em>Segment</em>\n
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadGetPreviousSegment()
+ */
+tObjId RoadGetSuccessiveSegment  (tRoad *road, tObjId segObjId);
+/** Function to get the first <em>Segment</em> of a given <em>Reference
+ *  line</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] rlObjId Object id of the <em>Reference line</em>
+ * \return In case of success: object id of the first <em>Segment</em>\n
+ * \return In case of failure: error code #ROAD_InvalidObjId
+ * \see RoadGetPreviousSegment() \see RoadGetSuccessiveSegment()
+ */
+tObjId RoadRefLineGetFirstSegment(tRoad *road, tObjId rlObjId);
+
+/** Function to convert a given <em>Segment</em> of type <em>\ref RST_File
+ *  "File"</em> to a <em>\ref RST_PointList "Point list"</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] segObjId Object id of the <em>Segment</em> that should be
+ *  converted
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadConvertFileSegment            (tRoad *road, tObjId segObjId);
+/** Function to convert all <em>Segments</em> of type <em>\ref RST_File "File"
+ *  </em> of a road instance to <em>\ref RST_PointList "Point lists"</em>
+ * \param[in,out] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadConvertAllSegFile2SegPointList(tRoad *road);
+
+/** Function to get the offset of a given <em>Segment's</em> starting point
+ *  on the <em>Reference line</em> 
+ * \param[in] road Handle of the road instance
+ * \param[in] segObjId Object id of the <em>Segment</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> offset of the starting point of the <em>Segment</em> on the
+ *  <em>Reference line</em> in meters
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+double RoadGetSegmentSOnRef(tRoad *road, tObjId segObjId);
+
+/** Function to convert a <em>Segment</em> into a cubic parametric spline in the
+ *  (x,y)-plane
+ * \param[in] road Handle of the road instance
+ * \param[in] segObjId Object id of the <em>Segment</em>
+ * \param[out] sp Cubic parametric spline
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table> 
+ *  \see Spline2DNew() \see Spline2DDelete()
+ */
+int    RoadSegment2Spline2D(tRoad *road, tObjId segObjId, tSpline2D **sp);
+
+/**  Function to get the flags defined for a given <em>Segment</em>
+* \param[in] road Handle of the road instance
+* \param[in] segObjId Object id of the <em>Segment</em>
+* \param[out] flags Flags of the given <em>Segment</em>:\n
+*  The binary system is used to generate combinations of the parametrization
+*  options #ROAD_PL_INIT, #ROAD_PL_S_AVAILABLE, #ROAD_PL_EXTERN_S_AVAILABLE and
+*  #ROAD_PL_LEN_DIFF_DETECTED.
+* \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+*  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+*  <tr><td> In case of failure:
+*  <td> see \ref ErrorCodes "error codes" for the road.
+*  </table>
+*/
+int RoadSegmentGetFlags(tRoad *road, tObjId segObjId, int *flags);
+
+
+/** @} */
+/******************************************************************************/
+/* --- Additional objects --------------------------------------------------- */
+/******************************************************************************/
+
+
+/******************************************************************************/
+/*     Bumps                                                                  */
+/******************************************************************************/
+
+/** \addtogroup BumpsEdit
+ * @{
+ */
+//! Bump of type Friction
+/** Struct for the parameters of a <em>Bump</em> of type <em>Friction</em>
+ */
+typedef struct tRoadBumpFric {
+    double s0;		/**< Start offset in meters
+			 */
+    double s1;		/**< End offset in meters
+			 */
+    double t;		/**< Lateral offset in meters without \ref angle
+                         * "rotation"
+			 */
+    int    lonR0;	/**< Integer value for the \ref tRoadLonRef
+			 * "longitudinal reference" of \ref tRoadBumpFric::s0
+                         * "s0"
+			 */
+    int    lonR1;	/**< Integer value for the \ref tRoadLonRef
+			 * "longitudinal reference" of \ref tRoadBumpFric::s1
+                         * "s1"
+			 */
+    int    latR;	/**< Integer value for the \ref tRoadLatRef
+			 * "lateral reference" of \ref tRoadBumpFric::t "t"
+			 */
+    double angle;	/**< Rotation of the local (u,v)-coordinate system of
+                         * the <em>Bump</em> relative to the (s,t)-coordinate
+                         * system: angle between s- and u-axis in degrees
+			 * - < 0 &harr; clockwise rotation
+                         * - > 0 &harr; couterclockwise rotation
+                         *
+                         * \note In case there is a rotation, the distance
+                         *  between \ref tRoadBumpFric::s0 "s0" and
+                         *  \ref tRoadBumpFric::s1 "s1" describes the length of
+                         *  the rotated friction patch.
+			 */
+    double fric;	/**< Friction coefficient of the patch ( > 0):\n
+			 * Special value: 0 <-> default: friction
+			 * coefficient of the parent object
+			 */
+    double width;	/**< Width of the friction patch in meters
+			 */
+    double texX;	/**< Scaling factor for the texture in x-direction
+                         * \deprecated Use RoadObjectGetMaterial()/
+                         * RoadObjectSetMaterial() for the definition of the
+                         * material of the friction patch.
+			 */
+    double texY;	/**< Scaling factor for the texture in y-direction
+                         * \deprecated Use RoadObjectGetMaterial()/
+                         * RoadObjectSetMaterial() for the definition of the
+                         * material of the friction patch.
+			 */
+    char   *material;	/**< \deprecated Set this parameter to NULL.\n
+                         * Use RoadObjectGetMaterial() / RoadObjectSetMaterial()
+                         * for the definition of the material of the friction
+                         * patch.
+			 */
+    char   *options;	/**< Additional string: not evaluated by the road
+			 */
+    int	   isRegular;	/**< Alignment of the friction patch:
+                         * - 0 &harr; following the <em>Reference line</em>
+			 * - 1 &harr; rectangular
+			 */
+} tRoadBumpFric;
+
+//! Bump of type Beam
+/** Struct for the parameters of a <em>Bump</em> of type <em>Beam</em>
+ */
+typedef struct tRoadBumpBeam {
+    double s;		/**< Offset of the start in meters
+			 */
+    double t;		/**< Lateral offset of the center of the start in meters
+			 */
+    int    lonR;	/**< Integer value for the \ref tRoadLonRef
+			 * "longitudinal reference" of \ref tRoadBumpBeam::s "s"
+			 */
+    int    latR;	/**< Integer value for the \ref tRoadLatRef
+			 * "lateral reference" of \ref tRoadBumpBeam::t "t"
+			 */
+    double angle;	/**< Rotation of the local (u,v)-coordinate system of
+                         * the <em>Bump</em> relative to the (s,t)-coordinate
+                         * system: angle between s- and u-axis in degrees
+			 * - < 0 &harr; clockwise rotation
+                         * - > 0 &harr; couterclockwise rotation
+			 */
+    double height;	/**< Height of the beam in meters
+			 */
+    double width;	/**< Width of the beam in v-direction in meters
+			 */
+    double lUp;		/**< Ramp up length in u-direction in meters
+			 */
+    double lFlat;	/**< Plateau length in u-direction in meters
+			 */
+    double lDown;	/**< Ramp down length in u-direction in meters
+			 */
+    double fric;	/**< Friction coefficient of the obstacle ( > 0):\n
+			 * Special value: 0 <-> default: friction
+			 * coefficient of the parent object
+			 */
+    double texX;	/**< Scaling factor for the texture in x-direction
+                         * \deprecated Use RoadObjectGetMaterial()/
+                         * RoadObjectSetMaterial() for the definition of the
+                         * material of the beam.
+			 */
+    double texY;	/**< Scaling factor for the texture in y-direction
+                         * \deprecated Use RoadObjectGetMaterial()/
+                         * RoadObjectSetMaterial() for the definition of the
+                         * material of the beam.
+			 */
+    char   *material;	/**< \deprecated Set this parameter to NULL.\n
+                         * Use RoadObjectGetMaterial() / RoadObjectSetMaterial()
+                         * for the definition of the material of the beam.
+			 */
+    char   *options;	/**< Additional string: not evaluated by the road
+			 */
+    int	   isRegular;	/**< Alignment of the beam:
+                         * - 0 &harr; following the <em>Reference line</em>
+			 * - 1 &harr; rectangular
+			 */
+} tRoadBumpBeam;
+
+//! Bump of type Wave
+/** Struct for the parameters of a <em>Bump</em> of type <em>Wave</em>
+ */
+typedef struct tRoadBumpWave {
+    double s0;		/**< Start offset in meters
+			 */
+    double s1;		/**< End offset in meters
+			 */
+    double t;		/**< Lateral offset in meters without
+                         * \ref tRoadBumpWave::angle "rotation"
+			 */
+    int    lonR0;	/**< Integer value for the \ref tRoadLonRef
+			 * "longitudinal reference" of \ref tRoadBumpWave::s0
+                         * "s0"
+			 */
+    int    lonR1;	/**< Integer value for the \ref tRoadLonRef
+			 * "longitudinal reference" of \ref tRoadBumpWave::s1
+                         * "s1"
+			 */
+    int    latR;	/**< Integer value for the \ref tRoadLatRef
+			 * "lateral reference" of \ref tRoadBumpWave::t "t"
+			 */
+    double angle;	/**< Rotation of the local (u,v)-coordinate system of
+                         * the <em>Bump</em> relative to the (s,t)-coordinate
+                         * system: angle between s- and u-axis in degrees
+			 * - < 0 &harr; clockwise rotation
+                         * - > 0 &harr; couterclockwise rotation
+                         *
+                         * \note In case there is a rotation, the distance
+                         *  between \ref tRoadBumpWave::s0 "s0" and
+                         *  \ref tRoadBumpWave::s1 "s1" describes the length of
+                         *  the rotated wave.
+			 */
+    double height;	/**< Height of the wave in meters
+			 */
+    double width;	/**< Width of the wave in meters
+			 */
+    double waveLen;	/**< Period length of the wave in meters
+			 */
+    double fric;	/**< Friction coefficient of the wave (\> 0):\n
+			 * Special value: 0 <-> default: friction
+			 * coefficient of the parent object
+			 */
+    double rampOnU;	/**< Transition length front in meters
+			 */
+    double rampOffU;	/**< Transition length back in meters
+			 */
+    double rampOnV;	/**< Transition length right in meters
+			 */
+    double rampOffV;	/**< Transition length left in meters
+			 */
+    char   *options;	/**< Additional string: not evaluated by the road
+			 */
+} tRoadBumpWave;
+
+//! Bump of type Cone
+/** Struct for the parameters of a <em>Bump</em> of type <em>Cone</em>
+ */
+typedef struct tRoadBumpCone {
+    double s;		/**< Offset of the start in meters
+			 */
+    double t;		/**< Lateral offset of the center of the start in meters
+			 */
+    int    lonR;	/**< Integer value for the \ref tRoadLonRef
+			 * "longitudinal reference" of \ref tRoadBumpCone::s "s"
+			 */
+    int    latR;	/**< Integer value for the \ref tRoadLatRef
+			 * "lateral reference" of \ref tRoadBumpCone::t "t"
+			 */
+    double angle;	/**< Rotation of the local (u,v)-coordinate system of
+                         * the <em>Bump</em> relative to the (s,t)-coordinate
+                         * system: angle between s- and u-axis in degrees
+			 * - < 0 &harr; clockwise rotation
+                         * - > 0 &harr; couterclockwise rotation
+			 */
+    double height;	/**< Height of the cone in meters
+			 */
+    double radiusU[2];	/**< Bottom/top radius in longitudinal direction of the
+			 * local coordinate system of the <em>Bump</em>
+			 */
+    double radiusV[2];	/**< Bottom/top radius in lateral direction of the
+			 * local coordinate system of the <em>Bump</em>
+			 */
+    double fric;	/**< Friction coefficient of the obstacle (\> 0):\n
+			 * Special value: 0 <-> default: friction
+			 * coefficient of the parent object
+			 */
+    double texX;	/**< Scaling factor for the texture in x-direction
+                         * \deprecated Use RoadObjectGetMaterial()/
+                         * RoadObjectSetMaterial() for the definition of the
+                         * material of the cone.
+			 */
+    double texY;	/**< Scaling factor for the texture in y-direction
+                         * \deprecated Use RoadObjectGetMaterial()/
+                         * RoadObjectSetMaterial() for the definition of the
+                         * material of the cone.
+			 */
+    char   *material;	/**< \deprecated Set this parameter to NULL.\n
+                         * Use RoadObjectGetMaterial() / RoadObjectSetMaterial()
+                         * for the definition of the material of the cone.
+			 */
+    char   *options;	/**< Additional string: not evaluated by the road
+			 */
+    int    isRegular;	/**< Alignment of the cone:
+                         * - 0 &harr; following the <em>Reference line</em>
+			 * - 1 &harr; rectangular
+			 */
+} tRoadBumpCone;
+
+//! Bump of type Mesh
+/** Struct for the parameters of a <em>Bump</em> of type <em>Mesh</em>
+ */
+typedef struct tRoadBumpMesh {
+    double 	    s;      /**< Offset of the start in meters
+                             */
+    double 	    t;      /**< Lateral offset of the center of the start
+                             * in meters
+                             */
+    int    	    lonR;   /**< Integer value for the \ref tRoadLonRef
+                             * "longitudinal reference" of \ref tRoadBumpMesh::s
+                             * "s"
+                             */
+    int    	    latR;   /**< Integer value for the \ref tRoadLatRef
+                             * "lateral reference" of \ref tRoadBumpMesh::t "t"
+                             */
+    double 	    angle;  /**< Rotation of the local (u,v)-coordinate system
+                             * of the <em>Bump</em> relative to the
+                             * (s,t)-coordinate system: angle between s- and
+                             * u-axis in degrees
+                             * - < 0 &harr; clockwise rotation
+                             * - > 0 &harr; couterclockwise rotation
+                             */
+/* --- Explicit mesh definition: set to zero if file is given ----- */
+/**
+ * \name Explicit mesh definition:
+ * The following parameters are only used in case the mesh is given explicitly
+ * and are set to zero if it is read from an external file, e.g. crg.
+ * @{
+ */
+    int    nU;              /**< <em> Explicit mesh definition:</em>\n
+                             * Number of nodes in u-direction
+                             * \note Set this this parameter to zero if a file
+                             *  is given.
+                             */
+    int    nV;              /**< <em> Explicit mesh definition:</em>\n
+                             * Number of nodes in v-direction
+                             * \note Set this this parameter to zero if a file
+                             *  is given.
+                             */
+
+    double *du;             /**< <em> Explicit mesh definition:</em>\n
+                             * Array with the distances between the nodes in
+                             * u-direction: du[\ref tRoadBumpMesh::nU "nU"]
+                             * \note Set this this parameter to zero if a file
+                             *  is given.
+                             */
+    double *dv;             /**< <em> Explicit mesh definition: </em>\n
+                             * Array with the distances between the nodes in
+                             * v-direction: dv[\ref tRoadBumpMesh::nV "nV"]
+                             * \note Set this this parameter to zero if a file
+                             *  is given.
+                             */
+    double **z;             /**< <em> Explicit mesh definition: </em>\n
+                             * Array with the z-offsets of the nodes relative to
+                             * the road: z[\ref tRoadBumpMesh::nU "nU"][\ref
+                             *  tRoadBumpMesh::nV "nV"]
+                             * \note Set this this parameter to zero if a file
+                             *  is given.
+                             */
+/** @} */
+/* --- Read mesh definition from external file, e.g. crg ----------- */
+/**
+ * \name Read mesh definition from external file:
+ * The following parameters are only used in case the mesh is read from an
+ * external file, e.g. crg and are set to zero otherwise.
+ * @{
+ */
+    char   *fname;		/**< <em> Mesh definition from an external file:
+                                 * </em>\n Name of the external file containing
+                                 * the definition of the <em>Bump</em>
+                                 * \note Set this parameter to "" if no file is
+                                 *  given.
+				 */
+    double fRampU[2];		/**< <em> Mesh definition from an external file:
+				 * </em>\n Transition ramp before/after the
+				 * mesh in meters
+                                 * \note Set this this parameter to zero if no
+                                 *  file is given.
+				 */
+    double fRampV[2];		/**< <em> Mesh definition from an external file:
+				 * </em>\n Transition ramp left/right of the
+				 * mesh in meters
+                                 * \note Set this this parameter to zero if no
+                                 *  file is given.
+				 */
+    int    fUseMesh;		/**< <em> Mesh definition from an external file:
+				 * </em>\n Flag indicating whether a mesh, e.g
+                                 * crg files, should be used if available.
+                                 * - 0 &harr; The mesh is not used.
+				 * - 1 &harr; The mesh is used.
+                                 *
+				 * \note Set this this parameter to zero if no
+                                 *  file is given.
+				 */
+    int    fUseZProfile[3];	/**< <em> Mesh definition from an external file:
+				 * </em>\n Flag indicating whether
+                                 * <em>Elevation</em>, <em>Slope</em> and
+                                 * <em>Camber profiles</em> should be used if
+                                 * available.
+                                 * - 0 &harr; The height profiles are not used.
+				 * - 1 &harr; The height profiles are used.
+                                 *
+				 * \note Set this this parameter to zero if no
+                                 *  file is given.
+				 */
+/** @} */
+/* ---------------------------------------------------------------- */
+    double          zScale;	/**< Grid scale factor in z-direction
+				 */
+    double          uScale;	/**< Grid scale factor in u-direction
+				 */
+    double          vScale;	/**< Grid scale factor in v-direction
+				 */
+    tRoadTransitionType tType;	/**<  Transition type: Mode of interpolation for
+				 * the mesh
+                                 * \note Only \ref RTT_Linear "linear" or \ref
+                                 *  RTT_Cubic "cubic interpolation" are allowed.
+				 */
+    double          fric;	/**< Friction coefficient of the obstacle (\>
+				 * 0):\n
+				 * Special value: 0 <-> default: friction
+				 * coefficient of the parent object
+				 */
+    double          texX;	/**< Scaling factor for the texture in
+				 * x-direction
+                                 * \deprecated Use RoadObjectGetMaterial()/
+                                 * RoadObjectSetMaterial() for the definition of
+                                 * the material of the mesh.
+				 */
+    double          texY;	/**< Scaling factor for the texture in
+				 * y-direction
+                                 * \deprecated Use RoadObjectGetMaterial()/
+                                 * RoadObjectSetMaterial() for the definition of
+                                 * the material of the mesh.
+				 */
+    char            *material;	/**< \deprecated Set this parameter to NULL.\n
+                                 * Use RoadObjectGetMaterial() /
+				 * RoadObjectSetMaterial() for the definition of
+				 * the material of the mesh.
+				 */
+    char            *options;	/**< Additional string: not evaluated by the
+                                 * road
+				 */
+    int             isRegular;	/**< Alignment of the mesh:
+				 * - 0 &harr; following the <em>Reference
+                                 * line</em>
+                                 * - 1 &harr; rectangular
+				 */
+} tRoadBumpMesh;
+
+//! Bump of type Lateral profile
+/** Struct for the parameters of a <em>Bump</em> of type
+ *   <em>Lateral profile</em>
+ */
+typedef struct tRoadBumpLatProfile {
+    double 	    s0;		/**< Start offset in meters
+				 */
+    double 	    s1;		/**< End offset in meters
+				 */
+    double 	    t;		/**< Lateral offset in meters
+                                 * \note The lateral offset can only be chosen
+                                 * if the lateral profile is defined on a
+                                 * <em>Junction</em>.
+				 */
+    int 	    lonR0;	/**< Integer value for the \ref tRoadLonRef
+				 * "longitudinal reference" of
+                                 * \ref tRoadBumpLatProfile::s0 "s0"
+				 */
+    int 	    lonR1;	/**< Integer value for the \ref tRoadLonRef
+				 * "longitudinal reference" of
+                                 * \ref tRoadBumpLatProfile::s1 "s1"
+				 */
+    int 	    latR;	/**< Integer value for the \ref tRoadLatRef
+				 * "lateral reference" of
+                                 * \ref tRoadBumpLatProfile::t "t"
+				 */
+    int 	    mirror;	/**< Mirroring the profile along the s-axis:
+                                 * - 0 &harr; The profile is not mirrored along
+                                 * the s-axis.
+                                 * - 1 &harr; The profile is mirrored along the
+                                 * s-axis.
+				 */
+    tRoadTransitionType type;	/**< Transition type: Mode of interpolation used
+				 * for the profile
+				 */
+    int 	    n;		/**< Number of nodes in t-direction
+				 */
+    double 	    *dz;	/**< Array with the z-offsets of the nodes
+				 * relative to the road: dz[\ref
+                                 * tRoadBumpLatProfile::n "n"]
+				 */
+    double 	    *dt;	/**< Array with the distances between the nodes
+				 * in t-direction: dt[\ref
+                                 * tRoadBumpLatProfile::n "n"]
+                                 * \note The first coordinate is the road
+                                 *  border. Negative entries are not allowed.
+				 */
+    double 	    rampOnS;	/**< Start transition length in meters
+				 */
+    double 	    rampOffS;	/**< End transition length in meters
+				 */
+    tRoadTransitionType rampOnType;	/**< Start transition type:
+				 * Mode of interpolation for the start
+				 */
+    tRoadTransitionType rampOffType;/**< End transition type:
+				 * Mode of interpolation for the end
+				 */
+    double 	    fric;	/**< Friction coefficient of the object (\> 0):
+				 * \n Special value: 0 <-> default: friction
+				 * coefficient of the parent object
+				 */
+    double 	    sTex;	/**< Scaling factor for the texture in
+                                 * s-direction
+                                 * \deprecated Use RoadObjectGetMaterial()/
+                                 * RoadObjectSetMaterial() for the definition of
+                                 * the material of the lateral profile.
+				 */
+    char 	    *material;	/**< \deprecated Set this parameter to NULL.\n
+				 * Use RoadObjectGetMaterial() /
+				 * RoadObjectSetMaterial() for the definition of
+				 * the material of the lateral profile.
+				 */
+    char 	    *options;	/**< Additional string: not evaluated by the
+                                 * road
+				 */
+} tRoadBumpLatProfile;
+
+/** Type of raised profile gutters
+ */
+typedef enum tRoadRPGutterType {
+    RGT_Slope = 0,     /**< <b>0</b> &nbsp; Gutter with constant slope
+                        */
+    RGT_U,             /**< <b>1</b> &nbsp; Gutter with round deepening
+                        */
+    RGT_V              /**< <b>2</b> &nbsp; Gutter with straight lined deepening
+                        */
+} tRoadRPGutterType;
+
+/** Types of raised profile curbs
+ */
+typedef enum tRoadRPCurbType {
+    RCT_R5 = 0,        /**< <b>0</b> &nbsp; Curb with constant radius of 5cm
+                        */
+    RCT_R2,            /**< <b>1</b> &nbsp; Curb with constant radius of 2cm
+                        */
+    RCT_F5x5,          /**< <b>2</b> &nbsp; Curb with 5cmx5cm bevel
+                        */
+    RCT_F10x7,         /**< <b>3</b> &nbsp; Curb with 10cmx7cm bevel
+                        */
+    RCT_F10x10,        /**< <b>4</b> &nbsp; Curb with 10cmx10cm bevel
+                        */
+    RCT_Flat,          /**< <b>5</b> &nbsp; Curb which slopes to end of gutter
+                        */
+} tRoadRPCurbType;
+
+//! Bump of type Raised profile
+/** Struct for the parameters of a <em>Bump</em> of type
+ *   <em>Raised profile</em>
+ */
+typedef struct tRoadBumpRaisedProfile {
+    double 	    s0;		/**< Start offset in meters
+				 */
+    double 	    s1;		/**< End offset in meters
+                                 * \note Only used for <em>Raised profiles</em>
+                                 * with \ref tRoadBumpRaisedProfile::lKind
+                                 * "line kind" #RLK_Offset.
+				 */
+    double 	    t;		/**< Lateral offset in meters
+                                 * \note Only used for <em>Raised profiles</em>
+                                 * with \ref tRoadBumpRaisedProfile::lKind
+                                 * "line kind" #RLK_Polyline or #RLK_Spline.
+				 */
+    int 	    lonR0;	/**< Integer value for the \ref tRoadLonRef
+				 * "longitudinal reference" of
+                                 * \ref tRoadBumpRaisedProfile::s0 "s0"
+				 */
+    int 	    lonR1;	/**< Integer value for the \ref tRoadLonRef
+				 * "longitudinal reference" of
+                                 * \ref tRoadBumpRaisedProfile::s1 "s1"
+                                 * \note Only used for <em>Raised profiles</em>
+                                 * with \ref tRoadBumpRaisedProfile::lKind
+                                 * "line kind" #RLK_Offset.
+                                 */
+    int 	    latR;	/**< Integer value for the \ref tRoadLatRef
+				 * "lateral reference" of
+                                 * \ref tRoadBumpRaisedProfile::t "t"
+                                 * \note Only used for <em>Raised profiles</em>
+                                 * with \ref tRoadBumpRaisedProfile::lKind
+                                 * "line kind" #RLK_Polyline or #RLK_Spline.
+				 */
+    int 	    mirror;	/**< Mirroring the profile along the s-axis:
+                                 * - 0 &harr; The profile is not mirrored along
+                                 * the s-axis.
+                                 * - 1 &harr; The profile is mirrored along the
+                                 * s-axis.
+				 */
+    int           withBorderExt; /**< Adding a surface with constant height next
+                                 * to the border of the <em>Raised profile</em>
+                                 * - 0 &harr; No extension of the profile
+                                 * adjacent to its sidewalk surface.
+                                 * - 1 &harr; Extension of the profile adjacent
+                                 * to the sidewalk surface.
+                                 *
+                                 * \note Only possible for a <em>Raised
+                                 * profile</em> with \ref
+                                 * tRoadBumpRaisedProfile::lKind "line kind"
+                                 * #RLK_Polyline or #RLK_Spline if
+                                 * its border forms a valid polygon and
+                                 * otherwise internally set to zero.
+                                 */
+    double 	  zBorderExt;	 /**< Height of the border extension relative to
+                                 * the height of the <em>Link</em> or
+                                 * <em>Junction</em> it is placed on at the
+                                 * start of the profile.
+                                 * \note Only relevant if the
+                                 * \ref tRoadBumpRaisedProfile::withBorderExt
+                                 * "border extension" is used, otherwise ignored.
+                                 */
+    tRoadRPGutterType gutterType; /**< Type of the gutter part
+				 */
+    tRoadRPCurbType curbType;   /**< Type of the curb part
+				 */
+    double wGutter;             /**< Gutter width (constant on the whole
+                                 * <em>Raised profile</em>)
+				 */
+    double wCurb;               /**< Curb width (constant on the whole
+                                 * <em>Raised profile</em>)
+				 */
+    char *options;              /**< Additional string: not evaluated by the
+                                 * road
+                                 */
+    int n;                      /**< Number of points in the
+				 * \ref tRoadBumpRaisedProfile::p "point list"
+    				 */
+    tRoadLineKind lKind;         /**< Kind of line used for the
+                                 * \ref tRoadBumpRaisedProfile::p "point list"
+				 */
+    double (*p)[2];              /**< Point list with (s,t)-coordinates in
+                                 * direction of the <em>Reference line</em>
+				 * relative to the insertion point
+				 */
+} tRoadBumpRaisedProfile;
+
+/** Function to add a new <em>Bump</em> to a <em>Reference line</em>,
+ *  <em>Link</em>, <em>Segment</em>, <em>Lane section</em>, <em>Lane</em>,
+ *  <em>Lane path</em>, <em>User path</em> or <em>Connector path</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the reference object for the parameters of the
+ *  new <em>Bump</em>
+ * \param[in] type \ref ROT_BBeam "Type" of the new <em>Bump</em>
+ * \param[in] bump Pointer to an appropriate tRoadBump struct containing the
+ *  data of the new <em>Bump</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the new <em>Bump</em>\n
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadGetBump() \see RoadSetBump() \see RoadDeleteBump()
+ */
+tObjId RoadAddBump   (tRoad *road, tObjId objId,
+		            tRoadObjectType type, void *bump);
+/**  Function to get a <em>Bump</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] bObjId Object id of the <em>Bump</em>
+ * \param[out] bump Pointer to an appropriate tRoadBump struct for the data of
+ *  the <em>Bump</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddBump() \see RoadSetBump() \see RoadDeleteBump()
+ */
+int    RoadGetBump   (tRoad *road, tObjId bObjId, void *bump);
+/** Function to set a <em>Bump</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] bObjId Object id of the <em>Bump</em>
+ * \param[in] bump Pointer to an appropriate tRoadBump struct containing the
+ *  data for the <em>Bump</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddBump() \see RoadGetBump() \see RoadDeleteBump()
+ */
+int    RoadSetBump   (tRoad *road, tObjId bObjId, void *bump);
+/** Function to delete a <em>Bump</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] bObjId Object id of the <em>Bump</em> that should be deleted
+ * \see RoadAddBump() \see RoadGetBump() \see RoadSetBump()
+ */
+void   RoadDeleteBump(tRoad *road, tObjId bObjId);
+/** Function to switch on/off the high resolution visualization of a
+ *  <em>Bump</em> of type <em>\ref ROT_BMesh "Mesh"</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] bObjId Object id of the <em>Bump</em>
+ * \param[in] enable Flag indicating whether the <em>Bump</em> visualization in
+ *  IPGMovie should be in high resolution:
+ *  - 0 &harr; no high resolution visualization
+ *  - 1 &harr; high resolution visualization
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetBumpHRV()
+ */
+int    RoadSetBumpHRV(tRoad *road, tObjId bObjId, int enable);
+/** Function to get the high resolution visualization state of a <em>Bump</em>
+ *  of type <em>\ref ROT_BMesh "Mesh"</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] bObjId Object id of the <em>Bump</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> flag indicating whether the <em>Bump</em> visualization in IPGMovie
+ *  should be in high resolution:
+ *  <tr><td><td>
+ *  - 0 &harr; no high resolution visualization
+ *  - 1 &harr; high resolution visualization
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadSetBumpHRV()
+ */
+int    RoadGetBumpHRV(tRoad *road, tObjId bObjId);
+/** Function to get the length of a <em>Bump</em> of type <em>\ref ROT_BRaisedP
+ *  "Raised profile"</em>\n
+ *  All height and width nodes of the <em>Raised profile</em> have to be defined
+ *  at an offset smaller than or equal to this length.
+ * \param[in] road Handle of the road instance
+ * \param[in] bObjId Object id of the <em>Bump</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> length of the <em>Raised profile</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+double RoadGetBumpLength(tRoad *road, tObjId bObjId);
+/** Function to get the object ids of the one-dimensional node profiles of a
+ *  <em>Bump</em> of type <em>\ref ROT_BRaisedP "Raised profile"</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] bObjId Object id of the <em>Bump</em>
+ * \param[in] option Flag indicating which of the profiles is considered:
+ *    - 0 &harr; width profile
+ *    - 1 &harr; inner height profile
+ *    - 2 &harr; outer height profile
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the one-dimensional node profile
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ *  \see RoadAddNode1DProfile() \see RoadGetNode1DProfile()
+ */
+tObjId RoadGetBumpNode1DProfile(tRoad *road, tObjId bObjId, int option);
+
+
+/** @} */
+/******************************************************************************/
+/*     Markers                                                                */
+/******************************************************************************/
+
+
+/** \addtogroup MarkersEdit
+ * @{
+ */
+/** Direction validity:\n
+ *  Options for the direction validity of <em>Markers</em>
+ */
+typedef enum tRoadDirValidity {
+    
+    RDV_Con    = -1,	/**< <b>-1</b> &nbsp; Counter link direction
+			 */
+    RDV_Both   =  0,	/**< <b>0</b> &nbsp; In both directions
+			 */
+    RDV_Pro    =  1	/**< <b>1</b> &nbsp; In link direction
+			 */
+} tRoadDirValidity;
+
+//! Marker of type Driver speed
+/** Struct for the parameters of a <em>Marker</em> of type <em>Driver
+ *  speed</em>
+ */
+typedef struct tRoadMarkerDrvSpeed {    
+    double s0;		/**< Start offset in meters
+			 */
+    double s1;		/**< \deprecated Internal use only.
+			 */
+    double t;		/**< \deprecated Internal use only.
+			 */
+    int    lonR0;	/**< Integer value for the \ref tRoadLonRef 
+			 * "longitudinal reference" of
+                         *  \ref tRoadMarkerDrvSpeed::s0 "s0"
+			 */
+    int    lonR1;	/**< \deprecated Internal use only.
+			 */
+    int    latR;	/**< \deprecated Internal use only.
+			 */
+    int    dirValidity;	/**< \ref tRoadDirValidity "Direction validity"
+                         * \note This parameter is only considered if the
+                         * <em>Marker</em> is placed on a <em>Link</em>.
+                         */
+    double speed;	/**< Speed limit in m/s
+			 */
+    char   *unit;	/**< Unit for the speed selected by the user: kmh or mph
+			 */
+    char   *options;	/**< Additional string: not evaluated by the road
+			 */
+} tRoadMarkerDrvSpeed;
+
+//! Marker of type Driver stop
+/** Struct for the parameters of a <em>Marker</em> of type <em>Driver stop</em>
+ */
+typedef struct tRoadMarkerDrvStop {    
+    double s;               /**< Start offset in meters
+                             */
+    double t;               /**< \deprecated Internal use only.
+                             */
+    int    lonR;            /**< Integer value for the \ref tRoadLonRef 
+                             * "longitudinal reference" of 
+                             * \ref tRoadMarkerDrvStop::s "s"
+                             */
+    int    latR;            /**< \deprecated Internal use only.
+                             */
+    int    dirValidity;     /**< \ref tRoadDirValidity "Direction validity"
+                             * \note This parameter is only considered if the
+                             * <em>Marker</em> is placed on a <em>Link</em>.
+                             * \warning #RDV_Both must not be used.
+                             */
+    tRoadDrvStopType type;  /**< Type of the <em>Stop marker</em>
+                             */
+    tObjId  refObjId;       /**< Object id of the reference object of the
+                             * <em>Marker</em>
+                             * \note This parameter is only considered for
+                             * <em>Stop markers</em> of type #RDST_TrfLight or
+                             * #RDST_Junction.
+                             */
+    double duration;        /**< Duration of the stop in seconds
+                             */
+    char   *options;        /**< Additional string: not evaluated by the road
+                             */
+} tRoadMarkerDrvStop;
+
+//! Pylon alley
+/** Struct for the parameters of a <em>Marker</em> of type <em>Pylon alley</em>
+ */
+typedef struct tRoadMarkerDrvPylon {    
+    double s;		/**< Start offset in meters
+			 */
+    double t;		/**< Lateral offset in meters
+			 */
+    int    lonR;	/**< Integer value for the \ref tRoadLonRef 
+			 * "longitudinal reference" of
+                         * \ref tRoadMarkerDrvPylon::s "s"
+			 */
+    int    latR;	/**< Integer value for the \ref tRoadLatRef
+			 * "lateral reference" of
+                         * \ref tRoadMarkerDrvPylon::t "t"
+			 */
+    int    dirValidity;	/**< \ref tRoadDirValidity "Direction validity" 
+                         * \note This parameter is only considered if the
+                         * <em>Marker</em> is placed on a <em>Link</em>.
+                         */
+    double width;	/**< Width between the two pylons in meters
+			 */
+    char   *options;	/**< Additional string: not evaluated by the road
+			 */
+} tRoadMarkerDrvPylon;
+
+//! Marker of type Wind
+/** Struct for the parameters of a <em>Marker</em> of type <em>Wind</em>
+ */
+typedef struct tRoadMarkerEnvWind {    
+    double s0;		/**< Start offset in meters
+			 */
+    double s1;		/**< \deprecated Internal use only.
+			 */
+    int    lonR0;	/**< Integer value for the \ref tRoadLonRef 
+			 * "longitudinal reference" of
+                         * \ref tRoadMarkerEnvWind::s0 "s0"
+			 */
+    int    lonR1;	/**< \deprecated Internal use only.
+			 */
+    int    dirValidity;	/**< \ref tRoadDirValidity "Direction validity"
+                         * \note This parameter is only considered if the
+                         * <em>Marker</em> is placed on a <em>Link</em>.
+			 */
+    double speed;	/**< Speed of the wind in m/s
+                         * \note A <em>Wind marker</em> with speed zero can be
+                         * used to cancel the effect of all previous <em>Wind
+                         * markers</em> on a <em>Path</em> or <em>Link</em>.
+			 */
+    double angle;	/**< Direction of the wind in degrees
+			 */
+    char   *unit;	/**< Unit of the wind speed selected by the user:
+                         * kmh or ms
+			 */
+    char   *options;	/**< Additional string: not evaluated by the road
+			 */
+} tRoadMarkerEnvWind;
+
+//! Marker of type Trigger point
+/** Struct for the parameters of a <em>Marker</em> of type <em>Trigger
+ * point</em>
+ */
+typedef struct tRoadMarkerDrivManTrigger {    
+    double s;		/**< Start offset in meters
+			 */
+    int    lonR;	/**< Integer value for the \ref tRoadLonRef 
+			 * "longitudinal reference" of
+                         * \ref tRoadMarkerDrivManTrigger::s "s"
+			 */
+    int    dirValidity;	/**< \ref tRoadDirValidity "Direction validity"
+                         * \note This parameter is only considered if the
+                         * <em>Marker</em> is placed on a <em>Link</em>.
+			 */
+    int    id;		/**< Positive integer value for the identification of
+			 * the <em>Marker</em>
+                         * \note Should be numbered consecutively.
+			 */
+    int    mode;	/**< Mode of the <em>Trigger point</em>: 
+			 * - 1 &harr; define a new reference point
+			 * - 2 &harr; take all measurements
+			 * - 3 &harr; take all measurements and define a new
+			 * reference point
+			 */
+    char   *options;	/**< Additional string: not evaluated by the road
+			 */
+} tRoadMarkerDrivManTrigger;
+
+//! Marker of type DrivMan command
+/** Struct for the parameters of a <em>Marker</em> of type <em>DrivMan
+ * command</em>
+ */
+typedef struct tRoadMarkerDrivManCmd {    
+    double s;		/**< Start offset in meters
+			 */
+    int    lonR;	/**< Integer value for the \ref tRoadLonRef 
+			 * "longitudinal reference" of
+                         * \ref tRoadMarkerDrivManCmd::s "s"
+			 */
+    int    dirValidity;	/**< \ref tRoadDirValidity "Direction validity"
+                         * \note This parameter is only considered if the
+                         * <em>Marker</em> is placed on a <em>Link</em>.
+			 */
+    char   *cmd;	/**< Minimaneuver command of the <em>Marker</em>
+			 */
+    char   *options;	/**< Additional string: not evaluated by the road
+			 */
+} tRoadMarkerDrivManCmd;
+
+//! Marker of type DrivMan jump
+/** Struct for the parameters of a <em>Marker</em> of type <em>DrivMan
+ *  jump</em>
+ */
+typedef struct tRoadMarkerDrivManJump {    
+    double s;		/**< Start offset in meters
+			 */
+    int    lonR;	/**< Integer value for the \ref tRoadLonRef 
+			 * "longitudinal reference" of
+                         * \ref tRoadMarkerDrivManJump::s "s"
+			 */
+    int    dirValidity;	/**< \ref tRoadDirValidity "Direction validity"
+                         * \note This parameter is only considered if the
+                         * <em>Marker</em> is placed on a <em>Link</em>.
+			 */
+    char   *label;	/**< Target label of the <em>Marker</em>
+			 */
+    char   *options;	/**< Additional string: not evaluated by the road
+			 */
+} tRoadMarkerDrivManJump;
+
+//! Marker of type User-defined
+/** Struct for the parameters of a <em>Marker</em> of type
+ *  <em>User-defined</em>
+ */
+typedef struct tRoadMarkerUser {    
+    double s0;		/**< Start offset in meters
+			 */
+    double s1;		/**< \deprecated Internal use only.
+			 */
+    double t;		/**< \deprecated Internal use only.
+			 */
+    int    lonR0;	/**< Integer value for the \ref tRoadLonRef 
+			 * "longitudinal reference" of
+                         * \ref tRoadMarkerUser::s0 "s0"
+			 */
+    int    lonR1;	/**< \deprecated Internal use only.
+			 */
+    int    latR;	/**< \deprecated Internal use only.
+			 */
+    int    dirValidity;	/**< \ref tRoadDirValidity "Direction validity"
+                         * \note This parameter is only considered if the
+                         * <em>Marker</em> is placed on a <em>Link</em>.
+			 */
+    int    valid;       /**< Flag indicating whether the <em>Marker</em>
+                         * signals the start or the end of the validity zone:
+                         * - 0 &harr; End of the validity zone.
+			 * - 1 &harr; Start of the validity zone.
+                         */
+    char   *name;	/**< Name of the user-defined class of the
+                         *  <em>Marker</em>
+			 */
+    void   *param;	/**< Array of parameters assigned to the <em>Marker</em>
+			 */
+} tRoadMarkerUser;
+
+
+/** Function to add a new <em>Marker</em> to a <em>Reference line</em>,
+ *  <em>Link</em>, <em>Segment</em>, <em>Lane path</em>, <em>User path</em> or
+ *  <em>Connector path</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the reference object for the parameters of the
+ *  new <em>Marker</em>
+ * \param[in] type \ref ROT_MDrvSpeed "Type" of the new <em>Marker</em>
+ * \param[in] marker Pointer to an appropriate tRoadMarker struct containing the
+ *  data of the new <em>Marker</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the new <em>Marker</em>\n
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadGetMarker() \see RoadSetMarker() \see RoadDeleteMarker()
+ */
+tObjId RoadAddMarker   (tRoad *road, tObjId objId,
+			      tRoadObjectType type, void *marker);
+/** Function to get a <em>Marker</em>\n
+ *  \note The user is responsible to free the memory allocated by this function.
+ *   Besides the memory for strings (names, labels, options, etc.), it also
+ *   allocates memory for \ref tRoadMarkerUser::param "param" and the strings
+ *   defined within in case of User-defined <em>Markers</em>.
+ * \param[in] road Handle of the road instance
+ * \param[in] mObjId Object id of the <em>Marker</em>
+ * \param[out] marker Pointer to an appropriate tRoadMarker struct for the
+ *  data of the <em>Marker</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddMarker() \see RoadSetMarker() \see RoadDeleteMarker()
+ */
+int    RoadGetMarker   (tRoad *road, tObjId mObjId, void *marker);
+/** Function to set a <em>Marker</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] mObjId Object id of the <em>Marker</em>
+ * \param[in] marker Pointer to an appropriate tRoadMarker struct containing the
+ *  data for the <em>Marker</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddMarker() \see RoadGetMarker() \see RoadDeleteMarker()
+ */
+int    RoadSetMarker   (tRoad *road, tObjId mObjId, void *marker);
+/** Function to delete a <em>Marker</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] mObjId Object id of the <em>Marker</em> that should be deleted
+ * \see RoadAddMarker() \see RoadGetMarker() \see RoadSetMarker()
+ */
+void   RoadDeleteMarker(tRoad *road, tObjId mObjId); 
+
+
+/** @} */
+/******************************************************************************/
+/*     Accessories and Scenery                                                */
+/******************************************************************************/
+
+
+/** \addtogroup SOEdit
+ * @{
+ */
+
+
+/** Mount part types:\n
+ *  Types of the objects that can be attached to a <em>Mount</em>
+ */
+typedef enum tRoadMountPartType {    
+    RMPT_TrfSign = 0,	/**< <b>0</b> &nbsp; Traffic sign
+			 */
+    RMPT_TrfLight	/**< <b>1</b> &nbsp; Traffic light
+			 */
+} tRoadMountPartType;
+
+/** Mount pole types:\n
+ *  Types of the <em>Mounts</em> of <em>Traffic signs</em> and 
+ *  <em>Traffic lights</em>
+ */
+typedef enum tRoadMountType {    
+    RMNT_None = 0,	/**< <b>0</b> &nbsp; No mount at all
+			 */
+    RMNT_Pole,		/**< <b>1</b> &nbsp; Single pole
+			 */
+    RMNT_DblPole,	/**< <b>2</b> &nbsp; Double pole
+			 */
+    RMNT_Frame,		/**< <b>3</b> &nbsp; Double pole with frame
+			 */
+    RMNT_Road,		/**< <b>4</b> &nbsp; Road surface
+                         * \warning Not yet implemented!
+			 */
+    RMNT_PoleTL,	/**< <b>5</b> &nbsp; Traffic light pole
+			 */
+    RMNT_Gantry,	/**< <b>6</b> &nbsp; Gantry
+			 */
+    RMNT_HalfGantry,	/**< <b>7</b> &nbsp; Half-gantry
+			 */
+    RMNT_GantryTL, 	/**< <b>8</b> &nbsp; Gantry for traffic lights
+			 */
+    RMNT_HalfGantryTL 	/**< <b>9</b> &nbsp; Half gantry for traffic lights
+			 */
+} tRoadMountType;
+//! Mount
+/** Struct for the parameters of a <em>Mount</em>
+ * \see tRoadMountOut \see tRoadTrafficSign \see tRoadTrafficLight
+ */
+typedef struct tRoadMount {    
+    double     s;	/**< Start offset in meters
+			 */
+    double     t;	/**< Lateral offset in meters
+			 */
+    double     length;	/**< Length of the <em>Mount</em>
+                         * \note Only for <em>Mounts</em> of type
+                         * \ref RMNT_Gantry "gantry".
+                         */
+    double     height;	/**< Height of the <em>Mount</em>
+                         */
+    double     rxyz[3]; /**< Euler angles in degrees\n rotation order: Z,Y',X''
+                         * \note Rotation around x- and y-axis is disabled for
+                         * all gantry mount types
+			 */
+    tRoadLonRef    lonR;/**< Integer value for the longitudinal reference of
+                         * \ref tRoadMount::s "s"
+			 */
+    tRoadLatRef    latR;/**< Integer value for the lateral reference of
+                         * \ref tRoadMount::t "t"
+			 */
+    tRoadMountType type;/**< Type of pole
+			 */
+} tRoadMount;
+
+
+//! Single Traffic sign
+/** Struct used to define a single <em>Traffic sign</em> in the struct 
+ *  tRoadTrafficSign
+ */
+typedef struct tRoadTS {    
+    char   *sign;		/**< Key of the type of <em>Traffic sign</em>
+				 */
+    char   *attr;		/**< Attributes communicated to the traffic sign
+				 * sensor
+				 */
+    char   *size;		/**< Size of the <em>Traffic sign</em>:
+				 * - M &harr; medium
+				 * - L &harr; large
+				 */
+    int	   isTwoSided;		/**< Flag indicating whether the sign has a
+				 * texture on both sides:
+				 * - 0 &harr; The sign is one-sided.
+				 * - 1 &harr; The sign is two-sided.
+				 */
+    double val[2];		/**< Values 0 / 1 displayed on <em>Traffic
+				 * signs</em> of appropriate \ref tRoadTS::sign
+                                 * "type"
+				 */
+} tRoadTS;
+//! Traffic sign
+/** Struct for the parameters of a <em>Traffic sign</em>
+ * \see tRoadMount \see tRoadTS \see tRoadTSOut
+ */
+typedef struct tRoadTrafficSign {    
+    tRoadTS main;		/**< Main traffic sign
+				 */
+    tRoadTS suppl[2];		/**< Optional supplementary signs
+                                 * \note Set suppl[i].sign to NULL if a
+                                 *  supplementary sign is not used.
+				 */
+    int	    facing;		/**< Flag indicating the direction validity of
+                                 * the sign:
+                                 * - -1 &harr; counter link direction
+				 * - 1 &harr; in link direction
+				 */
+    tRoadLatRef latR; 		/**< Integer value for the \ref tRoadLatRef
+				 * "lateral reference" of the <em>Traffic
+                                 * sign</em>
+				 * \note Only for <em>Mounts</em> of type \ref
+                                 *  RMNT_Gantry "gantry" or \ref RMNT_Road
+                                 *  "road surface".
+				 */ 
+    double  detectability;	/**< Probability of detection by the <em>Traffic
+				 * Sign Sensor</em> (range: 0..1)
+				 */
+    double  vhd[3];             /**< Translation in vertical, horizontal and
+                                 * depth direction relative to the mounting 
+                                 * point
+                                 * \note The translation is carried out before
+                                 * the rotation.
+                                 */
+    double  rvhd[3];            /**< Rotation around vertical, horizontal 
+                                 * and depth axis \n 
+                                 * rotation order V,H',D''
+                                 * \note The rotation is carried out after
+                                 * the translation.
+                                 */
+    double  w;			/**< Overall width of the <em>Traffic sign</em>
+                                 * including the supplementary signs
+				 */
+    double  h;			/**< Overall height of the <em>Traffic sign</em>
+				 * including the supplementary signs
+				 */
+    char    *options;		/**< String with additional parameters for the
+				 * <em>Traffic sign</em> (not evaluated by the
+				 * road)
+				 */
+} tRoadTrafficSign ;
+
+
+/** Types of <em>Traffic lights</em>
+ */
+typedef enum tRoadTLType {
+    RTLT_200_RYG = 0,		/**< <b>0</b> &nbsp; 
+                                 * Red-yellow-green traffic light
+    				 */
+    RTLT_200_RYG_Straight,	/**< <b>1</b> &nbsp; 
+                                 * Red-yellow-green traffic light straight
+    				 */
+    RTLT_200_RYG_Left,		/**< <b>2</b> &nbsp; 
+                                 * Red-yellow-green traffic light left
+    				 */
+    RTLT_200_RYG_Right,		/**< <b>3</b> &nbsp; 
+                                 * Red-yellow-green traffic light right
+    				 */
+    RTLT_200_RYG_StraightLeft,	/**< <b>4</b> &nbsp; 
+                                 * Red-yellow-green traffic light straight/left
+				 */
+    RTLT_200_RYG_StraightRight,	/**< <b>5</b> &nbsp; 
+                                 * Red-yellow-green traffic light straight/right
+				 */
+    RTLT_100_RYG,		/**< <b>6</b> &nbsp; 
+                                 * Red-yellow-green traffic light (small)
+    				 */
+    RTLT_200_RY,		/**< <b>7</b> &nbsp; 
+                                 * Red-yellow traffic light
+    				 */
+    RTLT_200_YG,		/**< <b>8</b> &nbsp; 
+                                 * Yellow-green traffic light
+    				 */
+    RTLT_200_YG_Left,		/**< <b>9</b> &nbsp; 
+                                 * Yellow-green traffic light left
+    				 */
+    RTLT_200_YG_Right,		/**< <b>10</b> &nbsp; 
+                                 * Yellow-green traffic light right
+    				 */
+    RTLT_300_YG_Left,		/**< <b>11</b> &nbsp; 
+                                 * Yellow-green traffic light left (large)
+    				 */
+    RTLT_300_YG_Right,		/**< <b>12</b> &nbsp; 
+                                 * Yellow-green traffic light right (large)
+    				 */
+    RTLT_300_R,			/**< <b>13</b> &nbsp; 
+                                 * Red traffic light (large)
+    				 */
+    RTLT_Ped_R,			/**< <b>14</b> &nbsp; 
+                                 * Red traffic light (pedestrian)
+    				 */
+    RTLT_Pedestrian,		/**< <b>15</b> &nbsp; 
+                                 * Red-green traffic light (pedestrian)
+    				 */
+    RTLT_Unknown		/**< <b>16</b> &nbsp; 
+                                 * Unknown traffic light type
+    				 */
+} tRoadTLType;
+//! Traffic light
+/** Struct for the parameters of a <em>Traffic light</em>
+ * \see tRoadMount \see tRoadTLOut
+ */
+typedef struct tRoadTrafficLight {
+    tObjId ctrlObjId;               /**< Object id of <em>Traffic light
+                                     * controller</em>
+                                     */
+    tRoadTLType type;               /**< Type of the <em>Traffic light</em>
+                                     */
+    tRoadLatRef latR;               /**< Integer value for the lateral reference
+                                     * of the <em>Traffic light</em>
+                                     * \note Only for <em>Mounts</em> of type
+                                     *  \ref RMNT_Gantry "gantry" or \ref
+                                     *  RMNT_Road "road surface".
+                                     */ 
+    int	    facing;                 /**< Flag indicating the direction validity
+                                     * of the traffic light:
+                                     * - -1 &harr; counter route direction
+				     * - 1 &harr; in route direction
+				     */
+    double  vhd[3];                 /**< Translation in vertical, horizontal and
+                                     * depth direction relative to the mounting 
+                                     * point
+                                     * \note The translation is carried out
+                                     * before the rotation.
+                                     */
+    double  rvhd[3];                 /**< Rotation around vertical, horizontal 
+                                     * and depth axis \n 
+                                     * rotation order V,H',D''
+                                     * \note The rotation is carried out after
+                                     * the translation.
+                                     */
+} tRoadTrafficLight;
+
+
+/** Types of <em>Traffic barriers</em>
+ */
+typedef enum tRoadTBType {
+    RTBT_Unknown = 0,	/**< <b>0</b> &nbsp; Unknown traffic barrier type
+			 */
+    RTBT_GuardRail1,	/**< <b>1</b> &nbsp; Guardrail (single)
+    			 */
+    RTBT_GuardRail2,	/**< <b>2</b> &nbsp; Guardrail (double)
+    			 */
+    RTBT_GuardRail3,	/**< <b>3</b> &nbsp; Guardrail (triple)
+    			 */
+    RTBT_JerseyBarrier1,/**< <b>4</b> &nbsp; Jersey barrier
+    			 */
+    RTBT_JerseyBarrier2,/**< <b>5</b> &nbsp; Jersey barrier (segmented)
+    			 */
+    RTBT_Wall1,		/**< <b>6</b> &nbsp; Wall
+    			 */
+    RTBT_Wall2		/**< <b>7</b> &nbsp; Wall (segmented)
+    			 */
+} tRoadTBType;
+
+/** Types of traffic barrier poles:\n
+ *  Only used for \ref RTBT_GuardRail1 "guardrail barriers".
+ */
+typedef enum tRoadTBPoleType {
+    RTBPT_None = 0,	/**< <b>0</b> &nbsp; No poles at all
+    			 */
+    RTBPT_Square,	/**< <b>1</b> &nbsp; Square poles
+    			 */
+    RTBPT_Sigma,	/**< <b>2</b> &nbsp; Sigma poles
+    			 */
+} tRoadTBPoleType;
+
+/** Types of traffic barrier ends
+ */
+typedef enum tRoadTBEndType {
+    RTBET_None=0,	/**< <b>0</b> &nbsp; No special end
+    			 */
+    RTBET_Ramp,		/**< <b>1</b> &nbsp; Ramp at the end of the traffic  
+                         * barrier \warning Not yet implemented!
+    			 */
+} tRoadTBEndType;
+//! Traffic barrier
+/** Struct for the parameters of a <em>Traffic barrier</em>
+ */
+typedef struct tRoadTrafficBarrier {    
+    double	s0;		/**< Start offset in meters
+				 */
+    double	s1;		/**< End offset in meters
+                                 * \note Only used for <em>Traffic barriers</em>
+                                 * with \ref tRoadTrafficBarrier::lKind
+                                 * "line kind" #RLK_Offset.
+				 */
+    double	t;		/**< Lateral offset in meters
+				 */
+    double	width;		/**< Width of the barrier in meters
+				 */
+    double	height;		/**< Height of the barrier pole in meters
+				 */
+    double	interval;	/**< Interval between two poles in meters
+				 */
+    double	detectability;	/**< Probability of detection by sensors (range:
+				 * 0..1)
+				 */
+    tRoadLonRef	lonR0;		/**< Integer value for the longitudinal
+				 * reference of \ref tRoadTrafficBarrier::s0
+                                 * "s0"
+				 */
+    tRoadLonRef	lonR1;		/**< Integer value for the longitudinal
+				 * reference of \ref tRoadTrafficBarrier::s1
+                                 * "s1"
+                                 * \note Only used for <em>Traffic barriers</em>
+                                 * with \ref tRoadTrafficBarrier::lKind
+                                 * "line kind" #RLK_Offset.
+				 */
+    tRoadLatRef	latR;		/**< Integer value for the lateral reference of
+				 * \ref tRoadTrafficBarrier::t "t"
+				 */
+    tRoadTBType	type;		/**< Type of <em>Traffic barrier</em>
+				 */
+    tRoadTBPoleType pType;	/**< Type of pole
+                                 * \note Only used for \ref RTBT_GuardRail1
+                                 *  "guardrail barriers".
+				 */
+    tRoadLineKind lKind;	/**< Kind of line used for the
+                                 * <em>Traffic barrier</em>
+				 */
+    int		visibility;	/**< Movie visibility flag:
+                                 * - 0 &harr; not visible
+                                 * - 1 &harr; visible
+                                 */
+    int		priority;	/**< Visibility priority:\n
+				 * Controls the visibility of overlapping
+                                 * <em>Traffic barriers</em> in IPGMovie
+                                 * (range: 0..5)
+				 */
+    int		userId;		/**< User definable id for the <em>Traffic
+                                 * barrier</em>: Optional custom indexing
+				 */
+    tRoadTBEndType 	eType0;	/**< Start type of the <em>Traffic barrier</em>
+				 */
+    tRoadTBEndType 	eType1;	/**< End type of the <em>Traffic barrier</em>
+				 */ 
+    char	*image0;	/**< Texture image for the barrier
+				 * \deprecated Use RoadObjectGetMaterial()/
+                                 * RoadObjectSetMaterial() for the definition of
+                                 * the material of the barrier.
+				 */
+    double      img0UV[2];	/**< Texture factor for the barrier
+				 * \deprecated Use RoadObjectGetMaterial()/
+                                 * RoadObjectSetMaterial() for the definition of
+                                 * the material of the barrier.
+				 */
+    char	*image1;	/**< Texture image for the poles
+				 * \deprecated Use RoadObjectGetMaterial()/
+                                 * RoadObjectSetMaterial() for the definition of
+                                 * the material of the poles.
+				 */
+    double      img1UV[2];	/**< Texture factor for the poles
+				 * \deprecated Use RoadObjectGetMaterial()/
+                                 * RoadObjectSetMaterial() for the definition of
+                                 * the material of the poles.
+				 */
+    int		n;		/**< Number of points in the
+				 * \ref tRoadTrafficBarrier::p "point list"
+    				 */
+    double	(*p)[2];	/**< Point list with (s,t)-coordinates in
+                                 * direction of the <em>Reference line</em>
+				 * relative to the insertion point
+				 */
+} tRoadTrafficBarrier;
+
+//! Road marking
+/** Struct for the parameters of a <em>Road marking</em>
+ */
+typedef struct tRoadRoadMarking {
+    double    s0;		/**< Start offset in meters
+				 */
+    double    s1;		/**< End offset in meters
+                                 * \note Only used for <em>Road markings</em>
+                                 * with \ref tRoadRoadMarking::lKind "line kind"
+                                 * #RLK_Offset.
+				 */
+    double    t;		/**< Lateral offset in meters
+				 */
+    double    width;		/**< Width of the line in meters
+				 */
+    double    height;		/**< Height of the line in meters
+				 */
+    double    space;		/**< Space length in meters
+				 */
+    double    dash;		/**< Dash length in meters
+				 */
+    double    detectability;	/**< Probability of detection by the Line Sensor
+                                 * (range: 0..1) 
+				 */
+    tRoadLonRef   lonR0;	/**< Integer value for the longitudinal
+				 * reference of \ref tRoadRoadMarking::s0 "s0"
+				 */
+    tRoadLonRef   lonR1;	/**< Integer value for the longitudinal
+				 * reference of \ref tRoadRoadMarking::s1 "s1"
+                                 * \note Only used for <em>Road markings</em>
+                                 * with \ref tRoadRoadMarking::lKind "line kind"
+                                 * #RLK_Offset.
+				 */
+    tRoadLatRef   latR;		/**< Integer value for the lateral reference of 
+				 * \ref tRoadRoadMarking::t "t"
+				 */
+    tRoadLineType lType;	/**< Type of line used for the <em>Road
+                                 * marking</em>
+				 */
+    tRoadLineKind lKind;	/**< Kind of line used for the <em>Road
+                                 * marking</em>
+				 */
+    int	      visibility;	/**< Movie visibility flag:
+                                 * - 0 &harr; not visible
+                                 * - 1 &harr; visible
+                                 */
+    int	      priority;         /**< Visibility priority:\n
+				 * Controls the visibility of overlapping
+                                 * <em>Road Markings</em> in IPGMovie
+                                 * (range: 0..5)
+				 */
+    int	      userId;		/**< User definable id for the <em>Road
+                                 * marking</em>: Optional custom indexing
+				 */
+    char      *image;		/**< Texture image
+				 * \deprecated Use RoadObjectGetMaterial()/
+                                 * RoadObjectSetMaterial() for the definition of
+                                 * the material of the <em>Road marking</em>.
+    				 */
+    double    imgUV[2];		/**< Texture factor
+				 * \deprecated Use RoadObjectGetMaterial()/
+                                 * RoadObjectSetMaterial() for the definition of
+                                 * the material of the <em>Road marking</em>.
+    				 */
+    int	      n;		/**< Number of points in the
+				 * \ref tRoadRoadMarking::p "point list"
+    				 */
+    double    (*p)[2];          /**< Point list with (s,t)-coordinates in
+                                 * direction of the <em>Reference line</em>
+				 * relative to the insertion point
+				 */
+} tRoadRoadMarking;
+
+//! Guide posts
+/** Struct for the parameters of <em>Guide posts</em>
+ */
+typedef struct tRoadGuidePost {    
+    double  s0;			/**< Start offset in meters
+				 */ 
+    double  s1;			/**< End offset in meters
+				 */
+    double  t;			/**< Lateral offset in meters
+				 */
+    double  spacing;		/**< Guidepost spacing in longitudinal direction
+                                 * in meters\n 
+				 * Special value: 0 &harr; Only one guide post
+				 * is created.
+				 */
+    tRoadLonRef lonR0;		/**< Integer value for the longitudinal
+				 * reference of \ref tRoadGuidePost::s0 "s0"
+				 */
+    tRoadLonRef lonR1;		/**< Integer value for the longitudinal
+				 * reference of \ref tRoadGuidePost::s1 "s1"
+				 */
+    tRoadLatRef latR;		/**< Integer value for the lateral reference of
+				 * \ref tRoadGuidePost::t "t"
+				 */
+    char    *options;		/**< Additional string: not evaluated by the
+                                 * road
+				 */
+} tRoadGuidePost;
+
+//! Tree strip
+/** Struct for the parameters of a <em>Tree strip</em>
+ */
+typedef struct tRoadTreeStrip {    
+    double  s0;		/**< Start offset in meters
+			 */ 
+    double  s1;		/**< End offset in meters
+			 */
+    double  t;		/**< Lateral offset in meters
+			 */
+    double  spacing;	/**< Spacing of the trees in longitudinal
+			 * direction in meters\n 
+                         * Special value: 0 &harr; Only one tree is created.
+			 */
+    double  width;	/**< Width of the tree strip in meters
+			 */
+    double  scaleW;	/**< Scaling factor for the trees in width
+			 */
+    double  scaleH;	/**< Scaling factor for the trees in height
+			 */
+    double  randomW;	/**< Random factor for the trees size variety in width
+			 */
+    double  randomH;	/**< Random factor for the tree size variety in height
+			 */
+    tRoadLonRef lonR0;	/**< Integer value for the longitudinal reference of
+			 * \ref tRoadTreeStrip::s0 "s0"
+			 */
+    tRoadLonRef lonR1;	/**< Integer value for the longitudinal reference of
+			 * \ref tRoadTreeStrip::s1 "s1"
+			 */
+    tRoadLatRef latR;	/**< Integer value for the lateral reference of 
+			 * \ref tRoadTreeStrip::t "t"
+			 */
+    char    *options;	/**< Additional string for the file specifying the tree
+                         * type (not evaluated by the road)
+                         */
+} tRoadTreeStrip;
+
+//! Geometry object
+/** Struct for the parameters of a <em>Geometry object</em>
+ */
+typedef struct tRoadGeoObject {
+    double  s0;             /**< Start offset in meters
+                             */ 
+    double  s1;             /**< End offset in meters
+                             */
+    double  t;              /**< Lateral offset in meters
+                             */
+    double  spacing;        /**< Multiple object spacing in longitudinal
+                             * direction in meters\n 
+                             * Special value: 0 &harr; Only one object is
+                             * created.
+                             */
+    double  width;          /**< Width of the object in meters
+                             */
+    double  scale[3];       /**< Scaling factors for the object in
+                             * x/y/z-direction
+                             */
+    double  zOffset;        /**< Offset in z-direction from the road surface
+                             * in meters
+                             */
+    double  rot[3];         /**< Rotation of the object in x/y/z-direction
+                             * in degrees
+                             */
+    double  detectability;  /**< Probability of detection (range: 0..1)
+                             * \note This parameter is not considered by
+                             * the CarMaker <em>Sensors</em>.
+                             */
+    double  min[3];         /**< Bounding box: Minimum x/y/z-coordinate of the
+                             * object in the global IPGRoad coordinate system
+                             * (Fr0)
+                             */
+    double  max[3];         /**< Bounding box: Maximum x/y/z-coordinate of the
+                             * object in the global IPGRoad coordinate system
+                             * (Fr0)
+                             */
+    tRoadLonRef lonR0;      /**< Integer value for the longitudinal
+                             * reference of \ref tRoadGeoObject::s0 "s0"
+                             */
+    tRoadLonRef lonR1;      /**< Integer value for the longitudinal
+                             * reference of \ref tRoadGeoObject::s1 "s1"
+                             */
+    tRoadLatRef latR;       /**< Integer value for the lateral reference of
+                             * \ref tRoadGeoObject::t "t"
+                             */
+    int     rel2Ground;     /**< Orientation:
+                             * - 0 &harr; plumb-vertical orientation
+                             * (perpendicular to the (x,y)-plane of the global
+                             * IPGRoad coordinate system (Fr0))
+                             * - 1&harr; following the inclination of the road
+                             * surface (perpendicular to the ground)
+                             */
+    char    *fname;         /**< Name of the file specifying the <em>Geometry
+                             * object</em>
+                             */
+    char    *options;       /**< Additional string: not evaluated by the road
+                             */
+} tRoadGeoObject;
+
+//! Road painting
+/** Struct for the parameters of a <em>Road painting</em>
+ */
+typedef struct tRoadRoadPainting {
+    double  s;              /**< Start offset in meters
+                             */ 
+    double  t;              /**< Lateral offset in meters
+                             */
+    double  angle;          /**< Rotation of the local (u,v)-coordinate system
+                             * of the <em>Road painting</em> relative to the
+                             * (s,t)-coordinate system of the reference object:
+                             * angle between s- and u-axis in degrees
+                             * - < 0 &harr; clockwise rotation
+                             * - > 0 &harr; couterclockwise rotation
+                             */
+    double  u;              /**< Length of the image in meters
+                             */
+    double  v;              /**< Width of the image in meters
+                             */
+    tRoadLonRef lonR;       /**< Integer value for the longitudinal
+                             * reference of \ref tRoadRoadPainting::s "s"
+                             */
+    tRoadLatRef latR;       /**< Integer value for the lateral reference of
+                             * \ref tRoadRoadPainting::t "t"
+                             */
+    char    *fname;         /**< Name of the file specifying the <em>Road
+                             * painting</em>
+                             */
+    char    *options;       /**< Additional string: not evaluated by the road
+                             */
+} tRoadRoadPainting;
+
+//! Sign plate
+/** Struct for the parameters of a <em>Sign plate</em>
+ */
+typedef struct tRoadSignPlate {    
+    double  s;              /**< Start offset in meters
+                             */ 
+    double  t;              /**< Lateral offset in meters
+                             */
+    double  angle;          /**< Rotation of the local (u,v)-coordinate system
+                             * of the <em>Sign plate</em> relative to the
+                             * (s,t)-coordinate system of the reference object:
+                             * angle between s- and u-axis in degrees
+                             * - < 0 &harr; clockwise rotation
+                             * - > 0 &harr; couterclockwise rotation
+                             */
+    double  width;          /**< Width of the sign plate in meters
+                             */
+    double  height;         /**< Height of the sign plate in meters
+                             */
+    double  poleHeight;     /**< Pole height: Height of the pole in meters
+                             */
+    double  poleDist;       /**< Pole spacing: Distance between the two
+                             * poles in meters
+                             */
+    tRoadLonRef lonR;       /**< Integer value for the longitudinal
+                             * reference of \ref tRoadSignPlate::s "s"
+                             */
+    tRoadLatRef latR;       /**< Integer value for the lateral reference of
+                             * \ref tRoadSignPlate::t "t"
+                             */
+    char    *fname;         /**< Name of the file specifying the <em>Sign
+                             * plate</em>
+                             */
+    char    *options;       /**< Additional string: not evaluated by the road
+                             */
+} tRoadSignPlate;
+
+
+/** Types of <em>Bridges</em>:\n
+ *  The bridge types are considered for the visualization.
+ */
+typedef enum tRoadBridgeType {
+    RBRT_None = 0,	/**< <b>0</b> &nbsp; No bridge\n
+                         * The part of the <em>Link</em> were the
+                         * <em>Bridge</em> is defined is handled by the terrain
+                         * generation as if there is a bridge, even though no
+                         * bridge is visualized.
+			 */
+    RBRT_Type1,         /**< <b>1</b> &nbsp; Default bridge
+			 */
+    RBRT_Unknown,	/**< <b>2</b> &nbsp; Unknown bridge type
+			 */
+    RBRT_Count	        /**< <b>3</b> &nbsp; Number of bridge types including
+                         * #RBRT_Unknown
+			 */
+} tRoadBridgeType;
+
+/** Types of bridge pillars:\n
+ *  The bridge pillar types are used for the visualization.
+ */
+typedef enum tRoadBridgePillarType {
+    RBRPT_None = 0,	/**< <b>0</b> &nbsp; No bridge pillar
+                         */
+    RBRPT_Type1,        /**< <b>1</b> &nbsp; Angular bridge pillar\n
+                         * The pillar is at an angle to the ground.
+			 */
+    RBRPT_Type2,        /**< <b>2</b> &nbsp; Straight bridge pillar\n
+                         * The pillar is at right angle to the ground.
+			 */
+    RBRPT_Type3,        /**< <b>3</b> &nbsp; Unused
+			 */
+    RBRPT_Unknown,	/**< <b>4</b> &nbsp; Unknown bridge pillar type
+			 */
+    RBRPT_Count	        /**< <b>5</b> &nbsp; Number of bridge pillar types
+                         * including #RBRPT_Unknown
+			 */
+} tRoadBridgePillarType;
+//! Bridge
+/** Struct for the parameters of a <em>Bridge</em>
+ */
+typedef struct tRoadBridge {    
+    double s0;		 /**< Start offset in meters
+			  */
+    double s1;		 /**< End offset in meters
+			  */
+    double tOffset[2];	 /**< Spacing: Distance to the road's left/right border 
+			  * in meters
+			  */
+    double height;	 /**< Height of the bridge profile in meters
+			  */
+    double angle0;	 /**< Pillar angle at the start in degrees
+			  * \note Currently without effect in IPGMovie.
+			  */
+    double angle1;	 /**< Pillar angle at the end in degrees
+			  * \note Currently without effect in IPGMovie.
+			  */
+    int    lonR0;	 /**< Integer value for the \ref tRoadLonRef 
+			 * "longitudinal reference" of \ref tRoadBridge::s0 "s0"
+			  */
+    int    lonR1;	 /**< Integer value for the \ref tRoadLonRef 
+			 * "longitudinal reference" of \ref tRoadBridge::s1 "s1"
+			  */
+    int    type;	 /**< \ref tRoadBridgeType "Type" of <em>Bridge</em>
+			  */
+    int    pillarType[2];/**< \ref tRoadBridgePillarType "Type" of the pillar
+                          * at the start / end
+			  */
+    char   *material;	 /**< \deprecated Set this parameter to NULL.\n
+                          * Use RoadObjectGetMaterial() /
+                          * RoadObjectSetMaterial() for the definition of the
+                          * material of the bridge.
+			  */
+} tRoadBridge;
+
+
+/** Types of <em>Tunnels</em>:\n
+ *  The tunnel types are used for the visualization.
+ */
+typedef enum tRoadTunnelType {
+    RTUT_Type1,         /**< <b>0</b> &nbsp; Default tunnel
+			 */
+    RTUT_Unknown,	/**< <b>1</b> &nbsp; Unknown tunnel type
+			 */
+    RTUT_Count	        /**< <b>2</b> &nbsp; Number of tunnel types
+                        * including #RTUT_Unknown
+			 */
+} tRoadTunnelType;
+//! Tunnel
+/** Struct for the parameters of a <em>Tunnel</em>
+ */
+typedef struct tRoadTunnel {    
+    double s0;		/**< Start offset in meters
+			 */
+    double s1;		/**< End offset in meters
+			 */
+    int    lonR0;	/**< Integer value for the \ref tRoadLonRef 
+			 * "longitudinal reference" of \ref tRoadTunnel::s0 "s0"
+			 */
+    int    lonR1;	/**< Integer value for the \ref tRoadLonRef 
+			 * "longitudinal reference" of \ref tRoadTunnel::s1 "s1"
+			 */
+    double angle0;	/**< Entry angle at the start in degrees
+                         * \note Currently without effect in IPGMovie.
+			 */
+    double angle1;	/**< Entry angle at the end in degrees
+                         * \note Currently without effect in IPGMovie.
+			 */
+    int    type;	/**< \ref tRoadTunnelType "Type" of <em>Tunnel</em>
+			 */
+    double tOffset[2];	/**< Spacing: Distance to the road's left/right border
+                         * in meters
+			 */
+    double height;	/**< Height of the tunnel above the road in meters
+			 */
+    char   *material;	/**< \deprecated Set this parameter to NULL.\n
+                         * Use RoadObjectGetMaterial() / RoadObjectSetMaterial()
+                         * for the definition of the material of the tunnel.
+			 */
+} tRoadTunnel;
+
+//! Road surface
+/** Struct for the parameters of a <em>Road surface</em>
+ */
+typedef struct tRoadRoadSurface {    
+    double s0;              /**< Start offset in meters
+                             */ 
+    double s1;              /**< End offset in meters
+                             */
+    double t;               /**< Lateral offset in meters
+                             */
+    int    lonR0;           /**< Integer value for the \ref tRoadLonRef 
+                             * "longitudinal reference" of
+                             * \ref tRoadRoadSurface::s0 "s0"
+                             */
+    int    lonR1;           /**< Integer value for the \ref tRoadLonRef 
+                             * "longitudinal reference" of
+                             * \ref tRoadRoadSurface::s1 "s1"
+                             */
+    int    latR;            /**< Integer value for the \ref tRoadLatRef
+                             * "lateral reference" of 
+                             * \ref tRoadRoadSurface::t "t"
+                             */
+    double angle;           /**< Rotation of the local (u,v)-coordinate system
+                             * of the <em>Road surface</em> relative to the
+                             * (s,t)-coordinate system of the reference object:
+                             * angle between s- and u-axis in degrees
+                             * - < 0 &harr; clockwise rotation
+                             * - > 0 &harr; couterclockwise rotation
+                             * 
+                             * \note In case there is a rotation, the distance 
+                             *  between \ref tRoadRoadSurface::s0 "s0" and
+                             *  \ref tRoadRoadSurface::s1 "s1" describes the
+                             *  length of the rotated surface patch.
+                             */
+    double width0;          /**< Start width of the surface patch in meters
+                             */
+    double width1;          /**< End width of the surface patch in meters
+                             */
+    double *shape;          /**< Currently unused: Reserved for future use.
+                             */
+    int    nShape;          /**< Currently unused: Reserved for future use.
+                             */
+    char   *options;        /**< Additional string: not evaluated by the road
+                             */
+    int	   isRegular;       /**< Alignment of the surface patch:\n
+                             * - 0 &harr; following the <em>Reference line</em>
+                             * - 1 &harr; rectangular
+                             */
+    tRoadTransitionType tType;/**< Transition type: Mode of interpolation for 
+                             * the width of the surface patch
+                             */
+} tRoadRoadSurface;
+
+
+/** Function to add a new <em>Accessory</em> or <em>Scenery object</em> to an
+ *  object of appropriate type:\n
+ *  The reference object of a <em>Accessory</em> or <em>Scenery object</em> can
+ *  be a <em>Reference line</em>, <em>Link</em>, <em>Segment</em> or <em>Lane
+ *  section</em> and for all but <em>Bridges</em> and <em>Tunnels</em> also a
+ *  <em>Lane</em>. Moreover, it is possible to add <em>Mounts</em>, <em>Traffic
+ *  barriers</em>, <em>Road markings</em>, <em>Road paintings</em> and
+ *  <em>Guide posts</em> to all kinds of <em>Paths</em>.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the reference object for the parameters of the
+ *  new <em>Accessory</em>
+ *  or <em>Scenery object</em>
+ * \param[in] type \ref ROT_Mount "Type" of the new <em>Accessory</em> or
+ *  <em>Scenery object</em>
+ * \param[in] sensorObj Pointer to an appropriate tRoad struct containing the
+ *  data of the new <em>Accessory</em> or <em>Scenery object</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the new <em>Accessory</em> or <em>Scenery object</em>\n
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadGetSensorObject() \see RoadSetSensorObject()
+ * \see RoadDeleteSensorObject()
+ */
+tObjId RoadAddSensorObject   (tRoad *road, tObjId objId,
+				   tRoadObjectType type, void *sensorObj);
+/**  Function to get an <em>Accessory</em> or <em>Scenery object</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the <em>Accessory</em> or
+ *  <em>Scenery object</em>
+ * \param[out] sensorObj Pointer to an appropriate tRoad struct for the data of
+ *  the <em>Accessory</em> or <em>Scenery object</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddSensorObject() \see RoadSetSensorObject()
+ * \see RoadDeleteSensorObject()
+ */
+int    RoadGetSensorObject   (tRoad *road, tObjId objId, void *sensorObj);
+/** Function to set a <em>Accessory</em> or <em>Scenery object</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the <em>Accessory</em> or
+ *  <em>Scenery object</em>
+ * \param[in] sensorObj Pointer to an appropriate tRoad struct containing the
+ *  data for the <em>Accessory</em> or <em>Scenery object</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddSensorObject() \see RoadGetSensorObject()
+ * \see RoadDeleteSensorObject()
+ */
+int    RoadSetSensorObject   (tRoad *road, tObjId objId, void *sensorObj);
+/** Function to delete a <em>Accessory</em> or <em>Scenery object</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the <em>Accessory</em> or
+ *  <em>Scenery object</em> that should be deleted
+ * \see RoadAddSensorObject() \see RoadGetSensorObject()
+ * \see RoadSetSensorObject()
+ */
+void   RoadDeleteSensorObject(tRoad *road, tObjId objId);
+
+//! Tree strip/Geometry object/Guide post
+/** Struct for the general information about the position of a <em>Tree
+ *  strip</em>, <em>Geometry object</em> or <em>Guide post</em>
+ */
+typedef struct tRoadSensorObjectOut {
+    double xyz[3];	/**< Position of the object in the global IPGRoad
+                         * coordinate system (Fr0)
+			 */
+    double rotXYZ[3];	/**< Euler angles for the rotation in z/y/x-direction
+			 */
+    double scale[3];	/**< Scaling factor in x/y/z-direction
+			 */
+    tObjId objId;	/**< Object id of the object
+			 */
+    char   *fname;	/**< Name of the file specifying the object
+                         * \note Only used for <em>Geometry objects</em>.
+  			 */
+    char   *options;	/**< Additional string: not evaluated by the road
+			 */
+} tRoadSensorObjectOut;
+
+/** Function to get a list of the <em>Tree strips</em>, <em>Geometry
+ *  objects</em> or <em>Guide posts</em> attached to the same <em>Link</em> as
+ *  a given <em>Tree strip</em>, <em>Geometry object</em> or <em>Guide
+ *  post</em>, respectively
+ * \note The user is responsible to free the memory of *list.
+ * \param[in] road Handle of the road instance
+ * \param[in] soObjId Object id of the given <em>Tree strip</em>,
+ *  <em>Geometry object</em> or <em>Guide posts</em>
+ * \param[in] useTerrain Parameter indicating whether a <em>Terrain</em> should
+ *  be taken into account:
+ *  - 0 &harr; The z-coordinates of the objects are calculated relative to the
+ *  road surface.
+ *  - 1 &harr; The z-coordinates of the objects are calculated considering the
+ * <em>Terrain</em> of the road instance if one exists.
+ * \param[out] list Pointer to an array for the information about the retrieved
+ *  objects
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> number of retrieved
+ *  <em>Tree strips</em>, <em>Geometry objects</em> or <em>Guide posts</em>
+ *  <tr><td> In case of failure:
+ *  <td>  see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+  */
+int    RoadGetSensorObjectList(tRoad *road, tObjId soObjId,
+				   int useTerrain, tRoadSensorObjectOut **list);
+
+/** @} */
+/** \addtogroup SOEval
+ * @{
+ */
+//! Traffic light: detection
+/** Struct for the parameters of an element of the list of <em>Traffic
+ *  lights</em> in tRoadTrfLightExtList
+ *  \see RoadGetAllLinkTrfLights() \see tRoadTrfLight
+ *  \deprecated <em>Traffic lights</em> are detected using the corresponding
+ *  <em>\ref RoadRouteGetAllDrvStops "Stop markers"</em>.
+ */
+typedef struct tRoadTrfLightExt {
+    char   *name;	/**< Name of the <em>Traffic light controller</em>
+    			 */
+    char   *startCond;	/**< Condition to trigger the starting of the
+                         * <em>Traffic light controller</em>
+			 */
+    tObjId objId;	/**< Object id of the <em>Traffic light controller</em>
+    			 */
+    int	   type;	/**< \ref tRoadTLType "Type" of the
+                         * <em>Traffic light</em>
+    			 */
+    int	   facing;	/**< Flag indicating the direction validity of the
+                         * traffic light:
+                         * - -1 &harr; counter route direction
+			 * - 1 &harr; in route direction
+			 */
+    int	   consider;	/**< Relevant for the driver:
+                         * - 0 &harr; not relevant
+			 * - 1 &harr; relevant
+			 */
+    int	   initialPhase;/**< Integer value for the initial phase of the 
+                         * <em>Traffic light controller</em>:
+                         *  - 0 &harr; off phase
+                         *  - 1 &harr; green phase
+                         *  - 2 &harr; yellow phase
+                         *  - 3 &harr; red phase
+                         *  - 4 &harr; red+yellow phase
+			 */
+    double sRoute;	/**< Offset of the <em>Traffic light's</em> stop line on
+                         * the <em>Route</em> in meters:\n The stop line is
+                         * internally defined two meters in front of the traffic
+                         * light and not visualized.
+                         * \note Only available if the <em>Traffic lights</em>
+                         *  along a given <em>Route</em> are evaluated.
+			 */
+    double xyz[3];	/**< Position of the traffic light in the global IPGRoad
+                         * coordinate system (Fr0)
+    			 */
+    double nuv[3];	/**< Road surface normal unit vector at
+                         * \ref tRoadTrfLightExt::xyz "xyz"
+    			 */
+    double timing[ROAD_NUM_TL_TIMING]; /**< Durations of the different phases
+                         * in seconds:
+                         *  - 0 &harr; off phase
+                         *  - 1 &harr; green phase
+                         *  - 2 &harr; yellow phase
+                         *  - 3 &harr; red phase
+                         *  - 4 &harr; red+yellow phase
+                         */
+} tRoadTrfLightExt;
+//! Traffic light list: detection
+/** Struct for a list of <em>Traffic lights</em>
+ *  \see RoadGetAllLinkTrfLights() \see tRoadTrfLightList
+ *  \deprecated <em>Traffic lights</em> are detected using the corresponding
+ *  <em>\ref RoadRouteGetAllDrvStops "Stop markers"</em>.
+ */
+typedef struct tRoadTrfLightExtList {
+   tRoadTrfLightExt *tl;	/**< List of <em>Traffic lights</em>
+				 */
+   int 		    nTL;	/**< Number of <em>Traffic lights</em> listed
+				 */
+} tRoadTrfLightExtList;
+
+/** Function to get all <em>Traffic lights</em> along a given <em>Link</em>
+ *  This function will only deliver <em>Traffic lights</em> connected to a valid 
+ *  <em> Traffic light controller</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] linkId Identifier of the <em>Link</em>
+ * \param[out] tlList Pointer to a list for the <em>Traffic lights</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Traffic light</em> along the <em>Link</em>\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ *  \deprecated Use RoadCtrlGetAllCtrlTL() and RoadCtrlGetTrfLights() to get all
+ *  <em>Traffic lights</em> of a given road instance. Moreover, the function
+ *  RoadRouteGetAllDrvStops() might be a good replacement.
+ */
+int    RoadGetAllLinkTrfLights(tRoad *road, int linkId,
+						  tRoadTrfLightExtList *tlList);
+
+
+/** @} */
+/** \addtogroup SOEdit
+ * @{
+ */
+/** Function to compare the parameters of a given <em>Mount</em> with those of
+ *  the <em>Mounts</em> attached to a given <em>Reference line</em> and
+ *  get the object id of a matching <em>Mount</em> in case it already exists
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the <em>Reference line</em>
+ * \param[in] mount Struct containing the data of the <em>Mount</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the matching <em>Mount</em>
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ */
+tObjId RoadMountExists(tRoad *road, tObjId objId, tRoadMount mount);
+
+/** Function to set the flag indicating whether a given <em>Road marking</em> or
+ *  <em>Traffic barrier</em> should be considered as part of a <em>Connected
+ *  trajectory list</em>\n
+ *  If the parameters of a <em>Road marking</em> or <em>Traffic barrier</em>
+ *  that is considered as part of a <em>Connected trajectory list</em> are
+ *  changed, those of the other objects belonging to the list are adapted
+ *  accordingly.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the <em>Road marking</em> or <em>Traffic
+ *  barrier</em>
+ * \param[in] setAll Parameter determining whether the given object is
+ *  considered as part of a <em>\ref ROT_CTL "Connected trajectory list"</em>:
+ *  - 0 &harr; The object's parameters and material are defined independently
+ *  from other objects.
+ *  - 1 &harr; All parameters and the material are set for the whole trajectory
+ *  list of the object.
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadAdoptParamsForCTL(tRoad *road, tObjId objId, int setAll);
+
+//! Mount: output
+/** Struct for the output parameters of RoadGetMountObj()
+ * \see tRoadMount
+ */
+typedef struct tRoadMountOut {
+    double xyz[3];	/**< Position of the <em>Mount</em> in the global
+                         * IPGRoad coordinate system (Fr0)
+    			 */
+    double dim[3];	/**< Dimensions of the mount in x/y/z-direction in
+                         * meters
+			 */
+    double angle;	/**< Rotation of the <em>Mount's</em> local coordinate
+                         * system relative to the (x,y)-plane of the global
+                         * IPGRoad coordinate system (Fr0) counter-clockwise
+                         * in degrees
+			 */
+    double roadAngle;	/**< Rotation of the <em>Mount's</em> local coordinate
+                         * system relative to the local coordinate system of the
+                         * associated <em>Reference line</em> counter-clockwise
+                         * in degrees
+                         */
+    int    type;	/**< Type of the pole of the <em>Mount</em>
+			 */
+    int    valid;	/**< Flag indicating whether the <em>Mount</em> is
+                         *  valid:
+                         * - 0 &harr; The <em>Mount</em> is defined with
+                         * reference to a part of the <em>Road network</em>
+                         * that has been deleted.
+                         * - 1 &harr; The <em>Mount</em> is valid. 
+			 */
+} tRoadMountOut;
+
+/** Function to get the general information about the position of a given
+ *  <em>Mount</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the <em>Mount</em>
+ * \param[out] mount Pointer to a struct for the data of the <em>Mount</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetMountObj(tRoad *road, tObjId objId, tRoadMountOut *mount);
+
+//! Traffic sign: output
+/** Struct for the output parameters of RoadGetTrfSignObj()
+ * \see tRoadTrafficSign
+ */
+typedef struct tRoadTSOut {
+    
+    double xyz[3];	/**< Position of the <em>Traffic sign</em> in the global
+                         * IPGRoad coordinate system (Fr0)
+    			 */
+    double angle;	/**< Rotation of the <em>Traffic sign's</em> local
+                         * coordinate system relative to the (x,y)-plane of the
+                         * global IPGRoad coordinate system (Fr0)
+                         * counter-clockwise in degrees
+			 */
+    double roadAngle;	/**< Rotation of the <em>Traffic sign's</em> local
+                         * coordinate system relative to the local coordinate
+                         * system of the associated <em>Reference line</em>
+                         * counter-clockwise in degrees
+			 */
+    struct {
+        char  *sign;	/**< Key of the type of <em>Traffic sign</em>
+			 */
+        char  *size;	/**< Size of the <em>Traffic sign</em>:
+			 * - M &harr; medium
+			 * - L &harr; large
+			 */
+        float val[2];	/**< Values 0 / 1 displayed on <em>Traffic signs</em> of
+                         * appropriate \ref tRoadTSOut::sign "type"
+			 */
+    } main,             /**< Main traffic sign
+                         */
+      suppl1,           /**< First supplement sign
+                         */
+      suppl2;           /**< Second supplement sign
+                         */
+    int    valid;	/**< Flag indicating whether the <em>Traffic sign</em>
+                         *  is valid:
+                         * - 0 &harr; The <em>Traffic sign</em> is defined with
+                         * reference to a part of the <em>Road network</em>
+                         * that has been deleted.
+                         * - 1 &harr; The <em>Traffic sign</em> is valid. 
+			 */
+} tRoadTSOut;
+
+/** Function to get the general information about the position of a given
+ *  <em>Traffic sign</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the <em>Traffic sign</em>
+ * \param[out] trfSign Pointer to a struct for the data of the
+ *  <em>Traffic sign</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetTrfSignObj(tRoad *road, tObjId objId, tRoadTSOut *trfSign);
+
+//! Traffic light: output
+/** Struct for the output parameters of RoadGetTrfLightObj()
+ * \see tRoadTrafficLight
+ */
+typedef struct tRoadTLOut {    
+    double xyz[3];	/**< Position of the <em>Traffic light</em> in the
+                         * global IPGRoad coordinate system (Fr0)
+                         */
+    double angle;	/**< Rotation of the <em>Traffic light's</em> local
+                         * coordinate system relative to the (x,y)-plane of the
+                         * global IPGRoad coordinate system (Fr0)
+                         * counter-clockwise in degrees
+			 */
+    double roadAngle;	/**< Rotation of the <em>Traffic light's</em> local
+                         * coordinate system relative to the local coordinate
+                         * system of the associated <em>Reference line</em>
+                         * counter-clockwise in degrees
+			 */
+    int    type;	/**< \ref tRoadTLType "Type" of the <em>Traffic
+                         * light</em>
+			 */
+    int    valid;	/**< Flag indicating whether the <em>Traffic light</em>
+                         *  is valid:
+                         * - 0 &harr; The <em>Traffic light</em> is defined with
+                         * reference to a part of the <em>Road network</em>
+                         * that has been deleted.
+                         * - 1 &harr; The <em>Traffic light</em> is valid. 
+			 */
+} tRoadTLOut;
+
+/** Function to get the general information about the position of a given
+ *  <em>Traffic light</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the <em>Traffic light</em>
+ * \param[out] trfLight Pointer to a struct for the data of the
+ *  <em>Traffic light</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetTrfLightObj(tRoad *road, tObjId objId, tRoadTLOut *trfLight);
+
+
+/** @} */
+/******************************************************************************/
+/* +++ Paths ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+/** \addtogroup LanePathsEdit
+ * @{
+ */
+//! Lane path
+/** Struct for the parameters of a <em>Lane path</em>
+ */
+typedef struct tRoadLanePath {    
+    double wf;		/**< Weight factor: Attribute for autonomous traffic\n
+			 * A higher weight factor results in a higher
+			 * probability that this <em>Path</em> will be used.
+                         * A <em>Path</em> with
+			 * a weight factor < = 0 will not be used by IPGTraffic.
+			 */
+    double pL;		/**< Probability for a lane change to the left:
+			 * Attribute for autonomous traffic.
+			 */
+    double pR;		/**< Probability for a lane change to the right:
+			 * Attribute for autonomous traffic.
+			 */
+    double limWidth;	/**< Path width limit: The meaning of this parameter
+			 * depends on the \ref tRoadLaneType "lane type".
+                         * \note See \ref tRoadPath::nDrv "drivable sections"
+                         *  of a <em>Path</em>.
+			 */
+} tRoadLanePath;
+
+/** Function to get a <em>Lane path</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] lanePathObjId Object id of the <em>Lane path</em>
+ * \param[out] lanePath Pointer to a struct for the data of the
+ *  <em>Lane path</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadSetLanePath()
+ */
+int    RoadGetLanePath (tRoad *road, tObjId lanePathObjId, 
+						       tRoadLanePath *lanePath);
+/** Function to set a <em>Lane path</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] lanePathObjId Object id of the <em>Lane path</em>
+ * \param[in] lanePath Pointer to a struct containing the data for the
+ *  <em>Lane path</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetLanePath()
+ */
+int    RoadSetLanePath (tRoad *road, tObjId lanePathObjId, 
+						       tRoadLanePath *lanePath);
+
+ /** @} */
+ /** \addtogroup UserPathsEdit
+  * @{
+  */
+//! User path node
+/** Struct for the parameters of a user path node
+ * \see tRoadUserPath
+ */
+typedef struct tRoadPathSTNode {    
+    double s;		/**< Offset on the \ref tRoadPathSTNode::objId
+                         * "reference object" in s-direction in meters
+			 */
+    double t[2];	/**<
+                         * - t[0]: Lateral offset in meters
+                         * - t[1]: Gradient with respect to the s-coordinate\n
+                         * Special value: \ref ROAD_UNDEFINED &harr;
+                         * A spline defined by the support points is used.
+			 */
+    int    lonR;	/**< Integer value for the \ref tRoadLonRef 
+			 * "longitudinal reference" of \ref tRoadPathSTNode::s
+                         * "s"
+                         * \note If the \ref tRoadPathSTNode::objId
+                         * "reference object" is a <em>Reference line</em> or a
+                         * <em>Lane</em>, only \ref RLR_Node0 "start point" and
+                         * \ref RLR_Node1 "end point" are allowed as reference.
+			 */
+    tObjId objId;	/**< Object id of the reference object for
+                         * \ref tRoadPathSTNode::s "s" and
+                         * \ref tRoadPathSTNode::t "t" that can be either a 
+                         * <em>Link</em>, a <em>Reference line</em> or a
+                         * <em>Lane</em>
+			 */
+} tRoadPathSTNode;
+
+/** Function to add a path node to a <em>User path</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] userPObjId Object id of the <em>User path</em>
+ * \param[in] node Pointer to a struct containing the data of the new path node
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the new user path node
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadGetPathSTNode() \see RoadSetPathSTNode() \see RoadDeletePathSTNode()
+ */
+tObjId RoadAddPathSTNode   (tRoad *road, tObjId userPObjId,
+							 tRoadPathSTNode *node);
+/** Function to get a path node
+ * \param[in] road Handle of the road instance
+ * \param[in] pathNodeObjId Object id of the path node
+ * \param[out] node Pointer to a struct for the data of the path node
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddPathSTNode() \see RoadSetPathSTNode() \see RoadDeletePathSTNode()
+ */
+int    RoadGetPathSTNode   (tRoad *road, tObjId pathNodeObjId,
+							 tRoadPathSTNode* node);
+/** Function to set a path node
+ * \param[in,out] road Handle of the road instance
+ * \param[in] pathNodeObjId Object id of the path node
+ * \param[in] node Pointer to a struct containing the data for the path node
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddPathSTNode() \see RoadGetPathSTNode() \see RoadDeletePathSTNode()
+ */
+int    RoadSetPathSTNode   (tRoad *road, tObjId pathNodeObjId,
+							 tRoadPathSTNode* node);
+/** Function to delete a path node of a <em>User path</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] pathNodeObjId Object id of the path node that should be deleted
+ * \see RoadAddPathSTNode() \see RoadGetPathSTNode() \see RoadSetPathSTNode()
+ */
+void   RoadDeletePathSTNode(tRoad *road, tObjId pathNodeObjId);
+
+//! User path
+/** Struct for the parameters of a <em>User path</em>
+ * \see tRoadPathSTNode
+ */
+typedef struct tRoadUserPath {    
+    double wf;		/**< Weight factor: Attribute for autonomous traffic\n
+			 * A higher weight factor results in a higher
+			 * probability that this <em>Path</em> will be used.
+                         * A <em>Path</em> with
+			 * a weight factor < = 0 will not be used by IPGTraffic.
+			 */
+    double w0;          /**< Path width at the start of the <em>Path</em>
+                         * (relevant for IPGDriver and IPGTraffic)\n 
+			 * Special values:
+			 * - -1 &harr; use lane width,
+			 * - -2 &harr; use road width
+                         * (left to right border)
+			 */
+    double w1;          /**< Path width at the end of the <em>Path</em>
+                         * (relevant for IPGDriver and IPGTraffic)\n
+			 * Special values:
+			 * - -1 &harr; use lane width,
+			 * - -2 &harr; use road width
+                         * (left to right border)
+			 */
+    int    dir;		/**< Path direction:\n
+			 * -  1 &harr; in link direction
+			 * - -1 &harr; counter link direction
+			 */
+    int    mode; 	/**< Currently unused: Reserved for future use.
+			 */
+} tRoadUserPath;
+
+/** Function to add a <em>User path</em> to a <em>Link</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[in] userPath Pointer to a struct containing the data of the new
+ *  <em>User path</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> object id of the new <em>User path</em>\n
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadGetUserPath() \see RoadSetUserPath() \see RoadDeleteUserPath()
+ */
+tObjId RoadAddUserPath   (tRoad *road, tObjId lObjId, 
+						       tRoadUserPath *userPath);
+/** Function to get a <em>User path</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] userPathObjId Object id of the <em>User path</em>
+ * \param[out] userPath Pointer to a struct for the data of the <em>User
+ *  path</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddUserPath() \see RoadSetUserPath() \see RoadDeleteUserPath()
+ */
+int    RoadGetUserPath   (tRoad *road, tObjId userPathObjId,
+						       tRoadUserPath *userPath);
+/** Function to set a <em>User path</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] userPathObjId Object id of the <em>User path</em>
+ * \param[in] userPath Pointer to a struct containing the data for the <em>User
+ *  path</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddUserPath() \see RoadGetUserPath() \see RoadDeleteUserPath()
+ */
+int    RoadSetUserPath   (tRoad *road, tObjId userPathObjId,
+						       tRoadUserPath *userPath);
+/** Function to delete a <em>User path</em>\n
+ *  \note In case the <em>User path</em> that should be deleted belongs to a
+ *   <em>Route</em> this <em>Route</em> is cut off right before it.
+ *   Moreover, if a <em>Route</em> starts with the <em>User path</em>, it is
+ *   deleted as well.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] userPathObjId Object id of the user path node that should be
+ *  deleted
+ * \see RoadAddUserPath() \see RoadGetUserPath() \see RoadSetUserPath()
+ */
+void   RoadDeleteUserPath(tRoad *road, tObjId userPathObjId);
+
+ /** @} */
+ /** \addtogroup ConPathsEdit
+  * @{
+  */
+ //! Connector path
+/** Struct for the parameters of a <em>Connector path</em>
+ */
+typedef struct tRoadConPath {    
+    double  s0;		    /**< Offset on the \ref tRoadConPath::objId0
+                             * "start path" where the <em>Connector path</em>
+                             * splits off from it
+			     */
+    double  s1;		    /**< Offset on the \ref tRoadConPath::objId1
+                             * "end path" where the <em>Connector path</em>
+                             * merges with it
+			     */
+    double  wf;		    /**< Weight factor: Attribute for autonomous traffic
+			     * \n A higher weight factor results in a higher
+			     * probability that this <em>Path</em> will be used.
+                             * A <em>Path</em> with a weight factor
+			     * < = 0 will not be used by IPGTraffic.
+			     */
+    double  w0;             /**< Path width at the start of the <em>Path</em>
+                             * (relevant for IPGDriver and IPGTraffic)\n
+                             * Special values:
+                             * - -1 &harr; use lane width
+                             * - -2 &harr; use road width
+                             *  (left to right border),
+                             * \note Only for <em>Connector paths</em> defined
+                             *  on a <em>Link</em>.
+			     */
+    double  w1;             /**< Path width at the end of the <em>Path</em>
+                             * (relevant for IPGDriver and IPGTraffic)\n
+                             * Special values:
+                             * - -1 &harr; use lane width
+                             * - -2 &harr; use road width
+                             *  (left to right border),
+                             * \note Only for <em>Connector paths</em> defined
+                             *  on a <em>Link</em>.
+			     */
+    tRoadLonRef lonR0;	    /**< Integer value for the longitudinal reference of
+                             * \ref tRoadConPath::s0 "s0"
+                             * \note If the parent object of the <em>Connector
+                             *  path</em> is a <em>Junction</em>, the \ref
+                             *  RLR_Node0 "start point" of its <em>Reference
+                             *  line</em> must be used as reference.
+			     */
+    tRoadLonRef lonR1;	    /**< Integer value for the longitudinal reference of
+                             * \ref tRoadConPath::s1 "s1"
+			     * \note If the parent object of the <em>Connector
+                             *  path</em> is a <em>Junction</em>, the \ref
+                             *  RLR_Node1 "end point" of its <em>Reference
+                             *  line</em> must be used as reference.
+			     */
+    tObjId  objId0;	    /**< Object id of the <em>Path</em> the start of
+                             * this <em>Path</em> is connected to.
+			     */
+    tObjId  objId1;	    /**< Object id of the <em>Path</em> the end of this
+                             * <em>Path</em> is connected to
+			     */
+    int     vhclClassMask;  /**< Mask for vehicles allowed to use this
+			     * <em>Path</em>:\n
+                             * The binary system is used to generate
+			     * combinations of the vehicle classes #ROAD_VC_CAR,
+			     * #ROAD_VC_TRUCK, #ROAD_VC_BUS, #ROAD_VC_MCYCLE and
+			     * #ROAD_VC_BICYCLE (special macro: #ROAD_VC_ALL).
+			     */
+    
+} tRoadConPath;
+
+/** Function to add a <em>Connector path</em> to a <em>Link</em> or
+ *  <em>Junction</em> 
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the <em>Link</em> or <em>Junction</em>
+ * \param[in] conPath Pointer to a struct containing the data of the new
+ *  <em>Connector path</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the new <em>Connector path</em>
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadGetConPath() \see RoadSetConPath() \see RoadDeleteConPath()
+ */
+tObjId RoadAddConPath   (tRoad *road, tObjId objId,
+							 tRoadConPath *conPath);
+/** Function to get a <em>Connector path</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] conPathObjId Object id of the <em>Connector path</em>
+ * \param[out] conPath Pointer to a struct for the data of the <em>Connector
+ *  path</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddConPath() \see RoadSetConPath() \see RoadDeleteConPath()
+ */
+int    RoadGetConPath   (tRoad *road, tObjId conPathObjId,
+							 tRoadConPath *conPath);
+/** Function to set a <em>Connector path</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] conPathObjId Object id of the <em>Connector path</em>
+ * \param[in] conPath Pointer to a struct containing the data for the
+ *  <em>Connector path</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddConPath() \see RoadGetConPath() \see RoadDeleteConPath()
+ */
+int    RoadSetConPath   (tRoad *road, tObjId conPathObjId,
+							 tRoadConPath *conPath);
+/** Function to delete a <em>Connector path</em>\n
+ *  \note In case the <em>Connector path</em> that should be deleted belongs to
+ *   a <em>Route</em> this <em>Route</em> is cut off right before it.
+ *   Moreover, if a <em>Route</em> starts with the <em>Connector path</em>, it
+ *   is deleted as well.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] conPathObjId Object id of the <em>Connector path</em> that should
+ *  be deleted
+ * \see RoadAddConPath() \see RoadGetConPath() \see RoadSetConPath()
+ */
+void   RoadDeleteConPath(tRoad *road, tObjId conPathObjId);
+
+/** Function to create the <em>Connector paths</em> connecting the <em>Lane
+ *  paths</em> running into and out of a <em>Junction</em> along a certain
+ *  <em>Junction arm</em> to the <em>Lane paths</em> of all other <em>Junction
+ *  arms</em>
+ *  \ note Can not be used for \ref RJT_Virtual "virtual" <em>Junctions</em>.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] jArmObjId Object id of the <em>Junction arm</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadJunctionArmDeleteConPaths() \see RoadJunctionAutoConPath()
+ */
+int    RoadJunctionArmAddConPaths   (tRoad *road, tObjId jArmObjId);
+/** Function to remove the <em>Connector paths</em> connecting the <em>Lane
+ *  paths</em> running into and out of a <em>Junction</em> along a certain
+ *  <em>Junction arm</em>.
+ *  \ note Can not be used for \ref RJT_Virtual "virtual" <em>Junctions</em>.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] jArmObjId Object id of the <em>Junction arm</em>
+ * \param[in] force Parameter determining whether <em>Connector paths</em>
+ *  belonging to a <em>Route</em> should be deleted as well:
+ *  - 0 &harr; <em>Connector paths</em> that are part of the <em>Driving
+ * path</em> of a <em>Route</em> are not deleted.
+ *  - 1 &harr; All <em>Connector paths</em> are deleted.
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadJunctionArmAddConPaths() \see RoadJunctionDeleteAllConPaths()
+ */
+int    RoadJunctionArmDeleteConPaths(tRoad *road, tObjId jArmObjId, int force);
+
+/** Function to create the <em>Connector paths</em> connecting the <em>Lane
+ *  paths</em> running into and out of a <em>Junction</em> automatically
+ *  \note The corresponding <em>Reference lines</em> of the <em>Junction</em>
+ *   are created as well
+ * \param[in,out] road Handle of the road instance
+ * \param[in] jObjId Object id of the <em>Junction</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadJunctionDeleteAllConPaths() \see RoadJunctionArmAddConPaths()
+ */
+int    RoadJunctionAutoConPath      (tRoad *road, tObjId jObjId);
+/** Function to delete all <em>Connector paths</em> of a <em>Junction</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] jObjId Object id of the <em>Junction</em>
+ * \param[in] force Parameter determining whether <em>Connector paths</em>
+ *  belonging to a <em>Route</em> should be deleted as well:
+ *  - 0 &harr; <em>Connector paths</em> that are part of the <em>Driving
+ * path</em> of a <em>Route</em> are not deleted.
+ *  - 1 &harr; All <em>Connector paths</em> are deleted.
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadJunctionAutoConPath() \see RoadJunctionArmDeleteConPaths()
+ */
+int    RoadJunctionDeleteAllConPaths(tRoad *road, tObjId jObjId, int force);
+
+
+ /** @} */
+ /** \addtogroup PathsEdit
+  * @{
+  */
+/** Function to convert a given position in the (x,y)-plane of the global
+ *  IPGRoad coordinate system (Fr0) to the corresponding position in the local
+ *  coordinate system of a given <em>Path</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] pathObjId Object id of the <em>Path</em>
+ * \param[in] lonR Integer value for the \ref tRoadLonRef
+ *  "longitudinal reference" of the offset: Only <em>\ref RLR_Node0
+ *  "start point"</em> and <em>\ref RLR_Node1 "end point"</em> are allowed.
+ * \param[in,out] xy Given position in the (x,y)-plane of the global IPGRoad
+ *  coordinate system (Fr0)\n
+ *  In case the given position is not on a <em>Path</em>, the (x,y)-coordinates
+ *  of its projection on the <em>Path</em> are calculated.
+ * \param[out] suv Longitudinal unit vector at <b>xy</b>:
+ *  Unit vector in s-direction of the <em>Path</em>
+ * \param[out] dt Pointer to the derivation of the lateral offset of the
+ *  <em>Path</em> from the <em>Reference line</em> at the offset of the given
+ *  position\n
+ *  <em><b>Note</b></em>: Discarded in case <b>dt</b> is the NULL pointer.
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> offset in s-direction of the given position on the <em>Path</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadPathXY2SExt() \see RoadGetLinkST() \see RoadGetReflineST()
+ */
+double RoadPathXY2S   (tRoad *road, tObjId pathObjId, int lonR,
+				       double xy[2], double suv[2], double *dt);
+/** Function to convert a given position in the (x,y)-plane of the global
+ *  IPGRoad coordinate system (Fr0) to the corresponding position in the local
+ *  coordinate system of a given <em>Path</em>\n\n 
+ *  <b><em>Extended version:</em></b>
+ *  If the given position <b>xy</b> is in an environment of either the starting
+ *  or the end point of the <em>Path</em>, the offset on the <em>Path</em> with
+ *  reference to this position is considered as zero and the determined offset
+ *  <b>sPath</b> and the given (x,y)-position <b>xy</b> are corrected
+ *  accordingly. If moreover <b>notLonR</b> is chosen accordingly, this position
+ *  is used as longitudinal reference <b>lonR</b> and <b>sPath</b> is set to
+ *  zero.\n
+ *  In case the given position is not in the environment of one of these two
+ *  reference positions, either the given longitudinal reference <b>lonR</b> or
+ *  the <em>Path's</em> starting point (see <b>notLonR</b>) is used as reference
+ *  for the offset <b>sPath</b>. Moreover, the (x,y)-coordinates of the
+ *  projection of the given position <b>xy</b> on the <em>Path</em> are
+ *  calculated.
+ * \param[in] road Handle of the road instance
+ * \param[in] pathObjId Object id of the <em>Path</em>
+ * \param[in] notLonR Parameter determining whether the position given as
+ *  longitudinal reference should be used:
+ *  - 0 &harr; The given longitudinal reference <b>lonR</b> is used.
+ *  - 1 &harr; The <em>\ref RLR_Node0 "start point"</em> is used as longitudinal
+ *  reference, unless the given position is in an environment of of the <em>\ref
+ *  RLR_Node1 "end point"</em>.
+ * \param[in] eps Range before and after the allowed reference positions
+ *  restricting the environment where the given position is considered as equal
+ *  to the reference position
+ * \param[in,out] xy Given position in the (x,y)-plane of the global IPGRoad
+ *  coordinate system (Fr0)\n
+ *  In case the given position is not on a <em>Path</em>, the (x,y)-coordinates
+ *  of its projection on the <em>Path</em> are calculated.
+ * \param[out] suv Longitudinal unit vector at <b>xy</b>:\n
+ *  Unit vector in s-direction of the <em>Path</em>
+ * \param[out] dt Pointer to the derivation of the lateral offset of the
+ *  <em>Path</em> from the <em>Reference line</em> at the offset of the given
+ *  position\n
+ *  <em><b>Note</b></em>: Discarded in case <b>dt</b> is the NULL pointer.
+ * \param[out] sPath Offset in s-direction of the given position on the
+ *  <em>Path</em>
+ * \param[in,out] lonR Pointer to an integer value for the \ref tRoadLonRef
+ *  "longitudinal reference" of the offset: Only <em>\ref RLR_Node0
+ *  "start point"</em> and <em>\ref RLR_Node1 "end point"</em> are allowed.
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadPathXY2S() \see RoadGetLinkSTExt() \see RoadGetRefLineSTExt()
+ */
+int    RoadPathXY2SExt(tRoad *road, tObjId pathObjId, int notLonR, double eps,
+				       double xy[2], double suv[2], double *dt,
+						      double *sPath, int *lonR);
+
+/** Function to get all <em>Paths</em> splitting off from a given <em>Path</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] pathObjId Object id of the <em>Path</em>
+ * \param[out] objIds Pointer to an array for the object ids of the
+ *  <em>Paths</em> splitting off from the given one
+ * \param[out] s Pointer to an array for the offsets on the given <em>Path</em>
+ *  where the other <em>Paths</em> split off from it
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Paths</em> splitting off from the given one
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadPathGetPossibleInPaths() \see RoadDrvPathGetPossibleOutPaths()
+ * \see RoadDrvPathGetPossibleInPaths()
+ */
+int    RoadPathGetPossibleOutPaths(tRoad *road, tObjId pathObjId,
+						   tObjId **objIds, double **s);
+/** Function to get all <em>Paths</em> merging with a given <em>Path</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] pathObjId Object id of the <em>Path</em>
+ * \param[out] objIds Pointer to an array for the object ids of the
+ *  <em>Paths</em> merging with the given one
+ * \param[out] s Pointer to an array for the offsets on the given <em>Path</em>
+ *  where the other <em>Paths</em> merge with it
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Paths</em> merging with the given one
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadPathGetPossibleOutPaths() \see RoadDrvPathGetPossibleOutPaths()
+ * \see RoadDrvPathGetPossibleInPaths()
+ */
+int    RoadPathGetPossibleInPaths (tRoad *road, tObjId pathObjId,
+						   tObjId **objIds, double **s);
+
+
+/** @} */
+/******************************************************************************/
+/* +++ Routes +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup RoutesEdit
+ * @{
+ */
+/** Function to add a new <em>Route</em> to a road instance
+ * \param[in,out] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> object id of the new <em>Route</em>\n
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadDeleteRoute()
+ */
+tObjId RoadAddRoute   (tRoad *road);
+/** Function to delete a <em>Route</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em> that should be deleted
+ * \see RoadAddRoute()
+ */
+void   RoadDeleteRoute(tRoad *road, tObjId rObjId);
+
+/** Function to add a <em>Driving path</em> to a given <em>Route</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] routeObjId Object id of the <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the new <em>Driving path</em>
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ */
+tObjId RoadRouteAddDrvPath   (tRoad *road, tObjId routeObjId);
+/** Function to delete a <em>Driving path</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] drvPathObjId Object id of the <em>Driving path</em> that should be
+ *  deleted
+ */
+void   RoadRouteRemoveDrvPath(tRoad *road, tObjId drvPathObjId);
+
+/** Function to get all <em>Paths</em> splitting off from the last <em>Path</em>
+ *  of a given <em>Driving path</em>\n
+ *  This function can be used to determine which <em>Paths</em> can be added to
+ *  a <em>Driving path</em>.
+ * \param[in] road Handle of the road instance
+ * \param[in] drvPathObjId Object id of the <em>Driving path</em>
+ * \param[out] objIds Pointer to an array for the object ids of the
+ *  <em>Paths</em> splitting off from the last <em>Path</em> of the <em>Driving
+ *  path</em>
+ * \param[out] s Pointer to an array for the offsets on the last <em>Path</em>
+ *  of the <em>Driving path</em> where the other <em>Paths</em> split off from
+ *  it
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Paths</em> splitting off from the last <em>Path</em>
+ *  of the <em>Driving path</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadDrvPathGetPossibleInPaths() \see RoadPathGetPossibleOutPaths()
+ * \see RoadPathGetPossibleInPaths()
+ */
+int    RoadDrvPathGetPossibleOutPaths(tRoad *road, tObjId drvPathObjId,
+						   tObjId **objIds, double **s);
+/** Function to get all <em>Paths</em> merging with the first <em>Path</em>
+ *  of a given <em>Driving path</em>\n
+ *  This function can be used to determine which <em>Paths</em> can be added to
+ *  a <em>Driving path</em>.
+ * \param[in] road Handle of the road instance
+ * \param[in] drvPathObjId Object id of the <em>Driving path</em>
+ * \param[out] objIds Pointer to an array for the object ids of the
+ *  <em>Paths</em> merging with the first <em>Path</em> of the <em>Driving
+ *  path</em> 
+ * \param[out] s Pointer to an array for the offsets on the first <em>Path</em>
+ *  of the <em>Driving path</em> where the other <em>Paths</em> merge with it  
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Paths</em> merging with the first <em>Path</em> of the
+ *  <em>Driving path</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road
+ *  </table>.
+ * \see RoadDrvPathGetPossibleOutPaths() \see RoadPathGetPossibleOutPaths()
+ * \see RoadPathGetPossibleInPaths()
+ */
+int    RoadDrvPathGetPossibleInPaths (tRoad *road, tObjId drvPathObjId,
+						   tObjId **objIds, double **s);
+
+/** Function to add a <em>Path</em> to the end of a <em>Driving path</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] drvPathObjId Object id of the <em>Driving path</em>
+ * \param[in] pathObjId Object id of the <em>Path</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadAddPath2DrvPath(tRoad *road, tObjId drvPathObjId, tObjId pathObjId);
+
+/** Function to check whether a given <em>Route</em> is valid
+ * \param[in] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \return Flag indicating whether the <em>Route</em> is valid:
+ *  - 0 &harr; invalid
+ *  - 1 &harr; valid
+ */
+int    RoadRouteIsValid(tRoad *road, tObjId rObjId);
+/** Function to update a given <em>Route</em>:\n A final completion is
+ *  carried out in preparation for the evaluation of a <em>Route</em>.
+ * \param[in,out] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadRouteUpdate()
+ */
+int    RoadRouteFinish (tRoad *road, tObjId rObjId);
+/** Function to update all <em>Routes</em> of a road instance:\n
+ *  A final completion is carried out in preparation for the evaluation of the
+ *  <em>Routes</em>.
+ * \param[in,out] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadRouteFinish()
+ */
+int    RoadRouteUpdate (tRoad *road);
+
+/** Function to get the object id of the main <em>Route</em> of a road instance
+ * \param[in] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the main <em>Route</em> of the road instance
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadRouteSetMain()
+ */
+tObjId RoadRouteGetMain(tRoad *road);
+/** Function to set the main <em>Route</em> of a road instance
+ * \param[in,out] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadRouteGetMain()
+ */
+int    RoadRouteSetMain(tRoad *road, tObjId rObjId);
+
+
+/** @} */
+/***   The following functions can only be used with                        ***/
+/***                         route definitions of Version 6.0.X and lower   ***/
+
+
+/** @} */
+/** \addtogroup Routes6Edit
+ * @{
+ */
+/** Function to set the <em>Path mode</em> of a <em>Route</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \param[in] mode <em>Path mode</em> for the <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadSetPathMode()
+ */
+int    RoadRouteSetPathMode(tRoad *road, tObjId rObjId, tRoutePathMode mode);
+/** Function to automatically add <em>Paths</em> for a given <em>Route</em> to a
+ *  road instance
+ * \param[in,out] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \param[in] mode <em>Path mode</em> for the <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadRouteAutoPath   (tRoad *road, tObjId rObjId, tRoutePathMode mode);
+
+/** Function to get all <em>Links</em> that can be possibly added to the end of
+ *  a given <em>Route</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \param[out] objIds Pointer to an array for object ids of the <em>Links</em>
+ * \return Number of <em>Links</em>
+ */
+int    RoadRouteGetPossibleLinks(tRoad *road, tObjId rObjId, tObjId **objIds);
+/** Function to add a <em>Link</em> to the end of a <em>Route</em> 
+ * \param[in,out] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[in] reverse Parameter determining whether the added <em>Link</em>
+ *  should be reversed:
+ *  - 0 &harr; not reversed
+ *  - 1 &harr; reversed           
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadRouteAddLink         (tRoad *road, tObjId rObjId, 
+						    tObjId lObjId, int reverse);
+/** Function to remove the <em>Link</em> at the end of a <em>Route</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of sections of the <em>Route</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadRouteRemoveLastLink  (tRoad *road, tObjId rObjId);
+
+/** Function to reverse a <em>Route</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadRouteReverse(tRoad *road, tObjId rObjId);
+
+/** \cond
+ */
+int    RoadRouteSectionSetSVFac(tRoad *road, tObjId rObjId, int secId,
+						  double svFac0, double svFac1);
+
+/** \endcond
+ */
+/** Function to get the lateral offset of the <em>Path</em> of a given
+ *  <em>Route</em> from the <em>Reference line</em> at a certain offset
+ * \param[in] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \param[in] sRoute Offset on the <em>Route</em>
+ * \param[out] t Lateral offset of the <em>Path</em> of the <em>Route</em> at
+ *  <b>sRoute</b>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadRouteGetPathT(tRoad *road, tObjId rObjId, double sRoute, double *t);
+
+/** Function to add a node to a given section of a <em>Route</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] rObjId Object id of the <em>Route</em>
+ * \param[in] rSecId Identifier of the section of the <em>Route</em>
+ * \param[in] sRouteSec Offset from the start of the section of the
+ *  <em>Route</em>
+ * \param[in] latRSec Integer value for the \ref tRoadLatRef "lateral reference"
+ *  of <b>tOff</b> in route direction
+ * \param[in] tOff Lateral offset of the new node
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadRouteAddPathNode(tRoad *road, tObjId rObjId, int rSecId,
+	                    double sRouteSec, tRoadLatRef latRSec, double tOff);
+
+
+/** @} */
+/******************************************************************************/
+/* +++ Control Objects ++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+/** \addtogroup ControllersEdit
+ * @{
+ */
+//! Traffic light controller
+/** Struct for the parameters of a <em>Traffic light controller</em>
+ */
+typedef struct tRoadCtrlTrfLight {
+    char    *name;                  /**< Name of the <em>Traffic light
+                                     * controller</em>
+                                     */
+    int	    initialPhase;           /**< Integer value for the initial phase
+                                     * of the <em>Traffic light controller</em>:
+                                     *  - 0 &harr; off phase
+                                     *  - 1 &harr; green phase
+                                     *  - 2 &harr; yellow phase
+                                     *  - 3 &harr; red phase
+                                     *  - 4 &harr; red+yellow phase
+                                     */
+    double  timing[ROAD_NUM_TL_TIMING];/**< Duration of the different phases
+                                     * in seconds:
+                                     *  - 0 &harr; off phase
+                                     *  - 1 &harr; green phase
+                                     *  - 2 &harr; yellow phase
+                                     *  - 3 &harr; red phase
+                                     *  - 4 &harr; red+yellow phase
+                                     */
+    char    *startCond;             /**< Condition to trigger the starting
+                                     * of the <em>Traffic light controller</em>
+                                     */   
+} tRoadCtrlTrfLight;
+
+/** Function to add a new control object of arbitrary type to a road instance
+ * \param[in,out] road Handle of the road instance
+ * \param[in] type \ref tRoadObjectType "Type" of the new control object
+ * \param[in] ctrlObj Pointer to a struct containing the data for the new
+ * control object
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the new control object\n
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ * \see RoadGetCtrlObject() \see RoadSetCtrlObject() \see RoadDeleteCtrlObject()
+ */
+tObjId RoadAddCtrlObject   (tRoad *road, tRoadObjectType type, void *ctrlObj);
+/** Function to get a control object of arbitrary type
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the control object required
+ * \param[out] ctrlObj Pointer to a struct for the data of the control object
+ *  required
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddCtrlObject() \see RoadSetCtrlObject() \see RoadDeleteCtrlObject()
+ */
+int    RoadGetCtrlObject   (tRoad *road, tObjId objId, void *ctrlObj);
+/** Function to set a control object of arbitrary type
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the control object to be set
+ * \param[in] ctrlObj Pointer to a struct containing the data for the control
+ *  object to be set
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadAddCtrlObject() \see RoadGetCtrlObject() \see RoadDeleteCtrlObject()
+ */
+int    RoadSetCtrlObject   (tRoad *road, tObjId objId, void *ctrlObj);
+/** Function to delete a control object of arbitrary type
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the control object that should be deleted
+ * \see RoadAddCtrlObject() \see RoadGetCtrlObject() \see RoadSetCtrlObject()
+ */
+void   RoadDeleteCtrlObject(tRoad *road, tObjId objId);
+
+/** Function to add a <em>Traffic light</em> to a control object
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the control object
+ * \param[in] tlObjId Object id of the <em>Traffic light</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadCtrlTrfLightRemoveTrfLight() \see RoadCtrlTrfLightAddStop()
+ */
+int    RoadCtrlTrfLightAddTrfLight   (tRoad *road, tObjId objId, tObjId tlObjId);
+/** Function to remove a <em>Traffic light</em> from a control object
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the control object
+ * \param[in] tlObjId Object id of the <em>Traffic light</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadCtrlTrfLightAddTrfLight() \see RoadCtrlTrfLightRemoveStop()
+ */
+int    RoadCtrlTrfLightRemoveTrfLight(tRoad *road, tObjId objId, tObjId tlObjId);
+
+/** Function to add a <em>Stop marker</em> to a control object
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the control object
+ * \param[in] stopObjId Object id of the <em>Stop marker</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadCtrlTrfLightRemoveStop() \see RoadCtrlTrfLightAddTrfLight()
+ */
+int    RoadCtrlTrfLightAddStop   (tRoad *road, tObjId objId, tObjId stopObjId);
+/** Function to remove a <em>Stop marker</em> from a control object
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the control object
+ * \param[in] stopObjId Object id of the <em>Stop marker</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadCtrlTrfLightAddStop() \see RoadCtrlTrfLightRemoveTrfLight()
+ */
+int    RoadCtrlTrfLightRemoveStop(tRoad *road, tObjId objId, tObjId stopObjId);
+
+
+/** @} */
+/******************************************************************************/
+/* +++ Terrain ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup TerrainEdit
+ * @{
+ */
+/** Smoothing types:\n
+ *  Used for the terrain generation
+ * \warning Internal use only!
+ */
+typedef enum tRoadTGSmoothType {
+    RTGST_None = 0,	/**< <b>0</b> &nbsp; No smoothing
+			 */
+    RTGST_Linear,       /**< <b>1</b> &nbsp; Linear smoothing
+			 */
+    RTGST_Quadratic,	/**< <b>2</b> &nbsp; Quadratic smoothing
+			 */
+    RTGST_Cubic		/**< <b>3</b> &nbsp; Cubic smoothing
+			 */
+} tRoadTGSmoothType;
+
+//! Terrain
+/** Struct for the parameters defining the <em>Terrain</em>
+ */
+typedef struct tRoadTerrainParam {
+    double	  minGridSize;	  /**< Grid size on the highest level
+				   */
+    double	  minBBExt;	  /**< Minimum extension of the bounding box of 
+				   * the road instance in each direction
+                                   * \note If <b>minBBExt</b> < 1 or
+                                   * <b>minBBExt</b> > 20000, it will be
+                                   * set to 100.
+				   */
+    double	  zOffsetRange[2];/**< Minimum/maximum height offset of the
+                                   * <em>Terrain</em>
+				   */
+    char	  *heightMapDir;  /**< Data directory for the <em>.srtm</em>
+                                   * files containing a <em>\ref tHM
+                                   * "Height map"</em>
+    				   */
+    char 	  *texFName;	  /**< Name of the texture file
+                                   * \note A texture is optional.
+    				   */
+    char 	  *texMode;	  /**< Texture mode
+				   */
+    char 	  *texModulate;	  /**< Texture modulation
+				   */
+    char 	  *outFName;	  /**< Name of the output file
+                                   */
+    char 	  *outDir;	  /**< Output directory
+				   */
+    int  	  nLevels;	  /**< Number of levels
+				   */
+    tRoadTGSmoothType smoothType; /**< Smooth mode
+				   */
+    int 	  nSmoothIter;	  /**< Number of smoothing iterations
+				   */
+    int  	  tgMode;	  /**< Internal use only
+				   */
+    float 	  texX;		  /**< Scaling factor for the texture in
+				   * x-direction
+				   */
+    float 	  texY;		  /**< Scaling factor for the texture in
+				   * y-direction
+				   */
+    float 	  texModulateX;	  /**< Scaling factor for the modulation of the 
+				   * texture in x-direction 
+				   */
+    float 	  texModulateY;	  /**< Scaling factor for the modulation of the
+				   * texture in y-direction
+				   */
+} tRoadTerrainParam;
+
+
+/*** Terrain generation display options ***/
+
+/** Terrain generation: do not display\n
+ *  Flag for the function #RoadDrawTerrain() indicating that the
+ *  <em>Terrain</em> should not be displayed in the Scenario Editor.
+ */
+#define TG_None         (0)
+/** Terrain generation: display grid points\n
+ *  Flag for the function #RoadDrawTerrain() indicating that the
+ *  <em>Terrain</em> should be displayed in the Scenario Editor.
+ */
+#define TG_Triangles    (1<<0)
+/** Terrain generation: display grid points\n
+ *  Flag for the function #RoadDrawTerrain() indicating that the grid points of
+ *  the <em>Terrain</em> should be displayed in the Scenario Editor.
+ */
+#define TG_Grid         (1<<1)
+/** Terrain generation: display border lines\n
+ *  Flag for the function #RoadDrawTerrain() indicating that the lines of the
+ *  road borders used for the terrain generation should be displayed in the
+ *  Scenario Editor.
+ */
+#define TG_Polylines    (1<<2)
+/** Terrain generation: display border points\n
+ *  Flag for the function #RoadDrawTerrain() indicating that the points on the
+ *  road border used for the terrain generation should be displayed in the
+ *  Scenario Editor.
+ */
+#define TG_PolylinePts  (1<<3)
+
+
+/** Function to draw a <em>Terrain</em> for a given road instance
+ * \param[in] road Handle of the road instance
+ * \param[in] mask Parameter determining what display option should be used for
+ *  the terrain generation:\n
+ *  The binary system is used to generate combinations of the display options
+ *  #TG_Triangles, #TG_Grid, #TG_Polylines and #TG_PolylinePts (special macro:
+ *  #TG_None).
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road. 
+ *  </table>
+ */
+int    RoadDrawTerrain              (tRoad *road, unsigned int mask);
+/** Function to create a <em>Terrain</em> for a given road instance
+ * \param[in,out] road Handle of the road instance
+ * \param[in] param Struct with the parameters of the terrain
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadCreateTerrain            (tRoad *road, tRoadTerrainParam param);
+/** Function to create an object file for the <em>Terrain</em>
+ * \param[in] road Handle of the road instance
+ * \param[in] outDir Name of the output directory of the file
+ * \param[in] fname Name of the file
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road. 
+ *  </table>
+ */
+int    RoadCreateTerrainObjectsFile (tRoad *road, char *outDir, char *fname);
+/** Function to check if the creation of an object file for the <em>Terrain</em>
+ *  is necessary
+ * \param[in] road Handle of the road instance 
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> flag indicating whether the saving of the road instance is necessary:
+ *  <tr><td><td> 
+ *  - 0 &harr; creation of terrain objects file is not needed
+ *  - 1 &harr; creation of terrain objects file is needed
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadNeedTerrainObjectsFile(tRoad *road);
+
+//! Area
+/** Struct for the parameters of a landscape area
+ */
+typedef struct tRoadArea {
+    double zOffsetRange[2];     /**< Minimum/maximum height offset of the area
+				 */
+    char   *heightMapDir;	/**< Data directory for the <em>.srtm</em> files
+                                 * containing a <em>\ref tHM "Height map"</em>
+    				 */
+    char   *texAreaFName;	/**< Name of the texture file
+                                 * \note A texture is optional.
+    				 */
+    float  texX;		/**< Scaling factor for the texture in
+				 * x-direction
+				 */
+    float  texY;		/**< Scaling factor for the texture in
+				 * y-direction
+				 */
+    float  texModulateX;        /**< Scaling factor for the modulation of the 
+				 * texture in x-direction 
+				 */
+    float  texModulateY;        /**< Scaling factor for the modulation of the
+				 * texture in y-direction
+				 */
+    char   *texModulate;        /**< Texture modulation
+				 */
+} tRoadArea;
+
+/** Function to get the area attached to a given <em>Link</em>
+ *  \warning Not yet supported!
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[out] area Pointer to a struct for the data of the area
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadSetArea()
+ */
+int    RoadGetArea(tRoad *road, tObjId lObjId, tRoadArea *area);
+/** Function to set the area attached to a given <em>Link</em>
+ *  \warning Not yet supported!
+ * \param[in,out] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[in] area Pointer to a struct containing the data of the area
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \see RoadGetArea()
+ */
+int    RoadSetArea(tRoad *road, tObjId lObjId, tRoadArea *area);
+
+//! Polygon
+/** Struct for the parameters of a polygon
+ */
+typedef struct tRoadPolygon {    
+    double (*xyz)[3];		/**< Positions of the vertices  in the global
+				 * IPGRoad coordinate system (Fr0)
+				 */
+    int    n;			/**< Number of vertices of the polygon
+				 */
+} tRoadPolygon;
+
+
+/** @} */
+/******************************************************************************/
+/*    Getting child object ids                                                */
+/******************************************************************************/
+
+
+/** \addtogroup Edit
+ * @{
+ */
+/** Function to get the object ids of all <em>Junctions</em> of a road instance
+ * \ingroup JunctionsEdit
+ * \note The user is responsible to free the memory allocated for *objIds.
+ * \param[in] road Handle of the road instance
+ * \param[out] objIds Pointer to an array for the object ids of the
+ *  <em>Junctions</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Junctions</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetJunctionObjIds   (tRoad *road,                tObjId **objIds);
+/** Function to get the object ids of all <em>Junction arms</em> of a given
+ *  <em>Junction</em> 
+ * \ingroup JunctionsEdit
+ * \note The user is responsible to free the memory allocated for *objIds.
+ * \param[in] road Handle of the road instance
+ * \param[in] jObjId Object id of the <em>Junction</em>
+ * \param[out] objIds Pointer to an array for the object ids of the
+ *  <em>Junction arms</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Junction arms</em>\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetJunctionArmObjIds(tRoad *road, tObjId jObjId, tObjId **objIds);
+/** Function to get the object ids of all <em>Links</em> of a road instance
+ * \ingroup LinksEdit
+ * \note The user is responsible to free the memory allocated for *objIds.
+ * \param[in] road Handle of the road instance
+ * \param[out] objIds Pointer to an array for the object ids of the
+ *  <em>Links</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Links</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetLinkObjIds       (tRoad *road,                tObjId **objIds);
+/** Function to get the object ids of all <em>Lane sections</em> of a given
+ *  <em>Link</em>
+ * \ingroup LSEdit
+ * \note The user is responsible to free the memory allocated for *objIds.
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[out] objIds Pointer to an array for the object ids of the
+ *  <em>Lane sections</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Lane sections</em>\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetLaneSectionObjIds(tRoad *road, tObjId lObjId,  tObjId **objIds);
+/** Function to get the object ids of all <em>Lanes</em> on a certain side of a
+ *  given <em>Lane section</em>
+ * \ingroup LanesEdit
+ * \note The user is responsible to free the memory allocated for *objIds.
+ * \param[in] road Handle of the road instance
+ * \param[in] lsObjId Object id of the <em>Lane section</em>
+ * \param[in] side Side of the <em>Lane section</em>: \ref R_LEFT "left" or
+ *  \ref R_RIGHT "right"
+ * \param[out] objIds Pointer to an array for the object ids of the
+ *  <em>Lanes</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Lanes</em>\n
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetLaneObjIds       (tRoad *road, tObjId lsObjId,
+						  int side, tObjId **objIds);
+/** Function to get the object id of the <em>Height profile</em> of a certain
+ *  type defined on a given <em>Link</em>
+ * \ingroup ZprofilesEdit
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[in] type Type of <em>Height profile</em>: \ref ROT_LonZPElevation
+ *  "elevation", \ref ROT_LatZPSlope "slope" or \ref ROT_LatZPCamber "camber"
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> object id of the <em>Height profile</em>
+ *  <tr><td> In case of failure: <td> error code #ROAD_InvalidObjId
+ *  </table>
+ */
+tObjId RoadGetZProfileObjId    (tRoad *road, tObjId lObjId,
+							  tRoadObjectType type);
+/** Function to get the object ids of all <em>Reference lines</em> of a given
+ *  <em>Link</em> or <em>Junction</em>
+ * \note Each <em>Link</em> has exactly one <em>Reference line</em>.
+ * \ingroup RefLinesEdit
+ * \note The user is responsible to free the memory allocated for *objIds.
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the <em>Link</em> or <em>Junction</em>
+ * \param[out] objIds Pointer to an array for the object ids of the
+ *  <em>Reference lines</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Reference lines</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetRefLineObjIds    (tRoad *road, tObjId objId,  tObjId **objIds);
+/** Function to get the object ids of all <em>Segments</em> defined on a given
+ *  <em>Link</em> or <em>Reference line</em>
+ * \ingroup SegmentsEdit
+ * \note The user is responsible to free the memory allocated for *objIds.
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the <em>Link</em> or <em>Reference line</em>
+ * \param[out] objIds Pointer to an array for the object ids of the
+ *  <em>Segments</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Segments</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetSegmentObjIds    (tRoad *road, tObjId objId,  tObjId **objIds);
+/**  Function to get the object ids of all <em>Mounts</em> defined on a given
+ *  <em>Link</em> or <em>Reference line</em>
+ * \ingroup SOEdit
+ * \note The user is responsible to free the memory allocated for *objIds.
+ * \param[in] road Handle of the road instance
+ * \param[in] objId Object id of the <em>Link</em> or <em>Reference line</em>
+ * \param[out] objIds Pointer to an array for the object ids of the
+ *  <em>Mounts</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Mounts</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetMountObjIds      (tRoad *road, tObjId objId,  tObjId **objIds);
+/** Function to get the object ids of all <em>Traffic signs</em> of a given
+ *  <em>Mount</em>
+ * \ingroup SOEdit
+ * \note The user is responsible to free the memory allocated for *objIds.
+ * \param[in] road Handle of the road instance
+ * \param[in] mObjId Object id of the <em>Mount</em>
+ * \param[out] objIds Pointer to an array for the object ids of the
+ *  <em>Traffic signs</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Traffic signs</em> on the <em>Mount</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetTrfSignObjIds    (tRoad *road, tObjId mObjId, tObjId **objIds);
+/** Function to get the object ids of all <em>Traffic lights</em> of a given
+ *  <em>Mount</em>
+ * \ingroup SOEdit
+ * \note The user is responsible to free the memory allocated for *objIds.
+ * \param[in] road Handle of the road instance
+ * \param[in] mObjId Object id of the <em>Mount</em>
+ * \param[out] objIds Pointer to an array for the object ids of the
+ *  <em>Traffic lights</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Traffic lights</em> on the <em>Mount</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetTrfLightObjIds   (tRoad *road, tObjId mObjId, tObjId **objIds);
+/** Function to get the object ids of all <em>Routes</em> running along a given
+ *  <em>Link</em>
+ * \ingroup RoutesEdit
+ * \note The user is responsible to free the memory allocated for *objIds.
+ * \param[in] road Handle of the road instance
+ * \param[in] lObjId Object id of the <em>Link</em>
+ * \param[out] objIds Pointer to an array for the object ids of the
+ *  <em>Routes</em>
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> number of <em>Routes</em>
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadGetRouteObjIds      (tRoad *road, tObjId lObjId, tObjId **objIds);
+
+/******************************************************************************/
+/*    Converting types                                                        */
+/******************************************************************************/
+
+
+/** Function to convert an integer value representing a road object type to the
+ *  corresponding string\n
+ *  &rarr; \subpage ObjectTypes
+ *  "List of all object types and their corresponding strings"
+ * \ingroup ObjectsEdit
+ * \param[in] type Type of the road object
+ * \return String representing the type of road object\n Default: "Invalid"
+ */
+char  *RoadObjectType2Str(tRoadObjectType type);
+
+/** @} */
+/******************************************************************************/
+/* === Additional functions ================================================= */
+/******************************************************************************/
+
+
+/******************************************************************************/
+/* +++ Automatic completion +++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup AutoCompl
+ * @{
+ */
+/*** Automatic completion options ***/
+
+/** No automatic completion:\n
+ *  Flag for the function #RoadBuilderAutoCompletion() indicating that nothing
+ *  should be done automatically.
+ */
+#define AC_NONE                                  0       //    0
+/** Complete automatic completion:\n
+ *  Flag for the function #RoadBuilderAutoCompletion() indicating that
+ *  everything the function is able to do automatically should be done.
+ */
+#define AC_ALL                               (1<<0)      //    1
+/** Automatic completion: Adapt lateral offset of links\n
+ *  Flag for the function #RoadBuilderAutoCompletion() indicating that the link
+ *  lateral offset should be adapted automatically:
+ *  The lateral offset of each <em>Link</em> of a given road instance is set to
+ *  the offset of the middle of all <em>Lanes</em>.
+ */
+#define AC_LatOffLinks                       (1<<1)      //    2
+/** Automatic completion: Add lane borders\n
+ *  Flag for the function #RoadBuilderAutoCompletion() indicating that lane
+ *  borders should be added automatically:
+ *  The outer <em>Lane</em> on each side of a <em>Link's</em> <em>Reference
+ *  line</em> has to be of type <em>Road side</em>.
+ */
+#define AC_AddBorderLanes                    (1<<2)      //    4
+/** Automatic completion: Adapt junctions\n
+ *  Flag for the function #RoadBuilderAutoCompletion() indicating that the
+ *  <em>Junctions</em> should be adapted automatically:
+ *  The types of the <em>Junctions</em> is considered and the parameters of
+ *  <em>Junctions</em> of type \ref RJT_Direct "direct" are checked and adapted
+ *  automatically.
+ */
+#define AC_Junctions                         (1<<3)      //    8
+/** Automatic completion: Adapt lateral offset of ramps\n
+ *  Flag for the function #RoadBuilderAutoCompletion() indicating that the ramp
+ *  lateral offset should be adapted automatically: To all arms beside the main
+ *  arms a lateral offset is added in order to prevent their overlapping with
+ *  one of the main arms.
+ */
+#define AC_LatOffRamps                       (1<<4)      //   16
+/** Automatic completion: Adapt lanes\n
+ *  Flag for the function #RoadBuilderAutoCompletion() indicating that the
+ *  number and width of the <em>Lanes</em> should be adapted automatically: The
+ *  number of <em>Lanes</em> leading into a ramp must be equal to the number of
+ *  <em>Lanes</em> running out of it. Moreover, the <em>Lanes</em> need to have
+ *  matching widths.
+ */
+#define AC_Lanes                             (1<<5)      //   32
+/** Automatic completion: Add bridges\n
+ *  Flag for the function #RoadBuilderAutoCompletion() indicating that
+ *  <em>Bridges</em> should be added automatically: 
+ *  In case a <em>Link</em> intersects itself or another <em>Link</em>, a
+ *  <em>Bridge</em> is added to provide a suitable presentation of the <em>Road
+ *  network</em>.
+ */
+#define AC_Bridges                           (1<<6)      //   64
+/** Automatic completion: Add road markings\n
+ *  Flag for the function #RoadBuilderAutoCompletion() indicating that the
+ *  <em>Road markings</em> should be added automatically:
+ *  To each <em>Link</em> and each <em>Junction</em> of a given road instance
+ *  the default <em>Road markings</em> are added automatically. The already
+ *  existing <em>Road markings</em> attached to the <em>Junctions</em> are
+ *  deleted.
+ */
+#define AC_RoadMarkings                      (1<<7)      //  128
+/** Automatic completion: Check unconnected link nodes\n
+ *  Flag for the function #RoadBuilderAutoCompletion() indicating that it should
+ *  be checked automatically whether unconnected link nodes end in nearly the
+ *  same coordinates:
+ *  In case two ends of the same <em>Link</em> or different <em>Links</em> end
+ *  in a sufficiently small environment of each other, a <em>Junction</em>
+ *  connecting them is defined.
+ */
+#define AC_CheckUnconnectedLinkNodes         (1<<8)      //  256
+/** Automatic completion: Check elevation\n
+ *  Flag for the function #RoadBuilderAutoCompletion() indicating that at 
+ *  junctions differences in height should be adapted automatically:
+ *  For each <em>Junction</em> of a given road instance for all <em>Junction
+ *  arms</em> is checked, whether they are connected to a <em>Link</em> to which
+ *  an <em>Elevation profile</em> is attached. If this is the case and the first
+ *  or last node of the profile is too near to a link node, it is adapted to the
+ *  height of the related <em>Junction's</em> center.
+ */
+#define AC_CheckElevationConsistency         (1<<9)      //  512
+/** Automatic completion: Optimize junction bezier patch\n
+ *  Flag for the function #RoadBuilderAutoCompletion() indicating that invalid
+ *  junction patches should be optimized.
+ */
+#define AC_OptimizeJunctionPatches           (1<<10)     // 1024
+/** Automatic completion: Clean up ramp junctions\n
+ *  Flag for the function #RoadBuilderAutoCompletion() indicating
+ */
+#define AC_CleanUpRampJunctions              (1<<11)     // 2048
+/** Automatic completion: Check simple and extended junctions\n
+ *  Flag for the function #RoadBuilderAutoCompletion() indicating that invalid
+ *  \ref RJT_Simple "simple" <em>Junctions</em> should be transformed to
+ *  \ref RJT_Extended "extended" <em>Junctions</em> automatically.
+ *  The surface of these <em>Junctions</em> is fit to the connected
+ *  <em>Links</em> and connected <em>Links</em>, which are inside an extended
+ *  <em>Junction</em>, are removed.
+ */
+#define AC_CheckSimpleAndExtendedJunctions   (1<<12)     // 4096
+
+/** Function to check, add and adapt different objects of the road
+ * \param[in,out] road Handle of the road instance
+ * \param[in] settings Parameter determining what should be done by the
+ *  function:\n
+ *  The binary system is used to generate combinations of the automatic
+ *  completion options #AC_LatOffLinks, #AC_AddBorderLanes, #AC_Junctions,
+ *  #AC_LatOffRamps, #AC_Lanes, #AC_Bridges, #AC_RoadMarkings,
+ *  #AC_CheckUnconnectedLinkNodes and #AC_CheckElevationConsistency (special
+ *  macros: #AC_NONE/#AC_ALL).
+ */
+void   RoadBuilderAutoCompletion(tRoad *road, int settings);
+/** Function to delete and create the road markings of a given <em>Junction</em>
+ * \param[in,out] road Handle of the road instance
+ * \param[in] objId Object id of the <em>Junction</em>
+ */
+void   RoadObjectAutoRoadMarking(tRoad *road, tObjId objId);
+
+/** Function to set a flag indicating that bridges should be added automatically
+ *  to the <em>.obj</em> file of a road instance
+ * \param[in,out] road Handle of the road instance
+ * \param[in] autoBridge Parameter determining whether bridges should be set
+ *  automatically:
+ *  - 0 &harr; no automatic addition of bridges
+ *  - 1 &harr; automatic addition of bridges
+ * \deprecated This function was implemented for road definitions of the former
+ *  road 4.5 format and has no effect.
+ */
+void   RoadSetAutoBridge(tRoad *road, int autoBridge);
+/** Function to get the flag indicating that bridges should be added
+ *  automatically to the <em>.obj</em> file of a road instance\n
+ *  Default: autoBridge = 0
+ * \param[in] road Handle of the road instance
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success:
+ *  <td> flag indicating whether bridges should be set automatically:
+ *  <tr><td><td>
+ *  - 0 &harr; no automatic addition of bridges
+ *  - 1 &harr; automatic addition of bridges
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ * \deprecated This function was implemented for road definitions of the former
+ *  road 4.5 format and has no effect.
+ */
+int    RoadGetAutoBridge(tRoad *road);
+
+
+
+/** @} */
+/******************************************************************************/
+/* === Road Independent Functions =========================================== */
+/******************************************************************************/
+
+
+/******************************************************************************/
+/* +++ Polynomials ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+/******************************************************************************/
+
+
+/** \addtogroup Poly
+ * @{
+ */
+/** Function to move a given polynomial of at most third order along the x- and
+ *  y-axis
+ * \param[in] order Order of the polynomial (at most three)
+ * \param[in] xOff Distance the polynomial should be moved in x-direction
+ * \param[in] yOff Distance the polynomial should be moved in y-direction
+ * \param[in] cIn Array with the coefficients of the given polynomial
+ *  (size: <b>order</b>+1)
+ * \param[out] cOut Array for the coefficients of the shifted polynomial
+ *  (size: <b>order</b>+1)
+ * \return <table frame=void  cellspacing="0" frame=void  cellspacing="0">
+ *  <tr><td style="width:120px"> In case of success: <td> #ROAD_Ok
+ *  <tr><td> In case of failure:
+ *  <td> see \ref ErrorCodes "error codes" for the road.
+ *  </table>
+ */
+int    RoadMovePolynom  (int order, double xOff, double yOff,
+						     double *cIn, double *cOut);
+/** Function to scale a given polynomial in x- and y-direction
+ * \param[in] order Order of the polynomial
+ * \param[in] xFac Scaling factor in x-direction
+ * \param[in] yFac Scaling factor in y-direction
+ * \param[in] cIn Array with the coefficients of the given polynomial
+ *  (size: <b>order</b>+1)
+ * \param[out] cOut Array for the coefficients of the scaled polynomial
+ *  (size: <b>order</b>+1)
+ */
+void   RoadScalePolynom (int order, double xFac, double yFac,
+						     double *cIn, double *cOut);
+/** Function to mirror a given polynomial of at most third order in the interval
+ *  [0, <b>xOff</b>] along the axis parallel to the y-axis running through the
+ *  middle of the interval (x = <b>xOff</b>/2)
+ * \param[in] order Order of the polynomial (at most three)
+ * \param[in] xOff Offset in x-direction where the considered interval ends
+ * \param[in] cIn Array with the coefficients of the given polynomial
+ *  (size: <b>order</b>+1)
+ * \param[out] cOut Array for the coefficients of the mirrored polynomial
+ *  (size: <b>order</b>+1)
+ */
+void   RoadMirrorPolynom(int order, double xOff,
+						     double *cIn, double *cOut);
+
+/** Function to determine the extrema of a given polynomial of at most third
+ *  order in the interval [0, <b>xOff</b>]
+ * \param[in] xOff Offset in x-direction where the considered interval ends
+ * \param[in] c Array with the coefficients of the given polynomial
+ *  (size: <b>order</b>+1)
+ * \param[in] min Array for the minima of the polynomial
+ * \param[in] max Array for the maxima of the polynomial
+ * \return #ROAD_Ok
+ */
+int    RoadGetCubicPolynomExtrema(double xOff, double c[4],
+						      double *min, double *max);
+
+
+/** @} */
+
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* ROAD_BUILDER_H */

src/test/testipgroad/testipgroad.pro

@@ -0,0 +1,38 @@
+QT -= gui
+
+CONFIG += c++11 console
+CONFIG -= app_bundle
+
+# The following define makes your compiler emit warnings if you use
+# any Qt feature that has been marked deprecated (the exact warnings
+# depend on your compiler). Please consult the documentation of the
+# deprecated API in order to know how to port your code away from it.
+DEFINES += QT_DEPRECATED_WARNINGS
+
+# You can also make your code fail to compile if it uses deprecated APIs.
+# In order to do so, uncomment the following line.
+# You can also select to disable deprecated APIs only up to a certain version of Qt.
+#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
+
+SOURCES += \
+        main.cpp \
+        rd5route.cpp
+
+# Default rules for deployment.
+qnx: target.path = /tmp/$${TARGET}/bin
+else: unix:!android: target.path = /opt/$${TARGET}/bin
+!isEmpty(target.path): INSTALLS += target
+
+HEADERS += \
+    rd5route.h \
+    road.h \
+    roadbuilder.h
+
+#file:///C:/Users/yuchu/Downloads/libinfofile.a
+
+#DEFINES += TESTC
+
+
+LIBS += -L$$PWD/./ -lipgroadbuilder -linfofile   -lm -lws2_32 -lpsapi -lwinspool -lmxml
+
+