Eclipse SUMO - Simulation of Urban MObility
NIImporter_Vissim.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-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 /****************************************************************************/
18 // -------------------
19 /****************************************************************************/
20 
21 
22 // ===========================================================================
23 // included modules
24 // ===========================================================================
25 #include <config.h>
26 
27 
28 #include <string>
29 #include <fstream>
34 #include <netbuild/NBNetBuilder.h>
35 #include "NIImporter_Vissim.h"
91 
92 
93 #include "tempstructs/NIVissimTL.h"
106 
108 #include <utils/xml/XMLSubSys.h>
113 
114 #include <netbuild/NBEdgeCont.h> // !!! only for debugging purposes
115 
116 
117 // ===========================================================================
118 // static variables
119 // ===========================================================================
128  { "linkPolyPoint", NIImporter_Vissim::VISSIM_TAG_LINKPOLYPOINT },
130  { "fromLinkEndPt", NIImporter_Vissim::VISSIM_TAG_FROM },
131  { "toLinkEndPt", NIImporter_Vissim::VISSIM_TAG_TO },
135  { "intObjectRef", NIImporter_Vissim::VISSIM_TAG_INTOBJECTREF },
136  { "desSpeedDecision", NIImporter_Vissim::VISSIM_TAG_SPEED_DECISION },
137  {
138  "desSpeedDistribution",
140  },
141  {
142  "speedDistributionDataPoint",
144  },
145  {
146  "vehicleRoutingDecisionStatic",
148  },
149  {
150  "vehicleRouteStatic",
152  },
153  { "conflictArea", NIImporter_Vissim::VISSIM_TAG_CA },
155 };
156 
157 
159  { "no", NIImporter_Vissim::VISSIM_ATTR_NO }, //id
171  { "intLink", NIImporter_Vissim::VISSIM_ATTR_INTLINK }, //edgeID
183 };
184 
185 
186 // ===========================================================================
187 // method definitions
188 // ===========================================================================
189 // ---------------------------------------------------------------------------
190 // static methods (interface in this case)
191 // ---------------------------------------------------------------------------
192 void
194  if (!oc.isSet("vissim-file")) {
195  return;
196  }
197  NIImporter_Vissim(nb).load(oc);
198 }
199 
200 
201 // ---------------------------------------------------------------------------
202 // definitions of NIVissimXMLHandler_Streckendefinition-methods
203 // ---------------------------------------------------------------------------
205  //std::map<int, VissimXMLEdge>& toFill)
206  nodeMap& elemData)
207  : GenericSAXHandler(vissimTags, VISSIM_TAG_NOTHING,
208  vissimAttrs, VISSIM_ATTR_NOTHING,
209  "vissim - file"),
210  myElemData(elemData),
211  myHierarchyLevel(0),
212  isConnector(false) {
213  myElemData.clear();
214 }
215 
217 
218 void
220  myHierarchyLevel++;
221 
222  // finding an actual LINK
223  if (element == VISSIM_TAG_LINK) {
224  //parse all links
225  bool ok = true;
226  int id = attrs.get<int>(VISSIM_ATTR_NO, nullptr, ok);
227  myLastNodeID = id;
228 
229  // !!! assuming empty myElemData
230  myElemData["id"].push_back(attrs.get<std::string>(VISSIM_ATTR_NO, nullptr, ok));
231  // error ignored if name is empty
232  myElemData["name"].push_back(attrs.get<std::string>(VISSIM_ATTR_NAME, nullptr, ok, false));
233  myElemData["type"].push_back(attrs.get<std::string>(VISSIM_ATTR_LINKBEHAVETYPE, nullptr, ok));
234  myElemData["zuschlag1"].push_back(attrs.get<std::string>(VISSIM_ATTR_ZUSCHLAG1, nullptr, ok));
235  myElemData["zuschlag2"].push_back(attrs.get<std::string>(VISSIM_ATTR_ZUSCHLAG2, nullptr, ok));
236  }
237 
238  if (element == VISSIM_TAG_LANE) {
239  bool ok = true;
240  // appends empty element if no width found
241  // error ignored if name is empty
242  myElemData["width"].push_back(attrs.get<std::string>(VISSIM_ATTR_WIDTH, nullptr, ok, false));
243  }
244 
245  if (element == VISSIM_TAG_FROM) {
246  if (isConnector != true) {
247  isConnector = true;
248  }
249  bool ok = true;
250  std::vector<std::string> from(StringTokenizer(attrs.get<std::string>(
251  VISSIM_ATTR_LANE, nullptr, ok), " ").getVector());
252  myElemData["from_pos"].push_back(attrs.get<std::string>(VISSIM_ATTR_POS, nullptr, ok));
253  myElemData["from_id"].push_back(from[0]);
254  myElemData["from_lane"].push_back(from[1]);
255  }
256 
257  if (element == VISSIM_TAG_TO) {
258  bool ok = true;
259  std::vector<std::string> to(StringTokenizer(attrs.get<std::string>(
260  VISSIM_ATTR_LANE, nullptr, ok), " ").getVector());
261  myElemData["to_pos"].push_back(attrs.get<std::string>(VISSIM_ATTR_POS, nullptr, ok));
262  myElemData["to_id"].push_back(to[0]);
263  myElemData["to_lane"].push_back(to[1]);
264  }
265 
266  if (element == VISSIM_TAG_POINT3D || element == VISSIM_TAG_LINKPOLYPOINT) {
267  bool ok = true;
268  // create a <sep> separated string of coordinate data
269  std::string sep(" ");
270 
271  std::string posS(attrs.get<std::string>(VISSIM_ATTR_X, nullptr, ok));
272  posS += sep;
273  posS.append(attrs.get<std::string>(VISSIM_ATTR_Y, nullptr, ok));
274  // allow for no Z
275  std::string z(attrs.get<std::string>(VISSIM_ATTR_ZOFFSET, nullptr, ok, false));
276  if (z.length() > 0) {
277  posS += sep;
278  posS.append(z);
279  }
280  myElemData["pos"].push_back(posS);
281  }
282 
283 
284 }
285 
286 void
288  if (element == VISSIM_TAG_LINK && myHierarchyLevel == 3) {
289  //std::cout << "elemData len:" << myElemData.size() << std::endl;
290 
291  NIVissimClosedLanesVector clv; //FIXME -> clv einlesen
292  std::vector<int> assignedVehicles; //FIXME -> assignedVehicles einlesen
293  int id(StringUtils::toInt(myElemData["id"].front()));
294 
295  PositionVector geom;
296  // convert all position coordinate strings to PositionVectors
297  while (!myElemData["pos"].empty()) {
298  std::vector<std::string> sPos_v(StringTokenizer(
299  myElemData["pos"].front(), " ").getVector());
300  myElemData["pos"].pop_front();
301  std::vector<double> pos_v(3);
302 
303  // doing a transform with explicit hint on function signature
304  std::transform(sPos_v.begin(), sPos_v.end(), pos_v.begin(),
306  geom.push_back_noDoublePos(Position(pos_v[0], pos_v[1], pos_v[2]));
307  }
308  // FIXME: a length = 0 PosVec seems fatal -> segfault
309  double length(geom.length());
310 
311  if (isConnector == false) {
312  // Add Edge
313  std::vector<double> laneWidths;
314  for (std::string& w : myElemData["width"]) {
315  laneWidths.push_back(StringUtils::toDouble(w));
316  }
317  NIVissimEdge* edge = new NIVissimEdge(id,
318  myElemData["name"].front(),
319  myElemData["type"].front(),
320  laneWidths,
321  StringUtils::toDouble(myElemData["zuschlag1"].front()),
322  StringUtils::toDouble(myElemData["zuschlag2"].front()),
323  length, geom, clv);
324  NIVissimEdge::dictionary(id, edge);
325  } else {
326  int numLanes = (int)myElemData["width"].size();
327  std::vector<int> laneVec(numLanes);
328  // Add Connector
329 
330  //NOTE: there should be only 1 lane number in XML
331  // subtraction of 1 as in readExtEdgePointDef()
332  laneVec[0] = StringUtils::toInt(myElemData["from_lane"].front()) - 1;
333  // then count up, building lane number vector
334  for (std::vector<int>::iterator each = ++laneVec.begin(); each != laneVec.end(); ++each) {
335  *each = *(each - 1) + 1;
336  }
337 
338  NIVissimExtendedEdgePoint from_def(
339  StringUtils::toInt(myElemData["from_id"].front()),
340  laneVec,
341  StringUtils::toDouble(myElemData["from_pos"].front()),
342  assignedVehicles);
343 
344  //NOTE: there should be only 1 lane number in XML
345  // subtraction of 1 as in readExtEdgePointDef()
346  laneVec[0] = StringUtils::toInt(myElemData["to_lane"].front()) - 1;
347  // then count up, building lane number vector
348  for (std::vector<int>::iterator each = ++laneVec.begin(); each != laneVec.end(); ++each) {
349  *each = *(each - 1) + 1;
350  }
351 
353  StringUtils::toInt(myElemData["to_id"].front()),
354  laneVec,
355  StringUtils::toDouble(myElemData["to_pos"].front()),
356  assignedVehicles);
357 
358  NIVissimConnection* connector = new
360  myElemData["name"].front(),
361  from_def, to_def,
362  geom, assignedVehicles, clv);
363 
364  NIVissimConnection::dictionary(id, connector);
365  }
366  // clear the element data
367  myElemData.clear();
368  isConnector = false;
369  //std::cout << "elemData len (clear):" << myElemData.size() << std::endl;
370  //std::cout.flush();
371 
372  }
373  --myHierarchyLevel;
374 }
375 
376 
377 // ---------------------------------------------------------------------------
378 // definitions of NIVissimXMLHandler_Zuflussdefinition-methods
379 // ---------------------------------------------------------------------------
383  "vissim - file") {
384 }
385 
387 
388 void
390  // finding an actual flow
391  if (element == VISSIM_TAG_VEHICLE_INPUT) {
392  //parse all flows
393  bool ok = true;
394  std::string id = attrs.get<std::string>(VISSIM_ATTR_NO, nullptr, ok);
395  std::string edgeid = attrs.get<std::string>(VISSIM_ATTR_LINK, nullptr, ok);
396  std::string name = attrs.get<std::string>(VISSIM_ATTR_NAME, nullptr, ok, false);
397 
399  name,
400  edgeid);
401  }
402 }
403 
404 // ---------------------------------------------------------------------------
405 // definitions of NIVissimXMLHandler_Parkplatzdefinition-methods
406 // ---------------------------------------------------------------------------
410  "vissim - file") {
411 }
412 
414 
415 void
417  // finding an actual parkinglot
418  if (element == VISSIM_TAG_PARKINGLOT) {
419  //parse all parkinglots
420  bool ok = true;
421  int id = attrs.get<int>(VISSIM_ATTR_NO, nullptr, ok);
422  int edgeid = attrs.get<int>(VISSIM_ATTR_INTLINK, nullptr, ok);
423  std::string name = attrs.get<std::string>(VISSIM_ATTR_NAME, nullptr, ok, false);
424  double position = attrs.get<double>(VISSIM_ATTR_POS, nullptr, ok);
425  std::vector<std::pair<int, int> > assignedVehicles; // (vclass, vwunsch)
426  //FIXME: vWunsch + Fahzeugklassen einlesen
427  // There can be s
428  std::vector<int> districts;
429  //FIXME: Parkplatzdefinition für mehrere Zonen implementieren
430  std::vector<double> percentages;
431  districts.push_back(attrs.get<int>(VISSIM_ATTR_DISTRICT, nullptr, ok));
432  percentages.push_back(attrs.get<double>(VISSIM_ATTR_PERCENTAGE, nullptr, ok));
433 
435  name,
436  districts,
437  percentages,
438  edgeid,
439  position,
440  assignedVehicles);
441  }
442 }
443 
444 
445 // ---------------------------------------------------------------------------
446 // definitions of NIVissimXMLHandler_Fahrzeugklassendefinition-methods
447 // ---------------------------------------------------------------------------
451  "vissim - file"),
452  myElemData(elemData),
453  myHierarchyLevel(0) {
454  myElemData.clear();
455 }
456 
458 
459 void
461  myHierarchyLevel++;
462 
463  if (element == VISSIM_TAG_VEHICLE_CLASS) {
464  bool ok = true;
465  myElemData["id"].push_back(attrs.get<std::string>(VISSIM_ATTR_NO, nullptr, ok));
466  myElemData["name"].push_back(attrs.get<std::string>(VISSIM_ATTR_NAME, nullptr, ok, false));
467  std::string colorStr(attrs.get<std::string>(VISSIM_ATTR_COLOR, nullptr, ok));
468  for (int pos = (int)colorStr.size() - 2; pos > 0; pos -= 2) {
469  colorStr.insert(pos, " ");
470  }
471  myElemData["color"].push_back(colorStr);
472  }
473  if (element == VISSIM_TAG_INTOBJECTREF) {
474  bool ok = true;
475  myElemData["types"].push_back(attrs.get<std::string>(VISSIM_ATTR_KEY, nullptr, ok));
476 
477 
478  }
479 }
480 
481 void
483  if (element == VISSIM_TAG_VEHICLE_CLASS && myHierarchyLevel == 3) {
484  RGBColor color;
485  std::istringstream iss(myElemData["color"].front());
486  std::vector<std::string> sCol_v(StringTokenizer(
487  myElemData["color"].front(), " ").getVector());
488  std::vector<int> myColorVector(sCol_v.size());
489  std::transform(sCol_v.begin(), sCol_v.end(), myColorVector.begin(), StringUtils::hexToInt);
490 
491  color = RGBColor((unsigned char)myColorVector[0],
492  (unsigned char)myColorVector[1],
493  (unsigned char)myColorVector[2],
494  (unsigned char)myColorVector[3]);
495  std::vector<int> types;
496  while (!myElemData["types"].empty()) {
497  types.push_back(StringUtils::toInt(myElemData["types"].front()));
498  myElemData["types"].pop_front();
499  }
500 
501  NIVissimVehTypeClass::dictionary(StringUtils::toInt(myElemData["id"].front()),
502  myElemData["name"].front(),
503  color,
504  types);
505  myElemData.clear();
506  }
507  --myHierarchyLevel;
508 }
509 
510 // ---------------------------------------------------------------------------
511 // definitions of NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition-methods
512 // ---------------------------------------------------------------------------
516  "vissim - file"),
517  myElemData(elemData),
518  myHierarchyLevel(0) {
519  myElemData.clear();
520 }
521 
523 
524 void
526  myHierarchyLevel++;
527  if (element == VISSIM_TAG_SPEED_DIST) {
528  bool ok = true;
529  myElemData["id"].push_back(attrs.get<std::string>(VISSIM_ATTR_NO, nullptr, ok));
530  }
531 
532  if (element == VISSIM_TAG_DATAPOINT) {
533  bool ok = true;
534  std::string sep(" ");
535  std::string posS(attrs.get<std::string>(VISSIM_ATTR_X, nullptr, ok));
536  posS += sep;
537  posS.append(attrs.get<std::string>(VISSIM_ATTR_FX, nullptr, ok));
538  myElemData["points"].push_back(posS);
539 
540  }
541 
542 }
543 
544 void
546  if (element == VISSIM_TAG_SPEED_DIST && myHierarchyLevel == 3) {
547  Distribution_Points* points = new Distribution_Points(myElemData["id"].front());
548  while (!myElemData["points"].empty()) {
549  std::vector<std::string> sPos_v(StringTokenizer(
550  myElemData["points"].front(), " ").getVector());
551  myElemData["points"].pop_front();
552  points->add(StringUtils::toDouble(sPos_v[0]), StringUtils::toDouble(sPos_v[1]));
553  }
554  DistributionCont::dictionary("speed", myElemData["id"].front(), points);
555  myElemData.clear();
556  }
557  --myHierarchyLevel;
558 }
559 
560 // ---------------------------------------------------------------------------
561 // definitions of NIVissimXMLHandler_VWunschentscheidungsdefinition-methods
562 // ---------------------------------------------------------------------------
566  "vissim - file"),
567  myElemData(elemData),
568  myHierarchyLevel(0) {
569  myElemData.clear();
570 }
571 
573 
574 void
576  myHierarchyLevel++;
577  if (element == VISSIM_TAG_SPEED_DECISION) {
578  bool ok = true;
579  myElemData["name"].push_back(attrs.get<std::string>(VISSIM_ATTR_NAME, nullptr, ok, false));
580  //FIXME: 2 vWunsch in the xml file, but only 1 of them is set???
581  }
582 
583 }
584 
585 void
587  --myHierarchyLevel;
588 }
589 
590 
591 // ---------------------------------------------------------------------------
592 // definitions of NIVissimXMLHandler_Routenentscheidungsdefinition-methods
593 // ---------------------------------------------------------------------------
597  "vissim - file"),
598  myElemData(elemData),
599  myHierarchyLevel(0) {
600  myElemData.clear();
601 }
602 
604 
605 void
607  myHierarchyLevel++;
608  if (element == VISSIM_TAG_DECISION_STATIC) {
609  bool ok = true;
610  myElemData["startLink"].push_back(attrs.get<std::string>(VISSIM_ATTR_LINK, nullptr, ok));
611  myElemData["startPos"].push_back(attrs.get<std::string>(VISSIM_ATTR_POS, nullptr, ok));
612  }
613  if (element == VISSIM_TAG_ROUTE_STATIC) {
614  bool ok = true;
615  myElemData["destLink"].push_back(attrs.get<std::string>(VISSIM_ATTR_DESTLINK, nullptr, ok));
616  myElemData["destPos"].push_back(attrs.get<std::string>(VISSIM_ATTR_DESTPOS, nullptr, ok));
617  myElemData["id"].push_back(attrs.get<std::string>(VISSIM_ATTR_NO, nullptr, ok));
618  }
619  if (element == VISSIM_TAG_INTOBJECTREF) {
620  // bool ok = true;
621  }
622 
623 }
624 
625 void
627  --myHierarchyLevel;
628 }
629 
630 // ---------------------------------------------------------------------------
631 // definitions of NIVissimXMLHandler_ConflictArea-methods
632 // ---------------------------------------------------------------------------
636  "vissim - file") {}
637 
639 
640 void
642  // finding an actual flow
643  if (element == VISSIM_TAG_CA) {
644  //parse all flows
645  bool ok = true;
646  std::string status = attrs.get<std::string>(VISSIM_ATTR_STATUS, nullptr, ok);
647  //get only the conflict areas which were set in VISSIM
648  if (status != "PASSIVE") {
649  NIVissimConflictArea::dictionary(attrs.get<int>(VISSIM_ATTR_NO, nullptr, ok),
650  attrs.get<std::string>(VISSIM_ATTR_LINK1, nullptr, ok),
651  attrs.get<std::string>(VISSIM_ATTR_LINK2, nullptr, ok),
652  status);
653  }
654 
655  }
656 }
657 
658 
659 /* -------------------------------------------------------------------------
660  * NIImporter_Vissim::VissimSingleTypeParser-methods
661  * ----------------------------------------------------------------------- */
663  : myVissimParent(parent) {}
664 
665 
667 
668 
669 std::string
671  std::string tmp;
672  from >> tmp;
673  return StringUtils::to_lower_case(tmp);
674 }
675 
676 
677 
678 std::string
680  const std::string& excl) {
681  std::string myExcl = StringUtils::to_lower_case(excl);
682  std::string tmp = myRead(from);
683  if (tmp == "") {
684  return "DATAEND";
685  }
686  if (tmp != myExcl
687  &&
688  (tmp.substr(0, 2) == "--" || !myVissimParent.admitContinue(tmp))
689  ) {
690  return "DATAEND";
691  }
692  return StringUtils::to_lower_case(tmp);
693 }
694 
695 
696 std::string
698  const std::vector<std::string>& excl) {
699  std::vector<std::string> myExcl;
700  std::vector<std::string>::const_iterator i;
701  for (i = excl.begin(); i != excl.end(); i++) {
702  std::string mes = StringUtils::to_lower_case(*i);
703  myExcl.push_back(mes);
704  }
705  std::string tmp = myRead(from);
706  if (tmp == "") {
707  return "DATAEND";
708  }
709 
710  bool equals = false;
711  for (i = myExcl.begin(); i != myExcl.end() && !equals; i++) {
712  if ((*i) == tmp) {
713  equals = true;
714  }
715  }
716  if (!equals
717  &&
718  (tmp.substr(0, 2) == "--" || !myVissimParent.admitContinue(tmp))
719  ) {
720  return "DATAEND";
721  }
722  return StringUtils::to_lower_case(tmp);
723 }
724 
725 
726 std::string
728  const std::string& tag) {
729  std::string tmp;
730  if (tag == "") {
731  tmp = myRead(from);
732  } else {
733  tmp = tag;
734  }
735  if (tmp == "beschriftung") {
736  tmp = myRead(from);
737  if (tmp == "keine") {
738  from >> tmp;
739  }
740  tmp = myRead(from);
741  tmp = myRead(from);
742  }
743  return tmp;
744 }
745 
746 
747 Position
749  double x, y;
750  from >> x; // type-checking is missing!
751  from >> y; // type-checking is missing!
752  return Position(x, y);
753 }
754 
755 
756 std::vector<int>
758  std::istream& from, const std::string& next) {
759  std::string tmp = readEndSecure(from);
760  std::vector<int> ret;
761  if (tmp == "alle") {
762  ret.push_back(-1);
763  return ret;
764  }
765  while (tmp != "DATAEND" && tmp != next) {
766  ret.push_back(StringUtils::toInt(tmp));
767  tmp = readEndSecure(from);
768  }
769  return ret;
770 }
771 
772 
775  std::istream& from) {
776  std::string tag;
777  from >> tag; // "Strecke"
778  int edgeid;
779  from >> edgeid; // type-checking is missing!
780  from >> tag; // "Spuren"
781  std::vector<int> lanes;
782  while (tag != "bei") {
783  tag = readEndSecure(from);
784  if (tag != "bei") {
785  int lane = StringUtils::toInt(tag);
786  lanes.push_back(lane - 1);
787  }
788  }
789  double position;
790  from >> position;
791  std::vector<int> dummy;
792  return NIVissimExtendedEdgePoint(edgeid, lanes, position, dummy);
793 }
794 
795 
796 std::string
798  std::string name;
799  from >> name;
800  if (name[0] == '"') {
801  while (name[name.length() - 1] != '"') {
802  std::string tmp;
803  from >> tmp;
804  name = name + " " + tmp;
805  }
806  name = name.substr(1, name.length() - 2);
807  }
808  return StringUtils::convertUmlaute(name);
809 }
810 
811 
812 void
814  const std::string& name) {
815  std::string tag;
816  while (tag != name) {
817  tag = myRead(from);
818  }
819 }
820 
821 bool
823  const std::string& name) {
824  std::string tag;
825  while (tag != name) {
826  tag = myRead(from);
827  }
828  while (tag != "DATAEND") {
829  tag = readEndSecure(from);
830  }
831  return true;
832 }
833 
834 
835 
836 /* -------------------------------------------------------------------------
837  * NIImporter_Vissim-methods
838  * ----------------------------------------------------------------------- */
841  buildParsers();
842  myColorMap["blau"] = RGBColor(77, 77, 255, 255);
843  myColorMap["gelb"] = RGBColor::YELLOW;
844  myColorMap["grau"] = RGBColor::GREY;
845  myColorMap["lila"] = RGBColor::MAGENTA;
846  myColorMap["gruen"] = RGBColor::GREEN;
847  myColorMap["rot"] = RGBColor::RED;
848  myColorMap["schwarz"] = RGBColor::BLACK;
849  myColorMap["tuerkis"] = RGBColor::CYAN;
850  myColorMap["weiss"] = RGBColor::WHITE;
851  myColorMap["keine"] = RGBColor::WHITE;
852 }
853 
854 
855 
856 
876  for (ToParserMap::iterator i = myParsers.begin(); i != myParsers.end(); i++) {
877  delete (*i).second;
878  }
879 }
880 
881 
882 void
884  const std::string file = options.getString("vissim-file");
885  // try to open the file
886  std::ifstream strm(file.c_str());
887  if (!strm.good()) {
888  WRITE_ERROR("Could not open vissim-file '" + file + "'.");
889  return;
890  }
891  std::string token;
892  strm >> token;
893  if (StringUtils::endsWith(file, ".inpx") || StringUtils::endsWith(token, "<?xml") || StringUtils::endsWith(token, "<network")) {
894  // Create NIVissimXMLHandlers
895  NIVissimXMLHandler_Streckendefinition XMLHandler_Streckendefinition(elementData);
896  NIVissimXMLHandler_Zuflussdefinition XMLHandler_Zuflussdefinition;
897  //NIVissimXMLHandler_Parkplatzdefinition XMLHandler_Parkplatzdefinition;
898  NIVissimXMLHandler_Fahrzeugklassendefinition XMLHandler_Fahrzeugklassendefinition(elementData);
899  NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition XMLHandler_Geschwindigkeitsverteilung(elementData);
900  NIVissimXMLHandler_ConflictArea XMLHandler_ConflictAreas;
901 
902  // Strecken + Verbinder
903  XMLHandler_Streckendefinition.setFileName(file);
904  PROGRESS_BEGIN_MESSAGE("Parsing strecken+verbinder from vissim-file '" + file + "'");
905  if (!XMLSubSys::runParser(XMLHandler_Streckendefinition, file)) {
906  return;
907  }
909 
910  // Zuflüsse
911  XMLHandler_Zuflussdefinition.setFileName(file);
912  PROGRESS_BEGIN_MESSAGE("Parsing zuflüsse from vissim-file '" + file + "'");
913  if (!XMLSubSys::runParser(XMLHandler_Zuflussdefinition, file)) {
914  return;
915  }
917 
918  //Geschwindigkeitsverteilungen
919  XMLHandler_Geschwindigkeitsverteilung.setFileName(file);
920  PROGRESS_BEGIN_MESSAGE("Parsing parkplätze from vissim-file '" + file + "'");
921  if (!XMLSubSys::runParser(XMLHandler_Geschwindigkeitsverteilung, file)) {
922  return;
923  }
925 
926 
927  //Fahrzeugklassen
928  XMLHandler_Fahrzeugklassendefinition.setFileName(file);
929  PROGRESS_BEGIN_MESSAGE("Parsing parkplätze from vissim-file '" + file + "'");
930  if (!XMLSubSys::runParser(XMLHandler_Fahrzeugklassendefinition, file)) {
931  return;
932  }
934 
935  //Parkplätze
936  /*XMLHandler_Parkplatzdefinition.setFileName(file);
937  PROGRESS_BEGIN_MESSAGE("Parsing parkplätze from vissim-file '" + file + "'");
938  if (!XMLSubSys::runParser(XMLHandler_Parkplatzdefinition, file)) {
939  return;
940  }
941  PROGRESS_DONE_MESSAGE();*/
942 
943 
944  //Konfliktflächen
945  XMLHandler_ConflictAreas.setFileName(file);
946  PROGRESS_BEGIN_MESSAGE("Parsing conflict areas from vissim-file '" + file + "'");
947  if (!XMLSubSys::runParser(XMLHandler_ConflictAreas, file)) {
948  return;
949  }
951  } else {
952  strm.seekg(strm.beg);
953  if (!readContents(strm)) {
954  return;
955  }
956  }
957  postLoadBuild(options.getFloat("vissim.join-distance"));
958 }
959 
960 
961 bool
962 NIImporter_Vissim::admitContinue(const std::string& tag) {
963  ToElemIDMap::const_iterator i = myKnownElements.find(tag);
964  if (i == myKnownElements.end()) {
965  return true;
966  }
967  myLastSecure = tag;
968  return false;
969 }
970 
971 
972 bool
973 NIImporter_Vissim::readContents(std::istream& strm) {
974  // read contents
975  bool ok = true;
976  while (strm.good() && ok) {
977  std::string tag;
978  if (myLastSecure != "") {
979  tag = myLastSecure;
980  } else {
981  strm >> tag;
982  }
983  myLastSecure = "";
984  bool parsed = false;
985  while (!parsed && strm.good() && ok) {
986  ToElemIDMap::iterator i = myKnownElements.find(StringUtils::to_lower_case(tag));
987  if (i != myKnownElements.end()) {
988  ToParserMap::iterator j = myParsers.find((*i).second);
989  if (j != myParsers.end()) {
990  VissimSingleTypeParser* parser = (*j).second;
991  ok = parser->parse(strm);
992  parsed = true;
993  }
994  }
995  if (!parsed) {
996  std::string line;
997  std::streamoff pos;
998  do {
999  pos = strm.tellg();
1000  getline(strm, line);
1001  } while (strm.good() && (line == "" || line[0] == ' ' || line[0] == '-'));
1002  if (!strm.good()) {
1003  return true;
1004  }
1005  strm.seekg(pos);
1006  strm >> tag;
1007  }
1008  }
1009  }
1010  return ok;
1011 }
1012 
1013 
1014 void
1016  // close the loading process
1020  // build district->connections map
1022  // build clusters around nodes
1023 // NIVissimNodeDef::buildNodeClusters();
1024  // build node clusters around traffic lights
1025 // NIVissimTL::buildNodeClusters();
1026 
1027  // when connections or disturbances are left, build nodes around them
1028 
1029  // try to assign connection clusters to nodes
1030  // only left connections will be processed in
1031  // buildConnectionClusters & join
1032 //30.4. brauchen wir noch! NIVissimNodeDef::dict_assignConnectionsToNodes();
1033 
1034  // build clusters of connections with the same direction and a similar position along the streets
1036  // check whether further nodes (connection clusters by now) must be added
1038 
1039  // join clusters when overlapping (different streets are possible)
1042 // NIVissimConnectionCluster::joinByDisturbances(offset);
1043 
1044 // NIVissimConnectionCluster::addTLs(offset);
1045 
1046  // build nodes from clusters
1049 
1050 // NIVissimNodeCluster::dict_recheckEdgeChanges();
1056  if (OptionsCont::getOptions().getBool("vissim.report-unset-speeds")) {
1058  }
1064 }
1065 
1066 
1067 void
1069  myKnownElements["kennung"] = VE_Kennungszeile;
1070  myKnownElements["zufallszahl"] = VE_Startzufallszahl;
1071  myKnownElements["simulationsdauer"] = VE_Simdauer;
1072  myKnownElements["startuhrzeit"] = VE_Startuhrzeit;
1073  myKnownElements["simulationsrate"] = VE_SimRate;
1074  myKnownElements["zeitschritt"] = VE_Zeitschrittfaktor;
1075  myKnownElements["linksverkehr"] = VE_Linksverkehr;
1076  myKnownElements["dynuml"] = VE_DynUml;
1078  myKnownElements["gelbverhalten"] = VE_Gelbverhaltendefinition;
1080  myKnownElements["verbindung"] = VE_Verbindungsdefinition;
1081  myKnownElements["richtungsentscheidung"] = VE_Richtungsentscheidungsdefinition;
1082  myKnownElements["routenentscheidung"] = VE_Routenentscheidungsdefinition;
1083  myKnownElements["vwunschentscheidung"] = VE_VWunschentscheidungsdefinition;
1084  myKnownElements["langsamfahrbereich"] = VE_Langsamfahrbereichdefinition;
1086  myKnownElements["fahrzeugtyp"] = VE_Fahrzeugtypdefinition;
1087  myKnownElements["fahrzeugklasse"] = VE_Fahrzeugklassendefinition;
1097  myKnownElements["wunschbeschleunigung"] = VE_Wunschbeschleunigungskurvedefinition;
1100  myKnownElements["querverkehrsstoerung"] = VE_Querverkehrsstoerungsdefinition;
1102  myKnownElements["signalgruppe"] = VE_Signalgruppendefinition;
1103  myKnownElements["signalgeber"] = VE_Signalgeberdefinition;
1104  myKnownElements["lsakopplung"] = VE_LSAKopplungdefinition;
1106  myKnownElements["haltestelle"] = VE_Haltestellendefinition;
1108  myKnownElements["stopschild"] = VE_Stopschilddefinition;
1112  myKnownElements["querschnittsmessung"] = VE_Querschnittsmessungsdefinition;
1113  myKnownElements["stauzaehler"] = VE_Stauzaehlerdefinition;
1114  myKnownElements["auswertung"] = VE_Auswertungsdefinition;
1117  myKnownElements["parkplatz"] = VE_Parkplatzdefinition;
1120  myKnownElements["netzobjekt"] = VE_Netzobjektdefinition;
1121  myKnownElements["richtungspfeil"] = VE_Richtungspfeildefinition;
1123  myKnownElements["fahrverhalten"] = VE_Fahrverhaltendefinition;
1124  myKnownElements["fahrtverlaufdateien"] = VE_Fahrtverlaufdateien;
1125  myKnownElements["emission"] = VE_Emission;
1127  myKnownElements["streckentyp"] = VE_Streckentypdefinition;
1128  myKnownElements["kantensperrung"] = VE_Kantensperrung;
1130 
1131 
1132  myKnownElements["advance"] = VE_DUMMY;
1133  myKnownElements["temperatur"] = VE_DUMMY;
1134 
1135 }
1136 
1137 
1138 
1139 void
1145  myParsers[VE_DynUml] =
1219 
1262 
1263 }
1264 
1265 
1266 
1267 /****************************************************************************/
1268 
NIImporter_Vissim::VissimSingleTypeParser::readExtEdgePointDef
NIVissimExtendedEdgePoint readExtEdgePointDef(std::istream &from)
Definition: NIImporter_Vissim.cpp:774
RGBColor::GREY
static const RGBColor GREY
Definition: RGBColor.h:198
NIVissimSingleTypeParser_Zuflussdefinition.h
NIImporter_Vissim::vissimAttrs
static StringBijection< int >::Entry vissimAttrs[]
The names of VISSIM-XML attributes (for passing to GenericSAXHandler)
Definition: NIImporter_Vissim.h:656
OptionsCont::isSet
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
Definition: OptionsCont.cpp:135
NIVissimDistrictConnection::dict_BuildDistrictNodes
static void dict_BuildDistrictNodes(NBDistrictCont &dc, NBNodeCont &nc)
Builds the nodes that belong to a district.
Definition: NIVissimDistrictConnection.cpp:151
RandomDistributor::add
bool add(T val, double prob, bool checkDuplicates=true)
Adds a value with an assigned probability to the distribution.
Definition: RandomDistributor.h:70
NIVissimSingleTypeParser_Lichtsignalanlagendefinition
Definition: NIVissimSingleTypeParser_Lichtsignalanlagendefinition.h:37
NIImporter_Vissim::VISSIM_TAG_LANES
Definition: NIImporter_Vissim.h:597
NIImporter_Vissim::NIVissimXMLHandler_Routenentscheidungsdefinition::myElemData
nodeMap & myElemData
Definition: NIImporter_Vissim.h:416
NIVissimConnection::dict_assignToEdges
static void dict_assignToEdges()
Definition: NIVissimConnection.cpp:305
NIVissimSingleTypeParser_TEAPACDefinition.h
NIVissimSingleTypeParser_Verkehrszusammensetzungsdefinition.h
NIVissimVehTypeClass::clearDict
static void clearDict()
Definition: NIVissimVehTypeClass.cpp:78
NIImporter_Vissim::VISSIM_ATTR_LINK1
Definition: NIImporter_Vissim.h:647
NIVissimSingleTypeParser_Auswertungsdefinition
Definition: NIVissimSingleTypeParser_Auswertungsdefinition.h:36
XMLSubSys::runParser
static bool runParser(GenericSAXHandler &handler, const std::string &file, const bool isNet=false)
Runs the given handler on the given file; returns if everything's ok.
Definition: XMLSubSys.cpp:112
NIImporter_Vissim::VISSIM_TAG_INTOBJECTREF
Definition: NIImporter_Vissim.h:610
NIVissimEdge::buildConnectionClusters
static void buildConnectionClusters()
Clusters connections of each edge.
Definition: NIVissimEdge.cpp:177
NIImporter_Vissim::NIVissimXMLHandler_ConflictArea::~NIVissimXMLHandler_ConflictArea
~NIVissimXMLHandler_ConflictArea()
Destructor.
Definition: NIImporter_Vissim.cpp:638
NIVissimClosedLanesVector
std::vector< NIVissimClosedLaneDef * > NIVissimClosedLanesVector
Definition: NIVissimClosedLanesVector.h:29
NIImporter_Vissim::NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition::myStartElement
void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
Definition: NIImporter_Vissim.cpp:525
NIVissimSingleTypeParser_Knotendefinition
Definition: NIVissimSingleTypeParser_Knotendefinition.h:36
NIImporter_Vissim::VissimSingleTypeParser::skipOverreading
bool skipOverreading(std::istream &from, const std::string &name="")
Overreads the named parameter (if) given and skips the rest until "DATAEND".
Definition: NIImporter_Vissim.cpp:822
NIImporter_Vissim::VISSIM_ATTR_DISTRICT
Definition: NIImporter_Vissim.h:641
NIImporter_Vissim::VissimSingleTypeParser::~VissimSingleTypeParser
virtual ~VissimSingleTypeParser()
Destructor.
Definition: NIImporter_Vissim.cpp:666
NIVissimSingleTypeParser_Zeitenverteilungsdefinition
Definition: NIVissimSingleTypeParser_Zeitenverteilungsdefinition.h:36
VE_Haltestellendefinition
Definition: NIVissimElements.h:64
NIVissimSingleTypeParser_Stauzaehlerdefinition
Definition: NIVissimSingleTypeParser_Stauzaehlerdefinition.h:36
DistributionCont::dictionary
static bool dictionary(const std::string &type, const std::string &id, Distribution *d)
Adds a distribution of the given type and name to the container.
Definition: DistributionCont.cpp:34
NIVissimEdge.h
NIVissimSingleTypeParser_Rautedefinition
Definition: NIVissimSingleTypeParser_Rautedefinition.h:37
NIVissimSingleTypeParser_Stauparameterdefinition
Definition: NIVissimSingleTypeParser_Stauparameterdefinition.h:36
VE_Zeitschrittfaktor
Definition: NIVissimElements.h:32
NIVissimSingleTypeParser_Einheitendefinition
Definition: NIVissimSingleTypeParser_Einheitendefinition.h:36
NIImporter_Vissim::VISSIM_TAG_LINKS
Definition: NIImporter_Vissim.h:600
NIVissimEdge
A temporary storage for edges imported from Vissim.
Definition: NIVissimEdge.h:52
VE_Verlustzeitmessungsdefinition
Definition: NIVissimElements.h:69
NBNetBuilder
Instance responsible for building networks.
Definition: NBNetBuilder.h:109
VE_Verbindungsdefinition
Definition: NIVissimElements.h:38
NIVissimNodeCluster::buildNBNodes
static void buildNBNodes(NBNodeCont &nc)
Definition: NIVissimNodeCluster.cpp:181
NIVissimSingleTypeParser_Startzufallszahl
Definition: NIVissimSingleTypeParser_Startzufallszahl.h:36
NIImporter_Vissim::NIVissimXMLHandler_ConflictArea::NIVissimXMLHandler_ConflictArea
NIVissimXMLHandler_ConflictArea()
Constructor.
Definition: NIImporter_Vissim.cpp:633
NIVissimNodeCluster::clearDict
static void clearDict()
Definition: NIVissimNodeCluster.cpp:285
NIVissimSingleTypeParser_Gefahrwarnungsdefinition.h
NIImporter_Vissim::VISSIM_ATTR_NAME
Definition: NIImporter_Vissim.h:628
NIImporter_Vissim::VISSIM_ATTR_Y
Definition: NIImporter_Vissim.h:630
NIVissimSingleTypeParser_Emission.h
RGBColor::BLACK
static const RGBColor BLACK
Definition: RGBColor.h:197
NIVissimSingleTypeParser_Messungsdefinition.h
NIImporter_Vissim::NIVissimXMLHandler_Parkplatzdefinition::~NIVissimXMLHandler_Parkplatzdefinition
~NIVissimXMLHandler_Parkplatzdefinition()
Destructor.
Definition: NIImporter_Vissim.cpp:413
NIVissimSource.h
OptionsCont.h
NIVissimSingleTypeParser_Haltestellendefinition.h
NIImporter_Vissim::NIVissimXMLHandler_Streckendefinition
Definition: NIImporter_Vissim.h:84
NIImporter_Vissim::NIVissimXMLHandler_Parkplatzdefinition::NIVissimXMLHandler_Parkplatzdefinition
NIVissimXMLHandler_Parkplatzdefinition()
Constructor.
Definition: NIImporter_Vissim.cpp:407
NIImporter_Vissim::NIVissimXMLHandler_Zuflussdefinition::myStartElement
void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
Definition: NIImporter_Vissim.cpp:389
StringUtils::toDouble
static double toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter
Definition: StringUtils.cpp:345
NIVissimSingleTypeParser_Signalgruppendefinition
Definition: NIVissimSingleTypeParser_Signalgruppendefinition.h:36
VE_Routenentscheidungsdefinition
Definition: NIVissimElements.h:40
VE_Auswertungsdefinition
Definition: NIVissimElements.h:72
SUMOSAXAttributes::get
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
Definition: SUMOSAXAttributes.h:492
NIImporter_Vissim::VISSIM_ATTR_PERCENTAGE
Definition: NIImporter_Vissim.h:640
VE_Signalgeberdefinition
Definition: NIVissimElements.h:61
NIImporter_Vissim::VISSIM_ATTR_DESTLINK
Definition: NIImporter_Vissim.h:645
NIImporter_Vissim::VISSIM_TAG_SPEED_DECISION
Definition: NIImporter_Vissim.h:611
MsgHandler.h
NIVissimSingleTypeParser_Emission
Definition: NIVissimSingleTypeParser_Emission.h:36
NIImporter_Vissim::VISSIM_ATTR_LINKBEHAVETYPE
Definition: NIImporter_Vissim.h:635
NIVissimSingleTypeParser_Linksverkehr
Definition: NIVissimSingleTypeParser_Linksverkehr.h:36
NIVissimClosures::clearDict
static void clearDict()
Definition: NIVissimClosures.cpp:78
RGBColor::YELLOW
static const RGBColor YELLOW
Definition: RGBColor.h:192
NIImporter_Vissim::VISSIM_TAG_LINK
Definition: NIImporter_Vissim.h:599
NIVissimSingleTypeParser_Stopschilddefinition
Definition: NIVissimSingleTypeParser_Stopschilddefinition.h:36
NIVissimConnectionCluster.h
NIImporter_Vissim::VissimSingleTypeParser::readName
std::string readName(std::istream &from)
Reads the structures name We cannot use the "<<" operator, as names may contain more than one word wh...
Definition: NIImporter_Vissim.cpp:797
VE_Langsamfahrbereichdefinition
Definition: NIVissimElements.h:42
VE_Messungsdefinition
Definition: NIVissimElements.h:67
VE_Stauparameterdefinition
Definition: NIVissimElements.h:35
NIImporter_Vissim::VISSIM_ATTR_KEY
Definition: NIImporter_Vissim.h:643
NIVissimSingleTypeParser_Querschnittsmessungsdefinition
Definition: NIVissimSingleTypeParser_Querschnittsmessungsdefinition.h:36
NIVissimSingleTypeParser_Fahrverhaltendefinition
Definition: NIVissimSingleTypeParser_Fahrverhaltendefinition.h:36
OptionsCont::getString
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
Definition: OptionsCont.cpp:201
SUMOSAXHandler.h
VE_Gefahrenwarnsystemdefinition
Definition: NIVissimElements.h:74
NIVissimDistrictConnection::dict_BuildDistrictConnections
static void dict_BuildDistrictConnections()
Definition: NIVissimDistrictConnection.cpp:117
FileHelpers.h
NIImporter_Vissim::admitContinue
bool admitContinue(const std::string &tag)
Definition: NIImporter_Vissim.cpp:962
RGBColor::CYAN
static const RGBColor CYAN
Definition: RGBColor.h:193
NIImporter_Vissim::NIVissimXMLHandler_Fahrzeugklassendefinition::~NIVissimXMLHandler_Fahrzeugklassendefinition
~NIVissimXMLHandler_Fahrzeugklassendefinition()
Destructor.
Definition: NIImporter_Vissim.cpp:457
VE_DynUml
Definition: NIVissimElements.h:34
VE_Gelbverhaltendefinition
Definition: NIVissimElements.h:36
NIImporter_Vissim::VISSIM_TAG_ROUTE_STATIC
Definition: NIImporter_Vissim.h:615
StringUtils::to_lower_case
static std::string to_lower_case(std::string str)
Transfers the content to lower case.
Definition: StringUtils.cpp:59
VE_Laufleistungsverteilungsdefinition
Definition: NIVissimElements.h:51
NBEdgeCont.h
NIImporter_Vissim
Importer for networks stored in Vissim format.
Definition: NIImporter_Vissim.h:58
NIVissimTL::clearDict
static void clearDict()
Definition: NIVissimTL.cpp:353
NIImporter_Vissim::elementData
nodeMap elementData
Definition: NIImporter_Vissim.h:78
NIVissimDistrictConnection::dictionary
static bool dictionary(int id, const std::string &name, const std::vector< int > &districts, const std::vector< double > &percentages, int edgeid, double position, const std::vector< std::pair< int, int > > &assignedVehicles)
Inserts the connection into the dictionary after building it.
Definition: NIVissimDistrictConnection.cpp:81
OptionsCont::getBool
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
Definition: OptionsCont.cpp:222
NIVissimSingleTypeParser_Fahrtverlaufdateien
Definition: NIVissimSingleTypeParser_Fahrtverlaufdateien.h:36
NIVissimSingleTypeParser_Kennungszeile.h
NIImporter_Vissim::VissimSingleTypeParser::getPosition
Position getPosition(std::istream &from)
returns the 2d-position saved as next within the stream
Definition: NIImporter_Vissim.cpp:748
NIImporter_Vissim::VISSIM_TAG_POINT3D
Definition: NIImporter_Vissim.h:602
OptionsCont::getOptions
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:57
NIVissimSource::dictionary
static bool dictionary(const std::string &id, const std::string &name, const std::string &edgeid)
Definition: NIVissimSource.cpp:39
NIImporter_Vissim::VISSIM_ATTR_COLOR
Definition: NIImporter_Vissim.h:642
NIVissimAbstractEdge::clearDict
static void clearDict()
Definition: NIVissimAbstractEdge.cpp:152
NIImporter_Vissim::myKnownElements
ToElemIDMap myKnownElements
Map from element names to their numerical representation.
Definition: NIImporter_Vissim.h:565
NIImporter_Vissim::VISSIM_ATTR_ZUSCHLAG2
Definition: NIImporter_Vissim.h:633
NIVissimSingleTypeParser_TEAPACDefinition
Definition: NIVissimSingleTypeParser_TEAPACDefinition.h:36
NIImporter_Vissim::insertKnownElements
void insertKnownElements()
adds name-to-id - relationships of known elements into myKnownElements
Definition: NIImporter_Vissim.cpp:1068
NIVissimSingleTypeParser__XKurvedefinition.h
PositionVector::length
double length() const
Returns the length.
Definition: PositionVector.cpp:484
NIVissimSingleTypeParser_Streckentypdefinition
Definition: NIVissimSingleTypeParser_Streckentypdefinition.h:36
NIVissimSource::clearDict
static void clearDict()
Definition: NIVissimSource.cpp:72
NIVissimSingleTypeParser_Fensterdefinition.h
NIVissimDistrictConnection::dict_BuildDistricts
static void dict_BuildDistricts(NBDistrictCont &dc, NBEdgeCont &ec, NBNodeCont &nc)
Builds the districts.
Definition: NIVissimDistrictConnection.cpp:182
NIVissimSingleTypeParser_Gefahrwarnungsdefinition
Definition: NIVissimSingleTypeParser_Gefahrwarnungsdefinition.h:36
NIImporter_Vissim::NIVissimXMLHandler_Streckendefinition::myElemData
nodeMap & myElemData
Definition: NIImporter_Vissim.h:116
NIVissimVehTypeClass.h
NIVissimConflictArea.h
VE_Detektorendefinition
Definition: NIVissimElements.h:63
NIVissimSingleTypeParser_Haltestellendefinition
Definition: NIVissimSingleTypeParser_Haltestellendefinition.h:36
VE_Maxverzoegerungskurvedefinition
Definition: NIVissimElements.h:56
VE_Kantensperrung
Definition: NIVissimElements.h:86
VE_Streckentypdefinition
Definition: NIVissimElements.h:85
NIImporter_Vissim::NIVissimXMLHandler_Streckendefinition::NIVissimXMLHandler_Streckendefinition
NIVissimXMLHandler_Streckendefinition(nodeMap &elemData)
Constructor.
Definition: NIImporter_Vissim.cpp:204
PositionVector
A list of positions.
Definition: PositionVector.h:45
NIImporter_Vissim::readContents
bool readContents(std::istream &strm)
Definition: NIImporter_Vissim.cpp:973
VE_Stopschilddefinition
Definition: NIVissimElements.h:66
VE_Kennungszeile
Definition: NIVissimElements.h:27
NIImporter_Vissim::VISSIM_TAG_SPEED_DIST
Definition: NIImporter_Vissim.h:612
NIImporter_Vissim::VISSIM_ATTR_NOTHING
Definition: NIImporter_Vissim.h:626
NIVissimSingleTypeParser_Gelbverhaltendefinition.h
NIImporter_Vissim::VISSIM_ATTR_LANE
Definition: NIImporter_Vissim.h:636
NIImporter_Vissim::NIVissimXMLHandler_Parkplatzdefinition::myStartElement
void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
Definition: NIImporter_Vissim.cpp:416
NIVissimSingleTypeParser_Zeitenverteilungsdefinition.h
NIVissimSingleTypeParser_Streckendefinition.h
VE_Liniendefinition
Definition: NIVissimElements.h:65
NIVissimSingleTypeParser_Parkplatzdefinition.h
NBNetBuilder::getEdgeCont
NBEdgeCont & getEdgeCont()
Definition: NBNetBuilder.h:150
NIImporter_Vissim::NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition::myEndElement
void myEndElement(int element)
Callback method for a closing tag to implement by derived classes.
Definition: NIImporter_Vissim.cpp:545
VE_Fahrverhaltendefinition
Definition: NIVissimElements.h:81
NIImporter_Vissim::VISSIM_ATTR_ZUSCHLAG1
Definition: NIImporter_Vissim.h:632
StringUtils::convertUmlaute
static std::string convertUmlaute(std::string str)
Converts german "Umlaute" to their latin-version.
Definition: StringUtils.cpp:87
VE_Zuflussdefinition
Definition: NIVissimElements.h:43
NIVissimSingleTypeParser_Startuhrzeit
Definition: NIVissimSingleTypeParser_Startuhrzeit.h:36
VE_Fahrzeugtypdefinition
Definition: NIVissimElements.h:44
NIImporter_Vissim::VISSIM_TAG_TO
Definition: NIImporter_Vissim.h:606
NIVissimSingleTypeParser_Reisezeitmessungsdefinition
Definition: NIVissimSingleTypeParser_Reisezeitmessungsdefinition.h:36
VE_Fahrtverlaufdateien
Definition: NIVissimElements.h:82
VE_Wunschverzoegerungskurvedefinition
Definition: NIVissimElements.h:57
VE_Geschwindigkeitsverteilungsdefinition
Definition: NIVissimElements.h:47
VE_Startzufallszahl
Definition: NIVissimElements.h:28
NIVissimTL::dict_SetSignals
static bool dict_SetSignals(NBTrafficLightLogicCont &tlc, NBEdgeCont &ec)
Definition: NIVissimTL.cpp:365
NIVissimEdge::dictionary
static bool dictionary(int id, const std::string &name, const std::string &type, int noLanes, double zuschlag1, double zuschlag2, double length, const PositionVector &geom, const NIVissimClosedLanesVector &clv)
Adds the described item to the dictionary Builds the edge first.
Definition: NIVissimEdge.cpp:138
RGBColor
Definition: RGBColor.h:39
NIVissimSingleTypeParser_Simdauer
Definition: NIVissimSingleTypeParser_Simdauer.h:36
NIVissimDisturbance.h
RGBColor::MAGENTA
static const RGBColor MAGENTA
Definition: RGBColor.h:194
NIImporter_Vissim::NIVissimXMLHandler_VWunschentscheidungsdefinition::myEndElement
void myEndElement(int element)
Callback method for a closing tag to implement by derived classes.
Definition: NIImporter_Vissim.cpp:586
NIVissimSingleTypeParser_Liniendefinition.h
NIVissimSingleTypeParser_DynUml
Definition: NIVissimSingleTypeParser_DynUml.h:36
NIImporter_Vissim::VISSIM_TAG_POINTS3D
Definition: NIImporter_Vissim.h:601
PositionVector::push_back_noDoublePos
void push_back_noDoublePos(const Position &p)
insert in back a non double position
Definition: PositionVector.cpp:1295
NIImporter_Vissim::VISSIM_ATTR_POS
Definition: NIImporter_Vissim.h:637
NIImporter_Vissim::VissimSingleTypeParser::readEndSecure
std::string readEndSecure(std::istream &from, const std::string &excl="")
as myRead, but returns "DATAEND" when the current field has ended
Definition: NIImporter_Vissim.cpp:679
StringBijection
Definition: StringBijection.h:43
StringUtils::endsWith
static bool endsWith(const std::string &str, const std::string suffix)
Checks whether a given string ends with the suffix.
Definition: StringUtils.cpp:180
NIVissimExtendedEdgePoint
Definition: NIVissimExtendedEdgePoint.h:42
NIImporter_Vissim::load
void load(const OptionsCont &options)
loads the vissim file
Definition: NIImporter_Vissim.cpp:883
NIVissimSingleTypeParser_Kantensperrung.h
NIImporter_Vissim::NIVissimXMLHandler_Streckendefinition::myEndElement
void myEndElement(int element)
Callback method for a closing tag to implement by derived classes.
Definition: NIImporter_Vissim.cpp:287
NIImporter_Vissim::NIVissimXMLHandler_Fahrzeugklassendefinition::myElemData
nodeMap & myElemData
Definition: NIImporter_Vissim.h:256
NIVissimSingleTypeParser_Kennungszeile
Definition: NIVissimSingleTypeParser_Kennungszeile.h:36
NIImporter_Vissim::myParsers
ToParserMap myParsers
Parsers by element id.
Definition: NIImporter_Vissim.h:571
NIVissimSingleTypeParser_Richtungspfeildefinition
Definition: NIVissimSingleTypeParser_Richtungspfeildefinition.h:36
NIImporter_Vissim::VissimSingleTypeParser::parse
virtual bool parse(std::istream &from)=0
Parses a single data type. Returns whether no error occurred.
NIVissimNodeDef.h
VE_Laengenverteilungsdefinition
Definition: NIVissimElements.h:48
NIVissimDistrictConnection::clearDict
static void clearDict()
Clears the dictionary.
Definition: NIVissimDistrictConnection.cpp:349
NIVissimSingleTypeParser_Detektordefinition.h
VE_Netzobjektdefinition
Definition: NIVissimElements.h:78
NIImporter_Vissim::NIVissimXMLHandler_VWunschentscheidungsdefinition::myElemData
nodeMap & myElemData
Definition: NIImporter_Vissim.h:308
VE_Signalgruppendefinition
Definition: NIVissimElements.h:60
NIVissimSingleTypeParser_Einheitendefinition.h
NIVissimSingleTypeParser_Startuhrzeit.h
NIVissimSingleTypeParser__XKurvedefinition
Definition: NIVissimSingleTypeParser__XKurvedefinition.h:36
NIImporter_Vissim::VISSIM_ATTR_WIDTH
Definition: NIImporter_Vissim.h:634
StringTokenizer
Definition: StringTokenizer.h:61
NIImporter_Vissim::VISSIM_TAG_DATAPOINT
Definition: NIImporter_Vissim.h:613
NIVissimSingleTypeParser_Streckentypdefinition.h
NIVissimSingleTypeParser_Fensterdefinition
Definition: NIVissimSingleTypeParser_Fensterdefinition.h:36
NIImporter_Vissim::VISSIM_ATTR_X
Definition: NIImporter_Vissim.h:629
NIImporter_Vissim::VISSIM_TAG_DECISION_STATIC
Definition: NIImporter_Vissim.h:614
NIVissimSingleTypeParser_Querschnittsmessungsdefinition.h
NIVissimConnection
Definition: NIVissimConnection.h:45
NIImporter_Vissim::VISSIM_ATTR_INTLINK
Definition: NIImporter_Vissim.h:639
NIImporter_Vissim::VISSIM_TAG_NETWORK
Definition: NIImporter_Vissim.h:596
VE_Querschnittsmessungsdefinition
Definition: NIVissimElements.h:70
VE_Knotendefinition
Definition: NIVissimElements.h:76
NBNetBuilder.h
NIVissimVehicleType.h
NIVissimClosures.h
NIVissimDisturbance::clearDict
static void clearDict()
Definition: NIVissimDisturbance.cpp:324
VE_Simdauer
Definition: NIVissimElements.h:29
VE_Massenverteilungsdefinition
Definition: NIVissimElements.h:52
NIVissimEdge::reportUnsetSpeeds
static void reportUnsetSpeeds()
Writes edges with unset speeds to the warnings message log instance.
Definition: NIVissimEdge.cpp:974
VE_Einheitendefinition
Definition: NIVissimElements.h:84
NIImporter_Vissim::VISSIM_ATTR_ZOFFSET
Definition: NIImporter_Vissim.h:631
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:38
NIVissimSingleTypeParser_Fahrzeugtypdefinition.h
VE_Richtungspfeildefinition
Definition: NIVissimElements.h:79
NIVissimSingleTypeParser_Reisezeitmessungsdefinition.h
VE_Parkplatzdefinition
Definition: NIVissimElements.h:75
VE_VWunschentscheidungsdefinition
Definition: NIVissimElements.h:41
NIVissimSingleTypeParser_Detektordefinition
Definition: NIVissimSingleTypeParser_Detektordefinition.h:36
NIVissimSingleTypeParser_Stopschilddefinition.h
RGBColor::RED
static const RGBColor RED
named colors
Definition: RGBColor.h:189
OptionsCont
A storage for options typed value containers)
Definition: OptionsCont.h:89
NIImporter_Vissim::vissimTags
static StringBijection< int >::Entry vissimTags[]
The names of VISSIM-XML elements (for passing to GenericSAXHandler)
Definition: NIImporter_Vissim.h:653
NIVissimSingleTypeParser_Parkplatzdefinition
Definition: NIVissimSingleTypeParser_Parkplatzdefinition.h:36
VE_Maxbeschleunigungskurvedefinition
Definition: NIVissimElements.h:54
NIImporter_Vissim::VissimSingleTypeParser
Definition: NIImporter_Vissim.h:487
NIVissimSingleTypeParser_Richtungsentscheidungsdefinition.h
VE_Richtungsentscheidungsdefinition
Definition: NIVissimElements.h:39
NIVissimSingleTypeParser_VWunschentscheidungsdefinition
Definition: NIVissimSingleTypeParser_VWunschentscheidungsdefinition.h:36
NIImporter_Vissim::myColorMap
ColorMap myColorMap
a map from color names to color definitions
Definition: NIImporter_Vissim.h:574
NIImporter_Vissim::NIVissimXMLHandler_Routenentscheidungsdefinition::myStartElement
void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
Definition: NIImporter_Vissim.cpp:606
NIVissimSingleTypeParser_Streckendefinition
Definition: NIVissimSingleTypeParser_Streckendefinition.h:36
NIVissimSingleTypeParser_Gelbverhaltendefinition
Definition: NIVissimSingleTypeParser_Gelbverhaltendefinition.h:36
NIVissimSingleTypeParser_Laengenverteilungsdefinition
Definition: NIVissimSingleTypeParser_Laengenverteilungsdefinition.h:36
NIImporter_Vissim::NIVissimXMLHandler_VWunschentscheidungsdefinition::~NIVissimXMLHandler_VWunschentscheidungsdefinition
~NIVissimXMLHandler_VWunschentscheidungsdefinition()
Destructor.
Definition: NIImporter_Vissim.cpp:572
NIImporter_Vissim::NIVissimXMLHandler_Streckendefinition::myStartElement
void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
Definition: NIImporter_Vissim.cpp:219
NIVissimSingleTypeParser_Fahrzeugklassendefinition.h
NIVissimSingleTypeParser_Fahrtverlaufdateien.h
NIImporter_Vissim::VISSIM_TAG_LINKPOLYPOINT
Definition: NIImporter_Vissim.h:603
NIImporter_Vissim::VISSIM_ATTR_LINK2
Definition: NIImporter_Vissim.h:648
NIVissimDistrictConnection::dict_CheckEdgeEnds
static void dict_CheckEdgeEnds()
Definition: NIVissimDistrictConnection.cpp:131
NIImporter_Vissim::NIVissimXMLHandler_VWunschentscheidungsdefinition::myStartElement
void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
Definition: NIImporter_Vissim.cpp:575
NIVissimEdge::dict_buildNBEdges
static void dict_buildNBEdges(NBDistrictCont &dc, NBNodeCont &nc, NBEdgeCont &ec, double offset)
Builds NBEdges from the VissimEdges within the dictionary.
Definition: NIVissimEdge.cpp:240
NIVissimSingleTypeParser_Richtungspfeildefinition.h
NIImporter_Vissim::NIVissimXMLHandler_Fahrzeugklassendefinition
Definition: NIImporter_Vissim.h:224
NIVissimSingleTypeParser_Lichtsignalanlagendefinition.h
NIImporter_Vissim::VISSIM_ATTR_NO
Definition: NIImporter_Vissim.h:627
VE_Fensterdefinition
Definition: NIVissimElements.h:73
NIVissimSingleTypeParser_Auswertungsdefinition.h
NIVissimSingleTypeParser_Richtungsentscheidungsdefinition
Definition: NIVissimSingleTypeParser_Richtungsentscheidungsdefinition.h:36
NIImporter_Vissim::VISSIM_TAG_PARKINGLOT
Definition: NIImporter_Vissim.h:608
NIImporter_Vissim::VISSIM_ATTR_FX
Definition: NIImporter_Vissim.h:644
NIVissimSingleTypeParser_Querverkehrsstoerungsdefinition
Definition: NIVissimSingleTypeParser_Querverkehrsstoerungsdefinition.h:36
NIVissimVehicleType::clearDict
static void clearDict()
Definition: NIVissimVehicleType.cpp:71
NIVissimSingleTypeParser_LSAKopplungsdefinition.h
NIVissimVehTypeClass::dictionary
static bool dictionary(int id, const std::string &name, const RGBColor &color, std::vector< int > &types)
Definition: NIVissimVehTypeClass.cpp:42
VE_TEAPACdefinition
Definition: NIVissimElements.h:77
NIVissimSingleTypeParser_Signalgruppendefinition.h
NIImporter_Vissim::VISSIM_ATTR_LINK
Definition: NIImporter_Vissim.h:638
NIVissimConflictArea::dictionary
static bool dictionary(int id, const std::string &link1, const std::string &link2, const std::string &status)
Adds the described item to the dictionary Builds the conflict area first.
Definition: NIVissimConflictArea.cpp:58
NIVissimConnection::dict_buildNBEdgeConnections
static void dict_buildNBEdgeConnections(NBEdgeCont &ec)
Definition: NIVissimConnection.cpp:266
StringUtils::hexToInt
static int hexToInt(const std::string &sData)
converts a string with a hex value into the integer value described by it by calling the char-type co...
Definition: StringUtils.cpp:321
NIImporter_Vissim::myNetBuilder
NBNetBuilder & myNetBuilder
Definition: NIImporter_Vissim.h:578
VE_Baujahrverteilungsdefinition
Definition: NIVissimElements.h:50
VE_Zeitenverteilungsdefinition
Definition: NIVissimElements.h:49
NIVissimSingleTypeParser_Zusammensetzungsdefinition.h
VE_Reisezeitmessungsdefinition
Definition: NIVissimElements.h:68
OptionsCont::getFloat
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
Definition: OptionsCont.cpp:208
StringUtils.h
NIVissimTL::NIVissimTLSignal::clearDict
static void clearDict()
Definition: NIVissimTL.cpp:111
NIImporter_Vissim::NIVissimXMLHandler_VWunschentscheidungsdefinition::NIVissimXMLHandler_VWunschentscheidungsdefinition
NIVissimXMLHandler_VWunschentscheidungsdefinition(nodeMap &elemData)
Constructor.
Definition: NIImporter_Vissim.cpp:563
StringUtils::toInt
static int toInt(const std::string &sData)
converts a string into the integer value described by it by calling the char-type converter,...
Definition: StringUtils.cpp:278
NIVissimSingleTypeParser_Zusammensetzungsdefinition
Definition: NIVissimSingleTypeParser_Zusammensetzungsdefinition.h:36
NIVissimConnection.h
NIImporter_Vissim::VissimSingleTypeParser::readUntil
void readUntil(std::istream &from, const std::string &name)
Reads from the stream until the keywor occurs.
Definition: NIImporter_Vissim.cpp:813
PROGRESS_BEGIN_MESSAGE
#define PROGRESS_BEGIN_MESSAGE(msg)
Definition: MsgHandler.h:278
NIVissimSingleTypeParser_Fahrzeugklassendefinition
Definition: NIVissimSingleTypeParser_Fahrzeugklassendefinition.h:36
NIVissimSingleTypeParser_Signalgeberdefinition.h
NIVissimSingleTypeParser_Liniendefinition
Definition: NIVissimSingleTypeParser_Liniendefinition.h:36
NIVissimTL.h
NIImporter_Vissim::NIImporter_Vissim
NIImporter_Vissim(NBNetBuilder &nb)
constructor
Definition: NIImporter_Vissim.cpp:839
NBNetBuilder::getTLLogicCont
NBTrafficLightLogicCont & getTLLogicCont()
Returns a reference to the traffic light logics container.
Definition: NBNetBuilder.h:165
NIImporter_Vissim::VISSIM_TAG_CA
Definition: NIImporter_Vissim.h:616
NIImporter_Vissim::VissimSingleTypeParser::parseAssignedVehicleTypes
std::vector< int > parseAssignedVehicleTypes(std::istream &from, const std::string &next)
parses a listof vehicle types assigned to the current data field One should remeber,...
Definition: NIImporter_Vissim.cpp:757
NIVissimBoundedClusterObject::closeLoading
static void closeLoading()
Definition: NIVissimBoundedClusterObject.cpp:62
NIVissimEdge::dict_propagateSpeeds
static void dict_propagateSpeeds()
Definition: NIVissimEdge.cpp:250
Distribution_Points
Definition: Distribution_Points.h:39
NIVissimSingleTypeParser_Laengenverteilungsdefinition.h
NIVissimTrafficDescription::clearDict
static void clearDict()
Definition: NIVissimTrafficDescription.cpp:88
Distribution_Points.h
NIImporter_Vissim::NIVissimXMLHandler_Fahrzeugklassendefinition::NIVissimXMLHandler_Fahrzeugklassendefinition
NIVissimXMLHandler_Fahrzeugklassendefinition(nodeMap &elemData)
Constructor.
Definition: NIImporter_Vissim.cpp:448
NIVissimSingleTypeParser_Geschwindigkeitsverteilungsdefinition.h
NIVissimSingleTypeParser_Routenentscheidungsdefinition
Definition: NIVissimSingleTypeParser_Routenentscheidungsdefinition.h:36
NIVissimDistrictConnection.h
NIImporter_Vissim::NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition::NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition
NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition(nodeMap &elemData)
Constructor.
Definition: NIImporter_Vissim.cpp:513
NIVissimSingleTypeParser_Zeitschrittfaktor.h
PROGRESS_DONE_MESSAGE
#define PROGRESS_DONE_MESSAGE()
Definition: MsgHandler.h:279
NIVissimSingleTypeParser_Netzobjektdefinition.h
NBNetBuilder::getDistrictCont
NBDistrictCont & getDistrictCont()
Returns a reference the districts container.
Definition: NBNetBuilder.h:170
VE_Startuhrzeit
Definition: NIVissimElements.h:30
VE_SimRate
Definition: NIVissimElements.h:31
NIVissimTL::NIVissimTLSignalGroup::clearDict
static void clearDict()
Definition: NIVissimTL.cpp:252
VE_Querverkehrsstoerungsdefinition
Definition: NIVissimElements.h:58
NIVissimSingleTypeParser_SimRate.h
NIVissimSingleTypeParser_Verlustzeitmessungsdefinition.h
NIImporter_Vissim::NIVissimXMLHandler_Streckendefinition::~NIVissimXMLHandler_Streckendefinition
~NIVissimXMLHandler_Streckendefinition()
Destructor.
Definition: NIImporter_Vissim.cpp:216
NIVissimEdge::dict_checkEdges2Join
static void dict_checkEdges2Join()
Definition: NIVissimEdge.cpp:867
NIVissimNodeDef::clearDict
static void clearDict()
Definition: NIVissimNodeDef.cpp:125
NIImporter_Vissim::VISSIM_TAG_NOTHING
Definition: NIImporter_Vissim.h:595
VE_Wunschbeschleunigungskurvedefinition
Definition: NIVissimElements.h:55
NIVissimDisturbance::dict_SetDisturbances
static void dict_SetDisturbances()
Definition: NIVissimDisturbance.cpp:333
NIImporter_Vissim::NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition::myElemData
nodeMap & myElemData
Definition: NIImporter_Vissim.h:363
NIVissimSingleTypeParser_Querverkehrsstoerungsdefinition.h
NIVissimSingleTypeParser_Verlustzeitmessungsdefinition
Definition: NIVissimSingleTypeParser_Verlustzeitmessungsdefinition.h:36
NIImporter_Vissim::VissimSingleTypeParser::overrideOptionalLabel
std::string overrideOptionalLabel(std::istream &from, const std::string &tag="")
overrides the optional label definition; returns the next tag as done by readEndSecure
Definition: NIImporter_Vissim.cpp:727
NIImporter_Vissim::VISSIM_TAG_LINKPOLYPTS
Definition: NIImporter_Vissim.h:604
NIVissimNodeDef::getMaxID
static int getMaxID()
Definition: NIVissimNodeDef.cpp:134
StringTokenizer::getVector
std::vector< std::string > getVector()
return vector of strings
Definition: StringTokenizer.cpp:191
VE_Streckendefinition
Definition: NIVissimElements.h:37
NIVissimSingleTypeParser_Verbindungsdefinition
Definition: NIVissimSingleTypeParser_Verbindungsdefinition.h:37
NIImporter_Vissim::myLastSecure
std::string myLastSecure
Definition: NIImporter_Vissim.h:576
NIVissimSingleTypeParser_SimRate
Definition: NIVissimSingleTypeParser_SimRate.h:36
NIVissimConnectionCluster::buildNodeClusters
static void buildNodeClusters()
Definition: NIVissimConnectionCluster.cpp:485
config.h
VE_DUMMY
Definition: NIVissimElements.h:87
NIVissimSingleTypeParser_Langsamfahrbereichdefinition
Definition: NIVissimSingleTypeParser_Langsamfahrbereichdefinition.h:36
NIImporter_Vissim::VISSIM_TAG_LANE
Definition: NIImporter_Vissim.h:598
NIImporter_Vissim::buildParsers
void buildParsers()
adds id-to-parser - relationships of elements to parse into myParsers
Definition: NIImporter_Vissim.cpp:1140
NIVissimSingleTypeParser_Signalgeberdefinition
Definition: NIVissimSingleTypeParser_Signalgeberdefinition.h:36
VE_Fahrzeugklassendefinition
Definition: NIVissimElements.h:45
NIImporter_Vissim::postLoadBuild
void postLoadBuild(double offset)
Definition: NIImporter_Vissim.cpp:1015
NIVissimConnection::dictionary
static bool dictionary(int id, NIVissimConnection *o)
Definition: NIVissimConnection.cpp:77
NIVissimConflictArea::setPriorityRegulation
static void setPriorityRegulation(NBEdgeCont &ec)
Sets the priority regulation according to the VISSIM conflict area data.
Definition: NIVissimConflictArea.cpp:117
NIVissimNodeCluster::dict_addDisturbances
static void dict_addDisturbances(NBDistrictCont &dc, NBNodeCont &nc, NBEdgeCont &ec)
Definition: NIVissimNodeCluster.cpp:270
VE_LSAKopplungdefinition
Definition: NIVissimElements.h:62
NIVissimSingleTypeParser_DynUml.h
NIVissimNodeCluster::setCurrentVirtID
static void setCurrentVirtID(int id)
Definition: NIVissimNodeCluster.cpp:294
StringTokenizer.h
NIVissimSingleTypeParser_Rautedefinition.h
NIVissimSingleTypeParser_Zeitschrittfaktor
Definition: NIVissimSingleTypeParser_Zeitschrittfaktor.h:36
NIVissimSingleTypeParser_Langsamfahrbereichdefinition.h
NIImporter_Vissim::NIVissimXMLHandler_Routenentscheidungsdefinition::myEndElement
void myEndElement(int element)
Callback method for a closing tag to implement by derived classes.
Definition: NIImporter_Vissim.cpp:626
NIVissimSingleTypeParser__XVerteilungsdefinition
Definition: NIVissimSingleTypeParser__XVerteilungsdefinition.h:36
VE_Linksverkehr
Definition: NIVissimElements.h:33
RGBColor::GREEN
static const RGBColor GREEN
Definition: RGBColor.h:190
NIVissimSingleTypeParser_Stauzaehlerdefinition.h
NIImporter_Vissim::VissimSingleTypeParser::myRead
std::string myRead(std::istream &from)
reads from the stream and returns the lower case version of the read value
Definition: NIImporter_Vissim.cpp:670
NIImporter_Vissim::VISSIM_TAG_VEHICLE_CLASS
Definition: NIImporter_Vissim.h:609
NIImporter_Vissim::nodeMap
std::map< std::string, std::list< std::string > > nodeMap
Definition: NIImporter_Vissim.h:77
NIImporter_Vissim::NIVissimXMLHandler_Routenentscheidungsdefinition::NIVissimXMLHandler_Routenentscheidungsdefinition
NIVissimXMLHandler_Routenentscheidungsdefinition(nodeMap &elemData)
Constructor.
Definition: NIImporter_Vissim.cpp:594
NIImporter_Vissim::NIVissimXMLHandler_Fahrzeugklassendefinition::myEndElement
void myEndElement(int element)
Callback method for a closing tag to implement by derived classes.
Definition: NIImporter_Vissim.cpp:482
NIVissimSingleTypeParser_Zuflussdefinition
Definition: NIVissimSingleTypeParser_Zuflussdefinition.h:36
NIImporter_Vissim::NIVissimXMLHandler_ConflictArea::myStartElement
void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
Definition: NIImporter_Vissim.cpp:641
NIImporter_Vissim::NIVissimXMLHandler_Zuflussdefinition::~NIVissimXMLHandler_Zuflussdefinition
~NIVissimXMLHandler_Zuflussdefinition()
Destructor.
Definition: NIImporter_Vissim.cpp:386
NBNetBuilder::getNodeCont
NBNodeCont & getNodeCont()
Returns a reference to the node container.
Definition: NBNetBuilder.h:155
NIImporter_Vissim::NIVissimXMLHandler_Zuflussdefinition
Definition: NIImporter_Vissim.h:140
NIImporter_Vissim::VISSIM_TAG_VEHICLE_INPUT
Definition: NIImporter_Vissim.h:607
NIVissimSingleTypeParser_Fahrzeugtypdefinition
Definition: NIVissimSingleTypeParser_Fahrzeugtypdefinition.h:36
NIVissimSingleTypeParser_Geschwindigkeitsverteilungsdefinition
Definition: NIVissimSingleTypeParser_Geschwindigkeitsverteilungsdefinition.h:36
GenericSAXHandler
A handler which converts occuring elements and attributes into enums.
Definition: GenericSAXHandler.h:67
NIVissimSingleTypeParser_Simdauer.h
NIImporter_Vissim::NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition::~NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition
~NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition()
Destructor.
Definition: NIImporter_Vissim.cpp:522
VE_Verkehrszusammensetzungsdefinition
Definition: NIVissimElements.h:46
NIImporter_Vissim::NIVissimXMLHandler_Routenentscheidungsdefinition::~NIVissimXMLHandler_Routenentscheidungsdefinition
~NIVissimXMLHandler_Routenentscheidungsdefinition()
Destructor.
Definition: NIImporter_Vissim.cpp:603
NIImporter_Vissim::~NIImporter_Vissim
~NIImporter_Vissim()
destructor
Definition: NIImporter_Vissim.cpp:857
NIVissimSingleTypeParser_Routenentscheidungsdefinition.h
NIImporter_Vissim::NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition
Definition: NIImporter_Vissim.h:331
SUMOSAXAttributes
Encapsulated SAX-Attributes.
Definition: SUMOSAXAttributes.h:56
NIVissimSingleTypeParser_VWunschentscheidungsdefinition.h
NIVissimSingleTypeParser__XVerteilungsdefinition.h
NIImporter_Vissim.h
NIVissimSingleTypeParser_Verbindungsdefinition.h
VE_Lichtsignalanlagendefinition
Definition: NIVissimElements.h:59
WRITE_ERROR
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:283
NIImporter_Vissim::NIVissimXMLHandler_Fahrzeugklassendefinition::myStartElement
void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
Definition: NIImporter_Vissim.cpp:460
VE_Rautedefinition
Definition: NIVissimElements.h:80
NIImporter_Vissim::VISSIM_ATTR_STATUS
Definition: NIImporter_Vissim.h:649
NIVissimSingleTypeParser_Fahrverhaltendefinition.h
NIImporter_Vissim::VISSIM_ATTR_DESTPOS
Definition: NIImporter_Vissim.h:646
DistributionCont.h
NIImporter_Vissim::loadNetwork
static void loadNetwork(const OptionsCont &oc, NBNetBuilder &nb)
Loads network definition from the assigned option and stores it in the given network builder.
Definition: NIImporter_Vissim.cpp:193
NIVissimSingleTypeParser_Knotendefinition.h
NIVissimConnectionCluster::clearDict
static void clearDict()
Definition: NIVissimConnectionCluster.cpp:688
VE_Stauzaehlerdefinition
Definition: NIVissimElements.h:71
NIVissimTrafficDescription.h
NIVissimSingleTypeParser_Kantensperrung
Definition: NIVissimSingleTypeParser_Kantensperrung.h:36
NIVissimSingleTypeParser_Linksverkehr.h
NIImporter_Vissim::VissimSingleTypeParser::VissimSingleTypeParser
VissimSingleTypeParser(NIImporter_Vissim &parent)
Constructor.
Definition: NIImporter_Vissim.cpp:662
NIImporter_Vissim::NIVissimXMLHandler_Zuflussdefinition::NIVissimXMLHandler_Zuflussdefinition
NIVissimXMLHandler_Zuflussdefinition()
Constructor.
Definition: NIImporter_Vissim.cpp:380
NIVissimSingleTypeParser_Stauparameterdefinition.h
NIVissimSingleTypeParser_Startzufallszahl.h
NIVissimConnectionCluster::joinBySameEdges
static void joinBySameEdges(double offset)
Tries to joind clusters participating within a node This is done by joining clusters which overlap.
Definition: NIVissimConnectionCluster.cpp:209
NIVissimConflictArea::clearDict
static void clearDict()
Clears the dictionary.
Definition: NIVissimConflictArea.cpp:108
NIVissimSingleTypeParser_LSAKopplungsdefinition
Definition: NIVissimSingleTypeParser_LSAKopplungsdefinition.h:36
GenericSAXHandler::setFileName
void setFileName(const std::string &name)
Sets the current file name.
Definition: GenericSAXHandler.cpp:68
XMLSubSys.h
RGBColor::WHITE
static const RGBColor WHITE
Definition: RGBColor.h:196
VE_Leistungsverteilungsdefinition
Definition: NIVissimElements.h:53
NIImporter_Vissim::NIVissimXMLHandler_ConflictArea
Definition: NIImporter_Vissim.h:437
NIVissimSingleTypeParser_Messungsdefinition
Definition: NIVissimSingleTypeParser_Messungsdefinition.h:36
NIVissimSingleTypeParser_Netzobjektdefinition
Definition: NIVissimSingleTypeParser_Netzobjektdefinition.h:36
VE_Emission
Definition: NIVissimElements.h:83
NIImporter_Vissim::VISSIM_TAG_FROM
Definition: NIImporter_Vissim.h:605