NBLoadedSUMOTLDef.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2011-2024 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// A complete traffic light logic loaded from a sumo-net. (opted to reimplement
// since NBLoadedTLDef is quite vissim specific)
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <vector>
#include <string>
#include <set>
#include "NBNode.h"
#include "NBEdgeCont.h"
#include "NBTrafficLightDefinition.h"
#include "NBTrafficLightLogic.h"
#include <utils/common/SUMOTime.h>
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class NBLoadedSUMOTLDef : public NBTrafficLightDefinition {
public:
 
    NBLoadedSUMOTLDef(const std::string& id, const std::string& programID, SUMOTime offset, TrafficLightType type);
 
    NBLoadedSUMOTLDef(const NBTrafficLightDefinition& def, const NBTrafficLightLogic& logic);
 
 
    ~NBLoadedSUMOTLDef();
 
    void setID(const std::string& newID);
 
    void setProgramID(const std::string& programID);
 
    void setTLControllingInformation() const;
 
    void remapRemoved(NBEdge* removed,
                      const EdgeVector& incoming, const EdgeVector& outgoing);
 
 
    void replaceRemoved(NBEdge* removed, int removedLane,
                        NBEdge* by, int byLane, bool incoming);
 
    void shiftTLConnectionLaneIndex(NBEdge* edge, int offset, int threshold = -1);
 
    void addPhase(const SUMOTime duration, const std::string& state, const SUMOTime minDur, const SUMOTime maxDur,
                  const SUMOTime earliestEnd, const SUMOTime latestEnd, const SUMOTime vehExt, const SUMOTime yellow,
                  const SUMOTime red, const std::vector<int>& next, const std::string& name);
 
    void phasesLoaded() {
        myPhasesLoaded = true;
    }
 
    void addConnection(NBEdge* from, NBEdge* to, int fromLane, int toLane, int linkIndex, int linkIndex2, bool reconstruct = true);
 
 
    void removeConnection(const NBConnection& conn, bool reconstruct = true);
 
    void registerModifications(bool addedConnections, bool removedConnections);
 
    NBTrafficLightLogic* getLogic() {
        return myTLLogic;
    }
 
    void setOffset(SUMOTime offset);
 
    void setType(TrafficLightType type);
 
    bool rightOnRedConflict(int index, int foeIndex) const;
 
    /* @brief shortens phase states to remove states that are not referenced by
     * any controlled link and returns whether states were shortened
    */
    bool cleanupStates();
 
    bool usingSignalGroups() const;
 
    void joinLogic(NBTrafficLightDefinition* def);
 
    void guessMinMaxDuration();
 
    void groupSignals();
 
    void ungroupSignals();
 
    // Note: Issues a warning when the grouping of def is incompatible with the current states
    void copyIndices(NBTrafficLightDefinition* def);
 
    void finalChecks() const;
 
    void replaceIndex(int oldIndex, int newIndex);
 
protected:
    void collectLinks();
 
    void collectEdges();
 
    NBTrafficLightLogic* myCompute(int brakingTimeSeconds);
 
    bool amInvalid() const;
 
    void initNeedsContRelation() const;
 
    int getMaxIndex();
 
    int getMaxValidIndex();
 
    std::string getStates(int index);
 
    bool isUsed(int index) const;
 
    std::set<const NBEdge*> getEdgesUsingIndex(int index) const;
 
private:
 
    NBTrafficLightLogic* myTLLogic;
 
    void patchIfCrossingsAdded();
 
    std::set<NBEdge*> myShifted;
 
    bool myReconstructAddedConnections;
    bool myReconstructRemovedConnections;
    bool myPhasesLoaded;
 
    void collectEdgeVectors(EdgeVector& fromEdges, EdgeVector& toEdges, std::vector<int>& fromLanes) const;
 
    void reconstructLogic();
 
    bool hasValidIndices() const;
 
private:
    class connection_equal {
    public:
        connection_equal(const NBConnection& c) : myC(c) {}
 
        bool operator()(const NBConnection& c) const {
            return c.getFrom() == myC.getFrom() && c.getTo() == myC.getTo() &&
                   c.getFromLane() == myC.getFromLane() && c.getToLane() == myC.getToLane();
        }
    private:
        const NBConnection& myC;
    };
 
};