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

fix floating point comparison, remove superflous inline keywords

Browse Source
This commit is contained in:
Dennis Luxen 2015-02-10 12:29:52 +01:00
parent b6314e0c73
commit b865bea482
1 changed files with 73 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
data_structures/rectangle.hpp
View File

@ -39,15 +39,17 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// TODO: Make template type, add tests // TODO: Make template type, add tests
struct RectangleInt2D struct RectangleInt2D
{ {
RectangleInt2D() : min_lon(std::numeric_limits<int32_t>::max()), RectangleInt2D()
: min_lon(std::numeric_limits<int32_t>::max()),
max_lon(std::numeric_limits<int32_t>::min()), max_lon(std::numeric_limits<int32_t>::min()),
min_lat(std::numeric_limits<int32_t>::max()), min_lat(std::numeric_limits<int32_t>::max()), max_lat(std::numeric_limits<int32_t>::min())
max_lat(std::numeric_limits<int32_t>::min()) {} {
}
int32_t min_lon, max_lon; int32_t min_lon, max_lon;
int32_t min_lat, max_lat; int32_t min_lat, max_lat;
inline void MergeBoundingBoxes(const RectangleInt2D &other) void MergeBoundingBoxes(const RectangleInt2D &other)
{ {
min_lon = std::min(min_lon, other.min_lon); min_lon = std::min(min_lon, other.min_lon);
max_lon = std::max(max_lon, other.max_lon); max_lon = std::max(max_lon, other.max_lon);
@ -59,7 +61,7 @@ struct RectangleInt2D
BOOST_ASSERT(max_lon != std::numeric_limits<int32_t>::min()); BOOST_ASSERT(max_lon != std::numeric_limits<int32_t>::min());
} }
inline FixedPointCoordinate Centroid() const FixedPointCoordinate Centroid() const
{ {
FixedPointCoordinate centroid; FixedPointCoordinate centroid;
// The coordinates of the midpoints are given by: // The coordinates of the midpoints are given by:
@ -69,7 +71,7 @@ struct RectangleInt2D
return centroid; return centroid;
} }
inline bool Intersects(const RectangleInt2D &other) const bool Intersects(const RectangleInt2D &other) const
{ {
FixedPointCoordinate upper_left(other.max_lat, other.min_lon); FixedPointCoordinate upper_left(other.max_lat, other.min_lon);
FixedPointCoordinate upper_right(other.max_lat, other.max_lon); FixedPointCoordinate upper_right(other.max_lat, other.max_lon);
@ -80,7 +82,7 @@ struct RectangleInt2D
Contains(lower_left)); Contains(lower_left));
} }
inline float GetMinDist(const FixedPointCoordinate &location) const float GetMinDist(const FixedPointCoordinate &location) const
{ {
const bool is_contained = Contains(location); const bool is_contained = Contains(location);
if (is_contained) if (is_contained)
@ -103,13 +105,13 @@ struct RectangleInt2D
Direction d = INVALID; Direction d = INVALID;
if (location.lat > max_lat) if (location.lat > max_lat)
d = (Direction) (d | NORTH); d = (Direction)(d | NORTH);
else if (location.lat < min_lat) else if (location.lat < min_lat)
d = (Direction) (d | SOUTH); d = (Direction)(d | SOUTH);
if (location.lon > max_lon) if (location.lon > max_lon)
d = (Direction) (d | EAST); d = (Direction)(d | EAST);
else if (location.lon < min_lon) else if (location.lon < min_lon)
d = (Direction) (d | WEST); d = (Direction)(d | WEST);
BOOST_ASSERT(d != INVALID); BOOST_ASSERT(d != INVALID);
@ -117,39 +119,47 @@ struct RectangleInt2D
switch (d) switch (d)
{ {
case NORTH: case NORTH:
min_dist = coordinate_calculation::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::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::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::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::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::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::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::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;
} }
BOOST_ASSERT(min_dist != std::numeric_limits<float>::max()); BOOST_ASSERT(min_dist < std::numeric_limits<float>::max());
return min_dist; return min_dist;
} }
inline float GetMinMaxDist(const FixedPointCoordinate &location) const float GetMinMaxDist(const FixedPointCoordinate &location) const
{ {
float min_max_dist = std::numeric_limits<float>::max(); float min_max_dist = std::numeric_limits<float>::max();
// Get minmax distance to each of the four sides // Get minmax distance to each of the four sides
@ -158,38 +168,36 @@ struct RectangleInt2D
const FixedPointCoordinate lower_right(min_lat, max_lon); const FixedPointCoordinate lower_right(min_lat, max_lon);
const FixedPointCoordinate lower_left(min_lat, min_lon); const FixedPointCoordinate lower_left(min_lat, min_lon);
min_max_dist = std::min( min_max_dist =
min_max_dist, std::min(min_max_dist,
std::max( std::max(coordinate_calculation::euclidean_distance(location, upper_left),
coordinate_calculation::euclidean_distance(location, upper_left),
coordinate_calculation::euclidean_distance(location, upper_right))); coordinate_calculation::euclidean_distance(location, upper_right)));
min_max_dist = std::min( min_max_dist =
min_max_dist, std::min(min_max_dist,
std::max( std::max(coordinate_calculation::euclidean_distance(location, upper_right),
coordinate_calculation::euclidean_distance(location, upper_right),
coordinate_calculation::euclidean_distance(location, lower_right))); coordinate_calculation::euclidean_distance(location, lower_right)));
min_max_dist = std::min( min_max_dist =
min_max_dist, std::min(min_max_dist,
std::max(coordinate_calculation::euclidean_distance(location, lower_right), std::max(coordinate_calculation::euclidean_distance(location, lower_right),
coordinate_calculation::euclidean_distance(location, lower_left))); coordinate_calculation::euclidean_distance(location, lower_left)));
min_max_dist = std::min( min_max_dist =
min_max_dist, std::min(min_max_dist,
std::max(coordinate_calculation::euclidean_distance(location, lower_left), std::max(coordinate_calculation::euclidean_distance(location, lower_left),
coordinate_calculation::euclidean_distance(location, upper_left))); coordinate_calculation::euclidean_distance(location, upper_left)));
return min_max_dist; return min_max_dist;
} }
inline bool Contains(const FixedPointCoordinate &location) const bool Contains(const FixedPointCoordinate &location) const
{ {
const bool lats_contained = (location.lat >= min_lat) && (location.lat <= max_lat); const bool lats_contained = (location.lat >= min_lat) && (location.lat <= max_lat);
const bool lons_contained = (location.lon >= min_lon) && (location.lon <= max_lon); const bool lons_contained = (location.lon >= min_lon) && (location.lon <= max_lon);
return lats_contained && lons_contained; return lats_contained && lons_contained;
} }
inline friend std::ostream &operator<<(std::ostream &out, const RectangleInt2D &rect) friend std::ostream &operator<<(std::ostream &out, const RectangleInt2D &rect)
{ {
out << rect.min_lat / COORDINATE_PRECISION << "," << rect.min_lon / COORDINATE_PRECISION out << rect.min_lat / COORDINATE_PRECISION << "," << rect.min_lon / COORDINATE_PRECISION
<< " " << rect.max_lat / COORDINATE_PRECISION << "," << " " << rect.max_lat / COORDINATE_PRECISION << ","