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
|
#ifndef MBGL_UTIL_GEO
#define MBGL_UTIL_GEO
#include <mbgl/util/vec.hpp>
#include <cmath>
namespace mbgl {
class TileID;
using PrecisionPoint = vec2<double>;
struct LatLng {
double latitude = 0;
double longitude = 0;
inline LatLng(double lat = 0, double lon = 0)
: latitude(lat), longitude(lon) {}
inline operator bool() const {
return !(std::isnan(latitude) || std::isnan(longitude));
}
// Constructs a LatLng object with the top left position of the specified tile.
LatLng(const TileID& id);
PrecisionPoint project() const;
};
struct ProjectedMeters {
double northing = 0;
double easting = 0;
inline ProjectedMeters(double n = 0, double e = 0)
: northing(n), easting(e) {}
inline operator bool() const {
return !(std::isnan(northing) || std::isnan(easting));
}
};
struct LatLngBounds {
LatLng sw = {-90, -180};
LatLng ne = {90, 180};
inline LatLngBounds() {}
inline LatLngBounds(const LatLng& sw_, const LatLng& ne_)
: sw(sw_), ne(ne_) {}
static inline LatLngBounds getExtendable() {
LatLngBounds bounds;
return { bounds.ne, bounds.sw };
}
inline operator bool() const {
return sw && ne;
}
// Constructs a LatLngBounds object with the tile's exact boundaries.
LatLngBounds(const TileID& id);
inline void extend(const LatLng& point) {
if (point.latitude < sw.latitude) sw.latitude = point.latitude;
if (point.latitude > ne.latitude) ne.latitude = point.latitude;
if (point.longitude < sw.longitude) sw.longitude = point.longitude;
if (point.longitude > ne.longitude) ne.longitude = point.longitude;
}
inline void extend(const LatLngBounds& bounds) {
extend(bounds.sw);
extend(bounds.ne);
}
inline bool contains(const LatLng& point) const {
return (point.latitude >= sw.latitude &&
point.latitude <= ne.latitude &&
point.longitude >= sw.longitude &&
point.longitude <= ne.longitude);
}
inline bool intersects(const LatLngBounds area) const {
return (area.ne.latitude > sw.latitude &&
area.sw.latitude < ne.latitude &&
area.ne.longitude > sw.longitude &&
area.sw.longitude < ne.longitude);
}
};
struct MetersBounds {
ProjectedMeters sw;
ProjectedMeters ne;
inline MetersBounds(const ProjectedMeters& sw_, const ProjectedMeters& ne_)
: sw(sw_), ne(ne_) {}
inline operator bool() const {
return sw && ne;
}
};
// Determines the orientation of the map.
enum class NorthOrientation : uint8_t {
Upwards, // Default
Rightwards,
Downwards,
Leftwards,
};
/// The distance on each side between a rectangle and a rectangle within.
struct EdgeInsets {
double top = 0; ///< Number of pixels inset from the top edge.
double left = 0; ///< Number of pixels inset from the left edge.
double bottom = 0; ///< Number of pixels inset from the bottom edge.
double right = 0; ///< Number of pixels inset from the right edge.
inline EdgeInsets() {}
inline EdgeInsets(const double t, const double l, const double b, const double r)
: top(t), left(l), bottom(b), right(r) {}
inline operator bool() const {
return top || left || bottom || right;
}
inline void operator+=(const EdgeInsets& o) {
top += o.top;
left += o.left;
bottom += o.bottom;
right += o.right;
}
inline EdgeInsets operator+(const EdgeInsets& o) const {
return {
top + o.top, left + o.left, bottom + o.bottom, right + o.right,
};
}
PrecisionPoint getCenter(uint16_t width, uint16_t height) const;
void flip();
};
} // namespace mbgl
#endif
|
