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 /****************************************************************************/
10 /// @file    NIImporter_Vissim.cpp
11 /// @author  Daniel Krajzewicz
12 /// @author  Jakob Erdmann
13 /// @author  Michael Behrisch
14 /// @author  Lukas Grohmann (AIT)
15 /// @author  Gerald Richter (AIT)
16 /// @date    Sept 2002
17 /// @version $Id$
18 ///
19 // -------------------
20 /****************************************************************************/
21 
22 
23 // ===========================================================================
24 // included modules
25 // ===========================================================================
26 #include <config.h>
27 
28 
29 #include <string>
30 #include <fstream>
31 #include <utils/common/StringUtils.h>
32 #include <utils/common/StringUtils.h>
33 #include <utils/common/MsgHandler.h>
34 #include <utils/options/OptionsCont.h>
35 #include <netbuild/NBNetBuilder.h>
36 #include "NIImporter_Vissim.h"
37 #include "typeloader/NIVissimSingleTypeParser_Simdauer.h"
38 #include "typeloader/NIVissimSingleTypeParser_Startuhrzeit.h"
39 #include "typeloader/NIVissimSingleTypeParser_DynUml.h"
40 #include "typeloader/NIVissimSingleTypeParser_Streckendefinition.h"
41 #include "typeloader/NIVissimSingleTypeParser_Verbindungsdefinition.h"
42 #include "typeloader/NIVissimSingleTypeParser_Richtungsentscheidungsdefinition.h"
43 #include "typeloader/NIVissimSingleTypeParser_Routenentscheidungsdefinition.h"
44 #include "typeloader/NIVissimSingleTypeParser_VWunschentscheidungsdefinition.h"
45 #include "typeloader/NIVissimSingleTypeParser_Langsamfahrbereichdefinition.h"
46 #include "typeloader/NIVissimSingleTypeParser_Zuflussdefinition.h"
47 #include "typeloader/NIVissimSingleTypeParser_Fahrzeugtypdefinition.h"
48 #include "typeloader/NIVissimSingleTypeParser_Fahrzeugklassendefinition.h"
49 #include "typeloader/NIVissimSingleTypeParser_Verkehrszusammensetzungsdefinition.h"
50 #include "typeloader/NIVissimSingleTypeParser_Geschwindigkeitsverteilungsdefinition.h"
51 #include "typeloader/NIVissimSingleTypeParser_Laengenverteilungsdefinition.h"
52 #include "typeloader/NIVissimSingleTypeParser_Zeitenverteilungsdefinition.h"
53 #include "typeloader/NIVissimSingleTypeParser_Querverkehrsstoerungsdefinition.h"
54 #include "typeloader/NIVissimSingleTypeParser_Lichtsignalanlagendefinition.h"
55 #include "typeloader/NIVissimSingleTypeParser_Signalgruppendefinition.h"
56 #include "typeloader/NIVissimSingleTypeParser_Stopschilddefinition.h"
57 #include "typeloader/NIVissimSingleTypeParser_Knotendefinition.h"
58 #include "typeloader/NIVissimSingleTypeParser_Signalgeberdefinition.h"
59 #include "typeloader/NIVissimSingleTypeParser_Detektordefinition.h"
60 #include "typeloader/NIVissimSingleTypeParser_Liniendefinition.h"
61 #include "typeloader/NIVissimSingleTypeParser_Haltestellendefinition.h"
62 #include "typeloader/NIVissimSingleTypeParser_Reisezeitmessungsdefinition.h"
63 #include "typeloader/NIVissimSingleTypeParser_Querschnittsmessungsdefinition.h"
64 #include "typeloader/NIVissimSingleTypeParser_Messungsdefinition.h"
65 #include "typeloader/NIVissimSingleTypeParser_Verlustzeitmessungsdefinition.h"
66 #include "typeloader/NIVissimSingleTypeParser_Stauzaehlerdefinition.h"
67 #include "typeloader/NIVissimSingleTypeParser_Richtungspfeildefinition.h"
68 #include "typeloader/NIVissimSingleTypeParser_Parkplatzdefinition.h"
69 #include "typeloader/NIVissimSingleTypeParser_Fahrverhaltendefinition.h"
70 #include "typeloader/NIVissimSingleTypeParser_Streckentypdefinition.h"
71 #include "typeloader/NIVissimSingleTypeParser_Kennungszeile.h"
72 #include "typeloader/NIVissimSingleTypeParser_Fensterdefinition.h"
73 #include "typeloader/NIVissimSingleTypeParser_Auswertungsdefinition.h"
74 #include "typeloader/NIVissimSingleTypeParser_Zusammensetzungsdefinition.h"
75 #include "typeloader/NIVissimSingleTypeParser_Startzufallszahl.h"
76 #include "typeloader/NIVissimSingleTypeParser_SimRate.h"
77 #include "typeloader/NIVissimSingleTypeParser_Zeitschrittfaktor.h"
78 #include "typeloader/NIVissimSingleTypeParser_Linksverkehr.h"
79 #include "typeloader/NIVissimSingleTypeParser_Stauparameterdefinition.h"
80 #include "typeloader/NIVissimSingleTypeParser_Gelbverhaltendefinition.h"
81 #include "typeloader/NIVissimSingleTypeParser_LSAKopplungsdefinition.h"
82 #include "typeloader/NIVissimSingleTypeParser_Gefahrwarnungsdefinition.h"
83 #include "typeloader/NIVissimSingleTypeParser_TEAPACDefinition.h"
84 #include "typeloader/NIVissimSingleTypeParser_Netzobjektdefinition.h"
85 #include "typeloader/NIVissimSingleTypeParser_Fahrtverlaufdateien.h"
86 #include "typeloader/NIVissimSingleTypeParser_Emission.h"
87 #include "typeloader/NIVissimSingleTypeParser_Einheitendefinition.h"
88 #include "typeloader/NIVissimSingleTypeParser__XVerteilungsdefinition.h"
89 #include "typeloader/NIVissimSingleTypeParser__XKurvedefinition.h"
90 #include "typeloader/NIVissimSingleTypeParser_Kantensperrung.h"
91 #include "typeloader/NIVissimSingleTypeParser_Rautedefinition.h"
92 
93 
94 #include "tempstructs/NIVissimTL.h"
95 #include "tempstructs/NIVissimClosures.h"
96 #include "tempstructs/NIVissimSource.h"
97 #include "tempstructs/NIVissimTrafficDescription.h"
98 #include "tempstructs/NIVissimVehTypeClass.h"
99 #include "tempstructs/NIVissimConnection.h"
100 #include "tempstructs/NIVissimDisturbance.h"
101 #include "tempstructs/NIVissimConnectionCluster.h"
102 #include "tempstructs/NIVissimNodeDef.h"
103 #include "tempstructs/NIVissimEdge.h"
104 #include "tempstructs/NIVissimConflictArea.h"
105 #include "tempstructs/NIVissimDistrictConnection.h"
106 #include "tempstructs/NIVissimVehicleType.h"
107 
108 #include <utils/xml/SUMOSAXHandler.h>
109 #include <utils/xml/XMLSubSys.h>
110 #include <utils/common/FileHelpers.h>
111 #include <utils/common/StringTokenizer.h>
112 #include <utils/distribution/Distribution_Points.h>
113 #include <utils/distribution/DistributionCont.h>
114 
115 #include <netbuild/NBEdgeCont.h> // !!! only for debugging purposes
116 
117 
118 // ===========================================================================
119 // static variables
120 // ===========================================================================
121 StringBijection<int>::Entry NIImporter_Vissim::vissimTags[] = {
122     { "network",          NIImporter_Vissim::VISSIM_TAG_NETWORK },
123     { "lanes",            NIImporter_Vissim::VISSIM_TAG_LANES },
124     { "lane",             NIImporter_Vissim::VISSIM_TAG_LANE },
125     { "link",             NIImporter_Vissim::VISSIM_TAG_LINK },
126     { "links",            NIImporter_Vissim::VISSIM_TAG_LINKS },
127     { "points3D",         NIImporter_Vissim::VISSIM_TAG_POINTS3D },
128     { "point3D",          NIImporter_Vissim::VISSIM_TAG_POINT3D },
129     { "fromLinkEndPt",    NIImporter_Vissim::VISSIM_TAG_FROM },
130     { "toLinkEndPt",      NIImporter_Vissim::VISSIM_TAG_TO },
131     { "vehicleInput",     NIImporter_Vissim::VISSIM_TAG_VEHICLE_INPUT },
132     { "parkingLot",       NIImporter_Vissim::VISSIM_TAG_PARKINGLOT },
133     { "vehicleClass",     NIImporter_Vissim::VISSIM_TAG_VEHICLE_CLASS },
134     { "intObjectRef",     NIImporter_Vissim::VISSIM_TAG_INTOBJECTREF },
135     { "desSpeedDecision", NIImporter_Vissim::VISSIM_TAG_SPEED_DECISION },
136     {
137         "desSpeedDistribution",
138         NIImporter_Vissim::VISSIM_TAG_SPEED_DIST
139     },
140     {
141         "speedDistributionDataPoint",
142         NIImporter_Vissim::VISSIM_TAG_DATAPOINT
143     },
144     {
145         "vehicleRoutingDecisionStatic",
146         NIImporter_Vissim::VISSIM_TAG_DECISION_STATIC
147     },
148     {
149         "vehicleRouteStatic",
150         NIImporter_Vissim::VISSIM_TAG_ROUTE_STATIC
151     },
152     { "conflictArea",     NIImporter_Vissim::VISSIM_TAG_CA },
153     { "",                 NIImporter_Vissim::VISSIM_TAG_NOTHING }
154 };
155 
156 
157 StringBijection<int>::Entry NIImporter_Vissim::vissimAttrs[] = {
158     { "no",             NIImporter_Vissim::VISSIM_ATTR_NO }, //id
159     { "name",           NIImporter_Vissim::VISSIM_ATTR_NAME },
160     { "x",              NIImporter_Vissim::VISSIM_ATTR_X },
161     { "y",              NIImporter_Vissim::VISSIM_ATTR_Y },
162     { "zOffset",        NIImporter_Vissim::VISSIM_ATTR_ZOFFSET },
163     { "surch1",         NIImporter_Vissim::VISSIM_ATTR_ZUSCHLAG1 },
164     { "surch2",         NIImporter_Vissim::VISSIM_ATTR_ZUSCHLAG2 },
165     { "width",          NIImporter_Vissim::VISSIM_ATTR_WIDTH },
166     { "linkBehavType",  NIImporter_Vissim::VISSIM_ATTR_LINKBEHAVETYPE},
167     { "lane",           NIImporter_Vissim::VISSIM_ATTR_LANE },
168     { "pos",            NIImporter_Vissim::VISSIM_ATTR_POS },
169     { "link",           NIImporter_Vissim::VISSIM_ATTR_LINK },
170     { "intLink",        NIImporter_Vissim::VISSIM_ATTR_INTLINK }, //edgeID
171     { "relFlow",        NIImporter_Vissim::VISSIM_ATTR_PERCENTAGE },
172     { "zone",           NIImporter_Vissim::VISSIM_ATTR_DISTRICT },
173     { "color",          NIImporter_Vissim::VISSIM_ATTR_COLOR },
174     { "key",            NIImporter_Vissim::VISSIM_ATTR_KEY },
175     { "fx",             NIImporter_Vissim::VISSIM_ATTR_FX },
176     { "destLink",       NIImporter_Vissim::VISSIM_ATTR_DESTLINK },
177     { "destPos",        NIImporter_Vissim::VISSIM_ATTR_DESTPOS },
178     { "link1",          NIImporter_Vissim::VISSIM_ATTR_LINK1 },
179     { "link2",          NIImporter_Vissim::VISSIM_ATTR_LINK2 },
180     { "status",         NIImporter_Vissim::VISSIM_ATTR_STATUS },
181     { "",               NIImporter_Vissim::VISSIM_ATTR_NOTHING }
182 };
183 
184 
185 // ===========================================================================
186 // method definitions
187 // ===========================================================================
188 // ---------------------------------------------------------------------------
189 // static methods (interface in this case)
190 // ---------------------------------------------------------------------------
191 void
loadNetwork(const OptionsCont & oc,NBNetBuilder & nb)192 NIImporter_Vissim::loadNetwork(const OptionsCont& oc, NBNetBuilder& nb) {
193     if (!oc.isSet("vissim-file")) {
194         return;
195     }
196     NIImporter_Vissim loader(nb, oc.getString("vissim-file"));
197     // check if legacy format file or newer XML file
198     // file name extension check
199     if ((oc.getString("vissim-file").find(".inpx") != std::string::npos))
200         //TODO: check if the given position of .inpx is at the end
201     {
202         // load the XML vissim network
203         loader.loadXML(oc, nb);
204         loader.myInputIsLegacyFormat = false;
205     } else {
206         // load the legacy vissim network
207         loader.load(oc);
208         loader.myInputIsLegacyFormat = true;
209     }
210 }
211 
212 
213 // ---------------------------------------------------------------------------
214 // definitions of NIVissimXMLHandler_Streckendefinition-methods
215 // ---------------------------------------------------------------------------
NIVissimXMLHandler_Streckendefinition(nodeMap & elemData)216 NIImporter_Vissim::NIVissimXMLHandler_Streckendefinition::NIVissimXMLHandler_Streckendefinition(
217     //std::map<int, VissimXMLEdge>& toFill)
218     nodeMap& elemData)
219     : GenericSAXHandler(vissimTags, VISSIM_TAG_NOTHING,
220                         vissimAttrs, VISSIM_ATTR_NOTHING,
221                         "vissim - file"),
222       myElemData(elemData),
223       myHierarchyLevel(0),
224       isConnector(false) {
225     myElemData.clear();
226 }
227 
~NIVissimXMLHandler_Streckendefinition()228 NIImporter_Vissim::NIVissimXMLHandler_Streckendefinition::~NIVissimXMLHandler_Streckendefinition() { }
229 
230 void
myStartElement(int element,const SUMOSAXAttributes & attrs)231 NIImporter_Vissim::NIVissimXMLHandler_Streckendefinition::myStartElement(int element, const SUMOSAXAttributes& attrs) {
232     myHierarchyLevel++;
233 
234     // finding an actual LINK
235     if (element == VISSIM_TAG_LINK) {
236         //parse all links
237         bool ok = true;
238         int id = attrs.get<int>(VISSIM_ATTR_NO, nullptr, ok);
239         myLastNodeID = id;
240 
241         // !!! assuming empty myElemData
242         myElemData["id"].push_back(attrs.get<std::string>(VISSIM_ATTR_NO, nullptr, ok));
243         // error ignored if name is empty
244         myElemData["name"].push_back(attrs.get<std::string>(VISSIM_ATTR_NAME, nullptr, ok, false));
245         myElemData["type"].push_back(attrs.get<std::string>(VISSIM_ATTR_LINKBEHAVETYPE, nullptr, ok));
246         myElemData["zuschlag1"].push_back(attrs.get<std::string>(VISSIM_ATTR_ZUSCHLAG1, nullptr, ok));
247         myElemData["zuschlag2"].push_back(attrs.get<std::string>(VISSIM_ATTR_ZUSCHLAG2, nullptr, ok));
248     }
249 
250     if (element == VISSIM_TAG_LANE) {
251         bool ok = true;
252         // appends empty element if no width found
253         // error ignored if name is empty
254         myElemData["width"].push_back(attrs.get<std::string>(VISSIM_ATTR_WIDTH, nullptr, ok, false));
255     }
256 
257     if (element == VISSIM_TAG_FROM) {
258         if (isConnector != true) {
259             isConnector = true;
260         }
261         bool ok = true;
262         std::vector<std::string> from(StringTokenizer(attrs.get<std::string>(
263                                           VISSIM_ATTR_LANE, nullptr, ok), " ").getVector());
264         myElemData["from_pos"].push_back(attrs.get<std::string>(VISSIM_ATTR_POS, nullptr, ok));
265         myElemData["from_id"].push_back(from[0]);
266         myElemData["from_lane"].push_back(from[1]);
267     }
268 
269     if (element == VISSIM_TAG_TO) {
270         bool ok = true;
271         std::vector<std::string> to(StringTokenizer(attrs.get<std::string>(
272                                         VISSIM_ATTR_LANE, nullptr, ok), " ").getVector());
273         myElemData["to_pos"].push_back(attrs.get<std::string>(VISSIM_ATTR_POS, nullptr, ok));
274         myElemData["to_id"].push_back(to[0]);
275         myElemData["to_lane"].push_back(to[1]);
276     }
277 
278     if (element == VISSIM_TAG_POINT3D) {
279         bool ok = true;
280         // create a <sep> separated string of coordinate data
281         std::string sep(" ");
282 
283         std::string posS(attrs.get<std::string>(VISSIM_ATTR_X, nullptr, ok));
284         posS += sep;
285         posS.append(attrs.get<std::string>(VISSIM_ATTR_Y, nullptr, ok));
286         // allow for no Z
287         std::string z(attrs.get<std::string>(VISSIM_ATTR_ZOFFSET, nullptr, ok, false));
288         if (z.length() > 0) {
289             posS += sep;
290             posS.append(z);
291         }
292         myElemData["pos"].push_back(posS);
293     }
294 
295 
296 }
297 
298 void
myEndElement(int element)299 NIImporter_Vissim::NIVissimXMLHandler_Streckendefinition::myEndElement(int element) {
300     if (element == VISSIM_TAG_LINK && myHierarchyLevel == 3) {
301         //std::cout << "elemData len:" << myElemData.size() << std::endl;
302 
303         NIVissimClosedLanesVector clv;          //FIXME -> clv einlesen
304         std::vector<int> assignedVehicles;      //FIXME -> assignedVehicles einlesen
305         int id(StringUtils::toInt(myElemData["id"].front()));
306 
307         PositionVector geom;
308         // convert all position coordinate strings to PositionVectors
309         while (!myElemData["pos"].empty()) {
310             std::vector<std::string> sPos_v(StringTokenizer(
311                                                 myElemData["pos"].front(), " ").getVector());
312             myElemData["pos"].pop_front();
313             std::vector<double> pos_v(3);
314 
315             // doing a transform with explicit hint on function signature
316             std::transform(sPos_v.begin(), sPos_v.end(), pos_v.begin(),
317                            StringUtils::toDouble);
318             geom.push_back_noDoublePos(Position(pos_v[0], pos_v[1], pos_v[2]));
319         }
320         // FIXME: a length = 0 PosVec seems fatal -> segfault
321         double length(geom.length());
322 
323         if (isConnector == false) {
324             // Add Edge
325             std::vector<double> laneWidths;
326             for (std::string& w : myElemData["width"]) {
327                 laneWidths.push_back(StringUtils::toDouble(w));
328             }
329             NIVissimEdge* edge = new NIVissimEdge(id,
330                                                   myElemData["name"].front(),
331                                                   myElemData["type"].front(),
332                                                   laneWidths,
333                                                   StringUtils::toDouble(myElemData["zuschlag1"].front()),
334                                                   StringUtils::toDouble(myElemData["zuschlag2"].front()),
335                                                   length, geom, clv);
336             NIVissimEdge::dictionary(id, edge);
337             if (id == 85 || id == 91) {
338                 std::cout << id << "\n";
339                 std::cout << myElemData["width"].size() << "\n";
340                 std::cout << length << "\n";
341                 std::cout << geom << "\n";
342             }
343         } else {
344             int numLanes = (int)myElemData["width"].size();
345             std::vector<int> laneVec(numLanes);
346             // Add Connector
347 
348             //NOTE: there should be only 1 lane number in XML
349             // subtraction of 1 as in readExtEdgePointDef()
350             laneVec[0] = StringUtils::toInt(myElemData["from_lane"].front()) - 1;
351             // then count up, building lane number vector
352             for (std::vector<int>::iterator each = ++laneVec.begin(); each != laneVec.end(); ++each) {
353                 *each = *(each - 1) + 1;
354             }
355 
356             NIVissimExtendedEdgePoint from_def(
357                 StringUtils::toInt(myElemData["from_id"].front()),
358                 laneVec,
359                 StringUtils::toDouble(myElemData["from_pos"].front()),
360                 assignedVehicles);
361 
362             //NOTE: there should be only 1 lane number in XML
363             // subtraction of 1 as in readExtEdgePointDef()
364             laneVec[0] = StringUtils::toInt(myElemData["to_lane"].front()) - 1;
365             // then count up, building lane number vector
366             for (std::vector<int>::iterator each = ++laneVec.begin(); each != laneVec.end(); ++each) {
367                 *each = *(each - 1) + 1;
368             }
369 
370             NIVissimExtendedEdgePoint to_def(
371                 StringUtils::toInt(myElemData["to_id"].front()),
372                 laneVec,
373                 StringUtils::toDouble(myElemData["to_pos"].front()),
374                 assignedVehicles);
375 
376             NIVissimConnection* connector = new
377             NIVissimConnection(id,
378                                myElemData["name"].front(),
379                                from_def, to_def,
380                                geom, assignedVehicles, clv);
381 
382             NIVissimConnection::dictionary(id, connector);
383         }
384         // clear the element data
385         myElemData.clear();
386         isConnector = false;
387         //std::cout << "elemData len (clear):" << myElemData.size() << std::endl;
388         //std::cout.flush();
389 
390     }
391     --myHierarchyLevel;
392 }
393 
394 
395 // ---------------------------------------------------------------------------
396 // definitions of NIVissimXMLHandler_Zuflussdefinition-methods
397 // ---------------------------------------------------------------------------
NIVissimXMLHandler_Zuflussdefinition()398 NIImporter_Vissim::NIVissimXMLHandler_Zuflussdefinition::NIVissimXMLHandler_Zuflussdefinition()
399     : GenericSAXHandler(vissimTags, VISSIM_TAG_NOTHING,
400                         vissimAttrs, VISSIM_ATTR_NOTHING,
401                         "vissim - file") {
402 }
403 
~NIVissimXMLHandler_Zuflussdefinition()404 NIImporter_Vissim::NIVissimXMLHandler_Zuflussdefinition::~NIVissimXMLHandler_Zuflussdefinition() { }
405 
406 void
myStartElement(int element,const SUMOSAXAttributes & attrs)407 NIImporter_Vissim::NIVissimXMLHandler_Zuflussdefinition::myStartElement(int element, const SUMOSAXAttributes& attrs) {
408     // finding an actual flow
409     if (element == VISSIM_TAG_VEHICLE_INPUT) {
410         //parse all flows
411         bool ok = true;
412         std::string id = attrs.get<std::string>(VISSIM_ATTR_NO, nullptr, ok);
413         std::string edgeid = attrs.get<std::string>(VISSIM_ATTR_LINK, nullptr, ok);
414         std::string name = attrs.get<std::string>(VISSIM_ATTR_NAME, nullptr, ok, false);
415 
416         NIVissimSource::dictionary(id,
417                                    name,
418                                    edgeid);
419     }
420 }
421 
422 // ---------------------------------------------------------------------------
423 // definitions of NIVissimXMLHandler_Parkplatzdefinition-methods
424 // ---------------------------------------------------------------------------
NIVissimXMLHandler_Parkplatzdefinition()425 NIImporter_Vissim::NIVissimXMLHandler_Parkplatzdefinition::NIVissimXMLHandler_Parkplatzdefinition()
426     : GenericSAXHandler(vissimTags, VISSIM_TAG_NOTHING,
427                         vissimAttrs, VISSIM_ATTR_NOTHING,
428                         "vissim - file") {
429 }
430 
~NIVissimXMLHandler_Parkplatzdefinition()431 NIImporter_Vissim::NIVissimXMLHandler_Parkplatzdefinition::~NIVissimXMLHandler_Parkplatzdefinition() { }
432 
433 void
myStartElement(int element,const SUMOSAXAttributes & attrs)434 NIImporter_Vissim::NIVissimXMLHandler_Parkplatzdefinition::myStartElement(int element, const SUMOSAXAttributes& attrs) {
435     // finding an actual parkinglot
436     if (element == VISSIM_TAG_PARKINGLOT) {
437         //parse all parkinglots
438         bool ok = true;
439         int id = attrs.get<int>(VISSIM_ATTR_NO, nullptr, ok);
440         int edgeid = attrs.get<int>(VISSIM_ATTR_INTLINK, nullptr, ok);
441         std::string name = attrs.get<std::string>(VISSIM_ATTR_NAME, nullptr, ok, false);
442         double position = attrs.get<double>(VISSIM_ATTR_POS, nullptr, ok);
443         std::vector<std::pair<int, int> > assignedVehicles; // (vclass, vwunsch)
444         //FIXME: vWunsch + Fahzeugklassen einlesen
445         // There can be s
446         std::vector<int> districts;
447         //FIXME: Parkplatzdefinition für mehrere Zonen implementieren
448         std::vector<double> percentages;
449         districts.push_back(attrs.get<int>(VISSIM_ATTR_DISTRICT, nullptr, ok));
450         percentages.push_back(attrs.get<double>(VISSIM_ATTR_PERCENTAGE, nullptr, ok));
451 
452         NIVissimDistrictConnection::dictionary(id,
453                                                name,
454                                                districts,
455                                                percentages,
456                                                edgeid,
457                                                position,
458                                                assignedVehicles);
459     }
460 }
461 
462 
463 // ---------------------------------------------------------------------------
464 // definitions of NIVissimXMLHandler_Fahrzeugklassendefinition-methods
465 // ---------------------------------------------------------------------------
NIVissimXMLHandler_Fahrzeugklassendefinition(nodeMap & elemData)466 NIImporter_Vissim::NIVissimXMLHandler_Fahrzeugklassendefinition::NIVissimXMLHandler_Fahrzeugklassendefinition(nodeMap& elemData)
467     : GenericSAXHandler(vissimTags, VISSIM_TAG_NOTHING,
468                         vissimAttrs, VISSIM_ATTR_NOTHING,
469                         "vissim - file"),
470       myElemData(elemData),
471       myHierarchyLevel(0) {
472     myElemData.clear();
473 }
474 
~NIVissimXMLHandler_Fahrzeugklassendefinition()475 NIImporter_Vissim::NIVissimXMLHandler_Fahrzeugklassendefinition::~NIVissimXMLHandler_Fahrzeugklassendefinition() { }
476 
477 void
myStartElement(int element,const SUMOSAXAttributes & attrs)478 NIImporter_Vissim::NIVissimXMLHandler_Fahrzeugklassendefinition::myStartElement(int element, const SUMOSAXAttributes& attrs) {
479     myHierarchyLevel++;
480 
481     if (element == VISSIM_TAG_VEHICLE_CLASS) {
482         bool ok = true;
483         myElemData["id"].push_back(attrs.get<std::string>(VISSIM_ATTR_NO, nullptr, ok));
484         myElemData["name"].push_back(attrs.get<std::string>(VISSIM_ATTR_NAME, nullptr, ok, false));
485         std::string colorStr(attrs.get<std::string>(VISSIM_ATTR_COLOR, nullptr, ok));
486         for (int pos = (int)colorStr.size() - 2; pos > 0; pos -= 2) {
487             colorStr.insert(pos, " ");
488         }
489         myElemData["color"].push_back(colorStr);
490     }
491     if (element == VISSIM_TAG_INTOBJECTREF) {
492         bool ok = true;
493         myElemData["types"].push_back(attrs.get<std::string>(VISSIM_ATTR_KEY, nullptr, ok));
494 
495 
496     }
497 }
498 
499 void
myEndElement(int element)500 NIImporter_Vissim::NIVissimXMLHandler_Fahrzeugklassendefinition::myEndElement(int element) {
501     if (element == VISSIM_TAG_VEHICLE_CLASS && myHierarchyLevel == 3) {
502         RGBColor color;
503         std::istringstream iss(myElemData["color"].front());
504         std::vector<std::string> sCol_v(StringTokenizer(
505                                             myElemData["color"].front(), " ").getVector());
506         std::vector<int> myColorVector(sCol_v.size());
507         std::transform(sCol_v.begin(), sCol_v.end(), myColorVector.begin(), StringUtils::hexToInt);
508 
509         color = RGBColor((unsigned char)myColorVector[0],
510                          (unsigned char)myColorVector[1],
511                          (unsigned char)myColorVector[2],
512                          (unsigned char)myColorVector[3]);
513         std::vector<int> types;
514         while (!myElemData["types"].empty()) {
515             types.push_back(StringUtils::toInt(myElemData["types"].front()));
516             myElemData["types"].pop_front();
517         }
518 
519         NIVissimVehTypeClass::dictionary(StringUtils::toInt(myElemData["id"].front()),
520                                          myElemData["name"].front(),
521                                          color,
522                                          types);
523         myElemData.clear();
524     }
525     --myHierarchyLevel;
526 }
527 
528 // ---------------------------------------------------------------------------
529 // definitions of NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition-methods
530 // ---------------------------------------------------------------------------
NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition(nodeMap & elemData)531 NIImporter_Vissim::NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition::NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition(nodeMap& elemData)
532     : GenericSAXHandler(vissimTags, VISSIM_TAG_NOTHING,
533                         vissimAttrs, VISSIM_ATTR_NOTHING,
534                         "vissim - file"),
535       myElemData(elemData),
536       myHierarchyLevel(0) {
537     myElemData.clear();
538 }
539 
~NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition()540 NIImporter_Vissim::NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition::~NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition() { }
541 
542 void
myStartElement(int element,const SUMOSAXAttributes & attrs)543 NIImporter_Vissim::NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition::myStartElement(int element, const SUMOSAXAttributes& attrs) {
544     myHierarchyLevel++;
545     if (element == VISSIM_TAG_SPEED_DIST) {
546         bool ok = true;
547         myElemData["id"].push_back(attrs.get<std::string>(VISSIM_ATTR_NO, nullptr, ok));
548     }
549 
550     if (element == VISSIM_TAG_DATAPOINT) {
551         bool ok = true;
552         std::string sep(" ");
553         std::string posS(attrs.get<std::string>(VISSIM_ATTR_X, nullptr, ok));
554         posS += sep;
555         posS.append(attrs.get<std::string>(VISSIM_ATTR_FX, nullptr, ok));
556         myElemData["points"].push_back(posS);
557 
558     }
559 
560 }
561 
562 void
myEndElement(int element)563 NIImporter_Vissim::NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition::myEndElement(int element) {
564     if (element == VISSIM_TAG_SPEED_DIST && myHierarchyLevel == 3) {
565         Distribution_Points* points = new Distribution_Points(myElemData["id"].front());
566         while (!myElemData["points"].empty()) {
567             std::vector<std::string> sPos_v(StringTokenizer(
568                                                 myElemData["points"].front(), " ").getVector());
569             myElemData["points"].pop_front();
570             points->add(StringUtils::toDouble(sPos_v[0]), StringUtils::toDouble(sPos_v[1]));
571         }
572         DistributionCont::dictionary("speed", myElemData["id"].front(), points);
573         myElemData.clear();
574     }
575     --myHierarchyLevel;
576 }
577 
578 // ---------------------------------------------------------------------------
579 // definitions of NIVissimXMLHandler_VWunschentscheidungsdefinition-methods
580 // ---------------------------------------------------------------------------
NIVissimXMLHandler_VWunschentscheidungsdefinition(nodeMap & elemData)581 NIImporter_Vissim::NIVissimXMLHandler_VWunschentscheidungsdefinition::NIVissimXMLHandler_VWunschentscheidungsdefinition(nodeMap& elemData)
582     : GenericSAXHandler(vissimTags, VISSIM_TAG_NOTHING,
583                         vissimAttrs, VISSIM_ATTR_NOTHING,
584                         "vissim - file"),
585       myElemData(elemData),
586       myHierarchyLevel(0) {
587     myElemData.clear();
588 }
589 
~NIVissimXMLHandler_VWunschentscheidungsdefinition()590 NIImporter_Vissim::NIVissimXMLHandler_VWunschentscheidungsdefinition::~NIVissimXMLHandler_VWunschentscheidungsdefinition() { }
591 
592 void
myStartElement(int element,const SUMOSAXAttributes & attrs)593 NIImporter_Vissim::NIVissimXMLHandler_VWunschentscheidungsdefinition::myStartElement(int element, const SUMOSAXAttributes& attrs) {
594     myHierarchyLevel++;
595     if (element == VISSIM_TAG_SPEED_DECISION) {
596         bool ok = true;
597         myElemData["name"].push_back(attrs.get<std::string>(VISSIM_ATTR_NAME, nullptr, ok, false));
598         //FIXME: 2 vWunsch in the xml file, but only 1 of them is set???
599     }
600 
601 }
602 
603 void
myEndElement(int)604 NIImporter_Vissim::NIVissimXMLHandler_VWunschentscheidungsdefinition::myEndElement(int /* element */) {
605     --myHierarchyLevel;
606 }
607 
608 
609 // ---------------------------------------------------------------------------
610 // definitions of NIVissimXMLHandler_Routenentscheidungsdefinition-methods
611 // ---------------------------------------------------------------------------
NIVissimXMLHandler_Routenentscheidungsdefinition(nodeMap & elemData)612 NIImporter_Vissim::NIVissimXMLHandler_Routenentscheidungsdefinition::NIVissimXMLHandler_Routenentscheidungsdefinition(nodeMap& elemData)
613     : GenericSAXHandler(vissimTags, VISSIM_TAG_NOTHING,
614                         vissimAttrs, VISSIM_ATTR_NOTHING,
615                         "vissim - file"),
616       myElemData(elemData),
617       myHierarchyLevel(0) {
618     myElemData.clear();
619 }
620 
~NIVissimXMLHandler_Routenentscheidungsdefinition()621 NIImporter_Vissim::NIVissimXMLHandler_Routenentscheidungsdefinition::~NIVissimXMLHandler_Routenentscheidungsdefinition() { }
622 
623 void
myStartElement(int element,const SUMOSAXAttributes & attrs)624 NIImporter_Vissim::NIVissimXMLHandler_Routenentscheidungsdefinition::myStartElement(int element, const SUMOSAXAttributes& attrs) {
625     myHierarchyLevel++;
626     if (element == VISSIM_TAG_DECISION_STATIC) {
627         bool ok = true;
628         myElemData["startLink"].push_back(attrs.get<std::string>(VISSIM_ATTR_LINK, nullptr, ok));
629         myElemData["startPos"].push_back(attrs.get<std::string>(VISSIM_ATTR_POS, nullptr, ok));
630     }
631     if (element == VISSIM_TAG_ROUTE_STATIC) {
632         bool ok = true;
633         myElemData["destLink"].push_back(attrs.get<std::string>(VISSIM_ATTR_DESTLINK, nullptr, ok));
634         myElemData["destPos"].push_back(attrs.get<std::string>(VISSIM_ATTR_DESTPOS, nullptr, ok));
635         myElemData["id"].push_back(attrs.get<std::string>(VISSIM_ATTR_NO, nullptr, ok));
636     }
637     if (element == VISSIM_TAG_INTOBJECTREF) {
638         // bool ok = true;
639     }
640 
641 }
642 
643 void
myEndElement(int)644 NIImporter_Vissim::NIVissimXMLHandler_Routenentscheidungsdefinition::myEndElement(int /* element */) {
645     --myHierarchyLevel;
646 }
647 
648 // ---------------------------------------------------------------------------
649 // definitions of NIVissimXMLHandler_ConflictArea-methods
650 // ---------------------------------------------------------------------------
NIVissimXMLHandler_ConflictArea()651 NIImporter_Vissim::NIVissimXMLHandler_ConflictArea::NIVissimXMLHandler_ConflictArea()
652     : GenericSAXHandler(vissimTags, VISSIM_TAG_NOTHING,
653                         vissimAttrs, VISSIM_ATTR_NOTHING,
654                         "vissim - file") {}
655 
~NIVissimXMLHandler_ConflictArea()656 NIImporter_Vissim::NIVissimXMLHandler_ConflictArea::~NIVissimXMLHandler_ConflictArea() { }
657 
658 void
myStartElement(int element,const SUMOSAXAttributes & attrs)659 NIImporter_Vissim::NIVissimXMLHandler_ConflictArea::myStartElement(int element, const SUMOSAXAttributes& attrs) {
660     // finding an actual flow
661     if (element == VISSIM_TAG_CA) {
662         //parse all flows
663         bool ok = true;
664         std::string status = attrs.get<std::string>(VISSIM_ATTR_STATUS, nullptr, ok);
665         //get only the conflict areas which were set in VISSIM
666         if (status != "PASSIVE") {
667             NIVissimConflictArea::dictionary(attrs.get<int>(VISSIM_ATTR_NO, nullptr, ok),
668                                              attrs.get<std::string>(VISSIM_ATTR_LINK1, nullptr, ok),
669                                              attrs.get<std::string>(VISSIM_ATTR_LINK2, nullptr, ok),
670                                              status);
671         }
672 
673     }
674 }
675 
676 
677 /* -------------------------------------------------------------------------
678  * NIImporter_Vissim::VissimSingleTypeParser-methods
679  * ----------------------------------------------------------------------- */
VissimSingleTypeParser(NIImporter_Vissim & parent)680 NIImporter_Vissim::VissimSingleTypeParser::VissimSingleTypeParser(NIImporter_Vissim& parent)
681     : myVissimParent(parent) {}
682 
683 
~VissimSingleTypeParser()684 NIImporter_Vissim::VissimSingleTypeParser::~VissimSingleTypeParser() {}
685 
686 
687 std::string
myRead(std::istream & from)688 NIImporter_Vissim::VissimSingleTypeParser::myRead(std::istream& from) {
689     std::string tmp;
690     from >> tmp;
691     return StringUtils::to_lower_case(tmp);
692 }
693 
694 
695 
696 std::string
readEndSecure(std::istream & from,const std::string & excl)697 NIImporter_Vissim::VissimSingleTypeParser::readEndSecure(std::istream& from,
698         const std::string& excl) {
699     std::string myExcl = StringUtils::to_lower_case(excl);
700     std::string tmp = myRead(from);
701     if (tmp == "") {
702         return "DATAEND";
703     }
704     if (tmp != myExcl
705             &&
706             (tmp.substr(0, 2) == "--" || !myVissimParent.admitContinue(tmp))
707        ) {
708         return "DATAEND";
709     }
710     return StringUtils::to_lower_case(tmp);
711 }
712 
713 
714 std::string
readEndSecure(std::istream & from,const std::vector<std::string> & excl)715 NIImporter_Vissim::VissimSingleTypeParser::readEndSecure(std::istream& from,
716         const std::vector<std::string>& excl) {
717     std::vector<std::string> myExcl;
718     std::vector<std::string>::const_iterator i;
719     for (i = excl.begin(); i != excl.end(); i++) {
720         std::string mes = StringUtils::to_lower_case(*i);
721         myExcl.push_back(mes);
722     }
723     std::string tmp = myRead(from);
724     if (tmp == "") {
725         return "DATAEND";
726     }
727 
728     bool equals = false;
729     for (i = myExcl.begin(); i != myExcl.end() && !equals; i++) {
730         if ((*i) == tmp) {
731             equals = true;
732         }
733     }
734     if (!equals
735             &&
736             (tmp.substr(0, 2) == "--" || !myVissimParent.admitContinue(tmp))
737        ) {
738         return "DATAEND";
739     }
740     return StringUtils::to_lower_case(tmp);
741 }
742 
743 
744 std::string
overrideOptionalLabel(std::istream & from,const std::string & tag)745 NIImporter_Vissim::VissimSingleTypeParser::overrideOptionalLabel(std::istream& from,
746         const std::string& tag) {
747     std::string tmp;
748     if (tag == "") {
749         tmp = myRead(from);
750     } else {
751         tmp = tag;
752     }
753     if (tmp == "beschriftung") {
754         tmp = myRead(from);
755         if (tmp == "keine") {
756             from >> tmp;
757         }
758         tmp = myRead(from);
759         tmp = myRead(from);
760     }
761     return tmp;
762 }
763 
764 
765 Position
getPosition(std::istream & from)766 NIImporter_Vissim::VissimSingleTypeParser::getPosition(std::istream& from) {
767     double x, y;
768     from >> x; // type-checking is missing!
769     from >> y; // type-checking is missing!
770     return Position(x, y);
771 }
772 
773 
774 std::vector<int>
parseAssignedVehicleTypes(std::istream & from,const std::string & next)775 NIImporter_Vissim::VissimSingleTypeParser::parseAssignedVehicleTypes(
776     std::istream& from, const std::string& next) {
777     std::string tmp = readEndSecure(from);
778     std::vector<int> ret;
779     if (tmp == "alle") {
780         ret.push_back(-1);
781         return ret;
782     }
783     while (tmp != "DATAEND" && tmp != next) {
784         ret.push_back(StringUtils::toInt(tmp));
785         tmp = readEndSecure(from);
786     }
787     return ret;
788 }
789 
790 
791 NIVissimExtendedEdgePoint
readExtEdgePointDef(std::istream & from)792 NIImporter_Vissim::VissimSingleTypeParser::readExtEdgePointDef(
793     std::istream& from) {
794     std::string tag;
795     from >> tag; // "Strecke"
796     int edgeid;
797     from >> edgeid; // type-checking is missing!
798     from >> tag; // "Spuren"
799     std::vector<int> lanes;
800     while (tag != "bei") {
801         tag = readEndSecure(from);
802         if (tag != "bei") {
803             int lane = StringUtils::toInt(tag);
804             lanes.push_back(lane - 1);
805         }
806     }
807     double position;
808     from >> position;
809     std::vector<int> dummy;
810     return NIVissimExtendedEdgePoint(edgeid, lanes, position, dummy);
811 }
812 
813 
814 std::string
readName(std::istream & from)815 NIImporter_Vissim::VissimSingleTypeParser::readName(std::istream& from) {
816     std::string name;
817     from >> name;
818     if (name[0] == '"') {
819         while (name[name.length() - 1] != '"') {
820             std::string tmp;
821             from >> tmp;
822             name = name + " " + tmp;
823         }
824         name = name.substr(1, name.length() - 2);
825     }
826     return StringUtils::convertUmlaute(name);
827 }
828 
829 
830 void
readUntil(std::istream & from,const std::string & name)831 NIImporter_Vissim::VissimSingleTypeParser::readUntil(std::istream& from,
832         const std::string& name) {
833     std::string tag;
834     while (tag != name) {
835         tag = myRead(from);
836     }
837 }
838 
839 bool
skipOverreading(std::istream & from,const std::string & name)840 NIImporter_Vissim::VissimSingleTypeParser::skipOverreading(std::istream& from,
841         const std::string& name) {
842     std::string tag;
843     while (tag != name) {
844         tag = myRead(from);
845     }
846     while (tag != "DATAEND") {
847         tag = readEndSecure(from);
848     }
849     return true;
850 }
851 
852 
853 
854 /* -------------------------------------------------------------------------
855  * NIImporter_Vissim-methods
856  * ----------------------------------------------------------------------- */
NIImporter_Vissim(NBNetBuilder & nb,const std::string & file)857 NIImporter_Vissim::NIImporter_Vissim(NBNetBuilder& nb, const std::string& file)
858     : myNetBuilder(nb), myInputIsLegacyFormat(false) {
859     UNUSED_PARAMETER(file);
860     insertKnownElements();
861     buildParsers();
862     myColorMap["blau"] = RGBColor(77, 77, 255, 255);
863     myColorMap["gelb"] = RGBColor::YELLOW;
864     myColorMap["grau"] = RGBColor::GREY;
865     myColorMap["lila"] = RGBColor::MAGENTA;
866     myColorMap["gruen"] = RGBColor::GREEN;
867     myColorMap["rot"] = RGBColor::RED;
868     myColorMap["schwarz"] = RGBColor::BLACK;
869     myColorMap["tuerkis"] = RGBColor::CYAN;
870     myColorMap["weiss"] = RGBColor::WHITE;
871     myColorMap["keine"] = RGBColor::WHITE;
872 }
873 
874 
875 
876 
~NIImporter_Vissim()877 NIImporter_Vissim::~NIImporter_Vissim() {
878     NIVissimAbstractEdge::clearDict();
879     NIVissimClosures::clearDict();
880     NIVissimDistrictConnection::clearDict();
881     NIVissimDisturbance::clearDict();
882     NIVissimNodeCluster::clearDict();
883     NIVissimNodeDef::clearDict();
884     NIVissimSource::clearDict();
885     NIVissimTL::clearDict();
886     NIVissimTL::NIVissimTLSignal::clearDict();
887     NIVissimTL::NIVissimTLSignalGroup::clearDict();
888     NIVissimTrafficDescription::clearDict();
889     NIVissimVehTypeClass::clearDict();
890     NIVissimVehicleType::clearDict();
891     NIVissimConnectionCluster::clearDict();
892     NIVissimEdge::clearDict();
893     NIVissimAbstractEdge::clearDict();
894     NIVissimConnection::clearDict();
895     NIVissimConflictArea::clearDict();
896     for (ToParserMap::iterator i = myParsers.begin(); i != myParsers.end(); i++) {
897         delete (*i).second;
898     }
899 }
900 
901 
902 void
load(const OptionsCont & options)903 NIImporter_Vissim::load(const OptionsCont& options) {
904     // load file contents
905     // try to open the file
906     std::ifstream strm(options.getString("vissim-file").c_str());
907     if (!strm.good()) {
908         WRITE_ERROR("The vissim-file '" + options.getString("vissim-file") + "' was not found.");
909         return;
910     }
911     if (!readContents(strm)) {
912         return;
913     }
914     postLoadBuild(options.getFloat("vissim.join-distance"));
915 }
916 
917 void
loadXML(const OptionsCont & options,NBNetBuilder &)918 NIImporter_Vissim::loadXML(const OptionsCont& options, NBNetBuilder& /* nb */) {
919     // Parse file
920     std::string file = options.getString("vissim-file");
921     // Create NIVissimXMLHandlers
922     NIVissimXMLHandler_Streckendefinition XMLHandler_Streckendefinition(elementData);
923     NIVissimXMLHandler_Zuflussdefinition XMLHandler_Zuflussdefinition;
924     //NIVissimXMLHandler_Parkplatzdefinition XMLHandler_Parkplatzdefinition;
925     NIVissimXMLHandler_Fahrzeugklassendefinition XMLHandler_Fahrzeugklassendefinition(elementData);
926     NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition XMLHandler_Geschwindigkeitsverteilung(elementData);
927     NIVissimXMLHandler_ConflictArea XMLHandler_ConflictAreas;
928     if (!FileHelpers::isReadable(file)) {
929         WRITE_ERROR("Could not open vissim-file '" + file + "'.");
930         return;
931     }
932 
933     // Strecken + Verbinder
934     XMLHandler_Streckendefinition.setFileName(file);
935     PROGRESS_BEGIN_MESSAGE("Parsing strecken+verbinder from vissim-file '" + file + "'");
936     if (!XMLSubSys::runParser(XMLHandler_Streckendefinition, file)) {
937         return;
938     }
939     PROGRESS_DONE_MESSAGE();
940 
941     // Zuflüsse
942     XMLHandler_Zuflussdefinition.setFileName(file);
943     PROGRESS_BEGIN_MESSAGE("Parsing zuflüsse from vissim-file '" + file + "'");
944     if (!XMLSubSys::runParser(XMLHandler_Zuflussdefinition, file)) {
945         return;
946     }
947     PROGRESS_DONE_MESSAGE();
948 
949     //Geschwindigkeitsverteilungen
950     XMLHandler_Geschwindigkeitsverteilung.setFileName(file);
951     PROGRESS_BEGIN_MESSAGE("Parsing parkplätze from vissim-file '" + file + "'");
952     if (!XMLSubSys::runParser(XMLHandler_Geschwindigkeitsverteilung, file)) {
953         return;
954     }
955     PROGRESS_DONE_MESSAGE();
956 
957 
958     //Fahrzeugklassen
959     XMLHandler_Fahrzeugklassendefinition.setFileName(file);
960     PROGRESS_BEGIN_MESSAGE("Parsing parkplätze from vissim-file '" + file + "'");
961     if (!XMLSubSys::runParser(XMLHandler_Fahrzeugklassendefinition, file)) {
962         return;
963     }
964     PROGRESS_DONE_MESSAGE();
965 
966     //Parkplätze
967     /*XMLHandler_Parkplatzdefinition.setFileName(file);
968     PROGRESS_BEGIN_MESSAGE("Parsing parkplätze from vissim-file '" + file + "'");
969     if (!XMLSubSys::runParser(XMLHandler_Parkplatzdefinition, file)) {
970         return;
971     }
972     PROGRESS_DONE_MESSAGE();*/
973 
974 
975     //Konfliktflächen
976     XMLHandler_ConflictAreas.setFileName(file);
977     PROGRESS_BEGIN_MESSAGE("Parsing conflict areas from vissim-file '" + file + "'");
978     if (!XMLSubSys::runParser(XMLHandler_ConflictAreas, file)) {
979         return;
980     }
981     PROGRESS_DONE_MESSAGE();
982 
983     postLoadBuild(options.getFloat("vissim.join-distance"));
984 }
985 
986 bool
admitContinue(const std::string & tag)987 NIImporter_Vissim::admitContinue(const std::string& tag) {
988     ToElemIDMap::const_iterator i = myKnownElements.find(tag);
989     if (i == myKnownElements.end()) {
990         return true;
991     }
992     myLastSecure = tag;
993     return false;
994 }
995 
996 
997 bool
readContents(std::istream & strm)998 NIImporter_Vissim::readContents(std::istream& strm) {
999     // read contents
1000     bool ok = true;
1001     while (strm.good() && ok) {
1002         std::string tag;
1003         if (myLastSecure != "") {
1004             tag = myLastSecure;
1005         } else {
1006             strm >> tag;
1007         }
1008         myLastSecure = "";
1009         bool parsed = false;
1010         while (!parsed && strm.good() && ok) {
1011             ToElemIDMap::iterator i = myKnownElements.find(StringUtils::to_lower_case(tag));
1012             if (i != myKnownElements.end()) {
1013                 ToParserMap::iterator j = myParsers.find((*i).second);
1014                 if (j != myParsers.end()) {
1015                     VissimSingleTypeParser* parser = (*j).second;
1016                     ok = parser->parse(strm);
1017                     parsed = true;
1018                 }
1019             }
1020             if (!parsed) {
1021                 std::string line;
1022                 std::streamoff pos;
1023                 do {
1024                     pos = strm.tellg();
1025                     getline(strm, line);
1026                 } while (strm.good() && (line == "" || line[0] == ' ' || line[0] == '-'));
1027                 if (!strm.good()) {
1028                     return true;
1029                 }
1030                 strm.seekg(pos);
1031                 strm >> tag;
1032             }
1033         }
1034     }
1035     return ok;
1036 }
1037 
1038 
1039 void
postLoadBuild(double offset)1040 NIImporter_Vissim::postLoadBuild(double offset) {
1041     // close the loading process
1042     NIVissimBoundedClusterObject::closeLoading();
1043     NIVissimConnection::dict_assignToEdges();
1044     NIVissimDisturbance::dict_SetDisturbances();
1045     // build district->connections map
1046     NIVissimDistrictConnection::dict_BuildDistrictConnections();
1047     // build clusters around nodes
1048 //    NIVissimNodeDef::buildNodeClusters();
1049     // build node clusters around traffic lights
1050 //    NIVissimTL::buildNodeClusters();
1051 
1052     // when connections or disturbances are left, build nodes around them
1053 
1054     // try to assign connection clusters to nodes
1055     //  only left connections will be processed in
1056     //   buildConnectionClusters & join
1057 //30.4. brauchen wir noch!    NIVissimNodeDef::dict_assignConnectionsToNodes();
1058 
1059     // build clusters of connections with the same direction and a similar position along the streets
1060     NIVissimEdge::buildConnectionClusters();
1061     // check whether further nodes (connection clusters by now) must be added
1062     NIVissimDistrictConnection::dict_CheckEdgeEnds();
1063 
1064     // join clusters when overlapping (different streets are possible)
1065     NIVissimEdge::dict_checkEdges2Join();
1066     NIVissimConnectionCluster::joinBySameEdges(offset);
1067 //    NIVissimConnectionCluster::joinByDisturbances(offset);
1068 
1069 //    NIVissimConnectionCluster::addTLs(offset);
1070 
1071     // build nodes from clusters
1072     NIVissimNodeCluster::setCurrentVirtID(NIVissimNodeDef::getMaxID());
1073     NIVissimConnectionCluster::buildNodeClusters();
1074 
1075 //    NIVissimNodeCluster::dict_recheckEdgeChanges();
1076     NIVissimNodeCluster::buildNBNodes(myNetBuilder.getNodeCont());
1077     NIVissimDistrictConnection::dict_BuildDistrictNodes(
1078         myNetBuilder.getDistrictCont(), myNetBuilder.getNodeCont());
1079     NIVissimEdge::dict_propagateSpeeds();
1080     NIVissimEdge::dict_buildNBEdges(myNetBuilder.getDistrictCont(), myNetBuilder.getNodeCont(), myNetBuilder.getEdgeCont(), offset);
1081     if (OptionsCont::getOptions().getBool("vissim.report-unset-speeds")) {
1082         NIVissimEdge::reportUnsetSpeeds();
1083     }
1084     NIVissimDistrictConnection::dict_BuildDistricts(myNetBuilder.getDistrictCont(), myNetBuilder.getEdgeCont(), myNetBuilder.getNodeCont());
1085     NIVissimConnection::dict_buildNBEdgeConnections(myNetBuilder.getEdgeCont());
1086     NIVissimNodeCluster::dict_addDisturbances(myNetBuilder.getDistrictCont(), myNetBuilder.getNodeCont(), myNetBuilder.getEdgeCont());
1087     NIVissimConflictArea::setPriorityRegulation(myNetBuilder.getEdgeCont());
1088     NIVissimTL::dict_SetSignals(myNetBuilder.getTLLogicCont(), myNetBuilder.getEdgeCont());
1089 }
1090 
1091 
1092 void
insertKnownElements()1093 NIImporter_Vissim::insertKnownElements() {
1094     myKnownElements["kennung"] = VE_Kennungszeile;
1095     myKnownElements["zufallszahl"] = VE_Startzufallszahl;
1096     myKnownElements["simulationsdauer"] = VE_Simdauer;
1097     myKnownElements["startuhrzeit"] = VE_Startuhrzeit;
1098     myKnownElements["simulationsrate"] = VE_SimRate;
1099     myKnownElements["zeitschritt"] = VE_Zeitschrittfaktor;
1100     myKnownElements["linksverkehr"] = VE_Linksverkehr;
1101     myKnownElements["dynuml"] = VE_DynUml;
1102     myKnownElements["stau"] = VE_Stauparameterdefinition;
1103     myKnownElements["gelbverhalten"] = VE_Gelbverhaltendefinition;
1104     myKnownElements["strecke"] = VE_Streckendefinition;
1105     myKnownElements["verbindung"] = VE_Verbindungsdefinition;
1106     myKnownElements["richtungsentscheidung"] = VE_Richtungsentscheidungsdefinition;
1107     myKnownElements["routenentscheidung"] = VE_Routenentscheidungsdefinition;
1108     myKnownElements["vwunschentscheidung"] = VE_VWunschentscheidungsdefinition;
1109     myKnownElements["langsamfahrbereich"] = VE_Langsamfahrbereichdefinition;
1110     myKnownElements["zufluss"] = VE_Zuflussdefinition;
1111     myKnownElements["fahrzeugtyp"] = VE_Fahrzeugtypdefinition;
1112     myKnownElements["fahrzeugklasse"] = VE_Fahrzeugklassendefinition;
1113     myKnownElements["zusammensetzung"] = VE_Verkehrszusammensetzungsdefinition;
1114     myKnownElements["vwunsch"] = VE_Geschwindigkeitsverteilungsdefinition;
1115     myKnownElements["laengen"] = VE_Laengenverteilungsdefinition;
1116     myKnownElements["zeiten"] = VE_Zeitenverteilungsdefinition;
1117     myKnownElements["baujahre"] = VE_Baujahrverteilungsdefinition;
1118     myKnownElements["leistungen"] = VE_Laufleistungsverteilungsdefinition;
1119     myKnownElements["massen"] = VE_Massenverteilungsdefinition;
1120     myKnownElements["leistungen"] = VE_Leistungsverteilungsdefinition;
1121     myKnownElements["maxbeschleunigung"] = VE_Maxbeschleunigungskurvedefinition;
1122     myKnownElements["wunschbeschleunigung"] = VE_Wunschbeschleunigungskurvedefinition;
1123     myKnownElements["maxverzoegerung"] = VE_Maxverzoegerungskurvedefinition;
1124     myKnownElements["wunschverzoegerung"] = VE_Wunschverzoegerungskurvedefinition;
1125     myKnownElements["querverkehrsstoerung"] = VE_Querverkehrsstoerungsdefinition;
1126     myKnownElements["lsa"] = VE_Lichtsignalanlagendefinition;
1127     myKnownElements["signalgruppe"] = VE_Signalgruppendefinition;
1128     myKnownElements["signalgeber"] = VE_Signalgeberdefinition;
1129     myKnownElements["lsakopplung"] = VE_LSAKopplungdefinition;
1130     myKnownElements["detektor"] = VE_Detektorendefinition;
1131     myKnownElements["haltestelle"] = VE_Haltestellendefinition;
1132     myKnownElements["linie"] = VE_Liniendefinition;
1133     myKnownElements["stopschild"] = VE_Stopschilddefinition;
1134     myKnownElements["messung"] = VE_Messungsdefinition;
1135     myKnownElements["reisezeit"] = VE_Reisezeitmessungsdefinition;
1136     myKnownElements["verlustzeit"] = VE_Verlustzeitmessungsdefinition;
1137     myKnownElements["querschnittsmessung"] = VE_Querschnittsmessungsdefinition;
1138     myKnownElements["stauzaehler"] = VE_Stauzaehlerdefinition;
1139     myKnownElements["auswertung"] = VE_Auswertungsdefinition;
1140     myKnownElements["fenster"] = VE_Fensterdefinition;
1141     myKnownElements["motiv"] = VE_Gefahrenwarnsystemdefinition;
1142     myKnownElements["parkplatz"] = VE_Parkplatzdefinition;
1143     myKnownElements["knoten"] = VE_Knotendefinition;
1144     myKnownElements["teapac"] = VE_TEAPACdefinition;
1145     myKnownElements["netzobjekt"] = VE_Netzobjektdefinition;
1146     myKnownElements["richtungspfeil"] = VE_Richtungspfeildefinition;
1147     myKnownElements["raute"] = VE_Rautedefinition;
1148     myKnownElements["fahrverhalten"] = VE_Fahrverhaltendefinition;
1149     myKnownElements["fahrtverlaufdateien"] = VE_Fahrtverlaufdateien;
1150     myKnownElements["emission"] = VE_Emission;
1151     myKnownElements["einheit"] = VE_Einheitendefinition;
1152     myKnownElements["streckentyp"] = VE_Streckentypdefinition;
1153     myKnownElements["kantensperrung"] = VE_Kantensperrung;
1154     myKnownElements["kante"] = VE_Kantensperrung;
1155 
1156 
1157     myKnownElements["advance"] = VE_DUMMY;
1158     myKnownElements["temperatur"] = VE_DUMMY;
1159 
1160 }
1161 
1162 
1163 
1164 void
buildParsers()1165 NIImporter_Vissim::buildParsers() {
1166     myParsers[VE_Simdauer] =
1167         new NIVissimSingleTypeParser_Simdauer(*this);
1168     myParsers[VE_Startuhrzeit] =
1169         new NIVissimSingleTypeParser_Startuhrzeit(*this);
1170     myParsers[VE_DynUml] =
1171         new NIVissimSingleTypeParser_DynUml(*this);
1172     myParsers[VE_Streckendefinition] =
1173         new NIVissimSingleTypeParser_Streckendefinition(*this);
1174     myParsers[VE_Verbindungsdefinition] =
1175         new NIVissimSingleTypeParser_Verbindungsdefinition(*this);
1176     myParsers[VE_Richtungsentscheidungsdefinition] =
1177         new NIVissimSingleTypeParser_Richtungsentscheidungsdefinition(*this);
1178     myParsers[VE_Routenentscheidungsdefinition] =
1179         new NIVissimSingleTypeParser_Routenentscheidungsdefinition(*this);
1180     myParsers[VE_VWunschentscheidungsdefinition] =
1181         new NIVissimSingleTypeParser_VWunschentscheidungsdefinition(*this);
1182     myParsers[VE_Langsamfahrbereichdefinition] =
1183         new NIVissimSingleTypeParser_Langsamfahrbereichdefinition(*this);
1184     myParsers[VE_Zuflussdefinition] =
1185         new NIVissimSingleTypeParser_Zuflussdefinition(*this);
1186     myParsers[VE_Fahrzeugtypdefinition] =
1187         new NIVissimSingleTypeParser_Fahrzeugtypdefinition(*this, myColorMap);
1188     myParsers[VE_Fahrzeugklassendefinition] =
1189         new NIVissimSingleTypeParser_Fahrzeugklassendefinition(*this, myColorMap);
1190     myParsers[VE_Geschwindigkeitsverteilungsdefinition] =
1191         new NIVissimSingleTypeParser_Geschwindigkeitsverteilungsdefinition(*this);
1192     myParsers[VE_Laengenverteilungsdefinition] =
1193         new NIVissimSingleTypeParser_Laengenverteilungsdefinition(*this);
1194     myParsers[VE_Zeitenverteilungsdefinition] =
1195         new NIVissimSingleTypeParser_Zeitenverteilungsdefinition(*this);
1196     myParsers[VE_Querverkehrsstoerungsdefinition] =
1197         new NIVissimSingleTypeParser_Querverkehrsstoerungsdefinition(*this);
1198     myParsers[VE_Lichtsignalanlagendefinition] =
1199         new NIVissimSingleTypeParser_Lichtsignalanlagendefinition(*this);
1200     myParsers[VE_Signalgruppendefinition] =
1201         new NIVissimSingleTypeParser_Signalgruppendefinition(*this);
1202     myParsers[VE_Stopschilddefinition] =
1203         new NIVissimSingleTypeParser_Stopschilddefinition(*this);
1204     myParsers[VE_Knotendefinition] =
1205         new NIVissimSingleTypeParser_Knotendefinition(*this);
1206     myParsers[VE_Signalgeberdefinition] =
1207         new NIVissimSingleTypeParser_Signalgeberdefinition(*this);
1208     myParsers[VE_Detektorendefinition] =
1209         new NIVissimSingleTypeParser_Detektordefinition(*this);
1210     myParsers[VE_Haltestellendefinition] =
1211         new NIVissimSingleTypeParser_Haltestellendefinition(*this);
1212     myParsers[VE_Liniendefinition] =
1213         new NIVissimSingleTypeParser_Liniendefinition(*this);
1214     myParsers[VE_Reisezeitmessungsdefinition] =
1215         new NIVissimSingleTypeParser_Reisezeitmessungsdefinition(*this);
1216     myParsers[VE_Querschnittsmessungsdefinition] =
1217         new NIVissimSingleTypeParser_Querschnittsmessungsdefinition(*this);
1218     myParsers[VE_Messungsdefinition] =
1219         new NIVissimSingleTypeParser_Messungsdefinition(*this);
1220     myParsers[VE_Verlustzeitmessungsdefinition] =
1221         new NIVissimSingleTypeParser_Verlustzeitmessungsdefinition(*this);
1222     myParsers[VE_Stauzaehlerdefinition] =
1223         new NIVissimSingleTypeParser_Stauzaehlerdefinition(*this);
1224     myParsers[VE_Rautedefinition] =
1225         new NIVissimSingleTypeParser_Rautedefinition(*this);
1226     myParsers[VE_Richtungspfeildefinition] =
1227         new NIVissimSingleTypeParser_Richtungspfeildefinition(*this);
1228     myParsers[VE_Parkplatzdefinition] =
1229         new NIVissimSingleTypeParser_Parkplatzdefinition(*this);
1230     myParsers[VE_Fahrverhaltendefinition] =
1231         new NIVissimSingleTypeParser_Fahrverhaltendefinition(*this);
1232     myParsers[VE_Streckentypdefinition] =
1233         new NIVissimSingleTypeParser_Streckentypdefinition(*this);
1234     myParsers[VE_Kennungszeile] =
1235         new NIVissimSingleTypeParser_Kennungszeile(*this);
1236     myParsers[VE_Fensterdefinition] =
1237         new NIVissimSingleTypeParser_Fensterdefinition(*this);
1238     myParsers[VE_Auswertungsdefinition] =
1239         new NIVissimSingleTypeParser_Auswertungsdefinition(*this);
1240     myParsers[VE_Verkehrszusammensetzungsdefinition] =
1241         new NIVissimSingleTypeParser_Zusammensetzungsdefinition(*this);
1242     myParsers[VE_Kantensperrung] =
1243         new NIVissimSingleTypeParser_Kantensperrung(*this);
1244 
1245     myParsers[VE_Startzufallszahl] =
1246         new NIVissimSingleTypeParser_Startzufallszahl(*this);
1247     myParsers[VE_SimRate] =
1248         new NIVissimSingleTypeParser_SimRate(*this);
1249     myParsers[VE_Zeitschrittfaktor] =
1250         new NIVissimSingleTypeParser_Zeitschrittfaktor(*this);
1251     myParsers[VE_Linksverkehr] =
1252         new NIVissimSingleTypeParser_Linksverkehr(*this);
1253     myParsers[VE_Stauparameterdefinition] =
1254         new NIVissimSingleTypeParser_Stauparameterdefinition(*this);
1255     myParsers[VE_Gelbverhaltendefinition] =
1256         new NIVissimSingleTypeParser_Gelbverhaltendefinition(*this);
1257     myParsers[VE_LSAKopplungdefinition] =
1258         new NIVissimSingleTypeParser_LSAKopplungsdefinition(*this);
1259     myParsers[VE_Gefahrenwarnsystemdefinition] =
1260         new NIVissimSingleTypeParser_Gefahrwarnungsdefinition(*this);
1261     myParsers[VE_TEAPACdefinition] =
1262         new NIVissimSingleTypeParser_TEAPACDefinition(*this);
1263     myParsers[VE_Netzobjektdefinition] =
1264         new NIVissimSingleTypeParser_Netzobjektdefinition(*this);
1265     myParsers[VE_Fahrtverlaufdateien] =
1266         new NIVissimSingleTypeParser_Fahrtverlaufdateien(*this);
1267     myParsers[VE_Emission] =
1268         new NIVissimSingleTypeParser_Emission(*this);
1269     myParsers[VE_Einheitendefinition] =
1270         new NIVissimSingleTypeParser_Einheitendefinition(*this);
1271     myParsers[VE_Baujahrverteilungsdefinition] =
1272         new NIVissimSingleTypeParser__XVerteilungsdefinition(*this);
1273     myParsers[VE_Laufleistungsverteilungsdefinition] =
1274         new NIVissimSingleTypeParser__XVerteilungsdefinition(*this);
1275     myParsers[VE_Massenverteilungsdefinition] =
1276         new NIVissimSingleTypeParser__XVerteilungsdefinition(*this);
1277     myParsers[VE_Leistungsverteilungsdefinition] =
1278         new NIVissimSingleTypeParser__XVerteilungsdefinition(*this);
1279     myParsers[VE_Maxbeschleunigungskurvedefinition] =
1280         new NIVissimSingleTypeParser__XKurvedefinition(*this);
1281     myParsers[VE_Wunschbeschleunigungskurvedefinition] =
1282         new NIVissimSingleTypeParser__XKurvedefinition(*this);
1283     myParsers[VE_Maxverzoegerungskurvedefinition] =
1284         new NIVissimSingleTypeParser__XKurvedefinition(*this);
1285     myParsers[VE_Wunschverzoegerungskurvedefinition] =
1286         new NIVissimSingleTypeParser__XKurvedefinition(*this);
1287 
1288 }
1289 
1290 
1291 
1292 /****************************************************************************/
1293 
1294