Getting rid of returning zero speed while pedestrian and bicycle routing. Fixing routing along ferry.

5 files changed, 62 insertions, 22 deletions

diff --git a/routing/bicycle_model.cpp b/routing/bicycle_model.cpp
index 997bcb6543..0761ac44c0 100644
--- a/routing/bicycle_model.cpp
+++ b/routing/bicycle_model.cpp
@@ -607,11 +607,11 @@ void BicycleModel::Init()
   m_noBicycleType = classif().GetTypeByPath({"hwtag", "nobicycle"});
   m_bidirBicycleType = classif().GetTypeByPath({"hwtag", "bidir_bicycle"});
 
-  initializer_list<char const *> arr[] = {
-      hwtagYesBicycle, {"route", "ferry"}, {"man_made", "pier"},
+  vector<AdditionalRoadTags> additionalTags = {
+      { hwtagYesBicycle, m_maxSpeedKMpH }, {{"route", "ferry"}, m_maxSpeedKMpH}, {{"man_made", "pier"}, 7.0 },
   };
 
-  SetAdditionalRoadTypes(classif(), arr, ARRAY_SIZE(arr));
+  SetAdditionalRoadTypes(classif(), additionalTags);
 }
 
 IVehicleModel::RoadAvailability BicycleModel::GetRoadAvailability(feature::TypesHolder const & types) const
diff --git a/routing/car_model.cpp b/routing/car_model.cpp
index 5904dbddac..9b743d37ba 100644
--- a/routing/car_model.cpp
+++ b/routing/car_model.cpp
@@ -4,6 +4,8 @@
 
 #include "indexer/classificator.hpp"
 
+#include "std/vector.hpp"
+
 namespace
 {
 
@@ -42,15 +44,15 @@ namespace routing
 CarModel::CarModel()
   : VehicleModel(classif(), s_carLimits)
 {
-  initializer_list<char const *> arr[] =
+  vector<AdditionalRoadTags> additionalTags =
   {
-    { "route", "ferry", "motorcar" },
-    { "route", "ferry", "motor_vehicle" },
-    { "railway", "rail", "motor_vehicle" },
-    { "route", "shuttle_train"},
+    {{ "route", "ferry", "motorcar" }, 15.0 },
+    {{ "route", "ferry", "motor_vehicle" }, 15.0 },
+    {{ "railway", "rail", "motor_vehicle" }, 40.0 },
+    {{ "route", "shuttle_train"}, 40.0 },
   };
 
-  SetAdditionalRoadTypes(classif(), arr, ARRAY_SIZE(arr));
+  SetAdditionalRoadTypes(classif(), additionalTags);
 }
 
 // static
diff --git a/routing/pedestrian_model.cpp b/routing/pedestrian_model.cpp
index 285ed91d38..a70576c3b7 100644
--- a/routing/pedestrian_model.cpp
+++ b/routing/pedestrian_model.cpp
@@ -626,11 +626,11 @@ void PedestrianModel::Init()
   m_noFootType = classif().GetTypeByPath({ "hwtag", "nofoot" });
   m_yesFootType = classif().GetTypeByPath(hwtagYesFoot);
 
-  initializer_list<char const *> arr[] = {
-      hwtagYesFoot, {"route", "ferry"}, {"man_made", "pier"},
+  vector<AdditionalRoadTags> additionalTags = {
+      { hwtagYesFoot, m_maxSpeedKMpH }, {{"route", "ferry"}, m_maxSpeedKMpH }, {{"man_made", "pier"}, 4.0 },
   };
 
-  SetAdditionalRoadTypes(classif(), arr, ARRAY_SIZE(arr));
+  SetAdditionalRoadTypes(classif(), additionalTags);
 }
 
 IVehicleModel::RoadAvailability PedestrianModel::GetRoadAvailability(feature::TypesHolder const & types) const
diff --git a/routing/vehicle_model.cpp b/routing/vehicle_model.cpp
index 3ff16732d8..8a582e4e6b 100644
--- a/routing/vehicle_model.cpp
+++ b/routing/vehicle_model.cpp
@@ -6,12 +6,18 @@
 
 #include "base/macros.hpp"
 
+#include "std/algorithm.hpp"
 #include "std/limits.hpp"
 #include "std/initializer_list.hpp"
 
 namespace routing
 {
 
+VehicleModel::AdditionalRoadTypes::AdditionalRoadTypes(Classificator const & c, AdditionalRoadTags const & tag)
+  : m_type(c.GetTypeByPath(tag.m_hwtag)), m_speedKmPerH(tag.m_speedKmPerH)
+{
+}
+
 VehicleModel::VehicleModel(Classificator const & c, InitListT const & speedLimits)
   : m_maxSpeedKMpH(0),
     m_onewayType(c.GetTypeByPath({ "hwtag", "oneway" }))
@@ -24,10 +30,13 @@ VehicleModel::VehicleModel(Classificator const & c, InitListT const & speedLimit
 }
 
 void VehicleModel::SetAdditionalRoadTypes(Classificator const & c,
-                                          initializer_list<char const *> const * arr, size_t sz)
+                                          vector<AdditionalRoadTags> const & additionalTags)
 {
-  for (size_t i = 0; i < sz; ++i)
-    m_addRoadTypes.push_back(c.GetTypeByPath(arr[i]));
+  for (auto const & tag : additionalTags)
+  {
+    m_addRoadTypes.emplace_back(c, tag);
+    m_maxSpeedKMpH = max(m_maxSpeedKMpH, tag.m_speedKmPerH);
+  }
 }
 
 double VehicleModel::GetSpeed(FeatureType const & f) const
@@ -40,7 +49,8 @@ double VehicleModel::GetSpeed(FeatureType const & f) const
   if (restriction != RoadAvailability::NotAvailable && HasRoadType(types))
     return GetMinTypeSpeed(types);
 
-  return 0.0;
+  LOG(LERROR, ("Wrong routing types:", types));
+  return 0.5 /* Small speed to prevent routing along this edge. */;
 }
 
 double VehicleModel::GetMinTypeSpeed(feature::TypesHolder const & types) const
@@ -52,11 +62,16 @@ double VehicleModel::GetMinTypeSpeed(feature::TypesHolder const & types) const
     auto it = m_types.find(type);
     if (it != m_types.end())
       speed = min(speed, it->second);
+
+    auto const addRoadInfoIter = GetRoadTypeIter(type);
+    if (addRoadInfoIter!= m_addRoadTypes.end())
+      speed = min(speed, addRoadInfoIter->m_speedKmPerH);
   }
   if (speed <= m_maxSpeedKMpH)
     return speed;
 
-  return 0.0;
+  LOG(LERROR, ("Wrong routing types:", types));
+  return 0.5 /* Small speed to prevent routing along this edge. */;
 }
 
 bool VehicleModel::IsOneWay(FeatureType const & f) const
@@ -83,7 +98,7 @@ bool VehicleModel::IsRoad(FeatureType const & f) const
 
 bool VehicleModel::IsRoadType(uint32_t type) const
 {
-  return find(m_addRoadTypes.begin(), m_addRoadTypes.end(), type) != m_addRoadTypes.end() ||
+  return GetRoadTypeIter(type) != m_addRoadTypes.end() ||
          m_types.find(ftypes::BaseChecker::PrepareToMatch(type, 2)) != m_types.end();
 }
 
@@ -92,6 +107,12 @@ IVehicleModel::RoadAvailability VehicleModel::GetRoadAvailability(feature::Types
   return RoadAvailability::Unknown;
 }
 
+vector<VehicleModel::AdditionalRoadTypes>::const_iterator VehicleModel::GetRoadTypeIter(uint32_t type) const
+{
+  return find_if(m_addRoadTypes.begin(), m_addRoadTypes.end(),
+                 [&type](AdditionalRoadTypes const & t){ return t.m_type == type;});
+}
+
 string DebugPrint(IVehicleModel::RoadAvailability const l)
 {
   switch (l)
diff --git a/routing/vehicle_model.hpp b/routing/vehicle_model.hpp
index b16bf32edf..b45f8dd14b 100644
--- a/routing/vehicle_model.hpp
+++ b/routing/vehicle_model.hpp
@@ -1,9 +1,8 @@
 #pragma once
-#include "base/buffer_vector.hpp"
-
 #include "std/cstdint.hpp"
 #include "std/initializer_list.hpp"
 #include "std/shared_ptr.hpp"
+#include "std/string.hpp"
 #include "std/unordered_map.hpp"
 #include "std/utility.hpp"
 #include "std/vector.hpp"
@@ -90,12 +89,18 @@ public:
   }
 
 protected:
+  struct AdditionalRoadTags
+  {
+    initializer_list<char const *> m_hwtag;
+    double m_speedKmPerH;
+  };
+
   /// @returns a special restriction which is set to the feature.
   virtual RoadAvailability GetRoadAvailability(feature::TypesHolder const & types) const;
 
   /// Used in derived class constructors only. Not for public use.
   void SetAdditionalRoadTypes(Classificator const & c,
-                              initializer_list<char const *> const * arr, size_t sz);
+                              vector<AdditionalRoadTags> const & additionalTags);
 
   /// \returns true if |types| is a oneway feature.
   /// \note According to OSM, tag "oneway" could have value "-1". That means it's a oneway feature
@@ -109,9 +114,21 @@ protected:
   double m_maxSpeedKMpH;
 
 private:
+  struct AdditionalRoadTypes
+  {
+    AdditionalRoadTypes(Classificator const & c, AdditionalRoadTags const & tag);
+
+    bool operator==(AdditionalRoadTypes const & rhs) const { return m_type == rhs.m_type; }
+
+    uint32_t const m_type;
+    double const m_speedKmPerH;
+  };
+
+  vector<AdditionalRoadTypes>::const_iterator GetRoadTypeIter(uint32_t type) const;
+
   unordered_map<uint32_t, double> m_types;
 
-  buffer_vector<uint32_t, 4> m_addRoadTypes;
+  vector<AdditionalRoadTypes> m_addRoadTypes;
   uint32_t m_onewayType;
 };