GNENet.h

Go to the documentation of this file.

/****************************************************************************/
// 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
//
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
// Copyright (C) 2001-2017 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This file is part of SUMO.
//   SUMO is free software: you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation, either version 3 of the License, or
//   (at your option) any later version.
//
/****************************************************************************/
#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"
#include "GNEDetectorE3.h"
#include "GNECalibrator.h"


// ===========================================================================
// class declarations
// ===========================================================================
class GNEApplicationWindow;
class GNEAttributeCarrier;
class GNEEdge;
class GNELane;
class GNEJunction;
class GNEUndoList;
class GNEAdditional;
class GNEBusStop;
class GNEChargingStation;
class GNEDetectorE1;
class GNEDetectorE2;
class GNEDetectorE3;
class GNEDetectorE3EntryExit;
class GNEConnection;
class GNECrossing;
class GNEShape;
class GNEPoly;
class GNEPOI;

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

    friend class GNEChange_Junction;
    friend class GNEChange_Edge;
    friend class GNEChange_Connection;

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;

    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 deletePOI(GNEPOI* POI, GNEUndoList* undoList);

    void deletePolygon(GNEPoly* polygon, GNEUndoList* undoList);

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

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

    bool revertLaneRestriction(GNELane* lane, GNEUndoList* undoList);

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

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

    void deleteGeometryOrEdge(GNEEdge* edge, const Position& pos, 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);

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

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

    void save(OptionsCont& oc);

    void saveAdditionals(const std::string& filename, bool volatileOptionsEnabled = false);

    void savePlain(OptionsCont& oc);

    void saveJoined(OptionsCont& oc);

    void setViewNet(GNEViewNet* viewNet);

    void refreshElement(GUIGlObject* o);

    void refreshAdditional(GNEAdditional* additional);

    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 computeJunction(GNEJunction* junction);

    void requireRecompute();

    void requiereSaveAdditionals();

    void requiereSaveShapes();

    bool netHasGNECrossings() const;

    FXApp* getApp();

    NBNetBuilder* getNetBuilder() const;

    void addExplicitTurnaround(std::string id);

    void removeExplicitTurnaround(std::string id);

    void moveSelection(const Position& moveSrc, const Position& moveDest);

    void finishMoveSelection(GNEUndoList* undoList);

    void insertAdditional(GNEAdditional* additional, bool hardFail = true);

    void deleteAdditional(GNEAdditional* additional);

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

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

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

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

    std::string getAdditionalID(SumoXMLTag type, const GNELane* lane, const double pos) const;

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

    int getNumberOfAdditionals(SumoXMLTag type = SUMO_TAG_NOTHING) const;

    const GNECalibratorRoute& getGNECalibratorRoute(const std::string& calibratorRouteID) const;

    const GNECalibratorVehicleType& getGNECalibratorVehicleType(const std::string& calibratorVehicleTypeID) const;

    const GNECalibratorFlow& getGNECalibratorFlow(const std::string& calibratorFlowID) const;

    bool routeExists(const std::string& routeID) const;

    bool vehicleTypeExists(const std::string& vehicleTypeID) const;

    bool flowExists(const std::string& flowID) 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 ignorePruning = false);

    GNEPoly* addPolygonForEditShapes(GNEJunction* junction);

    bool removePolygon(const std::string& id);

    void insertPolygonInView(GNEPoly* p);

    void removePolygonOfView(GNEPoly* p);

    void refreshPolygon(GNEPoly* p);

    std::string generatePolyID() const;

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

    void changePolygonID(GNEPoly* poly, const std::string& OldID);

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

    bool removePOI(const std::string& id);

    void insertPOIInView(GNEPOI* p);

    void removePOIOfView(GNEPOI* p);

    void refreshPOI(GNEPOI* p);

    std::string generatePOIID() const;

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

    void changePOIID(GNEPOI* POI, const std::string& OldID);

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

    int getNumberOfShapes() const;

    bool isShapeSelected(SumoXMLTag tag, const std::string& ID) const;

protected:
    SUMORTree myGrid;

    GNEViewNet* myViewNet;

    NBNetBuilder* myNetBuilder;

    typedef std::map<std::string, GNEJunction*> GNEJunctions;
    typedef std::map<std::string, GNEEdge*> GNEEdges;
    typedef std::map<std::pair<std::string, SumoXMLTag>, GNEAdditional*> GNEAdditionals;
    // @}

    GNEJunctions myJunctions;

    GNEEdges myEdges;

    GNEAdditionals myAdditionals;

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

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

    bool myNeedRecompute;

    bool myAdditionalsSaved;

    bool myShapesSaved;

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 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 keepEndpoints = false);

    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;

    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

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