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
|
// Boost.Geometry
// Copyright (c) 2022 Barend Gehrels, Amsterdam, the Netherlands.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_BUFFER_JOIN_MITER_HPP
#define BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_BUFFER_JOIN_MITER_HPP
#include <boost/range/value_type.hpp>
#include <boost/geometry/core/radian_access.hpp>
#include <boost/geometry/srs/spheroid.hpp>
#include <boost/geometry/strategies/buffer.hpp>
#include <boost/geometry/strategies/geographic/buffer_helper.hpp>
#include <boost/geometry/strategies/geographic/parameters.hpp>
#include <boost/geometry/util/math.hpp>
#include <boost/geometry/util/select_calculation_type.hpp>
namespace boost { namespace geometry
{
namespace strategy { namespace buffer
{
template
<
typename FormulaPolicy = strategy::andoyer,
typename Spheroid = srs::spheroid<double>,
typename CalculationType = void
>
class geographic_join_miter
{
public :
//! \brief Constructs the strategy with a spheroid
//! \param spheroid The spheroid to be used
//! \param miter_limit The miter limit, to avoid excessively long miters around sharp corners
explicit inline geographic_join_miter(Spheroid const& spheroid,
double miter_limit = 5.0)
: m_spheroid(spheroid)
, m_miter_limit(valid_limit(miter_limit))
{}
//! \brief Constructs the strategy
//! \param miter_limit The miter limit, to avoid excessively long miters around sharp corners
explicit inline geographic_join_miter(double miter_limit = 5.0)
: m_miter_limit(valid_limit(miter_limit))
{}
#ifndef DOXYGEN_SHOULD_SKIP_THIS
//! Fills output_range with a sharp shape around a vertex
template <typename Point, typename DistanceType, typename RangeOut>
inline bool apply(Point const& , Point const& vertex,
Point const& perp1, Point const& perp2,
DistanceType const& buffer_distance,
RangeOut& range_out) const
{
using calc_t = typename select_calculation_type
<
Point,
typename boost::range_value<RangeOut>::type,
CalculationType
>::type;
using helper = geographic_buffer_helper<FormulaPolicy, calc_t>;
calc_t const lon_rad = get_as_radian<0>(vertex);
calc_t const lat_rad = get_as_radian<1>(vertex);
calc_t first_azimuth;
calc_t angle_diff;
if (! helper::calculate_angles(lon_rad, lat_rad, perp1, perp2, m_spheroid,
angle_diff, first_azimuth))
{
return false;
}
calc_t const half = 0.5;
calc_t const half_angle_diff = half * angle_diff;
calc_t const azi = math::wrap_azimuth_in_radian(first_azimuth + half_angle_diff);
calc_t const cos_angle = std::cos(half_angle_diff);
if (cos_angle == 0)
{
// It is opposite, perp1==perp2, do not generate a miter cap
return false;
}
// If it is sharp (angle close to 0), the distance will become too high and will be capped.
calc_t const max_distance = m_miter_limit * geometry::math::abs(buffer_distance);
calc_t const distance = (std::min)(max_distance, buffer_distance / cos_angle);
range_out.push_back(perp1);
helper::append_point(lon_rad, lat_rad, distance, azi, m_spheroid, range_out);
range_out.push_back(perp2);
return true;
}
template <typename NumericType>
inline NumericType max_distance(NumericType const& distance) const
{
return distance * m_miter_limit;
}
#endif // DOXYGEN_SHOULD_SKIP_THIS
private :
double valid_limit(double miter_limit) const
{
if (miter_limit < 1.0)
{
// It should always exceed the buffer distance
miter_limit = 1.0;
}
return miter_limit;
}
Spheroid m_spheroid;
double m_miter_limit;
};
}} // namespace strategy::buffer
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_BUFFER_JOIN_MITER_HPP
|
