1 /****************************************************************************/ 2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo 3 // Copyright (C) 2008-2019 German Aerospace Center (DLR) and others. 4 // This program and the accompanying materials 5 // are made available under the terms of the Eclipse Public License v2.0 6 // which accompanies this distribution, and is available at 7 // http://www.eclipse.org/legal/epl-v20.html 8 // SPDX-License-Identifier: EPL-2.0 9 /****************************************************************************/ 10 /// @file NIImporter_DlrNavteq.h 11 /// @author Daniel Krajzewicz 12 /// @author Michael Behrisch 13 /// @author Jakob Erdmann 14 /// @date Mon, 14.04.2008 15 /// @version $Id$ 16 /// 17 // Importer for networks stored in Elmar's format 18 /****************************************************************************/ 19 #ifndef NIImporter_DlrNavteq_h 20 #define NIImporter_DlrNavteq_h 21 22 23 // =========================================================================== 24 // included modules 25 // =========================================================================== 26 #include <config.h> 27 28 #include <string> 29 #include <map> 30 #include <utils/common/UtilExceptions.h> 31 #include <utils/importio/LineHandler.h> 32 33 34 // =========================================================================== 35 // class declarations 36 // =========================================================================== 37 class NBEdgeCont; 38 class NBNetBuilder; 39 class NBNodeCont; 40 class NBTrafficLightLogicCont; 41 class NBTypeCont; 42 class OptionsCont; 43 class PositionVector; 44 class StringTokenizer; 45 46 47 // =========================================================================== 48 // class definitions 49 // =========================================================================== 50 /** 51 * @class NIImporter_DlrNavteq 52 * @brief Importer for networks stored in Elmar's format 53 * 54 */ 55 class NIImporter_DlrNavteq { 56 public: 57 /** @brief Loads content of the optionally given dlr-navteq (aka Elmar-fomat) folder 58 * 59 * If the option "dlr-navteq-prefix" is set, the file(s) stored therein is read and 60 * the network definition stored therein is stored within the given network 61 * builder. 62 * 63 * If the option "dlr-navteq-prefix" is not set, this method simply returns. 64 * 65 * @param[in] oc The options to use 66 * @param[in] nb The network builder to fill 67 */ 68 static void loadNetwork(const OptionsCont& oc, NBNetBuilder& nb); 69 70 /// @brief scaling factor for geo coordinates (DLRNavteq format uses this to increase floating point precisions) 71 static const std::string GEO_SCALE; 72 73 /// @brief magic value for undefined stuff 74 static const std::string UNDEFINED; 75 76 protected: 77 /** 78 * @class NodesHandler 79 * @brief Importer of nodes stored in unsplit elmar format 80 * 81 * Being a LineHandler, this class retrieves each line from a LineReader 82 * and parses these information assuming they contain node definitions 83 * in DLRNavteq's unsplit format. 84 */ 85 class NodesHandler : public LineHandler { 86 public: 87 /** @brief Constructor 88 * @param[in, filled] nc The node control to insert loaded nodes into 89 * @param[in] file The name of the parsed file 90 * @param[in, geoms] geoms Storage for read edge geometries 91 */ 92 NodesHandler(NBNodeCont& nc, const std::string& file, 93 std::map<std::string, PositionVector>& geoms); 94 95 96 /// @brief Destructor 97 ~NodesHandler(); 98 99 100 /** @brief Parsing method 101 * 102 * Implementation of the LineHandler-interface called by a LineReader; 103 * interprets the retrieved information and stores it into "myNodeCont". 104 * Additionally, edge geometries are parsed and stored into "myGeoms". 105 * 106 * @param[in] result The read line 107 * @return Whether the parsing shall continue 108 * @exception ProcessError if something fails 109 * @see LineHandler::report 110 */ 111 bool report(const std::string& result); 112 113 114 protected: 115 // @brief The node container to store parsed nodes into 116 NBNodeCont& myNodeCont; 117 118 /// @brief A container for parsed geometries 119 std::map<std::string, PositionVector>& myGeoms; 120 121 122 private: 123 /// @brief Invalidated copy constructor. 124 NodesHandler(const NodesHandler&); 125 126 /// @brief Invalidated assignment operator. 127 NodesHandler& operator=(const NodesHandler&); 128 129 }; 130 131 132 /** 133 * @class EdgesHandler 134 * @brief Importer of edges stored in unsplit elmar format 135 * 136 * Being a LineHandler, this class retrieves each line from a LineReader 137 * and parses these information assuming they contain edge definitions 138 * in DLRNavteq's unsplit format. 139 */ 140 class EdgesHandler : public LineHandler { 141 142 public: 143 /** @brief Constructor 144 * @param[in] nc The node control to retrieve nodes from 145 * @param[in, filled] ec The edge control to insert loaded edges into 146 * @param[in] tc The type control to retrieve types from 147 * @param[in] file The name of the parsed file 148 * @param[in] geoms The previously read edge geometries 149 * @param[in] streetNames The previously read street names 150 */ 151 EdgesHandler(NBNodeCont& nc, NBEdgeCont& ec, NBTypeCont& tc, 152 const std::string& file, 153 std::map<std::string, PositionVector>& geoms, 154 std::map<std::string, std::string>& streetNames); 155 156 157 /// @brief Destructor 158 ~EdgesHandler(); 159 160 161 /** @brief Parsing method 162 * 163 * Implementation of the LineHandler-interface called by a LineReader; 164 * interprets the retrieved information and stores it into "myEdgeCont". 165 * @param[in] result The read line 166 * @return Whether the parsing shall continue 167 * @exception ProcessError if something fails 168 * @see LineHandler::report 169 */ 170 bool report(const std::string& result); 171 172 173 protected: 174 /// @brief The node container to get the referenced nodes from 175 NBNodeCont& myNodeCont; 176 177 /// @brief The edge container to store loaded edges into 178 NBEdgeCont& myEdgeCont; 179 180 /// @brief The type container to retrieve type info from 181 NBTypeCont& myTypeCont; 182 183 /// @brief Previously read edge geometries (manipulated during use) 184 std::map<std::string, PositionVector>& myGeoms; 185 186 /// @brief Previously read streat names (non-const because operate[] is more convenient) 187 std::map<std::string, std::string>& myStreetNames; 188 189 /// @brief Whether node positions shall not be added to the edge's geometry 190 bool myTryIgnoreNodePositions; 191 192 /// @brief version number of current file 193 double myVersion; 194 195 /// @brief the version number of the edge file being parsed 196 std::vector<int> myColumns; 197 198 /// @brief the file being parsed 199 const std::string myFile; 200 201 static const int MISSING_COLUMN; 202 203 enum ColumnName { 204 LINK_ID = 0, 205 NODE_ID_FROM, 206 NODE_ID_TO, 207 BETWEEN_NODE_ID, 208 LENGTH, 209 VEHICLE_TYPE, 210 FORM_OF_WAY, 211 BRUNNEL_TYPE, 212 FUNCTIONAL_ROAD_CLASS, 213 SPEED_CATEGORY, 214 NUMBER_OF_LANES, 215 SPEED_LIMIT, 216 SPEED_RESTRICTION, 217 NAME_ID1_REGIONAL, 218 NAME_ID2_LOCAL, 219 HOUSENUMBERS_RIGHT, 220 HOUSENUMBERS_LEFT, 221 ZIP_CODE, 222 AREA_ID, 223 SUBAREA_ID, 224 THROUGH_TRAFFIC, 225 SPECIAL_RESTRICTIONS, 226 EXTENDED_NUMBER_OF_LANES, 227 ISRAMP, 228 CONNECTION 229 }; 230 231 std::string getColumn(const StringTokenizer& st, ColumnName name, const std::string fallback = ""); 232 233 private: 234 /// @brief build the street name for the given ids 235 std::string getStreetNameFromIDs(const std::string& regionalID, const std::string& localID) const; 236 237 238 private: 239 /// @brief Invalidated copy constructor. 240 EdgesHandler(const EdgesHandler&); 241 242 /// @brief Invalidated assignment operator. 243 EdgesHandler& operator=(const EdgesHandler&); 244 245 }; 246 247 248 /** 249 * @class TrafficlightsHandler 250 * @brief Importer of traffic lights stored in DLRNavteq's (aka elmar) format 251 * 252 * Being a LineHandler, this class retrieves each line from a LineReader 253 * and parses these information assuming they contain traffic light definitions 254 * in DLRNavteq's format. 255 */ 256 class TrafficlightsHandler : public LineHandler { 257 public: 258 /** @brief Constructor 259 * @param[in] nc The node control to retrieve nodes from 260 * @param[in, filled] tlc The traffic lights container to fill 261 * @param[in] file The name of the parsed file 262 */ 263 TrafficlightsHandler(NBNodeCont& nc, NBTrafficLightLogicCont& tlc, 264 NBEdgeCont& ne, const std::string& file); 265 266 267 /// @brief Destructor 268 ~TrafficlightsHandler(); 269 270 271 /** @brief Parsing method 272 * 273 * Implementation of the LineHandler-interface called by a LineReader; 274 * interprets the retrieved information and alters the nodes. 275 * @param[in] result The read line 276 * @return Whether the parsing shall continue 277 * @exception ProcessError if something fails 278 * @see LineHandler::report 279 */ 280 bool report(const std::string& result); 281 282 283 protected: 284 /// @brief The node container to get the referenced nodes from 285 NBNodeCont& myNodeCont; 286 287 /// @brief The traffic lights container to add built tls to 288 NBTrafficLightLogicCont& myTLLogicCont; 289 290 /// @brief The edge container to get the referenced edges from 291 NBEdgeCont& myEdgeCont; 292 293 294 private: 295 /// @brief Invalidated copy constructor. 296 TrafficlightsHandler(const TrafficlightsHandler&); 297 298 /// @brief Invalidated assignment operator. 299 TrafficlightsHandler& operator=(const TrafficlightsHandler&); 300 301 }; 302 303 304 /** 305 * @class NamesHandler 306 * @brief Importer of street names in DLRNavteq's (aka elmar) format 307 * 308 * Being a LineHandler, this class retrieves each line from a LineReader 309 * and parses these information assuming they contain name definitions 310 * in DLRNavteq's format. 311 */ 312 class NamesHandler : public LineHandler { 313 public: 314 /** @brief Constructor 315 * @param[in] file The name of the parsed file 316 * @param[filled] streetNames output container for read names 317 */ 318 NamesHandler(const std::string& file, std::map<std::string, std::string>& streetNames); 319 320 321 /// @brief Destructor 322 ~NamesHandler(); 323 324 325 /** @brief Parsing method 326 * 327 * Implementation of the LineHandler-interface called by a LineReader; 328 * interprets the retrieved information and stores the streetNames 329 * @param[in] result The read line 330 * @return Whether the parsing shall continue 331 * @exception ProcessError if something fails 332 * @see LineHandler::report 333 */ 334 bool report(const std::string& result); 335 336 337 protected: 338 /// @brief The container for storing read names 339 std::map<std::string, std::string>& myStreetNames; 340 341 342 private: 343 /// @brief Invalidated copy constructor. 344 NamesHandler(const NamesHandler&); 345 346 /// @brief Invalidated assignment operator. 347 NamesHandler& operator=(const NamesHandler&); 348 349 }; 350 351 352 /** 353 * @class TimeRestrictionsHandler 354 * @brief Importer of street names in DLRNavteq's (aka elmar) format 355 * 356 * Being a LineHandler, this class retrieves each line from a LineReader 357 * and parses these information assuming they contain name definitions 358 * in DLRNavteq's format. 359 */ 360 class TimeRestrictionsHandler : public LineHandler { 361 public: 362 /** @brief Constructor 363 * @param[in] file The name of the parsed file 364 * @param[filled] streetNames output container for read names 365 */ 366 TimeRestrictionsHandler(NBEdgeCont& ec, NBDistrictCont& dc, time_t constructionTime); 367 368 369 /// @brief Destructor 370 ~TimeRestrictionsHandler(); 371 372 373 /** @brief Parsing method 374 * 375 * Implementation of the LineHandler-interface called by a LineReader; 376 * interprets the retrieved information and stores the streetNames 377 * @param[in] result The read line 378 * @return Whether the parsing shall continue 379 * @exception ProcessError if something fails 380 * @see LineHandler::report 381 */ 382 bool report(const std::string& result); 383 384 void printSummary(); 385 386 387 protected: 388 /// @brief The edge container 389 NBEdgeCont& myEdgeCont; 390 NBDistrictCont& myDistrictCont; 391 392 /// @brief The date for which to build the network (in case some edges are still under construction) 393 time_t myConstructionTime; 394 time_t myCS_min; 395 time_t myCS_max; 396 int myConstructionEntries; 397 int myNotStarted; 398 int myUnderConstruction; 399 int myFinished; 400 int myRemovedEdges; // only counts those not already removed through other options 401 402 403 private: 404 /// @brief Invalidated copy constructor. 405 TimeRestrictionsHandler(const TimeRestrictionsHandler&); 406 407 /// @brief Invalidated assignment operator. 408 TimeRestrictionsHandler& operator=(const TimeRestrictionsHandler&); 409 410 }; 411 412 413 /** 414 * @class ProhibitionHandler 415 * @brief Imports prohibitions regarding connectivity 416 * 417 * Being a LineHandler, this class retrieves each line from a LineReader 418 * and parses these information assuming they contain prohibited manoeuver definitions 419 * in DLRNavteq's format. 420 */ 421 class ProhibitionHandler : public LineHandler { 422 public: 423 /** @brief Constructor 424 * @param[in] file The name of the parsed file 425 * @param[filled] streetNames output container for read names 426 */ 427 ProhibitionHandler(NBEdgeCont& ne, const std::string& file, time_t constructionTime); 428 429 430 /// @brief Destructor 431 ~ProhibitionHandler(); 432 433 434 /** @brief Parsing method 435 * 436 * Implementation of the LineHandler-interface called by a LineReader; 437 * interprets the retrieved information and stores the streetNames 438 * @param[in] result The read line 439 * @return Whether the parsing shall continue 440 * @exception ProcessError if something fails 441 * @see LineHandler::report 442 */ 443 bool report(const std::string& result); 444 445 446 protected: 447 /// @brief The edge container to store loaded edges into 448 NBEdgeCont& myEdgeCont; 449 const std::string myFile; 450 double myVersion; 451 time_t myConstructionTime; 452 453 454 private: 455 /// @brief Invalidated copy constructor. 456 ProhibitionHandler(const ProhibitionHandler&); 457 458 /// @brief Invalidated assignment operator. 459 ProhibitionHandler& operator=(const ProhibitionHandler&); 460 461 }; 462 463 464 /** 465 * @class ConnectedLanesHandler 466 * @brief Imports prohibitions regarding connectivity 467 * 468 * Being a LineHandler, this class retrieves each line from a LineReader 469 * and parses these information assuming they contain prohibited manoeuver definitions 470 * in DLRNavteq's format. 471 */ 472 class ConnectedLanesHandler : public LineHandler { 473 public: 474 /** @brief Constructor 475 * @param[in] file The name of the parsed file 476 * @param[filled] streetNames output container for read names 477 */ 478 ConnectedLanesHandler(NBEdgeCont& ne); 479 480 481 /// @brief Destructor 482 ~ConnectedLanesHandler(); 483 484 485 /** @brief Parsing method 486 * 487 * Implementation of the LineHandler-interface called by a LineReader; 488 * interprets the retrieved information and stores the streetNames 489 * @param[in] result The read line 490 * @return Whether the parsing shall continue 491 * @exception ProcessError if something fails 492 * @see LineHandler::report 493 */ 494 bool report(const std::string& result); 495 496 497 protected: 498 /// @brief The edge container to store loaded edges into 499 NBEdgeCont& myEdgeCont; 500 501 502 private: 503 /// @brief Invalidated copy constructor. 504 ConnectedLanesHandler(const ConnectedLanesHandler&); 505 506 /// @brief Invalidated assignment operator. 507 ConnectedLanesHandler& operator=(const ConnectedLanesHandler&); 508 509 }; 510 511 512 static double readVersion(const std::string& line, const std::string& file); 513 static int readPrefixedInt(const std::string& s, const std::string& prefix, int fallBack = 0); 514 static time_t readTimeRec(const std::string& start, const std::string& duration); 515 static time_t readDate(const std::string& yyyymmdd); 516 517 }; 518 519 520 #endif 521 522 /****************************************************************************/ 523 524