Implement #495

Algorithms/StronglyConnectedComponents.h

@@ -343,10 +343,10 @@ public:
                     //edges that end on bollard nodes may actually be in two distinct components
                     if(std::min(vectorOfComponentSizes[componentsIndex[u]], vectorOfComponentSizes[componentsIndex[v]]) < 10) {
 
-                        //INFO("(" << inputNodeInfoList[u].lat/100000. << ";" << inputNodeInfoList[u].lon/100000. << ") -> (" << inputNodeInfoList[v].lat/100000. << ";" << inputNodeInfoList[v].lon/100000. << ")");
+                        //INFO("(" << inputNodeInfoList[u].lat/COORDINATE_PRECISION << ";" << inputNodeInfoList[u].lon/COORDINATE_PRECISION << ") -> (" << inputNodeInfoList[v].lat/COORDINATE_PRECISION << ";" << inputNodeInfoList[v].lon/COORDINATE_PRECISION << ")");
                         OGRLineString lineString;
-                        lineString.addPoint(inputNodeInfoList[u].lon/100000., inputNodeInfoList[u].lat/100000.);
+                        lineString.addPoint(inputNodeInfoList[u].lon/COORDINATE_PRECISION, inputNodeInfoList[u].lat/COORDINATE_PRECISION);
-                        lineString.addPoint(inputNodeInfoList[v].lon/100000., inputNodeInfoList[v].lat/100000.);
+                        lineString.addPoint(inputNodeInfoList[v].lon/COORDINATE_PRECISION, inputNodeInfoList[v].lat/COORDINATE_PRECISION);
                         OGRFeature *poFeature;
                         poFeature = OGRFeature::CreateFeature( poLayer->GetLayerDefn() );
                         poFeature->SetGeometry( &lineString );

Contractor/EdgeBasedGraphFactory.cpp

@@ -400,10 +400,10 @@ unsigned EdgeBasedGraphFactory::GetNumberOfNodes() const {
 /* Get angle of line segment (A,C)->(C,B), atan2 magic, formerly cosine theorem*/
 template<class CoordinateT>
 double EdgeBasedGraphFactory::GetAngleBetweenTwoEdges(const CoordinateT& A, const CoordinateT& C, const CoordinateT& B) const {
-    const double v1x = (A.lon - C.lon)/100000.;
+    const double v1x = (A.lon - C.lon)/COORDINATE_PRECISION;
-    const double v1y = lat2y(A.lat/100000.) - lat2y(C.lat/100000.);
+    const double v1y = lat2y(A.lat/COORDINATE_PRECISION) - lat2y(C.lat/COORDINATE_PRECISION);
-    const double v2x = (B.lon - C.lon)/100000.;
+    const double v2x = (B.lon - C.lon)/COORDINATE_PRECISION;
-    const double v2y = lat2y(B.lat/100000.) - lat2y(C.lat/100000.);
+    const double v2y = lat2y(B.lat/COORDINATE_PRECISION) - lat2y(C.lat/COORDINATE_PRECISION);
 
     double angle = (atan2(v2y,v2x) - atan2(v1y,v1x) )*180/M_PI;
     while(angle < 0)

DataStructures/Coordinate.h

@@ -29,6 +29,8 @@ or see http://www.gnu.org/licenses/agpl.txt.
 
 #include <iostream>
 
+static const double COORDINATE_PRECISION = 1000000.;
+
 struct _Coordinate {
     int lat;
     int lon;
@@ -43,7 +45,12 @@ struct _Coordinate {
         return (INT_MIN != lat) && (INT_MIN != lon);
     }
     inline bool isValid() const {
-        if(lat > 90*100000 || lat < -90*100000 || lon > 180*100000 || lon <-180*100000) {
+        if(
+            lat >   90*COORDINATE_PRECISION ||
+            lat <  -90*COORDINATE_PRECISION ||
+            lon >  180*COORDINATE_PRECISION ||
+            lon < -180*COORDINATE_PRECISION
+        ) {
             return false;
         }
         return true;
@@ -64,10 +71,10 @@ inline double ApproximateDistance( const int lat1, const int lon1, const int lat
     assert(lat2 != INT_MIN);
     assert(lon2 != INT_MIN);
     double RAD = 0.017453292519943295769236907684886;
-    double lt1 = lat1/100000.;
+    double lt1 = lat1/COORDINATE_PRECISION;
-    double ln1 = lon1/100000.;
+    double ln1 = lon1/COORDINATE_PRECISION;
-    double lt2 = lat2/100000.;
+    double lt2 = lat2/COORDINATE_PRECISION;
-    double ln2 = lon2/100000.;
+    double ln2 = lon2/COORDINATE_PRECISION;
     double dlat1=lt1*(RAD);
 
     double dlong1=ln1*(RAD);
@@ -96,10 +103,10 @@ inline double ApproximateEuclideanDistance(const _Coordinate &c1, const _Coordin
     assert(c2.lat != INT_MIN);
     assert(c2.lon != INT_MIN);
     const double RAD = 0.017453292519943295769236907684886;
-    const double lat1 = (c1.lat/100000.)*RAD;
+    const double lat1 = (c1.lat/COORDINATE_PRECISION)*RAD;
-    const double lon1 = (c1.lon/100000.)*RAD;
+    const double lon1 = (c1.lon/COORDINATE_PRECISION)*RAD;
-    const double lat2 = (c2.lat/100000.)*RAD;
+    const double lat2 = (c2.lat/COORDINATE_PRECISION)*RAD;
-    const double lon2 = (c2.lon/100000.)*RAD;
+    const double lon2 = (c2.lon/COORDINATE_PRECISION)*RAD;
 
     const double x = (lon2-lon1) * cos((lat1+lat2)/2.);
     const double y = (lat2-lat1);
@@ -111,7 +118,7 @@ inline double ApproximateEuclideanDistance(const _Coordinate &c1, const _Coordin
 static inline void convertInternalLatLonToString(const int value, std::string & output) {
     char buffer[100];
     buffer[10] = 0; // Nullterminierung
-    char* string = printInt< 10, 5 >( buffer, value );
+    char* string = printInt< 10, 6 >( buffer, value );
     output = string;
 }
 

DataStructures/HilbertValue.h

@@ -21,6 +21,8 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #ifndef HILBERTVALUE_H_
 #define HILBERTVALUE_H_
 
+#include "Coordinate.h"
+
 #include <boost/integer.hpp>
 #include <boost/noncopyable.hpp>
 
@@ -31,8 +33,8 @@ public:
 	static uint64_t GetHilbertNumberForCoordinate(
 			const _Coordinate & current_coordinate) {
 		unsigned location[2];
-		location[0] = current_coordinate.lat+( 90*100000);
+		location[0] = current_coordinate.lat+( 90*COORDINATE_PRECISION);
-		location[1] = current_coordinate.lon+(180*100000);
+		location[1] = current_coordinate.lon+(180*COORDINATE_PRECISION);
 
 		TransposeCoordinate(location);
 		const uint64_t result = BitInterleaving(location[0], location[1]);

DataStructures/NodeCoords.h

@@ -21,6 +21,7 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #ifndef _NODE_COORDS_H
 #define _NODE_COORDS_H
 
+#include "Coordinate.h"
 #include "../typedefs.h"
 
 #include <cassert>
@@ -41,10 +42,10 @@ struct NodeCoords {
 	NodeT id;
 
 	static NodeCoords<NodeT> min_value() {
-		return NodeCoords<NodeT>(-90*100000,-180*100000,std::numeric_limits<NodeT>::min());
+		return NodeCoords<NodeT>(-90*COORDINATE_PRECISION,-180*COORDINATE_PRECISION,std::numeric_limits<NodeT>::min());
 	}
 	static NodeCoords<NodeT> max_value() {
-		return NodeCoords<NodeT>(90*100000, 180*100000, std::numeric_limits<NodeT>::max());
+		return NodeCoords<NodeT>(90*COORDINATE_PRECISION, 180*COORDINATE_PRECISION, std::numeric_limits<NodeT>::max());
 	}
 
 	value_type operator[](std::size_t n) const {

DataStructures/StaticRTree.h

@@ -220,10 +220,10 @@ private:
             std::ostream & out,
             const RectangleInt2D & rect
         ) {
-            out << rect.min_lat/100000. << ","
+            out << rect.min_lat/COORDINATE_PRECISION << ","
-                << rect.min_lon/100000. << " "
+                << rect.min_lon/COORDINATE_PRECISION << " "
-                << rect.max_lat/100000. << ","
+                << rect.max_lat/COORDINATE_PRECISION << ","
-                << rect.max_lon/100000.;
+                << rect.max_lon/COORDINATE_PRECISION;
             return out;
         }
     };
@@ -298,7 +298,7 @@ public:
             //Get Hilbert-Value for centroid in mercartor projection
             DataT & current_element = input_data_vector[element_counter];
             _Coordinate current_centroid = current_element.Centroid();
-            current_centroid.lat = 100000*lat2y(current_centroid.lat/100000.);
+            current_centroid.lat = COORDINATE_PRECISION*lat2y(current_centroid.lat/COORDINATE_PRECISION);
 
             uint64_t current_hilbert_value = HilbertCode::GetHilbertNumberForCoordinate(current_centroid);
             input_wrapper_vector[element_counter].m_hilbert_value = current_hilbert_value;

Descriptors/DescriptionFactory.cpp

@@ -33,10 +33,10 @@ inline double DescriptionFactory::RadianToDegree(const double radian) const {
 }
 
 double DescriptionFactory::GetBearing(const _Coordinate& A, const _Coordinate& B) const {
-    double deltaLong = DegreeToRadian(B.lon/100000. - A.lon/100000.);
+    double deltaLong = DegreeToRadian(B.lon/COORDINATE_PRECISION - A.lon/COORDINATE_PRECISION);
 
-    double lat1 = DegreeToRadian(A.lat/100000.);
+    double lat1 = DegreeToRadian(A.lat/COORDINATE_PRECISION);
-    double lat2 = DegreeToRadian(B.lat/100000.);
+    double lat2 = DegreeToRadian(B.lat/COORDINATE_PRECISION);
 
     double y = sin(deltaLong) * cos(lat2);
     double x = cos(lat1) * sin(lat2) - sin(lat1) * cos(lat2) * cos(deltaLong);

Extractor/ExtractorCallbacks.cpp

@@ -31,7 +31,7 @@ ExtractorCallbacks::~ExtractorCallbacks() { }
 
 /** warning: caller needs to take care of synchronization! */
 void ExtractorCallbacks::nodeFunction(const _Node &n) {
-    if(n.lat <= 85*100000 && n.lat >= -85*100000) {
+    if(n.lat <= 85*COORDINATE_PRECISION && n.lat >= -85*COORDINATE_PRECISION) {
         externalMemory->allNodes.push_back(n);
     }
 }

Extractor/ExtractorCallbacks.h

@@ -34,6 +34,8 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include "ExtractionHelperFunctions.h"
 #include "ExtractorStructs.h"
 
+#include "../DataStructures/Coordinate.h"
+
 class ExtractorCallbacks{
 private:
     StringMap * stringMap;

Extractor/PBFParser.cpp

@@ -166,8 +166,8 @@ inline void PBFParser::parseDenseNode(_ThreadData * threadData) {
 		m_lastDenseLatitude += dense.lat( i );
 		m_lastDenseLongitude += dense.lon( i );
 		extracted_nodes_vector[i].id = m_lastDenseID;
-		extracted_nodes_vector[i].lat = 100000*( ( double ) m_lastDenseLatitude * threadData->PBFprimitiveBlock.granularity() + threadData->PBFprimitiveBlock.lat_offset() ) / NANO;
+		extracted_nodes_vector[i].lat = COORDINATE_PRECISION*( ( double ) m_lastDenseLatitude * threadData->PBFprimitiveBlock.granularity() + threadData->PBFprimitiveBlock.lat_offset() ) / NANO;
-		extracted_nodes_vector[i].lon = 100000*( ( double ) m_lastDenseLongitude * threadData->PBFprimitiveBlock.granularity() + threadData->PBFprimitiveBlock.lon_offset() ) / NANO;
+		extracted_nodes_vector[i].lon = COORDINATE_PRECISION*( ( double ) m_lastDenseLongitude * threadData->PBFprimitiveBlock.granularity() + threadData->PBFprimitiveBlock.lon_offset() ) / NANO;
 		while (denseTagIndex < dense.keys_vals_size()) {
 			const int tagValue = dense.keys_vals( denseTagIndex );
 			if( 0==tagValue ) {

Extractor/PBFParser.h

@@ -23,6 +23,7 @@
 
 #include "BaseParser.h"
 
+#include "../DataStructures/Coordinate.h"
 #include "../DataStructures/HashTable.h"
 #include "../DataStructures/ConcurrentQueue.h"
 #include "../Util/MachineInfo.h"

Extractor/XMLParser.cpp

@@ -217,12 +217,12 @@ ImportNode XMLParser::_ReadXMLNode() {
 
 	xmlChar* attribute = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "lat" );
 	if ( attribute != NULL ) {
-		node.lat =  static_cast<NodeID>(100000.*atof(( const char* ) attribute ) );
+		node.lat =  static_cast<NodeID>(COORDINATE_PRECISION*atof(( const char* ) attribute ) );
 		xmlFree( attribute );
 	}
 	attribute = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "lon" );
 	if ( attribute != NULL ) {
-		node.lon =  static_cast<NodeID>(100000.*atof(( const char* ) attribute ));
+		node.lon =  static_cast<NodeID>(COORDINATE_PRECISION*atof(( const char* ) attribute ));
 		xmlFree( attribute );
 	}
 	attribute = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "id" );

Extractor/XMLParser.h

@@ -22,6 +22,7 @@
 #define XMLPARSER_H_
 
 #include "BaseParser.h"
+#include "../DataStructures/Coordinate.h"
 #include "../Util/StringUtil.h"
 #include "../typedefs.h"
 

Plugins/BasePlugin.h

@@ -22,6 +22,7 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #define BASEPLUGIN_H_
 
 #include "RouteParameters.h"
+#include "../DataStructures/Coordinate.h"
 #include "../Server/BasicDatastructures.h"
 
 #include <string>

Plugins/HelloWorldPlugin.h

@@ -35,7 +35,7 @@ public:
         content << "language: " << routeParameters.language << "<br>";
         content << "Number of locations: " << routeParameters.coordinates.size() << "\n";
         for(unsigned i = 0; i < routeParameters.coordinates.size(); ++i) {
-            content << "  [" << i << "] " << routeParameters.coordinates[i].lat/100000. << "," << routeParameters.coordinates[i].lon/100000. << "\n";
+            content << "  [" << i << "] " << routeParameters.coordinates[i].lat/COORDINATE_PRECISION << "," << routeParameters.coordinates[i].lon/COORDINATE_PRECISION << "\n";
         }
         content << "Number of hints: " << routeParameters.hints.size() << "\n";
         for(unsigned i = 0; i < routeParameters.hints.size(); ++i) {

Plugins/LocatePlugin.h

@@ -101,7 +101,12 @@ public:
     }
 private:
     inline bool checkCoord(const _Coordinate & c) {
-        if(c.lat > 90*100000 || c.lat < -90*100000 || c.lon > 180*100000 || c.lon <-180*100000) {
+        if(
+            c.lat >   90*COORDINATE_PRECISION ||
+            c.lat <  -90*COORDINATE_PRECISION ||
+            c.lon >  180*COORDINATE_PRECISION ||
+            c.lon < -180*COORDINATE_PRECISION
+        ) {
             return false;
         }
         return true;

Plugins/NearestPlugin.h

@@ -109,7 +109,12 @@ public:
     }
 private:
     inline bool checkCoord(const _Coordinate & c) {
-        if(c.lat > 90*100000 || c.lat < -90*100000 || c.lon > 180*100000 || c.lon <-180*100000) {
+        if(
+            c.lat >   90*COORDINATE_PRECISION ||
+            c.lat <  -90*COORDINATE_PRECISION ||
+            c.lon >  180*COORDINATE_PRECISION ||
+            c.lon < -180*COORDINATE_PRECISION
+        ) {
             return false;
         }
         return true;

Plugins/RouteParameters.h

@@ -106,9 +106,8 @@ struct RouteParameters {
     }
 
     void addCoordinate(boost::fusion::vector < double, double > arg_) {
-        int lat = 100000.*boost::fusion::at_c < 0 > (arg_);
+        int lat = COORDINATE_PRECISION*boost::fusion::at_c < 0 > (arg_);
-        int lon = 100000.*boost::fusion::at_c < 1 > (arg_);
+        int lon = COORDINATE_PRECISION*boost::fusion::at_c < 1 > (arg_);
-        _Coordinate myCoordinate(lat, lon);
         coordinates.push_back(_Coordinate(lat, lon));
     }
 };

Plugins/ViaRoutePlugin.h

@@ -201,7 +201,6 @@ public:
                 reply.headers[2].name = "Content-Disposition";
                 reply.headers[2].value = "attachment; filename=\"route.json\"";
             }
-
             break;
         }
 
@@ -210,7 +209,12 @@ public:
     }
 private:
     inline bool checkCoord(const _Coordinate & c) {
-        if(c.lat > 90*100000 || c.lat < -90*100000 || c.lon > 180*100000 || c.lon <-180*100000) {
+        if(
+            c.lat >   90*COORDINATE_PRECISION ||
+            c.lat <  -90*COORDINATE_PRECISION ||
+            c.lon >  180*COORDINATE_PRECISION ||
+            c.lon < -180*COORDINATE_PRECISION
+        ) {
             return false;
         }
         return true;

Tools/simpleclient.cpp

@@ -62,8 +62,8 @@ int main (int argc, char * argv[]) {
     route_parameters.language = ""; //unused atm
     //route_parameters.hints.push_back(); // see wiki, saves I/O if done properly
 
-    _Coordinate start_coordinate(52.519930*100000,13.438640*100000);
+    _Coordinate start_coordinate(52.519930*1000000,13.438640*1000000);
-    _Coordinate target_coordinate(52.513191*100000,13.415852*100000);
+    _Coordinate target_coordinate(52.513191*1000000,13.415852*1000000);
     route_parameters.coordinates.push_back(start_coordinate);
     route_parameters.coordinates.push_back(target_coordinate);