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