PCLoaderOSM.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2008-2024 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
/****************************************************************************/
// A reader of pois and polygons stored in OSM-format
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include "PCPolyContainer.h"
#include "PCTypeMap.h"
#include <utils/xml/SUMOSAXHandler.h>
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class OptionsCont;
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class PCLoaderOSM : public SUMOSAXHandler {
public:
    static void loadIfSet(OptionsCont& oc, PCPolyContainer& toFill,
                          PCTypeMap& tm);
 
 
protected:
 
    struct PCOSMNode {
        long long int id;
        double lon;
        double lat;
        std::string name;
        std::map<std::string, std::string> myAttributes;
    };
 
 
    struct PCOSMRelation {
        long long int id;
        std::string name;
        std::vector<long long int> myWays;
        std::map<std::string, std::string> myAttributes;
        bool keep;
    };
 
 
    struct PCOSMEdge {
        long long int id;
        std::string name;
        bool myIsClosed;
        std::vector<long long int> myCurrentNodes;
        std::map<std::string, std::string> myAttributes;
        // @brief Wether this way constitutes a complete polygon object
        bool standalone;
    };
 
    typedef std::vector<PCOSMRelation*> Relations;
    typedef std::map<long long int, PCOSMRelation*> RelationsMap;
    typedef std::map<long long int, PCOSMEdge*> EdgeMap;
 
protected:
    static int addPolygon(const PCOSMEdge* edge, const PositionVector& vec, const PCTypeMap::TypeDef& def,
                          const std::string& fullType, int index, bool useName, PCPolyContainer& toFill, bool ignorePruning, bool withAttributes);
 
    static int addPOI(const PCOSMNode* node, const Position& pos, const PCTypeMap::TypeDef& def,
                      const std::string& fullType, int index, bool useName, PCPolyContainer& toFill, bool ignorePruning, bool withAttributes);
 
 
protected:
    static const std::set<std::string> MyKeysToInclude;
 
private:
    static std::set<std::string> initMyKeysToInclude();
 
    static Position convertNodePosition(PCOSMNode* n);
 
    static double mergeClosest(const std::map<long long int, PCOSMNode*>& nodes, std::vector<std::vector<long long int> >& snippets);
 
protected:
    class NodesHandler : public SUMOSAXHandler {
    public:
        NodesHandler(std::map<long long int, PCOSMNode*>& toFill, bool withAttributes,
                     MsgHandler& errorHandler);
 
 
        ~NodesHandler();
 
 
    protected:
 
 
        void myStartElement(int element, const SUMOSAXAttributes& attrs);
 
 
        void myEndElement(int element);
 
 
    private:
        bool myWithAttributes;
 
        MsgHandler& myErrorHandler;
 
        std::map<long long int, PCOSMNode*>& myToFill;
 
        std::vector<int> myParentElements;
 
        long long int myLastNodeID;
 
    private:
        NodesHandler(const NodesHandler& s);
 
        NodesHandler& operator=(const NodesHandler& s);
 
    };
 
    class RelationsHandler : public SUMOSAXHandler {
    public:
        RelationsHandler(RelationsMap& additionalWays,
                         Relations& relations,
                         std::set<long long int>& innerEdges,
                         bool withAttributes,
                         MsgHandler& errorHandler);
 
 
        ~RelationsHandler();
 
 
    protected:
 
 
        void myStartElement(int element, const SUMOSAXAttributes& attrs);
 
 
        void myEndElement(int element);
 
 
    private:
        RelationsMap& myAdditionalWays;
 
        Relations& myRelations;
 
        std::set<long long int>& myInnerEdges;
 
        bool myWithAttributes;
 
        MsgHandler& myErrorHandler;
 
        PCOSMRelation* myCurrentRelation;
 
        std::vector<long long int> myCurrentWays;
 
        std::vector<long long int> myParentElements;
 
        bool myKeep;
 
    private:
        RelationsHandler(const RelationsHandler& s);
 
        RelationsHandler& operator=(const RelationsHandler& s);
 
    };
 
 
    class EdgesHandler : public SUMOSAXHandler {
    public:
        EdgesHandler(const std::map<long long int, PCOSMNode*>& osmNodes,
                     EdgeMap& toFill,
                     const RelationsMap& additionalWays,
                     bool withAttributes,
                     MsgHandler& errorHandler);
 
 
        ~EdgesHandler();
 
 
    protected:
 
 
        void myStartElement(int element, const SUMOSAXAttributes& attrs);
 
 
        void myEndElement(int element);
 
 
    private:
        bool myWithAttributes;
 
        MsgHandler& myErrorHandler;
 
        const std::map<long long int, PCOSMNode*>& myOSMNodes;
 
        EdgeMap& myEdgeMap;
 
        const RelationsMap& myAdditionalWays;
 
        PCOSMEdge* myCurrentEdge;
 
        std::vector<int> myParentElements;
 
        bool myKeep;
 
    private:
        EdgesHandler(const EdgesHandler& s);
 
        EdgesHandler& operator=(const EdgesHandler& s);
 
    };
 
};