Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

rename coordinate calculation functions, remove code clutter

Browse Source
This commit is contained in:
Dennis Luxen 2015-01-22 16:28:40 +01:00
parent 547a2aec09
commit 3fa12445a5
7 changed files with 72 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
data_structures/coordinate_calculation.cpp
View File

@ -42,7 +42,7 @@ constexpr static const float RAD = 0.017453292519943295769236907684886;
constexpr static const float earth_radius = 6372797.560856f; constexpr static const float earth_radius = 6372797.560856f;
} }
double coordinate_calculation::ApproximateDistance(const int lat1, double coordinate_calculation::great_circle_distance(const int lat1,
const int lon1, const int lon1,
const int lat2, const int lat2,
const int lon2) const int lon2)
@ -51,41 +51,41 @@ double coordinate_calculation::ApproximateDistance(const int lat1,
BOOST_ASSERT(lon1 != std::numeric_limits<int>::min()); BOOST_ASSERT(lon1 != std::numeric_limits<int>::min());
BOOST_ASSERT(lat2 != std::numeric_limits<int>::min()); BOOST_ASSERT(lat2 != std::numeric_limits<int>::min());
BOOST_ASSERT(lon2 != std::numeric_limits<int>::min()); BOOST_ASSERT(lon2 != std::numeric_limits<int>::min());
double lt1 = lat1 / COORDINATE_PRECISION; const double lt1 = lat1 / COORDINATE_PRECISION;
double ln1 = lon1 / COORDINATE_PRECISION; const double ln1 = lon1 / COORDINATE_PRECISION;
double lt2 = lat2 / COORDINATE_PRECISION; const double lt2 = lat2 / COORDINATE_PRECISION;
double ln2 = lon2 / COORDINATE_PRECISION; const double ln2 = lon2 / COORDINATE_PRECISION;
double dlat1 = lt1 * (RAD); const double dlat1 = lt1 * (RAD);
double dlong1 = ln1 * (RAD); const double dlong1 = ln1 * (RAD);
double dlat2 = lt2 * (RAD); const double dlat2 = lt2 * (RAD);
double dlong2 = ln2 * (RAD); const double dlong2 = ln2 * (RAD);
double dLong = dlong1 - dlong2; const double dLong = dlong1 - dlong2;
double dLat = dlat1 - dlat2; const double dLat = dlat1 - dlat2;
double aHarv = pow(sin(dLat / 2.0), 2.0) + cos(dlat1) * cos(dlat2) * pow(sin(dLong / 2.), 2); const double aHarv = pow(sin(dLat / 2.0), 2.0) + cos(dlat1) * cos(dlat2) * pow(sin(dLong / 2.), 2);
double cHarv = 2. * atan2(sqrt(aHarv), sqrt(1.0 - aHarv)); const double cHarv = 2. * atan2(sqrt(aHarv), sqrt(1.0 - aHarv));
// earth radius varies between 6,356.750-6,378.135 km (3,949.901-3,963.189mi) // earth radius varies between 6,356.750-6,378.135 km (3,949.901-3,963.189mi)
// The IUGG value for the equatorial radius is 6378.137 km (3963.19 miles) // The IUGG value for the equatorial radius is 6378.137 km (3963.19 miles)
return earth_radius * cHarv; return earth_radius * cHarv;
} }
double coordinate_calculation::ApproximateDistance(const FixedPointCoordinate &coordinate_1, double coordinate_calculation::great_circle_distance(const FixedPointCoordinate &coordinate_1,
const FixedPointCoordinate &coordinate_2) const FixedPointCoordinate &coordinate_2)
{ {
return ApproximateDistance(coordinate_1.lat, coordinate_1.lon, coordinate_2.lat, return great_circle_distance(coordinate_1.lat, coordinate_1.lon, coordinate_2.lat,
coordinate_2.lon); coordinate_2.lon);
} }
float coordinate_calculation::approx_euclidean_distance(const FixedPointCoordinate &coordinate_1, float coordinate_calculation::euclidean_distance(const FixedPointCoordinate &coordinate_1,
const FixedPointCoordinate &coordinate_2) const FixedPointCoordinate &coordinate_2)
{ {
return approx_euclidean_distance(coordinate_1.lat, coordinate_1.lon, coordinate_2.lat, return euclidean_distance(coordinate_1.lat, coordinate_1.lon, coordinate_2.lat,
coordinate_2.lon); coordinate_2.lon);
} }
float coordinate_calculation::approx_euclidean_distance(const int lat1, float coordinate_calculation::euclidean_distance(const int lat1,
const int lon1, const int lon1,
const int lat2, const int lat2,
const int lon2) const int lon2)
@ -217,7 +217,7 @@ float coordinate_calculation::perpendicular_distance_from_projected_coordinate(
BOOST_ASSERT(nearest_location.is_valid()); BOOST_ASSERT(nearest_location.is_valid());
const float approximate_distance = const float approximate_distance =
coordinate_calculation::approx_euclidean_distance(query_location, nearest_location); coordinate_calculation::euclidean_distance(query_location, nearest_location);
BOOST_ASSERT(0. <= approximate_distance); BOOST_ASSERT(0. <= approximate_distance);
return approximate_distance; return approximate_distance;
} }

11
data_structures/coordinate_calculation.hpp
View File

@ -37,19 +37,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
struct coordinate_calculation struct coordinate_calculation
{ {
static double static double
ApproximateDistance(const int lat1, const int lon1, const int lat2, const int lon2); great_circle_distance(const int lat1, const int lon1, const int lat2, const int lon2);
static double ApproximateDistance(const FixedPointCoordinate &first_coordinate, static double great_circle_distance(const FixedPointCoordinate &first_coordinate,
const FixedPointCoordinate &second_coordinate); const FixedPointCoordinate &second_coordinate);
static float approx_euclidean_distance(const FixedPointCoordinate &first_coordinate, static float euclidean_distance(const FixedPointCoordinate &first_coordinate,
const FixedPointCoordinate &second_coordinate); const FixedPointCoordinate &second_coordinate);
static float static float
approx_euclidean_distance(const int lat1, const int lon1, const int lat2, const int lon2); euclidean_distance(const int lat1, const int lon1, const int lat2, const int lon2);
static float ApproximateSquaredEuclideanDistance(const FixedPointCoordinate &first_coordinate,
const FixedPointCoordinate &second_coordinate);
static void lat_or_lon_to_string(const int value, std::string &output); static void lat_or_lon_to_string(const int value, std::string &output);

32
data_structures/rectangle.hpp
View File

@ -117,28 +117,28 @@ struct RectangleInt2D
switch (d) switch (d)
{ {
case NORTH: case NORTH:
min_dist = coordinate_calculation::approx_euclidean_distance(location, FixedPointCoordinate(max_lat, location.lon)); min_dist = coordinate_calculation::euclidean_distance(location, FixedPointCoordinate(max_lat, location.lon));
break; break;
case SOUTH: case SOUTH:
min_dist = coordinate_calculation::approx_euclidean_distance(location, FixedPointCoordinate(min_lat, location.lon)); min_dist = coordinate_calculation::euclidean_distance(location, FixedPointCoordinate(min_lat, location.lon));
break; break;
case WEST: case WEST:
min_dist = coordinate_calculation::approx_euclidean_distance(location, FixedPointCoordinate(location.lat, min_lon)); min_dist = coordinate_calculation::euclidean_distance(location, FixedPointCoordinate(location.lat, min_lon));
break; break;
case EAST: case EAST:
min_dist = coordinate_calculation::approx_euclidean_distance(location, FixedPointCoordinate(location.lat, max_lon)); min_dist = coordinate_calculation::euclidean_distance(location, FixedPointCoordinate(location.lat, max_lon));
break; break;
case NORTH_EAST: case NORTH_EAST:
min_dist = coordinate_calculation::approx_euclidean_distance(location, FixedPointCoordinate(max_lat, max_lon)); min_dist = coordinate_calculation::euclidean_distance(location, FixedPointCoordinate(max_lat, max_lon));
break; break;
case NORTH_WEST: case NORTH_WEST:
min_dist = coordinate_calculation::approx_euclidean_distance(location, FixedPointCoordinate(max_lat, min_lon)); min_dist = coordinate_calculation::euclidean_distance(location, FixedPointCoordinate(max_lat, min_lon));
break; break;
case SOUTH_EAST: case SOUTH_EAST:
min_dist = coordinate_calculation::approx_euclidean_distance(location, FixedPointCoordinate(min_lat, max_lon)); min_dist = coordinate_calculation::euclidean_distance(location, FixedPointCoordinate(min_lat, max_lon));
break; break;
case SOUTH_WEST: case SOUTH_WEST:
min_dist = coordinate_calculation::approx_euclidean_distance(location, FixedPointCoordinate(min_lat, min_lon)); min_dist = coordinate_calculation::euclidean_distance(location, FixedPointCoordinate(min_lat, min_lon));
break; break;
default: default:
break; break;
@ -161,24 +161,24 @@ struct RectangleInt2D
min_max_dist = std::min( min_max_dist = std::min(
min_max_dist, min_max_dist,
std::max( std::max(
coordinate_calculation::approx_euclidean_distance(location, upper_left), coordinate_calculation::euclidean_distance(location, upper_left),
coordinate_calculation::approx_euclidean_distance(location, upper_right))); coordinate_calculation::euclidean_distance(location, upper_right)));
min_max_dist = std::min( min_max_dist = std::min(
min_max_dist, min_max_dist,
std::max( std::max(
coordinate_calculation::approx_euclidean_distance(location, upper_right), coordinate_calculation::euclidean_distance(location, upper_right),
coordinate_calculation::approx_euclidean_distance(location, lower_right))); coordinate_calculation::euclidean_distance(location, lower_right)));
min_max_dist = std::min( min_max_dist = std::min(
min_max_dist, min_max_dist,
std::max(coordinate_calculation::approx_euclidean_distance(location, lower_right), std::max(coordinate_calculation::euclidean_distance(location, lower_right),
coordinate_calculation::approx_euclidean_distance(location, lower_left))); coordinate_calculation::euclidean_distance(location, lower_left)));
min_max_dist = std::min( min_max_dist = std::min(
min_max_dist, min_max_dist,
std::max(coordinate_calculation::approx_euclidean_distance(location, lower_left), std::max(coordinate_calculation::euclidean_distance(location, lower_left),
coordinate_calculation::approx_euclidean_distance(location, upper_left))); coordinate_calculation::euclidean_distance(location, upper_left)));
return min_max_dist; return min_max_dist;
} }

40
data_structures/static_rtree.hpp
View File

@ -177,28 +177,28 @@ class StaticRTree
switch (d) switch (d)
{ {
case NORTH: case NORTH:
min_dist = coordinate_calculation::approx_euclidean_distance(location, FixedPointCoordinate(max_lat, location.lon)); min_dist = coordinate_calculation::euclidean_distance(location, FixedPointCoordinate(max_lat, location.lon));
break; break;
case SOUTH: case SOUTH:
min_dist = coordinate_calculation::approx_euclidean_distance(location, FixedPointCoordinate(min_lat, location.lon)); min_dist = coordinate_calculation::euclidean_distance(location, FixedPointCoordinate(min_lat, location.lon));
break; break;
case WEST: case WEST:
min_dist = coordinate_calculation::approx_euclidean_distance(location, FixedPointCoordinate(location.lat, min_lon)); min_dist = coordinate_calculation::euclidean_distance(location, FixedPointCoordinate(location.lat, min_lon));
break; break;
case EAST: case EAST:
min_dist = coordinate_calculation::approx_euclidean_distance(location, FixedPointCoordinate(location.lat, max_lon)); min_dist = coordinate_calculation::euclidean_distance(location, FixedPointCoordinate(location.lat, max_lon));
break; break;
case NORTH_EAST: case NORTH_EAST:
min_dist = coordinate_calculation::approx_euclidean_distance(location, FixedPointCoordinate(max_lat, max_lon)); min_dist = coordinate_calculation::euclidean_distance(location, FixedPointCoordinate(max_lat, max_lon));
break; break;
case NORTH_WEST: case NORTH_WEST:
min_dist = coordinate_calculation::approx_euclidean_distance(location, FixedPointCoordinate(max_lat, min_lon)); min_dist = coordinate_calculation::euclidean_distance(location, FixedPointCoordinate(max_lat, min_lon));
break; break;
case SOUTH_EAST: case SOUTH_EAST:
min_dist = coordinate_calculation::approx_euclidean_distance(location, FixedPointCoordinate(min_lat, max_lon)); min_dist = coordinate_calculation::euclidean_distance(location, FixedPointCoordinate(min_lat, max_lon));
break; break;
case SOUTH_WEST: case SOUTH_WEST:
min_dist = coordinate_calculation::approx_euclidean_distance(location, FixedPointCoordinate(min_lat, min_lon)); min_dist = coordinate_calculation::euclidean_distance(location, FixedPointCoordinate(min_lat, min_lon));
break; break;
default: default:
break; break;
@ -221,24 +221,24 @@ class StaticRTree
min_max_dist = std::min( min_max_dist = std::min(
min_max_dist, min_max_dist,
std::max( std::max(
coordinate_calculation::approx_euclidean_distance(location, upper_left), coordinate_calculation::euclidean_distance(location, upper_left),
coordinate_calculation::approx_euclidean_distance(location, upper_right))); coordinate_calculation::euclidean_distance(location, upper_right)));
min_max_dist = std::min( min_max_dist = std::min(
min_max_dist, min_max_dist,
std::max( std::max(
coordinate_calculation::approx_euclidean_distance(location, upper_right), coordinate_calculation::euclidean_distance(location, upper_right),
coordinate_calculation::approx_euclidean_distance(location, lower_right))); coordinate_calculation::euclidean_distance(location, lower_right)));
min_max_dist = std::min( min_max_dist = std::min(
min_max_dist, min_max_dist,
std::max(coordinate_calculation::approx_euclidean_distance(location, lower_right), std::max(coordinate_calculation::euclidean_distance(location, lower_right),
coordinate_calculation::approx_euclidean_distance(location, lower_left))); coordinate_calculation::euclidean_distance(location, lower_left)));
min_max_dist = std::min( min_max_dist = std::min(
min_max_dist, min_max_dist,
std::max(coordinate_calculation::approx_euclidean_distance(location, lower_left), std::max(coordinate_calculation::euclidean_distance(location, lower_left),
coordinate_calculation::approx_euclidean_distance(location, upper_left))); coordinate_calculation::euclidean_distance(location, upper_left)));
return min_max_dist; return min_max_dist;
} }
@ -607,7 +607,7 @@ class StaticRTree
} }
float current_minimum_distance = float current_minimum_distance =
coordinate_calculation::approx_euclidean_distance( coordinate_calculation::euclidean_distance(
input_coordinate.lat, input_coordinate.lat,
input_coordinate.lon, input_coordinate.lon,
m_coordinate_list->at(current_edge.u).lat, m_coordinate_list->at(current_edge.u).lat,
@ -620,7 +620,7 @@ class StaticRTree
} }
current_minimum_distance = current_minimum_distance =
coordinate_calculation::approx_euclidean_distance( coordinate_calculation::euclidean_distance(
input_coordinate.lat, input_coordinate.lat,
input_coordinate.lon, input_coordinate.lon,
m_coordinate_list->at(current_edge.v).lat, m_coordinate_list->at(current_edge.v).lat,
@ -1060,9 +1060,9 @@ class StaticRTree
inline void SetForwardAndReverseWeightsOnPhantomNode(const EdgeDataT & nearest_edge, inline void SetForwardAndReverseWeightsOnPhantomNode(const EdgeDataT & nearest_edge,
PhantomNode &result_phantom_node) const PhantomNode &result_phantom_node) const
{ {
const float distance_1 = coordinate_calculation::approx_euclidean_distance( const float distance_1 = coordinate_calculation::euclidean_distance(
m_coordinate_list->at(nearest_edge.u), result_phantom_node.location); m_coordinate_list->at(nearest_edge.u), result_phantom_node.location);
const float distance_2 = coordinate_calculation::approx_euclidean_distance( const float distance_2 = coordinate_calculation::euclidean_distance(
m_coordinate_list->at(nearest_edge.u), m_coordinate_list->at(nearest_edge.v)); m_coordinate_list->at(nearest_edge.u), m_coordinate_list->at(nearest_edge.v));
const float ratio = std::min(1.f, distance_1 / distance_2); const float ratio = std::min(1.f, distance_1 / distance_2);

2
descriptors/description_factory.cpp
View File

@ -135,7 +135,7 @@ void DescriptionFactory::Run(const unsigned zoom_level)
{ {
// move down names by one, q&d hack // move down names by one, q&d hack
path_description[i - 1].name_id = path_description[i].name_id; path_description[i - 1].name_id = path_description[i].name_id;
path_description[i].length = coordinate_calculation::approx_euclidean_distance( path_description[i].length = coordinate_calculation::euclidean_distance(
path_description[i - 1].location, path_description[i].location); path_description[i - 1].location, path_description[i].location);
} }

2
extractor/extraction_containers.cpp
View File

@ -321,7 +321,7 @@ void ExtractionContainers::PrepareData(const std::string &output_file_name,
edge_iterator->target_coordinate.lat = node_iterator->lat; edge_iterator->target_coordinate.lat = node_iterator->lat;
edge_iterator->target_coordinate.lon = node_iterator->lon; edge_iterator->target_coordinate.lon = node_iterator->lon;
const double distance = coordinate_calculation::approx_euclidean_distance( const double distance = coordinate_calculation::euclidean_distance(
edge_iterator->source_coordinate.lat, edge_iterator->source_coordinate.lon, edge_iterator->source_coordinate.lat, edge_iterator->source_coordinate.lon,
node_iterator->lat, node_iterator->lon); node_iterator->lat, node_iterator->lon);

2
tools/components.cpp
View File

@ -244,7 +244,7 @@ int main(int argc, char *argv[])
if (source < target || graph->EndEdges(target) == graph->FindEdge(target, source)) if (source < target || graph->EndEdges(target) == graph->FindEdge(target, source))
{ {
total_network_distance += total_network_distance +=
100 * coordinate_calculation::approx_euclidean_distance( 100 * coordinate_calculation::euclidean_distance(
coordinate_list[source].lat, coordinate_list[source].lat,
coordinate_list[source].lon, coordinate_list[source].lon,
coordinate_list[target].lat, coordinate_list[target].lat,