NBLoadedSUMOTLDef.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
// Copyright (C) 2011-2017 German Aerospace Center (DLR) and others.
/****************************************************************************/
//
//   This program and the accompanying materials
//   are made available under the terms of the Eclipse Public License v2.0
//   which accompanies this distribution, and is available at
//   http://www.eclipse.org/legal/epl-v20.html
//
/****************************************************************************/
// A complete traffic light logic loaded from a sumo-net. (opted to reimplement
// since NBLoadedTLDef is quite vissim specific)
/****************************************************************************/
#ifndef NBLoadedSUMOTLDef_h
#define NBLoadedSUMOTLDef_h


// ===========================================================================
// included modules
// ===========================================================================
#ifdef _MSC_VER
#include <windows_config.h>
#else
#include <config.h>
#endif

#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(NBTrafficLightDefinition* def, NBTrafficLightLogic* logic);


    ~NBLoadedSUMOTLDef();

    void setTLControllingInformation() const;

    void remapRemoved(NBEdge* removed,
                      const EdgeVector& incoming, const EdgeVector& outgoing);


    void replaceRemoved(NBEdge* removed, int removedLane,
                        NBEdge* by, int byLane);

    void shiftTLConnectionLaneIndex(NBEdge* edge, int offset);

    void addPhase(SUMOTime duration, const std::string& state, SUMOTime minDur, SUMOTime maxDur);

    void phasesLoaded() {
        myPhasesLoaded = true;
    }

    void addConnection(NBEdge* from, NBEdge* to, int fromLane, int toLane, int linkIndex, 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();

protected:
    void collectLinks();

    void collectEdges();

    NBTrafficLightLogic* myCompute(int brakingTimeSeconds);

    bool amInvalid() const;

    /* initialize myNeedsContRelation and set myNeedsContRelationReady to true */
    void initNeedsContRelation() const;

private:

    NBTrafficLightLogic* myTLLogic;

    std::set<NBNode*> myOriginalNodes;

    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();

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;
    private:
        connection_equal& operator=(const connection_equal& s);

    };

};


#endif

/****************************************************************************/