SUMO - Simulation of Urban MObility
PedestrianRouter.h
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2018 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 /****************************************************************************/
15 // The Pedestrian Router builds a special network and delegates to a SUMOAbstractRouter.
16 /****************************************************************************/
17 #ifndef PedestrianRouter_h
18 #define PedestrianRouter_h
19 
20 
21 // ===========================================================================
22 // included modules
23 // ===========================================================================
24 #include <config.h>
25 
26 #include <string>
27 #include <vector>
28 #include <algorithm>
29 #include <assert.h>
31 #include <utils/common/SUMOTime.h>
32 #include <utils/common/ToString.h>
33 #include "SUMOAbstractRouter.h"
34 #include "DijkstraRouter.h"
35 #include "IntermodalNetwork.h"
36 
37 //#define PedestrianRouter_DEBUG_ROUTES
38 
39 
40 // ===========================================================================
41 // class definitions
42 // ===========================================================================
47 template<class E, class L, class N, class V>
48 class PedestrianRouter : public SUMOAbstractRouter<E, IntermodalTrip<E, N, V> > {
49 private:
54 
55 public:
58  SUMOAbstractRouter<E, _IntermodalTrip>("PedestrianRouter"), myAmClone(false) {
59  myPedNet = new _IntermodalNetwork(E::getAllEdges(), true);
61  }
62 
63  PedestrianRouter(_IntermodalNetwork* net):
64  SUMOAbstractRouter<E, _IntermodalTrip>("PedestrianRouterClone"), myAmClone(true) {
65  myPedNet = net;
67  }
68 
70  virtual ~PedestrianRouter() {
71  delete myInternalRouter;
72  if (!myAmClone) {
73  delete myPedNet;
74  }
75  }
76 
79  }
80 
83  double compute(const E* from, const E* to, double departPos, double arrivalPos, double speed,
84  SUMOTime msTime, const N* onlyNode, std::vector<const E*>& into, bool allEdges = false) {
85  if (getSidewalk<E, L>(from) == 0) {
86  WRITE_WARNING("Departure edge '" + from->getID() + "' does not allow pedestrians.");
87  return false;
88  }
89  if (getSidewalk<E, L>(to) == 0) {
90  WRITE_WARNING("Destination edge '" + to->getID() + "' does not allow pedestrians.");
91  return false;
92  }
93  _IntermodalTrip trip(from, to, departPos, arrivalPos, speed, msTime, onlyNode);
94  std::vector<const _IntermodalEdge*> intoPed;
95  const bool success = myInternalRouter->compute(myPedNet->getDepartConnector(from),
97  &trip, msTime, intoPed);
98  double time = 0.;
99  if (success) {
100  for (const _IntermodalEdge* pedEdge : intoPed) {
101  if (pedEdge->includeInRoute(allEdges)) {
102  into.push_back(pedEdge->getEdge());
103  }
104  time += myInternalRouter->getEffort(pedEdge, &trip, time);
105  }
106  }
107 #ifdef PedestrianRouter_DEBUG_ROUTES
108  std::cout << TIME2STEPS(msTime) << " trip from " << from->getID() << " to " << to->getID()
109  << " departPos=" << departPos
110  << " arrivalPos=" << arrivalPos
111  << " onlyNode=" << (onlyNode == 0 ? "NULL" : onlyNode->getID())
112  << " edges=" << toString(intoPed)
113  << " resultEdges=" << toString(into)
114  << " time=" << time
115  << "\n";
116 #endif
117  return success ? time : -1.;
118  }
119 
122  bool compute(const E*, const E*, const _IntermodalTrip* const,
123  SUMOTime, std::vector<const E*>&) {
124  throw ProcessError("Do not use this method");
125  }
126 
127  void prohibit(const std::vector<E*>& toProhibit) {
128  std::vector<_IntermodalEdge*> toProhibitPE;
129  for (typename std::vector<E*>::const_iterator it = toProhibit.begin(); it != toProhibit.end(); ++it) {
130  toProhibitPE.push_back(myPedNet->getBothDirections(*it).first);
131  toProhibitPE.push_back(myPedNet->getBothDirections(*it).second);
132  }
133  myInternalRouter->prohibit(toProhibitPE);
134  }
135 
136 private:
137  const bool myAmClone;
138  _InternalRouter* myInternalRouter;
139  _IntermodalNetwork* myPedNet;
140 
141 
142 private:
145 
146 };
147 
148 
149 #endif
150 
151 /****************************************************************************/
const EdgePair & getBothDirections(const E *e) const
Returns the pair of forward and backward edge.
long long int SUMOTime
Definition: SUMOTime.h:36
_IntermodalEdge * getDepartConnector(const E *e, const int splitIndex=0) const
Returns the departing intermodal connector at the given split offset.
const std::vector< _IntermodalEdge * > & getAllEdges()
virtual ~PedestrianRouter()
Destructor.
virtual SUMOAbstractRouter< E, _IntermodalTrip > * clone()
IntermodalTrip< E, N, V > _IntermodalTrip
static double getTravelTimeStatic(const IntermodalEdge *const edge, const IntermodalTrip< E, N, V > *const trip, double time)
virtual bool compute(const E *from, const E *to, const V *const vehicle, SUMOTime msTime, std::vector< const E *> &into)
Builds the route between the given edges using the minimum effort at the given time The definition of...
#define TIME2STEPS(x)
Definition: SUMOTime.h:60
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:241
PedestrianRouter()
Constructor.
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:49
Computes the shortest path through a network using the Dijkstra algorithm.
bool compute(const E *, const E *, const _IntermodalTrip *const, SUMOTime, std::vector< const E *> &)
Builds the route between the given edges using the minimum effort at the given time The definition of...
double compute(const E *from, const E *to, double departPos, double arrivalPos, double speed, SUMOTime msTime, const N *onlyNode, std::vector< const E *> &into, bool allEdges=false)
Builds the route between the given edges using the minimum effort at the given time The definition of...
_IntermodalNetwork * myPedNet
_IntermodalEdge * getArrivalConnector(const E *e, const int splitIndex=0) const
Returns the arriving intermodal connector at the given split offset.
IntermodalEdge< E, L, N, V > _IntermodalEdge
PedestrianRouter & operator=(const PedestrianRouter &s)
Invalidated assignment operator.
the intermodal network storing edges, connections and the mappings to the "real" edges ...
the base edge type that is given to the internal router (SUMOAbstractRouter)
void prohibit(const std::vector< E *> &toProhibit)
_InternalRouter * myInternalRouter
PedestrianRouter(_IntermodalNetwork *net)
IntermodalNetwork< E, L, N, V > _IntermodalNetwork
the "vehicle" type that is given to the internal router (SUMOAbstractRouter)
DijkstraRouter< _IntermodalEdge, _IntermodalTrip, SUMOAbstractRouterPermissions< _IntermodalEdge, _IntermodalTrip > > _InternalRouter