Isochrone Plugin #2189

include/engine/api/isochrone_api.hpp

@@ -0,0 +1,89 @@
+#ifndef ENGINE_API_ISOCHRONE_HPP
+#define ENGINE_API_ISOCHRONE_HPP
+
+#include "engine/api/base_api.hpp"
+#include "engine/api/isochrone_parameters.hpp"
+#include "engine/plugins/isochrone.hpp"
+#include "engine/plugins/plugin_base.hpp"
+
+namespace osrm
+{
+namespace engine
+{
+namespace api
+{
+
+class IsochroneAPI final : public BaseAPI
+{
+
+  public:
+    const IsochroneParameters &parameters;
+
+    IsochroneAPI(const datafacade::BaseDataFacade &facade_, const IsochroneParameters &parameters_)
+        : BaseAPI(facade_, parameters_), parameters(parameters_)
+    {
+    }
+
+    void MakeResponse(const std::vector<engine::plugins::IsochroneNode> isochroneNodes,
+                      const std::vector<engine::plugins::IsochroneNode> convexhull,
+                      const std::vector<engine::plugins::IsochroneNode> concavehull,
+                      util::json::Object &response) const
+    {
+        util::json::Array isochroneJson;
+        for (auto isochrone : isochroneNodes)
+        {
+            util::json::Object object;
+
+            util::json::Object source;
+            source.values["lat"] = static_cast<double>(util::toFloating(isochrone.node.lat));
+            source.values["lon"] = static_cast<double>(util::toFloating(isochrone.node.lon));
+            object.values["p1"] = std::move(source);
+
+            util::json::Object predecessor;
+            predecessor.values["lat"] =
+                static_cast<double>(util::toFloating(isochrone.predecessor.lat));
+            predecessor.values["lon"] =
+                static_cast<double>(util::toFloating(isochrone.predecessor.lon));
+            object.values["p2"] = std::move(predecessor);
+
+            util::json::Object distance;
+            object.values["distance_from_start"] = isochrone.distance;
+
+            util::json::Object duration;
+            object.values["duration_from_start"] = isochrone.duration;
+
+            isochroneJson.values.push_back(object);
+        }
+        response.values["isochrone"] = std::move(isochroneJson);
+
+        if (!convexhull.empty())
+        {
+            util::json::Array convexhullArray;
+            for (engine::plugins::IsochroneNode n : convexhull)
+            {
+                util::json::Object point;
+                point.values["lat"] = static_cast<double>(util::toFloating(n.node.lat));
+                point.values["lon"] = static_cast<double>(util::toFloating(n.node.lon));
+                convexhullArray.values.push_back(point);
+            }
+            response.values["convexhull"] = std::move(convexhullArray);
+        }
+
+        if (!concavehull.empty())
+        {
+            util::json::Array concavehullArray;
+            for (engine::plugins::IsochroneNode n : concavehull)
+            {
+                util::json::Object point;
+                point.values["lat"] = static_cast<double>(util::toFloating(n.node.lat));
+                point.values["lon"] = static_cast<double>(util::toFloating(n.node.lon));
+                concavehullArray.values.push_back(point);
+            }
+            response.values["concavehull"] = std::move(concavehullArray);
+        }
+    }
+};
+}
+}
+}
+#endif // ENGINE_API_ISOCHRONE_HPP

include/engine/api/isochrone_parameters.hpp

@@ -0,0 +1,26 @@
+#ifndef ENGINE_API_ISOCHRONE_PARAMETERS_HPP
+#define ENGINE_API_ISOCHRONE_PARAMETERS_HPP
+
+#include "engine/api/base_parameters.hpp"
+
+namespace osrm
+{
+namespace engine
+{
+namespace api
+{
+
+struct IsochroneParameters : public BaseParameters
+{
+    unsigned int duration = 0;
+    double distance = 0;
+    bool convexhull = false;
+    bool concavehull = false;
+    double threshold = 1; // max precision
+
+    bool IsValid() const { return BaseParameters::IsValid(); }
+};
+}
+}
+}
+#endif // ENGINE_API_ISOCHRONE_PARAMETERS_HPP

include/engine/engine.hpp

@@ -36,6 +36,7 @@ struct NearestParameters;
 struct TripParameters;
 struct MatchParameters;
 struct TileParameters;
+struct IsochroneParameters;
 }
 namespace plugins
 {
@@ -45,6 +46,7 @@ class NearestPlugin;
 class TripPlugin;
 class MatchPlugin;
 class TilePlugin;
+class IsochronePlugin;
 }
 // End fwd decls
 
@@ -70,6 +72,7 @@ class Engine final
     Status Trip(const api::TripParameters &parameters, util::json::Object &result) const;
     Status Match(const api::MatchParameters &parameters, util::json::Object &result) const;
     Status Tile(const api::TileParameters &parameters, std::string &result) const;
+    Status Isochrone(const api::IsochroneParameters &parameters, util::json::Object &result) const;
 
   private:
     std::unique_ptr<storage::SharedBarriers> lock;
@@ -80,6 +83,7 @@ class Engine final
     std::unique_ptr<plugins::TripPlugin> trip_plugin;
     std::unique_ptr<plugins::MatchPlugin> match_plugin;
     std::unique_ptr<plugins::TilePlugin> tile_plugin;
+    std::unique_ptr<plugins::IsochronePlugin> isochrone_plugin;
 
     std::shared_ptr<datafacade::BaseDataFacade> query_data_facade;
 };

include/engine/engine_config.hpp

@@ -68,6 +68,7 @@ struct EngineConfig final
     int max_locations_map_matching = -1;
     int max_results_nearest = -1;
     bool use_shared_memory = true;
+    bool use_isochrone = true;
 };
 }
 }

include/engine/plugins/isochrone.hpp

@@ -0,0 +1,99 @@
+#ifndef ISOCHRONE_HPP
+#define ISOCHRONE_HPP
+
+#include "engine/api/isochrone_parameters.hpp"
+#include "engine/plugins/plugin_base.hpp"
+#include "osrm/json_container.hpp"
+#include "util/binary_heap.hpp"
+#include "util/static_graph.hpp"
+
+#include <boost/bind.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+#include <boost/function.hpp>
+#include <tbb/parallel_sort.h>
+
+#include <algorithm>
+#include <cstdlib>
+#include <utility>
+#include <vector>
+
+namespace osrm
+{
+namespace engine
+{
+namespace plugins
+{
+struct HeapData
+{
+    NodeID parent;
+    HeapData(NodeID p) : parent(p) {}
+};
+struct SimpleEdgeData
+{
+    SimpleEdgeData() : weight(INVALID_EDGE_WEIGHT), real(false) {}
+    SimpleEdgeData(unsigned weight_, bool real_) : weight(weight_), real(real_) {}
+    unsigned weight;
+    bool real;
+};
+
+struct IsochroneNode
+{
+    IsochroneNode(){};
+    IsochroneNode(osrm::extractor::QueryNode node,
+                  osrm::extractor::QueryNode predecessor,
+                  double distance,
+                  int duration)
+        : node(node), predecessor(predecessor), distance(distance), duration(duration)
+    {
+    }
+
+    osrm::extractor::QueryNode node;
+    osrm::extractor::QueryNode predecessor;
+    double distance;
+    int duration;
+
+    bool operator==(const IsochroneNode &n) const
+    {
+        if (n.node.node_id == node.node_id)
+            return true;
+        else
+            return false;
+    }
+};
+
+using SimpleGraph = util::StaticGraph<SimpleEdgeData>;
+using SimpleEdge = SimpleGraph::InputEdge;
+using QueryHeap = osrm::util::
+    BinaryHeap<NodeID, NodeID, int, HeapData, osrm::util::UnorderedMapStorage<NodeID, int>>;
+typedef std::vector<IsochroneNode> IsochroneVector;
+
+class IsochronePlugin final : public BasePlugin
+{
+  private:
+    boost::filesystem::path base;
+    std::shared_ptr<engine::plugins::SimpleGraph> graph;
+    std::vector<osrm::extractor::QueryNode> coordinate_list;
+    std::vector<engine::plugins::SimpleEdge> graph_edge_list;
+    std::size_t number_of_nodes;
+
+    std::size_t loadGraph(const std::string &path,
+                          std::vector<extractor::QueryNode> &coordinate_list,
+                          std::vector<SimpleEdge> &graph_edge_list);
+
+    void dijkstraByDuration(IsochroneVector &set, NodeID &source, int duration);
+    void dijkstraByDistance(IsochroneVector &isochroneSet, NodeID &source, double distance);
+    void update(IsochroneVector &s, IsochroneNode node);
+
+  public:
+    explicit IsochronePlugin(const std::string base);
+
+    Status HandleRequest(const std::shared_ptr<datafacade::BaseDataFacade> facade,
+                         const api::IsochroneParameters &params,
+                         util::json::Object &json_result);
+};
+}
+}
+}
+
+#endif // ISOCHRONE_HPP

include/engine/search_engine.hpp

@@ -0,0 +1,50 @@
+#ifndef SEARCH_ENGINE_HPP
+#define SEARCH_ENGINE_HPP
+
+#include "engine/routing_algorithms/alternative_path.hpp"
+#include "engine/routing_algorithms/direct_shortest_path.hpp"
+#include "engine/routing_algorithms/many_to_many.hpp"
+#include "engine/routing_algorithms/map_matching.hpp"
+#include "engine/routing_algorithms/one_to_many.hpp"
+#include "engine/routing_algorithms/shortest_path.hpp"
+#include "engine/search_engine_data.hpp"
+
+#include <type_traits>
+
+namespace osrm
+{
+namespace engine
+{
+
+template <class DataFacadeT> class SearchEngine
+{
+  private:
+    DataFacadeT *facade;
+    SearchEngineData engine_working_data;
+
+  public:
+    routing_algorithms::ShortestPathRouting<DataFacadeT> shortest_path;
+    routing_algorithms::DirectShortestPathRouting<DataFacadeT> direct_shortest_path;
+    routing_algorithms::AlternativeRouting<DataFacadeT> alternative_path;
+    routing_algorithms::ManyToManyRouting<DataFacadeT> distance_table;
+    routing_algorithms::MapMatching<DataFacadeT> map_matching;
+    routing_algorithms::OneToManyRouting<DataFacadeT> oneToMany;
+
+    explicit SearchEngine(DataFacadeT *facade)
+        : facade(facade), shortest_path(facade, engine_working_data),
+          direct_shortest_path(facade, engine_working_data),
+          alternative_path(facade, engine_working_data),
+          distance_table(facade, engine_working_data), map_matching(facade, engine_working_data),
+          oneToMany(facade, engine_working_data)
+    {
+        static_assert(!std::is_pointer<DataFacadeT>::value, "don't instantiate with ptr type");
+        static_assert(std::is_object<DataFacadeT>::value,
+                      "don't instantiate with void, function, or reference");
+    }
+
+    ~SearchEngine() {}
+};
+}
+}
+
+#endif // SEARCH_ENGINE_HPP

include/osrm/isochrone_parameters.hpp

@@ -0,0 +1,11 @@
+#ifndef GLOBAL_ISOCHRONE_PARAMETERS_HPP
+#define GLOBAL_ISOCHRONE_PARAMETERS_HPP
+
+#include "engine/api/isochrone_parameters.hpp"
+
+namespace osrm
+{
+using engine::api::IsochroneParameters;
+}
+
+#endif // GLOBAL_ISOCHRONE_PARAMETERS_HPP

include/osrm/osrm.hpp

@@ -44,6 +44,7 @@ using engine::api::NearestParameters;
 using engine::api::TripParameters;
 using engine::api::MatchParameters;
 using engine::api::TileParameters;
+using engine::api::IsochroneParameters;
 
 /**
  * Represents a Open Source Routing Machine with access to its services.
@@ -130,6 +131,14 @@ class OSRM final
      */
     Status Tile(const TileParameters &parameters, std::string &result) const;
 
+    /**
+     * Isochrone for given distance
+     * \param parameters nearest query specific parameters
+     * \return Status indicating success for the query or failure
+     * \see Status, NearestParameters and json::Object
+     */
+    Status Isochrone(const IsochroneParameters &parameters, json::Object &result) const;
+
   private:
     std::unique_ptr<engine::Engine> engine_;
 };

include/osrm/osrm_fwd.hpp

@@ -52,6 +52,7 @@ struct NearestParameters;
 struct TripParameters;
 struct MatchParameters;
 struct TileParameters;
+struct IsochroneParameters;
 } // ns api
 
 class Engine;