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 NIVissimNodeCluster.cpp
15 : /// @author Daniel Krajzewicz
16 : /// @author Jakob Erdmann
17 : /// @author Michael Behrisch
18 : /// @date Sept 2002
19 : ///
20 : // -------------------
21 : /****************************************************************************/
22 : #include <config.h>
23 :
24 :
25 : #include <map>
26 : #include <algorithm>
27 : #include <cassert>
28 : #include <utils/common/VectorHelper.h>
29 : #include <utils/common/ToString.h>
30 : #include <utils/geom/PositionVector.h>
31 : #include <netbuild/NBNode.h>
32 : #include <netbuild/NBNodeCont.h>
33 : #include "NIVissimTL.h"
34 : #include "NIVissimDisturbance.h"
35 : #include "NIVissimConnection.h"
36 : #include "NIVissimNodeCluster.h"
37 :
38 :
39 : // ===========================================================================
40 : // static member variables
41 : // ===========================================================================
42 : NIVissimNodeCluster::DictType NIVissimNodeCluster::myDict;
43 : int NIVissimNodeCluster::myCurrentID = 1;
44 :
45 :
46 : // ===========================================================================
47 : // method definitions
48 : // ===========================================================================
49 348 : NIVissimNodeCluster::NIVissimNodeCluster(int id, int nodeid, int tlid,
50 : const std::vector<int>& connectors,
51 : const std::vector<int>& disturbances,
52 348 : bool amEdgeSplitOnly)
53 348 : : myID(id), myNodeID(nodeid), myTLID(tlid),
54 348 : myConnectors(connectors), myDisturbances(disturbances),
55 348 : myNBNode(nullptr), myAmEdgeSplit(amEdgeSplitOnly) {}
56 :
57 :
58 348 : NIVissimNodeCluster::~NIVissimNodeCluster() {}
59 :
60 :
61 :
62 :
63 : bool
64 348 : NIVissimNodeCluster::dictionary(int id, NIVissimNodeCluster* o) {
65 : DictType::iterator i = myDict.find(id);
66 348 : if (i == myDict.end()) {
67 348 : myDict[id] = o;
68 348 : return true;
69 : }
70 : assert(false);
71 : return false;
72 : }
73 :
74 :
75 : int
76 348 : NIVissimNodeCluster::dictionary(int nodeid, int tlid,
77 : const std::vector<int>& connectors,
78 : const std::vector<int>& disturbances,
79 : bool amEdgeSplitOnly) {
80 : int id = nodeid;
81 348 : if (nodeid < 0) {
82 348 : id = myCurrentID++;
83 : }
84 : NIVissimNodeCluster* o = new NIVissimNodeCluster(id,
85 348 : nodeid, tlid, connectors, disturbances, amEdgeSplitOnly);
86 348 : dictionary(id, o);
87 348 : return id;
88 : }
89 :
90 :
91 : NIVissimNodeCluster*
92 1061 : NIVissimNodeCluster::dictionary(int id) {
93 : DictType::iterator i = myDict.find(id);
94 1061 : if (i == myDict.end()) {
95 : return nullptr;
96 : }
97 1061 : return (*i).second;
98 : }
99 :
100 :
101 :
102 : int
103 0 : NIVissimNodeCluster::contSize() {
104 0 : return (int)myDict.size();
105 : }
106 :
107 :
108 :
109 : std::string
110 696 : NIVissimNodeCluster::getNodeName() const {
111 696 : if (myTLID == -1) {
112 696 : return toString<int>(myID);
113 : } else {
114 0 : return toString<int>(myID) + "LSA " + toString<int>(myTLID);
115 : }
116 : }
117 :
118 :
119 : void
120 348 : NIVissimNodeCluster::buildNBNode(NBNodeCont& nc) {
121 348 : if (myConnectors.size() == 0) {
122 0 : return; // !!! Check, whether this can happen
123 : }
124 :
125 : // compute the position
126 348 : PositionVector crossings;
127 : std::vector<int>::iterator i, j;
128 : // check whether this is a split of an edge only
129 348 : if (myAmEdgeSplit) {
130 : // !!! should be assert(myTLID==-1);
131 499 : for (i = myConnectors.begin(); i != myConnectors.end(); i++) {
132 286 : NIVissimConnection* c1 = NIVissimConnection::dictionary(*i);
133 286 : crossings.push_back_noDoublePos(c1->getFromGeomPosition());
134 : }
135 : } else {
136 : // compute the places the connections cross
137 776 : for (i = myConnectors.begin(); i != myConnectors.end(); i++) {
138 641 : NIVissimAbstractEdge* c1 = NIVissimAbstractEdge::dictionary(*i);
139 641 : c1->buildGeom();
140 2446 : for (j = i + 1; j != myConnectors.end(); j++) {
141 1805 : NIVissimAbstractEdge* c2 = NIVissimAbstractEdge::dictionary(*j);
142 1805 : c2->buildGeom();
143 1805 : if (c1->crossesEdge(c2)) {
144 674 : crossings.push_back_noDoublePos(c1->crossesEdgeAtPoint(c2));
145 : }
146 : }
147 : }
148 : // alternative way: compute via positions of crossings
149 135 : if (crossings.size() == 0) {
150 93 : for (i = myConnectors.begin(); i != myConnectors.end(); i++) {
151 65 : NIVissimConnection* c1 = NIVissimConnection::dictionary(*i);
152 65 : crossings.push_back_noDoublePos(c1->getFromGeomPosition());
153 65 : crossings.push_back_noDoublePos(c1->getToGeomPosition());
154 : }
155 : }
156 : }
157 : // get the position (center)
158 348 : Position pos = crossings.getPolygonCenter();
159 : // build the node
160 : /* if(myTLID!=-1) {
161 : !!! NIVissimTL *tl = NIVissimTL::dictionary(myTLID);
162 : if(tl->getType()=="festzeit") {
163 : node = new NBNode(getNodeName(), pos.x(), pos.y(),
164 : "traffic_light");
165 : } else {
166 : node = new NBNode(getNodeName(), pos.x(), pos.y(),
167 : "actuated_traffic_light");
168 : }
169 : }*/
170 348 : NBNode* node = new NBNode(getNodeName(), pos, SumoXMLNodeType::PRIORITY);
171 348 : if (!nc.insert(node)) {
172 0 : delete node;
173 0 : throw 1;
174 : }
175 348 : myNBNode = node;
176 348 : }
177 :
178 :
179 : void
180 9 : NIVissimNodeCluster::buildNBNodes(NBNodeCont& nc) {
181 357 : for (DictType::iterator i = myDict.begin(); i != myDict.end(); i++) {
182 348 : (*i).second->buildNBNode(nc);
183 : }
184 9 : }
185 :
186 :
187 :
188 : void
189 0 : NIVissimNodeCluster::dict_recheckEdgeChanges() {
190 0 : return;
191 : }
192 :
193 :
194 : int
195 0 : NIVissimNodeCluster::getFromNode(int edgeid) {
196 : int ret = -1;
197 0 : for (DictType::iterator i = myDict.begin(); i != myDict.end(); i++) {
198 0 : NIVissimNodeCluster* c = (*i).second;
199 0 : for (std::vector<int>::iterator j = c->myConnectors.begin(); j != c->myConnectors.end(); j++) {
200 0 : NIVissimConnection* conn = NIVissimConnection::dictionary(*j);
201 0 : if (conn != nullptr && conn->getToEdgeID() == edgeid) {
202 : // return (*i).first;
203 0 : if (ret != -1 && (*i).first != ret) {
204 : // "NIVissimNodeCluster:DoubleNode:" << ret << endl;
205 0 : throw 1; // an edge should not outgo from two different nodes
206 : // but actually, a joined cluster may posess a connections more than once
207 : }
208 0 : ret = (*i).first;
209 : }
210 : }
211 : }
212 0 : return ret;
213 : }
214 :
215 :
216 : int
217 0 : NIVissimNodeCluster::getToNode(int edgeid) {
218 : int ret = -1;
219 0 : for (DictType::iterator i = myDict.begin(); i != myDict.end(); i++) {
220 0 : NIVissimNodeCluster* c = (*i).second;
221 0 : for (std::vector<int>::iterator j = c->myConnectors.begin(); j != c->myConnectors.end(); j++) {
222 0 : NIVissimConnection* conn = NIVissimConnection::dictionary(*j);
223 0 : if (conn != nullptr && conn->getFromEdgeID() == edgeid) {
224 : // return (*i).first;
225 0 : if (ret != -1 && ret != (*i).first) {
226 : // << "NIVissimNodeCluster: multiple to-nodes" << endl;
227 0 : throw 1; // an edge should not outgo from two different nodes
228 : // but actually, a joined cluster may posess a connections more than once
229 :
230 : }
231 0 : ret = (*i).first;
232 : }
233 : }
234 : }
235 0 : return ret;
236 : }
237 :
238 :
239 : void
240 0 : NIVissimNodeCluster::_debugOut(std::ostream& into) {
241 0 : for (DictType::iterator i = myDict.begin(); i != myDict.end(); i++) {
242 0 : NIVissimNodeCluster* c = (*i).second;
243 0 : into << std::endl << c->myID << ":";
244 0 : for (std::vector<int>::iterator j = c->myConnectors.begin(); j != c->myConnectors.end(); j++) {
245 0 : if (j != c->myConnectors.begin()) {
246 0 : into << ", ";
247 : }
248 0 : into << (*j);
249 : }
250 : }
251 : into << "=======================" << std::endl;
252 0 : }
253 :
254 :
255 :
256 : NBNode*
257 1061 : NIVissimNodeCluster::getNBNode() const {
258 1061 : return myNBNode;
259 : }
260 :
261 :
262 : Position
263 0 : NIVissimNodeCluster::getPos() const {
264 0 : return myPosition;
265 : }
266 :
267 :
268 : void
269 9 : NIVissimNodeCluster::dict_addDisturbances(NBDistrictCont& dc,
270 : NBNodeCont& nc, NBEdgeCont& ec) {
271 357 : for (DictType::iterator i = myDict.begin(); i != myDict.end(); i++) {
272 348 : const std::vector<int>& disturbances = (*i).second->myDisturbances;
273 696 : NBNode* node = nc.retrieve((*i).second->getNodeName());
274 769 : for (std::vector<int>::const_iterator j = disturbances.begin(); j != disturbances.end(); j++) {
275 421 : NIVissimDisturbance* disturbance = NIVissimDisturbance::dictionary(*j);
276 421 : disturbance->addToNode(node, dc, nc, ec);
277 : }
278 : }
279 9 : NIVissimDisturbance::reportRefused();
280 9 : }
281 :
282 :
283 : void
284 9 : NIVissimNodeCluster::clearDict() {
285 357 : for (DictType::iterator i = myDict.begin(); i != myDict.end(); i++) {
286 348 : delete (*i).second;
287 : }
288 : myDict.clear();
289 9 : }
290 :
291 :
292 : void
293 9 : NIVissimNodeCluster::setCurrentVirtID(int id) {
294 9 : myCurrentID = id;
295 9 : }
296 :
297 :
298 : /****************************************************************************/
|
