1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
#pragma once
#include "base/followed_polyline.hpp"
#include "routing_settings.hpp"
#include "turns.hpp"
#include "geometry/polyline2d.hpp"
#include "std/vector.hpp"
#include "std/set.hpp"
#include "std/string.hpp"
namespace location
{
class GpsInfo;
class RouteMatchingInfo;
}
namespace routing
{
class Route
{
public:
using TTurns = vector<turns::TurnItem>;
using TTimeItem = pair<uint32_t, double>;
using TTimes = vector<TTimeItem>;
using TStreetItem = pair<uint32_t, string>;
using TStreets = vector<TStreetItem>;
explicit Route(string const & router)
: m_router(router), m_routingSettings(GetCarRoutingSettings()) {}
template <class TIter>
Route(string const & router, TIter beg, TIter end)
: m_router(router), m_routingSettings(GetCarRoutingSettings()), m_poly(beg, end)
{
Update();
}
Route(string const & router, vector<m2::PointD> const & points, string const & name = string());
void Swap(Route & rhs);
template <class TIter> void SetGeometry(TIter beg, TIter end)
{
if (beg == end)
FollowedPolyline().Swap(m_poly);
else
FollowedPolyline(beg, end).Swap(m_poly);
Update();
}
inline void SetTurnInstructions(TTurns & v)
{
swap(m_turns, v);
}
inline void SetSectionTimes(TTimes & v)
{
swap(m_times, v);
}
inline void SetStreetNames(TStreets & v)
{
swap(m_streets, v);
}
uint32_t GetTotalTimeSec() const;
uint32_t GetCurrentTimeToEndSec() const;
FollowedPolyline const & GetFollowedPolyline() const { return m_poly; }
string const & GetRouterId() const { return m_router; }
m2::PolylineD const & GetPoly() const { return m_poly.GetPolyline(); }
TTurns const & GetTurns() const { return m_turns; }
void GetTurnsDistances(vector<double> & distances) const;
string const & GetName() const { return m_name; }
bool IsValid() const { return (m_poly.GetPolyline().GetSize() > 1); }
double GetTotalDistanceMeters() const;
double GetCurrentDistanceFromBeginMeters() const;
double GetCurrentDistanceToEndMeters() const;
double GetMercatorDistanceFromBegin() const;
/// \brief GetCurrentTurn returns information about the nearest turn.
/// \param distanceToTurnMeters is a distance from current position to the nearest turn.
/// \param turn is information about the nearest turn.
bool GetCurrentTurn(double & distanceToTurnMeters, turns::TurnItem & turn) const;
/// \brief Returns a name of a street where the user rides at this moment.
void GetCurrentStreetName(string &) const;
/// \brief Returns a name of a street next to idx point of the path. Function avoids short unnamed links.
void GetStreetNameAfterIdx(uint32_t idx, string &) const;
/// @return true if GetNextTurn() returns a valid result in parameters, false otherwise.
/// \param distanceToTurnMeters is a distance from current position to the second turn.
/// \param turn is information about the second turn.
/// @return true if its parameters are filled with correct result.
/// \note All parameters are filled while a GetNextTurn function call.
bool GetNextTurn(double & distanceToTurnMeters, turns::TurnItem & turn) const;
/// \brief Extract information about zero, one or two nearest turns depending on current position.
/// @return true if its parameter is filled with correct result. (At least with one element.)
bool GetNextTurns(vector<turns::TurnItemDist> & turns) const;
void GetCurrentDirectionPoint(m2::PointD & pt) const;
/// @return true If position was updated successfully (projection within gps error radius).
bool MoveIterator(location::GpsInfo const & info) const;
void MatchLocationToRoute(location::GpsInfo & location, location::RouteMatchingInfo & routeMatchingInfo) const;
bool IsCurrentOnEnd() const;
/// Add country name if we have no country filename to make route
void AddAbsentCountry(string const & name);
/// Get absent file list of a routing files for shortest path finding
set<string> const & GetAbsentCountries() const { return m_absentCountries; }
inline void SetRoutingSettings(RoutingSettings const & routingSettings)
{
m_routingSettings = routingSettings;
Update();
}
private:
/// Call this fucnction when geometry have changed.
void Update();
double GetPolySegAngle(size_t ind) const;
TTurns::const_iterator GetCurrentTurn() const;
TStreets::const_iterator GetCurrentStreetNameIterAfter(FollowedPolyline::Iter iter) const;
private:
friend string DebugPrint(Route const & r);
string m_router;
RoutingSettings m_routingSettings;
string m_name;
FollowedPolyline m_poly;
FollowedPolyline m_simplifiedPoly;
set<string> m_absentCountries;
TTurns m_turns;
TTimes m_times;
TStreets m_streets;
mutable double m_currentTime;
};
} // namespace routing
|
