Organic Maps sources as of 02.04.2025 (fad26bbf22ac3da75e01e62aa01e5c8e11861005)

To expand with full Organic Maps and Maps.ME commits history run:
  git remote add om-historic [om-historic.git repo url]
  git fetch --tags om-historic
  git replace squashed-history historic-commits

routing/routes_builder/routes_builder_tool/routes_builder_tool.cpp

@@ -0,0 +1,144 @@
+#include "routing/routes_builder/routes_builder_tool/utils.hpp"
+
+#include "routing/routes_builder/routes_builder.hpp"
+
+#include "platform/platform.hpp"
+
+#include "base/assert.hpp"
+#include "base/logging.hpp"
+
+#include <exception>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <gflags/gflags.h>
+
+DEFINE_uint64(threads, 0,
+              "The number of threads. std::thread::hardware_concurrency() is used by default.");
+
+DEFINE_string(routes_file, "", "Path to file with routes in format: \n\t"
+                               "first_start_lat first_start_lon first_finish_lat first_finish_lon\n\t"
+                               "second_start_lat second_start_lon second_finish_lat second_finish_lon\n\t"
+                               "...");
+
+DEFINE_string(dump_path, "", "Path where routes will be dumped after building."
+                             "Useful for intermediate results, because routes building "
+                             "is a long process.");
+
+DEFINE_string(data_path, "", "Data path.");
+DEFINE_string(resources_path, "", "Resources path.");
+
+DEFINE_string(api_name, "", "Api name, current options: mapbox,google");
+DEFINE_string(api_token, "", "Token for chosen api.");
+
+DEFINE_uint64(start_from, 0, "The line number from which the tool should start reading.");
+
+DEFINE_int32(timeout, 10 * 60, "Timeout in seconds for each route building. "
+                               "0 means without timeout (default: 10 minutes).");
+
+DEFINE_bool(verbose, false, "Verbose logging (default: false)");
+
+DEFINE_int32(launches_number, 1, "Number of launches of routes buildings. Needs for benchmarking (default: 1)");
+DEFINE_string(vehicle_type, "car", "Vehicle type: car|pedestrian|bicycle|transit. (Only for mapsme).");
+
+using namespace routing;
+using namespace routes_builder;
+using namespace routing_quality;
+
+namespace
+{
+bool IsLocalBuild()
+{
+  return !FLAGS_routes_file.empty() && FLAGS_api_name.empty() && FLAGS_api_token.empty();
+}
+
+bool IsApiBuild()
+{
+  return !FLAGS_routes_file.empty() && !FLAGS_api_name.empty() && !FLAGS_api_token.empty();
+}
+
+void CheckDirExistence(std::string const & dir)
+{
+  CHECK(Platform::IsDirectory(dir), ("Can not find directory:", dir));
+}
+}  // namespace
+
+int Main(int argc, char ** argv)
+{
+  gflags::SetUsageMessage("This tool provides routes building for them further analyze.");
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+
+  CHECK_GREATER_OR_EQUAL(FLAGS_timeout, 0, ("Timeout should be greater than zero."));
+
+  CHECK(!FLAGS_routes_file.empty(),
+        ("\n\n\t--routes_file is required.",
+         "\n\nType --help for usage."));
+
+  if (!FLAGS_data_path.empty())
+    GetPlatform().SetWritableDirForTests(FLAGS_data_path);
+
+  if (!FLAGS_resources_path.empty())
+    GetPlatform().SetResourceDir(FLAGS_resources_path);
+
+  CHECK(IsLocalBuild() || IsApiBuild(),
+        ("\n\n\t--routes_file empty is:", FLAGS_routes_file.empty(),
+         "\n\t--api_name empty is:", FLAGS_api_name.empty(),
+         "\n\t--api_token empty is:", FLAGS_api_token.empty(),
+         "\n\nType --help for usage."));
+
+  CHECK(!FLAGS_dump_path.empty(),
+        ("\n\n\t--dump_path is empty. It makes no sense to run this tool. No result will be saved.",
+         "\n\nType --help for usage."));
+
+  CHECK_GREATER_OR_EQUAL(FLAGS_launches_number, 1, ());
+
+  if (Platform::IsFileExistsByFullPath(FLAGS_dump_path))
+    CheckDirExistence(FLAGS_dump_path);
+  else
+    CHECK_EQUAL(Platform::MkDir(FLAGS_dump_path), Platform::EError::ERR_OK,());
+
+  if (IsLocalBuild())
+  {
+    auto const launchesNumber = static_cast<uint32_t>(FLAGS_launches_number);
+    if (launchesNumber > 1)
+    {
+      LOG(LINFO,
+          ("Benchmark mode is activated. Each route will be built", launchesNumber, "times."));
+    }
+
+    BuildRoutes(FLAGS_routes_file, FLAGS_dump_path, FLAGS_start_from, FLAGS_threads, FLAGS_timeout,
+                FLAGS_vehicle_type, FLAGS_verbose, launchesNumber);
+  }
+
+  if (IsApiBuild())
+  {
+    auto api = CreateRoutingApi(FLAGS_api_name, FLAGS_api_token);
+    BuildRoutesWithApi(std::move(api), FLAGS_routes_file, FLAGS_dump_path, FLAGS_start_from);
+  }
+
+  return 0;
+}
+
+int main(int argc, char ** argv)
+{
+  try
+  {
+    Main(argc, argv);
+  }
+  catch (RootException const & e)
+  {
+    LOG(LERROR, ("Core exception:", e.Msg()));
+  }
+  catch (std::exception const & e)
+  {
+    LOG(LERROR, ("Std exception:", e.what()));
+  }
+  catch (...)
+  {
+    LOG(LERROR, ("Unknown exception."));
+  }
+
+  LOG(LINFO, ("Done."));
+  return 0;
+}