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

Make progress increase monotonically.

Browse source
This commit is contained in:
Lev Dragunov 2015-07-21 13:47:40 +03:00 • committed by Alex Zolotarev
parent 84c0f7088a
commit 104140a94d
4 changed files with 67 additions and 18 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
routing/base/astar_progress.hpp
View file

@ -12,20 +12,20 @@ public:
AStarProgress(float startValue, float stopValue)
: m_startValue(startValue), m_stopValue(stopValue) {}
void Initialise(m2::PointD const & startPoint, m2::PointD const & finalPoint)
void Initialize(m2::PointD const & startPoint, m2::PointD const & finalPoint)
{
m_startPoint = startPoint;
m_finalPoint = finalPoint;
m_initialDistance = MercatorBounds::DistanceOnEarth(startPoint, finalPoint);
m_forwardDistance = m_initialDistance;
m_backwardDistance = m_initialDistance;
m_lastValue = m_startValue;
}
float GetProgressForDirectedAlgo(m2::PointD const & point)
{
return m_startValue +
(m_stopValue - m_startValue) *
(1.0 - MercatorBounds::DistanceOnEarth(point, m_finalPoint) / m_initialDistance);
return CheckConstraints(
1.0 - MercatorBounds::DistanceOnEarth(point, m_finalPoint) / m_initialDistance);
}
float GetProgressForBidirectedAlgo(m2::PointD const & point, m2::PointD const & target)
@ -36,15 +36,25 @@ public:
m_backwardDistance = MercatorBounds::DistanceOnEarth(point, target);
else
ASSERT(false, ());
return m_startValue +
(m_stopValue - m_startValue) *
(2.0 - (m_forwardDistance + m_backwardDistance) / m_initialDistance);
return CheckConstraints(2.0 - (m_forwardDistance + m_backwardDistance) / m_initialDistance);
}
float GetLastValue() const { return m_lastValue; }
private:
float CheckConstraints(float const & roadPart)
{
float mappedValue = m_startValue + (m_stopValue - m_startValue) * roadPart;
mappedValue = my::clamp(mappedValue, m_startValue, m_stopValue);
if (mappedValue > m_lastValue)
m_lastValue = mappedValue;
return m_lastValue;
}
float m_forwardDistance;
float m_backwardDistance;
float m_initialDistance;
float m_lastValue;
m2::PointD m_startPoint;
m2::PointD m_finalPoint;

19
routing/routing_algorithm.cpp
View file

@ -11,6 +11,8 @@ namespace routing
namespace
{
float constexpr kProgressInterval = 2;
double constexpr KMPH2MPS = 1000.0 / (60 * 60);
inline double TimeBetweenSec(Junction const & j1, Junction const & j2, double speedMPS)
@ -139,8 +141,10 @@ AStarRoutingAlgorithm::AStarRoutingAlgorithm(TRoutingVisualizerFn routingVisuali
routingVisualizerFn(junction.GetPoint());
if (routingProgressFn != nullptr)
{
routingProgressFn(
m_progress.GetProgressForDirectedAlgo(junction.GetPoint()));
auto const lastValue = m_progress.GetLastValue();
auto const newValue = m_progress.GetProgressForDirectedAlgo(junction.GetPoint());
if (newValue - lastValue > kProgressInterval)
routingProgressFn(newValue);
}
};
@ -153,7 +157,7 @@ IRoutingAlgorithm::Result AStarRoutingAlgorithm::CalculateRoute(IRoadGraph const
vector<Junction> & path)
{
my::Cancellable const & cancellable = *this;
m_progress.Initialise(startPos.GetPoint(), finalPos.GetPoint());
m_progress.Initialize(startPos.GetPoint(), finalPos.GetPoint());
TAlgorithmImpl::Result const res = TAlgorithmImpl().FindPath(RoadGraph(graph), startPos, finalPos, path, cancellable, m_onVisitJunctionFn);
return Convert(res);
}
@ -171,8 +175,11 @@ AStarBidirectionalRoutingAlgorithm::AStarBidirectionalRoutingAlgorithm(
routingVisualizerFn(junction.GetPoint());
if (routingProgressFn != nullptr)
{
routingProgressFn(
m_progress.GetProgressForBidirectedAlgo(junction.GetPoint(), target.GetPoint()));
auto const lastValue = m_progress.GetLastValue();
auto const newValue =
m_progress.GetProgressForBidirectedAlgo(junction.GetPoint(), target.GetPoint());
if (newValue - lastValue > kProgressInterval)
routingProgressFn(newValue);
}
};
@ -185,7 +192,7 @@ IRoutingAlgorithm::Result AStarBidirectionalRoutingAlgorithm::CalculateRoute(IRo
vector<Junction> & path)
{
my::Cancellable const & cancellable = *this;
m_progress.Initialise(startPos.GetPoint(), finalPos.GetPoint());
m_progress.Initialize(startPos.GetPoint(), finalPos.GetPoint());
TAlgorithmImpl::Result const res = TAlgorithmImpl().FindPathBidirectional(RoadGraph(graph), startPos, finalPos, path, cancellable, m_onVisitJunctionFn);
return Convert(res);
}

1
routing/routing_algorithm.hpp
View file

@ -4,6 +4,7 @@
#include "routing/road_graph.hpp"
#include "routing/router.hpp"
#include "routing/base/astar_progress.hpp"
#include "std/functional.hpp"

41
routing/routing_tests/astar_progress_test.cpp
View file

@ -13,13 +13,44 @@ UNIT_TEST(DirectedAStarProgressCheck)
m2::PointD middle = m2::PointD(0, 2);
AStarProgress progress(0, 100);
progress.Initialise(start, finish);
progress.Initialize(start, finish);
TEST_LESS(progress.GetProgressForDirectedAlgo(start), 0.1f, ());
TEST_LESS(progress.GetProgressForDirectedAlgo(middle), 50.5f, ());
TEST_GREATER(progress.GetProgressForDirectedAlgo(middle), 49.5f, ());
TEST_GREATER(progress.GetProgressForDirectedAlgo(finish), 99.9f, ());
}
UNIT_TEST(DirectedAStarDegradationCheck)
{
m2::PointD start = m2::PointD(0, 1);
m2::PointD finish = m2::PointD(0, 3);
m2::PointD middle = m2::PointD(0, 2);
AStarProgress progress(0, 100);
progress.Initialize(start, finish);
auto value1 = progress.GetProgressForDirectedAlgo(middle);
auto value2 = progress.GetProgressForDirectedAlgo(start);
TEST_LESS_OR_EQUAL(value1, value2, ());
progress.Initialize(start, finish);
auto value3 = progress.GetProgressForDirectedAlgo(start);
TEST_GREATER_OR_EQUAL(value1, value3, ());
}
UNIT_TEST(RangeCheckTest)
{
m2::PointD start = m2::PointD(0, 1);
m2::PointD finish = m2::PointD(0, 3);
m2::PointD preStart = m2::PointD(0, 0);
m2::PointD postFinish = m2::PointD(0, 6);
AStarProgress progress(0, 100);
progress.Initialize(start, finish);
TEST_EQUAL(progress.GetProgressForDirectedAlgo(preStart), 0.0, ());
TEST_EQUAL(progress.GetProgressForDirectedAlgo(postFinish), 0.0, ());
TEST_EQUAL(progress.GetProgressForDirectedAlgo(finish), 100.0, ());
}
UNIT_TEST(DirectedAStarProgressCheckAtShiftedInterval)
{
m2::PointD start = m2::PointD(0, 1);
@ -27,7 +58,7 @@ UNIT_TEST(DirectedAStarProgressCheckAtShiftedInterval)
m2::PointD middle = m2::PointD(0, 2);
AStarProgress progress(50, 250);
progress.Initialise(start, finish);
progress.Initialize(start, finish);
TEST_LESS(progress.GetProgressForDirectedAlgo(start), 50.1f, ());
TEST_LESS(progress.GetProgressForDirectedAlgo(middle), 150.5f, ());
TEST_GREATER(progress.GetProgressForDirectedAlgo(middle), 145.5f, ());
@ -42,10 +73,10 @@ UNIT_TEST(BidirectedAStarProgressCheck)
m2::PointD bWave = m2::PointD(0, 3);
AStarProgress progress(0.0f, 100.0f);
progress.Initialise(start, finish);
progress.Initialize(start, finish);
progress.GetProgressForBidirectedAlgo(fWave, finish);
float result = progress.GetProgressForBidirectedAlgo(bWave, start);
ASSERT_GREATER(result, 49.5, ());
ASSERT_LESS(result, 50.5, ());
TEST_GREATER(result, 49.5, ());
TEST_LESS(result, 50.5, ());
}
} // namespace routing_test