drifty/comaps
1
0
Fork 0
mirror of https://codeberg.org/comaps/comaps synced 2025-12-22 06:03:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

Format all C++ and Java code via clang-format

Browse Source 
Signed-off-by: Konstantin Pastbin <konstantin.pastbin@gmail.com>
This commit is contained in:
Konstantin Pastbin
2025-08-17 14:32:37 +07:00
parent 9f0290c0ec
commit bfffa1fff4
2169 changed files with 56441 additions and 64188 deletions
Download Patch File Download Diff File Expand all files Collapse all files

243
libs/routing/base/astar_algorithm.hpp
View File

@@ -28,12 +28,18 @@ namespace astar
struct DefaultVisitor
{
template <class State, class Vertex> void operator() (State const &, Vertex const &) const {}
template <class State, class Vertex>
void operator()(State const &, Vertex const &) const
{}
};
struct DefaultLengthChecker
{
template <class Weight> bool operator()(Weight const &) const { return true; }
template <class Weight>
bool operator()(Weight const &) const
{
return true;
}
};
} // namespace astar
@@ -41,7 +47,6 @@ template <typename Vertex, typename Edge, typename Weight>
class AStarAlgorithm
{
public:
using Graph = AStarGraph<Vertex, Edge, Weight>;
enum class Result
@@ -55,15 +60,9 @@ public:
{
switch (result)
{
case Result::OK:
os << "OK";
break;
case Result::NoPath:
os << "NoPath";
break;
case Result::Cancelled:
os << "Cancelled";
break;
case Result::OK: os << "OK"; break;
case Result::NoPath: os << "NoPath"; break;
case Result::Cancelled: os << "Cancelled"; break;
}
return os;
}
@@ -72,12 +71,11 @@ public:
{
ParamsBase(Graph & graph, Vertex const & startVertex, Vertex const & finalVertex,
base::Cancellable const & cancellable)
: m_graph(graph)
, m_startVertex(startVertex)
, m_finalVertex(finalVertex)
, m_cancellable(cancellable)
{
}
: m_graph(graph)
, m_startVertex(startVertex)
, m_finalVertex(finalVertex)
, m_cancellable(cancellable)
{}
Graph & m_graph;
Weight const m_weightEpsilon = m_graph.GetAStarWeightEpsilon();
@@ -92,19 +90,16 @@ public:
// |LengthChecker| callback used to check path length from start/finish to the edge (including the
// edge itself) before adding the edge to AStar queue. Can be used to clip some path which does
// not meet restrictions.
template <typename Visitor = astar::DefaultVisitor,
typename LengthChecker = astar::DefaultLengthChecker>
template <typename Visitor = astar::DefaultVisitor, typename LengthChecker = astar::DefaultLengthChecker>
struct Params : public ParamsBase
{
Params(Graph & graph, Vertex const & startVertex, Vertex const & finalVertex,
base::Cancellable const & cancellable,
Params(Graph & graph, Vertex const & startVertex, Vertex const & finalVertex, base::Cancellable const & cancellable,
Visitor && onVisitedVertexCallback = astar::DefaultVisitor(),
LengthChecker && checkLengthCallback = astar::DefaultLengthChecker())
: ParamsBase(graph, startVertex, finalVertex, cancellable)
, m_onVisitedVertexCallback(std::forward<Visitor>(onVisitedVertexCallback))
, m_checkLengthCallback(std::forward<LengthChecker>(checkLengthCallback))
{
}
{}
Visitor m_onVisitedVertexCallback;
LengthChecker const m_checkLengthCallback;
@@ -117,8 +112,7 @@ public:
LengthChecker && checkLengthCallback = astar::DefaultLengthChecker())
: ParamsBase(graph, startVertex, finalVertex, m_dummy)
, m_checkLengthCallback(std::forward<LengthChecker>(checkLengthCallback))
{
}
{}
astar::DefaultVisitor const m_onVisitedVertexCallback{};
LengthChecker const m_checkLengthCallback;
@@ -130,15 +124,9 @@ public:
class Context final
{
public:
Context(Graph & graph) : m_graph(graph)
{
m_graph.SetAStarParents(true /* forward */, m_parents);
}
Context(Graph & graph) : m_graph(graph) { m_graph.SetAStarParents(true /* forward */, m_parents); }
~Context()
{
m_graph.DropAStarParents();
}
~Context() { m_graph.DropAStarParents(); }
void Clear()
{
@@ -146,10 +134,7 @@ public:
m_parents.clear();
}
bool HasDistance(Vertex const & vertex) const
{
return m_distanceMap.find(vertex) != m_distanceMap.cend();
}
bool HasDistance(Vertex const & vertex) const { return m_distanceMap.find(vertex) != m_distanceMap.cend(); }
Weight GetDistance(Vertex const & vertex) const
{
@@ -160,20 +145,11 @@ public:
return it->second;
}
void SetDistance(Vertex const & vertex, Weight const & distance)
{
m_distanceMap[vertex] = distance;
}
void SetDistance(Vertex const & vertex, Weight const & distance) { m_distanceMap[vertex] = distance; }
void SetParent(Vertex const & parent, Vertex const & child)
{
m_parents[parent] = child;
}
void SetParent(Vertex const & parent, Vertex const & child) { m_parents[parent] = child; }
bool HasParent(Vertex const & child) const
{
return m_parents.count(child) != 0;
}
bool HasParent(Vertex const & child) const { return m_parents.count(child) != 0; }
Vertex const & GetParent(Vertex const & child) const
{
@@ -194,15 +170,13 @@ public:
// VisitVertex returns true: wave will continue
// VisitVertex returns false: wave will stop
template <typename VisitVertex, typename AdjustEdgeWeight, typename FilterStates,
typename ReducedToRealLength>
template <typename VisitVertex, typename AdjustEdgeWeight, typename FilterStates, typename ReducedToRealLength>
void PropagateWave(Graph & graph, Vertex const & startVertex, VisitVertex && visitVertex,
AdjustEdgeWeight && adjustEdgeWeight, FilterStates && filterStates,
ReducedToRealLength && reducedToRealLength, Context & context) const;
template <typename VisitVertex>
void PropagateWave(Graph & graph, Vertex const & startVertex, VisitVertex && visitVertex,
Context & context) const;
void PropagateWave(Graph & graph, Vertex const & startVertex, VisitVertex && visitVertex, Context & context) const;
template <typename P>
Result FindPath(P & params, RoutingResult<Vertex, Weight> & result) const;
@@ -225,8 +199,7 @@ public:
// Adjust route to the previous one.
// Expects |params.m_checkLengthCallback| to check wave propagation limit.
template <typename P>
typename AStarAlgorithm<Vertex, Edge, Weight>::Result AdjustRoute(P & params,
std::vector<Edge> const & prevRoute,
typename AStarAlgorithm<Vertex, Edge, Weight>::Result AdjustRoute(P & params, std::vector<Edge> const & prevRoute,
RoutingResult<Vertex, Weight> & result) const;
private:
@@ -259,9 +232,10 @@ private:
struct State
{
State(Vertex const & vertex, Weight const & distance, Weight const & heuristic)
: vertex(vertex), distance(distance), heuristic(heuristic)
{
}
: vertex(vertex)
, distance(distance)
, heuristic(heuristic)
{}
State(Vertex const & vertex, Weight const & distance) : State(vertex, distance, Weight()) {}
inline bool operator>(State const & rhs) const { return distance > rhs.distance; }
@@ -278,22 +252,18 @@ private:
{
using Parents = typename Graph::Parents;
BidirectionalStepContext(bool forward, Vertex const & startVertex, Vertex const & finalVertex,
Graph & graph)
: forward(forward)
, startVertex(startVertex)
, finalVertex(finalVertex)
, graph(graph)
BidirectionalStepContext(bool forward, Vertex const & startVertex, Vertex const & finalVertex, Graph & graph)
: forward(forward)
, startVertex(startVertex)
, finalVertex(finalVertex)
, graph(graph)
{
bestVertex = forward ? startVertex : finalVertex;
pS = ConsistentHeuristic(bestVertex);
graph.SetAStarParents(forward, parent);
}
~BidirectionalStepContext()
{
graph.DropAStarParents();
}
~BidirectionalStepContext() { graph.DropAStarParents(); }
Weight TopDistance() const
{
@@ -336,10 +306,7 @@ private:
return it != bestDistance.end() && state.distance > it->second - eps;
}
void UpdateDistance(State const & state)
{
bestDistance.insert_or_assign(state.vertex, state.distance);
}
void UpdateDistance(State const & state) { bestDistance.insert_or_assign(state.vertex, state.distance); }
std::optional<Weight> GetDistance(Vertex const & vertex) const
{
@@ -347,10 +314,7 @@ private:
return it != bestDistance.cend() ? std::optional<Weight>(it->second) : std::nullopt;
}
void UpdateParent(Vertex const & to, Vertex const & from)
{
parent.insert_or_assign(to, from);
}
void UpdateParent(Vertex const & to, Vertex const & from) { parent.insert_or_assign(to, from); }
void GetAdjacencyList(State const & state, typename Graph::EdgeListT & adj)
{
@@ -383,13 +347,12 @@ private:
Weight pS;
};
static void ReconstructPath(Vertex const & v,
typename BidirectionalStepContext::Parents const & parent,
static void ReconstructPath(Vertex const & v, typename BidirectionalStepContext::Parents const & parent,
std::vector<Vertex> & path);
static void ReconstructPathBidirectional(
Vertex const & v, Vertex const & w,
typename BidirectionalStepContext::Parents const & parentV,
typename BidirectionalStepContext::Parents const & parentW, std::vector<Vertex> & path);
static void ReconstructPathBidirectional(Vertex const & v, Vertex const & w,
typename BidirectionalStepContext::Parents const & parentV,
typename BidirectionalStepContext::Parents const & parentW,
std::vector<Vertex> & path);
};
template <typename Vertex, typename Edge, typename Weight>
@@ -399,13 +362,12 @@ constexpr Weight AStarAlgorithm<Vertex, Edge, Weight>::kZeroDistance;
template <typename Vertex, typename Edge, typename Weight>
template <typename VisitVertex, typename AdjustEdgeWeight, typename FilterStates, typename ReducedToFullLength>
void AStarAlgorithm<Vertex, Edge, Weight>::PropagateWave(
Graph & graph, Vertex const & startVertex,
VisitVertex && visitVertex,
AdjustEdgeWeight && adjustEdgeWeight,
FilterStates && filterStates,
ReducedToFullLength && reducedToFullLength,
AStarAlgorithm<Vertex, Edge, Weight>::Context & context) const
void AStarAlgorithm<Vertex, Edge, Weight>::PropagateWave(Graph & graph, Vertex const & startVertex,
VisitVertex && visitVertex,
AdjustEdgeWeight && adjustEdgeWeight,
FilterStates && filterStates,
ReducedToFullLength && reducedToFullLength,
AStarAlgorithm<Vertex, Edge, Weight>::Context & context) const
{
auto const epsilon = graph.GetAStarWeightEpsilon();
@@ -457,17 +419,14 @@ void AStarAlgorithm<Vertex, Edge, Weight>::PropagateWave(
template <typename Vertex, typename Edge, typename Weight>
template <typename VisitVertex>
void AStarAlgorithm<Vertex, Edge, Weight>::PropagateWave(
Graph & graph, Vertex const & startVertex, VisitVertex && visitVertex,
AStarAlgorithm<Vertex, Edge, Weight>::Context & context) const
void AStarAlgorithm<Vertex, Edge, Weight>::PropagateWave(Graph & graph, Vertex const & startVertex,
VisitVertex && visitVertex,
AStarAlgorithm<Vertex, Edge, Weight>::Context & context) const
{
auto const adjustEdgeWeight = [](Vertex const & /* vertex */, Edge const & edge) {
return edge.GetWeight();
};
auto const adjustEdgeWeight = [](Vertex const & /* vertex */, Edge const & edge) { return edge.GetWeight(); };
auto const filterStates = [](State const & /* state */) { return true; };
auto const reducedToRealLength = [](State const & state) { return state.distance; };
PropagateWave(graph, startVertex, visitVertex, adjustEdgeWeight, filterStates,
reducedToRealLength, context);
PropagateWave(graph, startVertex, visitVertex, adjustEdgeWeight, filterStates, reducedToRealLength, context);
}
// This implementation is based on the view that the A* algorithm
@@ -488,8 +447,8 @@ void AStarAlgorithm<Vertex, Edge, Weight>::PropagateWave(
template <typename Vertex, typename Edge, typename Weight>
template <typename P>
typename AStarAlgorithm<Vertex, Edge, Weight>::Result
AStarAlgorithm<Vertex, Edge, Weight>::FindPath(P & params, RoutingResult<Vertex, Weight> & result) const
typename AStarAlgorithm<Vertex, Edge, Weight>::Result AStarAlgorithm<Vertex, Edge, Weight>::FindPath(
P & params, RoutingResult<Vertex, Weight> & result) const
{
auto const epsilon = params.m_weightEpsilon;
@@ -503,22 +462,17 @@ AStarAlgorithm<Vertex, Edge, Weight>::FindPath(P & params, RoutingResult<Vertex,
PeriodicPollCancellable periodicCancellable(params.m_cancellable);
Result resultCode = Result::NoPath;
auto const heuristicDiff = [&](Vertex const & vertexFrom, Vertex const & vertexTo) {
return graph.HeuristicCostEstimate(vertexFrom, finalVertex) -
graph.HeuristicCostEstimate(vertexTo, finalVertex);
};
auto const heuristicDiff = [&](Vertex const & vertexFrom, Vertex const & vertexTo)
{ return graph.HeuristicCostEstimate(vertexFrom, finalVertex) - graph.HeuristicCostEstimate(vertexTo, finalVertex); };
auto const fullToReducedLength = [&](Vertex const & vertexFrom, Vertex const & vertexTo,
Weight const length) {
return length - heuristicDiff(vertexFrom, vertexTo);
};
auto const fullToReducedLength = [&](Vertex const & vertexFrom, Vertex const & vertexTo, Weight const length)
{ return length - heuristicDiff(vertexFrom, vertexTo); };
auto const reducedToFullLength = [&](Vertex const & vertexFrom, Vertex const & vertexTo,
Weight const reducedLength) {
return reducedLength + heuristicDiff(vertexFrom, vertexTo);
};
auto const reducedToFullLength = [&](Vertex const & vertexFrom, Vertex const & vertexTo, Weight const reducedLength)
{ return reducedLength + heuristicDiff(vertexFrom, vertexTo); };
auto visitVertex = [&](Vertex const & vertex) {
auto visitVertex = [&](Vertex const & vertex)
{
if (periodicCancellable.IsCancelled())
{
resultCode = Result::Cancelled;
@@ -536,7 +490,8 @@ AStarAlgorithm<Vertex, Edge, Weight>::FindPath(P & params, RoutingResult<Vertex,
return true;
};
auto const adjustEdgeWeight = [&](Vertex const & vertexV, Edge const & edge) {
auto const adjustEdgeWeight = [&](Vertex const & vertexV, Edge const & edge)
{
auto const reducedWeight = fullToReducedLength(vertexV, edge.GetTarget(), edge.GetWeight());
CHECK_GREATER_OR_EQUAL(reducedWeight, -epsilon, ("Invariant violated."));
@@ -544,22 +499,18 @@ AStarAlgorithm<Vertex, Edge, Weight>::FindPath(P & params, RoutingResult<Vertex,
return std::max(reducedWeight, kZeroDistance);
};
auto const reducedToRealLength = [&](State const & state) {
return reducedToFullLength(startVertex, state.vertex, state.distance);
};
auto const reducedToRealLength = [&](State const & state)
{ return reducedToFullLength(startVertex, state.vertex, state.distance); };
auto const filterStates = [&](State const & state) {
return params.m_checkLengthCallback(reducedToRealLength(state));
};
auto const filterStates = [&](State const & state)
{ return params.m_checkLengthCallback(reducedToRealLength(state)); };
PropagateWave(graph, startVertex, visitVertex, adjustEdgeWeight, filterStates,
reducedToRealLength, context);
PropagateWave(graph, startVertex, visitVertex, adjustEdgeWeight, filterStates, reducedToRealLength, context);
if (resultCode == Result::OK)
{
context.ReconstructPath(finalVertex, result.m_path);
result.m_distance =
reducedToFullLength(startVertex, finalVertex, context.GetDistance(finalVertex));
result.m_distance = reducedToFullLength(startVertex, finalVertex, context.GetDistance(finalVertex));
if (!params.m_checkLengthCallback(result.m_distance))
resultCode = Result::NoPath;
@@ -570,8 +521,8 @@ AStarAlgorithm<Vertex, Edge, Weight>::FindPath(P & params, RoutingResult<Vertex,
template <typename Vertex, typename Edge, typename Weight>
template <class P, class Emitter>
typename AStarAlgorithm<Vertex, Edge, Weight>::Result
AStarAlgorithm<Vertex, Edge, Weight>::FindPathBidirectionalEx(P & params, Emitter && emitter) const
typename AStarAlgorithm<Vertex, Edge, Weight>::Result AStarAlgorithm<Vertex, Edge, Weight>::FindPathBidirectionalEx(
P & params, Emitter && emitter) const
{
auto const epsilon = params.m_weightEpsilon;
auto & graph = params.m_graph;
@@ -605,7 +556,7 @@ AStarAlgorithm<Vertex, Edge, Weight>::FindPathBidirectionalEx(P & params, Emitte
{
// No problem if length check fails, but we still emit the result.
// Happens with "transit" route because of length, haven't seen with regular car route.
//ASSERT(params.m_checkLengthCallback(bestPathRealLength), ());
// ASSERT(params.m_checkLengthCallback(bestPathRealLength), ());
RoutingResult<Vertex, Weight> result;
ReconstructPathBidirectional(cur->bestVertex, nxt->bestVertex, cur->parent, nxt->parent, result.m_path);
@@ -684,8 +635,8 @@ AStarAlgorithm<Vertex, Edge, Weight>::FindPathBidirectionalEx(P & params, Emitte
if (reducedWeight < -epsilon && params.m_badReducedWeight(reducedWeight, std::max(pW, pV)))
{
// Break in Debug, log in Release and safe continue: std::max(reducedWeight, kZeroDistance).
LOG(LERROR, ("Invariant violated for:", "v =", stateV.vertex, "w =", stateW.vertex,
"reduced weight =", reducedWeight));
LOG(LERROR,
("Invariant violated for:", "v =", stateV.vertex, "w =", stateW.vertex, "reduced weight =", reducedWeight));
}
stateW.distance = stateV.distance + std::max(reducedWeight, kZeroDistance);
@@ -739,10 +690,8 @@ AStarAlgorithm<Vertex, Edge, Weight>::FindPathBidirectionalEx(P & params, Emitte
template <typename Vertex, typename Edge, typename Weight>
template <typename P>
typename AStarAlgorithm<Vertex, Edge, Weight>::Result
AStarAlgorithm<Vertex, Edge, Weight>::AdjustRoute(P & params,
std::vector<Edge> const & prevRoute,
RoutingResult<Vertex, Weight> & result) const
typename AStarAlgorithm<Vertex, Edge, Weight>::Result AStarAlgorithm<Vertex, Edge, Weight>::AdjustRoute(
P & params, std::vector<Edge> const & prevRoute, RoutingResult<Vertex, Weight> & result) const
{
auto & graph = params.m_graph;
auto const & startVertex = params.m_startVertex;
@@ -766,8 +715,8 @@ AStarAlgorithm<Vertex, Edge, Weight>::AdjustRoute(P & params,
Context context(graph);
PeriodicPollCancellable periodicCancellable(params.m_cancellable);
auto visitVertex = [&](Vertex const & vertex) {
auto visitVertex = [&](Vertex const & vertex)
{
if (periodicCancellable.IsCancelled())
{
wasCancelled = true;
@@ -790,18 +739,13 @@ AStarAlgorithm<Vertex, Edge, Weight>::AdjustRoute(P & params,
return true;
};
auto const adjustEdgeWeight = [](Vertex const & /* vertex */, Edge const & edge) {
return edge.GetWeight();
};
auto const adjustEdgeWeight = [](Vertex const & /* vertex */, Edge const & edge) { return edge.GetWeight(); };
auto const filterStates = [&](State const & state) {
return params.m_checkLengthCallback(state.distance);
};
auto const filterStates = [&](State const & state) { return params.m_checkLengthCallback(state.distance); };
auto const reducedToRealLength = [&](State const & state) { return state.distance; };
PropagateWave(graph, startVertex, visitVertex, adjustEdgeWeight, filterStates,
reducedToRealLength, context);
PropagateWave(graph, startVertex, visitVertex, adjustEdgeWeight, filterStates, reducedToRealLength, context);
if (wasCancelled)
return Result::Cancelled;
@@ -824,8 +768,7 @@ AStarAlgorithm<Vertex, Edge, Weight>::AdjustRoute(P & params,
}
}
CHECK(found, ("Can't find", returnVertex, ", prev:", prevRoute.size(),
", adjust:", result.m_path.size()));
CHECK(found, ("Can't find", returnVertex, ", prev:", prevRoute.size(), ", adjust:", result.m_path.size()));
auto const & it = remainingDistances.find(returnVertex);
CHECK(it != remainingDistances.end(), ());
@@ -835,9 +778,9 @@ AStarAlgorithm<Vertex, Edge, Weight>::AdjustRoute(P & params,
// static
template <typename Vertex, typename Edge, typename Weight>
void AStarAlgorithm<Vertex, Edge, Weight>::ReconstructPath(
Vertex const & v, typename BidirectionalStepContext::Parents const & parent,
std::vector<Vertex> & path)
void AStarAlgorithm<Vertex, Edge, Weight>::ReconstructPath(Vertex const & v,
typename BidirectionalStepContext::Parents const & parent,
std::vector<Vertex> & path)
{
path.clear();
Vertex cur = v;
@@ -870,9 +813,7 @@ void AStarAlgorithm<Vertex, Edge, Weight>::ReconstructPathBidirectional(
}
template <typename Vertex, typename Edge, typename Weight>
void
AStarAlgorithm<Vertex, Edge, Weight>::Context::ReconstructPath(Vertex const & v,
std::vector<Vertex> & path) const
void AStarAlgorithm<Vertex, Edge, Weight>::Context::ReconstructPath(Vertex const & v, std::vector<Vertex> & path) const
{
AStarAlgorithm<Vertex, Edge, Weight>::ReconstructPath(v, m_parents, path);
}

18
libs/routing/base/astar_graph.hpp
View File

@@ -1,7 +1,7 @@
#pragma once
#include "routing/base/astar_weight.hpp"
#include "routing/base/astar_vertex_data.hpp"
#include "routing/base/astar_weight.hpp"
#include "routing/base/small_list.hpp"
#include "base/buffer_vector.hpp"
@@ -27,15 +27,12 @@ public:
virtual Weight HeuristicCostEstimate(Vertex const & from, Vertex const & to) = 0;
virtual void GetOutgoingEdgesList(astar::VertexData<Vertex, Weight> const & vertexData,
EdgeListT & edges) = 0;
virtual void GetIngoingEdgesList(astar::VertexData<Vertex, Weight> const & vertexData,
EdgeListT & edges) = 0;
virtual void GetOutgoingEdgesList(astar::VertexData<Vertex, Weight> const & vertexData, EdgeListT & edges) = 0;
virtual void GetIngoingEdgesList(astar::VertexData<Vertex, Weight> const & vertexData, EdgeListT & edges) = 0;
virtual void SetAStarParents(bool forward, Parents & parents);
virtual void DropAStarParents();
virtual bool AreWavesConnectible(Parents & forwardParents, Vertex const & commonVertex,
Parents & backwardParents);
virtual bool AreWavesConnectible(Parents & forwardParents, Vertex const & commonVertex, Parents & backwardParents);
virtual Weight GetAStarWeightEpsilon();
@@ -43,11 +40,12 @@ public:
};
template <typename VertexType, typename EdgeType, typename WeightType>
void AStarGraph<VertexType, EdgeType, WeightType>::SetAStarParents(bool /* forward */,
Parents & /* parents */) {}
void AStarGraph<VertexType, EdgeType, WeightType>::SetAStarParents(bool /* forward */, Parents & /* parents */)
{}
template <typename VertexType, typename EdgeType, typename WeightType>
void AStarGraph<VertexType, EdgeType, WeightType>::DropAStarParents() {}
void AStarGraph<VertexType, EdgeType, WeightType>::DropAStarParents()
{}
template <typename VertexType, typename EdgeType, typename WeightType>
bool AStarGraph<VertexType, EdgeType, WeightType>::AreWavesConnectible(AStarGraph::Parents & /* forwardParents */,

28
libs/routing/base/astar_progress.cpp
View File

@@ -19,9 +19,10 @@ double AStarSubProgress::CalcDistance(ms::LatLon const & from, ms::LatLon const
return fabs(from.m_lon - to.m_lon) + fabs(from.m_lat - to.m_lat);
}
AStarSubProgress::AStarSubProgress(ms::LatLon const & start, ms::LatLon const & finish,
double contributionCoef)
: m_contributionCoef(contributionCoef), m_startPoint(start), m_finishPoint(finish)
AStarSubProgress::AStarSubProgress(ms::LatLon const & start, ms::LatLon const & finish, double contributionCoef)
: m_contributionCoef(contributionCoef)
, m_startPoint(start)
, m_finishPoint(finish)
{
ASSERT_GREATER(m_contributionCoef, 0.0, ());
@@ -30,8 +31,7 @@ AStarSubProgress::AStarSubProgress(ms::LatLon const & start, ms::LatLon const &
m_backwardDistance = m_fullDistance;
}
AStarSubProgress::AStarSubProgress(double contributionCoef)
: m_contributionCoef(contributionCoef)
AStarSubProgress::AStarSubProgress(double contributionCoef) : m_contributionCoef(contributionCoef)
{
ASSERT_NOT_EQUAL(m_contributionCoef, 0.0, ());
}
@@ -49,7 +49,7 @@ double AStarSubProgress::UpdateProgress(ms::LatLon const & current, ms::LatLon c
double part = 2.0 - (m_forwardDistance + m_backwardDistance) / m_fullDistance;
part = math::Clamp(part, 0.0, 1.0);
double const newProgress = m_contributionCoef * part;
double const newProgress = m_contributionCoef * part;
m_currentProgress = std::max(newProgress, m_currentProgress);
return m_currentProgress;
@@ -65,7 +65,10 @@ void AStarSubProgress::Flush(double progress)
m_currentProgress += m_contributionCoef * progress;
}
double AStarSubProgress::GetMaxContribution() const { return m_contributionCoef; }
double AStarSubProgress::GetMaxContribution() const
{
return m_contributionCoef;
}
// AStarProgress -------------------------------------------------------------------------
@@ -107,18 +110,19 @@ double AStarProgress::UpdateProgress(ms::LatLon const & current, ms::LatLon cons
double const newProgress = UpdateProgressImpl(m_subProgresses.begin(), current, end) * 100.0;
m_lastPercentValue = std::max(m_lastPercentValue, newProgress);
ASSERT(m_lastPercentValue < kMaxPercent ||
AlmostEqualAbs(m_lastPercentValue, kMaxPercent, 1e-5 /* eps */),
ASSERT(m_lastPercentValue < kMaxPercent || AlmostEqualAbs(m_lastPercentValue, kMaxPercent, 1e-5 /* eps */),
(m_lastPercentValue, kMaxPercent));
m_lastPercentValue = std::min(m_lastPercentValue, kMaxPercent);
return m_lastPercentValue;
}
double AStarProgress::GetLastPercent() const { return m_lastPercentValue; }
double AStarProgress::GetLastPercent() const
{
return m_lastPercentValue;
}
double AStarProgress::UpdateProgressImpl(ListItem subProgress, ms::LatLon const & current,
ms::LatLon const & end)
double AStarProgress::UpdateProgressImpl(ListItem subProgress, ms::LatLon const & current, ms::LatLon const & end)
{
if (std::next(subProgress) != m_subProgresses.end())
return subProgress->UpdateProgress(UpdateProgressImpl(std::next(subProgress), current, end));

3
libs/routing/base/astar_progress.hpp
View File

@@ -53,8 +53,7 @@ public:
private:
using ListItem = std::list<AStarSubProgress>::iterator;
double UpdateProgressImpl(ListItem subProgress, ms::LatLon const & current,
ms::LatLon const & end);
double UpdateProgressImpl(ListItem subProgress, ms::LatLon const & current, ms::LatLon const & end);
// This value is in range: [0, 1].
double m_lastPercentValue = 0.0;

7
libs/routing/base/astar_vertex_data.hpp
View File

@@ -7,12 +7,9 @@ struct VertexData
{
static VertexData Zero() { return VertexData(Vertex(), Weight()); }
VertexData(Vertex const & vertex, Weight const & realDistance)
: m_vertex(vertex), m_realDistance(realDistance)
{
}
VertexData(Vertex const & vertex, Weight const & realDistance) : m_vertex(vertex), m_realDistance(realDistance) {}
Vertex m_vertex;
Weight m_realDistance;
};
} // namespace routing
} // namespace routing::astar

12
libs/routing/base/bfs.hpp
View File

@@ -27,10 +27,9 @@ public:
Vertex m_parent;
};
explicit BFS(Graph & graph): m_graph(graph) {}
explicit BFS(Graph & graph) : m_graph(graph) {}
void Run(Vertex const & start, bool isOutgoing,
std::function<bool(State const &)> && onVisitCallback);
void Run(Vertex const & start, bool isOutgoing, std::function<bool(State const &)> && onVisitCallback);
std::vector<Vertex> ReconstructPath(Vertex from, bool reverse);
@@ -40,15 +39,12 @@ private:
};
template <typename Graph>
void BFS<Graph>::Run(Vertex const & start, bool isOutgoing,
std::function<bool(State const &)> && onVisitCallback)
void BFS<Graph>::Run(Vertex const & start, bool isOutgoing, std::function<bool(State const &)> && onVisitCallback)
{
m_parents.clear();
m_parents.emplace(start, start);
SCOPE_GUARD(removeStart, [&]() {
m_parents.erase(start);
});
SCOPE_GUARD(removeStart, [&]() { m_parents.erase(start); });
std::queue<Vertex> queue;
queue.emplace(start);

25
libs/routing/base/followed_polyline.cpp
View File

@@ -41,9 +41,8 @@ double FollowedPolyline::GetDistanceM(Iter const & it1, Iter const & it2) const
if (it1.m_ind == it2.m_ind)
return mercator::DistanceOnEarth(it1.m_pt, it2.m_pt);
return (mercator::DistanceOnEarth(it1.m_pt, m_poly.GetPoint(it1.m_ind + 1)) +
m_segDistance[it2.m_ind - 1] - m_segDistance[it1.m_ind] +
mercator::DistanceOnEarth(m_poly.GetPoint(it2.m_ind), it2.m_pt));
return (mercator::DistanceOnEarth(it1.m_pt, m_poly.GetPoint(it1.m_ind + 1)) + m_segDistance[it2.m_ind - 1] -
m_segDistance[it1.m_ind] + mercator::DistanceOnEarth(m_poly.GetPoint(it2.m_ind), it2.m_pt));
}
double FollowedPolyline::GetTotalDistanceMeters() const
@@ -115,16 +114,14 @@ bool FollowedPolyline::IsFakeSegment(size_t index) const
}
template <class DistanceFn>
Iter FollowedPolyline::GetBestProjection(m2::RectD const & posRect,
DistanceFn const & distFn) const
Iter FollowedPolyline::GetBestProjection(m2::RectD const & posRect, DistanceFn const & distFn) const
{
CHECK_EQUAL(m_segProj.size() + 1, m_poly.GetSize(), ());
// At first trying to find a projection to two closest route segments of route which is close
// enough to |posRect| center. If |m_current| is right before intermediate point we can get |closestIter|
// right after intermediate point (in next subroute).
size_t const hoppingBorderIdx = min(m_segProj.size(), m_current.m_ind + 2);
Iter const closestIter =
GetClosestProjectionInInterval(posRect, distFn, m_current.m_ind, hoppingBorderIdx);
Iter const closestIter = GetClosestProjectionInInterval(posRect, distFn, m_current.m_ind, hoppingBorderIdx);
if (closestIter.IsValid())
return closestIter;
@@ -139,8 +136,7 @@ Iter FollowedPolyline::GetBestMatchingProjection(m2::RectD const & posRect) cons
// At first trying to find a projection to two closest route segments of route which is close
// enough to |posRect| center. If |m_current| is right before intermediate point we can get |iter|
// right after intermediate point (in next subroute).
size_t const hoppingBorderIdx =
min(m_nextCheckpointIndex, min(m_segProj.size(), m_current.m_ind + 3));
size_t const hoppingBorderIdx = min(m_nextCheckpointIndex, min(m_segProj.size(), m_current.m_ind + 3));
auto const iter = GetClosestMatchingProjectionInInterval(posRect, m_current.m_ind, hoppingBorderIdx);
if (iter.IsValid())
return iter;
@@ -172,10 +168,7 @@ Iter FollowedPolyline::UpdateProjection(m2::RectD const & posRect)
Iter res;
m2::PointD const currPos = posRect.Center();
res = GetBestProjection(posRect, [&](Iter const & it)
{
return mercator::DistanceOnEarth(it.m_pt, currPos);
});
res = GetBestProjection(posRect, [&](Iter const & it) { return mercator::DistanceOnEarth(it.m_pt, currPos); });
if (res.IsValid())
m_current = res;
@@ -210,16 +203,14 @@ void FollowedPolyline::GetCurrentDirectionPoint(m2::PointD & pt, double toleranc
size_t currentIndex = min(m_current.m_ind + 1, m_poly.GetSize() - 1);
m2::PointD point = m_poly.GetPoint(currentIndex);
for (; currentIndex < m_poly.GetSize() - 1; point = m_poly.GetPoint(++currentIndex))
{
if (mercator::DistanceOnEarth(point, m_current.m_pt) > toleranceM)
break;
}
pt = point;
}
Iter FollowedPolyline::GetClosestMatchingProjectionInInterval(m2::RectD const & posRect,
size_t startIdx, size_t endIdx) const
Iter FollowedPolyline::GetClosestMatchingProjectionInInterval(m2::RectD const & posRect, size_t startIdx,
size_t endIdx) const
{
CHECK_LESS_OR_EQUAL(endIdx, m_segProj.size(), ());
CHECK_LESS_OR_EQUAL(startIdx, endIdx, ());

7
libs/routing/base/followed_polyline.hpp
View File

@@ -93,8 +93,8 @@ public:
/// \param endIdx The index after the last one in |m_segProj|.
/// \returns iterator which contains projection point and projection segment index.
template <typename DistanceFn>
Iter GetClosestProjectionInInterval(m2::RectD const & posRect, DistanceFn const & distFn,
size_t startIdx, size_t endIdx) const
Iter GetClosestProjectionInInterval(m2::RectD const & posRect, DistanceFn const & distFn, size_t startIdx,
size_t endIdx) const
{
CHECK_LESS_OR_EQUAL(endIdx, m_segProj.size(), ());
CHECK_LESS_OR_EQUAL(startIdx, endIdx, ());
@@ -121,8 +121,7 @@ public:
return res;
}
Iter GetClosestMatchingProjectionInInterval(m2::RectD const & posRect, size_t startIdx,
size_t endIdx) const;
Iter GetClosestMatchingProjectionInInterval(m2::RectD const & posRect, size_t startIdx, size_t endIdx) const;
bool IsFakeSegment(size_t index) const;

5
libs/routing/base/routing_result.hpp
View File

@@ -24,10 +24,7 @@ struct RoutingResult final
struct LessWeight
{
bool operator() (RoutingResult const & l, RoutingResult const & r) const
{
return l.m_distance < r.m_distance;
}
bool operator()(RoutingResult const & l, RoutingResult const & r) const { return l.m_distance < r.m_distance; }
};
};
} // namespace routing

7
libs/routing/base/small_list.cpp
View File

@@ -20,8 +20,9 @@ void Statistics::Add(char const * name, size_t val)
void Statistics::Dump()
{
for (auto const & e : s_map)
LOG(LINFO, (e.first, ": count = ", e.second.m_count, "; max = ", e.second.m_max, "; avg = ", e.second.m_sum / double(e.second.m_count)));
LOG(LINFO, (e.first, ": count = ", e.second.m_count, "; max = ", e.second.m_max,
"; avg = ", e.second.m_sum / double(e.second.m_count)));
}
} // namespace impl
} // namesapce routing
} // namespace impl
} // namespace routing

7
libs/routing/base/small_list.hpp
View File

@@ -24,9 +24,10 @@ public:
static void Dump();
};
} // namespace impl
} // namespace impl
template <class T> class SmallList : public buffer_vector<T, 8>
template <class T>
class SmallList : public buffer_vector<T, 8>
{
using BaseT = buffer_vector<T, 8>;
@@ -54,4 +55,4 @@ inline std::string DebugPrint(SmallList<T> const & v)
return DebugPrint(static_cast<buffer_vector<T, 8> const &>(v));
}
} // namesapce routing
} // namespace routing