GNENetHelper.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
/****************************************************************************/
// Helper for GNENet
//
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <foreign/rtree/SUMORTree.h>
#include <netbuild/NBEdge.h>
#include <netbuild/NBTrafficLightLogicCont.h>
#include <netbuild/NBVehicle.h>
#include <netedit/changes/GNEChange.h>
#include <netedit/dialogs/GNEDialog.h>
#include <utils/common/IDSupplier.h>
#include <utils/common/SUMOVehicleClass.h>
#include <utils/foxtools/fxheader.h>
#include <utils/geom/Boundary.h>
#include <utils/geom/PositionVector.h>
#include <utils/geom/Triangle.h>
#include <utils/gui/globjects/GUIGlObject.h>
#include <utils/gui/globjects/GUIShapeContainer.h>
#include <utils/gui/settings/GUIVisualizationSettings.h>
#include <utils/router/SUMOAbstractRouter.h>
#include <utils/xml/SUMOXMLDefinitions.h>
 
// ===========================================================================
// class declarations
// ===========================================================================
 
class GNEAdditional;
class GNEApplicationWindow;
class GNEAttributeCarrier;
class GNEConnection;
class GNECrossing;
class GNEDataInterval;
class GNEDataSet;
class GNEDemandElement;
class GNEEdge;
class GNEEdgeType;
class GNEJunction;
class GNELane;
class GNELaneType;
class GNEMeanData;
class GNENet;
class GNENetworkElement;
class GNEPOI;
class GNEPoly;
class GNEUndoList;
class GNEViewNet;
class GNEWalkingArea;
class NBNetBuilder;
 
// ===========================================================================
// class definitions
// ===========================================================================
 
struct GNENetHelper {
 
    class AttributeCarriers {
 
        friend class GNEAdditionalHandler;
        friend class GNERouteHandler;
        friend class GNEDataHandler;
        friend class GNEMeanDataHandler;
        friend class GNEJunction;
        friend class GNEEdge;
        friend class GNEDataSet;
        friend class GNEDataInterval;
        friend class GNEChange_Junction;
        friend class GNEChange_EdgeType;
        friend class GNEChange_Edge;
        friend class GNEChange_TAZSourceSink;
        friend class GNEChange_Additional;
        friend class GNEChange_Shape;
        friend class GNEChange_TAZElement;
        friend class GNEChange_DemandElement;
        friend class GNEChange_DataSet;
        friend class GNEChange_DataInterval;
        friend class GNEChange_GenericData;
        friend class GNEChange_MeanData;
        friend class GNETLSEditorFrame;
 
    public:
        AttributeCarriers(GNENet* net);
 
        ~AttributeCarriers();
 
        void remapJunctionAndEdgeIds();
 
        bool isNetworkElementAroundTriangle(GNEAttributeCarrier* AC, const Triangle& triangle) const;
 
        int getNumberOfNetworkElements() const;
 
        int getNumberOfDemandElements() const;
 
        int getNumberOfDataElements() const;
 
 
 
        GNEAttributeCarrier* retrieveAttributeCarrier(const GUIGlID id, bool hardFail = true) const;
 
        std::vector<GNEAttributeCarrier*> retrieveAttributeCarriers(SumoXMLTag tag = SUMO_TAG_NOTHING);
 
        std::vector<GNEAttributeCarrier*> retrieveAttributeCarriers(Supermode supermode, const bool onlySelected);
 
        std::vector<GNEAttributeCarrier*> getSelectedAttributeCarriers(const bool ignoreCurrentSupermode);
 
 
 
        GNEJunction* retrieveJunction(const std::string& id, bool hardFail = true) const;
 
        const std::map<std::string, GNEJunction*>& getJunctions() const;
 
        std::vector<GNEJunction*> getSelectedJunctions() const;
 
        GNEJunction* registerJunction(GNEJunction* junction);
 
        void clearJunctions();
 
        void addPrefixToJunctions(const std::string& prefix);
 
        void updateJunctionID(GNEJunction* junction, const std::string& newID);
 
        int getNumberOfSelectedJunctions() const;
 
 
 
        GNECrossing* retrieveCrossing(const GUIGlObject* glObject, bool hardFail = true) const;
 
        const std::unordered_map<const GUIGlObject*, GNECrossing*>& getCrossings() const;
 
        std::vector<GNECrossing*> getSelectedCrossings() const;
 
        int getNumberOfSelectedCrossings() const;
 
 
 
        GNEWalkingArea* retrieveWalkingArea(const GUIGlObject* glObject, bool hardFail = true) const;
 
        const std::unordered_map<const GUIGlObject*, GNEWalkingArea*>& getWalkingAreas() const;
 
        std::vector<GNEWalkingArea*> getSelectedWalkingAreas() const;
 
        int getNumberOfSelectedWalkingAreas() const;
 
 
 
        GNEEdgeType* retrieveEdgeType(const std::string& id, bool hardFail = true) const;
 
        GNEEdgeType* registerEdgeType(GNEEdgeType* edgeType);
 
        const std::map<std::string, GNEEdgeType*>& getEdgeTypes() const;
 
        void clearEdgeTypes();
 
        void updateEdgeTypeID(GNEEdgeType* edgeType, const std::string& newID);
 
        std::string generateEdgeTypeID() const;
 
 
 
        GNEEdge* retrieveEdge(const std::string& id, bool hardFail = true) const;
 
        std::vector<GNEEdge*> retrieveEdges(GNEJunction* from, GNEJunction* to) const;
 
        const std::map<std::string, GNEEdge*>& getEdges() const;
 
        std::vector<GNEEdge*> getSelectedEdges() const;
 
        GNEEdge* registerEdge(GNEEdge* edge);
 
        void clearEdges();
 
        void addPrefixToEdges(const std::string& prefix);
 
        std::string generateEdgeID() const;
 
        void updateEdgeID(GNEEdge* edge, const std::string& newID);
 
        int getNumberOfSelectedEdges() const;
 
 
 
        GNELane* retrieveLane(const std::string& id, bool hardFail = true, bool checkVolatileChange = false) const;
 
        GNELane* retrieveLane(const GUIGlObject* glObject, bool hardFail = true) const;
 
        const std::unordered_map<const GUIGlObject*, GNELane*>& getLanes() const;
 
        std::vector<GNELane*> getSelectedLanes() const;
 
        int getNumberOfSelectedLanes() const;
 
 
 
        GNEConnection* retrieveConnection(const std::string& id, bool hardFail = true) const;
 
        GNEConnection* retrieveConnection(const GUIGlObject* glObject, bool hardFail = true) const;
 
        const std::unordered_map<const GUIGlObject*, GNEConnection*>& getConnections() const;
 
        std::vector<GNEConnection*> getSelectedConnections() const;
 
        int getNumberOfSelectedConnections() const;
 
 
 
        GNEInternalLane* retrieveInternalLane(const GUIGlObject* glObject, bool hardFail = true) const;
 
 
 
        GNEAdditional* retrieveAdditional(SumoXMLTag type, const std::string& id, bool hardFail = true) const;
 
        GNEAdditional* retrieveAdditionals(const std::vector<SumoXMLTag> types, const std::string& id, bool hardFail = true) const;
 
        GNEAdditional* retrieveAdditional(const GUIGlObject* glObject, bool hardFail = true) const;
 
        GNEAdditional* retrieveRerouterInterval(const std::string& rerouterID, const SUMOTime begin, const SUMOTime end) const;
 
        const std::unordered_map<SumoXMLTag, std::unordered_map<const GUIGlObject*, GNEAdditional*>, std::hash<int> >& getAdditionals() const;
 
        std::vector<GNEAdditional*> getSelectedAdditionals() const;
 
        std::vector<GNEAdditional*> getSelectedShapes() const;
 
        int getNumberOfAdditionals() const;
 
        void clearAdditionals();
 
        void updateAdditionalID(GNEAdditional* additional, const std::string& newID);
 
        std::string generateAdditionalID(SumoXMLTag type) const;
 
        int getNumberOfSelectedAdditionals() const;
 
        int getNumberOfSelectedPureAdditionals() const;
 
        int getNumberOfSelectedPolygons() const;
 
        int getNumberOfSelectedJpsWalkableAreas() const;
 
        int getNumberOfSelectedJpsObstacles() const;
 
        int getNumberOfSelectedPOIs() const;
 
        int getNumberOfSelectedTAZs() const;
 
        int getNumberOfSelectedWires() const;
 
        std::vector<std::string> getPOIParamKeys() const;
 
 
        GNETAZSourceSink* retrieveTAZSourceSink(const GNEAttributeCarrier* sourceSink, bool hardFail = true) const;
 
        const std::unordered_map<SumoXMLTag, std::unordered_map<const GNEAttributeCarrier*, GNETAZSourceSink*>, std::hash<int> >& getTAZSourceSinks() const;
 
        int getNumberOfTAZSourceSinks() const;
 
        void clearTAZSourceSinks();
 
 
 
        GNEDemandElement* retrieveDemandElement(SumoXMLTag type, const std::string& id, bool hardFail = true) const;
 
        GNEDemandElement* retrieveDemandElements(const std::vector<SumoXMLTag> types, const std::string& id, bool hardFail = true) const;
 
        GNEDemandElement* retrieveDemandElement(const GUIGlObject* glObject, bool hardFail = true) const;
 
        std::vector<GNEDemandElement*> getSelectedDemandElements() const;
 
        const std::unordered_map<SumoXMLTag, std::unordered_map<const GUIGlObject*, GNEDemandElement*>, std::hash<int> >& getDemandElements() const;
 
        std::string generateDemandElementID(SumoXMLTag tag) const;
 
        GNEDemandElement* getDefaultType() const;
 
        void clearDemandElements();
 
        void updateDemandElementID(GNEDemandElement* demandElement, const std::string& newID);
 
        void addDefaultVTypes();
 
        int getStopIndex();
 
        int getNumberOfSelectedDemandElements() const;
 
        int getNumberOfSelectedRoutes() const;
 
        int getNumberOfSelectedVehicles() const;
 
        int getNumberOfSelectedPersons() const;
 
        int getNumberOfSelectedPersonTrips() const;
 
        int getNumberOfSelectedWalks() const;
 
        int getNumberOfSelectedRides() const;
 
        int getNumberOfSelectedContainers() const;
 
        int getNumberOfSelectedTransport() const;
 
        int getNumberOfSelectedTranships() const;
 
        int getNumberOfSelectedStops() const;
 
 
 
        GNEDataSet* retrieveDataSet(const std::string& id, bool hardFail = true) const;
 
        const std::map<const std::string, GNEDataSet*>& getDataSets() const;
 
        std::string generateDataSetID() const;
 
 
 
        GNEDataInterval* retrieveDataInterval(const GNEAttributeCarrier* AC, bool hardFail = true) const;
 
        const std::unordered_map<const GNEAttributeCarrier*, GNEDataInterval*>& getDataIntervals() const;
 
 
 
        GNEGenericData* retrieveGenericData(const GUIGlObject* glObject, bool hardFail = true) const;
 
        std::vector<GNEGenericData*> getSelectedGenericDatas() const;
 
        const std::unordered_map<SumoXMLTag, std::unordered_map<const GUIGlObject*, GNEGenericData*>, std::hash<int> >& getGenericDatas() const;
 
        std::vector<GNEGenericData*> retrieveGenericDatas(const SumoXMLTag genericDataTag, const double begin, const double end);
 
        int getNumberOfGenericDatas() const;
 
        int getNumberOfSelectedEdgeDatas() const;
 
        int getNumberOfSelectedEdgeRelDatas() const;
 
        int getNumberOfSelectedEdgeTAZRel() const;
 
        std::set<std::string> retrieveGenericDataParameters(const std::string& genericDataTag, const double begin, const double end) const;
 
        std::set<std::string> retrieveGenericDataParameters(const std::string& dataSetID, const std::string& genericDataTag,
                const std::string& beginStr, const std::string& endStr) const;
 
 
 
        GNEMeanData* retrieveMeanData(SumoXMLTag type, const std::string& id, bool hardFail = true) const;
 
        const std::unordered_map<SumoXMLTag, std::map<const std::string, GNEMeanData*>, std::hash<int> >& getMeanDatas() const;
 
        int getNumberOfMeanDatas() const;
 
        void clearMeanDatas();
 
        void updateMeanDataID(GNEMeanData* meanData, const std::string& newID);
 
        std::string generateMeanDataID(SumoXMLTag type) const;
 
 
    protected:
 
        void insertJunction(GNEJunction* junction);
 
        void deleteSingleJunction(GNEJunction* junction);
 
 
 
        void insertEdgeType(GNEEdgeType* edgeType);
 
        void deleteEdgeType(GNEEdgeType* edgeType);
 
 
        void insertEdge(GNEEdge* edge);
 
        void deleteSingleEdge(GNEEdge* edge);
 
 
 
        void insertLane(GNELane* lane);
 
        void deleteLane(GNELane* lane);
 
 
 
        void insertCrossing(GNECrossing* crossing);
 
        void deleteCrossing(GNECrossing* crossing);
 
 
 
        void insertWalkingArea(GNEWalkingArea* walkingArea);
 
        void deleteWalkingArea(GNEWalkingArea* walkingArea);
 
 
 
        void insertConnection(GNEConnection* connection);
 
        void deleteConnection(GNEConnection* connection);
 
 
 
        void insertInternalLane(GNEInternalLane* internalLane);
 
        void deleteInternalLane(GNEInternalLane* internalLane);
 
 
 
        void insertAdditional(GNEAdditional* additional);
 
        void deleteAdditional(GNEAdditional* additional);
 
 
 
        void insertTAZSourceSink(GNETAZSourceSink* sourceSink);
 
        void deleteTAZSourceSink(GNETAZSourceSink* sourceSink);
 
 
 
        void insertDemandElement(GNEDemandElement* demandElement);
 
        void deleteDemandElement(GNEDemandElement* demandElement, const bool updateFrames);
 
 
 
        void insertDataSet(GNEDataSet* dataSet);
 
        void deleteDataSet(GNEDataSet* dataSet);
 
 
 
        void insertDataInterval(const GNEAttributeCarrier* AC, GNEDataInterval* dataInterval);
 
        void deleteDataInterval(GNEDataInterval* dataInterval);
 
 
 
        void insertGenericData(GNEGenericData* genericData);
 
        void deleteGenericData(GNEGenericData* genericData);
 
 
 
        void insertMeanData(GNEMeanData* meanData);
 
        void deleteMeanData(GNEMeanData* meanData);
 
 
        void updateDemandElementFrames(const GNETagProperties* tagProperty);
 
        void retrieveAttributeCarriersRecursively(const GNETagProperties* tag, std::vector<GNEAttributeCarrier*>& ACs);
 
    private:
        GNENet* myNet;
 
        int myStopIndex;
 
        int myNumberOfNetworkElements = 0;
 
        int myNumberOfDemandElements = 0;
 
        int myNumberOfDataElements = 0;
 
        int myNumberOfMeanDataElements = 0;
 
        std::map<std::string, GNEJunction*> myJunctions;
 
        std::unordered_map<const GUIGlObject*, GNECrossing*> myCrossings;
 
        std::unordered_map<const GUIGlObject*, GNEWalkingArea*> myWalkingAreas;
 
        std::map<std::string, GNEEdgeType*> myEdgeTypes;
 
        std::map<std::string, GNEEdge*> myEdges;
 
        std::unordered_map<const GUIGlObject*, GNELane*> myLanes;
 
        std::unordered_map<const GUIGlObject*, GNEConnection*> myConnections;
 
        std::unordered_map<const GUIGlObject*, GNEInternalLane*> myInternalLanes;
 
        std::unordered_map<SumoXMLTag, std::map<const std::string, GNEAdditional*>, std::hash<int> > myAdditionalIDs;
 
        std::unordered_map<SumoXMLTag, std::unordered_map<const GUIGlObject*, GNEAdditional*>, std::hash<int> > myAdditionals;
 
        std::unordered_map<SumoXMLTag, std::unordered_map<const GNEAttributeCarrier*, GNETAZSourceSink*>, std::hash<int> > myTAZSourceSinks;
 
        std::unordered_map<SumoXMLTag, std::map<const std::string, GNEDemandElement*>, std::hash<int> > myDemandElementIDs;
 
        std::unordered_map<SumoXMLTag, std::unordered_map<const GUIGlObject*, GNEDemandElement*>, std::hash<int> > myDemandElements;
 
        std::map<const std::string, GNEDataSet*> myDataSets;
 
        std::unordered_map<const GNEAttributeCarrier*, GNEDataInterval*> myDataIntervals;
 
        std::unordered_map<SumoXMLTag, std::unordered_map<const GUIGlObject*, GNEGenericData*>, std::hash<int> > myGenericDatas;
 
        std::unordered_map<SumoXMLTag, std::map<const std::string, GNEMeanData*>, std::hash<int> > myMeanDatas;
 
        AttributeCarriers() = delete;
 
        AttributeCarriers(const AttributeCarriers&) = delete;
 
        AttributeCarriers& operator=(const AttributeCarriers&) = delete;
    };
 
    class ACTemplate {
 
    public:
        ACTemplate(GNENet* net);
 
        void buildTemplates();
 
        ~ACTemplate();
 
        std::map<SumoXMLTag, GNEAttributeCarrier*> getACTemplates() const;
 
        GNEAttributeCarrier* getTemplateAC(const SumoXMLTag tag) const;
 
        GNEAttributeCarrier* getTemplateAC(const std::string& selectorText) const;
 
    private:
        GNENet* myNet = nullptr;
 
        std::map<SumoXMLTag, GNEAttributeCarrier*> myTemplates;
 
        ACTemplate() = delete;
 
        ACTemplate(const ACTemplate&) = delete;
 
        ACTemplate& operator=(const ACTemplate& src) = delete;
    };
 
    class SavingFilesHandler {
 
    public:
        typedef std::map<std::string, std::unordered_set<const GNEAttributeCarrier*> > ACsbyFilename;
 
        SavingFilesHandler(GNENet* net);
 
        void updateNeteditConfig();
 
 
        void addAdditionalFilename(const GNEAttributeCarrier* additionalElement);
 
        void updateAdditionalEmptyFilenames(const std::string& file);
 
        const std::vector<std::string>& getAdditionalFilenames() const;
 
        ACsbyFilename getAdditionalsByFilename();
 
        bool existAdditionalFilename(const std::string& file) const;
 
 
 
        void addDemandFilename(const GNEAttributeCarrier* demandElement);
 
        void updateDemandEmptyFilenames(const std::string& file);
 
        const std::vector<std::string>& getDemandFilenames() const;
 
        ACsbyFilename getDemandsByFilename();
 
        bool existDemandFilename(const std::string& file) const;
 
 
 
        void addDataFilename(const GNEAttributeCarrier* dataElement);
 
        void updateDataEmptyFilenames(const std::string& file);
 
        const std::vector<std::string>& getDataFilenames() const;
 
        ACsbyFilename getDatasByFilename();
 
        bool existDataFilename(const std::string& file) const;
 
 
 
        void addMeanDataFilename(const GNEAttributeCarrier* meanDataElement);
 
        void updateMeanDataEmptyFilenames(const std::string& file);
 
        const std::vector<std::string>& getMeanDataFilenames() const;
 
        ACsbyFilename getMeanDatasByFilename();
 
        bool existMeanDataFilename(const std::string& file) const;
 
 
    private:
        GNENet* myNet;
 
        std::vector<std::string> myAdditionalElementsSavingFiles;
 
        std::vector<std::string> myDemandElementsSavingFiles;
 
        std::vector<std::string> myDataElementsSavingFiles;
 
        std::vector<std::string> myMeanDataElementsSavingFiles;
 
        std::string parsingSavingFiles(const std::vector<std::string>& savingFiles) const;
 
        SavingFilesHandler() = delete;
 
        SavingFilesHandler(const SavingFilesHandler&) = delete;
 
        SavingFilesHandler& operator=(const SavingFilesHandler&) = delete;
    };
 
    class SavingStatus {
 
    public:
        SavingStatus(GNENet* net);
 
 
        void requireSaveSumoConfig();
 
        void SumoConfigSaved();
 
        bool isSumoConfigSaved() const;
 
 
 
        void requireSaveNeteditConfig();
 
        void neteditConfigSaved();
 
        bool isNeteditConfigSaved() const;
 
 
 
        void requireSaveNetwork();
 
        void networkSaved();
 
        bool isNetworkSaved() const;
 
 
 
        void requireSaveTLS();
 
        void TLSSaved();
 
        bool isTLSSaved() const;
 
 
 
        void requireSaveEdgeType();
 
        void edgeTypeSaved();
 
        bool isEdgeTypeSaved() const;
 
 
 
        void requireSaveAdditionals();
 
        void additionalsSaved();
 
        bool isAdditionalsSaved() const;
 
 
 
        void requireSaveDemandElements();
 
        void demandElementsSaved();
 
        bool isDemandElementsSaved() const;
 
 
 
        void requireSaveDataElements();
 
        void dataElementsSaved();
 
        bool isDataElementsSaved() const;
 
 
 
        void requireSaveMeanDatas();
 
        void meanDatasSaved();
 
        bool isMeanDatasSaved() const;
 
 
 
        GNEDialog::Result askSaveNetwork(GNEDialog::Result &commonResult) const;
 
        GNEDialog::Result askSaveAdditionalElements(GNEDialog::Result &commonResult) const;
 
        GNEDialog::Result askSaveDemandElements(GNEDialog::Result &commonResult) const;
 
        GNEDialog::Result askSaveDataElements(GNEDialog::Result &commonResult) const;
 
        GNEDialog::Result askSaveMeanDataElements(GNEDialog::Result &commonResult) const;
 
 
    private:
        GNENet* myNet;
 
        bool mySumoConfigSaved = true;
 
        bool myNeteditConfigSaved = true;
 
        bool myNetworkSaved = true;
 
        bool myTLSSaved = true;
 
        bool myEdgeTypeSaved = true;
 
        bool myAdditionalSaved = true;
 
        bool myDemandElementSaved = true;
 
        bool myDataElementSaved = true;
 
        bool myMeanDataElementSaved = true;
 
        SavingStatus() = delete;
 
        SavingStatus(const SavingStatus&) = delete;
 
        SavingStatus& operator=(const SavingStatus&) = delete;
    };
 
    class GNEChange_ReplaceEdgeInTLS : public GNEChange {
        FXDECLARE_ABSTRACT(GNEChange_ReplaceEdgeInTLS)
 
    public:
        GNEChange_ReplaceEdgeInTLS(NBTrafficLightLogicCont& tllcont, NBEdge* replaced, NBEdge* by);
 
        ~GNEChange_ReplaceEdgeInTLS();
 
        void undo();
 
        void redo();
 
        std::string undoName() const;
 
        std::string redoName() const;
 
        bool trueChange();
 
    private:
        NBTrafficLightLogicCont& myTllcont;
 
        NBEdge* myReplaced;
 
        NBEdge* myBy;
    };
};