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

Review fixes.

Browse source
This commit is contained in:
Vladimir Byko-Ianko 2018-06-01 17:26:04 +03:00 • committed by mpimenov
parent 1d4174dd50
commit 9d5562b78e
7 changed files with 56 additions and 57 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

43
map/extrapolation/extrapolator.cpp
View file

@ -11,10 +11,10 @@
namespace
{
// If the difference of an value between two instances of GpsInfo is greater
// If the difference of values between two instances of GpsInfo is greater
// than the appropriate constant below the extrapolator will be switched off for
// these two instances of GpsInfo.
double constexpr kMaxExtrapolationSpeedMPS = 120.0;
double constexpr kMaxExtrapolationSpeedMPS = 85.0;
double constexpr kMaxExtrapolationDistMeters = 120.0;
double constexpr kMaxExtrapolationTimeSeconds = 2.1;
@ -53,7 +53,7 @@ location::GpsInfo LinearExtrapolation(location::GpsInfo const & gpsInfo1,
location::GpsInfo result = gpsInfo2;
LinearExtrapolator e(timeBetweenPointsMs, timeAfterPoint2Ms);
result.m_timestamp += timeAfterPoint2Ms;
result.m_timestamp += static_cast<double>(timeAfterPoint2Ms) / 1000.0;
result.m_longitude = e.Extrapolate(gpsInfo1.m_longitude, gpsInfo2.m_longitude);
result.m_latitude = e.Extrapolate(gpsInfo1.m_latitude, gpsInfo2.m_latitude);
result.m_horizontalAccuracy = e.Extrapolate(gpsInfo1.m_horizontalAccuracy, gpsInfo2.m_horizontalAccuracy);
@ -78,19 +78,22 @@ location::GpsInfo LinearExtrapolation(location::GpsInfo const & gpsInfo1,
bool AreCoordsGoodForExtrapolation(location::GpsInfo const & beforeLastGpsInfo,
location::GpsInfo const & lastGpsInfo)
{
if (!beforeLastGpsInfo.IsValid() || !lastGpsInfo.IsValid())
return false;
double const distM =
ms::DistanceOnEarth(beforeLastGpsInfo.m_latitude, beforeLastGpsInfo.m_longitude,
lastGpsInfo.m_latitude, lastGpsInfo.m_longitude);
double const timeS = lastGpsInfo.m_timestamp - beforeLastGpsInfo.m_timestamp;
// Note. |timeS| may be less than zero. (beforeLastGpsInfo.m_timestamp >= lastGpsInfo.m_timestamp)
// It may happen in rare cases because GpsInfo::m_timestamp is not monotonic generally.
// Note. |timeS| may be less than zero. (beforeLastGpsInfo.m_timestampS >= lastGpsInfo.m_timestampS)
// It may happen in rare cases because GpsInfo::m_timestampS is not monotonic generally.
// Please see comment in declaration of class GpsInfo for details.
// @TODO(bykoianko) Switching off extrapolation based on acceleration should be implemented.
// Switching off extrapolation based on speed, distance and time.
return distM / timeS <= kMaxExtrapolationSpeedMPS && distM <= kMaxExtrapolationDistMeters &&
timeS <= kMaxExtrapolationTimeSeconds && timeS > 0;
return timeS > 0 && distM / timeS <= kMaxExtrapolationSpeedMPS &&
distM <= kMaxExtrapolationDistMeters && timeS <= kMaxExtrapolationTimeSeconds;
}
// Extrapolator ------------------------------------------------------------------------------------
@ -122,22 +125,21 @@ void Extrapolator::Enable(bool enabled)
void Extrapolator::ExtrapolatedLocationUpdate()
{
location::GpsInfo gpsInfo;
do
{
lock_guard<mutex> guard(m_mutex);
uint64_t const extrapolationTimeMs = kExtrapolationPeriodMs * m_extrapolationCounter;
if (extrapolationTimeMs >= kMaxExtrapolationTimeMs || !m_lastGpsInfo.IsValid())
break;
if (DoesExtrapolationWork())
if (extrapolationTimeMs < kMaxExtrapolationTimeMs && m_lastGpsInfo.IsValid())
{
gpsInfo = LinearExtrapolation(m_beforeLastGpsInfo, m_lastGpsInfo, extrapolationTimeMs);
break;
if (DoesExtrapolationWork())
{
gpsInfo = LinearExtrapolation(m_beforeLastGpsInfo, m_lastGpsInfo, extrapolationTimeMs);
}
else if (m_lastGpsInfo.IsValid())
{
gpsInfo = m_lastGpsInfo;
}
}
if (m_lastGpsInfo.IsValid())
gpsInfo = m_lastGpsInfo;
} while (false);
}
if (gpsInfo.IsValid())
{
@ -162,11 +164,8 @@ void Extrapolator::ExtrapolatedLocationUpdate()
bool Extrapolator::DoesExtrapolationWork() const
{
if (!m_isEnabled || m_extrapolationCounter == kExtrapolationCounterUndefined ||
!m_lastGpsInfo.IsValid() || !m_beforeLastGpsInfo.IsValid())
{
if (!m_isEnabled || m_extrapolationCounter == kExtrapolationCounterUndefined)
return false;
}
return AreCoordsGoodForExtrapolation(m_beforeLastGpsInfo, m_lastGpsInfo);
}

7
map/extrapolation/extrapolator.hpp
View file

@ -25,7 +25,14 @@ class Extrapolator
public:
using ExtrapolatedLocationUpdateFn = std::function<void(location::GpsInfo const &)>;
// |kMaxExtrapolationTimeMs| is time in milliseconds showing how long location will be
// extrapolated after last location gotten from GPS.
static uint64_t constexpr kMaxExtrapolationTimeMs = 1000;
// |kExtrapolationPeriodMs| is time in milliseconds showing how often location will be
// extrapolated. So if the last location was gotten from GPS at time X the next location
// will be emulated by Extrapolator at X + kExtrapolationPeriodMs.
// Then X + 2 * kExtrapolationPeriodMs and so on till
// X + n * kExtrapolationPeriodMs <= kMaxExtrapolationTimeMs.
static uint64_t constexpr kExtrapolationPeriodMs = 200;
/// \param update is a function which is called with params according to extrapolated position.

55
map/extrapolation_benchmark/extrapolation_benchmark.cpp
View file

@ -27,7 +27,7 @@
// This tool is written to estimate quality of location extrapolation. To launch the benchmark
// you need tracks in csv file with the format described below. To generate the csv file
// you need to go through following steps:
// * take logs form Trafim project production in gz files
// * take logs from "trafin" project production in gz files
// * extract them (gzip -d)
// * run track_analyzer tool with unmatched_tracks command to generate csv
// (track_analyzer -cmd unmatched_tracks -in ./trafin_log.20180517-0000)
@ -48,31 +48,24 @@ namespace
{
struct GpsPoint
{
GpsPoint(double timestamp, double lat, double lon)
: m_timestamp(timestamp)
GpsPoint(double timestampS, double lat, double lon)
: m_timestampS(timestampS)
, m_lat(lat)
, m_lon(lon)
{
}
double m_timestamp;
double m_timestampS;
// @TODO(bykoianko) Using LatLog type instead of two double should be considered.
double m_lat;
double m_lon;
};
class MathematicalExpectation
class Expectation
{
public:
void Add(double value)
{
if (m_counter == 0)
{
m_averageValue = value;
++m_counter;
return;
}
m_averageValue = (m_averageValue * m_counter + value) / (m_counter + 1);
++m_counter;
}
@ -85,10 +78,10 @@ private:
size_t m_counter = 0;
};
class MathematicalExpectationVec
class ExpectationVec
{
public:
explicit MathematicalExpectationVec(size_t size) { m_mes.resize(size); }
explicit ExpectationVec(size_t size) { m_mes.resize(size); }
void Add(vector<double> const & values)
{
@ -97,10 +90,10 @@ public:
m_mes[i].Add(values[i]);
}
vector<MathematicalExpectation> const & Get() const { return m_mes; }
vector<Expectation> const & Get() const { return m_mes; }
private:
vector<MathematicalExpectation> m_mes;
vector<Expectation> m_mes;
};
using Track = vector<GpsPoint>;
@ -130,9 +123,9 @@ bool GetUint64(stringstream & lineStream, uint64_t & result)
return strings::to_uint64(strResult, result);
}
bool GetGpsPoint(stringstream & lineStream, uint64_t & timestamp, double & lat, double & lon)
bool GetGpsPoint(stringstream & lineStream, uint64_t & timestampS, double & lat, double & lon)
{
if (!GetUint64(lineStream, timestamp))
if (!GetUint64(lineStream, timestampS))
return false;
if (!GetDouble(lineStream, lat))
return false;
@ -180,10 +173,10 @@ bool Parse(string const & pathToCsv, Tracks & tracks)
void GpsPointToGpsInfo(GpsPoint const gpsPoint, GpsInfo & gpsInfo)
{
gpsInfo.m_timestamp = gpsPoint.m_timestamp;
gpsInfo.m_source = TLocationSource::EAppleNative;
gpsInfo.m_timestamp = gpsPoint.m_timestampS;
gpsInfo.m_latitude = gpsPoint.m_lat;
gpsInfo.m_longitude = gpsPoint.m_lon;
}
} // namespace
@ -192,7 +185,7 @@ void GpsPointToGpsInfo(GpsPoint const gpsPoint, GpsInfo & gpsInfo)
int main(int argc, char * argv[])
{
google::SetUsageMessage(
"Location extrapolation benchmark. Calculates mathematical expectation and dispersion for "
"Location extrapolation benchmark. Calculates expected value and variance for "
"all extrapolation deviations from tracks passed in csv with with csv_path.");
google::ParseCommandLineFlags(&argc, &argv, true);
@ -229,17 +222,17 @@ int main(int argc, char * argv[])
LOG(LINFO, ("General tracks statistics."
"\n Number of tracks:", tracks.size(),
"\n Number of track points:", trackPointNum,
"\n Points per track in average:", trackPointNum / tracks.size(),
"\n Average points per track:", trackPointNum / tracks.size(),
"\n Average track length:", trackLengths / tracks.size(), "meters"));
// For all points of each track in |tracks| some extrapolations will be calculated.
// The number of extrapolations depends on |Extrapolator::kExtrapolationPeriodMs|
// and |Extrapolator::kMaxExtrapolationTimeMs| and equal for all points.
// Then mathematical expectation and dispersion each extrapolation will be printed.
// Then expected value and variance each extrapolation will be printed.
auto const extrapolationNumber = static_cast<size_t>(Extrapolator::kMaxExtrapolationTimeMs /
Extrapolator::kExtrapolationPeriodMs);
MathematicalExpectationVec mes(extrapolationNumber);
MathematicalExpectationVec squareMes(extrapolationNumber);
ExpectationVec mes(extrapolationNumber);
ExpectationVec squareMes(extrapolationNumber);
// Number of extrapolations which projections are calculated successfully for.
size_t projectionCounter = 0;
for (auto const & t : tracks)
@ -277,8 +270,10 @@ int main(int argc, char * argv[])
m2::RectD const posRect = MercatorBounds::MetresToXY(
extrapolated.m_longitude, extrapolated.m_latitude, 100.0 /* half square in meters */);
// Note. One is deducted from polyline size because in GetClosestProjectionInInterval()
// Note 1. One is deducted from polyline size because in GetClosestProjectionInInterval()
// is used segment indices but not point indices.
// Note 2. Calculating projection of the center of |posRect| to polyline segments which
// are inside of |posRect|.
auto const & iter = followedPoly.GetClosestProjectionInInterval(
posRect,
[&extrapolatedMerc](FollowedPolyline::Iter const & it) {
@ -318,13 +313,13 @@ int main(int argc, char * argv[])
" ", mes.Get()[0].GetCounter() * extrapolationNumber, "extrapolations is calculated.\n",
" Projection is calculated for", projectionCounter, "extrapolations."));
LOG(LINFO, ("Mathematical expectation for each extrapolation:"));
LOG(LINFO, ("Expected value for each extrapolation:"));
for (size_t i = 0; i < extrapolationNumber; ++i)
{
double const dispersion = squareMes.Get()[i].Get() - mes.Get()[i].Get() * mes.Get()[i].Get();
double const variance = squareMes.Get()[i].Get() - mes.Get()[i].Get() * mes.Get()[i].Get();
LOG(LINFO, ("Extrapolation", i + 1, ",", Extrapolator::kExtrapolationPeriodMs * (i + 1),
"seconds after point two. Mathematical expectation =", mes.Get()[i].Get(),
"meters.", "Dispersion =", dispersion, ". Standard deviation =", sqrt(dispersion)));
"seconds after point two. Expected value =", mes.Get()[i].Get(),
"meters.", "Variance =", variance, ". Standard deviation =", sqrt(variance)));
}
return 0;

2
platform/location.hpp
View file

@ -43,7 +43,7 @@ namespace location
{
public:
TLocationSource m_source = EUndefined;
/// \note |m_timestamp| is calculated based on platform methods which don't
/// @TODO(bykoianko) |m_timestamp| is calculated based on platform methods which don't
/// guarantee that |m_timestamp| is monotonic. |m_monotonicTimeMs| should be added to
/// class |GpsInfo|. This time should be calculated based on Location::getElapsedRealtimeNanos()
/// method in case of Android. How to calculate such time in case of iOS should be

2
routing/base/followed_polyline.hpp
View file

@ -78,7 +78,7 @@ public:
Iter GetIterToIndex(size_t index) const;
/// \brief Calculates projection of center of |posRect| to the polyline.
/// \param posRect Only projection inside the rect are considered.
/// \param posRect Only projection inside the rect is considered.
/// \param distFn A method which is used to calculate the destination between points.
/// \param startIdx Start segment index in |m_segProj|.
/// \param endIdx The index after the last one in |m_segProj|.

2
track_analyzing/track_analyzer/cmd_table.cpp
View file

@ -228,8 +228,6 @@ void CmdTagsTable(string const & filepath, string const & trackExtension, String
for (size_t trackIdx = 0; trackIdx < kv.second.size(); ++trackIdx)
{
MatchedTrack const & track = kv.second[trackIdx];
// Note. There's no need in tracks with length one point. CalcSpeedKMpH() used below
// requires |timeElapsed| is greater then zero. It's impossible if track length is one.
if (track.size() <= 1)
continue;

2
track_analyzing/track_analyzer/track_analyzer.cpp
View file

@ -25,7 +25,7 @@ namespace
DEFINE_string_ext(cmd, "",
"command:\n"
"match - based on raw logs gathers points to tracks and matchs them to features\n"
"match - based on raw logs gathers points to tracks and matches them to features\n"
"unmatched_tracks - based on raw logs gathers points to tracks "
"and save tracks to csv. Track points save as lat, log, timestamp in seconds\n"
"tracks - prints track statistics\n"