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

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

    Boundary getCenteringBoundary() const override;

    void expandBoundary(const Boundary& newBoundary);

    const Boundary& getZBoundary() const;

    void addZValueInBoundary(const double z);

    void drawGL(const GUIVisualizationSettings& s) const override;


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