GNENet.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2025 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// 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)
//
// WorkrouteFlow (rough draft)
//   wrap NB-components
//   do netedit stuff
//   call NBNetBuilder::buildLoaded to save results
//
/****************************************************************************/
#pragma once
#include <config.h>
 
#include "GNENetHelper.h"
#include "GNEPathManager.h"
 
// ===========================================================================
// class definitions
// ===========================================================================
class GNENet : public GUIGlObject {
 
public:
    GNENet(NBNetBuilder* netBuilder, const GNETagPropertiesDatabase* tagPropertiesDatabase);
 
    ~GNENet();
 
    const GNETagPropertiesDatabase* getTagPropertiesDatabase() const;
 
    GNENetHelper::AttributeCarriers* getAttributeCarriers() const;
 
    GNENetHelper::ACTemplate* getACTemplates() const;
 
    GNENetHelper::SavingFilesHandler* getSavingFilesHandler() const;
 
    GNENetHelper::SavingStatus* getSavingStatus() const;
 
    GNEPathManager* getNetworkPathManager();
 
    GNEPathManager* getDemandPathManager();
 
    GNEPathManager* getDataPathManager();
 
 
    GUIGLObjectPopupMenu* getPopUpMenu(GUIMainWindow& app, GUISUMOAbstractView& parent);
 
    GUIParameterTableWindow* getParameterWindow(GUIMainWindow& app, GUISUMOAbstractView& parent);
 
    Boundary getCenteringBoundary() const;
 
    void expandBoundary(const Boundary& newBoundary);
 
    const Boundary& getZBoundary() const;
 
    void addZValueInBoundary(const double z);
 
    void drawGL(const GUIVisualizationSettings& s) const;
 
 
    const Boundary& getBoundary() const;
 
    SUMORTree& getGrid();
 
    const std::map<std::string, int>& getEdgesAndNumberOfLanes() const;
 
    GNEJunction* createJunction(const Position& pos, GNEUndoList* undoList);
 
    GNEEdge* createEdge(GNEJunction* src, GNEJunction* dest, GNEEdge* edgeTemplate, GNEUndoList* undoList,
                        const std::string& suggestedName = "", bool wasSplit = false, bool allowDuplicateGeom = false,
                        bool recomputeConnections = true);
 
    void deleteNetworkElement(GNENetworkElement* networkElement, GNEUndoList* undoList);
 
    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 deleteAdditional(GNEAdditional* additional, GNEUndoList* undoList);
 
    void deleteTAZSourceSink(GNETAZSourceSink* TAZSourceSink, GNEUndoList* undoList);
 
    void deleteDemandElement(GNEDemandElement* demandElement, GNEUndoList* undoList);
 
    void deleteDataSet(GNEDataSet* dataSet, GNEUndoList* undoList);
 
    void deleteDataInterval(GNEDataInterval* dataInterval, GNEUndoList* undoList);
 
    void deleteGenericData(GNEGenericData* genericData, GNEUndoList* undoList);
 
    void deleteMeanData(GNEMeanData* meanData, GNEUndoList* undoList);
 
    void duplicateLane(GNELane* lane, GNEUndoList* undoList, bool recomputeConnections);
 
    bool restrictLane(SUMOVehicleClass vclass, GNELane* lane, GNEUndoList* undoList);
 
    bool addRestrictedLane(SUMOVehicleClass vclass, GNEEdge* edge, int index, GNEUndoList* undoList);
 
    bool addGreenVergeLane(GNEEdge* edge, int index, GNEUndoList* undoList);
 
    bool removeRestrictedLane(SUMOVehicleClass vclass, GNEEdge* edge, GNEUndoList* undoList);
 
    std::pair<GNEJunction*, GNEEdge*> splitEdge(GNEEdge* edge, const Position& pos, GNEUndoList* undoList, GNEJunction* newJunction = 0);
 
    void splitEdgesBidi(GNEEdge* edge, GNEEdge* oppositeEdge, const Position& pos, GNEUndoList* undoList);
 
    void reverseEdge(GNEEdge* edge, GNEUndoList* undoList);
 
    GNEEdge* addReversedEdge(GNEEdge* edge, const bool disconnected, GNEUndoList* undoList);
 
    void mergeJunctions(GNEJunction* moved, const GNEJunction* target, GNEUndoList* undoList);
 
    void selectRoundabout(GNEJunction* junction, GNEUndoList* undoList);
 
    void createRoundabout(GNEJunction* junction, GNEUndoList* undoList);
 
    void saveNetwork();
 
    void savePlain(const std::string& prefix);
 
    void saveJoined(const std::string& filename);
 
    void setViewNet(GNEViewNet* viewNet);
 
    void addGLObjectIntoGrid(GNEAttributeCarrier* AC);
 
    void removeGLObjectFromGrid(GNEAttributeCarrier* AC);
 
    void changeEdgeEndpoints(GNEEdge* edge, const std::string& newSourceID, const std::string& newDestID);
 
    GNEViewNet* getViewNet() const;
 
    NBTrafficLightLogicCont& getTLLogicCont();
 
    NBEdgeCont& getEdgeCont();
 
    void initGNEConnections();
 
    void computeAndUpdate(OptionsCont& neteditOptions, bool volatileOptions);
 
    void computeNetwork(GNEApplicationWindow* window, bool force = false, bool volatileOptions = false);
 
    void computeDemandElements(GNEApplicationWindow* window);
 
    void computeDataElements(GNEApplicationWindow* window);
 
    bool joinSelectedJunctions(GNEUndoList* undoList);
 
    bool cleanInvalidCrossings(GNEUndoList* undoList);
 
    void removeSolitaryJunctions(GNEUndoList* undoList);
 
    void cleanUnusedRoutes(GNEUndoList* undoList);
 
    void joinRoutes(GNEUndoList* undoList);
 
    void adjustPersonPlans(GNEUndoList* undoList);
 
    void cleanInvalidDemandElements(GNEUndoList* undoList);
 
    void replaceJunctionByGeometry(GNEJunction* junction, GNEUndoList* undoList);
 
    void splitJunction(GNEJunction* junction, bool reconnect, GNEUndoList* undoList);
 
    void clearJunctionConnections(GNEJunction* junction, GNEUndoList* undoList);
 
    void resetJunctionConnections(GNEJunction* junction, GNEUndoList* undoList);
 
    void clearAdditionalElements(GNEUndoList* undoList);
 
    void clearDemandElements(GNEUndoList* undoList);
 
    void clearDataElements(GNEUndoList* undoList);
 
    void clearMeanDataElements(GNEUndoList* undoList);
 
    void computeJunction(GNEJunction* junction);
 
    void requireRecompute();
 
    bool isNetRecomputed() const;
 
    FXApp* getApp();
 
    NBNetBuilder* getNetBuilder() const;
 
    void addExplicitTurnaround(std::string id);
 
    void removeExplicitTurnaround(std::string id);
 
    bool saveAdditionals();
 
    bool saveJuPedSimElements(const std::unordered_set<const GNEAttributeCarrier*>& ACs, const std::string& file);
 
    bool saveDemandElements();
 
    bool saveDataElements();
 
    double getDataSetIntervalMinimumBegin() const;
 
    double getDataSetIntervalMaximumEnd() const;
 
    bool saveMeanDatas();
 
    void saveTLSPrograms(const std::string& filename);
 
    int getNumberOfTLSPrograms() const;
 
    void saveEdgeTypes(const std::string& filename);
 
    void enableUpdateGeometry();
 
    void disableUpdateGeometry();
 
    bool isUpdateGeometryEnabled() const;
 
 
    void enableUpdateData();
 
    void disableUpdateData();
 
    bool isUpdateDataEnabled() const;
 
 
    unsigned int& getJunctionIDCounter();
 
    unsigned int& getEdgeIDCounter();
 
    static const std::map<SumoXMLAttr, std::string> EMPTY_HEADER;
 
protected:
    SUMORTree myGrid;
 
    NBNetBuilder* myNetBuilder;
 
    GNEViewNet* myViewNet = nullptr;
 
    const GNETagPropertiesDatabase* myTagPropertiesDatabase = nullptr;
 
    GNENetHelper::AttributeCarriers* myAttributeCarriers = nullptr;
 
    GNENetHelper::ACTemplate* myACTemplates = nullptr;
 
    GNENetHelper::SavingFilesHandler* mySavingFilesHandler = nullptr;
 
    GNENetHelper::SavingStatus* mySavingStatus = nullptr;
 
    GNEPathManager* myNetworkPathManager = nullptr;
 
    GNEPathManager* myDemandPathManager = nullptr;
 
    GNEPathManager* myDataPathManager = nullptr;
 
    // @{
    unsigned int myJunctionIDCounter = 0;
    unsigned int myEdgeIDCounter = 0;
    // @}
 
    std::set<std::string> myExplicitTurnarounds;
 
    bool myNeedRecompute = true;
 
    bool myUpdateGeometryEnabled = true;
 
    bool myUpdateDataEnabled = true;
 
private:
    void initJunctionsAndEdges();
 
    bool checkJunctionPosition(const Position& pos);
 
    void saveAdditionalsConfirmed();
 
    void saveDemandElementsConfirmed();
 
    void saveDataElementsConfirmed();
 
    void saveMeanDatasConfirmed();
 
    void writeAdditionalByType(OutputDevice& device, const std::unordered_set<const GNEAttributeCarrier*>& ACs,
                               const std::vector<SumoXMLTag> tags) const;
 
    void writeDemandByType(OutputDevice& device, const std::unordered_set<const GNEAttributeCarrier*>& ACs, SumoXMLTag tag) const;
 
    void writeRouteDistributions(OutputDevice& device, const std::unordered_set<const GNEAttributeCarrier*>& ACs) const;
 
    void writeRoutes(OutputDevice& device, const std::unordered_set<const GNEAttributeCarrier*>& ACs, const bool additionalFile) const;
 
    void writeVTypeDistributions(OutputDevice& device, const std::unordered_set<const GNEAttributeCarrier*>& ACs) const;
 
    void writeVTypes(OutputDevice& device, const std::unordered_set<const GNEAttributeCarrier*>& ACs, const bool additionalFile) const;
 
    void writeMeanDatas(OutputDevice& device, const std::unordered_set<const GNEAttributeCarrier*>& ACs, SumoXMLTag tag) const;
 
    bool writeVTypeComment(OutputDevice& device, const std::unordered_set<const GNEAttributeCarrier*>& ACs, const bool additionalFile) const;
 
    bool writeRouteComment(OutputDevice& device, const std::unordered_set<const GNEAttributeCarrier*>& ACs, const bool additionalFile) const;
 
    bool writeRouteProbeComment(OutputDevice& device, const std::unordered_set<const GNEAttributeCarrier*>& ACs) const;
 
    bool writeCalibratorComment(OutputDevice& device, const std::unordered_set<const GNEAttributeCarrier*>& ACs) const;
 
    bool writeStoppingPlaceComment(OutputDevice& device, const std::unordered_set<const GNEAttributeCarrier*>& ACs) const;
 
    bool writeDetectorComment(OutputDevice& device, const std::unordered_set<const GNEAttributeCarrier*>& ACs) const;
 
    bool writeOtherAdditionalsComment(OutputDevice& device, const std::unordered_set<const GNEAttributeCarrier*>& ACs) const;
 
    bool writeShapesComment(OutputDevice& device, const std::unordered_set<const GNEAttributeCarrier*>& ACs) const;
 
    bool writeJuPedSimComment(OutputDevice& device, const std::unordered_set<const GNEAttributeCarrier*>& ACs) const;
 
    bool writeTAZComment(OutputDevice& device, const std::unordered_set<const GNEAttributeCarrier*>& ACs) const;
 
    bool writeWireComment(OutputDevice& device, const std::unordered_set<const GNEAttributeCarrier*>& ACs) const;
 
    bool writeMeanDataEdgeComment(OutputDevice& device) const;
 
    bool writeMeanDataLaneComment(OutputDevice& device) const;
 
    static void replaceInListAttribute(GNEAttributeCarrier* ac, SumoXMLAttr key, const std::string& which, const std::string& by, GNEUndoList* undoList);
 
    Boundary myZBoundary;
 
    std::map<std::string, int> myEdgesAndNumberOfLanes;
 
    static const double Z_INITIALIZED;
 
    GNENet() = delete;
 
    GNENet(const GNENet&) = delete;
 
    GNENet& operator=(const GNENet&) = delete;
};
class GNENet : public GUIGlObject {…};