GNENet.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
// Copyright (C) 2001-2018 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
// SPDX-License-Identifier: EPL-2.0
/****************************************************************************/
// 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
// ===========================================================================
#include <config.h>

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


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

class GNEAdditional;
class GNEApplicationWindow;
class GNEAttributeCarrier;
class GNEConnection;
class GNECrossing;
class GNEEdge;
class GNEJunction;
class GNELane;
class GNENetElement;
class GNEPOI;
class GNEPoly;
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, bool relativePath, 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, bool relativePath, 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,
                        bool recomputeConnections = true);

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

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

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

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

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

    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;

    GNEConnection* retrieveConnection(const std::string& id, bool failHard = true) const;

    std::vector<GNEConnection*> retrieveConnections(bool onlySelected = false) const;

    GNECrossing* retrieveCrossing(const std::string& id, bool failHard = true) const;

    std::vector<GNECrossing*> retrieveCrossings(bool onlySelected = false) const;

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

    std::vector<GNEAttributeCarrier*> retrieveAttributeCarriers(SumoXMLTag type = SUMO_TAG_NOTHING);

    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, bool onlySelected = false);

    std::vector<GNEShape*> retrieveShapes(bool onlySelected = false);

    void requiereSaveNet(bool value);

    bool isNetSaved() const;

    void save(OptionsCont& oc);

    void savePlain(OptionsCont& oc);

    void saveJoined(OptionsCont& oc);

    void setViewNet(GNEViewNet* viewNet);

    void addGLObjectIntoGrid(GUIGlObject* o);

    void removeGLObjectFromGrid(GUIGlObject* o);

    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;

    std::vector<GNEAttributeCarrier*> getSelectedAttributeCarriers();

    NBTrafficLightLogicCont& getTLLogicCont();

    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 splitJunction(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(SumoXMLTag type, const std::string& id, bool hardFail = true) const;

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

    const std::map<std::string, GNEAdditional*>& getAdditionalByType(SumoXMLTag type) const;

    int getNumberOfAdditionals(SumoXMLTag type = SUMO_TAG_NOTHING) const;

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

    void requiereSaveAdditionals(bool value);

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

    std::string generateAdditionalID(SumoXMLTag type) const;



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

    void removePolygonForEditShapes(GNEPoly* polygon);

    std::string generateShapeID(SumoXMLTag shapeTag) const;

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

    void requiereSaveShapes(bool value);

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

    int getNumberOfShapes() const;

    void requiereSaveTLSPrograms();

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

    int getNumberOfTLSPrograms() const;

protected:
    struct AttributeCarriers {
        std::map<std::string, GNEJunction*> junctions;

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

        std::map<SumoXMLTag, std::map<std::string, GNEAdditional*> > additionals;
    };

    SUMORTree myGrid;

    GNEViewNet* myViewNet;

    NBNetBuilder* myNetBuilder;

    AttributeCarriers myAttributeCarriers;

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

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

    bool myNeedRecompute;

    bool myNetSaved;

    bool myAdditionalsSaved;

    bool myShapesSaved;

    bool myTLSProgramsSaved;


    void insertAdditional(GNEAdditional* additional);

    void deleteAdditional(GNEAdditional* additional);


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

    bool checkJunctionPosition(const Position& pos);

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

    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;

    bool myAllowUndoShapes;

    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

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