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