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 "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 definitions
// ===========================================================================
class GNENet : public GUIGlObject {

    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;

    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 deleteLane(GNELane* lane, GNEUndoList* undoList);

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

    void deleteCrossing(GNECrossing* crossing, 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);

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

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

    /* @brief get ids of currently active objects
     * param[in] type If type != GLO_MAX, get active ids of that type, otherwise get all active ids
     */
    std::set<GUIGlID> getGlIDs(GUIGlObjectType type = GLO_MAX);

    void initGNEConnections();

    void computeAndUpdate(OptionsCont& oc);

    bool isAdditionalsSaved() const;

    void setAdditionalSaved(bool value);

    /* @brief trigger full netbuild computation
     * param[in] window The window to inform about delay
     * param[in] force Whether to force recomputation even if not needed
     */
    void computeEverything(GNEApplicationWindow* window, bool force = false);

    /* @brief join selected junctions
     * @note difference to mergeJunctions:
     *  - can join more than 2
     *  - connected edges will keep their geometry (big junction shape is created)
     *  - no hirarchy: if any junction has a traffic light than the resuling junction will
     */
    void joinSelectedJunctions(GNEUndoList* undoList);

    void removeSolitaryJunctions(GNEUndoList* undoList);

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

    /* @brief trigger recomputation of junction shape and logic
     * param[in] window The window to inform about delay
     */
    void computeJunction(GNEJunction* junction);

    void requireRecompute();

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

    ShapeContainer& getShapeContainer();

    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;

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;
    // @}

    GUIShapeContainer myShapeContainer;

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

    bool myNeedRecompute;

    bool myAdditionalsSaved;

private:
    void initDetectors();

    void initTLMap();

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

    Boundary myZBoundary;

    static const double Z_INITIALIZED;
};

#endif

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