263 lines
7.0 KiB
C++
263 lines
7.0 KiB
C++
/*
|
|
open source routing machine
|
|
Copyright (C) Dennis Luxen, 2010
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU AFFERO General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Affero General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
or see http://www.gnu.org/licenses/agpl.txt.
|
|
*/
|
|
|
|
#ifndef EXTRACTORSTRUCTS_H_
|
|
#define EXTRACTORSTRUCTS_H_
|
|
|
|
#include <climits>
|
|
#include <cmath>
|
|
#include <string>
|
|
#include "HashTable.h"
|
|
#include "Util.h"
|
|
|
|
/* Default Speed Profile:
|
|
motorway 110
|
|
motorway_link 90
|
|
trunk 90
|
|
trunk_link 70
|
|
primary 70
|
|
primary_link 60
|
|
secondary 60
|
|
secondary_link 50
|
|
tertiary 55
|
|
unclassified 25
|
|
residential 40
|
|
living_street 10
|
|
service 30
|
|
ferry 5
|
|
*/
|
|
|
|
typedef google::dense_hash_map<std::string, NodeID> StringMap;
|
|
|
|
std::string names[14] = { "motorway", "motorway_link", "trunk", "trunk_link", "primary", "primary_link", "secondary", "secondary_link", "tertiary", "unclassified", "residential", "living_street", "service", "ferry" };
|
|
double speeds[14] = { 110, 90, 90, 70, 70, 60, 60, 50, 55, 25, 40 , 10, 30, 5};
|
|
|
|
struct _Node : NodeInfo{
|
|
_Node(int _lat, int _lon, unsigned int _id) : NodeInfo(_lat, _lon, _id) {}
|
|
_Node() {}
|
|
|
|
static _Node min_value()
|
|
{
|
|
return _Node(0,0,0);
|
|
}
|
|
static _Node max_value()
|
|
{
|
|
return _Node(numeric_limits<int>::max(), numeric_limits<int>::max(), numeric_limits<unsigned int>::max());
|
|
}
|
|
NodeID key() const
|
|
{
|
|
return id;
|
|
}
|
|
};
|
|
|
|
struct _Coordinate {
|
|
int lat;
|
|
int lon;
|
|
_Coordinate () : lat(INT_MIN), lon(INT_MIN) {}
|
|
_Coordinate (int t, int n) : lat(t) , lon(n) {}
|
|
};
|
|
|
|
struct _Way {
|
|
_Way() {
|
|
direction = _Way::notSure;
|
|
maximumSpeed = -1;
|
|
type = -1;
|
|
useful = false;
|
|
access = true;
|
|
}
|
|
|
|
std::vector< NodeID > path;
|
|
enum {
|
|
notSure = 0, oneway, bidirectional, opposite
|
|
} direction;
|
|
unsigned id;
|
|
unsigned nameID;
|
|
std::string name;
|
|
double maximumSpeed;
|
|
bool useful:1;
|
|
bool access:1;
|
|
short type;
|
|
HashTable<std::string, std::string> keyVals;
|
|
};
|
|
|
|
struct _Relation {
|
|
enum {
|
|
unknown = 0, ferry
|
|
} type;
|
|
};
|
|
|
|
struct _Edge {
|
|
_Edge() {};
|
|
_Edge(NodeID s, NodeID t) : start(s), target(t) { }
|
|
_Edge(NodeID s, NodeID t, short tp, short d, double sp): start(s), target(t), type(tp), direction(d), speed(sp) { }
|
|
NodeID start;
|
|
NodeID target;
|
|
short type;
|
|
short direction;
|
|
double speed;
|
|
unsigned nameID;
|
|
|
|
_Coordinate startCoord;
|
|
_Coordinate targetCoord;
|
|
};
|
|
|
|
struct Settings {
|
|
struct SpeedProfile {
|
|
vector< double > speed;
|
|
vector< string > names;
|
|
} speedProfile;
|
|
// vector<string> accessList;
|
|
// int trafficLightPenalty;
|
|
int indexInAccessListOf( const string & key)
|
|
{
|
|
for(unsigned i = 0; i< speedProfile.names.size(); i++)
|
|
{
|
|
if(speedProfile.names[i] == key)
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
};
|
|
|
|
struct Cmp : public std::binary_function<NodeID, NodeID, bool>
|
|
{
|
|
typedef NodeID value_type;
|
|
bool operator () (const NodeID & a, const NodeID & b) const
|
|
{
|
|
return a < b;
|
|
}
|
|
value_type max_value()
|
|
{
|
|
return 0xffffffff;
|
|
}
|
|
value_type min_value()
|
|
{
|
|
return 0x0;
|
|
}
|
|
};
|
|
|
|
struct CompareEdgeByStart : public std::binary_function<_Edge, _Edge, bool>
|
|
{
|
|
typedef _Edge value_type;
|
|
bool operator () (const _Edge & a, const _Edge & b) const
|
|
{
|
|
return a.start < b.start;
|
|
}
|
|
value_type max_value()
|
|
{
|
|
return _Edge(UINT_MAX, UINT_MAX);
|
|
}
|
|
value_type min_value()
|
|
{
|
|
return _Edge(0, 0);
|
|
}
|
|
};
|
|
|
|
struct CompareEdgeByTarget : public std::binary_function<_Edge, _Edge, bool>
|
|
{
|
|
typedef _Edge value_type;
|
|
bool operator () (const _Edge & a, const _Edge & b) const
|
|
{
|
|
return a.target < b.target;
|
|
}
|
|
value_type max_value()
|
|
{
|
|
return _Edge(UINT_MAX, UINT_MAX);
|
|
}
|
|
value_type min_value()
|
|
{
|
|
return _Edge(0, 0);
|
|
}
|
|
};
|
|
|
|
struct CmpNodeByID : public std::binary_function<_Node, _Node, bool>
|
|
{
|
|
typedef _Node value_type;
|
|
bool operator () (const _Node & a, const _Node & b) const
|
|
{
|
|
return a.id < b.id;
|
|
}
|
|
value_type max_value()
|
|
{
|
|
return _Node::max_value();
|
|
}
|
|
value_type min_value()
|
|
{
|
|
return _Node::min_value();
|
|
}
|
|
};
|
|
|
|
double ApproximateDistance( const int lat1, const int lon1, const int lat2, const int lon2 ) {
|
|
static const double DEG_TO_RAD = 0.017453292519943295769236907684886;
|
|
///Earth's quatratic mean radius for WGS-84
|
|
static const double EARTH_RADIUS_IN_METERS = 6372797.560856;
|
|
double latitudeArc = ( lat1/100000. - lat2/100000. ) * DEG_TO_RAD;
|
|
double longitudeArc = ( lon1/100000. - lon2/100000. ) * DEG_TO_RAD;
|
|
double latitudeH = sin( latitudeArc * 0.5 );
|
|
latitudeH *= latitudeH;
|
|
double lontitudeH = sin( longitudeArc * 0.5 );
|
|
lontitudeH *= lontitudeH;
|
|
double tmp = cos( lat1/100000. * DEG_TO_RAD ) * cos( lat2/100000. * DEG_TO_RAD );
|
|
double distanceArc = 2.0 * asin( sqrt( latitudeH + tmp * lontitudeH ) );
|
|
return EARTH_RADIUS_IN_METERS * distanceArc;
|
|
}
|
|
|
|
/* Get angle of line segment (A,C)->(C,B), atan2 magic, formerly cosine theorem*/
|
|
double GetAngleBetweenTwoEdges(const _Coordinate& A, const _Coordinate& C, const _Coordinate& B)
|
|
{
|
|
// double a = ApproximateDistance(A.lat, A.lon, C.lat, C.lon); //first edge segment
|
|
// double b = ApproximateDistance(B.lat, B.lon, C.lat, C.lon); //second edge segment
|
|
// double c = ApproximateDistance(A.lat, A.lon, B.lat, B.lon); //third edgefrom triangle
|
|
//
|
|
// double cosAlpha = (a*a + b*b - c*c)/ (2*a*b);
|
|
//
|
|
// double alpha = ( (acos(cosAlpha) * 180.0 / M_PI) * (cosAlpha > 0 ? -1 : 1) ) + 180;
|
|
// return alpha;
|
|
// V = <x2 - x1, y2 - y1>
|
|
int v1x = A.lon - C.lon;
|
|
int v1y = A.lat - C.lat;
|
|
int v2x = B.lon - C.lon;
|
|
int v2y = B.lat - C.lat;
|
|
|
|
double angle = (atan2(v2y,v2x) - atan2(v1y,v1x) )*180/M_PI;
|
|
while(angle < 0)
|
|
angle += 360;
|
|
|
|
return angle;
|
|
}
|
|
|
|
string GetRandomString() {
|
|
char s[128];
|
|
static const char alphanum[] =
|
|
"0123456789"
|
|
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
|
"abcdefghijklmnopqrstuvwxyz";
|
|
|
|
for (int i = 0; i < 128; ++i) {
|
|
s[i] = alphanum[rand() % (sizeof(alphanum) - 1)];
|
|
}
|
|
s[128] = 0;
|
|
return string(s);
|
|
}
|
|
|
|
typedef google::dense_hash_map<NodeID, _Node> NodeMap;
|
|
|
|
#endif /* EXTRACTORSTRUCTS_H_ */
|