Isochrone

modules/isochrone/CMakeLists.txt

@@ -0,0 +1,34 @@
+cmake_minimum_required(VERSION 3.10)
+project(motis)
+
+include_directories(include)
+
+file(GLOB_RECURSE motis-isochrone-files src/*.cc)
+add_library(motis-isochrone STATIC ${motis-isochrone-files})
+target_include_directories(motis-isochrone PUBLIC include)
+target_compile_features(motis-isochrone PUBLIC cxx_std_17)
+target_link_libraries(motis-isochrone ${Boost_PROGRAM_OPTIONS_LIBRARY} ${Boost_SYSTEM_LIBRARY} motis-module)
+target_compile_options(motis-isochrone PRIVATE ${MOTIS_CXX_FLAGS})
+
+include_directories(eval/include)
+
+file(GLOB_RECURSE motis-isochrone-generator-files eval/src/query_generator.cc)
+add_executable(motis-isochrone-generator EXCLUDE_FROM_ALL ${motis-isochrone-generator-files})
+target_compile_features(motis-isochrone-generator PUBLIC cxx_std_17)
+target_link_libraries(motis-isochrone-generator motis-bootstrap motis-core conf ${CMAKE_THREAD_LIBS_INIT} ianatzdb-res)
+target_compile_options(motis-isochrone-generator PRIVATE ${MOTIS_CXX_FLAGS})
+set_target_properties(motis-isochrone-generator PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}")
+
+file(GLOB_RECURSE motis-iso-routing-files eval/src/isochrone_to_routing_query_generator.cc)
+add_executable(motis-iso-routing EXCLUDE_FROM_ALL ${motis-iso-routing-files})
+target_compile_features(motis-iso-routing PUBLIC cxx_std_17)
+target_link_libraries(motis-iso-routing motis-core conf ${CMAKE_THREAD_LIBS_INIT})
+target_compile_options(motis-iso-routing PRIVATE ${MOTIS_CXX_FLAGS})
+set_target_properties(motis-iso-routing PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}")
+
+file(GLOB_RECURSE motis-iso-comparator-files eval/src/isochrone_routing_comparator.cc)
+add_executable(motis-iso-comparator EXCLUDE_FROM_ALL ${motis-iso-comparator-files})
+target_compile_features(motis-iso-comparator PUBLIC cxx_std_17)
+target_link_libraries(motis-iso-comparator motis-bootstrap motis-core conf ${CMAKE_THREAD_LIBS_INIT})
+target_compile_options(motis-iso-comparator PRIVATE ${MOTIS_CXX_FLAGS})
+set_target_properties(motis-iso-comparator PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}")

modules/isochrone/eval/src/isochrone_routing_comparator.cc

@@ -0,0 +1,85 @@
+
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <random>
+
+#include "boost/algorithm/string.hpp"
+#include "boost/date_time/gregorian/gregorian_types.hpp"
+#include "boost/date_time/posix_time/posix_time.hpp"
+#include "boost/program_options.hpp"
+
+#include "utl/erase.h"
+#include "utl/to_vec.h"
+
+#include "conf/options_parser.h"
+
+#include "motis/core/schedule/time.h"
+#include "motis/core/access/time_access.h"
+#include "motis/module/message.h"
+#include "motis/bootstrap/dataset_settings.h"
+#include "motis/bootstrap/motis_instance.h"
+
+using namespace flatbuffers;
+using namespace motis;
+using namespace motis::module;
+using namespace motis::isochrone;
+using namespace motis::routing;
+
+int main(int argc, char const** argv) {
+  if (argc != 3) {
+    std::cout << "Usage: " << argv[0]
+              << " {iso_responses.txt} {routing_responses.txt}\n";
+    return 0;
+  }
+  std::ifstream in_i(argv[1]), in_r(argv[2]);
+  std::ofstream failed_routes("failed_routes.txt");
+  std::string line_i, line_r;
+  std::map<int, std::tuple<uint64_t, std::string, std::string, std::string>> times;
+  int mismatches = 0;
+  while (in_i.peek() != EOF && !in_i.eof()){
+
+    std::getline(in_i, line_i);
+    auto const i_msg = make_msg(line_i);
+    auto const i_res = motis_content(IsochroneResponse, i_msg);
+    for(int i = 0; i<i_res->arrival_times()->size(); ++i) {
+      times[i_msg->id()*1000000+i] = {i_res->arrival_times()->Get(i),i_res->stations()->Get(0)->id()->str(),
+                                      i_res->stations()->Get(i)->id()->str(), i_res->stations()->Get(i)->name()->str()};
+    }
+
+
+  }
+  while (in_r.peek() != EOF && !in_r.eof()) {
+
+    std::getline(in_r, line_r);
+    auto const r_msg = make_msg(line_r);
+    auto const r_res = motis_content(RoutingResponse, r_msg);
+    uint64_t at = 0;
+    for(auto it : *r_res->connections()) {
+      auto at_new = (it->stops()->Get(it->stops()->size()-1)->arrival()->time());
+
+      if(it->stops()->size()==2 && it->stops()->Get(0)->departure()->time() == r_res->interval_begin()+1800) {
+        at_new -= 1800;
+      }
+
+      if(at_new < at || at == 0) {
+        at = at_new;
+      }
+    }
+
+    auto const remaining_time = 3600 - (at - r_res->interval_begin());
+    if (std::get<0>(times.at(r_msg->id())) != remaining_time && r_msg->id()%1000000!=0) {
+      auto x = std::get<0>(times.at(r_msg->id()));
+      mismatches++;
+      failed_routes << "id:" << r_msg->id() << " iso time:"<< x << " routing time:" << remaining_time
+      <<" start:"<< std::get<1>(times.at(r_msg->id()))
+      <<" dest:"<< std::get<2>(times.at(r_msg->id()))<<" "<< std::get<3 >(times.at(r_msg->id())) <<std::endl;
+    }
+  }
+
+  failed_routes.flush();
+
+  std::cout << mismatches << std::endl;
+  return 0;
+};
+

modules/isochrone/eval/src/isochrone_to_routing_query_generator.cc

@@ -0,0 +1,141 @@
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <random>
+
+#include "boost/algorithm/string.hpp"
+#include "boost/date_time/posix_time/posix_time.hpp"
+#include "boost/program_options.hpp"
+
+#include "geo/latlng.h"
+#include "geo/webmercator.h"
+
+#include "utl/erase.h"
+
+#include "motis/core/access/time_access.h"
+#include "motis/module/message.h"
+
+
+
+using namespace flatbuffers;
+using namespace motis;
+using namespace motis::module;
+using namespace motis::routing;
+using namespace motis::intermodal;
+using namespace motis::isochrone;
+using namespace motis::ppr;
+
+
+std::string query(int id,
+                  std::time_t interval_start, std::time_t interval_end,
+                  const Position *start_pos, const String *id_str) {
+  message_creator fbb;
+  auto const start = Position(start_pos->lat(), start_pos->lng());
+  auto const interval = Interval(interval_start, interval_end);
+  std::vector<Offset<ModeWrapper>> modes_start{CreateModeWrapper(
+          fbb, Mode_FootPPR,
+          CreateFootPPR(fbb, CreateSearchOptions(fbb, fbb.CreateString("default"),
+                                                 15*60))
+                  .Union())};
+  std::vector<Offset<ModeWrapper>> modes_dest{CreateModeWrapper(
+          fbb, Mode_FootPPR,
+          CreateFootPPR(fbb, CreateSearchOptions(fbb, fbb.CreateString("default"),
+                                                 0))
+                  .Union())};
+  fbb.create_and_finish(
+          MsgContent_IntermodalRoutingRequest,
+          CreateIntermodalRoutingRequest(
+                  fbb, IntermodalStart_IntermodalOntripStart,
+                  CreateIntermodalOntripStart(fbb, &start, interval_start)
+                          .Union(),
+                  fbb.CreateVector(modes_start), IntermodalDestination_InputStation,
+                  CreateInputStation(fbb, fbb.CreateString(id_str), fbb.CreateString("")).Union(),
+                  fbb.CreateVector(modes_dest), SearchType_Default,
+                  SearchDir_Forward)
+                  .Union(),
+          "/intermodal");
+  auto msg = make_msg(fbb);
+  msg->get()->mutate_id(id);
+
+  auto json = msg->to_json();
+  utl::erase(json, '\n');
+  return json;
+}
+
+bool generate_routing_query(const int i, std::pair<msg_ptr, msg_ptr> qr, std::ofstream& routing_queries) {
+  if (!std::get<0>(qr) || !std::get<1>(qr)) {
+    return false;
+  }
+  auto const has_error = std::apply(
+          [](auto&&... args) {
+            auto error = false;
+            (([&](msg_ptr const& msg) {
+              error = error || msg->get()->content_type() == MsgContent_MotisError;
+            })(args),
+                    ...);
+            return error;
+          },
+          qr);
+  if (has_error) {
+    return true;
+  }
+  auto const& q = std::get<0>(qr);
+  auto const& r = std::get<1>(qr);
+
+  auto const& q_msg = motis_content(IsochroneRequest, q);
+  auto const& r_msg = motis_content(IsochroneResponse, r);
+
+  std::cout << "query nr:" << i << std::endl;
+  for(int j = 0; j < r_msg->stations()->size(); ++j) {
+    routing_queries << query(i*1000000 + j, q_msg->departure_time(),
+                             q_msg->departure_time()+q_msg->max_travel_time(), q_msg->position(),
+                             r_msg->stations()->Get(j)->id()) << "\n";
+  }
+
+  return true;
+};
+
+int main(int argc, char const** argv) {
+
+  if (argc != 3) {
+    std::cout << "Usage: " << argv[0]
+              << " {queries.txt} {responses.txt}\n";
+    return 0;
+  }
+
+  std::ifstream in_q(argv[1]), in_r(argv[2]);
+
+  std::ofstream routing_queries("isochrone_routing_queries.txt");
+  std::string line_q, line_r;
+  std::map<int, std::pair<msg_ptr, msg_ptr>> pending_msgs;
+  while (in_q.peek() != EOF && !in_q.eof() && in_r.peek() != EOF && !in_r.eof()){
+
+    std::getline(in_q, line_q);
+    std::getline(in_r, line_r);
+
+    auto const q = make_msg(line_q);
+    auto const r = make_msg(line_r);
+
+    std::get<0>(pending_msgs[q->id()]) = q;
+    std::get<1>(pending_msgs[r->id()]) = r;
+
+    for (auto const i : {q->id(), r->id()}) {
+      auto const it = pending_msgs.find(i);
+      if (it == end(pending_msgs)) {
+        continue;
+      }
+
+      if (generate_routing_query(i, it->second, routing_queries)) {
+        pending_msgs.erase(i);
+      }
+    }
+
+
+
+  }
+  routing_queries.flush();
+  return 0;
+}
+
+
+