osm2graph_baremetal.cpp File Reference

#include <cstdio>
#include <utility>
#include <inttypes.h>
#include <vector>
#include <cstring>
#include <cmath>
#include <algorithm>
#include "SwappyItems.hpp"
#include "osmpbfreader.hpp"

Classes
struct	NodeData
struct	WayData
struct	Vertex
struct	Distance
struct	Routing

Macros
#define	FILE_ITEMS   ( 7*1024)
#define	FILE_MULTI   6
#define	RAM_MULTI   9
#define	BBITS   5
#define	BMASK   ((BBITS+4)* FILE_ITEMS)
#define	TORADI(angleDegrees)   ((angleDegrees) * M_PI / 180.0)
#define	LON_BOUND   5.85
#define	LON_BOUND_DIF   3.62
#define	LAT_BOUND   50.32
#define	LAT_BOUND_DIF   2.2

Typedefs
typedef uint64_t	Key
typedef SwappyItems< Key, WayData, FILE_ITEMS, FILE_MULTI, RAM_MULTI, BBITS, BMASK >	Ways_t
typedef SwappyItems< Key, NodeData, FILE_ITEMS, FILE_MULTI, RAM_MULTI, BBITS, BMASK >	Nodes_t
typedef SwappyItems< Key, Vertex, FILE_ITEMS, FILE_MULTI, RAM_MULTI, BBITS, BMASK >	Vertices_t
typedef SwappyItems< Key, Distance, FILE_ITEMS, FILE_MULTI, RAM_MULTI, BBITS, BMASK >	Distance_t

Functions
Key	calcDist (double lon1, double lat1, double lon2, double lat2)
uint8_t	relevance (const std::string &wt)
int	main (int argc, char **argv)

Variables
Ways_t *	ways
Nodes_t *	nodes
Vertices_t *	verticies
Distance_t *	distances

Macro Definition Documentation

BBITS

#define BBITS   5

BMASK

#define BMASK   ((BBITS+4)* FILE_ITEMS)

FILE_ITEMS

#define FILE_ITEMS   ( 7*1024)

FILE_MULTI

#define FILE_MULTI   6

LAT_BOUND

#define LAT_BOUND   50.32

LAT_BOUND_DIF

#define LAT_BOUND_DIF   2.2

LON_BOUND

#define LON_BOUND   5.85

LON_BOUND_DIF

#define LON_BOUND_DIF   3.62

RAM_MULTI

#define RAM_MULTI   9

TORADI

#define TORADI

(

angleDegrees

)

((angleDegrees) * M_PI / 180.0)

Typedef Documentation

Distance_t

typedef SwappyItems<Key, Distance, FILE_ITEMS, FILE_MULTI, RAM_MULTI, BBITS, BMASK> Distance_t

Key

typedef uint64_t Key

Nodes_t

typedef SwappyItems<Key, NodeData, FILE_ITEMS, FILE_MULTI, RAM_MULTI, BBITS, BMASK> Nodes_t

Vertices_t

typedef SwappyItems<Key, Vertex, FILE_ITEMS, FILE_MULTI, RAM_MULTI, BBITS, BMASK> Vertices_t

Ways_t

typedef SwappyItems<Key, WayData, FILE_ITEMS, FILE_MULTI, RAM_MULTI, BBITS, BMASK> Ways_t

Function Documentation

calcDist()

Key calcDist	(	double	lon1,
		double	lat1,
		double	lon2,
		double	lat2
	)

                                                                 {
    double dist = 6378388.0 * std::acos(std::sin(TORADI(lat1)) * std::sin(TORADI(lat2)) + std::cos(TORADI(lat1)) * std::cos(TORADI(lat2)) * std::cos(TORADI(lon2 - lon1)));
    if (dist < 0) dist *=-1;
    return dist;
}

main()

int main	(	int	argc,
		char **	argv
	)

                                {
    Routing routing;
    ways = new Ways_t(1);
    nodes = new Nodes_t(2);
    
    verticies = new Vertices_t(3);
    distances = new Distance_t(4);
    
    read_osm_pbf(argv[1], routing, true); // ways
 
    read_osm_pbf(argv[1], routing, false); // nodes und bedingungen
    
    // create verticies -------------------------------------------------------------------------------------
    
    Ways_t::Data w;
    ways->each(w, [](Key wayosmid, Ways_t::Data & way) {
        bool firstItem = true;
        Key last;
        double lastLon = 0.0;
        double lastLat = 0.0;
        Key dist = 0;
 
        // create verticies from refs: a->b->c->d->e
        // d link to e(=last)
        // c link to d(=last)
        // ...
        for (unsigned i=0; i < way.second.size(); ++i) {
            Key ref = way.second[way.second.size()-1 - i]; // add actually ref to the last ref (from backward)
            Nodes_t::Data * nptr = nodes->get(ref);
            
            if (nptr == nullptr) continue;
            if (nptr->first._lon == 0 && nptr->first._lat == 0) continue;
            
            if (nptr->first._used == 0) {
                if (firstItem == false) {
                    dist += calcDist(nptr->first._lon, nptr->first._lat, lastLon, lastLat);
                    lastLon = nptr->first._lon;
                    lastLat = nptr->first._lat;
                }
                continue;
            }
            
            Vertices_t::Data * vptr = verticies->get(ref);
            Distance_t::Data * dptr = distances->get(ref);
 
            if (vptr == nullptr) {
                Vertices_t::Data vertex;
                Distance_t::Data distance;
                vertex.first._way = wayosmid;
                vertex.first._lon = nptr->first._lon;
                vertex.first._lat = nptr->first._lat;
                if (firstItem) {
                    firstItem = false;
                } else {
                    dist += calcDist(vertex.first._lon, vertex.first._lat, lastLon, lastLat);
                    vertex.second.push_back(last);
                    distance.second.push_back(dist);
                }
                lastLon = nptr->first._lon;
                lastLat = nptr->first._lat;
                verticies->set(ref, vertex.first, vertex.second);
                distances->set(ref, distance.first, distance.second);
            } else {
                if (firstItem) {
                    firstItem = false;
                } else {
                    dist += calcDist(vptr->first._lon, vptr->first._lat, lastLon, lastLat);
                    vptr->second.push_back(last);
                    dptr->second.push_back(dist);
                }
                lastLon = nptr->first._lon;
                lastLat = nptr->first._lat;
                verticies->set(ref, vptr->first, vptr->second);
                distances->set(ref, dptr->first, dptr->second);
            }
            dist = 0;
            last = ref;
        }
        
        // Not a oneway. create verticies from refs in the direction: a<-b<-c<-d<-e
        // b link to a(=last)
        // c link to b(=last)
        // ...
        firstItem = true;
        lastLon = 0.0;
        lastLat = 0.0;
        dist = 0;
        if (way.first._oneway == false) {
            for (unsigned i=0; i < way.second.size(); ++i) {
                Key ref = way.second[i];
                Nodes_t::Data * nptr = nodes->get(ref);
                
                if (nptr == nullptr) continue;
                if (nptr->first._lon == 0 && nptr->first._lat == 0) continue;
            
                if (nptr->first._used == 0) {
                    if (firstItem == false) {
                        dist += calcDist(nptr->first._lon, nptr->first._lat, lastLon, lastLat);
                        lastLon = nptr->first._lon;
                        lastLat = nptr->first._lat;
                    }
                    continue;
                }
                
                Vertices_t::Data * vptr = verticies->get(ref);
                Distance_t::Data * dptr = distances->get(ref);
 
                if (vptr == nullptr) {
                    Vertices_t::Data vertex;
                    Distance_t::Data distance;
                    vertex.first._way = wayosmid;
                    vertex.first._lon = nptr->first._lon;
                    vertex.first._lat = nptr->first._lat;
                    if (firstItem) {
                        firstItem = false;
                    } else {
                        dist += calcDist(vertex.first._lon, vertex.first._lat, lastLon, lastLat);
                        vertex.second.push_back(last);
                        distance.second.push_back(dist);
                    }
                    lastLon = nptr->first._lon;
                    lastLat = nptr->first._lat;
                    verticies->set(ref, vertex.first, vertex.second);
                    distances->set(ref, distance.first, distance.second);
                } else {
                    if (firstItem) {
                        firstItem = false;
                    } else {
                        dist += calcDist(vptr->first._lon, vptr->first._lat, lastLon, lastLat);
                        vptr->second.push_back(last);
                        dptr->second.push_back(dist);
                    }
                    lastLon = nptr->first._lon;
                    lastLat = nptr->first._lat;
                    verticies->set(ref, vptr->first, vptr->second);
                    distances->set(ref, dptr->first, dptr->second);
                }
                dist = 0;
                last = ref;
            }
        }
        // all items, no stop
        return false;
    });
    
    // print verticies ------------------------------------------------
    
    Vertices_t::Data dummy;
    verticies->each(dummy, [](Key id, Vertices_t::Data & v) {
        printf("%ld (%f,%f) part of way %ld\n", id, v.first._lon, v.first._lat, v.first._way);
        for (Key r : v.second) {
            printf(" %" PRId64, r);
        }
        printf("\n");
        Distance_t::Data * dptr = distances->get(id);
        for (Key r : dptr->second) {
            printf(" %" PRId64, r);
        }
        printf("\n");
        // all items, no stop
        return false;
    });
    
    delete distances;
    delete verticies;
    delete nodes;
    delete ways;
    
    return 0;
}

relevance()

uint8_t relevance

(

const std::string &

wt

)

                                        {
    if (wt.compare("motorway") == 0) return 1;
    if (wt.compare("motorway_link") == 0) return 2;
    if (wt.compare("trunk") == 0) return 1;
    if (wt.compare("trunk_link") == 0) return 2;
    if (wt.compare("primary") == 0) return 1;
    if (wt.compare("primary_link") == 0) return 2;
    if (wt.compare("secondary") == 0) return 1;
    if (wt.compare("secondary_link") == 0) return 2;
    if (wt.compare("unclassified") == 0) return 1;
    if (wt.compare("tertiary") == 0) return 1;
    if (wt.compare("tertiary_link") == 0) return 2;
    if (wt.compare("residential") == 0) return 1;
    return 0;
}

Variable Documentation

distances

Distance_t* distances

nodes

Nodes_t* nodes

verticies

Vertices_t* verticies

ways

Ways_t* ways