Refactor the OSRM/BirdDistance management

connection_scan_algorithm/include/calculator.hpp

@@ -41,14 +41,15 @@ namespace TrRouting
   class TransitData;
   class ConnectionSet;
   class Point;
+  class GeoFilter;
 
   class Calculator {
 
   public:
 
     std::map<std::string, int> benchmarking;
 
-    Calculator(const TransitData &_transitData);
+    Calculator(const TransitData &_transitData, GeoFilter &_geofilter);
 
     void reset(CommonParameters &parameters, std::optional<std::reference_wrapper<const Point>> origin, std::optional<std::reference_wrapper<const Point>> destination, bool resetAccessPaths = true, bool resetFilters = true);
     // TODO This function supports both allNodes and simple calculation, which
@@ -101,6 +102,8 @@ namespace TrRouting
 
     //TODO set it mutable so it can be changed/reset?
     const TransitData &transitData;
+    //TODO Should it be const?
+    GeoFilter &geoFilter;
 
     int              departureTimeSeconds;
     int              arrivalTimeSeconds;

connection_scan_algorithm/include/program_options.hpp

@@ -17,6 +17,7 @@ namespace TrRouting
     int         port;
     bool        debug;
     bool        cacheAllConnectionSets;
+    bool        useEuclideanDistance;
     std::string algorithm;
     std::string dataFetcherShortname;
     std::string osrmWalkingPort;

connection_scan_algorithm/src/initializations.cpp

@@ -17,14 +17,16 @@
 #include "person.hpp"
 #include "connection_cache.hpp"
 #include "transit_data.hpp"
+#include "geofilter.hpp"
 
 namespace TrRouting
 {
 
-  Calculator::Calculator(const TransitData &_transitData) :
+  Calculator::Calculator(const TransitData &_transitData, GeoFilter &_geoFilter) :
     algorithmCalculationTime(CalculationTime()),
     odTripGlob(std::nullopt),
     transitData(_transitData),
+    geoFilter(_geoFilter),
     departureTimeSeconds(0),
     arrivalTimeSeconds(-1),
     minAccessTravelTime(0),

connection_scan_algorithm/src/parameters/legacyV1_parameters.cpp

@@ -47,8 +47,6 @@ namespace TrRouting
     maxTotalWalkingTravelTimeSeconds       = 60*60; // not used right now
     maxOnlyWalkingAccessTravelTimeRatio    = 1.5; // prefer walking only if it is faster than transit and total only walking travel time <= maxAccessWalkingTravelTimeSeconds * this ratio
     transferPenaltySeconds                 = 0; // not used right now
-    accessMode                             = "walking";
-    egressMode                             = "walking";
     noResultSecondMode                     = "driving";
     tryNextModeIfRoutingFails              = false;
     noResultNextAccessTimeSecondsIncrement = 5*60;

connection_scan_algorithm/src/program_options.cpp

@@ -18,6 +18,8 @@ namespace TrRouting {
       ("cachePath",                                         boost::program_options::value<std::string>()->default_value("cache"), "cache path");
    options.add_options()
       ("cacheAllConnectionSets",                            boost::program_options::value<bool>()       ->default_value(false), "cache all connections set instead of the ones from the last used scenario");
+    options.add_options()
+      ("useEuclideanDistance",                              boost::program_options::value<bool>()       ->default_value(false), "Use euclidean distance calculation instead of OSRM for access and egress calculations");
     options.add_options()
       ("osrmPort,osrmWalkPort,osrmWalkingPort",             boost::program_options::value<std::string>()->default_value("5000"), "osrm walking port");
     options.add_options()
@@ -43,6 +45,7 @@ namespace TrRouting {
     dataFetcherShortname = "cache";
     cachePath            = "cache";
     cacheAllConnectionSets = false;
+    useEuclideanDistance = false;
     osrmWalkingPort      = "5000";
     osrmCyclingPort      = "8000";
     osrmDrivingPort      = "7000";
@@ -78,6 +81,10 @@ namespace TrRouting {
     {
       cacheAllConnectionSets = variablesMap["cacheAllConnectionSets"].as<bool>();
     }
+    if(variablesMap.count("useEuclideanDistance") == 1)
+    {
+      useEuclideanDistance = variablesMap["useEuclideanDistance"].as<bool>();
+    }
 
     if(variablesMap.count("osrmWalkPort") == 1)
     {

connection_scan_algorithm/src/resets.cpp

@@ -2,7 +2,6 @@
 #include "calculator.hpp"
 #include "parameters.hpp"
 #include "trip.hpp"
-#include "osrm_fetcher.hpp"
 #include "toolbox.hpp" //MAX_INT
 #include "od_trip.hpp"
 #include "routing_result.hpp"
@@ -13,6 +12,7 @@
 #include "node.hpp"
 #include "transit_data.hpp"
 #include "connection_set.hpp"
+#include "geofilter.hpp"
 
 namespace TrRouting
 {
@@ -199,9 +199,9 @@ namespace TrRouting
     }
     else
     {
-      spdlog::debug("  fetching nodes with osrm with mode {}", params.accessMode);
+      spdlog::debug("  fetching nodes with osrm");
 
-      accessFootpaths = OsrmFetcher::getAccessibleNodesFootpathsFromPoint(origin, transitData.getNodes(), params.accessMode, parameters.getMaxAccessWalkingTravelTimeSeconds(), params.walkingSpeedMetersPerSecond);
+      accessFootpaths = geoFilter.getAccessibleNodesFootpathsFromPoint(origin, transitData.getNodes(), parameters.getMaxAccessWalkingTravelTimeSeconds(), params.walkingSpeedMetersPerSecond);
       if (accessFootpaths.size() == 0) {
         accessFootpathOk = false;
       }
@@ -240,7 +240,7 @@ namespace TrRouting
     }
     else
     {
-      egressFootpaths = OsrmFetcher::getAccessibleNodesFootpathsFromPoint(destination, transitData.getNodes(), params.accessMode, parameters.getMaxEgressWalkingTravelTimeSeconds(), params.walkingSpeedMetersPerSecond);
+      egressFootpaths = geoFilter.getAccessibleNodesFootpathsFromPoint(destination, transitData.getNodes(), parameters.getMaxEgressWalkingTravelTimeSeconds(), params.walkingSpeedMetersPerSecond);
       if (egressFootpaths.size() == 0) {
         egressFootpathOk = false;
       }

connection_scan_algorithm/src/transit_routing_http_server.cpp

@@ -27,8 +27,9 @@
 #include "result_to_v2_summary.hpp"
 #include "result_to_v2_accessibility.hpp"
 #include "routing_result.hpp"
-#include "osrm_fetcher.hpp"
 #include "transit_data.hpp"
+#include "osrmgeofilter.hpp"
+#include "euclideangeofilter.hpp"
 
 using namespace TrRouting;
 
@@ -108,13 +109,6 @@ int main(int argc, char** argv) {
   // setup program options:
   spdlog::info("Starting transit routing on port {} for the data: {}", programOptions.port, programOptions.cachePath);
 
-  OsrmFetcher::osrmWalkingPort        = programOptions.osrmWalkingPort;
-  OsrmFetcher::osrmCyclingPort        = programOptions.osrmCyclingPort;
-  OsrmFetcher::osrmDrivingPort        = programOptions.osrmDrivingPort;
-  OsrmFetcher::osrmWalkingHost        = programOptions.osrmWalkingHost;
-  OsrmFetcher::osrmCyclingHost        = programOptions.osrmCyclingHost;
-  OsrmFetcher::osrmDrivingHost        = programOptions.osrmDrivingHost;
-
   if (programOptions.debug) {
     spdlog::set_level(spdlog::level::debug);
   }
@@ -132,8 +126,18 @@ int main(int argc, char** argv) {
   //TODO We wanted to handle error in the constructor, but later part of this code expect a dataStatus
   // leaving as a todo
   DataStatus dataStatus = transitData.getDataStatus();
-
-  Calculator calculator(transitData);
+
+  // Selection which geofilter to use. OSRM is the default one. Euclidean mostly used for debugging and testing
+  GeoFilter *geoFilter = 0;
+  if (programOptions.useEuclideanDistance) {
+    geoFilter = new EuclideanGeoFilter();
+    spdlog::info("Using Euclidean distance for access/egress node time/distance");
+  } else {
+    geoFilter = new OsrmGeoFilter("walking", programOptions.osrmWalkingHost, programOptions.osrmWalkingPort);
+    spdlog::info("Using OSRM for access/egress node time/distance");
+  }
+
+  Calculator calculator(transitData, *geoFilter);
   //TODO, should this be in the constructor?
   calculator.initializeCalculationData();
   spdlog::info("preparing server...");

include/euclideangeofilter.hpp

@@ -0,0 +1,23 @@
+#ifndef TR_EUCLIDEAN_GEO_FILTER
+#define TR_EUCLIDEAN_GEO_FILTER
+
+#include "geofilter.hpp"
+#include <string>
+
+namespace TrRouting
+{
+  /* Filter nodes using Euclidean distance */
+  class EuclideanGeoFilter : public GeoFilter
+  {
+  public:
+    EuclideanGeoFilter();
+
+    virtual std::vector<NodeTimeDistance> getAccessibleNodesFootpathsFromPoint(const Point &point,
+                                                                       const std::map<boost::uuids::uuid, Node> &nodes,
+                                                                       int maxWalkingTravelTime,
+                                                                       float walkingSpeedMetersPerSecond,
+                                                                       bool reversed = false);    
+  };
+}
+
+#endif // TR_EUCLIDEAN_GEO_FILTER

include/geofilter.hpp

@@ -0,0 +1,34 @@
+#ifndef TR_GEO_FILTER
+#define TR_GEO_FILTER
+
+#include <vector>
+#include <map> //For node map types, TODO have a typedef somewhere for the nodes array
+#include <boost/uuid/uuid.hpp>
+#include <tuple>
+
+namespace TrRouting
+{
+  class Point;
+  class Node;
+  class NodeTimeDistance;
+
+  /* Base class to implement filter based in geography */
+  class GeoFilter
+  {
+  public:
+    virtual std::vector<NodeTimeDistance> getAccessibleNodesFootpathsFromPoint(const Point &point,
+                                                                       const std::map<boost::uuids::uuid, Node> &nodes,
+                                                                       int maxWalkingTravelTime,
+                                                                       float walkingSpeedMetersPerSecond,
+                                                                       bool reversed = false) = 0;
+  protected:
+    // Common utility functions
+    static std::tuple<float, float> calculateLengthOfOneDegree(const Point &point);
+    static float calculateMaxDistanceSquared(int maxWalkingTravelTime, float walkingSpeed);
+    //TODO WHy one point * and other &
+    static float calculateNodeDistanceSquared(const Point *node, const Point &point, const std::tuple<float, float> &lengthOfOneDegree);
+
+  };
+}
+
+#endif // TR_GEO_FILTER

include/osrmgeofilter.hpp

@@ -0,0 +1,28 @@
+#ifndef TR_OSRM_GEO_FILTER
+#define TR_OSRM_GEO_FILTER
+
+#include "geofilter.hpp"
+#include <string>
+
+namespace TrRouting
+{
+  /* Filter nodes using OSRM */
+  class OsrmGeoFilter : public GeoFilter
+  {
+  public:
+    OsrmGeoFilter(const std::string &mode, const std::string &host, const std::string & port);
+
+    virtual std::vector<NodeTimeDistance> getAccessibleNodesFootpathsFromPoint(const Point &point,
+                                                                       const std::map<boost::uuids::uuid, Node> &nodes,
+                                                                       int maxWalkingTravelTime,
+                                                                       float walkingSpeedMetersPerSecond,
+                                                                       bool reversed = false);
+  protected:
+    std::string mode;
+    std::string host;
+    std::string port; //Could be an int, but it's used as a string every where. Keep a string remove conversions
+
+  };
+}
+
+#endif // TR_OSRM_GEO_FILTER

include/parameters.hpp

@@ -281,8 +281,6 @@ namespace TrRouting
       std::optional<boost::uuids::uuid> startingNodeUuid;
       std::optional<boost::uuids::uuid> endingNodeUuid;
 
-      std::string accessMode;
-      std::string egressMode;
       bool tryNextModeIfRoutingFails;
       std::string noResultSecondMode;
       int noResultNextAccessTimeSecondsIncrement;

src/Makefile.am

@@ -11,7 +11,9 @@ lines_cache_fetcher.cpp \
 modes_initialization.cpp \
 nodes_cache_fetcher.cpp \
 od_trips_cache_fetcher.cpp \
-osrm_fetcher.cpp \
+geofilter.cpp \
+euclideangeofilter.cpp \
+osrmgeofilter.cpp \
 paths_cache_fetcher.cpp \
 persons_cache_fetcher.cpp \
 scenarios_cache_fetcher.cpp \

src/euclideangeofilter.cpp

@@ -0,0 +1,41 @@
+#include "euclideangeofilter.hpp"
+#include "point.hpp"
+#include "node.hpp"
+#include "spdlog/spdlog.h"
+
+namespace TrRouting
+{
+
+  EuclideanGeoFilter::EuclideanGeoFilter() {}
+
+
+  std::vector<NodeTimeDistance> EuclideanGeoFilter::getAccessibleNodesFootpathsFromPoint(const Point &point,
+                                                                                         const std::map<boost::uuids::uuid, Node> &nodes,
+                                                                                         int maxWalkingTravelTime,
+                                                                                         float walkingSpeedMetersPerSecond,
+                                                                                         bool /*Unused reversed*/) {
+    std::vector<NodeTimeDistance> accessibleNodesFootpaths;
+
+    auto lengthOfOneDegree = calculateLengthOfOneDegree(point);
+    float maxDistanceMetersSquared = calculateMaxDistanceSquared(maxWalkingTravelTime, walkingSpeedMetersPerSecond);
+    float distanceMetersSquared;
+
+    spdlog::debug("use of bird distance ");
+
+    for (auto &&[uuid,node] : nodes)
+    {
+      distanceMetersSquared = calculateNodeDistanceSquared(node.point.get(), point, lengthOfOneDegree);
+
+      if (distanceMetersSquared <= maxDistanceMetersSquared)
+      {
+        int distanceMeters = sqrt(distanceMetersSquared);
+        int travelTimeSeconds = distanceMeters / walkingSpeedMetersPerSecond;
+        accessibleNodesFootpaths.push_back(NodeTimeDistance(node, travelTimeSeconds, distanceMeters));
+      }
+    }
+
+    spdlog::debug("fetched footpaths using bird distance ({} footpaths found)", accessibleNodesFootpaths.size());
+
+    return accessibleNodesFootpaths;
+  }
+}