Rename NodeInfo -> QueryNode

2014-08-29 12:37:07 +02:00
parent b4b753ce2e
commit 0d7141ce5b
14 changed files with 213 additions and 30 deletions
@@ -31,7 +31,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 ExternalMemoryNode::ExternalMemoryNode(
    int lat, int lon, unsigned int node_id, bool barrier, bool traffic_lights)
-    : NodeInfo(lat, lon, node_id), barrier(barrier), traffic_lights(traffic_lights)
+    : QueryNode(lat, lon, node_id), barrier(barrier), traffic_lights(traffic_lights)
 {
 }

@@ -32,7 +32,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #include <string>

-struct ExternalMemoryNode : NodeInfo
+struct ExternalMemoryNode : QueryNode
 {
    ExternalMemoryNode(int lat, int lon, NodeID id, bool barrier, bool traffic_light);

@@ -36,13 +36,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #include <limits>

-struct NodeInfo
+struct QueryNode
 {
    using key_type = NodeID; // type of NodeID
    using value_type = int; // type of lat,lons

-    explicit NodeInfo(int lat, int lon, NodeID node_id) : lat(lat), lon(lon), node_id(node_id) {}
-    NodeInfo()
+    explicit QueryNode(int lat, int lon, NodeID node_id) : lat(lat), lon(lon), node_id(node_id) {}
+    QueryNode()
        : lat(std::numeric_limits<int>::max()), lon(std::numeric_limits<int>::max()),
          node_id(std::numeric_limits<unsigned>::max())
    {
@@ -52,18 +52,18 @@ struct NodeInfo
    int lon;
    NodeID node_id;

-    static NodeInfo min_value()
+    static QueryNode min_value()
    {
-        return NodeInfo(static_cast<int>(-90 * COORDINATE_PRECISION),
-                        static_cast<int>(-180 * COORDINATE_PRECISION),
-                        std::numeric_limits<NodeID>::min());
+        return QueryNode(static_cast<int>(-90 * COORDINATE_PRECISION),
+                         static_cast<int>(-180 * COORDINATE_PRECISION),
+                         std::numeric_limits<NodeID>::min());
    }

-    static NodeInfo max_value()
+    static QueryNode max_value()
    {
-        return NodeInfo(static_cast<int>(90 * COORDINATE_PRECISION),
-                        static_cast<int>(180 * COORDINATE_PRECISION),
-                        std::numeric_limits<NodeID>::max());
+        return QueryNode(static_cast<int>(90 * COORDINATE_PRECISION),
+                         static_cast<int>(180 * COORDINATE_PRECISION),
+                         std::numeric_limits<NodeID>::max());
    }

    value_type operator[](const std::size_t n) const
@@ -72,6 +72,190 @@ template <class EdgeDataT,
 class StaticRTree
 {
  public:
+    struct RectangleInt2D
+    {
+        RectangleInt2D() : min_lon(INT_MAX), max_lon(INT_MIN), min_lat(INT_MAX), max_lat(INT_MIN) {}
+
+        int32_t min_lon, max_lon;
+        int32_t min_lat, max_lat;
+
+        inline void InitializeMBRectangle(const std::array<EdgeDataT, LEAF_NODE_SIZE> &objects,
+                                          const uint32_t element_count,
+                                          const std::vector<QueryNode> &coordinate_list)
+        {
+            for (uint32_t i = 0; i < element_count; ++i)
+            {
+                min_lon = std::min(min_lon,
+                                   std::min(coordinate_list.at(objects[i].u).lon,
+                                            coordinate_list.at(objects[i].v).lon));
+                max_lon = std::max(max_lon,
+                                   std::max(coordinate_list.at(objects[i].u).lon,
+                                            coordinate_list.at(objects[i].v).lon));
+
+                min_lat = std::min(min_lat,
+                                   std::min(coordinate_list.at(objects[i].u).lat,
+                                            coordinate_list.at(objects[i].v).lat));
+                max_lat = std::max(max_lat,
+                                   std::max(coordinate_list.at(objects[i].u).lat,
+                                            coordinate_list.at(objects[i].v).lat));
+            }
+            BOOST_ASSERT(min_lat != std::numeric_limits<int>::min());
+            BOOST_ASSERT(min_lon != std::numeric_limits<int>::min());
+            BOOST_ASSERT(max_lat != std::numeric_limits<int>::min());
+            BOOST_ASSERT(max_lon != std::numeric_limits<int>::min());
+        }
+
+        inline void MergeBoundingBoxes(const RectangleInt2D &other)
+        {
+            min_lon = std::min(min_lon, other.min_lon);
+            max_lon = std::max(max_lon, other.max_lon);
+            min_lat = std::min(min_lat, other.min_lat);
+            max_lat = std::max(max_lat, other.max_lat);
+            BOOST_ASSERT(min_lat != std::numeric_limits<int>::min());
+            BOOST_ASSERT(min_lon != std::numeric_limits<int>::min());
+            BOOST_ASSERT(max_lat != std::numeric_limits<int>::min());
+            BOOST_ASSERT(max_lon != std::numeric_limits<int>::min());
+        }
+
+        inline FixedPointCoordinate Centroid() const
+        {
+            FixedPointCoordinate centroid;
+            // The coordinates of the midpoints are given by:
+            // x = (x1 + x2) /2 and y = (y1 + y2) /2.
+            centroid.lon = (min_lon + max_lon) / 2;
+            centroid.lat = (min_lat + max_lat) / 2;
+            return centroid;
+        }
+
+        inline bool Intersects(const RectangleInt2D &other) const
+        {
+            FixedPointCoordinate upper_left(other.max_lat, other.min_lon);
+            FixedPointCoordinate upper_right(other.max_lat, other.max_lon);
+            FixedPointCoordinate lower_right(other.min_lat, other.max_lon);
+            FixedPointCoordinate lower_left(other.min_lat, other.min_lon);
+
+            return (Contains(upper_left) || Contains(upper_right) || Contains(lower_right) ||
+                    Contains(lower_left));
+        }
+
+        inline float GetMinDist(const FixedPointCoordinate &location) const
+        {
+            const bool is_contained = Contains(location);
+            if (is_contained)
+            {
+                return 0.;
+            }
+
+            enum Direction
+            {
+                INVALID    = 0,
+                NORTH      = 1,
+                SOUTH      = 2,
+                EAST       = 4,
+                NORTH_EAST = 5,
+                SOUTH_EAST = 6,
+                WEST       = 8,
+                NORTH_WEST = 9,
+                SOUTH_WEST = 10
+            };
+
+            Direction d = INVALID;
+            if (location.lat > max_lat)
+                d = (Direction) (d | NORTH);
+            else if (location.lat < min_lat)
+                d = (Direction) (d | SOUTH);
+            if (location.lon > max_lon)
+                d = (Direction) (d | EAST);
+            else if (location.lon < min_lon)
+                d = (Direction) (d | WEST);
+
+            BOOST_ASSERT(d != INVALID);
+
+            float min_dist = std::numeric_limits<float>::max();
+            switch (d)
+            {
+                case NORTH:
+                    min_dist = FixedPointCoordinate::ApproximateEuclideanDistance(location, FixedPointCoordinate(max_lat, location.lon));
+                    break;
+                case SOUTH:
+                    min_dist = FixedPointCoordinate::ApproximateEuclideanDistance(location, FixedPointCoordinate(min_lat, location.lon));
+                    break;
+                case WEST:
+                    min_dist = FixedPointCoordinate::ApproximateEuclideanDistance(location, FixedPointCoordinate(location.lat, min_lon));
+                    break;
+                case EAST:
+                    min_dist = FixedPointCoordinate::ApproximateEuclideanDistance(location, FixedPointCoordinate(location.lat, max_lon));
+                    break;
+                case NORTH_EAST:
+                    min_dist = FixedPointCoordinate::ApproximateEuclideanDistance(location, FixedPointCoordinate(max_lat, max_lon));
+                    break;
+                case NORTH_WEST:
+                    min_dist = FixedPointCoordinate::ApproximateEuclideanDistance(location, FixedPointCoordinate(max_lat, min_lon));
+                    break;
+                case SOUTH_EAST:
+                    min_dist = FixedPointCoordinate::ApproximateEuclideanDistance(location, FixedPointCoordinate(min_lat, max_lon));
+                    break;
+                case SOUTH_WEST:
+                    min_dist = FixedPointCoordinate::ApproximateEuclideanDistance(location, FixedPointCoordinate(min_lat, min_lon));
+                    break;
+                default:
+                    break;
+            }
+
+            BOOST_ASSERT(min_dist != std::numeric_limits<float>::max());
+
+            return min_dist;
+        }
+
+        inline float GetMinMaxDist(const FixedPointCoordinate &location) const
+        {
+            float min_max_dist = std::numeric_limits<float>::max();
+            // Get minmax distance to each of the four sides
+            const FixedPointCoordinate upper_left(max_lat, min_lon);
+            const FixedPointCoordinate upper_right(max_lat, max_lon);
+            const FixedPointCoordinate lower_right(min_lat, max_lon);
+            const FixedPointCoordinate lower_left(min_lat, min_lon);
+
+            min_max_dist = std::min(
+                min_max_dist,
+                std::max(
+                    FixedPointCoordinate::ApproximateEuclideanDistance(location, upper_left),
+                    FixedPointCoordinate::ApproximateEuclideanDistance(location, upper_right)));
+
+            min_max_dist = std::min(
+                min_max_dist,
+                std::max(
+                    FixedPointCoordinate::ApproximateEuclideanDistance(location, upper_right),
+                    FixedPointCoordinate::ApproximateEuclideanDistance(location, lower_right)));
+
+            min_max_dist = std::min(
+                min_max_dist,
+                std::max(FixedPointCoordinate::ApproximateEuclideanDistance(location, lower_right),
+                         FixedPointCoordinate::ApproximateEuclideanDistance(location, lower_left)));
+
+            min_max_dist = std::min(
+                min_max_dist,
+                std::max(FixedPointCoordinate::ApproximateEuclideanDistance(location, lower_left),
+                         FixedPointCoordinate::ApproximateEuclideanDistance(location, upper_left)));
+            return min_max_dist;
+        }
+
+        inline bool Contains(const FixedPointCoordinate &location) const
+        {
+            const bool lats_contained = (location.lat >= min_lat) && (location.lat <= max_lat);
+            const bool lons_contained = (location.lon >= min_lon) && (location.lon <= max_lon);
+            return lats_contained && lons_contained;
+        }
+
+        inline friend std::ostream &operator<<(std::ostream &out, const RectangleInt2D &rect)
+        {
+            out << rect.min_lat / COORDINATE_PRECISION << "," << rect.min_lon / COORDINATE_PRECISION
+                << " " << rect.max_lat / COORDINATE_PRECISION << ","
+                << rect.max_lon / COORDINATE_PRECISION;
+            return out;
+        }
+    };
+
    using RectangleT = RectangleInt2D;

    struct TreeNode
@@ -159,7 +343,7 @@ class StaticRTree
    explicit StaticRTree(std::vector<EdgeDataT> &input_data_vector,
                         const std::string tree_node_filename,
                         const std::string leaf_node_filename,
-                         const std::vector<NodeInfo> &coordinate_list)
+                         const std::vector<QueryNode> &coordinate_list)
        : m_element_count(input_data_vector.size()), m_leaf_node_filename(leaf_node_filename)
    {
        SimpleLogger().Write() << "constructing r-tree of " << m_element_count
@@ -1021,7 +1205,7 @@ class StaticRTree
    inline void InitializeMBRectangle(RectangleT& rectangle,
                                      const std::array<EdgeDataT, LEAF_NODE_SIZE> &objects,
                                      const uint32_t element_count,
-                                      const std::vector<NodeInfo> &coordinate_list)
+                                      const std::vector<QueryNode> &coordinate_list)
    {
        for (uint32_t i = 0; i < element_count; ++i)
        {