51 myReconstructAddedConnections(false),
52 myReconstructRemovedConnections(false),
53 myPhasesLoaded(false) {
71 if (sumoDef !=
nullptr) {
102 NBConnection conn(from, fromLane, to, toLane, linkIndex);
127 (*i)->removeTrafficLight(&dummy);
162 (*it).replaceFrom(removed, removedLane, by, byLane);
163 (*it).replaceTo(removed, removedLane, by, byLane);
203 if (it->getFrom() == conn.
getFrom() &&
204 it->getTo() == conn.
getTo() &&
242 const EdgeVector& incoming = (*i)->getIncomingEdges();
243 copy(incoming.begin(), incoming.end(), back_inserter(
myIncomingEdges));
244 const EdgeVector& outgoing = (*i)->getOutgoingEdges();
245 copy(outgoing.begin(), outgoing.end(), back_inserter(myOutgoing));
252 EdgeVector::iterator k = std::find(myOutgoing.begin(), myOutgoing.end(), edge);
253 if (k != myOutgoing.end()) {
255 bool controlled =
false;
257 if ((*it).getFrom() == edge) {
266 (*j)->setInsideTLS();
296 (*it).shiftLaneIndex(edge, offset, threshold);
311 const int numNormalLinks = noLinksAll;
312 int oldCrossings = 0;
314 bool customIndex =
false;
315 std::vector<NBNode::Crossing*> crossings;
317 const std::vector<NBNode::Crossing*>& c = (*i)->getCrossings();
319 customIndex |= (*i)->setCrossingTLIndices(
getID(), noLinksAll);
320 copy(c.begin(), c.end(), std::back_inserter(crossings));
321 noLinksAll += (int)c.size();
322 oldCrossings += (*i)->numCrossingsFromSumoNet();
324 if ((
int)crossings.size() != oldCrossings) {
327 if (phases.size() > 0 && (
328 (int)(phases.front().state.size()) < noLinksAll ||
329 ((
int)(phases.front().state.size()) > noLinksAll && !customIndex))) {
333 std::vector<int> fromLanes(size, 0);
335 const std::string crossingDefaultState(crossings.size(),
'r');
341 for (std::vector<NBTrafficLightLogic::PhaseDefinition>::const_iterator it = phases.begin(); it != phases.end(); it++) {
342 const std::string state = it->state.substr(0, numNormalLinks) + crossingDefaultState;
349 }
else if (phases.size() == 0) {
358 assert(fromEdges.size() > 0);
359 assert(fromEdges.size() == toEdges.size());
360 const int size = (int)fromEdges.size();
367 "' with " +
toString(size) +
" links.");
383 const std::vector<NBTrafficLightLogic::PhaseDefinition> phases =
myTLLogic->
getPhases();
384 for (std::vector<NBTrafficLightLogic::PhaseDefinition>::const_iterator it = phases.begin(); it != phases.end(); it++) {
385 const std::string state = (*it).state;
397 && (state[i2] ==
'G' || state[i2] ==
'g')
403 if (forbidden || rightTurnConflict) {
442 #ifdef DEBUG_RECONSTRUCTION 446 std::cout <<
" " << *it <<
"\n";
463 (*i)->removeTrafficLight(&dummy);
467 if (newLogic !=
nullptr) {
503 bool exclusive =
true;
505 if (other != con && other.
getTLIndex() == removed) {
513 if (other.getTLIndex() > removed) {
514 other.setTLIndex(other.getTLIndex() - 1);
520 if (c->customTLIndex > removed) {
526 const std::vector<NBTrafficLightLogic::PhaseDefinition> phases =
myTLLogic->
getPhases();
528 for (std::vector<NBTrafficLightLogic::PhaseDefinition>::const_iterator it = phases.begin(); it != phases.end(); it++) {
529 std::string newState = it->state;
530 newState.erase(newState.begin() + removed);
531 newLogic->
addStep(it->duration, newState);
541 #ifdef DEBUG_RECONSTRUCTION 542 if (debugPrintModified) {
543 std::cout <<
" newLinks:\n";
545 std::cout <<
" " << *it <<
"\n";
556 maxIndex =
MAX2(maxIndex, c.getTLIndex());
560 maxIndex =
MAX2(maxIndex, c->tlLinkIndex);
561 maxIndex =
MAX2(maxIndex, c->tlLinkIndex2);
616 std::map<int, int> indexUsage;
618 indexUsage[c.getTLIndex()]++;
622 indexUsage[c->tlLinkIndex]++;
623 indexUsage[c->tlLinkIndex2]++;
626 for (
auto it : indexUsage) {
627 if (it.first >= 0 && it.second > 1) {
636 bool hasMinMaxDur =
false;
639 std::cout <<
" phase=" << phase.state <<
" maxDur=" << phase.maxDur <<
"\n";
646 std::set<int> yellowIndices;
648 for (
int i = 0; i < (int)phase.state.size(); i++) {
649 if (phase.state[i] ==
'y' || phase.state[i] ==
'Y') {
650 yellowIndices.insert(i);
655 bool needMinMaxDur =
false;
657 std::set<int> greenIndices;
658 if (phase.state.find_first_of(
"yY") != std::string::npos) {
661 for (
int i = 0; i < (int)phase.state.size(); i++) {
662 if (yellowIndices.count(i) != 0 && phase.state[i] ==
'G') {
663 needMinMaxDur =
true;
664 greenIndices.insert(i);
670 if (greenIndices.count(c.getTLIndex()) != 0) {
671 maxSpeed =
MAX2(maxSpeed, c.getFrom()->getLaneSpeed(c.getFromLane()));
675 const double minDurBySpeed = maxSpeed * 3.6 / 6 - 3.3;
bool mayBeTLSControlled(int fromLane, NBEdge *toEdge, int toLane) const
return true if certain connection must be controlled by TLS
void removeConnection(const NBConnection &conn, bool reconstruct=true)
removes the given connection from the traffic light if recontruct=true, reconstructs the logic and in...
virtual void setParticipantsInformation()
Builds the list of participating nodes/edges/links.
bool setControllingTLInformation(const NBConnection &c, const std::string &tlID)
Returns if the link could be set as to be controlled.
void setTLControllingInformation() const
Informs edges about being controlled by a tls.
TrafficLightType myType
The algorithm type for the traffic light.
virtual void addNode(NBNode *node)
Adds a node to the traffic light logic.
NBLoadedSUMOTLDef(const std::string &id, const std::string &programID, SUMOTime offset, TrafficLightType type)
Constructor.
void guessMinMaxDuration()
heuristically add minDur and maxDur when switching from tlType fixed to actuated
void setPhaseMaxDuration(int phaseIndex, SUMOTime duration)
void collectEdges()
Build the list of participating edges.
void collectAllLinks()
helper method for use in NBOwnTLDef and NBLoadedSUMOTLDef
static const std::string DummyID
id for temporary definitions
void setOffset(SUMOTime offset)
Sets the offset of this tls.
void reconstructLogic()
adapt to removal or addition of connections
int getNumLinks()
Returns the number of participating links.
A loaded (complete) traffic light logic.
RightOnRedConflicts myRightOnRedConflicts
A SUMO-compliant built logic for a traffic light.
bool myReconstructAddedConnections
whether the logic must be reconstructed
void registerModifications(bool addedConnections, bool removedConnections)
register changes that necessitate recomputation
EdgeVector myIncomingEdges
The list of incoming edges.
The representation of a single edge during network building.
TrafficLightType getType() const
get the algorithm type (static etc..)
class for identifying connections
const std::vector< PhaseDefinition > & getPhases() const
Returns the phases.
const NBConnectionVector & getControlledLinks() const
returns the controlled links (depends on previous call to collectLinks)
NBTrafficLightLogic * compute(OptionsCont &oc)
Computes the traffic light logic.
The base class for traffic light logic definitions.
void setPhaseMinDuration(int phaseIndex, SUMOTime duration)
void setOffset(SUMOTime offset)
Sets the offset of this tls.
static const SUMOTime UNSPECIFIED_DURATION
int computeBrakingTime(double minDecel) const
Computes the time vehicles may need to brake.
NBEdge * getFrom() const
returns the from-edge (start of the connection)
bool hasValidIndices() const
return whether all tls link indices are valid
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
const std::string & getID() const
Returns the id.
SUMOTime myOffset
The offset in the program.
#define UNUSED_PARAMETER(x)
void addPhase(SUMOTime duration, const std::string &state, SUMOTime minDur, SUMOTime maxDur, const std::vector< int > &next, const std::string &name)
Adds a phase to the logic the new phase is inserted at the end of the list of already added phases...
#define WRITE_WARNING(msg)
void replaceRemoved(NBEdge *removed, int removedLane, NBEdge *by, int byLane)
Replaces a removed edge/lane.
static OptionsCont & getOptions()
Retrieves the options.
static bool rightTurnConflict(const NBEdge *from, const NBEdge *to, int fromLane, const NBEdge *prohibitorFrom, const NBEdge *prohibitorTo, int prohibitorFromLane, bool lefthand=false)
return whether the given laneToLane connection is a right turn which must yield to a bicycle crossing...
SUMOTime getOffset()
Returns the offset.
void setType(TrafficLightType type)
set the algorithm type (static etc..)
void initNeedsContRelation() const
static void addPedestrianScramble(NBTrafficLightLogic *logic, int noLinksAll, SUMOTime greenTime, SUMOTime yellowTime, const std::vector< NBNode::Crossing *> &crossings, const EdgeVector &fromEdges, const EdgeVector &toEdges)
add an additional pedestrian phase if there are crossings that did not get green yet ...
virtual void collectEdges()
Build the list of participating edges.
static const int InvalidTlIndex
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
void updateParameter(const std::map< std::string, std::string > &mapArg)
Adds or updates all given parameters from the map.
virtual int getMaxIndex()=0
Returns the maximum index controlled by this traffic light and assigned to a connection.
std::set< std::string > myControlledInnerEdges
Set of inner edges that shall be controlled, though.
void addStep(SUMOTime duration, const std::string &state, const std::vector< int > &next=std::vector< int >(), const std::string &name="", int index=-1)
Adds a phase to the logic.
int getNumLanes() const
Returns the number of lanes.
void patchIfCrossingsAdded()
repair the plan if controlled nodes received pedestrian crossings
void addConnection(NBEdge *from, NBEdge *to, int fromLane, int toLane, int linkIndex, bool reconstruct=true)
Adds a connection and immediately informs the edges.
std::set< NBNode * > myOriginalNodes
The original nodes for which the loaded logic is valid.
bool hasConnectionTo(NBEdge *destEdge, int destLane, int fromLane=-1) const
Retrieves info about a connection to a certain lane of a certain edge.
const std::string & getID() const
bool rightOnRedConflict(int index, int foeIndex) const
whether the given index must yield to the foeIndex while turing right on a red light ...
int getMaxValidIndex()
Returns the maximum index controlled by this traffic light.
void setProgramID(const std::string &programID)
Sets the programID.
const std::string & getProgramID() const
Returns the ProgramID.
void remapRemoved(NBEdge *removed, const EdgeVector &incoming, const EdgeVector &outgoing)
Replaces occurences of the removed edge in incoming/outgoing edges of all definitions.
void joinLogic(NBTrafficLightDefinition *def)
join nodes and states from the given logic (append red state)
const EdgeVector & getIncomingEdges() const
Returns the list of incoming edges (must be build first)
void setTLControllingInformation() const
Informs edges about being controlled by a tls.
int getToLane() const
returns the to-lane
NBEdge * getTo() const
returns the to-edge (end of the connection)
void closeBuilding(bool checkVarDurations=true)
closes the building process
std::set< NBEdge * > myShifted
set of edges with shifted lane indices (to avoid shifting twice)
bool myRightOnRedConflictsReady
void setID(const std::string &newID)
resets the id
static std::string addPedestrianPhases(NBTrafficLightLogic *logic, SUMOTime greenTime, SUMOTime minDur, SUMOTime maxDur, std::string state, const std::vector< NBNode::Crossing *> &crossings, const EdgeVector &fromEdges, const EdgeVector &toEdges)
add 1 or 2 phases depending on the presence of pedestrian crossings
bool forbids(const NBEdge *const possProhibitorFrom, const NBEdge *const possProhibitorTo, const NBEdge *const possProhibitedFrom, const NBEdge *const possProhibitedTo, bool regardNonSignalisedLowerPriority, bool sameNodeOnly=false) const
Returns the information whether "prohibited" flow must let "prohibitor" flow pass.
bool myNeedsContRelationReady
TrafficLightType getType() const
get the algorithm type (static etc..)
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
static bool runningNetedit()
whether netbuilding takes place in the context of NETEDIT
const std::vector< NBNode * > & getNodes() const
Returns the list of controlled nodes.
void collectLinks()
Collects the links participating in this traffic light (only if not previously loaded) ...
NeedsContRelation myNeedsContRelation
bool isTurningDirectionAt(const NBEdge *const edge) const
Returns whether the given edge is the opposite direction to this edge.
int getFromLane() const
returns the from-lane
NBTrafficLightLogic * myCompute(int brakingTimeSeconds)
Computes the traffic light logic finally in dependence to the type.
Represents a single node (junction) during network building.
const std::map< std::string, std::string > & getParametersMap() const
Returns the inner key/value map.
A definition of a pedestrian crossing.
void setStateLength(int numLinks, LinkState fill=LINKSTATE_TL_RED)
bool myReconstructRemovedConnections
~NBLoadedSUMOTLDef()
Destructor.
bool usingSignalGroups() const
whether this definition uses signal group (multiple connections with the same link index) ...
data structure for caching needsCont information
void setType(TrafficLightType type)
Sets the algorithm type of this tls.
void shiftTLConnectionLaneIndex(NBEdge *edge, int offset, int threshold=-1)
patches signal plans by modifying lane indices with the given offset, only indices with a value above...
int getTLIndex() const
returns the index within the controlling tls or InvalidTLIndex if this link is unontrolled ...
std::vector< NBNode * > myControlledNodes
The container with participating nodes.
NBNode * getFromNode() const
Returns the origin node of the edge.
A traffic light logics which must be computed (only nodes/edges are given)
bool foes(const NBEdge *const from1, const NBEdge *const to1, const NBEdge *const from2, const NBEdge *const to2) const
Returns the information whether the given flows cross.
NBConnectionVector myControlledLinks
The list of controlled links.
NBNode * getToNode() const
Returns the destination node of the edge.
EdgeVector myEdgesWithin
The list of edges within the area controlled by the tls.
NBTrafficLightLogic * myTLLogic
phases are added directly to myTLLogic which is then returned in myCompute()
int getMaxIndex()
return the highest known tls link index used by any controlled connection or crossing ...
void collectEdgeVectors(EdgeVector &fromEdges, EdgeVector &toEdges, std::vector< int > &fromLanes) const
Collects the edges for each tlIndex.