diff --git a/Algorithms/StronglyConnectedComponents.h b/Algorithms/StronglyConnectedComponents.h
index 4ef81e90f..c688a050b 100644
--- a/Algorithms/StronglyConnectedComponents.h
+++ b/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[v].lon/100000., inputNodeInfoList[v].lat/100000.);
+                        lineString.addPoint(inputNodeInfoList[u].lon/COORDINATE_PRECISION, inputNodeInfoList[u].lat/COORDINATE_PRECISION);
+                        lineString.addPoint(inputNodeInfoList[v].lon/COORDINATE_PRECISION, inputNodeInfoList[v].lat/COORDINATE_PRECISION);
                         OGRFeature *poFeature;
                         poFeature = OGRFeature::CreateFeature( poLayer->GetLayerDefn() );
                         poFeature->SetGeometry( &lineString );
diff --git a/Contractor/EdgeBasedGraphFactory.cpp b/Contractor/EdgeBasedGraphFactory.cpp
index 13f49ecb7..9443c24e4 100644
--- a/Contractor/EdgeBasedGraphFactory.cpp
+++ b/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 v1y = lat2y(A.lat/100000.) - lat2y(C.lat/100000.);
-    const double v2x = (B.lon - C.lon)/100000.;
-    const double v2y = lat2y(B.lat/100000.) - lat2y(C.lat/100000.);
+    const double v1x = (A.lon - C.lon)/COORDINATE_PRECISION;
+    const double v1y = lat2y(A.lat/COORDINATE_PRECISION) - lat2y(C.lat/COORDINATE_PRECISION);
+    const double v2x = (B.lon - C.lon)/COORDINATE_PRECISION;
+    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)
diff --git a/DataStructures/Coordinate.h b/DataStructures/Coordinate.h
index 68219d5a1..47008d65f 100644
--- a/DataStructures/Coordinate.h
+++ b/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 ln1 = lon1/100000.;
-    double lt2 = lat2/100000.;
-    double ln2 = lon2/100000.;
+    double lt1 = lat1/COORDINATE_PRECISION;
+    double ln1 = lon1/COORDINATE_PRECISION;
+    double lt2 = lat2/COORDINATE_PRECISION;
+    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 lon1 = (c1.lon/100000.)*RAD;
-    const double lat2 = (c2.lat/100000.)*RAD;
-    const double lon2 = (c2.lon/100000.)*RAD;
+    const double lat1 = (c1.lat/COORDINATE_PRECISION)*RAD;
+    const double lon1 = (c1.lon/COORDINATE_PRECISION)*RAD;
+    const double lat2 = (c2.lat/COORDINATE_PRECISION)*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;
 }
 
diff --git a/DataStructures/HilbertValue.h b/DataStructures/HilbertValue.h
index 05e2bb15f..8b64a505b 100644
--- a/DataStructures/HilbertValue.h
+++ b/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[1] = current_coordinate.lon+(180*100000);
+		location[0] = current_coordinate.lat+( 90*COORDINATE_PRECISION);
+		location[1] = current_coordinate.lon+(180*COORDINATE_PRECISION);
 
 		TransposeCoordinate(location);
 		const uint64_t result = BitInterleaving(location[0], location[1]);
diff --git a/DataStructures/NodeCoords.h b/DataStructures/NodeCoords.h
index 80fda42b8..c2f62430b 100644
--- a/DataStructures/NodeCoords.h
+++ b/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 {
diff --git a/DataStructures/StaticRTree.h b/DataStructures/StaticRTree.h
index 3e598f3e4..34f9fd00b 100644
--- a/DataStructures/StaticRTree.h
+++ b/DataStructures/StaticRTree.h
@@ -220,10 +220,10 @@ private:
             std::ostream & out,
             const RectangleInt2D & rect
         ) {
-            out << rect.min_lat/100000. << ","
-                << rect.min_lon/100000. << " "
-                << rect.max_lat/100000. << ","
-                << rect.max_lon/100000.;
+            out << rect.min_lat/COORDINATE_PRECISION << ","
+                << rect.min_lon/COORDINATE_PRECISION << " "
+                << rect.max_lat/COORDINATE_PRECISION << ","
+                << 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;
diff --git a/Descriptors/DescriptionFactory.cpp b/Descriptors/DescriptionFactory.cpp
index 63e8883eb..e027c3704 100644
--- a/Descriptors/DescriptionFactory.cpp
+++ b/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 lat2 = DegreeToRadian(B.lat/100000.);
+    double lat1 = DegreeToRadian(A.lat/COORDINATE_PRECISION);
+    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);
diff --git a/Extractor/ExtractorCallbacks.cpp b/Extractor/ExtractorCallbacks.cpp
index db8e8f8f9..8c28f855d 100644
--- a/Extractor/ExtractorCallbacks.cpp
+++ b/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);
     }
 }
diff --git a/Extractor/ExtractorCallbacks.h b/Extractor/ExtractorCallbacks.h
index 3e9fcddf5..0ba78c709 100644
--- a/Extractor/ExtractorCallbacks.h
+++ b/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;
diff --git a/Extractor/PBFParser.cpp b/Extractor/PBFParser.cpp
index 1ce5a0231..4f3b40fde 100644
--- a/Extractor/PBFParser.cpp
+++ b/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].lon = 100000*( ( double ) m_lastDenseLongitude * threadData->PBFprimitiveBlock.granularity() + threadData->PBFprimitiveBlock.lon_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 = 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 ) {
diff --git a/Extractor/PBFParser.h b/Extractor/PBFParser.h
index 18c28bed1..edf5cd012 100644
--- a/Extractor/PBFParser.h
+++ b/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"
diff --git a/Extractor/XMLParser.cpp b/Extractor/XMLParser.cpp
index 90590e5e9..6ce834335 100644
--- a/Extractor/XMLParser.cpp
+++ b/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" );
diff --git a/Extractor/XMLParser.h b/Extractor/XMLParser.h
index d17230dfe..39070f470 100644
--- a/Extractor/XMLParser.h
+++ b/Extractor/XMLParser.h
@@ -22,6 +22,7 @@
 #define XMLPARSER_H_
 
 #include "BaseParser.h"
+#include "../DataStructures/Coordinate.h"
 #include "../Util/StringUtil.h"
 #include "../typedefs.h"
 
diff --git a/Plugins/BasePlugin.h b/Plugins/BasePlugin.h
index 954edbf8b..034c848a7 100644
--- a/Plugins/BasePlugin.h
+++ b/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>
diff --git a/Plugins/HelloWorldPlugin.h b/Plugins/HelloWorldPlugin.h
index 6315dad8c..8e755ea8a 100644
--- a/Plugins/HelloWorldPlugin.h
+++ b/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) {
diff --git a/Plugins/LocatePlugin.h b/Plugins/LocatePlugin.h
index f1c7d60ac..7369390a9 100644
--- a/Plugins/LocatePlugin.h
+++ b/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;
diff --git a/Plugins/NearestPlugin.h b/Plugins/NearestPlugin.h
index 0b60225ef..3fa1b7379 100644
--- a/Plugins/NearestPlugin.h
+++ b/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;
diff --git a/Plugins/RouteParameters.h b/Plugins/RouteParameters.h
index 88fd1c260..6c2b1af3b 100644
--- a/Plugins/RouteParameters.h
+++ b/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 lon = 100000.*boost::fusion::at_c < 1 > (arg_);
-        _Coordinate myCoordinate(lat, lon);
+        int lat = COORDINATE_PRECISION*boost::fusion::at_c < 0 > (arg_);
+        int lon = COORDINATE_PRECISION*boost::fusion::at_c < 1 > (arg_);
         coordinates.push_back(_Coordinate(lat, lon));
     }
 };
diff --git a/Plugins/ViaRoutePlugin.h b/Plugins/ViaRoutePlugin.h
index 1bd924ece..72d27dc63 100644
--- a/Plugins/ViaRoutePlugin.h
+++ b/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;
diff --git a/Tools/simpleclient.cpp b/Tools/simpleclient.cpp
index 32dc07a76..74aa8c8f3 100644
--- a/Tools/simpleclient.cpp
+++ b/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 target_coordinate(52.513191*100000,13.415852*100000);
+    _Coordinate start_coordinate(52.519930*1000000,13.438640*1000000);
+    _Coordinate target_coordinate(52.513191*1000000,13.415852*1000000);
     route_parameters.coordinates.push_back(start_coordinate);
     route_parameters.coordinates.push_back(target_coordinate);