GNENet.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
// Copyright (C) 2001-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
//
/****************************************************************************/
// The lop level container for GNE-network-components such as GNEEdge and
// GNEJunction.  Contains an internal instances of NBNetBuilder GNE components
// wrap netbuild-components of this underlying NBNetBuilder and supply
// visualisation and editing capabilities (adapted from GUINet)
//
// Workflow (rough draft)
//   wrap NB-components
//   do netedit stuff
//   call NBNetBuilder::buildLoaded to save results
//
/****************************************************************************/
#ifndef GNENet_h
#define GNENet_h


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

#include <string>
#include <utility>
#include <utils/gui/globjects/GLIncludes.h>
#include <netbuild/NBNetBuilder.h>
#include <utils/geom/Boundary.h>
#include <utils/geom/Position.h>
#include <foreign/rtree/SUMORTree.h>
#include <utils/gui/globjects/GUIGlObjectStorage.h>
#include <utils/gui/globjects/GUIGLObjectPopupMenu.h>
#include <utils/gui/globjects/GUIGlObject.h>
#include <utils/gui/globjects/GUIShapeContainer.h>
#include <utils/common/StringUtils.h>
#include <utils/common/RGBColor.h>
#include <utils/common/IDSupplier.h>
#include <utils/options/OptionsCont.h>
#include <utils/iodevices/OutputDevice.h>
#include "GNEChange.h"


// ===========================================================================
// class declarations
// ===========================================================================

class GNEAdditional;
class GNEApplicationWindow;
class GNEAttributeCarrier;
class GNECalibratorFlow;
class GNECalibratorRoute;
class GNECalibratorVehicleType;
class GNEConnection;
class GNECrossing;
class GNEEdge;
class GNEJunction;
class GNELane;
class GNENetElement;
class GNEPOI;
class GNEPOILane;
class GNEPoly;
class GNERerouterInterval;
class GNEShape;
class GNEUndoList;
class GNEViewNet;

// ===========================================================================
// class definitions
// ===========================================================================
class GNENet : public GUIGlObject, public ShapeContainer {

    friend class GNEAdditionalHandler;
    friend class GNEChange_Junction;
    friend class GNEChange_Edge;
    friend class GNEChange_Lane;
    friend class GNEChange_Connection;
    friend class GNEChange_Shape;
    friend class GNEChange_CalibratorItem;
    friend class GNEChange_Additional;

public:
    static const RGBColor selectionColor;

    static const RGBColor selectedLaneColor;

    static const RGBColor selectedConnectionColor;

    static const RGBColor selectedAdditionalColor;

    GNENet(NBNetBuilder* netBuilder);

    ~GNENet();


    GUIGLObjectPopupMenu* getPopUpMenu(GUIMainWindow& app, GUISUMOAbstractView& parent);

    GUIParameterTableWindow* getParameterWindow(GUIMainWindow& app, GUISUMOAbstractView& parent);

    Boundary getCenteringBoundary() const;

    const Boundary& getZBoundary() const;

    void drawGL(const GUIVisualizationSettings& s) const;


    bool addPolygon(const std::string& id, const std::string& type, const RGBColor& color, double layer,
                    double angle, const std::string& imgFile, const PositionVector& shape, bool fill,
                    bool geo, bool ignorePruning = false);

    bool addPOI(const std::string& id, const std::string& type, const RGBColor& color, const Position& pos, bool geo,
                const std::string& lane, double posOverLane, double posLat, double layer, double angle,
                const std::string& imgFile, double width, double height, bool ignorePruning = false);

    const Boundary& getBoundary() const;

    SUMORTree& getVisualisationSpeedUp();

    const SUMORTree& getVisualisationSpeedUp() const;

    GNEJunction* createJunction(const Position& pos, GNEUndoList* undoList);

    GNEEdge* createEdge(GNEJunction* src, GNEJunction* dest, GNEEdge* tpl, GNEUndoList* undoList,
                        const std::string& suggestedName = "", bool wasSplit = false, bool allowDuplicateGeom = false);

    void deleteJunction(GNEJunction* junction, GNEUndoList* undoList);

    void deleteEdge(GNEEdge* edge, GNEUndoList* undoList);

    void replaceIncomingEdge(GNEEdge* which, GNEEdge* by, GNEUndoList* undoList);

    void deleteLane(GNELane* lane, GNEUndoList* undoList);

    void deleteConnection(GNEConnection* connection, GNEUndoList* undoList);

    void deleteCrossing(GNECrossing* crossing, GNEUndoList* undoList);

    void deleteShape(GNEShape* shape, GNEUndoList* undoList);

    void duplicateLane(GNELane* lane, GNEUndoList* undoList);

    bool restrictLane(SUMOVehicleClass vclass, GNELane* lane, GNEUndoList* undoList);

    bool addSRestrictedLane(SUMOVehicleClass vclass, GNEEdge& edge, GNEUndoList* undoList);

    bool removeRestrictedLane(SUMOVehicleClass vclass, GNEEdge& edge, GNEUndoList* undoList);

    GNEJunction* splitEdge(GNEEdge* edge, const Position& pos, GNEUndoList* undoList, GNEJunction* newJunction = 0);

    void splitEdgesBidi(const std::set<GNEEdge*>& edges, const Position& pos, GNEUndoList* undoList);

    void reverseEdge(GNEEdge* edge, GNEUndoList* undoList);

    GNEEdge* addReversedEdge(GNEEdge* edge, GNEUndoList* undoList);

    void mergeJunctions(GNEJunction* moved, GNEJunction* target, GNEUndoList* undoList);

    GNEJunction* retrieveJunction(const std::string& id, bool failHard = true);

    GNEEdge* retrieveEdge(const std::string& id, bool failHard = true);

    GNEEdge* retrieveEdge(GNEJunction* from, GNEJunction* to, bool failHard = true);

    GNEPoly* retrievePolygon(const std::string& id, bool failHard = true) const;

    GNEPOI* retrievePOI(const std::string& id, bool failHard = true) const;

    GNEPOILane* retrievePOILane(const std::string& id, bool failHard = true) const;

    GNEAttributeCarrier* retrieveAttributeCarrier(const GUIGlID id, bool failHard = true);

    std::vector<GNEAttributeCarrier*> retrieveAttributeCarriers(const std::set<GUIGlID>& ids, GUIGlObjectType type);

    std::vector<GNEEdge*> retrieveEdges(bool onlySelected = false);

    std::vector<GNELane*> retrieveLanes(bool onlySelected = false);

    GNELane* retrieveLane(const std::string& id, bool failHard = true, bool checkVolatileChange = false);

    std::vector<GNEJunction*> retrieveJunctions(bool onlySelected = false);

    std::vector<GNEShape*> retrieveShapes(SumoXMLTag shapeTag = SUMO_TAG_NOTHING, bool onlySelected = false);

    void save(OptionsCont& oc);

    void savePlain(OptionsCont& oc);

    void saveJoined(OptionsCont& oc);

    void setViewNet(GNEViewNet* viewNet);

    void refreshElement(GUIGlObject* o);

    std::string generateVaporizerID() const;

    void renameEdge(GNEEdge* edge, const std::string& newID);

    void renameJunction(GNEJunction* junction, const std::string& newID);

    void changeEdgeEndpoints(GNEEdge* edge, const std::string& newSourceID, const std::string& newDestID);

    GNEViewNet* getViewNet() const;

    NBTrafficLightLogicCont& getTLLogicCont();

    std::set<GUIGlID> getGlIDs(GUIGlObjectType type = GLO_MAX);

    void initGNEConnections();

    void computeAndUpdate(OptionsCont& oc, bool volatileOptions);

    void computeEverything(GNEApplicationWindow* window, bool force = false, bool volatileOptions = false, std::string additionalPath = "", std::string shapePath = "");

    bool joinSelectedJunctions(GNEUndoList* undoList);

    bool cleanInvalidCrossings(GNEUndoList* undoList);

    void removeSolitaryJunctions(GNEUndoList* undoList);

    void replaceJunctionByGeometry(GNEJunction* junction, GNEUndoList* undoList);

    void clearJunctionConnections(GNEJunction* junction, GNEUndoList* undoList);

    void resetJunctionConnections(GNEJunction* junction, GNEUndoList* undoList);

    void computeJunction(GNEJunction* junction);

    void requireRecompute();

    bool netHasGNECrossings() const;

    FXApp* getApp();

    NBNetBuilder* getNetBuilder() const;

    void addExplicitTurnaround(std::string id);

    void removeExplicitTurnaround(std::string id);


    GNEAdditional* retrieveAdditional(const std::string& id, bool hardFail = true) const;

    std::vector<GNEAdditional*> retrieveAdditionals(bool onlySelected = false);

    GNEAdditional* getAdditional(SumoXMLTag type, const std::string& id) const;

    std::vector<GNEAdditional*> getAdditionals(SumoXMLTag type = SUMO_TAG_NOTHING) const;

    /* @brief retrieve Rerouter Interval
     * @param rerouterIntervalID ID of rerouter interval
     * @param rerouter interval if was found, or NULL in other case
     */
    GNERerouterInterval* getRerouterInterval(const std::string& rerouterIntervalID) const;

    int getNumberOfAdditionals(SumoXMLTag type = SUMO_TAG_NOTHING) const;

    void updateAdditionalID(const std::string& oldID, GNEAdditional* additional);

    void requiereSaveAdditionals();

    void saveAdditionals(const std::string& filename);



    GNECalibratorRoute* retrieveCalibratorRoute(const std::string& id, bool hardFail = true) const;

    GNECalibratorVehicleType* retrieveCalibratorVehicleType(const std::string& id, bool hardFail = true) const;

    GNECalibratorFlow* retrieveCalibratorFlow(const std::string& id, bool hardFail = true) const;

    std::string generateCalibratorRouteID() const;

    std::string generateCalibratorVehicleTypeID() const;

    std::string generateCalibratorFlowID() const;

    void changeCalibratorRouteID(GNECalibratorRoute* route, const std::string& oldID);

    void changeCalibratorVehicleTypeID(GNECalibratorVehicleType* vehicleType, const std::string& oldID);

    void changeCalibratorFlowID(GNECalibratorFlow* flow, const std::string& oldID);



    GNEPoly* addPolygonForEditShapes(GNENetElement* netElement, const PositionVector& shape, bool fill);

    void removePolygonForEditShapes(GNEPoly* polygon);

    std::string generateShapeID(SumoXMLTag shapeTag) const;

    void changeShapeID(GNEShape* s, const std::string& OldID);

    void requiereSaveShapes();

    void saveShapes(const std::string& filename);

    int getNumberOfShapes() const;

protected:
    SUMORTree myGrid;

    GNEViewNet* myViewNet;

    NBNetBuilder* myNetBuilder;

    std::map<std::string, GNEJunction*> myJunctions;

    std::map<std::string, GNEEdge*> myEdges;

    std::map<std::pair<std::string, SumoXMLTag>, GNEAdditional*> myAdditionals;

    std::map<std::string, GNECalibratorRoute*> myCalibratorRoutes;

    std::map<std::string, GNECalibratorVehicleType*> myCalibratorVehicleTypes;

    std::map<std::string, GNECalibratorFlow*> myCalibratorFlows;

    // @{
    IDSupplier myEdgeIDSupplier;
    IDSupplier myJunctionIDSupplier;
    // @}

    std::set<std::string> myExplicitTurnarounds;

    bool myNeedRecompute;

    bool myAdditionalsSaved;

    bool myShapesSaved;


    void insertAdditional(GNEAdditional* additional);

    void deleteAdditional(GNEAdditional* additional);



    void insertCalibratorRoute(GNECalibratorRoute* route);

    void deleteCalibratorRoute(GNECalibratorRoute* route);

    void insertCalibratorFlow(GNECalibratorFlow* flow);

    void deleteCalibratorFlow(GNECalibratorFlow* flow);

    void insertCalibratorVehicleType(GNECalibratorVehicleType* vehicleType);

    void deleteCalibratorVehicleType(GNECalibratorVehicleType* vehicleType);


private:
    void initJunctionsAndEdges();

    void insertJunction(GNEJunction* junction);

    void insertEdge(GNEEdge* edge);

    GNEJunction* registerJunction(GNEJunction* junction);

    GNEEdge* registerEdge(GNEEdge* edge);

    void deleteSingleJunction(GNEJunction* junction);

    void deleteSingleEdge(GNEEdge* edge);

    void insertShape(GNEShape* shape);

    void removeShape(GNEShape* shape);

    void update();

    void reserveEdgeID(const std::string& id);

    void reserveJunctionID(const std::string& id);

    /* @brief helper function for changing the endpoints of a junction
     * @param[in] keepEndpoints Whether to keep the original edge endpoints (influences junction shape)
     */
    void remapEdge(GNEEdge* oldEdge, GNEJunction* from, GNEJunction* to, GNEUndoList* undoList, bool preserveShapeStart, bool preserveShapeEnd);

    bool checkJunctionPosition(const Position& pos);

    static void replaceInListAttribute(GNEAttributeCarrier* ac, SumoXMLAttr key, const std::string& which, const std::string& by, GNEUndoList* undoList);

    Boundary myZBoundary;

    static const double Z_INITIALIZED;

    std::map<std::string, int> myEdgesAndNumberOfLanes;

    class GNEChange_ReplaceEdgeInTLS : public GNEChange {
        FXDECLARE_ABSTRACT(GNEChange_ReplaceEdgeInTLS)

    public:
        GNEChange_ReplaceEdgeInTLS(NBTrafficLightLogicCont& tllcont, NBEdge* replaced, NBEdge* by) :
            GNEChange(0, true),
            myTllcont(tllcont), myReplaced(replaced), myBy(by) { }

        ~GNEChange_ReplaceEdgeInTLS() {};

        FXString undoName() const {
            return "Redo replace in TLS";
        }

        FXString redoName() const {
            return "Undo replace in TLS";
        }

        void undo() {
            myTllcont.replaceRemoved(myBy, -1, myReplaced, -1);
        }

        void redo() {
            myTllcont.replaceRemoved(myReplaced, -1, myBy, -1);
        }

        bool trueChange() {
            return myReplaced != myBy;
        }

    private:
        NBTrafficLightLogicCont& myTllcont;

        NBEdge* myReplaced;

        NBEdge* myBy;
    };

};

#endif

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