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

138
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()
max_lon(std::numeric_limits<int32_t>::min()), : min_lon(std::numeric_limits<int32_t>::max()),
min_lat(std::numeric_limits<int32_t>::max()), max_lon(std::numeric_limits<int32_t>::min()),
max_lat(std::numeric_limits<int32_t>::min()) {} min_lat(std::numeric_limits<int32_t>::max()), 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)
@ -90,66 +92,74 @@ struct RectangleInt2D
enum Direction enum Direction
{ {
INVALID = 0, INVALID = 0,
NORTH = 1, NORTH = 1,
SOUTH = 2, SOUTH = 2,
EAST = 4, EAST = 4,
NORTH_EAST = 5, NORTH_EAST = 5,
SOUTH_EAST = 6, SOUTH_EAST = 6,
WEST = 8, WEST = 8,
NORTH_WEST = 9, NORTH_WEST = 9,
SOUTH_WEST = 10 SOUTH_WEST = 10
}; };
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);
float min_dist = std::numeric_limits<float>::max(); float min_dist = std::numeric_limits<float>::max();
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(
break; location, FixedPointCoordinate(max_lat, location.lon));
case SOUTH: break;
min_dist = coordinate_calculation::euclidean_distance(location, FixedPointCoordinate(min_lat, location.lon)); case SOUTH:
break; min_dist = coordinate_calculation::euclidean_distance(
case WEST: location, FixedPointCoordinate(min_lat, location.lon));
min_dist = coordinate_calculation::euclidean_distance(location, FixedPointCoordinate(location.lat, min_lon)); break;
break; case WEST:
case EAST: min_dist = coordinate_calculation::euclidean_distance(
min_dist = coordinate_calculation::euclidean_distance(location, FixedPointCoordinate(location.lat, max_lon)); location, FixedPointCoordinate(location.lat, min_lon));
break; break;
case NORTH_EAST: case EAST:
min_dist = coordinate_calculation::euclidean_distance(location, FixedPointCoordinate(max_lat, max_lon)); min_dist = coordinate_calculation::euclidean_distance(
break; location, FixedPointCoordinate(location.lat, max_lon));
case NORTH_WEST: break;
min_dist = coordinate_calculation::euclidean_distance(location, FixedPointCoordinate(max_lat, min_lon)); case NORTH_EAST:
break; min_dist = coordinate_calculation::euclidean_distance(
case SOUTH_EAST: location, FixedPointCoordinate(max_lat, max_lon));
min_dist = coordinate_calculation::euclidean_distance(location, FixedPointCoordinate(min_lat, max_lon)); break;
break; case NORTH_WEST:
case SOUTH_WEST: min_dist = coordinate_calculation::euclidean_distance(
min_dist = coordinate_calculation::euclidean_distance(location, FixedPointCoordinate(min_lat, min_lon)); location, FixedPointCoordinate(max_lat, min_lon));
break; break;
default: case SOUTH_EAST:
break; min_dist = coordinate_calculation::euclidean_distance(
location, FixedPointCoordinate(min_lat, max_lon));
break;
case SOUTH_WEST:
min_dist = coordinate_calculation::euclidean_distance(
location, FixedPointCoordinate(min_lat, min_lon));
break;
default:
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 << ","