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
|
#pragma once
#include "routing/fake_feature_ids.hpp"
#include "routing/road_point.hpp"
#include "routing/route_weight.hpp"
#include "routing_common/num_mwm_id.hpp"
#include <cstdint>
#include <ios>
#include <sstream>
#include <string>
namespace routing
{
// This is directed road segment used as vertex in index graph.
//
// You can imagine the segment as a material arrow.
// Head of each arrow is connected to fletchings of next arrows with invisible links:
// these are the edges of the graph.
//
// Position of the segment is a position of the arrowhead: GetPointId(true).
// This position is used in heuristic and edges weight calculations.
class Segment final
{
public:
Segment() = default;
constexpr Segment(NumMwmId mwmId, uint32_t featureId, uint32_t segmentIdx, bool forward)
: m_featureId(featureId), m_segmentIdx(segmentIdx), m_mwmId(mwmId), m_forward(forward)
{
}
NumMwmId GetMwmId() const { return m_mwmId; }
uint32_t GetFeatureId() const { return m_featureId; }
uint32_t GetSegmentIdx() const { return m_segmentIdx; }
bool IsForward() const { return m_forward; }
uint32_t GetPointId(bool front) const
{
return m_forward == front ? m_segmentIdx + 1 : m_segmentIdx;
}
uint32_t GetMinPointId() const { return m_segmentIdx; }
uint32_t GetMaxPointId() const { return m_segmentIdx + 1; }
RoadPoint GetRoadPoint(bool front) const { return RoadPoint(m_featureId, GetPointId(front)); }
bool operator<(Segment const & seg) const
{
if (m_featureId != seg.m_featureId)
return m_featureId < seg.m_featureId;
if (m_segmentIdx != seg.m_segmentIdx)
return m_segmentIdx < seg.m_segmentIdx;
if (m_mwmId != seg.m_mwmId)
return m_mwmId < seg.m_mwmId;
return m_forward < seg.m_forward;
}
bool operator==(Segment const & seg) const
{
return m_featureId == seg.m_featureId && m_segmentIdx == seg.m_segmentIdx &&
m_mwmId == seg.m_mwmId && m_forward == seg.m_forward;
}
bool operator!=(Segment const & seg) const { return !(*this == seg); }
bool IsInverse(Segment const & seg) const
{
return m_featureId == seg.m_featureId && m_segmentIdx == seg.m_segmentIdx &&
m_mwmId == seg.m_mwmId && m_forward != seg.m_forward;
}
void Inverse() { m_forward = !m_forward; }
bool IsRealSegment() const
{
return m_mwmId != kFakeNumMwmId && !FakeFeatureIds::IsTransitFeature(m_featureId);
}
void Next(bool forward)
{
forward ? ++m_segmentIdx : --m_segmentIdx;
}
private:
uint32_t m_featureId = 0;
uint32_t m_segmentIdx = 0;
NumMwmId m_mwmId = kFakeNumMwmId;
bool m_forward = false;
};
class SegmentEdge final
{
public:
SegmentEdge() = default;
SegmentEdge(Segment const & target, RouteWeight const & weight)
: m_target(target), m_weight(weight)
{
}
Segment const & GetTarget() const { return m_target; }
RouteWeight const & GetWeight() const { return m_weight; }
bool operator==(SegmentEdge const & edge) const
{
return m_target == edge.m_target && m_weight == edge.m_weight;
}
bool operator<(SegmentEdge const & edge) const
{
if (m_target != edge.m_target)
return m_target < edge.m_target;
return m_weight < edge.m_weight;
}
private:
// Target is vertex going to for outgoing edges, vertex going from for ingoing edges.
Segment m_target;
RouteWeight m_weight;
};
inline std::string DebugPrint(Segment const & segment)
{
std::ostringstream out;
out << std::boolalpha << "Segment(" << segment.GetMwmId() << ", " << segment.GetFeatureId() << ", "
<< segment.GetSegmentIdx() << ", " << segment.IsForward() << ")";
return out.str();
}
inline std::string DebugPrint(SegmentEdge const & edge)
{
std::ostringstream out;
out << "Edge(" << DebugPrint(edge.GetTarget()) << ", " << edge.GetWeight() << ")";
return out.str();
}
} // namespace routing
|
