pastk/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

Review fixes.

Browse source
This commit is contained in:
vng 2015-04-09 12:29:18 +03:00 • committed by Alex Zolotarev
parent 0ca724004a
commit ddcaf0f734
3 changed files with 57 additions and 46 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
routing/features_road_graph.cpp
View file

@ -25,6 +25,7 @@ uint32_t crossFound = 0;
uint32_t crossCheck = 0;
/// @todo Factor out vehicle model as a parameter for the features graph.
FeaturesRoadGraph::FeaturesRoadGraph(Index const * pIndex, size_t mwmID)
: m_pIndex(pIndex), m_mwmID(mwmID), m_vehicleModel(new PedestrianModel()), m_cache(FEATURE_CACHE_SIZE),
m_cacheMiss(0), m_cacheAccess(0)
@ -299,8 +300,8 @@ void FeaturesRoadGraph::ReconstructPath(RoadPosVectorT const & positions, Route
Route::TimesT times;
/// @todo Make proper time and turns calculation.
times.push_back(Route::TimeItemT(poly.size() - 1, 100500));
turnsDir.push_back(Route::TurnItem(poly.size() - 1, turns::ReachedYourDestination));
times.emplace_back(poly.size() - 1, 100500);
turnsDir.emplace_back(poly.size() - 1, turns::ReachedYourDestination);
route.SetGeometry(poly.rbegin(), poly.rend());
route.SetTurnInstructions(turnsDir);

65
routing/vehicle_model.cpp
View file

@ -39,43 +39,45 @@ VehicleModel::InitListT const s_carLimits =
//{ {"highway", "construction"}, 40 },
};
static int const kPedestrianSpeedKMpH = 5;
VehicleModel::InitListT const s_pedestrianLimits =
{
{ {"highway", "primary"}, 5 },
{ {"highway", "primary_link"}, 5 },
{ {"highway", "secondary"}, 5 },
{ {"highway", "secondary_link"}, 5 },
{ {"highway", "tertiary"}, 5 },
{ {"highway", "tertiary_link"}, 5 },
{ {"highway", "residential"}, 5 },
{ {"highway", "pedestrian"}, 5 },
{ {"highway", "unclassified"}, 5 },
{ {"highway", "service"}, 5 },
{ {"highway", "living_street"}, 5 },
{ {"highway", "road"}, 5 },
{ {"highway", "track"}, 5 },
{ {"highway", "path"}, 5 },
{ {"highway", "steps"}, 5 },
{ {"highway", "pedestrian"}, 5 },
{ {"highway", "footway"}, 5 },
{ {"highway", "primary"}, kPedestrianSpeedKMpH },
{ {"highway", "primary_link"}, kPedestrianSpeedKMpH },
{ {"highway", "secondary"}, kPedestrianSpeedKMpH },
{ {"highway", "secondary_link"}, kPedestrianSpeedKMpH },
{ {"highway", "tertiary"}, kPedestrianSpeedKMpH },
{ {"highway", "tertiary_link"}, kPedestrianSpeedKMpH },
{ {"highway", "residential"}, kPedestrianSpeedKMpH },
{ {"highway", "pedestrian"}, kPedestrianSpeedKMpH },
{ {"highway", "unclassified"}, kPedestrianSpeedKMpH },
{ {"highway", "service"}, kPedestrianSpeedKMpH },
{ {"highway", "living_street"}, kPedestrianSpeedKMpH },
{ {"highway", "road"}, kPedestrianSpeedKMpH },
{ {"highway", "track"}, kPedestrianSpeedKMpH },
{ {"highway", "path"}, kPedestrianSpeedKMpH },
{ {"highway", "steps"}, kPedestrianSpeedKMpH },
{ {"highway", "pedestrian"}, kPedestrianSpeedKMpH },
{ {"highway", "footway"}, kPedestrianSpeedKMpH },
};
VehicleModel::VehicleModel(Classificator const & c, VehicleModel::InitListT const & speedLimits)
: m_maxSpeed(0),
: m_maxSpeedKMpH(0),
m_onewayType(c.GetTypeByPath({ "hwtag", "oneway" }))
{
for (auto const & v : speedLimits)
{
m_maxSpeed = max(m_maxSpeed, v.m_speed);
m_types[c.GetTypeByPath(vector<string>(v.m_types, v.m_types + 2))] = v.m_speed;
m_maxSpeedKMpH = max(m_maxSpeedKMpH, v.m_speedKMpH);
m_types[c.GetTypeByPath(vector<string>(v.m_types, v.m_types + 2))] = v.m_speedKMpH;
}
}
template <size_t N>
void VehicleModel::SetAdditionalRoadTypes(Classificator const & c, initializer_list<char const *> (&arr)[N])
void VehicleModel::SetAdditionalRoadTypes(Classificator const & c,
initializer_list<char const *> const * arr, size_t sz)
{
for (size_t i = 0; i < N; ++i)
for (size_t i = 0; i < sz; ++i)
m_addRoadTypes.push_back(c.GetTypeByPath(arr[i]));
}
@ -86,7 +88,7 @@ double VehicleModel::GetSpeed(FeatureType const & f) const
double VehicleModel::GetSpeed(feature::TypesHolder const & types) const
{
double speed = m_maxSpeed * 2;
double speed = m_maxSpeedKMpH * 2;
for (uint32_t t : types)
{
uint32_t const type = ftypes::BaseChecker::PrepareToMatch(t, 2);
@ -94,7 +96,7 @@ double VehicleModel::GetSpeed(feature::TypesHolder const & types) const
if (it != m_types.end())
speed = min(speed, it->second);
}
if (speed <= m_maxSpeed)
if (speed <= m_maxSpeedKMpH)
return speed;
return 0.0;
@ -117,8 +119,8 @@ bool VehicleModel::IsRoad(FeatureType const & f) const
bool VehicleModel::IsRoad(uint32_t type) const
{
return (find(m_addRoadTypes.begin(), m_addRoadTypes.end(), type) != m_addRoadTypes.end() ||
m_types.find(ftypes::BaseChecker::PrepareToMatch(type, 2)) != m_types.end());
return find(m_addRoadTypes.begin(), m_addRoadTypes.end(), type) != m_addRoadTypes.end() ||
m_types.find(ftypes::BaseChecker::PrepareToMatch(type, 2)) != m_types.end();
}
@ -132,7 +134,7 @@ CarModel::CarModel()
{ "railway", "rail", "motor_vehicle" },
};
SetAdditionalRoadTypes(classif(), arr);
SetAdditionalRoadTypes(classif(), arr, ARRAY_SIZE(arr));
}
@ -146,21 +148,20 @@ PedestrianModel::PedestrianModel()
{ "man_made", "pier" },
};
SetAdditionalRoadTypes(classif(), arr);
SetAdditionalRoadTypes(classif(), arr, ARRAY_SIZE(arr));
}
bool PedestrianModel::IsFoot(feature::TypesHolder const & types) const
{
return (find(types.begin(), types.end(), m_noFootType) == types.end());
return find(types.begin(), types.end(), m_noFootType) == types.end();
}
double PedestrianModel::GetSpeed(FeatureType const & f) const
{
feature::TypesHolder types(f);
// Fixed speed: 5 km/h.
if (IsFoot(types) && IsRoad(types))
return m_maxSpeed;
return m_maxSpeedKMpH;
else
return 0.0;
}

33
routing/vehicle_model.hpp
View file

@ -20,8 +20,11 @@ class IVehicleModel
public:
virtual ~IVehicleModel() {}
/// @return Allowed speed in KMpH.
/// 0 means that is's forbidden to drive on this feature or it's not a road at all.
virtual double GetSpeed(FeatureType const & f) const = 0;
virtual double GetMaxSpeed() const = 0;
virtual bool IsOneWay(FeatureType const & f) const = 0;
};
@ -30,16 +33,19 @@ class VehicleModel : public IVehicleModel
public:
struct SpeedForType
{
char const * m_types[2];
double m_speed;
char const * m_types[2]; /// 2-arity road type
double m_speedKMpH; /// max allowed speed on this road type
};
typedef initializer_list<SpeedForType> InitListT;
VehicleModel(Classificator const & c, InitListT const & speedLimits);
virtual double GetSpeed(FeatureType const & f) const;
virtual double GetMaxSpeed() const { return m_maxSpeed; }
virtual bool IsOneWay(FeatureType const & f) const;
/// @name Overrides from IVehicleModel.
//@{
double GetSpeed(FeatureType const & f) const override;
double GetMaxSpeed() const override { return m_maxSpeedKMpH; }
bool IsOneWay(FeatureType const & f) const override;
//@}
double GetSpeed(feature::TypesHolder const & types) const;
bool IsOneWay(feature::TypesHolder const & types) const;
@ -55,14 +61,14 @@ public:
bool IsRoad(uint32_t type) const;
protected:
template <size_t N>
void SetAdditionalRoadTypes(Classificator const & c, initializer_list<char const *> (&arr)[N]);
/// Used in derived class constructors only. Not for public use.
void SetAdditionalRoadTypes(Classificator const & c,
initializer_list<char const *> const * arr, size_t sz);
double m_maxSpeed;
double m_maxSpeedKMpH;
private:
typedef unordered_map<uint32_t, double> TypesT;
TypesT m_types;
unordered_map<uint32_t, double> m_types;
buffer_vector<uint32_t, 4> m_addRoadTypes;
uint32_t m_onewayType;
@ -83,8 +89,11 @@ class PedestrianModel : public VehicleModel
public:
PedestrianModel();
virtual double GetSpeed(FeatureType const & f) const;
virtual bool IsOneWay(FeatureType const &) const { return false; }
/// @name Overrides from VehicleModel.
//@{
double GetSpeed(FeatureType const & f) const override;
bool IsOneWay(FeatureType const &) const override { return false; }
//@}
};
}