inet::osm::OpenStreetMap Class Reference

Represents OpenStreetMap map data, as loaded from an OSM file. More...

#include <OpenStreetMap.h>

Public Member Functions
	OpenStreetMap ()
	OpenStreetMap (const OpenStreetMap &)=delete
	OpenStreetMap (OpenStreetMap &&other)
	~OpenStreetMap ()
void	operator= (const OpenStreetMap &)=delete
void	operator= (OpenStreetMap &&)
const Bounds &	getBounds () const
const std::vector< const Node * > &	getNodes () const
const std::vector< const Way * > &	getWays () const
const std::vector< const Relation * > &	getRelations () const

Static Public Member Functions
static OpenStreetMap	from (cXMLElement *mapRoot)

Private Member Functions
const char *	getPooled (const char *s)
void	releaseAllocations ()
void	parseTags (cXMLElement *parent, Tags &intoTags)

Private Attributes
Bounds	bounds
std::vector< const Node * >	nodes
std::vector< const Way * >	ways
std::vector< const Relation * >	relations
std::set< std::string > *	strings = new std::set<std::string>()

Detailed Description

Represents OpenStreetMap map data, as loaded from an OSM file.

OSM files can be obtained e.g. by exporting from http://openstreetmap.org.

Constructor & Destructor Documentation

OpenStreetMap() [1/3]

inet::osm::OpenStreetMap::OpenStreetMap ( )

inline

{}

OpenStreetMap() [2/3]

inet::osm::OpenStreetMap::OpenStreetMap ( const OpenStreetMap &  )

delete

OpenStreetMap() [3/3]

inet::osm::OpenStreetMap::OpenStreetMap

(

OpenStreetMap &&

other

)

{
    bounds = other.bounds;
    nodes = std::move(other.nodes);
    ways = std::move(other.ways);
    relations = std::move(other.relations);
    strings = other.strings;
    other.strings = nullptr;
}

~OpenStreetMap()

inet::osm::OpenStreetMap::~OpenStreetMap

(

)

{
    releaseAllocations();
}

Member Function Documentation

from()

OpenStreetMap inet::osm::OpenStreetMap::from ( cXMLElement *  mapRoot )

static

{
    OpenStreetMap map;
    std::map<id_t, Node *> nodeById;
    std::map<id_t, Way *> wayById;
    std::map<id_t, Relation *> relationById;
 
    cXMLElement *boundsElement = mapRoot->getFirstChildWithTag("bounds");
    Bounds& bounds = map.bounds;
    bounds.minlat = bounds.minlon = bounds.maxlat = bounds.maxlon = NAN;
 
    if (boundsElement) {
        bounds.minlat = parseDouble(boundsElement->getAttribute("minlat"));
        bounds.minlon = parseDouble(boundsElement->getAttribute("minlon"));
        bounds.maxlat = parseDouble(boundsElement->getAttribute("maxlat"));
        bounds.maxlon = parseDouble(boundsElement->getAttribute("maxlon"));
    }
 
    for (cXMLElement *nodeElem : mapRoot->getChildrenByTagName("node")) {
        Node *node = new Node();
        node->id = parseId(nodeElem->getAttribute("id"));
        node->lat = parseDouble(nodeElem->getAttribute("lat"));
        node->lon = parseDouble(nodeElem->getAttribute("lon"));
        map.parseTags(nodeElem, node->tags);
        map.nodes.push_back(node);
        nodeById[node->id] = node;
    }
 
    for (cXMLElement *wayElem : mapRoot->getChildrenByTagName("way")) {
        Way *way = new Way();
        way->id = parseId(wayElem->getAttribute("id"));
        for (cXMLElement *nodeElem : wayElem->getChildrenByTagName("nd")) {
            id_t ref = parseId(nodeElem->getAttribute("ref"));
            auto it = nodeById.find(ref);
            if (it == nodeById.end())
                throw cRuntimeError("Referenced node not found at %s", nodeElem->getSourceLocation());
            Node *node = it->second;
            way->nodes.push_back(node);
        }
        map.parseTags(wayElem, way->tags);
        map.ways.push_back(way);
        wayById[way->id] = way;
    }
 
    for (cXMLElement *relationElem : mapRoot->getChildrenByTagName("relation")) {
        Relation *relation = new Relation();
        relation->id = parseId(relationElem->getAttribute("id"));
        for (cXMLElement *memberElem : relationElem->getChildrenByTagName("member")) {
            Member member;
            const char *type = memberElem->getAttribute("type");
            id_t ref = parseId(memberElem->getAttribute("ref"));
            if (strcmp(type, "node") == 0) {
                member.type = Member::NODE;
                auto it = nodeById.find(ref);
                member.resolved = (it != nodeById.end());
                if (member.resolved)
                    member.node = it->second;
                else
                    member.unresolvedId = ref;
            }
            else if (strcmp(type, "way") == 0) {
                member.type = Member::WAY;
                auto it = wayById.find(ref);
                member.resolved = (it != wayById.end());
                if (member.resolved)
                    member.way = it->second;
                else
                    member.unresolvedId = ref;
            }
            else if (strcmp(type, "relation") == 0) {
                member.type = Member::RELATION;
                auto it = relationById.find(ref);
                member.resolved = (it != relationById.end());
                if (member.resolved)
                    member.relation = it->second;
                else
                    member.unresolvedId = ref;
            }
            else {
                throw cRuntimeError("Invalid member type '%s' at %s", type, memberElem->getSourceLocation());
            }
            member.role = map.getPooled(memberElem->getAttribute("role"));
            relation->members.push_back(member);
        }
        map.parseTags(relationElem, relation->tags);
        map.relations.push_back(relation);
        relationById[relation->id] = relation;
    }
 
    // resolve references to relations defined out of order
    for (const Relation *relation : map.relations) {
        for (Member& member : const_cast<Relation *>(relation)->members) {
            if (member.type == Member::RELATION && !member.resolved) {
                auto it = relationById.find(member.unresolvedId);
                if (it != relationById.end()) {
                    member.resolved = true;
                    member.relation = it->second;
                }
            }
        }
    }
 
    return map;
}

Referenced by inet::visualizer::OpenStreetMapSceneCanvasVisualizer::initialize().

getBounds()

const Bounds& inet::osm::OpenStreetMap::getBounds ( ) const

inline

{ return bounds; };

Referenced by inet::visualizer::OpenStreetMapSceneCanvasVisualizer::initialize().

getNodes()

const std::vector<const Node *>& inet::osm::OpenStreetMap::getNodes ( ) const

inline

{ return nodes; }

Referenced by inet::visualizer::OpenStreetMapSceneCanvasVisualizer::initialize().

getPooled()

const char * inet::osm::OpenStreetMap::getPooled ( const char *  s )

private

{
    if (s == nullptr)
        return nullptr;
    auto it = strings->find(s);
    if (it == strings->end())
        it = strings->insert(s).first;
    return it->c_str();
}

Referenced by from(), and parseTags().

getRelations()

const std::vector<const Relation *>& inet::osm::OpenStreetMap::getRelations ( ) const

inline

{ return relations; }

getWays()

const std::vector<const Way *>& inet::osm::OpenStreetMap::getWays ( ) const

inline

{ return ways; }

Referenced by inet::visualizer::OpenStreetMapSceneCanvasVisualizer::createMapFigure(), and inet::visualizer::OpenStreetMapSceneCanvasVisualizer::initialize().

operator=() [1/2]

void inet::osm::OpenStreetMap::operator= ( const OpenStreetMap &  )

delete

operator=() [2/2]

void inet::osm::OpenStreetMap::operator=

(

OpenStreetMap &&

other

)

{
    if (this != &other) {
        releaseAllocations();
        bounds = other.bounds;
        nodes = std::move(other.nodes);
        ways = std::move(other.ways);
        relations = std::move(other.relations);
        strings = other.strings;
        other.strings = nullptr;
    }
}

parseTags()

void inet::osm::OpenStreetMap::parseTags ( cXMLElement *  parent, Tags &  intoTags  )

private

{
    for (cXMLElement *child : parent->getChildrenByTagName("tag")) {
        const char *k = child->getAttribute("k");
        const char *v = child->getAttribute("v");
        tags.add(getPooled(k), getPooled(v));
    }
}

Referenced by from().

releaseAllocations()

void inet::osm::OpenStreetMap::releaseAllocations ( )

private

{
    for (const Way *way : ways)
        delete way;
    for (const Node *node : nodes)
        delete node;
    for (const Relation *relation : relations)
        delete relation;
    delete strings;
}

Referenced by operator=(), and ~OpenStreetMap().

Member Data Documentation

bounds

Bounds inet::osm::OpenStreetMap::bounds

private

Referenced by from(), OpenStreetMap(), and operator=().

nodes

std::vector<const Node *> inet::osm::OpenStreetMap::nodes

private

Referenced by from(), OpenStreetMap(), operator=(), and releaseAllocations().

relations

std::vector<const Relation *> inet::osm::OpenStreetMap::relations

private

Referenced by from(), OpenStreetMap(), operator=(), and releaseAllocations().

strings

std::set<std::string>* inet::osm::OpenStreetMap::strings = new std::set<std::string>()

private

Referenced by getPooled(), OpenStreetMap(), operator=(), and releaseAllocations().

ways

std::vector<const Way *> inet::osm::OpenStreetMap::ways

private

Referenced by from(), OpenStreetMap(), operator=(), and releaseAllocations().

---

The documentation for this class was generated from the following files:

• OpenStreetMap.h
• OpenStreetMap.cc