osm2graph_bitmap.cpp File Reference

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

Classes
struct	NodeData
struct	WayData
struct	Vertex
struct	Distance
struct	Routing

Macros
#define	IMAGE_WIDTH   1200
#define	IMAGE_HEIGHT   2000
#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   6.4
#define	LON_BOUND_DIF   0.30
#define	LAT_BOUND   51.1
#define	LAT_BOUND_DIF   0.30
#define	MAX_NODES   27672

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)
Color	toColor (double id)
int	main (int argc, char **argv)

Variables
Ways_t *	ways
Nodes_t *	nodes
Vertices_t *	verticies
Distance_t *	distances
Bmp	bild
Color	c
double	pos = 0.0

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

IMAGE_HEIGHT

#define IMAGE_HEIGHT   2000

IMAGE_WIDTH

#define IMAGE_WIDTH   1200

LAT_BOUND

#define LAT_BOUND   51.1

LAT_BOUND_DIF

#define LAT_BOUND_DIF   0.30

LON_BOUND

#define LON_BOUND   6.4

LON_BOUND_DIF

#define LON_BOUND_DIF   0.30

MAX_NODES

#define MAX_NODES   27672

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 ------------------------------------------------
    
    bild.init(IMAGE_WIDTH, IMAGE_HEIGHT);
 
    Vertices_t::Data dummy;
    verticies->each(dummy, [](Key id, Vertices_t::Data & v) {
        pos += 1.0;
        
        // europa: lon  -10..25
        //         lat   35..70
        // projektion: 1000px to 35 grad
        
        double lon = v.first._lon - LON_BOUND;
        double lat = v.first._lat - LAT_BOUND;
        int x = IMAGE_WIDTH*(lon/LON_BOUND_DIF);
        int y = IMAGE_HEIGHT - IMAGE_HEIGHT*(lat/LAT_BOUND_DIF);
        c = bild.get(x, y);
        
        // set color only if nothing set there before
        if (c.red == 0 && c.green ==0 && c.blue == 0) {
            bild.get(x, y) = toColor(pos);
        }
 
        // all items, no stop
        return false;
    });
 
    bild.write("graphnodes.bmp");
 
    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;
}

toColor()

Color toColor

(

double

id

)

                         {
    Color col;
    col.red = 0; col.green = 0; col.blue = 0;
    if( id >= MAX_NODES ) return col;
    double hi,q,t,coef;
 
    coef = 7.0 * (id/MAX_NODES);
    hi = floor(coef);
    t = coef - hi;
    q = 1 - t;
 
    if (hi == 0.0) {
        col.red   = 0;
        col.green = t*255; //immer mehr green und blau -> dunkelblau zu cyan
        col.blue  = t*127 + 128;
    } else if (hi == 1.0) {
        col.red   = t*255; //immer mehr rot -> cyan zu weiss
        col.green = 255;
        col.blue  = 255;
    } else if (hi == 2.0) {
        col.red   = 255;
        col.green = 255;
        col.blue  = q*255; // immer weniger blau -> weiss zu gelb
    } else if (hi == 3.0) {
        col.red   = 255;
        col.green = q*127 + 128; // immer weniger green -> gelb zu orange
        col.blue  = 0;
    } else if (hi == 4.0) {
        col.red   = q*127 + 128; // orange wird dunkler -> orange zu braun
        col.green = q*63 + 64;
        col.blue  = 0;
    } else if (hi == 5.0) {
        col.red   = 128;
        col.green = 64;
        col.blue  = t*128; // mehr blau -> braun zu violett
    } else if (hi == 6.0) {
        col.red   = t*127 + 128; // weniger blau und green, mehr rot -> violett wird rot
        col.green = q*64;
        col.blue  = q*128;
    }
    return col;
}

Variable Documentation

bild

Bmp bild

c

Color c

distances

Distance_t* distances

nodes

Nodes_t* nodes

pos

double pos = 0.0

verticies

Vertices_t* verticies

ways

Ways_t* ways