Eclipse SUMO - Simulation of Urban MObility
GNEHierarchicalChildElements.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
14 // A abstract class for representation of additional elements
15 /****************************************************************************/
16 
17 // ===========================================================================
18 // included modules
19 // ===========================================================================
20 #include <config.h>
21 
22 #include <netedit/GNEViewNet.h>
27 #include <utils/gui/div/GLHelper.h>
29 
31 
32 // ===========================================================================
33 // member method definitions
34 // ===========================================================================
35 
37  const std::vector<GNEEdge*>& childEdges,
38  const std::vector<GNELane*>& childLanes,
39  const std::vector<GNEShape*>& childShapes,
40  const std::vector<GNEAdditional*>& childAdditionals,
41  const std::vector<GNEDemandElement*>& childDemandElements) :
42  myChildConnections(this),
43  myChildEdges(childEdges),
44  myChildLanes(childLanes),
45  myChildShapes(childShapes),
46  myChildAdditionals(childAdditionals),
47  myChildDemandElements(childDemandElements),
48  myAC(AC) {
49  // fill SortedChildDemandElementsByType with all demand element tags (it's needed because getChildDemandElementsSortedByType(...) function is constant
50  auto listOfTags = GNEAttributeCarrier::allowedTagsByCategory(GNEAttributeCarrier::TagType::TAGTYPE_DEMANDELEMENT, false);
51  for (const auto& tag : listOfTags) {
53  }
54 }
55 
56 
58 
59 
60 const Position&
62  for (const auto& childConnection : myChildConnections.symbolsPositionAndRotation) {
63  if (childConnection.lane == lane) {
64  return childConnection.pos;
65  }
66  }
67  throw ProcessError("Lane doesn't exist");
68 }
69 
70 
71 double
73  for (const auto& childConnection : myChildConnections.symbolsPositionAndRotation) {
74  if (childConnection.lane == lane) {
75  return childConnection.rot;
76  }
77  }
78  throw ProcessError("Lane doesn't exist");
79 }
80 
81 
82 void
85 }
86 
87 
88 void
90  myChildConnections.draw(s, GLTypeParent);
91 }
92 
93 
94 void
96  // Check if additional is valid
97  if (additional == nullptr) {
98  throw InvalidArgument("Trying to add an empty child additional in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
99  } else {
100  // add it in child additional container
101  myChildAdditionals.push_back(additional);
102  // Check if children has to be sorted automatically
105  }
106  // update parent additional after add additional (note: by default non-implemented)
108  }
109 }
110 
111 
112 void
114  // First check that additional was already inserted
115  auto it = std::find(myChildAdditionals.begin(), myChildAdditionals.end(), additional);
116  if (it == myChildAdditionals.end()) {
117  throw ProcessError(additional->getTagStr() + " with ID='" + additional->getID() + "' doesn't exist in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
118  } else {
119  myChildAdditionals.erase(it);
120  // Check if children has to be sorted automatically
123  }
124  // update parent additional after add additional (note: by default non-implemented)
126  }
127 }
128 
129 
130 const std::vector<GNEAdditional*>&
132  return myChildAdditionals;
133 }
134 
135 
136 void
139  // we need to sort Entry/Exits due additional.xds model
140  std::vector<GNEAdditional*> sortedEntryExits;
141  // obtain all entrys
142  for (const auto& additional : myChildAdditionals) {
143  if (additional->getTagProperty().getTag() == SUMO_TAG_DET_ENTRY) {
144  sortedEntryExits.push_back(additional);
145  }
146  }
147  // obtain all exits
148  for (const auto& additional : myChildAdditionals) {
149  if (additional->getTagProperty().getTag() == SUMO_TAG_DET_EXIT) {
150  sortedEntryExits.push_back(additional);
151  }
152  }
153  // change myChildAdditionals for sortedEntryExits
154  if (sortedEntryExits.size() == myChildAdditionals.size()) {
155  myChildAdditionals = sortedEntryExits;
156  } else {
157  throw ProcessError("Some child additional were lost during sorting");
158  }
159  } else if (myAC->getTagProperty().getTag() == SUMO_TAG_TAZ) {
160  // we need to sort Entry/Exits due additional.xds model
161  std::vector<GNEAdditional*> sortedTAZSourceSink;
162  // obtain all TAZSources
163  for (const auto& additional : myChildAdditionals) {
164  if (additional->getTagProperty().getTag() == SUMO_TAG_TAZSOURCE) {
165  sortedTAZSourceSink.push_back(additional);
166  }
167  }
168  // obtain all TAZSinks
169  for (const auto& additional : myChildAdditionals) {
170  if (additional->getTagProperty().getTag() == SUMO_TAG_TAZSINK) {
171  sortedTAZSourceSink.push_back(additional);
172  }
173  }
174  // change myChildAdditionals for sortedEntryExits
175  if (sortedTAZSourceSink.size() == myChildAdditionals.size()) {
176  myChildAdditionals = sortedTAZSourceSink;
177  } else {
178  throw ProcessError("Some child additional were lost during sorting");
179  }
180  } else {
181  // declare a vector to keep sorted children
182  std::vector<std::pair<std::pair<double, double>, GNEAdditional*> > sortedChildren;
183  // iterate over child additional
184  for (const auto& additional : myChildAdditionals) {
185  sortedChildren.push_back(std::make_pair(std::make_pair(0., 0.), additional));
186  // set begin/start attribute
187  if (additional->getTagProperty().hasAttribute(SUMO_ATTR_TIME) && GNEAttributeCarrier::canParse<double>(additional->getAttribute(SUMO_ATTR_TIME))) {
188  sortedChildren.back().first.first = additional->getAttributeDouble(SUMO_ATTR_TIME);
189  } else if (additional->getTagProperty().hasAttribute(SUMO_ATTR_BEGIN) && GNEAttributeCarrier::canParse<double>(additional->getAttribute(SUMO_ATTR_BEGIN))) {
190  sortedChildren.back().first.first = additional->getAttributeDouble(SUMO_ATTR_BEGIN);
191  }
192  // set end attribute
193  if (additional->getTagProperty().hasAttribute(SUMO_ATTR_END) && GNEAttributeCarrier::canParse<double>(additional->getAttribute(SUMO_ATTR_END))) {
194  sortedChildren.back().first.second = additional->getAttributeDouble(SUMO_ATTR_END);
195  } else {
196  sortedChildren.back().first.second = sortedChildren.back().first.first;
197  }
198  }
199  // sort children
200  std::sort(sortedChildren.begin(), sortedChildren.end());
201  // make sure that number of sorted children is the same as the child additional
202  if (sortedChildren.size() == myChildAdditionals.size()) {
203  myChildAdditionals.clear();
204  for (auto i : sortedChildren) {
205  myChildAdditionals.push_back(i.second);
206  }
207  } else {
208  throw ProcessError("Some child additional were lost during sorting");
209  }
210  }
211 }
212 
213 
214 bool
216  // declare a vector to keep sorted children
217  std::vector<std::pair<std::pair<double, double>, GNEAdditional*> > sortedChildren;
218  // iterate over child additional
219  for (const auto& additional : myChildAdditionals) {
220  sortedChildren.push_back(std::make_pair(std::make_pair(0., 0.), additional));
221  // set begin/start attribute
222  if (additional->getTagProperty().hasAttribute(SUMO_ATTR_TIME) && GNEAttributeCarrier::canParse<double>(additional->getAttribute(SUMO_ATTR_TIME))) {
223  sortedChildren.back().first.first = additional->getAttributeDouble(SUMO_ATTR_TIME);
224  } else if (additional->getTagProperty().hasAttribute(SUMO_ATTR_BEGIN) && GNEAttributeCarrier::canParse<double>(additional->getAttribute(SUMO_ATTR_BEGIN))) {
225  sortedChildren.back().first.first = additional->getAttributeDouble(SUMO_ATTR_BEGIN);
226  }
227  // set end attribute
228  if (additional->getTagProperty().hasAttribute(SUMO_ATTR_END) && GNEAttributeCarrier::canParse<double>(additional->getAttribute(SUMO_ATTR_END))) {
229  sortedChildren.back().first.second = additional->getAttributeDouble(SUMO_ATTR_END);
230  } else {
231  sortedChildren.back().first.second = sortedChildren.back().first.first;
232  }
233  }
234  // sort children
235  std::sort(sortedChildren.begin(), sortedChildren.end());
236  // make sure that number of sorted children is the same as the child additional
237  if (sortedChildren.size() == myChildAdditionals.size()) {
238  if (sortedChildren.size() <= 1) {
239  return true;
240  } else {
241  // check overlapping
242  for (int i = 0; i < (int)sortedChildren.size() - 1; i++) {
243  if (sortedChildren.at(i).first.second > sortedChildren.at(i + 1).first.first) {
244  return false;
245  }
246  }
247  }
248  return true;
249  } else {
250  throw ProcessError("Some child additional were lost during sorting");
251  }
252 }
253 
254 
255 void
257  // Check if demand element is valid
258  if (demandElement == nullptr) {
259  throw InvalidArgument("Trying to add an empty child demand element in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
260  } else {
261  // add it in demandElement child container
262  myChildDemandElements.push_back(demandElement);
263  // add it also in SortedChildDemandElementsByType container
264  mySortedChildDemandElementsByType.at(demandElement->getTagProperty().getTag()).insert(demandElement);
265  // Check if children has to be sorted automatically
268  }
269  }
270 }
271 
272 
273 void
275  // First check that demandElement was already inserted
276  auto it = std::find(myChildDemandElements.begin(), myChildDemandElements.end(), demandElement);
277  if (it == myChildDemandElements.end()) {
278  throw ProcessError(demandElement->getTagStr() + " with ID='" + demandElement->getID() + "' doesn't exist in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
279  } else {
280  // first check if element is duplicated in vector
281  bool singleElement = std::count(myChildDemandElements.begin(), myChildDemandElements.end(), demandElement) == 1;
282  myChildDemandElements.erase(it);
283  // only remove it from mySortedChildDemandElementsByType if is a single element
284  if (singleElement) {
285  mySortedChildDemandElementsByType.at(demandElement->getTagProperty().getTag()).erase(demandElement);
286  }
287  // Check if children has to be sorted automatically
290  }
291  }
292 }
293 
294 
295 const std::vector<GNEDemandElement*>&
297  return myChildDemandElements;
298 }
299 
300 
301 const std::set<GNEDemandElement*>&
303  return mySortedChildDemandElementsByType.at(tag);
304 }
305 
306 
307 void
309  // by default empty
310 }
311 
312 
313 bool
315  return true;
316 }
317 
318 
321  // find child demand element
322  auto it = std::find(myChildDemandElements.begin(), myChildDemandElements.end(), demandElement);
323  // return element or null depending of iterator
324  if (it == myChildDemandElements.end()) {
325  return nullptr;
326  } else if (it == myChildDemandElements.begin()) {
327  return nullptr;
328  } else {
329  return *(it - 1);
330  }
331 }
332 
333 
336  // find child demand element
337  auto it = std::find(myChildDemandElements.begin(), myChildDemandElements.end(), demandElement);
338  // return element or null depending of iterator
339  if (it == myChildDemandElements.end()) {
340  return nullptr;
341  } else if (it == (myChildDemandElements.end() - 1)) {
342  return nullptr;
343  } else {
344  return *(it + 1);
345  }
346 }
347 
348 
349 void
351  // Check that edge is valid and doesn't exist previously
352  if (edge == nullptr) {
353  throw InvalidArgument("Trying to add an empty child edge in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
354  } else {
355  myChildEdges.push_back(edge);
356  }
357 }
358 
359 
360 void
362  // Check that edge is valid and exist previously
363  if (edge == nullptr) {
364  throw InvalidArgument("Trying to remove an empty child edge in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
365  } else if (std::find(myChildEdges.begin(), myChildEdges.end(), edge) == myChildEdges.end()) {
366  throw InvalidArgument("Trying to remove a non previously inserted child edge in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
367  } else {
368  myChildEdges.erase(std::find(myChildEdges.begin(), myChildEdges.end(), edge));
369  // update connections geometry
371  }
372 }
373 
374 
375 const std::vector<GNEEdge*>&
377  return myChildEdges;
378 }
379 
380 
381 void
383  // Check if lane is valid
384  if (lane == nullptr) {
385  throw InvalidArgument("Trying to add an empty child lane in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
386  } else {
387  myChildLanes.push_back(lane);
388  // update connections geometry
390  }
391 }
392 
393 
394 void
396  // Check if lane is valid
397  if (lane == nullptr) {
398  throw InvalidArgument("Trying to remove an empty child lane in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
399  } else {
400  myChildLanes.erase(std::find(myChildLanes.begin(), myChildLanes.end(), lane));
401  // update connections geometry
403  }
404 }
405 
406 
407 const std::vector<GNELane*>&
409  return myChildLanes;
410 }
411 
412 
413 void
415  // Check that shape is valid and doesn't exist previously
416  if (shape == nullptr) {
417  throw InvalidArgument("Trying to add an empty child shape in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
418  } else if (std::find(myChildShapes.begin(), myChildShapes.end(), shape) != myChildShapes.end()) {
419  throw InvalidArgument("Trying to add a duplicate child shape in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
420  } else {
421  myChildShapes.push_back(shape);
422  // update connections geometry
424  }
425 }
426 
427 
428 void
430  // Check that shape is valid and exist previously
431  if (shape == nullptr) {
432  throw InvalidArgument("Trying to remove an empty child shape in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
433  } else if (std::find(myChildShapes.begin(), myChildShapes.end(), shape) == myChildShapes.end()) {
434  throw InvalidArgument("Trying to remove a non previously inserted child shape in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
435  } else {
436  myChildShapes.erase(std::find(myChildShapes.begin(), myChildShapes.end(), shape));
437  // update connections geometry
439  }
440 }
441 
442 
443 const std::vector<GNEShape*>&
445  return myChildShapes;
446 }
447 
448 
449 void
451  // by default nothing to do
452 }
453 
454 
455 void
457  // by default nothing to do
458 }
459 
460 
461 void
462 GNEHierarchicalChildElements::changeChildEdges(GNEAdditional* elementChild, const std::string& newEdgeIDs) {
463  // remove demandElement of child edges
464  for (const auto& edge : myChildEdges) {
465  edge->removeParentAdditional(elementChild);
466  }
467  // obtain new child edges (note: it can be empty)
468  myChildEdges = GNEAttributeCarrier::parse<std::vector<GNEEdge*> >(elementChild->getViewNet()->getNet(), newEdgeIDs);
469  // add demandElement into parent edges
470  for (const auto& edge : myChildEdges) {
471  edge->addParentAdditional(elementChild);
472  }
473  // update connections geometry
475 }
476 
477 
478 void
479 GNEHierarchicalChildElements::changeChildLanes(GNEAdditional* elementChild, const std::string& newLaneIDs) {
480  // remove demandElement of child lanes
481  for (const auto& lane : myChildLanes) {
482  lane->removeParentAdditional(elementChild);
483  }
484  // obtain new child lanes (note: it can be empty)
485  myChildLanes = GNEAttributeCarrier::parse<std::vector<GNELane*> >(elementChild->getViewNet()->getNet(), newLaneIDs);
486  // add demandElement into parent lanes
487  for (const auto& lane : myChildLanes) {
488  lane->addParentAdditional(elementChild);
489  }
490  // update connections geometry
492 }
493 
494 // ---------------------------------------------------------------------------
495 // GNEHierarchicalChildElements::ChildConnections - methods
496 // ---------------------------------------------------------------------------
497 
499  lane(nullptr),
500  pos(Position::INVALID),
501  rot(0) {
502 }
503 
504 
506  lane(_lane),
507  pos(_pos),
508  rot(_rot) {
509 }
510 
511 
513  myHierarchicalElement(hierarchicalElement) {}
514 
515 
516 void
518  // first clear connection positions
519  connectionPositions.clear();
520  symbolsPositionAndRotation.clear();
521  // calculate position and rotation of every simbol for every edge
522  for (const auto& edge : myHierarchicalElement->myChildEdges) {
523  for (const auto& lane : edge->getLanes()) {
524  Position pos;
525  double rot;
526  // set position and length depending of shape's lengt
527  if (lane->getLaneShape().length() - 6 > 0) {
528  pos = lane->getLaneShape().positionAtOffset(lane->getLaneShape().length() - 6);
529  rot = lane->getLaneShape().rotationDegreeAtOffset(lane->getLaneShape().length() - 6);
530  } else {
531  pos = lane->getLaneShape().positionAtOffset(lane->getLaneShape().length());
532  rot = lane->getLaneShape().rotationDegreeAtOffset(lane->getLaneShape().length());
533  }
534  symbolsPositionAndRotation.push_back(ConnectionGeometry(lane, pos, rot));
535  }
536  }
537  // calculate position and rotation of every symbol for every lane
538  for (const auto& lane : myHierarchicalElement->myChildLanes) {
539  Position pos;
540  double rot;
541  // set position and length depending of shape's lengt
542  if (lane->getLaneShape().length() - 6 > 0) {
543  pos = lane->getLaneShape().positionAtOffset(lane->getLaneShape().length() - 6);
544  rot = lane->getLaneShape().rotationDegreeAtOffset(lane->getLaneShape().length() - 6);
545  } else {
546  pos = lane->getLaneShape().positionAtOffset(lane->getLaneShape().length());
547  rot = lane->getLaneShape().rotationDegreeAtOffset(lane->getLaneShape().length());
548  }
549  symbolsPositionAndRotation.push_back(ConnectionGeometry(lane, pos, rot));
550  }
551  // calculate position for every child additional
552  for (const auto& additional : myHierarchicalElement->myChildAdditionals) {
553  // check that position is different of position
554  if (additional->getPositionInView() != myHierarchicalElement->getPositionInView()) {
555  std::vector<Position> posConnection;
556  double A = std::abs(additional->getPositionInView().x() - myHierarchicalElement->getPositionInView().x());
557  double B = std::abs(additional->getPositionInView().y() - myHierarchicalElement->getPositionInView().y());
558  // Set positions of connection's vertex. Connection is build from Entry to E3
559  posConnection.push_back(additional->getPositionInView());
560  if (myHierarchicalElement->getPositionInView().x() > additional->getPositionInView().x()) {
561  if (myHierarchicalElement->getPositionInView().y() > additional->getPositionInView().y()) {
562  posConnection.push_back(Position(additional->getPositionInView().x() + A, additional->getPositionInView().y()));
563  } else {
564  posConnection.push_back(Position(additional->getPositionInView().x(), additional->getPositionInView().y() - B));
565  }
566  } else {
567  if (myHierarchicalElement->getPositionInView().y() > additional->getPositionInView().y()) {
568  posConnection.push_back(Position(additional->getPositionInView().x(), additional->getPositionInView().y() + B));
569  } else {
570  posConnection.push_back(Position(additional->getPositionInView().x() - A, additional->getPositionInView().y()));
571  }
572  }
573  posConnection.push_back(myHierarchicalElement->getPositionInView());
574  connectionPositions.push_back(posConnection);
575  }
576  }
577  // calculate geometry for connections between parent and children
578  for (const auto& symbol : symbolsPositionAndRotation) {
579  std::vector<Position> posConnection;
580  double A = std::abs(symbol.pos.x() - myHierarchicalElement->getPositionInView().x());
581  double B = std::abs(symbol.pos.y() - myHierarchicalElement->getPositionInView().y());
582  // Set positions of connection's vertex. Connection is build from Entry to E3
583  posConnection.push_back(symbol.pos);
584  if (myHierarchicalElement->getPositionInView().x() > symbol.pos.x()) {
585  if (myHierarchicalElement->getPositionInView().y() > symbol.pos.y()) {
586  posConnection.push_back(Position(symbol.pos.x() + A, symbol.pos.y()));
587  } else {
588  posConnection.push_back(Position(symbol.pos.x(), symbol.pos.y() - B));
589  }
590  } else {
591  if (myHierarchicalElement->getPositionInView().y() > symbol.pos.y()) {
592  posConnection.push_back(Position(symbol.pos.x(), symbol.pos.y() + B));
593  } else {
594  posConnection.push_back(Position(symbol.pos.x() - A, symbol.pos.y()));
595  }
596  }
597  posConnection.push_back(myHierarchicalElement->getPositionInView());
598  connectionPositions.push_back(posConnection);
599  }
600 }
601 
602 
603 void
605  // first check if connections can be drawn
606  if (!s.drawForRectangleSelection) {
607  // Iterate over myConnectionPositions
608  for (const auto& connection : connectionPositions) {
609  // Add a draw matrix
610  glPushMatrix();
611  // traslate in the Z axis
612  glTranslated(0, 0, parentType - 0.01);
613  // Set color of the base
615  // iterate over connections
616  for (auto position = connection.begin(); (position + 1) != connection.end(); position++) {
617  // Draw Lines
618  GLHelper::drawLine((*position), (*(position + 1)));
619  }
620  // Pop draw matrix
621  glPopMatrix();
622  }
623  }
624 }
625 
626 /****************************************************************************/
GNEHierarchicalChildElements::addChildAdditional
void addChildAdditional(GNEAdditional *additional)
Definition: GNEHierarchicalChildElements.cpp:95
GNEDemandElement
An Element which don't belongs to GNENet but has influency in the simulation.
Definition: GNEDemandElement.h:55
GNEAdditional
An Element which don't belongs to GNENet but has influency in the simulation.
Definition: GNEAdditional.h:48
GNEHierarchicalChildElements::removeChildLane
void removeChildLane(GNELane *lane)
remove child lane
Definition: GNEHierarchicalChildElements.cpp:395
GNEAdditional.h
GNEAttributeCarrier::getID
const std::string getID() const
function to support debugging
Definition: GNEAttributeCarrier.cpp:1289
GNEHierarchicalChildElements::removeChildEdge
void removeChildEdge(GNEEdge *edge)
remove child edge
Definition: GNEHierarchicalChildElements.cpp:361
GNEHierarchicalChildElements::getChildDemandElements
const std::vector< GNEDemandElement * > & getChildDemandElements() const
return child demand elements
Definition: GNEHierarchicalChildElements.cpp:296
GUIVisualizationSettings::drawForRectangleSelection
bool drawForRectangleSelection
whether drawing is performed for the purpose of selecting objects using a rectangle
Definition: GUIVisualizationSettings.h:647
GNEHierarchicalChildElements::getChildEdges
const std::vector< GNEEdge * > & getChildEdges() const
get child edges
Definition: GNEHierarchicalChildElements.cpp:376
GNEHierarchicalChildElements::addChildEdge
void addChildEdge(GNEEdge *edge)
Definition: GNEHierarchicalChildElements.cpp:350
GNEHierarchicalChildElements::updateParentDemandElement
virtual void updateParentDemandElement()
update parent after add or remove a child (can be reimplemented, for example used for statistics)
Definition: GNEHierarchicalChildElements.cpp:456
GNEHierarchicalChildElements::drawChildConnections
void drawChildConnections(const GUIVisualizationSettings &s, const GUIGlObjectType GLTypeParent) const
Definition: GNEHierarchicalChildElements.cpp:89
GNEHierarchicalChildElements::addChildDemandElement
void addChildDemandElement(GNEDemandElement *demandElement)
Definition: GNEHierarchicalChildElements.cpp:256
GNEHierarchicalChildElements.h
SUMO_TAG_TAZSOURCE
@ SUMO_TAG_TAZSOURCE
a source within a district (connection road)
Definition: SUMOXMLDefinitions.h:135
GNEHierarchicalChildElements::myChildAdditionals
std::vector< GNEAdditional * > myChildAdditionals
vector with the child additional
Definition: GNEHierarchicalChildElements.h:250
GNEHierarchicalChildElements::~GNEHierarchicalChildElements
~GNEHierarchicalChildElements()
Destructor.
Definition: GNEHierarchicalChildElements.cpp:57
GNEHierarchicalChildElements::sortChildAdditionals
void sortChildAdditionals()
sort child additionals (used by Rerouters, VSS, TAZs...)
Definition: GNEHierarchicalChildElements.cpp:137
SUMO_TAG_DET_ENTRY
@ SUMO_TAG_DET_ENTRY
an e3 entry point
Definition: SUMOXMLDefinitions.h:81
GUIVisualizationColorSettings::childConnections
static const RGBColor childConnections
color for child connections between parents and child elements
Definition: GUIVisualizationSettings.h:162
GLHelper.h
GNEHierarchicalChildElements::ChildConnections::myHierarchicalElement
GNEHierarchicalChildElements * myHierarchicalElement
pointer to hierarchical element parent
Definition: GNEHierarchicalChildElements.h:227
GLHelper::setColor
static void setColor(const RGBColor &c)
Sets the gl-color to this value.
Definition: GLHelper.cpp:621
SumoXMLTag
SumoXMLTag
Numbers representing SUMO-XML - element names.
Definition: SUMOXMLDefinitions.h:41
GNEAttributeCarrier::TagProperties::getTag
SumoXMLTag getTag() const
get Tag vinculated with this attribute Property
Definition: GNEAttributeCarrier.cpp:523
GNEHierarchicalChildElements
An special type of Attribute carrier that owns hierarchical elements.
Definition: GNEHierarchicalChildElements.h:45
GNEHierarchicalChildElements::myChildShapes
std::vector< GNEShape * > myChildShapes
vector with the child lanes of this element
Definition: GNEHierarchicalChildElements.h:247
INVALID
#define INVALID
Definition: MSDevice_SSM.cpp:70
SUMO_ATTR_BEGIN
@ SUMO_ATTR_BEGIN
weights: time range begin
Definition: SUMOXMLDefinitions.h:678
GUIGlObjectType
GUIGlObjectType
Definition: GUIGlObjectTypes.h:39
GNEEdge
A road/street connecting two junctions (netedit-version)
Definition: GNEEdge.h:51
GNEAttributeCarrier::TagProperties::canAutomaticSortChildren
bool canAutomaticSortChildren() const
return true if tag correspond to an element that can sort their children automatic
Definition: GNEAttributeCarrier.cpp:883
GNEViewNet::getNet
GNENet * getNet() const
get the net object
Definition: GNEViewNet.cpp:1014
GNEHierarchicalChildElements::getChildLanes
const std::vector< GNELane * > & getChildLanes() const
get child lanes
Definition: GNEHierarchicalChildElements.cpp:408
GNEHierarchicalChildElements::getChildRotation
double getChildRotation(const GNELane *lane)
get child rotation calculated in ChildConnections
Definition: GNEHierarchicalChildElements.cpp:72
GNEHierarchicalChildElements::addChildLane
void addChildLane(GNELane *lane)
Definition: GNEHierarchicalChildElements.cpp:382
GNEHierarchicalChildElements::ChildConnections::update
void update()
update Connection's geometry
Definition: GNEHierarchicalChildElements.cpp:517
GNEHierarchicalChildElements::getPreviousChildDemandElement
GNEDemandElement * getPreviousChildDemandElement(const GNEDemandElement *demandElement) const
get previous child demand element to the given demand element
Definition: GNEHierarchicalChildElements.cpp:320
GNEAttributeCarrier::getTagProperty
const TagProperties & getTagProperty() const
get Tag Property assigned to this object
Definition: GNEAttributeCarrier.cpp:1273
GNEShape
Definition: GNEShape.h:34
GNEHierarchicalChildElements::GNEHierarchicalChildElements
GNEHierarchicalChildElements(GNEAttributeCarrier *AC, const std::vector< GNEEdge * > &childEdges, const std::vector< GNELane * > &childLanes, const std::vector< GNEShape * > &childShapes, const std::vector< GNEAdditional * > &childAdditionals, const std::vector< GNEDemandElement * > &childDemandElements)
Parameter Constructor.
Definition: GNEHierarchicalChildElements.cpp:36
GNEAttributeCarrier::allowedTagsByCategory
static std::vector< SumoXMLTag > allowedTagsByCategory(int tagPropertyCategory, bool onlyDrawables)
get tags of all editable element types using TagProperty Type (TAGTYPE_NETELEMENT,...
Definition: GNEAttributeCarrier.cpp:1333
GNEHierarchicalChildElements::sortChildDemandElements
void sortChildDemandElements()
sort child demand elements
Definition: GNEHierarchicalChildElements.cpp:308
GNEHierarchicalChildElements::removeChildShape
void removeChildShape(GNEShape *shape)
remove child shape
Definition: GNEHierarchicalChildElements.cpp:429
GNEHierarchicalChildElements::getChildShapes
const std::vector< GNEShape * > & getChildShapes() const
get child shapes
Definition: GNEHierarchicalChildElements.cpp:444
GNEHierarchicalChildElements::myChildDemandElements
std::vector< GNEDemandElement * > myChildDemandElements
vector with the demand elements children
Definition: GNEHierarchicalChildElements.h:253
GNEDemandElement.h
GNEHierarchicalChildElements::ChildConnections::draw
void draw(const GUIVisualizationSettings &s, const GUIGlObjectType parentType) const
draw connections between Parent and childrens
Definition: GNEHierarchicalChildElements.cpp:604
GNEViewNet.h
GNEHierarchicalChildElements::ChildConnections::ChildConnections
ChildConnections(GNEHierarchicalChildElements *hierarchicalElement)
constructor
Definition: GNEHierarchicalChildElements.cpp:512
GNEHierarchicalChildElements::ChildConnections::ConnectionGeometry
connection geometry
Definition: GNEHierarchicalChildElements.h:192
ProcessError
Definition: UtilExceptions.h:39
GNEHierarchicalChildElements::ChildConnections::ConnectionGeometry::ConnectionGeometry
ConnectionGeometry()
default constructor
Definition: GNEHierarchicalChildElements.cpp:498
GNEHierarchicalChildElements::getNextChildDemandElement
GNEDemandElement * getNextChildDemandElement(const GNEDemandElement *demandElement) const
get next child demand element to the given demand element
Definition: GNEHierarchicalChildElements.cpp:335
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:38
GNEEdge.h
GLHelper::drawLine
static void drawLine(const Position &beg, double rot, double visLength)
Draws a thin line.
Definition: GLHelper.cpp:274
GNEHierarchicalChildElements::myChildEdges
std::vector< GNEEdge * > myChildEdges
vector with the child edges of this element
Definition: GNEHierarchicalChildElements.h:241
GNEHierarchicalChildElements::updateChildConnections
void updateChildConnections()
update child connections
Definition: GNEHierarchicalChildElements.cpp:83
GNEHierarchicalChildElements::removeChildAdditional
void removeChildAdditional(GNEAdditional *additional)
remove child additional
Definition: GNEHierarchicalChildElements.cpp:113
GNEHierarchicalChildElements::changeChildEdges
void changeChildEdges(GNEAdditional *elementChild, const std::string &newEdgeIDs)
change child edges of an additional
Definition: GNEHierarchicalChildElements.cpp:462
GNEAdditional::getAttributeDouble
virtual double getAttributeDouble(SumoXMLAttr key) const =0
GNEHierarchicalChildElements::changeChildLanes
void changeChildLanes(GNEAdditional *elementChild, const std::string &newEdgeIDs)
change child edges of an additional
Definition: GNEHierarchicalChildElements.cpp:479
GNEHierarchicalChildElements::removeChildDemandElement
void removeChildDemandElement(GNEDemandElement *demandElement)
remove child demand element
Definition: GNEHierarchicalChildElements.cpp:274
GNEHierarchicalChildElements::myAC
GNEAttributeCarrier * myAC
pointer to AC (needed to avoid diamond problem)
Definition: GNEHierarchicalChildElements.h:259
SUMO_ATTR_TIME
@ SUMO_ATTR_TIME
trigger: the time of the step
Definition: SUMOXMLDefinitions.h:676
GNELane.h
GNEHierarchicalChildElements::checkChildDemandElementsOverlapping
bool checkChildDemandElementsOverlapping() const
check if childs demand elements are overlapped
Definition: GNEHierarchicalChildElements.cpp:314
GUIVisualizationSettings::colorSettings
GUIVisualizationColorSettings colorSettings
color settings
Definition: GUIVisualizationSettings.h:677
SUMO_TAG_TAZ
@ SUMO_TAG_TAZ
a traffic assignment zone
Definition: SUMOXMLDefinitions.h:133
GNEHierarchicalChildElements::getChildPosition
const Position & getChildPosition(const GNELane *lane)
get child position calculated in ChildConnections
Definition: GNEHierarchicalChildElements.cpp:61
GLIncludes.h
SUMO_TAG_TAZSINK
@ SUMO_TAG_TAZSINK
a sink within a district (connection road)
Definition: SUMOXMLDefinitions.h:137
GNEHierarchicalChildElements::getChildDemandElementsSortedByType
const std::set< GNEDemandElement * > & getChildDemandElementsSortedByType(SumoXMLTag tag) const
return child demand elements sorted by type
Definition: GNEHierarchicalChildElements.cpp:302
GNEHierarchicalChildElements::checkChildAdditionalsOverlapping
bool checkChildAdditionalsOverlapping() const
check if children are overlapped (Used by Rerouters)
Definition: GNEHierarchicalChildElements.cpp:215
GNEHierarchicalChildElements::myChildConnections
ChildConnections myChildConnections
variable ChildConnections
Definition: GNEHierarchicalChildElements.h:237
InvalidArgument
Definition: UtilExceptions.h:56
GNEHierarchicalChildElements::ChildConnections::symbolsPositionAndRotation
std::vector< ConnectionGeometry > symbolsPositionAndRotation
position and rotation of every symbol over lane
Definition: GNEHierarchicalChildElements.h:220
GNEAdditional::getViewNet
GNEViewNet * getViewNet() const
Returns a pointer to GNEViewNet in which additional element is located.
Definition: GNEAdditional.cpp:307
SUMO_TAG_E3DETECTOR
@ SUMO_TAG_E3DETECTOR
an e3 detector
Definition: SUMOXMLDefinitions.h:73
config.h
GNEHierarchicalChildElements::myChildLanes
std::vector< GNELane * > myChildLanes
vector with the child lanes of this element
Definition: GNEHierarchicalChildElements.h:244
GNEHierarchicalChildElements::addChildShape
void addChildShape(GNEShape *shape)
Definition: GNEHierarchicalChildElements.cpp:414
SUMO_ATTR_END
@ SUMO_ATTR_END
weights: time range end
Definition: SUMOXMLDefinitions.h:680
GNEAttributeCarrier::getTagStr
const std::string & getTagStr() const
get tag assigned to this object in string format
Definition: GNEAttributeCarrier.cpp:1267
GUIVisualizationSettings
Stores the information about how to visualize structures.
Definition: GUIVisualizationSettings.h:345
GNEHierarchicalChildElements::updateParentAdditional
virtual void updateParentAdditional()
update parent after add or remove a child (can be reimplemented, for example used for statistics)
Definition: GNEHierarchicalChildElements.cpp:450
SUMO_TAG_DET_EXIT
@ SUMO_TAG_DET_EXIT
an e3 exit point
Definition: SUMOXMLDefinitions.h:83
GNELane
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
Definition: GNELane.h:45
GNEHierarchicalChildElements::mySortedChildDemandElementsByType
std::map< SumoXMLTag, std::set< GNEDemandElement * > > mySortedChildDemandElementsByType
vector with the demand elements children sorted by type and filtered (to avoid duplicated
Definition: GNEHierarchicalChildElements.h:256
GNEAttributeCarrier
Definition: GNEAttributeCarrier.h:54
GNEHierarchicalChildElements::getChildAdditionals
const std::vector< GNEAdditional * > & getChildAdditionals() const
return child additionals
Definition: GNEHierarchicalChildElements.cpp:131