stabilize build system: depends, installer, boost/bdb fixes, cross targets groundwork
This commit is contained in:
@@ -0,0 +1,182 @@
|
||||
// Boost.Geometry (aka GGL, Generic Geometry Library)
|
||||
|
||||
// Copyright (c) 2016-2017 Oracle and/or its affiliates.
|
||||
// Contributed and/or modified by Vissarion Fisikopoulos, on behalf of Oracle
|
||||
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
|
||||
|
||||
// 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_SPHERICAL_AREA_HPP
|
||||
#define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_AREA_HPP
|
||||
|
||||
|
||||
#include <boost/geometry/formulas/area_formulas.hpp>
|
||||
#include <boost/geometry/core/radius.hpp>
|
||||
#include <boost/geometry/core/srs.hpp>
|
||||
#include <boost/geometry/strategies/area.hpp>
|
||||
|
||||
|
||||
namespace boost { namespace geometry
|
||||
{
|
||||
|
||||
namespace strategy { namespace area
|
||||
{
|
||||
|
||||
/*!
|
||||
\brief Spherical area calculation
|
||||
\ingroup strategies
|
||||
\details Calculates area on the surface of a sphere using the trapezoidal rule
|
||||
\tparam PointOfSegment \tparam_segment_point
|
||||
\tparam CalculationType \tparam_calculation
|
||||
|
||||
\qbk{
|
||||
[heading See also]
|
||||
[link geometry.reference.algorithms.area.area_2_with_strategy area (with strategy)]
|
||||
}
|
||||
*/
|
||||
template
|
||||
<
|
||||
typename PointOfSegment,
|
||||
typename CalculationType = void
|
||||
>
|
||||
class spherical
|
||||
{
|
||||
// Enables special handling of long segments
|
||||
static const bool LongSegment = false;
|
||||
|
||||
typedef typename boost::mpl::if_c
|
||||
<
|
||||
boost::is_void<CalculationType>::type::value,
|
||||
typename select_most_precise
|
||||
<
|
||||
typename coordinate_type<PointOfSegment>::type,
|
||||
double
|
||||
>::type,
|
||||
CalculationType
|
||||
>::type CT;
|
||||
|
||||
protected :
|
||||
struct excess_sum
|
||||
{
|
||||
CT m_sum;
|
||||
|
||||
// Keep track if encircles some pole
|
||||
size_t m_crosses_prime_meridian;
|
||||
|
||||
inline excess_sum()
|
||||
: m_sum(0)
|
||||
, m_crosses_prime_meridian(0)
|
||||
{}
|
||||
template <typename SphereType>
|
||||
inline CT area(SphereType sphere) const
|
||||
{
|
||||
CT result;
|
||||
CT radius = geometry::get_radius<0>(sphere);
|
||||
|
||||
// Encircles pole
|
||||
if(m_crosses_prime_meridian % 2 == 1)
|
||||
{
|
||||
size_t times_crosses_prime_meridian
|
||||
= 1 + (m_crosses_prime_meridian / 2);
|
||||
|
||||
result = CT(2)
|
||||
* geometry::math::pi<CT>()
|
||||
* times_crosses_prime_meridian
|
||||
- geometry::math::abs(m_sum);
|
||||
|
||||
if(geometry::math::sign<CT>(m_sum) == 1)
|
||||
{
|
||||
result = - result;
|
||||
}
|
||||
|
||||
} else {
|
||||
result = m_sum;
|
||||
}
|
||||
|
||||
result *= radius * radius;
|
||||
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
public :
|
||||
typedef CT return_type;
|
||||
typedef PointOfSegment segment_point_type;
|
||||
typedef excess_sum state_type;
|
||||
typedef geometry::srs::sphere<CT> sphere_type;
|
||||
|
||||
// For backward compatibility reasons the radius is set to 1
|
||||
inline spherical()
|
||||
: m_sphere(1.0)
|
||||
{}
|
||||
|
||||
template <typename T>
|
||||
explicit inline spherical(geometry::srs::sphere<T> const& sphere)
|
||||
: m_sphere(geometry::get_radius<0>(sphere))
|
||||
{}
|
||||
|
||||
explicit inline spherical(CT const& radius)
|
||||
: m_sphere(radius)
|
||||
{}
|
||||
|
||||
inline void apply(PointOfSegment const& p1,
|
||||
PointOfSegment const& p2,
|
||||
excess_sum& state) const
|
||||
{
|
||||
if (! geometry::math::equals(get<0>(p1), get<0>(p2)))
|
||||
{
|
||||
|
||||
state.m_sum += geometry::formula::area_formulas
|
||||
<CT>::template spherical<LongSegment>(p1, p2);
|
||||
|
||||
// Keep track whenever a segment crosses the prime meridian
|
||||
geometry::formula::area_formulas
|
||||
<CT>::crosses_prime_meridian(p1, p2, state);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
inline return_type result(excess_sum const& state) const
|
||||
{
|
||||
return state.area(m_sphere);
|
||||
}
|
||||
|
||||
private :
|
||||
/// srs Sphere
|
||||
sphere_type m_sphere;
|
||||
};
|
||||
|
||||
#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
|
||||
|
||||
namespace services
|
||||
{
|
||||
|
||||
|
||||
template <typename Point>
|
||||
struct default_strategy<spherical_equatorial_tag, Point>
|
||||
{
|
||||
typedef strategy::area::spherical<Point> type;
|
||||
};
|
||||
|
||||
// Note: spherical polar coordinate system requires "get_as_radian_equatorial"
|
||||
template <typename Point>
|
||||
struct default_strategy<spherical_polar_tag, Point>
|
||||
{
|
||||
typedef strategy::area::spherical<Point> type;
|
||||
};
|
||||
|
||||
} // namespace services
|
||||
|
||||
#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
|
||||
|
||||
|
||||
}} // namespace strategy::area
|
||||
|
||||
|
||||
|
||||
|
||||
}} // namespace boost::geometry
|
||||
|
||||
#endif // BOOST_GEOMETRY_STRATEGIES_SPHERICAL_AREA_HPP
|
||||
@@ -0,0 +1,87 @@
|
||||
// Boost.Geometry (aka GGL, Generic Geometry Library)
|
||||
|
||||
// Copyright (c) 2016-2017 Oracle and/or its affiliates.
|
||||
// Contributed and/or modified by Vissarion Fisikopoulos, on behalf of Oracle
|
||||
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
|
||||
|
||||
// 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_SPHERICAL_AZIMUTH_HPP
|
||||
#define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_AZIMUTH_HPP
|
||||
|
||||
|
||||
#include <boost/geometry/strategies/azimuth.hpp>
|
||||
#include <boost/geometry/formulas/spherical.hpp>
|
||||
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/type_traits/is_void.hpp>
|
||||
|
||||
|
||||
namespace boost { namespace geometry
|
||||
{
|
||||
|
||||
namespace strategy { namespace azimuth
|
||||
{
|
||||
|
||||
template
|
||||
<
|
||||
typename CalculationType = void
|
||||
>
|
||||
class spherical
|
||||
{
|
||||
public :
|
||||
|
||||
inline spherical()
|
||||
{}
|
||||
|
||||
template <typename T>
|
||||
static inline void apply(T const& lon1_rad, T const& lat1_rad,
|
||||
T const& lon2_rad, T const& lat2_rad,
|
||||
T& a1, T& a2)
|
||||
{
|
||||
typedef typename boost::mpl::if_
|
||||
<
|
||||
boost::is_void<CalculationType>, T, CalculationType
|
||||
>::type calc_t;
|
||||
|
||||
geometry::formula::result_spherical<calc_t>
|
||||
result = geometry::formula::spherical_azimuth<calc_t, true>(
|
||||
calc_t(lon1_rad), calc_t(lat1_rad),
|
||||
calc_t(lon2_rad), calc_t(lat2_rad));
|
||||
|
||||
a1 = result.azimuth;
|
||||
a2 = result.reverse_azimuth;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
|
||||
|
||||
namespace services
|
||||
{
|
||||
|
||||
template <typename CalculationType>
|
||||
struct default_strategy<spherical_equatorial_tag, CalculationType>
|
||||
{
|
||||
typedef strategy::azimuth::spherical<CalculationType> type;
|
||||
};
|
||||
|
||||
/*
|
||||
template <typename CalculationType>
|
||||
struct default_strategy<spherical_polar_tag, CalculationType>
|
||||
{
|
||||
typedef strategy::azimuth::spherical<CalculationType> type;
|
||||
};
|
||||
*/
|
||||
}
|
||||
|
||||
#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
|
||||
|
||||
}} // namespace strategy::azimuth
|
||||
|
||||
|
||||
}} // namespace boost::geometry
|
||||
|
||||
#endif // BOOST_GEOMETRY_STRATEGIES_SPHERICAL_AZIMUTH_HPP
|
||||
+152
@@ -0,0 +1,152 @@
|
||||
// Boost.Geometry (aka GGL, Generic Geometry Library)
|
||||
|
||||
// Copyright (c) 2007-2012 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_SPHERICAL_COMPARE_SPHERICAL_HPP
|
||||
#define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_COMPARE_SPHERICAL_HPP
|
||||
|
||||
#include <boost/math/constants/constants.hpp>
|
||||
|
||||
#include <boost/geometry/core/cs.hpp>
|
||||
#include <boost/geometry/core/tags.hpp>
|
||||
#include <boost/geometry/strategies/compare.hpp>
|
||||
#include <boost/geometry/util/math.hpp>
|
||||
|
||||
|
||||
namespace boost { namespace geometry
|
||||
{
|
||||
|
||||
|
||||
namespace strategy { namespace compare
|
||||
{
|
||||
|
||||
|
||||
#ifndef DOXYGEN_NO_DETAIL
|
||||
namespace detail
|
||||
{
|
||||
|
||||
template <typename Units>
|
||||
struct shift
|
||||
{
|
||||
};
|
||||
|
||||
template <>
|
||||
struct shift<degree>
|
||||
{
|
||||
static inline double full() { return 360.0; }
|
||||
static inline double half() { return 180.0; }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct shift<radian>
|
||||
{
|
||||
static inline double full() { return 2.0 * boost::math::constants::pi<double>(); }
|
||||
static inline double half() { return boost::math::constants::pi<double>(); }
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
#endif
|
||||
|
||||
/*!
|
||||
\brief Compare (in one direction) strategy for spherical coordinates
|
||||
\ingroup strategies
|
||||
\tparam Point point-type
|
||||
\tparam Dimension dimension
|
||||
*/
|
||||
template <typename CoordinateType, typename Units, typename Compare>
|
||||
struct circular_comparator
|
||||
{
|
||||
static inline CoordinateType put_in_range(CoordinateType const& c,
|
||||
double min_border, double max_border)
|
||||
{
|
||||
CoordinateType value = c;
|
||||
while (value < min_border)
|
||||
{
|
||||
value += detail::shift<Units>::full();
|
||||
}
|
||||
while (value > max_border)
|
||||
{
|
||||
value -= detail::shift<Units>::full();
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
inline bool operator()(CoordinateType const& c1, CoordinateType const& c2) const
|
||||
{
|
||||
Compare compare;
|
||||
|
||||
// Check situation that one of them is e.g. std::numeric_limits.
|
||||
static const double full = detail::shift<Units>::full();
|
||||
double mx = 10.0 * full;
|
||||
if (c1 < -mx || c1 > mx || c2 < -mx || c2 > mx)
|
||||
{
|
||||
// do normal comparison, using circular is not useful
|
||||
return compare(c1, c2);
|
||||
}
|
||||
|
||||
static const double half = full / 2.0;
|
||||
CoordinateType v1 = put_in_range(c1, -half, half);
|
||||
CoordinateType v2 = put_in_range(c2, -half, half);
|
||||
|
||||
// Two coordinates on a circle are
|
||||
// at max <= half a circle away from each other.
|
||||
// So if it is more, shift origin.
|
||||
CoordinateType diff = geometry::math::abs(v1 - v2);
|
||||
if (diff > half)
|
||||
{
|
||||
v1 = put_in_range(v1, 0, full);
|
||||
v2 = put_in_range(v2, 0, full);
|
||||
}
|
||||
|
||||
return compare(v1, v2);
|
||||
}
|
||||
};
|
||||
|
||||
}} // namespace strategy::compare
|
||||
|
||||
#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
|
||||
|
||||
// Specialize for the longitude (dim 0)
|
||||
template
|
||||
<
|
||||
typename Point,
|
||||
template<typename> class CoordinateSystem,
|
||||
typename Units
|
||||
>
|
||||
struct strategy_compare<spherical_polar_tag, 1, Point, CoordinateSystem<Units>, 0>
|
||||
{
|
||||
typedef typename coordinate_type<Point>::type coordinate_type;
|
||||
typedef strategy::compare::circular_comparator
|
||||
<
|
||||
coordinate_type,
|
||||
Units,
|
||||
std::less<coordinate_type>
|
||||
> type;
|
||||
};
|
||||
|
||||
template
|
||||
<
|
||||
typename Point,
|
||||
template<typename> class CoordinateSystem,
|
||||
typename Units
|
||||
>
|
||||
struct strategy_compare<spherical_polar_tag, -1, Point, CoordinateSystem<Units>, 0>
|
||||
{
|
||||
typedef typename coordinate_type<Point>::type coordinate_type;
|
||||
typedef strategy::compare::circular_comparator
|
||||
<
|
||||
coordinate_type,
|
||||
Units,
|
||||
std::greater<coordinate_type>
|
||||
> type;
|
||||
};
|
||||
|
||||
#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
|
||||
|
||||
}} // namespace boost::geometry
|
||||
|
||||
#endif // BOOST_GEOMETRY_STRATEGIES_SPHERICAL_COMPARE_SPHERICAL_HPP
|
||||
+773
@@ -0,0 +1,773 @@
|
||||
// Boost.Geometry (aka GGL, Generic Geometry Library)
|
||||
|
||||
// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
|
||||
|
||||
// This file was modified by Oracle on 2014.
|
||||
// Modifications copyright (c) 2014, Oracle and/or its affiliates.
|
||||
|
||||
// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
|
||||
|
||||
// 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_SPHERICAL_DISTANCE_CROSS_TRACK_HPP
|
||||
#define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_DISTANCE_CROSS_TRACK_HPP
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/concept_check.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/type_traits/is_void.hpp>
|
||||
|
||||
#include <boost/geometry/core/cs.hpp>
|
||||
#include <boost/geometry/core/access.hpp>
|
||||
#include <boost/geometry/core/radian_access.hpp>
|
||||
#include <boost/geometry/core/tags.hpp>
|
||||
|
||||
#include <boost/geometry/algorithms/detail/course.hpp>
|
||||
|
||||
#include <boost/geometry/strategies/distance.hpp>
|
||||
#include <boost/geometry/strategies/concepts/distance_concept.hpp>
|
||||
#include <boost/geometry/strategies/spherical/distance_haversine.hpp>
|
||||
|
||||
#include <boost/geometry/util/math.hpp>
|
||||
#include <boost/geometry/util/promote_floating_point.hpp>
|
||||
#include <boost/geometry/util/select_calculation_type.hpp>
|
||||
|
||||
#ifdef BOOST_GEOMETRY_DEBUG_CROSS_TRACK
|
||||
# include <boost/geometry/io/dsv/write.hpp>
|
||||
#endif
|
||||
|
||||
|
||||
namespace boost { namespace geometry
|
||||
{
|
||||
|
||||
namespace strategy { namespace distance
|
||||
{
|
||||
|
||||
|
||||
namespace comparable
|
||||
{
|
||||
|
||||
/*
|
||||
Given a spherical segment AB and a point D, we are interested in
|
||||
computing the distance of D from AB. This is usually known as the
|
||||
cross track distance.
|
||||
|
||||
If the projection (along great circles) of the point D lies inside
|
||||
the segment AB, then the distance (cross track error) XTD is given
|
||||
by the formula (see http://williams.best.vwh.net/avform.htm#XTE):
|
||||
|
||||
XTD = asin( sin(dist_AD) * sin(crs_AD-crs_AB) )
|
||||
|
||||
where dist_AD is the great circle distance between the points A and
|
||||
B, and crs_AD, crs_AB is the course (bearing) between the points A,
|
||||
D and A, B, respectively.
|
||||
|
||||
If the point D does not project inside the arc AB, then the distance
|
||||
of D from AB is the minimum of the two distances dist_AD and dist_BD.
|
||||
|
||||
Our reference implementation for this procedure is listed below
|
||||
(this was the old Boost.Geometry implementation of the cross track distance),
|
||||
where:
|
||||
* The member variable m_strategy is the underlying haversine strategy.
|
||||
* p stands for the point D.
|
||||
* sp1 stands for the segment endpoint A.
|
||||
* sp2 stands for the segment endpoint B.
|
||||
|
||||
================= reference implementation -- start =================
|
||||
|
||||
return_type d1 = m_strategy.apply(sp1, p);
|
||||
return_type d3 = m_strategy.apply(sp1, sp2);
|
||||
|
||||
if (geometry::math::equals(d3, 0.0))
|
||||
{
|
||||
// "Degenerate" segment, return either d1 or d2
|
||||
return d1;
|
||||
}
|
||||
|
||||
return_type d2 = m_strategy.apply(sp2, p);
|
||||
|
||||
return_type crs_AD = geometry::detail::course<return_type>(sp1, p);
|
||||
return_type crs_AB = geometry::detail::course<return_type>(sp1, sp2);
|
||||
return_type crs_BA = crs_AB - geometry::math::pi<return_type>();
|
||||
return_type crs_BD = geometry::detail::course<return_type>(sp2, p);
|
||||
return_type d_crs1 = crs_AD - crs_AB;
|
||||
return_type d_crs2 = crs_BD - crs_BA;
|
||||
|
||||
// d1, d2, d3 are in principle not needed, only the sign matters
|
||||
return_type projection1 = cos( d_crs1 ) * d1 / d3;
|
||||
return_type projection2 = cos( d_crs2 ) * d2 / d3;
|
||||
|
||||
if (projection1 > 0.0 && projection2 > 0.0)
|
||||
{
|
||||
return_type XTD
|
||||
= radius() * math::abs( asin( sin( d1 / radius() ) * sin( d_crs1 ) ));
|
||||
|
||||
// Return shortest distance, projected point on segment sp1-sp2
|
||||
return return_type(XTD);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Return shortest distance, project either on point sp1 or sp2
|
||||
return return_type( (std::min)( d1 , d2 ) );
|
||||
}
|
||||
|
||||
================= reference implementation -- end =================
|
||||
|
||||
|
||||
Motivation
|
||||
----------
|
||||
In what follows we develop a comparable version of the cross track
|
||||
distance strategy, that meets the following goals:
|
||||
* It is more efficient than the original cross track strategy (less
|
||||
operations and less calls to mathematical functions).
|
||||
* Distances using the comparable cross track strategy can not only
|
||||
be compared with other distances using the same strategy, but also with
|
||||
distances computed with the comparable version of the haversine strategy.
|
||||
* It can serve as the basis for the computation of the cross track distance,
|
||||
as it is more efficient to compute its comparable version and
|
||||
transform that to the actual cross track distance, rather than
|
||||
follow/use the reference implementation listed above.
|
||||
|
||||
Major idea
|
||||
----------
|
||||
The idea here is to use the comparable haversine strategy to compute
|
||||
the distances d1, d2 and d3 in the above listing. Once we have done
|
||||
that we need also to make sure that instead of returning XTD (as
|
||||
computed above) that we return a distance CXTD that is compatible
|
||||
with the comparable haversine distance. To achieve this CXTD must satisfy
|
||||
the relation:
|
||||
XTD = 2 * R * asin( sqrt(XTD) )
|
||||
where R is the sphere's radius.
|
||||
|
||||
Below we perform the mathematical analysis that show how to compute CXTD.
|
||||
|
||||
|
||||
Mathematical analysis
|
||||
---------------------
|
||||
Below we use the following trigonometric identities:
|
||||
sin(2 * x) = 2 * sin(x) * cos(x)
|
||||
cos(asin(x)) = sqrt(1 - x^2)
|
||||
|
||||
Observation:
|
||||
The distance d1 needed when the projection of the point D is within the
|
||||
segment must be the true distance. However, comparable::haversine<>
|
||||
returns a comparable distance instead of the one needed.
|
||||
To remedy this, we implicitly compute what is needed.
|
||||
More precisely, we need to compute sin(true_d1):
|
||||
|
||||
sin(true_d1) = sin(2 * asin(sqrt(d1)))
|
||||
= 2 * sin(asin(sqrt(d1)) * cos(asin(sqrt(d1)))
|
||||
= 2 * sqrt(d1) * sqrt(1-(sqrt(d1))^2)
|
||||
= 2 * sqrt(d1 - d1 * d1)
|
||||
This relation is used below.
|
||||
|
||||
As we mentioned above the goal is to find CXTD (named "a" below for
|
||||
brevity) such that ("b" below stands for "d1", and "c" for "d_crs1"):
|
||||
|
||||
2 * R * asin(sqrt(a)) == R * asin(2 * sqrt(b-b^2) * sin(c))
|
||||
|
||||
Analysis:
|
||||
2 * R * asin(sqrt(a)) == R * asin(2 * sqrt(b-b^2) * sin(c))
|
||||
<=> 2 * asin(sqrt(a)) == asin(sqrt(b-b^2) * sin(c))
|
||||
<=> sin(2 * asin(sqrt(a))) == 2 * sqrt(b-b^2) * sin(c)
|
||||
<=> 2 * sin(asin(sqrt(a))) * cos(asin(sqrt(a))) == 2 * sqrt(b-b^2) * sin(c)
|
||||
<=> 2 * sqrt(a) * sqrt(1-a) == 2 * sqrt(b-b^2) * sin(c)
|
||||
<=> sqrt(a) * sqrt(1-a) == sqrt(b-b^2) * sin(c)
|
||||
<=> sqrt(a-a^2) == sqrt(b-b^2) * sin(c)
|
||||
<=> a-a^2 == (b-b^2) * (sin(c))^2
|
||||
|
||||
Consider the quadratic equation: x^2-x+p^2 == 0,
|
||||
where p = sqrt(b-b^2) * sin(c); its discriminant is:
|
||||
d = 1 - 4 * p^2 = 1 - 4 * (b-b^2) * (sin(c))^2
|
||||
|
||||
The two solutions are:
|
||||
a_1 = (1 - sqrt(d)) / 2
|
||||
a_2 = (1 + sqrt(d)) / 2
|
||||
|
||||
Which one to choose?
|
||||
"a" refers to the distance (on the unit sphere) of D from the
|
||||
supporting great circle Circ(A,B) of the segment AB.
|
||||
The two different values for "a" correspond to the lengths of the two
|
||||
arcs delimited D and the points of intersection of Circ(A,B) and the
|
||||
great circle perperdicular to Circ(A,B) passing through D.
|
||||
Clearly, the value we want is the smallest among these two distances,
|
||||
hence the root we must choose is the smallest root among the two.
|
||||
|
||||
So the answer is:
|
||||
CXTD = ( 1 - sqrt(1 - 4 * (b-b^2) * (sin(c))^2) ) / 2
|
||||
|
||||
Therefore, in order to implement the comparable version of the cross
|
||||
track strategy we need to:
|
||||
(1) Use the comparable version of the haversine strategy instead of
|
||||
the non-comparable one.
|
||||
(2) Instead of return XTD when D projects inside the segment AB, we
|
||||
need to return CXTD, given by the following formula:
|
||||
CXTD = ( 1 - sqrt(1 - 4 * (d1-d1^2) * (sin(d_crs1))^2) ) / 2;
|
||||
|
||||
|
||||
Complexity Analysis
|
||||
-------------------
|
||||
In the analysis that follows we refer to the actual implementation below.
|
||||
In particular, instead of computing CXTD as above, we use the more
|
||||
efficient (operation-wise) computation of CXTD shown here:
|
||||
|
||||
return_type sin_d_crs1 = sin(d_crs1);
|
||||
return_type d1_x_sin = d1 * sin_d_crs1;
|
||||
return_type d = d1_x_sin * (sin_d_crs1 - d1_x_sin);
|
||||
return d / (0.5 + math::sqrt(0.25 - d));
|
||||
|
||||
Notice that instead of computing:
|
||||
0.5 - 0.5 * sqrt(1 - 4 * d) = 0.5 - sqrt(0.25 - d)
|
||||
we use the following formula instead:
|
||||
d / (0.5 + sqrt(0.25 - d)).
|
||||
This is done for numerical robustness. The expression 0.5 - sqrt(0.25 - x)
|
||||
has large numerical errors for values of x close to 0 (if using doubles
|
||||
the error start to become large even when d is as large as 0.001).
|
||||
To remedy that, we re-write 0.5 - sqrt(0.25 - x) as:
|
||||
0.5 - sqrt(0.25 - d)
|
||||
= (0.5 - sqrt(0.25 - d) * (0.5 - sqrt(0.25 - d)) / (0.5 + sqrt(0.25 - d)).
|
||||
The numerator is the difference of two squares:
|
||||
(0.5 - sqrt(0.25 - d) * (0.5 - sqrt(0.25 - d))
|
||||
= 0.5^2 - (sqrt(0.25 - d))^ = 0.25 - (0.25 - d) = d,
|
||||
which gives the expression we use.
|
||||
|
||||
For the complexity analysis, we distinguish between two cases:
|
||||
(A) The distance is realized between the point D and an
|
||||
endpoint of the segment AB
|
||||
|
||||
Gains:
|
||||
Since we are using comparable::haversine<> which is called
|
||||
3 times, we gain:
|
||||
-> 3 calls to sqrt
|
||||
-> 3 calls to asin
|
||||
-> 6 multiplications
|
||||
|
||||
Loses: None
|
||||
|
||||
So the net gain is:
|
||||
-> 6 function calls (sqrt/asin)
|
||||
-> 6 arithmetic operations
|
||||
|
||||
If we use comparable::cross_track<> to compute
|
||||
cross_track<> we need to account for a call to sqrt, a call
|
||||
to asin and 2 multiplications. In this case the net gain is:
|
||||
-> 4 function calls (sqrt/asin)
|
||||
-> 4 arithmetic operations
|
||||
|
||||
|
||||
(B) The distance is realized between the point D and an
|
||||
interior point of the segment AB
|
||||
|
||||
Gains:
|
||||
Since we are using comparable::haversine<> which is called
|
||||
3 times, we gain:
|
||||
-> 3 calls to sqrt
|
||||
-> 3 calls to asin
|
||||
-> 6 multiplications
|
||||
Also we gain the operations used to compute XTD:
|
||||
-> 2 calls to sin
|
||||
-> 1 call to asin
|
||||
-> 1 call to abs
|
||||
-> 2 multiplications
|
||||
-> 1 division
|
||||
So the total gains are:
|
||||
-> 9 calls to sqrt/sin/asin
|
||||
-> 1 call to abs
|
||||
-> 8 multiplications
|
||||
-> 1 division
|
||||
|
||||
Loses:
|
||||
To compute a distance compatible with comparable::haversine<>
|
||||
we need to perform a few more operations, namely:
|
||||
-> 1 call to sin
|
||||
-> 1 call to sqrt
|
||||
-> 2 multiplications
|
||||
-> 1 division
|
||||
-> 1 addition
|
||||
-> 2 subtractions
|
||||
|
||||
So roughly speaking the net gain is:
|
||||
-> 8 fewer function calls and 3 fewer arithmetic operations
|
||||
|
||||
If we were to implement cross_track directly from the
|
||||
comparable version (much like what haversine<> does using
|
||||
comparable::haversine<>) we need additionally
|
||||
-> 2 function calls (asin/sqrt)
|
||||
-> 2 multiplications
|
||||
|
||||
So it pays off to re-implement cross_track<> to use
|
||||
comparable::cross_track<>; in this case the net gain would be:
|
||||
-> 6 function calls
|
||||
-> 1 arithmetic operation
|
||||
|
||||
Summary/Conclusion
|
||||
------------------
|
||||
Following the mathematical and complexity analysis above, the
|
||||
comparable cross track strategy (as implemented below) satisfies
|
||||
all the goal mentioned in the beginning:
|
||||
* It is more efficient than its non-comparable counter-part.
|
||||
* Comparable distances using this new strategy can also be compared
|
||||
with comparable distances computed with the comparable haversine
|
||||
strategy.
|
||||
* It turns out to be more efficient to compute the actual cross
|
||||
track distance XTD by first computing CXTD, and then computing
|
||||
XTD by means of the formula:
|
||||
XTD = 2 * R * asin( sqrt(CXTD) )
|
||||
*/
|
||||
|
||||
template
|
||||
<
|
||||
typename CalculationType = void,
|
||||
typename Strategy = comparable::haversine<double, CalculationType>
|
||||
>
|
||||
class cross_track
|
||||
{
|
||||
public :
|
||||
template <typename Point, typename PointOfSegment>
|
||||
struct return_type
|
||||
: promote_floating_point
|
||||
<
|
||||
typename select_calculation_type
|
||||
<
|
||||
Point,
|
||||
PointOfSegment,
|
||||
CalculationType
|
||||
>::type
|
||||
>
|
||||
{};
|
||||
|
||||
typedef typename Strategy::radius_type radius_type;
|
||||
|
||||
inline cross_track()
|
||||
{}
|
||||
|
||||
explicit inline cross_track(typename Strategy::radius_type const& r)
|
||||
: m_strategy(r)
|
||||
{}
|
||||
|
||||
inline cross_track(Strategy const& s)
|
||||
: m_strategy(s)
|
||||
{}
|
||||
|
||||
|
||||
// It might be useful in the future
|
||||
// to overload constructor with strategy info.
|
||||
// crosstrack(...) {}
|
||||
|
||||
|
||||
template <typename Point, typename PointOfSegment>
|
||||
inline typename return_type<Point, PointOfSegment>::type
|
||||
apply(Point const& p, PointOfSegment const& sp1, PointOfSegment const& sp2) const
|
||||
{
|
||||
|
||||
#if !defined(BOOST_MSVC)
|
||||
BOOST_CONCEPT_ASSERT
|
||||
(
|
||||
(concepts::PointDistanceStrategy<Strategy, Point, PointOfSegment>)
|
||||
);
|
||||
#endif
|
||||
|
||||
typedef typename return_type<Point, PointOfSegment>::type return_type;
|
||||
|
||||
#ifdef BOOST_GEOMETRY_DEBUG_CROSS_TRACK
|
||||
std::cout << "Course " << dsv(sp1) << " to " << dsv(p) << " "
|
||||
<< crs_AD * geometry::math::r2d<return_type>() << std::endl;
|
||||
std::cout << "Course " << dsv(sp1) << " to " << dsv(sp2) << " "
|
||||
<< crs_AB * geometry::math::r2d<return_type>() << std::endl;
|
||||
std::cout << "Course " << dsv(sp2) << " to " << dsv(p) << " "
|
||||
<< crs_BD * geometry::math::r2d << std::endl;
|
||||
std::cout << "Projection AD-AB " << projection1 << " : "
|
||||
<< d_crs1 * geometry::math::r2d<return_type>() << std::endl;
|
||||
std::cout << "Projection BD-BA " << projection2 << " : "
|
||||
<< d_crs2 * geometry::math::r2d<return_type>() << std::endl;
|
||||
#endif
|
||||
|
||||
// http://williams.best.vwh.net/avform.htm#XTE
|
||||
return_type d1 = m_strategy.apply(sp1, p);
|
||||
return_type d3 = m_strategy.apply(sp1, sp2);
|
||||
|
||||
if (geometry::math::equals(d3, 0.0))
|
||||
{
|
||||
// "Degenerate" segment, return either d1 or d2
|
||||
return d1;
|
||||
}
|
||||
|
||||
return_type d2 = m_strategy.apply(sp2, p);
|
||||
|
||||
return_type crs_AD = geometry::detail::course<return_type>(sp1, p);
|
||||
return_type crs_AB = geometry::detail::course<return_type>(sp1, sp2);
|
||||
return_type crs_BA = crs_AB - geometry::math::pi<return_type>();
|
||||
return_type crs_BD = geometry::detail::course<return_type>(sp2, p);
|
||||
return_type d_crs1 = crs_AD - crs_AB;
|
||||
return_type d_crs2 = crs_BD - crs_BA;
|
||||
|
||||
// d1, d2, d3 are in principle not needed, only the sign matters
|
||||
return_type projection1 = cos( d_crs1 ) * d1 / d3;
|
||||
return_type projection2 = cos( d_crs2 ) * d2 / d3;
|
||||
|
||||
if (projection1 > 0.0 && projection2 > 0.0)
|
||||
{
|
||||
#ifdef BOOST_GEOMETRY_DEBUG_CROSS_TRACK
|
||||
return_type XTD = radius() * geometry::math::abs( asin( sin( d1 ) * sin( d_crs1 ) ));
|
||||
|
||||
std::cout << "Projection ON the segment" << std::endl;
|
||||
std::cout << "XTD: " << XTD
|
||||
<< " d1: " << (d1 * radius())
|
||||
<< " d2: " << (d2 * radius())
|
||||
<< std::endl;
|
||||
#endif
|
||||
return_type const half(0.5);
|
||||
return_type const quarter(0.25);
|
||||
|
||||
return_type sin_d_crs1 = sin(d_crs1);
|
||||
/*
|
||||
This is the straightforward obvious way to continue:
|
||||
|
||||
return_type discriminant
|
||||
= 1.0 - 4.0 * (d1 - d1 * d1) * sin_d_crs1 * sin_d_crs1;
|
||||
return 0.5 - 0.5 * math::sqrt(discriminant);
|
||||
|
||||
Below we optimize the number of arithmetic operations
|
||||
and account for numerical robustness:
|
||||
*/
|
||||
return_type d1_x_sin = d1 * sin_d_crs1;
|
||||
return_type d = d1_x_sin * (sin_d_crs1 - d1_x_sin);
|
||||
return d / (half + math::sqrt(quarter - d));
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef BOOST_GEOMETRY_DEBUG_CROSS_TRACK
|
||||
std::cout << "Projection OUTSIDE the segment" << std::endl;
|
||||
#endif
|
||||
|
||||
// Return shortest distance, project either on point sp1 or sp2
|
||||
return return_type( (std::min)( d1 , d2 ) );
|
||||
}
|
||||
}
|
||||
|
||||
inline typename Strategy::radius_type radius() const
|
||||
{ return m_strategy.radius(); }
|
||||
|
||||
private :
|
||||
Strategy m_strategy;
|
||||
};
|
||||
|
||||
} // namespace comparable
|
||||
|
||||
|
||||
/*!
|
||||
\brief Strategy functor for distance point to segment calculation
|
||||
\ingroup strategies
|
||||
\details Class which calculates the distance of a point to a segment, for points on a sphere or globe
|
||||
\see http://williams.best.vwh.net/avform.htm
|
||||
\tparam CalculationType \tparam_calculation
|
||||
\tparam Strategy underlying point-point distance strategy, defaults to haversine
|
||||
|
||||
\qbk{
|
||||
[heading See also]
|
||||
[link geometry.reference.algorithms.distance.distance_3_with_strategy distance (with strategy)]
|
||||
}
|
||||
|
||||
*/
|
||||
template
|
||||
<
|
||||
typename CalculationType = void,
|
||||
typename Strategy = haversine<double, CalculationType>
|
||||
>
|
||||
class cross_track
|
||||
{
|
||||
public :
|
||||
template <typename Point, typename PointOfSegment>
|
||||
struct return_type
|
||||
: promote_floating_point
|
||||
<
|
||||
typename select_calculation_type
|
||||
<
|
||||
Point,
|
||||
PointOfSegment,
|
||||
CalculationType
|
||||
>::type
|
||||
>
|
||||
{};
|
||||
|
||||
typedef typename Strategy::radius_type radius_type;
|
||||
|
||||
inline cross_track()
|
||||
{}
|
||||
|
||||
explicit inline cross_track(typename Strategy::radius_type const& r)
|
||||
: m_strategy(r)
|
||||
{}
|
||||
|
||||
inline cross_track(Strategy const& s)
|
||||
: m_strategy(s)
|
||||
{}
|
||||
|
||||
|
||||
// It might be useful in the future
|
||||
// to overload constructor with strategy info.
|
||||
// crosstrack(...) {}
|
||||
|
||||
|
||||
template <typename Point, typename PointOfSegment>
|
||||
inline typename return_type<Point, PointOfSegment>::type
|
||||
apply(Point const& p, PointOfSegment const& sp1, PointOfSegment const& sp2) const
|
||||
{
|
||||
|
||||
#if !defined(BOOST_MSVC)
|
||||
BOOST_CONCEPT_ASSERT
|
||||
(
|
||||
(concepts::PointDistanceStrategy<Strategy, Point, PointOfSegment>)
|
||||
);
|
||||
#endif
|
||||
typedef typename return_type<Point, PointOfSegment>::type return_type;
|
||||
typedef cross_track<CalculationType, Strategy> this_type;
|
||||
|
||||
typedef typename services::comparable_type
|
||||
<
|
||||
this_type
|
||||
>::type comparable_type;
|
||||
|
||||
comparable_type cstrategy
|
||||
= services::get_comparable<this_type>::apply(m_strategy);
|
||||
|
||||
return_type const a = cstrategy.apply(p, sp1, sp2);
|
||||
return_type const c = return_type(2.0) * asin(math::sqrt(a));
|
||||
return c * radius();
|
||||
}
|
||||
|
||||
inline typename Strategy::radius_type radius() const
|
||||
{ return m_strategy.radius(); }
|
||||
|
||||
private :
|
||||
|
||||
Strategy m_strategy;
|
||||
};
|
||||
|
||||
|
||||
|
||||
#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
|
||||
namespace services
|
||||
{
|
||||
|
||||
template <typename CalculationType, typename Strategy>
|
||||
struct tag<cross_track<CalculationType, Strategy> >
|
||||
{
|
||||
typedef strategy_tag_distance_point_segment type;
|
||||
};
|
||||
|
||||
|
||||
template <typename CalculationType, typename Strategy, typename P, typename PS>
|
||||
struct return_type<cross_track<CalculationType, Strategy>, P, PS>
|
||||
: cross_track<CalculationType, Strategy>::template return_type<P, PS>
|
||||
{};
|
||||
|
||||
|
||||
template <typename CalculationType, typename Strategy>
|
||||
struct comparable_type<cross_track<CalculationType, Strategy> >
|
||||
{
|
||||
typedef comparable::cross_track
|
||||
<
|
||||
CalculationType, typename comparable_type<Strategy>::type
|
||||
> type;
|
||||
};
|
||||
|
||||
|
||||
template
|
||||
<
|
||||
typename CalculationType,
|
||||
typename Strategy
|
||||
>
|
||||
struct get_comparable<cross_track<CalculationType, Strategy> >
|
||||
{
|
||||
typedef typename comparable_type
|
||||
<
|
||||
cross_track<CalculationType, Strategy>
|
||||
>::type comparable_type;
|
||||
public :
|
||||
static inline comparable_type
|
||||
apply(cross_track<CalculationType, Strategy> const& strategy)
|
||||
{
|
||||
return comparable_type(strategy.radius());
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template
|
||||
<
|
||||
typename CalculationType,
|
||||
typename Strategy,
|
||||
typename P,
|
||||
typename PS
|
||||
>
|
||||
struct result_from_distance<cross_track<CalculationType, Strategy>, P, PS>
|
||||
{
|
||||
private :
|
||||
typedef typename cross_track
|
||||
<
|
||||
CalculationType, Strategy
|
||||
>::template return_type<P, PS>::type return_type;
|
||||
public :
|
||||
template <typename T>
|
||||
static inline return_type
|
||||
apply(cross_track<CalculationType, Strategy> const& , T const& distance)
|
||||
{
|
||||
return distance;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// Specializations for comparable::cross_track
|
||||
template <typename RadiusType, typename CalculationType>
|
||||
struct tag<comparable::cross_track<RadiusType, CalculationType> >
|
||||
{
|
||||
typedef strategy_tag_distance_point_segment type;
|
||||
};
|
||||
|
||||
|
||||
template
|
||||
<
|
||||
typename RadiusType,
|
||||
typename CalculationType,
|
||||
typename P,
|
||||
typename PS
|
||||
>
|
||||
struct return_type<comparable::cross_track<RadiusType, CalculationType>, P, PS>
|
||||
: comparable::cross_track
|
||||
<
|
||||
RadiusType, CalculationType
|
||||
>::template return_type<P, PS>
|
||||
{};
|
||||
|
||||
|
||||
template <typename RadiusType, typename CalculationType>
|
||||
struct comparable_type<comparable::cross_track<RadiusType, CalculationType> >
|
||||
{
|
||||
typedef comparable::cross_track<RadiusType, CalculationType> type;
|
||||
};
|
||||
|
||||
|
||||
template <typename RadiusType, typename CalculationType>
|
||||
struct get_comparable<comparable::cross_track<RadiusType, CalculationType> >
|
||||
{
|
||||
private :
|
||||
typedef comparable::cross_track<RadiusType, CalculationType> this_type;
|
||||
public :
|
||||
static inline this_type apply(this_type const& input)
|
||||
{
|
||||
return input;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template
|
||||
<
|
||||
typename RadiusType,
|
||||
typename CalculationType,
|
||||
typename P,
|
||||
typename PS
|
||||
>
|
||||
struct result_from_distance
|
||||
<
|
||||
comparable::cross_track<RadiusType, CalculationType>, P, PS
|
||||
>
|
||||
{
|
||||
private :
|
||||
typedef comparable::cross_track<RadiusType, CalculationType> strategy_type;
|
||||
typedef typename return_type<strategy_type, P, PS>::type return_type;
|
||||
public :
|
||||
template <typename T>
|
||||
static inline return_type apply(strategy_type const& strategy,
|
||||
T const& distance)
|
||||
{
|
||||
return_type const s
|
||||
= sin( (distance / strategy.radius()) / return_type(2.0) );
|
||||
return s * s;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
/*
|
||||
|
||||
TODO: spherical polar coordinate system requires "get_as_radian_equatorial<>"
|
||||
|
||||
template <typename Point, typename PointOfSegment, typename Strategy>
|
||||
struct default_strategy
|
||||
<
|
||||
segment_tag, Point, PointOfSegment,
|
||||
spherical_polar_tag, spherical_polar_tag,
|
||||
Strategy
|
||||
>
|
||||
{
|
||||
typedef cross_track
|
||||
<
|
||||
void,
|
||||
typename boost::mpl::if_
|
||||
<
|
||||
boost::is_void<Strategy>,
|
||||
typename default_strategy
|
||||
<
|
||||
point_tag, Point, PointOfSegment,
|
||||
spherical_polar_tag, spherical_polar_tag
|
||||
>::type,
|
||||
Strategy
|
||||
>::type
|
||||
> type;
|
||||
};
|
||||
*/
|
||||
|
||||
template <typename Point, typename PointOfSegment, typename Strategy>
|
||||
struct default_strategy
|
||||
<
|
||||
point_tag, segment_tag, Point, PointOfSegment,
|
||||
spherical_equatorial_tag, spherical_equatorial_tag,
|
||||
Strategy
|
||||
>
|
||||
{
|
||||
typedef cross_track
|
||||
<
|
||||
void,
|
||||
typename boost::mpl::if_
|
||||
<
|
||||
boost::is_void<Strategy>,
|
||||
typename default_strategy
|
||||
<
|
||||
point_tag, point_tag, Point, PointOfSegment,
|
||||
spherical_equatorial_tag, spherical_equatorial_tag
|
||||
>::type,
|
||||
Strategy
|
||||
>::type
|
||||
> type;
|
||||
};
|
||||
|
||||
|
||||
template <typename PointOfSegment, typename Point, typename Strategy>
|
||||
struct default_strategy
|
||||
<
|
||||
segment_tag, point_tag, PointOfSegment, Point,
|
||||
spherical_equatorial_tag, spherical_equatorial_tag,
|
||||
Strategy
|
||||
>
|
||||
{
|
||||
typedef typename default_strategy
|
||||
<
|
||||
point_tag, segment_tag, Point, PointOfSegment,
|
||||
spherical_equatorial_tag, spherical_equatorial_tag,
|
||||
Strategy
|
||||
>::type type;
|
||||
};
|
||||
|
||||
|
||||
} // namespace services
|
||||
#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
|
||||
|
||||
}} // namespace strategy::distance
|
||||
|
||||
}} // namespace boost::geometry
|
||||
|
||||
#endif // BOOST_GEOMETRY_STRATEGIES_SPHERICAL_DISTANCE_CROSS_TRACK_HPP
|
||||
+364
@@ -0,0 +1,364 @@
|
||||
// Boost.Geometry (aka GGL, Generic Geometry Library)
|
||||
|
||||
// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
|
||||
// Copyright (c) 2008-2015 Barend Gehrels, Amsterdam, the Netherlands.
|
||||
// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
|
||||
|
||||
// This file was modified by Oracle on 2014, 2015.
|
||||
// Modifications copyright (c) 2014-2015, Oracle and/or its affiliates.
|
||||
|
||||
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
|
||||
// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
|
||||
|
||||
// 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_SPHERICAL_DISTANCE_CROSS_TRACK_POINT_BOX_HPP
|
||||
#define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_DISTANCE_CROSS_TRACK_POINT_BOX_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/concept_check.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/type_traits/is_void.hpp>
|
||||
|
||||
#include <boost/geometry/core/access.hpp>
|
||||
#include <boost/geometry/core/assert.hpp>
|
||||
#include <boost/geometry/core/point_type.hpp>
|
||||
#include <boost/geometry/core/radian_access.hpp>
|
||||
#include <boost/geometry/core/tags.hpp>
|
||||
|
||||
#include <boost/geometry/strategies/distance.hpp>
|
||||
#include <boost/geometry/strategies/concepts/distance_concept.hpp>
|
||||
#include <boost/geometry/strategies/spherical/distance_cross_track.hpp>
|
||||
|
||||
#include <boost/geometry/util/math.hpp>
|
||||
#include <boost/geometry/algorithms/detail/assign_box_corners.hpp>
|
||||
|
||||
|
||||
namespace boost { namespace geometry
|
||||
{
|
||||
|
||||
namespace strategy { namespace distance
|
||||
{
|
||||
|
||||
|
||||
/*!
|
||||
\brief Strategy functor for distance point to box calculation
|
||||
\ingroup strategies
|
||||
\details Class which calculates the distance of a point to a box, for
|
||||
points and boxes on a sphere or globe
|
||||
\tparam CalculationType \tparam_calculation
|
||||
\tparam Strategy underlying point-segment distance strategy, defaults
|
||||
to cross track
|
||||
|
||||
\qbk{
|
||||
[heading See also]
|
||||
[link geometry.reference.algorithms.distance.distance_3_with_strategy distance (with strategy)]
|
||||
}
|
||||
|
||||
*/
|
||||
template
|
||||
<
|
||||
typename CalculationType = void,
|
||||
typename Strategy = cross_track<CalculationType>
|
||||
>
|
||||
class cross_track_point_box
|
||||
{
|
||||
public:
|
||||
template <typename Point, typename Box>
|
||||
struct return_type
|
||||
: services::return_type<Strategy, Point, typename point_type<Box>::type>
|
||||
{};
|
||||
|
||||
typedef typename Strategy::radius_type radius_type;
|
||||
|
||||
inline cross_track_point_box()
|
||||
{}
|
||||
|
||||
explicit inline cross_track_point_box(typename Strategy::radius_type const& r)
|
||||
: m_ps_strategy(r)
|
||||
{}
|
||||
|
||||
inline cross_track_point_box(Strategy const& s)
|
||||
: m_ps_strategy(s)
|
||||
{}
|
||||
|
||||
|
||||
// It might be useful in the future
|
||||
// to overload constructor with strategy info.
|
||||
// crosstrack(...) {}
|
||||
|
||||
template <typename Point, typename Box>
|
||||
inline typename return_type<Point, Box>::type
|
||||
apply(Point const& point, Box const& box) const
|
||||
{
|
||||
#if !defined(BOOST_MSVC)
|
||||
BOOST_CONCEPT_ASSERT
|
||||
(
|
||||
(concepts::PointSegmentDistanceStrategy
|
||||
<
|
||||
Strategy, Point, typename point_type<Box>::type
|
||||
>)
|
||||
);
|
||||
#endif
|
||||
|
||||
// this method assumes that the coordinates of the point and
|
||||
// the box are normalized
|
||||
|
||||
typedef typename return_type<Point, Box>::type return_type;
|
||||
typedef typename point_type<Box>::type box_point_type;
|
||||
|
||||
// TODO: This strategy as well as other cross-track strategies
|
||||
// and therefore e.g. spherical within(Point, Box) may not work
|
||||
// properly for a Box degenerated to a Segment or Point
|
||||
|
||||
box_point_type bottom_left, bottom_right, top_left, top_right;
|
||||
geometry::detail::assign_box_corners(box,
|
||||
bottom_left, bottom_right,
|
||||
top_left, top_right);
|
||||
|
||||
return_type const plon = geometry::get_as_radian<0>(point);
|
||||
return_type const plat = geometry::get_as_radian<1>(point);
|
||||
|
||||
return_type const lon_min = geometry::get_as_radian<0>(bottom_left);
|
||||
return_type const lat_min = geometry::get_as_radian<1>(bottom_left);
|
||||
return_type const lon_max = geometry::get_as_radian<0>(top_right);
|
||||
return_type const lat_max = geometry::get_as_radian<1>(top_right);
|
||||
|
||||
return_type const pi = math::pi<return_type>();
|
||||
return_type const two_pi = math::two_pi<return_type>();
|
||||
|
||||
// First check if the point is within the band defined by the
|
||||
// minimum and maximum longitude of the box; if yes, determine
|
||||
// if the point is above, below or inside the box and compute
|
||||
// the distance (easy in this case)
|
||||
//
|
||||
// Notice that the point may not be inside the longitude range
|
||||
// of the box, but the shifted point may be inside the
|
||||
// longitude range of the box; in this case the point is still
|
||||
// considered as inside the longitude range band of the box
|
||||
if ((plon >= lon_min && plon <= lon_max) || plon + two_pi <= lon_max)
|
||||
{
|
||||
if (plat > lat_max)
|
||||
{
|
||||
return services::result_from_distance
|
||||
<
|
||||
Strategy, Point, box_point_type
|
||||
>::apply(m_ps_strategy, radius() * (plat - lat_max));
|
||||
}
|
||||
else if (plat < lat_min)
|
||||
{
|
||||
return services::result_from_distance
|
||||
<
|
||||
Strategy, Point, box_point_type
|
||||
>::apply(m_ps_strategy, radius() * (lat_min - plat));
|
||||
}
|
||||
else
|
||||
{
|
||||
BOOST_GEOMETRY_ASSERT(plat >= lat_min && plat <= lat_max);
|
||||
return return_type(0);
|
||||
}
|
||||
}
|
||||
|
||||
// Otherwise determine which among the two medirian segments of the
|
||||
// box the point is closest to, and compute the distance of
|
||||
// the point to this closest segment
|
||||
|
||||
// Below lon_midway is the longitude of the meridian that:
|
||||
// (1) is midway between the meridians of the left and right
|
||||
// meridians of the box, and
|
||||
// (2) does not intersect the box
|
||||
return_type const two = 2.0;
|
||||
bool use_left_segment;
|
||||
if (lon_max > pi)
|
||||
{
|
||||
// the box crosses the antimeridian
|
||||
|
||||
// midway longitude = lon_min - (lon_min + (lon_max - 2 * pi)) / 2;
|
||||
return_type const lon_midway = (lon_min - lon_max) / two + pi;
|
||||
BOOST_GEOMETRY_ASSERT(lon_midway >= -pi && lon_midway <= pi);
|
||||
|
||||
use_left_segment = plon > lon_midway;
|
||||
}
|
||||
else
|
||||
{
|
||||
// the box does not cross the antimeridian
|
||||
|
||||
return_type const lon_sum = lon_min + lon_max;
|
||||
if (math::equals(lon_sum, return_type(0)))
|
||||
{
|
||||
// special case: the box is symmetric with respect to
|
||||
// the prime meridian; the midway meridian is the antimeridian
|
||||
|
||||
use_left_segment = plon < lon_min;
|
||||
}
|
||||
else
|
||||
{
|
||||
// midway long. = lon_min - (2 * pi - (lon_max - lon_min)) / 2;
|
||||
return_type lon_midway = (lon_min + lon_max) / two - pi;
|
||||
|
||||
// normalize the midway longitude
|
||||
if (lon_midway > pi)
|
||||
{
|
||||
lon_midway -= two_pi;
|
||||
}
|
||||
else if (lon_midway < -pi)
|
||||
{
|
||||
lon_midway += two_pi;
|
||||
}
|
||||
BOOST_GEOMETRY_ASSERT(lon_midway >= -pi && lon_midway <= pi);
|
||||
|
||||
// if lon_sum is positive the midway meridian is left
|
||||
// of the box, or right of the box otherwise
|
||||
use_left_segment = lon_sum > 0
|
||||
? (plon < lon_min && plon >= lon_midway)
|
||||
: (plon <= lon_max || plon > lon_midway);
|
||||
}
|
||||
}
|
||||
|
||||
return use_left_segment
|
||||
? m_ps_strategy.apply(point, bottom_left, top_left)
|
||||
: m_ps_strategy.apply(point, bottom_right, top_right);
|
||||
}
|
||||
|
||||
inline typename Strategy::radius_type radius() const
|
||||
{
|
||||
return m_ps_strategy.radius();
|
||||
}
|
||||
|
||||
private:
|
||||
Strategy m_ps_strategy;
|
||||
};
|
||||
|
||||
|
||||
|
||||
#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
|
||||
namespace services
|
||||
{
|
||||
|
||||
template <typename CalculationType, typename Strategy>
|
||||
struct tag<cross_track_point_box<CalculationType, Strategy> >
|
||||
{
|
||||
typedef strategy_tag_distance_point_box type;
|
||||
};
|
||||
|
||||
|
||||
template <typename CalculationType, typename Strategy, typename P, typename Box>
|
||||
struct return_type<cross_track_point_box<CalculationType, Strategy>, P, Box>
|
||||
: cross_track_point_box
|
||||
<
|
||||
CalculationType, Strategy
|
||||
>::template return_type<P, Box>
|
||||
{};
|
||||
|
||||
|
||||
template <typename CalculationType, typename Strategy>
|
||||
struct comparable_type<cross_track_point_box<CalculationType, Strategy> >
|
||||
{
|
||||
typedef cross_track_point_box
|
||||
<
|
||||
CalculationType, typename comparable_type<Strategy>::type
|
||||
> type;
|
||||
};
|
||||
|
||||
|
||||
template <typename CalculationType, typename Strategy>
|
||||
struct get_comparable<cross_track_point_box<CalculationType, Strategy> >
|
||||
{
|
||||
typedef cross_track_point_box<CalculationType, Strategy> this_strategy;
|
||||
typedef typename comparable_type<this_strategy>::type comparable_type;
|
||||
|
||||
public:
|
||||
static inline comparable_type apply(this_strategy const& strategy)
|
||||
{
|
||||
return comparable_type(strategy.radius());
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <typename CalculationType, typename Strategy, typename P, typename Box>
|
||||
struct result_from_distance
|
||||
<
|
||||
cross_track_point_box<CalculationType, Strategy>, P, Box
|
||||
>
|
||||
{
|
||||
private:
|
||||
typedef cross_track_point_box<CalculationType, Strategy> this_strategy;
|
||||
|
||||
typedef typename this_strategy::template return_type
|
||||
<
|
||||
P, Box
|
||||
>::type return_type;
|
||||
|
||||
public:
|
||||
template <typename T>
|
||||
static inline return_type apply(this_strategy const& strategy,
|
||||
T const& distance)
|
||||
{
|
||||
Strategy s(strategy.radius());
|
||||
|
||||
return result_from_distance
|
||||
<
|
||||
Strategy, P, typename point_type<Box>::type
|
||||
>::apply(s, distance);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// define cross_track_point_box<default_point_segment_strategy> as
|
||||
// default point-box strategy for the spherical equatorial coordinate system
|
||||
template <typename Point, typename Box, typename Strategy>
|
||||
struct default_strategy
|
||||
<
|
||||
point_tag, box_tag, Point, Box,
|
||||
spherical_equatorial_tag, spherical_equatorial_tag,
|
||||
Strategy
|
||||
>
|
||||
{
|
||||
typedef cross_track_point_box
|
||||
<
|
||||
void,
|
||||
typename boost::mpl::if_
|
||||
<
|
||||
boost::is_void<Strategy>,
|
||||
typename default_strategy
|
||||
<
|
||||
point_tag, segment_tag,
|
||||
Point, typename point_type<Box>::type,
|
||||
spherical_equatorial_tag, spherical_equatorial_tag
|
||||
>::type,
|
||||
Strategy
|
||||
>::type
|
||||
> type;
|
||||
};
|
||||
|
||||
|
||||
template <typename Box, typename Point, typename Strategy>
|
||||
struct default_strategy
|
||||
<
|
||||
box_tag, point_tag, Box, Point,
|
||||
spherical_equatorial_tag, spherical_equatorial_tag,
|
||||
Strategy
|
||||
>
|
||||
{
|
||||
typedef typename default_strategy
|
||||
<
|
||||
point_tag, box_tag, Point, Box,
|
||||
spherical_equatorial_tag, spherical_equatorial_tag,
|
||||
Strategy
|
||||
>::type type;
|
||||
};
|
||||
|
||||
|
||||
} // namespace services
|
||||
#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
|
||||
|
||||
|
||||
}} // namespace strategy::distance
|
||||
|
||||
|
||||
}} // namespace boost::geometry
|
||||
|
||||
|
||||
#endif // BOOST_GEOMETRY_STRATEGIES_SPHERICAL_DISTANCE_CROSS_TRACK_POINT_BOX_HPP
|
||||
+305
@@ -0,0 +1,305 @@
|
||||
// Boost.Geometry (aka GGL, Generic Geometry Library)
|
||||
|
||||
// Copyright (c) 2007-2012 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_SPHERICAL_DISTANCE_HAVERSINE_HPP
|
||||
#define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_DISTANCE_HAVERSINE_HPP
|
||||
|
||||
|
||||
#include <boost/geometry/core/cs.hpp>
|
||||
#include <boost/geometry/core/access.hpp>
|
||||
#include <boost/geometry/core/radian_access.hpp>
|
||||
|
||||
#include <boost/geometry/util/math.hpp>
|
||||
#include <boost/geometry/util/select_calculation_type.hpp>
|
||||
#include <boost/geometry/util/promote_floating_point.hpp>
|
||||
|
||||
#include <boost/geometry/strategies/distance.hpp>
|
||||
|
||||
|
||||
|
||||
namespace boost { namespace geometry
|
||||
{
|
||||
|
||||
|
||||
namespace strategy { namespace distance
|
||||
{
|
||||
|
||||
|
||||
namespace comparable
|
||||
{
|
||||
|
||||
// Comparable haversine.
|
||||
// To compare distances, we can avoid:
|
||||
// - multiplication with radius and 2.0
|
||||
// - applying sqrt
|
||||
// - applying asin (which is strictly (monotone) increasing)
|
||||
template
|
||||
<
|
||||
typename RadiusType,
|
||||
typename CalculationType = void
|
||||
>
|
||||
class haversine
|
||||
{
|
||||
public :
|
||||
template <typename Point1, typename Point2>
|
||||
struct calculation_type
|
||||
: promote_floating_point
|
||||
<
|
||||
typename select_calculation_type
|
||||
<
|
||||
Point1,
|
||||
Point2,
|
||||
CalculationType
|
||||
>::type
|
||||
>
|
||||
{};
|
||||
|
||||
typedef RadiusType radius_type;
|
||||
|
||||
explicit inline haversine(RadiusType const& r = 1.0)
|
||||
: m_radius(r)
|
||||
{}
|
||||
|
||||
template <typename Point1, typename Point2>
|
||||
static inline typename calculation_type<Point1, Point2>::type
|
||||
apply(Point1 const& p1, Point2 const& p2)
|
||||
{
|
||||
return calculate<typename calculation_type<Point1, Point2>::type>(
|
||||
get_as_radian<0>(p1), get_as_radian<1>(p1),
|
||||
get_as_radian<0>(p2), get_as_radian<1>(p2)
|
||||
);
|
||||
}
|
||||
|
||||
inline RadiusType radius() const
|
||||
{
|
||||
return m_radius;
|
||||
}
|
||||
|
||||
|
||||
private :
|
||||
template <typename R, typename T1, typename T2>
|
||||
static inline R calculate(T1 const& lon1, T1 const& lat1,
|
||||
T2 const& lon2, T2 const& lat2)
|
||||
{
|
||||
return math::hav(lat2 - lat1)
|
||||
+ cos(lat1) * cos(lat2) * math::hav(lon2 - lon1);
|
||||
}
|
||||
|
||||
RadiusType m_radius;
|
||||
};
|
||||
|
||||
|
||||
|
||||
} // namespace comparable
|
||||
|
||||
/*!
|
||||
\brief Distance calculation for spherical coordinates
|
||||
on a perfect sphere using haversine
|
||||
\ingroup strategies
|
||||
\tparam RadiusType \tparam_radius
|
||||
\tparam CalculationType \tparam_calculation
|
||||
\author Adapted from: http://williams.best.vwh.net/avform.htm
|
||||
\see http://en.wikipedia.org/wiki/Great-circle_distance
|
||||
\note (from Wiki:) The great circle distance d between two
|
||||
points with coordinates {lat1,lon1} and {lat2,lon2} is given by:
|
||||
d=acos(sin(lat1)*sin(lat2)+cos(lat1)*cos(lat2)*cos(lon1-lon2))
|
||||
A mathematically equivalent formula, which is less subject
|
||||
to rounding error for short distances is:
|
||||
d=2*asin(sqrt((sin((lat1-lat2) / 2))^2
|
||||
+ cos(lat1)*cos(lat2)*(sin((lon1-lon2) / 2))^2))
|
||||
|
||||
|
||||
\qbk{
|
||||
[heading See also]
|
||||
[link geometry.reference.algorithms.distance.distance_3_with_strategy distance (with strategy)]
|
||||
}
|
||||
|
||||
*/
|
||||
template
|
||||
<
|
||||
typename RadiusType,
|
||||
typename CalculationType = void
|
||||
>
|
||||
class haversine
|
||||
{
|
||||
typedef comparable::haversine<RadiusType, CalculationType> comparable_type;
|
||||
|
||||
public :
|
||||
template <typename Point1, typename Point2>
|
||||
struct calculation_type
|
||||
: services::return_type<comparable_type, Point1, Point2>
|
||||
{};
|
||||
|
||||
typedef RadiusType radius_type;
|
||||
|
||||
/*!
|
||||
\brief Constructor
|
||||
\param radius radius of the sphere, defaults to 1.0 for the unit sphere
|
||||
*/
|
||||
inline haversine(RadiusType const& radius = 1.0)
|
||||
: m_radius(radius)
|
||||
{}
|
||||
|
||||
/*!
|
||||
\brief applies the distance calculation
|
||||
\return the calculated distance (including multiplying with radius)
|
||||
\param p1 first point
|
||||
\param p2 second point
|
||||
*/
|
||||
template <typename Point1, typename Point2>
|
||||
inline typename calculation_type<Point1, Point2>::type
|
||||
apply(Point1 const& p1, Point2 const& p2) const
|
||||
{
|
||||
typedef typename calculation_type<Point1, Point2>::type calculation_type;
|
||||
calculation_type const a = comparable_type::apply(p1, p2);
|
||||
calculation_type const c = calculation_type(2.0) * asin(math::sqrt(a));
|
||||
return calculation_type(m_radius) * c;
|
||||
}
|
||||
|
||||
/*!
|
||||
\brief access to radius value
|
||||
\return the radius
|
||||
*/
|
||||
inline RadiusType radius() const
|
||||
{
|
||||
return m_radius;
|
||||
}
|
||||
|
||||
private :
|
||||
RadiusType m_radius;
|
||||
};
|
||||
|
||||
|
||||
#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
|
||||
namespace services
|
||||
{
|
||||
|
||||
template <typename RadiusType, typename CalculationType>
|
||||
struct tag<haversine<RadiusType, CalculationType> >
|
||||
{
|
||||
typedef strategy_tag_distance_point_point type;
|
||||
};
|
||||
|
||||
|
||||
template <typename RadiusType, typename CalculationType, typename P1, typename P2>
|
||||
struct return_type<haversine<RadiusType, CalculationType>, P1, P2>
|
||||
: haversine<RadiusType, CalculationType>::template calculation_type<P1, P2>
|
||||
{};
|
||||
|
||||
|
||||
template <typename RadiusType, typename CalculationType>
|
||||
struct comparable_type<haversine<RadiusType, CalculationType> >
|
||||
{
|
||||
typedef comparable::haversine<RadiusType, CalculationType> type;
|
||||
};
|
||||
|
||||
|
||||
template <typename RadiusType, typename CalculationType>
|
||||
struct get_comparable<haversine<RadiusType, CalculationType> >
|
||||
{
|
||||
private :
|
||||
typedef haversine<RadiusType, CalculationType> this_type;
|
||||
typedef comparable::haversine<RadiusType, CalculationType> comparable_type;
|
||||
public :
|
||||
static inline comparable_type apply(this_type const& input)
|
||||
{
|
||||
return comparable_type(input.radius());
|
||||
}
|
||||
};
|
||||
|
||||
template <typename RadiusType, typename CalculationType, typename P1, typename P2>
|
||||
struct result_from_distance<haversine<RadiusType, CalculationType>, P1, P2>
|
||||
{
|
||||
private :
|
||||
typedef haversine<RadiusType, CalculationType> this_type;
|
||||
typedef typename return_type<this_type, P1, P2>::type return_type;
|
||||
public :
|
||||
template <typename T>
|
||||
static inline return_type apply(this_type const& , T const& value)
|
||||
{
|
||||
return return_type(value);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// Specializations for comparable::haversine
|
||||
template <typename RadiusType, typename CalculationType>
|
||||
struct tag<comparable::haversine<RadiusType, CalculationType> >
|
||||
{
|
||||
typedef strategy_tag_distance_point_point type;
|
||||
};
|
||||
|
||||
|
||||
template <typename RadiusType, typename CalculationType, typename P1, typename P2>
|
||||
struct return_type<comparable::haversine<RadiusType, CalculationType>, P1, P2>
|
||||
: comparable::haversine<RadiusType, CalculationType>::template calculation_type<P1, P2>
|
||||
{};
|
||||
|
||||
|
||||
template <typename RadiusType, typename CalculationType>
|
||||
struct comparable_type<comparable::haversine<RadiusType, CalculationType> >
|
||||
{
|
||||
typedef comparable::haversine<RadiusType, CalculationType> type;
|
||||
};
|
||||
|
||||
|
||||
template <typename RadiusType, typename CalculationType>
|
||||
struct get_comparable<comparable::haversine<RadiusType, CalculationType> >
|
||||
{
|
||||
private :
|
||||
typedef comparable::haversine<RadiusType, CalculationType> this_type;
|
||||
public :
|
||||
static inline this_type apply(this_type const& input)
|
||||
{
|
||||
return input;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <typename RadiusType, typename CalculationType, typename P1, typename P2>
|
||||
struct result_from_distance<comparable::haversine<RadiusType, CalculationType>, P1, P2>
|
||||
{
|
||||
private :
|
||||
typedef comparable::haversine<RadiusType, CalculationType> strategy_type;
|
||||
typedef typename return_type<strategy_type, P1, P2>::type return_type;
|
||||
public :
|
||||
template <typename T>
|
||||
static inline return_type apply(strategy_type const& strategy, T const& distance)
|
||||
{
|
||||
return_type const s = sin((distance / strategy.radius()) / return_type(2));
|
||||
return s * s;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// Register it as the default for point-types
|
||||
// in a spherical equatorial coordinate system
|
||||
template <typename Point1, typename Point2>
|
||||
struct default_strategy
|
||||
<
|
||||
point_tag, point_tag, Point1, Point2,
|
||||
spherical_equatorial_tag, spherical_equatorial_tag
|
||||
>
|
||||
{
|
||||
typedef strategy::distance::haversine<typename select_coordinate_type<Point1, Point2>::type> type;
|
||||
};
|
||||
|
||||
// Note: spherical polar coordinate system requires "get_as_radian_equatorial"
|
||||
|
||||
|
||||
} // namespace services
|
||||
#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
|
||||
|
||||
|
||||
}} // namespace strategy::distance
|
||||
|
||||
|
||||
}} // namespace boost::geometry
|
||||
|
||||
|
||||
#endif // BOOST_GEOMETRY_STRATEGIES_SPHERICAL_DISTANCE_HAVERSINE_HPP
|
||||
+86
@@ -0,0 +1,86 @@
|
||||
// Boost.Geometry (aka GGL, Generic Geometry Library)
|
||||
|
||||
// Copyright (c) 2017 Oracle and/or its affiliates.
|
||||
// Contributed and/or modified by Vissarion Fisikopoulos, on behalf of Oracle
|
||||
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
|
||||
|
||||
// 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_SPHERICAL_ENVELOPE_SEGMENT_HPP
|
||||
#define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_ENVELOPE_SEGMENT_HPP
|
||||
|
||||
#include <boost/geometry/algorithms/detail/envelope/segment.hpp>
|
||||
#include <boost/geometry/algorithms/detail/normalize.hpp>
|
||||
#include <boost/geometry/strategies/envelope.hpp>
|
||||
#include <boost/geometry/strategies/spherical/azimuth.hpp>
|
||||
|
||||
namespace boost { namespace geometry
|
||||
{
|
||||
|
||||
namespace strategy { namespace envelope
|
||||
{
|
||||
|
||||
template
|
||||
<
|
||||
typename CalculationType = void
|
||||
>
|
||||
class spherical_segment
|
||||
{
|
||||
public :
|
||||
|
||||
inline spherical_segment()
|
||||
{}
|
||||
|
||||
template <typename Point1, typename Point2, typename Box>
|
||||
inline void
|
||||
apply(Point1 const& point1, Point2 const& point2, Box& box) const
|
||||
{
|
||||
Point1 p1_normalized = detail::return_normalized<Point1>(point1);
|
||||
Point2 p2_normalized = detail::return_normalized<Point2>(point2);
|
||||
|
||||
geometry::strategy::azimuth::spherical<CalculationType> azimuth_spherical;
|
||||
|
||||
typedef typename coordinate_system<Point1>::type::units units_type;
|
||||
|
||||
geometry::detail::envelope::envelope_segment_impl<spherical_equatorial_tag>
|
||||
::template apply<units_type>(geometry::get<0>(p1_normalized),
|
||||
geometry::get<1>(p1_normalized),
|
||||
geometry::get<0>(p2_normalized),
|
||||
geometry::get<1>(p2_normalized),
|
||||
box,
|
||||
azimuth_spherical);
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
|
||||
|
||||
namespace services
|
||||
{
|
||||
|
||||
template <typename CalculationType>
|
||||
struct default_strategy<spherical_equatorial_tag, CalculationType>
|
||||
{
|
||||
typedef strategy::envelope::spherical_segment<CalculationType> type;
|
||||
};
|
||||
|
||||
|
||||
template <typename CalculationType>
|
||||
struct default_strategy<spherical_polar_tag, CalculationType>
|
||||
{
|
||||
typedef strategy::envelope::spherical_segment<CalculationType> type;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
|
||||
|
||||
|
||||
}} // namespace strategy::envelope
|
||||
|
||||
}} //namepsace boost::geometry
|
||||
|
||||
#endif // BOOST_GEOMETRY_STRATEGIES_SPHERICAL_ENVELOPE_SEGMENT_HPP
|
||||
|
||||
+980
@@ -0,0 +1,980 @@
|
||||
// Boost.Geometry
|
||||
|
||||
// Copyright (c) 2016-2017, Oracle and/or its affiliates.
|
||||
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
|
||||
|
||||
// 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_SPHERICAL_INTERSECTION_HPP
|
||||
#define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_INTERSECTION_HPP
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
#include <boost/geometry/core/cs.hpp>
|
||||
#include <boost/geometry/core/access.hpp>
|
||||
#include <boost/geometry/core/radian_access.hpp>
|
||||
#include <boost/geometry/core/tags.hpp>
|
||||
|
||||
#include <boost/geometry/algorithms/detail/assign_values.hpp>
|
||||
#include <boost/geometry/algorithms/detail/assign_indexed_point.hpp>
|
||||
#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
|
||||
#include <boost/geometry/algorithms/detail/recalculate.hpp>
|
||||
|
||||
#include <boost/geometry/arithmetic/arithmetic.hpp>
|
||||
#include <boost/geometry/arithmetic/cross_product.hpp>
|
||||
#include <boost/geometry/arithmetic/dot_product.hpp>
|
||||
#include <boost/geometry/arithmetic/normalize.hpp>
|
||||
#include <boost/geometry/formulas/spherical.hpp>
|
||||
|
||||
#include <boost/geometry/geometries/concepts/point_concept.hpp>
|
||||
#include <boost/geometry/geometries/concepts/segment_concept.hpp>
|
||||
|
||||
#include <boost/geometry/policies/robustness/segment_ratio.hpp>
|
||||
|
||||
#include <boost/geometry/strategies/agnostic/point_in_poly_winding.hpp>
|
||||
#include <boost/geometry/strategies/covered_by.hpp>
|
||||
#include <boost/geometry/strategies/intersection.hpp>
|
||||
#include <boost/geometry/strategies/intersection_result.hpp>
|
||||
#include <boost/geometry/strategies/side.hpp>
|
||||
#include <boost/geometry/strategies/side_info.hpp>
|
||||
#include <boost/geometry/strategies/spherical/area.hpp>
|
||||
#include <boost/geometry/strategies/spherical/distance_haversine.hpp>
|
||||
#include <boost/geometry/strategies/spherical/ssf.hpp>
|
||||
#include <boost/geometry/strategies/within.hpp>
|
||||
|
||||
#include <boost/geometry/util/math.hpp>
|
||||
#include <boost/geometry/util/select_calculation_type.hpp>
|
||||
|
||||
|
||||
namespace boost { namespace geometry
|
||||
{
|
||||
|
||||
namespace strategy { namespace intersection
|
||||
{
|
||||
|
||||
// NOTE:
|
||||
// The coordinates of crossing IP may be calculated with small precision in some cases.
|
||||
// For double, near the equator noticed error ~1e-9 so far greater than
|
||||
// machine epsilon which is ~1e-16. This error is ~0.04m.
|
||||
// E.g. consider two cases, one near the origin and the second one rotated by 90 deg around Z or SN axis.
|
||||
// After the conversion from spherical degrees to cartesian 3d the following coordinates
|
||||
// are calculated:
|
||||
// for sph (-1 -1, 1 1) deg cart3d ys are -0.017449748351250485 and 0.017449748351250485
|
||||
// for sph (89 -1, 91 1) deg cart3d xs are 0.017449748351250571 and -0.017449748351250450
|
||||
// During the conversion degrees must first be converted to radians and then radians
|
||||
// are passed into trigonometric functions. The error may have several causes:
|
||||
// 1. Radians cannot represent exactly the same angles as degrees.
|
||||
// 2. Different longitudes are passed into sin() for x, corresponding to cos() for y,
|
||||
// and for different angle the error of the result may be different.
|
||||
// 3. These non-corresponding cartesian coordinates are used in calculation,
|
||||
// e.g. multiplied several times in cross and dot products.
|
||||
// If it was a problem this strategy could e.g. "normalize" longitudes before the conversion using the source units
|
||||
// by rotating the globe around Z axis, so moving longitudes always the same way towards the origin,
|
||||
// assuming this could help which is not clear.
|
||||
// For now, intersection points near the endpoints are checked explicitly if needed (if the IP is near the endpoint)
|
||||
// to generate precise result for them. Only the crossing (i) case may suffer from lower precision.
|
||||
|
||||
template
|
||||
<
|
||||
typename CalcPolicy,
|
||||
typename CalculationType = void
|
||||
>
|
||||
struct ecef_segments
|
||||
{
|
||||
typedef side::spherical_side_formula<CalculationType> side_strategy_type;
|
||||
|
||||
static inline side_strategy_type get_side_strategy()
|
||||
{
|
||||
return side_strategy_type();
|
||||
}
|
||||
|
||||
template <typename Geometry1, typename Geometry2>
|
||||
struct point_in_geometry_strategy
|
||||
{
|
||||
typedef strategy::within::winding
|
||||
<
|
||||
typename point_type<Geometry1>::type,
|
||||
typename point_type<Geometry2>::type,
|
||||
side_strategy_type,
|
||||
CalculationType
|
||||
> type;
|
||||
};
|
||||
|
||||
template <typename Geometry1, typename Geometry2>
|
||||
static inline typename point_in_geometry_strategy<Geometry1, Geometry2>::type
|
||||
get_point_in_geometry_strategy()
|
||||
{
|
||||
typedef typename point_in_geometry_strategy
|
||||
<
|
||||
Geometry1, Geometry2
|
||||
>::type strategy_type;
|
||||
return strategy_type();
|
||||
}
|
||||
|
||||
template <typename Geometry>
|
||||
struct area_strategy
|
||||
{
|
||||
typedef area::spherical
|
||||
<
|
||||
typename point_type<Geometry>::type,
|
||||
CalculationType
|
||||
> type;
|
||||
};
|
||||
|
||||
template <typename Geometry>
|
||||
static inline typename area_strategy<Geometry>::type get_area_strategy()
|
||||
{
|
||||
typedef typename area_strategy<Geometry>::type strategy_type;
|
||||
return strategy_type();
|
||||
}
|
||||
|
||||
template <typename Geometry>
|
||||
struct distance_strategy
|
||||
{
|
||||
typedef distance::haversine
|
||||
<
|
||||
typename coordinate_type<Geometry>::type,
|
||||
CalculationType
|
||||
> type;
|
||||
};
|
||||
|
||||
template <typename Geometry>
|
||||
static inline typename distance_strategy<Geometry>::type get_distance_strategy()
|
||||
{
|
||||
typedef typename distance_strategy<Geometry>::type strategy_type;
|
||||
return strategy_type();
|
||||
}
|
||||
|
||||
enum intersection_point_flag { ipi_inters = 0, ipi_at_a1, ipi_at_a2, ipi_at_b1, ipi_at_b2 };
|
||||
|
||||
// segment_intersection_info cannot outlive relate_ecef_segments
|
||||
template <typename CoordinateType, typename SegmentRatio, typename Vector3d>
|
||||
struct segment_intersection_info
|
||||
{
|
||||
typedef typename select_most_precise
|
||||
<
|
||||
CoordinateType, double
|
||||
>::type promoted_type;
|
||||
|
||||
segment_intersection_info(CalcPolicy const& calc)
|
||||
: calc_policy(calc)
|
||||
{}
|
||||
|
||||
promoted_type comparable_length_a() const
|
||||
{
|
||||
return robust_ra.denominator();
|
||||
}
|
||||
|
||||
promoted_type comparable_length_b() const
|
||||
{
|
||||
return robust_rb.denominator();
|
||||
}
|
||||
|
||||
template <typename Point, typename Segment1, typename Segment2>
|
||||
void assign_a(Point& point, Segment1 const& a, Segment2 const& b) const
|
||||
{
|
||||
assign(point, a, b);
|
||||
}
|
||||
template <typename Point, typename Segment1, typename Segment2>
|
||||
void assign_b(Point& point, Segment1 const& a, Segment2 const& b) const
|
||||
{
|
||||
assign(point, a, b);
|
||||
}
|
||||
|
||||
template <typename Point, typename Segment1, typename Segment2>
|
||||
void assign(Point& point, Segment1 const& a, Segment2 const& b) const
|
||||
{
|
||||
if (ip_flag == ipi_inters)
|
||||
{
|
||||
// TODO: assign the rest of coordinates
|
||||
point = calc_policy.template from_cart3d<Point>(intersection_point);
|
||||
}
|
||||
else if (ip_flag == ipi_at_a1)
|
||||
{
|
||||
detail::assign_point_from_index<0>(a, point);
|
||||
}
|
||||
else if (ip_flag == ipi_at_a2)
|
||||
{
|
||||
detail::assign_point_from_index<1>(a, point);
|
||||
}
|
||||
else if (ip_flag == ipi_at_b1)
|
||||
{
|
||||
detail::assign_point_from_index<0>(b, point);
|
||||
}
|
||||
else // ip_flag == ipi_at_b2
|
||||
{
|
||||
detail::assign_point_from_index<1>(b, point);
|
||||
}
|
||||
}
|
||||
|
||||
Vector3d intersection_point;
|
||||
SegmentRatio robust_ra;
|
||||
SegmentRatio robust_rb;
|
||||
intersection_point_flag ip_flag;
|
||||
|
||||
CalcPolicy const& calc_policy;
|
||||
};
|
||||
|
||||
// Relate segments a and b
|
||||
template
|
||||
<
|
||||
typename Segment1,
|
||||
typename Segment2,
|
||||
typename Policy,
|
||||
typename RobustPolicy
|
||||
>
|
||||
static inline typename Policy::return_type
|
||||
apply(Segment1 const& a, Segment2 const& b,
|
||||
Policy const& policy, RobustPolicy const& robust_policy)
|
||||
{
|
||||
typedef typename point_type<Segment1>::type point1_t;
|
||||
typedef typename point_type<Segment2>::type point2_t;
|
||||
point1_t a1, a2;
|
||||
point2_t b1, b2;
|
||||
|
||||
// TODO: use indexed_point_view if possible?
|
||||
detail::assign_point_from_index<0>(a, a1);
|
||||
detail::assign_point_from_index<1>(a, a2);
|
||||
detail::assign_point_from_index<0>(b, b1);
|
||||
detail::assign_point_from_index<1>(b, b2);
|
||||
|
||||
return apply(a, b, policy, robust_policy, a1, a2, b1, b2);
|
||||
}
|
||||
|
||||
// Relate segments a and b
|
||||
template
|
||||
<
|
||||
typename Segment1,
|
||||
typename Segment2,
|
||||
typename Policy,
|
||||
typename RobustPolicy,
|
||||
typename Point1,
|
||||
typename Point2
|
||||
>
|
||||
static inline typename Policy::return_type
|
||||
apply(Segment1 const& a, Segment2 const& b,
|
||||
Policy const&, RobustPolicy const&,
|
||||
Point1 const& a1, Point1 const& a2, Point2 const& b1, Point2 const& b2)
|
||||
{
|
||||
// For now create it using default constructor. In the future it could
|
||||
// be stored in strategy. However then apply() wouldn't be static and
|
||||
// all relops and setops would have to take the strategy or model.
|
||||
// Initialize explicitly to prevent compiler errors in case of PoD type
|
||||
CalcPolicy const calc_policy = CalcPolicy();
|
||||
|
||||
BOOST_CONCEPT_ASSERT( (concepts::ConstSegment<Segment1>) );
|
||||
BOOST_CONCEPT_ASSERT( (concepts::ConstSegment<Segment2>) );
|
||||
|
||||
// TODO: check only 2 first coordinates here?
|
||||
using geometry::detail::equals::equals_point_point;
|
||||
bool a_is_point = equals_point_point(a1, a2);
|
||||
bool b_is_point = equals_point_point(b1, b2);
|
||||
|
||||
if(a_is_point && b_is_point)
|
||||
{
|
||||
return equals_point_point(a1, b2)
|
||||
? Policy::degenerate(a, true)
|
||||
: Policy::disjoint()
|
||||
;
|
||||
}
|
||||
|
||||
typedef typename select_calculation_type
|
||||
<Segment1, Segment2, CalculationType>::type calc_t;
|
||||
|
||||
calc_t const c0 = 0;
|
||||
calc_t const c1 = 1;
|
||||
|
||||
typedef model::point<calc_t, 3, cs::cartesian> vec3d_t;
|
||||
|
||||
vec3d_t const a1v = calc_policy.template to_cart3d<vec3d_t>(a1);
|
||||
vec3d_t const a2v = calc_policy.template to_cart3d<vec3d_t>(a2);
|
||||
vec3d_t const b1v = calc_policy.template to_cart3d<vec3d_t>(b1);
|
||||
vec3d_t const b2v = calc_policy.template to_cart3d<vec3d_t>(b2);
|
||||
|
||||
side_info sides;
|
||||
|
||||
typename CalcPolicy::template plane<vec3d_t>
|
||||
plane2 = calc_policy.get_plane(b1v, b2v);
|
||||
|
||||
// not normalized normals, the same as in side strategy
|
||||
sides.set<0>(plane2.side_value(a1v), plane2.side_value(a2v));
|
||||
if (sides.same<0>())
|
||||
{
|
||||
// Both points are at same side of other segment, we can leave
|
||||
return Policy::disjoint();
|
||||
}
|
||||
|
||||
typename CalcPolicy::template plane<vec3d_t>
|
||||
plane1 = calc_policy.get_plane(a1v, a2v);
|
||||
|
||||
// not normalized normals, the same as in side strategy
|
||||
sides.set<1>(plane1.side_value(b1v), plane1.side_value(b2v));
|
||||
if (sides.same<1>())
|
||||
{
|
||||
// Both points are at same side of other segment, we can leave
|
||||
return Policy::disjoint();
|
||||
}
|
||||
|
||||
// NOTE: at this point the segments may still be disjoint
|
||||
|
||||
calc_t len1, len2;
|
||||
|
||||
// point or opposite sides of a sphere/spheroid, assume point
|
||||
if (! detail::vec_normalize(plane1.normal, len1))
|
||||
{
|
||||
a_is_point = true;
|
||||
if (sides.get<0, 0>() == 0 || sides.get<0, 1>() == 0)
|
||||
{
|
||||
sides.set<0>(0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
if (! detail::vec_normalize(plane2.normal, len2))
|
||||
{
|
||||
b_is_point = true;
|
||||
if (sides.get<1, 0>() == 0 || sides.get<1, 1>() == 0)
|
||||
{
|
||||
sides.set<1>(0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
// check both degenerated once more
|
||||
if (a_is_point && b_is_point)
|
||||
{
|
||||
return equals_point_point(a1, b2)
|
||||
? Policy::degenerate(a, true)
|
||||
: Policy::disjoint()
|
||||
;
|
||||
}
|
||||
|
||||
// NOTE: at this point the segments may still be disjoint
|
||||
// NOTE: at this point one of the segments may be degenerated
|
||||
|
||||
bool collinear = sides.collinear();
|
||||
|
||||
if (! collinear)
|
||||
{
|
||||
// NOTE: for some approximations it's possible that both points may lie
|
||||
// on the same geodesic but still some of the sides may be != 0.
|
||||
// This is e.g. true for long segments represented as elliptic arcs
|
||||
// with origin different than the center of the coordinate system.
|
||||
// So make the sides consistent
|
||||
|
||||
// WARNING: the side strategy doesn't have the info about the other
|
||||
// segment so it may return results inconsistent with this intersection
|
||||
// strategy, as it checks both segments for consistency
|
||||
|
||||
if (sides.get<0, 0>() == 0 && sides.get<0, 1>() == 0)
|
||||
{
|
||||
collinear = true;
|
||||
sides.set<1>(0, 0);
|
||||
}
|
||||
else if (sides.get<1, 0>() == 0 && sides.get<1, 1>() == 0)
|
||||
{
|
||||
collinear = true;
|
||||
sides.set<0>(0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
calc_t dot_n1n2 = dot_product(plane1.normal, plane2.normal);
|
||||
|
||||
// NOTE: this is technically not needed since theoretically above sides
|
||||
// are calculated, but just in case check the normals.
|
||||
// Have in mind that SSF side strategy doesn't check this.
|
||||
// collinear if normals are equal or opposite: cos(a) in {-1, 1}
|
||||
if (! collinear && math::equals(math::abs(dot_n1n2), c1))
|
||||
{
|
||||
collinear = true;
|
||||
sides.set<0>(0, 0);
|
||||
sides.set<1>(0, 0);
|
||||
}
|
||||
|
||||
if (collinear)
|
||||
{
|
||||
if (a_is_point)
|
||||
{
|
||||
return collinear_one_degenerated<Policy, calc_t>(a, true, b1, b2, a1, a2, b1v, b2v, plane2, a1v);
|
||||
}
|
||||
else if (b_is_point)
|
||||
{
|
||||
// b2 used to be consistent with (degenerated) checks above (is it needed?)
|
||||
return collinear_one_degenerated<Policy, calc_t>(b, false, a1, a2, b1, b2, a1v, a2v, plane1, b1v);
|
||||
}
|
||||
else
|
||||
{
|
||||
calc_t dist_a1_a2, dist_a1_b1, dist_a1_b2;
|
||||
calc_t dist_b1_b2, dist_b1_a1, dist_b1_a2;
|
||||
// use shorter segment
|
||||
if (len1 <= len2)
|
||||
{
|
||||
calculate_collinear_data(a1, a2, b1, b2, a1v, a2v, plane1, b1v, dist_a1_a2, dist_a1_b1);
|
||||
calculate_collinear_data(a1, a2, b1, b2, a1v, a2v, plane1, b2v, dist_a1_a2, dist_a1_b2);
|
||||
dist_b1_b2 = dist_a1_b2 - dist_a1_b1;
|
||||
dist_b1_a1 = -dist_a1_b1;
|
||||
dist_b1_a2 = dist_a1_a2 - dist_a1_b1;
|
||||
}
|
||||
else
|
||||
{
|
||||
calculate_collinear_data(b1, b2, a1, a2, b1v, b2v, plane2, a1v, dist_b1_b2, dist_b1_a1);
|
||||
calculate_collinear_data(b1, b2, a1, a2, b1v, b2v, plane2, a2v, dist_b1_b2, dist_b1_a2);
|
||||
dist_a1_a2 = dist_b1_a2 - dist_b1_a1;
|
||||
dist_a1_b1 = -dist_b1_a1;
|
||||
dist_a1_b2 = dist_b1_b2 - dist_b1_a1;
|
||||
}
|
||||
|
||||
segment_ratio<calc_t> ra_from(dist_b1_a1, dist_b1_b2);
|
||||
segment_ratio<calc_t> ra_to(dist_b1_a2, dist_b1_b2);
|
||||
segment_ratio<calc_t> rb_from(dist_a1_b1, dist_a1_a2);
|
||||
segment_ratio<calc_t> rb_to(dist_a1_b2, dist_a1_a2);
|
||||
|
||||
// NOTE: this is probably not needed
|
||||
int const a1_wrt_b = position_value(c0, dist_a1_b1, dist_a1_b2);
|
||||
int const a2_wrt_b = position_value(dist_a1_a2, dist_a1_b1, dist_a1_b2);
|
||||
int const b1_wrt_a = position_value(c0, dist_b1_a1, dist_b1_a2);
|
||||
int const b2_wrt_a = position_value(dist_b1_b2, dist_b1_a1, dist_b1_a2);
|
||||
|
||||
if (a1_wrt_b == 1)
|
||||
{
|
||||
ra_from.assign(0, dist_b1_b2);
|
||||
rb_from.assign(0, dist_a1_a2);
|
||||
}
|
||||
else if (a1_wrt_b == 3)
|
||||
{
|
||||
ra_from.assign(dist_b1_b2, dist_b1_b2);
|
||||
rb_to.assign(0, dist_a1_a2);
|
||||
}
|
||||
|
||||
if (a2_wrt_b == 1)
|
||||
{
|
||||
ra_to.assign(0, dist_b1_b2);
|
||||
rb_from.assign(dist_a1_a2, dist_a1_a2);
|
||||
}
|
||||
else if (a2_wrt_b == 3)
|
||||
{
|
||||
ra_to.assign(dist_b1_b2, dist_b1_b2);
|
||||
rb_to.assign(dist_a1_a2, dist_a1_a2);
|
||||
}
|
||||
|
||||
if ((a1_wrt_b < 1 && a2_wrt_b < 1) || (a1_wrt_b > 3 && a2_wrt_b > 3))
|
||||
{
|
||||
return Policy::disjoint();
|
||||
}
|
||||
|
||||
bool const opposite = dot_n1n2 < c0;
|
||||
|
||||
return Policy::segments_collinear(a, b, opposite,
|
||||
a1_wrt_b, a2_wrt_b, b1_wrt_a, b2_wrt_a,
|
||||
ra_from, ra_to, rb_from, rb_to);
|
||||
}
|
||||
}
|
||||
else // crossing
|
||||
{
|
||||
if (a_is_point || b_is_point)
|
||||
{
|
||||
return Policy::disjoint();
|
||||
}
|
||||
|
||||
vec3d_t i1;
|
||||
intersection_point_flag ip_flag;
|
||||
calc_t dist_a1_a2, dist_a1_i1, dist_b1_b2, dist_b1_i1;
|
||||
if (calculate_ip_data(a1, a2, b1, b2, a1v, a2v, b1v, b2v,
|
||||
plane1, plane2, calc_policy, sides,
|
||||
i1, dist_a1_a2, dist_a1_i1, dist_b1_b2, dist_b1_i1, ip_flag))
|
||||
{
|
||||
// intersects
|
||||
segment_intersection_info
|
||||
<
|
||||
calc_t,
|
||||
segment_ratio<calc_t>,
|
||||
vec3d_t
|
||||
> sinfo(calc_policy);
|
||||
|
||||
sinfo.robust_ra.assign(dist_a1_i1, dist_a1_a2);
|
||||
sinfo.robust_rb.assign(dist_b1_i1, dist_b1_b2);
|
||||
sinfo.intersection_point = i1;
|
||||
sinfo.ip_flag = ip_flag;
|
||||
|
||||
return Policy::segments_crosses(sides, sinfo, a, b);
|
||||
}
|
||||
else
|
||||
{
|
||||
return Policy::disjoint();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
template <typename Policy, typename CalcT, typename Segment, typename Point1, typename Point2, typename Vec3d, typename Plane>
|
||||
static inline typename Policy::return_type
|
||||
collinear_one_degenerated(Segment const& segment, bool degenerated_a,
|
||||
Point1 const& a1, Point1 const& a2,
|
||||
Point2 const& b1, Point2 const& b2,
|
||||
Vec3d const& v1, Vec3d const& v2,
|
||||
Plane const& plane,
|
||||
Vec3d const& vother)
|
||||
{
|
||||
CalcT dist_1_2, dist_1_o;
|
||||
return ! calculate_collinear_data(a1, a2, b1, b2, v1, v2, plane, vother, dist_1_2, dist_1_o)
|
||||
? Policy::disjoint()
|
||||
: Policy::one_degenerate(segment, segment_ratio<CalcT>(dist_1_o, dist_1_2), degenerated_a);
|
||||
}
|
||||
|
||||
template <typename Point1, typename Point2, typename Vec3d, typename Plane, typename CalcT>
|
||||
static inline bool calculate_collinear_data(Point1 const& a1, Point1 const& a2, // in
|
||||
Point2 const& b1, Point2 const& b2, // in
|
||||
Vec3d const& a1v, // in
|
||||
Vec3d const& a2v, // in
|
||||
Plane const& plane1, // in
|
||||
Vec3d const& b1v_or_b2v, // in
|
||||
CalcT& dist_a1_a2, CalcT& dist_a1_i1) // out
|
||||
{
|
||||
// calculate dist_a1_a2 and dist_a1_i1
|
||||
calculate_dists(a1v, a2v, plane1, b1v_or_b2v, dist_a1_a2, dist_a1_i1);
|
||||
|
||||
// if i1 is close to a1 and b1 or b2 is equal to a1
|
||||
if (is_endpoint_equal(dist_a1_i1, a1, b1, b2))
|
||||
{
|
||||
dist_a1_i1 = 0;
|
||||
return true;
|
||||
}
|
||||
// or i1 is close to a2 and b1 or b2 is equal to a2
|
||||
else if (is_endpoint_equal(dist_a1_a2 - dist_a1_i1, a2, b1, b2))
|
||||
{
|
||||
dist_a1_i1 = dist_a1_a2;
|
||||
return true;
|
||||
}
|
||||
|
||||
// or i1 is on b
|
||||
return segment_ratio<CalcT>(dist_a1_i1, dist_a1_a2).on_segment();
|
||||
}
|
||||
|
||||
template <typename Point1, typename Point2, typename Vec3d, typename Plane, typename CalcT>
|
||||
static inline bool calculate_ip_data(Point1 const& a1, Point1 const& a2, // in
|
||||
Point2 const& b1, Point2 const& b2, // in
|
||||
Vec3d const& a1v, Vec3d const& a2v, // in
|
||||
Vec3d const& b1v, Vec3d const& b2v, // in
|
||||
Plane const& plane1, // in
|
||||
Plane const& plane2, // in
|
||||
CalcPolicy const& calc_policy, // in
|
||||
side_info const& sides, // in
|
||||
Vec3d & ip, // out
|
||||
CalcT& dist_a1_a2, CalcT& dist_a1_ip, // out
|
||||
CalcT& dist_b1_b2, CalcT& dist_b1_ip, // out
|
||||
intersection_point_flag& ip_flag) // out
|
||||
{
|
||||
Vec3d ip1, ip2;
|
||||
calc_policy.intersection_points(plane1, plane2, ip1, ip2);
|
||||
|
||||
calculate_dists(a1v, a2v, plane1, ip1, dist_a1_a2, dist_a1_ip);
|
||||
ip = ip1;
|
||||
|
||||
// choose the opposite side of the globe if the distance is shorter
|
||||
{
|
||||
CalcT const d = abs_distance(dist_a1_a2, dist_a1_ip);
|
||||
if (d > CalcT(0))
|
||||
{
|
||||
// TODO: this should be ok not only for sphere
|
||||
// but requires more investigation
|
||||
CalcT const dist_a1_i2 = dist_of_i2(dist_a1_ip);
|
||||
CalcT const d2 = abs_distance(dist_a1_a2, dist_a1_i2);
|
||||
if (d2 < d)
|
||||
{
|
||||
dist_a1_ip = dist_a1_i2;
|
||||
ip = ip2;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool is_on_a = false, is_near_a1 = false, is_near_a2 = false;
|
||||
if (! is_potentially_crossing(dist_a1_a2, dist_a1_ip, is_on_a, is_near_a1, is_near_a2))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
calculate_dists(b1v, b2v, plane2, ip, dist_b1_b2, dist_b1_ip);
|
||||
|
||||
bool is_on_b = false, is_near_b1 = false, is_near_b2 = false;
|
||||
if (! is_potentially_crossing(dist_b1_b2, dist_b1_ip, is_on_b, is_near_b1, is_near_b2))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// reassign the IP if some endpoints overlap
|
||||
using geometry::detail::equals::equals_point_point;
|
||||
if (is_near_a1)
|
||||
{
|
||||
if (is_near_b1 && equals_point_point(a1, b1))
|
||||
{
|
||||
dist_a1_ip = 0;
|
||||
dist_b1_ip = 0;
|
||||
//i1 = a1v;
|
||||
ip_flag = ipi_at_a1;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (is_near_b2 && equals_point_point(a1, b2))
|
||||
{
|
||||
dist_a1_ip = 0;
|
||||
dist_b1_ip = dist_b1_b2;
|
||||
//i1 = a1v;
|
||||
ip_flag = ipi_at_a1;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (is_near_a2)
|
||||
{
|
||||
if (is_near_b1 && equals_point_point(a2, b1))
|
||||
{
|
||||
dist_a1_ip = dist_a1_a2;
|
||||
dist_b1_ip = 0;
|
||||
//i1 = a2v;
|
||||
ip_flag = ipi_at_a2;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (is_near_b2 && equals_point_point(a2, b2))
|
||||
{
|
||||
dist_a1_ip = dist_a1_a2;
|
||||
dist_b1_ip = dist_b1_b2;
|
||||
//i1 = a2v;
|
||||
ip_flag = ipi_at_a2;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// at this point we know that the endpoints doesn't overlap
|
||||
// reassign IP and distance if the IP is on a segment and one of
|
||||
// the endpoints of the other segment lies on the former segment
|
||||
if (is_on_a)
|
||||
{
|
||||
if (is_near_b1 && sides.template get<1, 0>() == 0) // b1 wrt a
|
||||
{
|
||||
dist_b1_ip = 0;
|
||||
//i1 = b1v;
|
||||
ip_flag = ipi_at_b1;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (is_near_b2 && sides.template get<1, 1>() == 0) // b2 wrt a
|
||||
{
|
||||
dist_b1_ip = dist_b1_b2;
|
||||
//i1 = b2v;
|
||||
ip_flag = ipi_at_b2;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (is_on_b)
|
||||
{
|
||||
if (is_near_a1 && sides.template get<0, 0>() == 0) // a1 wrt b
|
||||
{
|
||||
dist_a1_ip = 0;
|
||||
//i1 = a1v;
|
||||
ip_flag = ipi_at_a1;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (is_near_a2 && sides.template get<0, 1>() == 0) // a2 wrt b
|
||||
{
|
||||
dist_a1_ip = dist_a1_a2;
|
||||
//i1 = a2v;
|
||||
ip_flag = ipi_at_a2;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
ip_flag = ipi_inters;
|
||||
|
||||
return is_on_a && is_on_b;
|
||||
}
|
||||
|
||||
template <typename Vec3d, typename Plane, typename CalcT>
|
||||
static inline void calculate_dists(Vec3d const& a1v, // in
|
||||
Vec3d const& a2v, // in
|
||||
Plane const& plane1, // in
|
||||
Vec3d const& i1, // in
|
||||
CalcT& dist_a1_a2, // out
|
||||
CalcT& dist_a1_i1) // out
|
||||
{
|
||||
//CalcT const c0 = 0;
|
||||
CalcT const c1 = 1;
|
||||
CalcT const c2 = 2;
|
||||
CalcT const c4 = 4;
|
||||
|
||||
CalcT cos_a1_a2 = plane1.cos_angle_between(a1v, a2v);
|
||||
dist_a1_a2 = -cos_a1_a2 + c1; // [1, -1] -> [0, 2] representing [0, pi]
|
||||
|
||||
bool is_forward = true;
|
||||
CalcT cos_a1_i1 = plane1.cos_angle_between(a1v, i1, is_forward);
|
||||
dist_a1_i1 = -cos_a1_i1 + c1; // [0, 2] representing [0, pi]
|
||||
if (! is_forward) // left or right of a1 on a
|
||||
{
|
||||
dist_a1_i1 = -dist_a1_i1; // [0, 2] -> [0, -2] representing [0, -pi]
|
||||
}
|
||||
if (dist_a1_i1 <= -c2) // <= -pi
|
||||
{
|
||||
dist_a1_i1 += c4; // += 2pi
|
||||
}
|
||||
}
|
||||
|
||||
// the dist of the ip on the other side of the sphere
|
||||
template <typename CalcT>
|
||||
static inline CalcT dist_of_i2(CalcT const& dist_a1_i1)
|
||||
{
|
||||
CalcT const c2 = 2;
|
||||
CalcT const c4 = 4;
|
||||
|
||||
CalcT dist_a1_i2 = dist_a1_i1 - c2; // dist_a1_i2 = dist_a1_i1 - pi;
|
||||
if (dist_a1_i2 <= -c2) // <= -pi
|
||||
{
|
||||
dist_a1_i2 += c4; // += 2pi;
|
||||
}
|
||||
return dist_a1_i2;
|
||||
}
|
||||
|
||||
template <typename CalcT>
|
||||
static inline CalcT abs_distance(CalcT const& dist_a1_a2, CalcT const& dist_a1_i1)
|
||||
{
|
||||
if (dist_a1_i1 < CalcT(0))
|
||||
return -dist_a1_i1;
|
||||
else if (dist_a1_i1 > dist_a1_a2)
|
||||
return dist_a1_i1 - dist_a1_a2;
|
||||
else
|
||||
return CalcT(0);
|
||||
}
|
||||
|
||||
template <typename CalcT>
|
||||
static inline bool is_potentially_crossing(CalcT const& dist_a1_a2, CalcT const& dist_a1_i1, // in
|
||||
bool& is_on_a, bool& is_near_a1, bool& is_near_a2) // out
|
||||
{
|
||||
is_on_a = segment_ratio<CalcT>(dist_a1_i1, dist_a1_a2).on_segment();
|
||||
is_near_a1 = is_near(dist_a1_i1);
|
||||
is_near_a2 = is_near(dist_a1_a2 - dist_a1_i1);
|
||||
return is_on_a || is_near_a1 || is_near_a2;
|
||||
}
|
||||
|
||||
template <typename CalcT, typename P1, typename P2>
|
||||
static inline bool is_endpoint_equal(CalcT const& dist,
|
||||
P1 const& ai, P2 const& b1, P2 const& b2)
|
||||
{
|
||||
using geometry::detail::equals::equals_point_point;
|
||||
return is_near(dist) && (equals_point_point(ai, b1) || equals_point_point(ai, b2));
|
||||
}
|
||||
|
||||
template <typename CalcT>
|
||||
static inline bool is_near(CalcT const& dist)
|
||||
{
|
||||
CalcT const small_number = CalcT(boost::is_same<CalcT, float>::value ? 0.0001 : 0.00000001);
|
||||
return math::abs(dist) <= small_number;
|
||||
}
|
||||
|
||||
template <typename ProjCoord1, typename ProjCoord2>
|
||||
static inline int position_value(ProjCoord1 const& ca1,
|
||||
ProjCoord2 const& cb1,
|
||||
ProjCoord2 const& cb2)
|
||||
{
|
||||
// S1x 0 1 2 3 4
|
||||
// S2 |---------->
|
||||
return math::equals(ca1, cb1) ? 1
|
||||
: math::equals(ca1, cb2) ? 3
|
||||
: cb1 < cb2 ?
|
||||
( ca1 < cb1 ? 0
|
||||
: ca1 > cb2 ? 4
|
||||
: 2 )
|
||||
: ( ca1 > cb1 ? 0
|
||||
: ca1 < cb2 ? 4
|
||||
: 2 );
|
||||
}
|
||||
};
|
||||
|
||||
struct spherical_segments_calc_policy
|
||||
{
|
||||
template <typename Point, typename Point3d>
|
||||
static Point from_cart3d(Point3d const& point_3d)
|
||||
{
|
||||
return formula::cart3d_to_sph<Point>(point_3d);
|
||||
}
|
||||
|
||||
template <typename Point3d, typename Point>
|
||||
static Point3d to_cart3d(Point const& point)
|
||||
{
|
||||
return formula::sph_to_cart3d<Point3d>(point);
|
||||
}
|
||||
|
||||
template <typename Point3d>
|
||||
struct plane
|
||||
{
|
||||
typedef typename coordinate_type<Point3d>::type coord_t;
|
||||
|
||||
// not normalized
|
||||
plane(Point3d const& p1, Point3d const& p2)
|
||||
: normal(cross_product(p1, p2))
|
||||
{}
|
||||
|
||||
int side_value(Point3d const& pt) const
|
||||
{
|
||||
return formula::sph_side_value(normal, pt);
|
||||
}
|
||||
|
||||
static coord_t cos_angle_between(Point3d const& p1, Point3d const& p2)
|
||||
{
|
||||
return dot_product(p1, p2);
|
||||
}
|
||||
|
||||
coord_t cos_angle_between(Point3d const& p1, Point3d const& p2, bool & is_forward) const
|
||||
{
|
||||
coord_t const c0 = 0;
|
||||
is_forward = dot_product(normal, cross_product(p1, p2)) >= c0;
|
||||
return dot_product(p1, p2);
|
||||
}
|
||||
|
||||
Point3d normal;
|
||||
};
|
||||
|
||||
template <typename Point3d>
|
||||
static plane<Point3d> get_plane(Point3d const& p1, Point3d const& p2)
|
||||
{
|
||||
return plane<Point3d>(p1, p2);
|
||||
}
|
||||
|
||||
template <typename Point3d>
|
||||
static bool intersection_points(plane<Point3d> const& plane1,
|
||||
plane<Point3d> const& plane2,
|
||||
Point3d & ip1, Point3d & ip2)
|
||||
{
|
||||
typedef typename coordinate_type<Point3d>::type coord_t;
|
||||
|
||||
ip1 = cross_product(plane1.normal, plane2.normal);
|
||||
// NOTE: the length should be greater than 0 at this point
|
||||
// if the normals were not normalized and their dot product
|
||||
// not checked before this function is called the length
|
||||
// should be checked here (math::equals(len, c0))
|
||||
coord_t const len = math::sqrt(dot_product(ip1, ip1));
|
||||
divide_value(ip1, len); // normalize i1
|
||||
|
||||
ip2 = ip1;
|
||||
multiply_value(ip2, coord_t(-1));
|
||||
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template
|
||||
<
|
||||
typename CalculationType = void
|
||||
>
|
||||
struct spherical_segments
|
||||
: ecef_segments
|
||||
<
|
||||
spherical_segments_calc_policy,
|
||||
CalculationType
|
||||
>
|
||||
{};
|
||||
|
||||
|
||||
#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
|
||||
namespace services
|
||||
{
|
||||
|
||||
/*template <typename CalculationType>
|
||||
struct default_strategy<spherical_polar_tag, CalculationType>
|
||||
{
|
||||
typedef spherical_segments<CalculationType> type;
|
||||
};*/
|
||||
|
||||
template <typename CalculationType>
|
||||
struct default_strategy<spherical_equatorial_tag, CalculationType>
|
||||
{
|
||||
typedef spherical_segments<CalculationType> type;
|
||||
};
|
||||
|
||||
template <typename CalculationType>
|
||||
struct default_strategy<geographic_tag, CalculationType>
|
||||
{
|
||||
// NOTE: Spherical strategy returns the same result as the geographic one
|
||||
// representing segments as great elliptic arcs. If the elliptic arcs are
|
||||
// not great elliptic arcs (the origin not in the center of the coordinate
|
||||
// system) then there may be problems with consistency of the side and
|
||||
// intersection strategies.
|
||||
typedef spherical_segments<CalculationType> type;
|
||||
};
|
||||
|
||||
} // namespace services
|
||||
#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
|
||||
|
||||
|
||||
}} // namespace strategy::intersection
|
||||
|
||||
|
||||
namespace strategy
|
||||
{
|
||||
|
||||
namespace within { namespace services
|
||||
{
|
||||
|
||||
template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
|
||||
struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, linear_tag, linear_tag, spherical_tag, spherical_tag>
|
||||
{
|
||||
typedef strategy::intersection::spherical_segments<> type;
|
||||
};
|
||||
|
||||
template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
|
||||
struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, linear_tag, polygonal_tag, spherical_tag, spherical_tag>
|
||||
{
|
||||
typedef strategy::intersection::spherical_segments<> type;
|
||||
};
|
||||
|
||||
template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
|
||||
struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, polygonal_tag, linear_tag, spherical_tag, spherical_tag>
|
||||
{
|
||||
typedef strategy::intersection::spherical_segments<> type;
|
||||
};
|
||||
|
||||
template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
|
||||
struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, polygonal_tag, polygonal_tag, spherical_tag, spherical_tag>
|
||||
{
|
||||
typedef strategy::intersection::spherical_segments<> type;
|
||||
};
|
||||
|
||||
}} // within::services
|
||||
|
||||
namespace covered_by { namespace services
|
||||
{
|
||||
|
||||
template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
|
||||
struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, linear_tag, linear_tag, spherical_tag, spherical_tag>
|
||||
{
|
||||
typedef strategy::intersection::spherical_segments<> type;
|
||||
};
|
||||
|
||||
template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
|
||||
struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, linear_tag, polygonal_tag, spherical_tag, spherical_tag>
|
||||
{
|
||||
typedef strategy::intersection::spherical_segments<> type;
|
||||
};
|
||||
|
||||
template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
|
||||
struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, polygonal_tag, linear_tag, spherical_tag, spherical_tag>
|
||||
{
|
||||
typedef strategy::intersection::spherical_segments<> type;
|
||||
};
|
||||
|
||||
template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
|
||||
struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, polygonal_tag, polygonal_tag, spherical_tag, spherical_tag>
|
||||
{
|
||||
typedef strategy::intersection::spherical_segments<> type;
|
||||
};
|
||||
|
||||
}} // within::services
|
||||
|
||||
} // strategy
|
||||
|
||||
|
||||
}} // namespace boost::geometry
|
||||
|
||||
|
||||
#endif // BOOST_GEOMETRY_STRATEGIES_SPHERICAL_INTERSECTION_HPP
|
||||
+76
@@ -0,0 +1,76 @@
|
||||
// Boost.Geometry (aka GGL, Generic Geometry Library)
|
||||
|
||||
// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
|
||||
|
||||
// This file was modified by Oracle on 2014.
|
||||
// Modifications copyright (c) 2014, Oracle and/or its affiliates.
|
||||
|
||||
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
|
||||
|
||||
// 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_SPHERICAL_SIDE_BY_CROSS_TRACK_HPP
|
||||
#define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_SIDE_BY_CROSS_TRACK_HPP
|
||||
|
||||
#include <boost/geometry/core/cs.hpp>
|
||||
#include <boost/geometry/core/access.hpp>
|
||||
#include <boost/geometry/core/radian_access.hpp>
|
||||
|
||||
#include <boost/geometry/algorithms/detail/course.hpp>
|
||||
|
||||
#include <boost/geometry/util/math.hpp>
|
||||
#include <boost/geometry/util/promote_floating_point.hpp>
|
||||
#include <boost/geometry/util/select_calculation_type.hpp>
|
||||
|
||||
#include <boost/geometry/strategies/side.hpp>
|
||||
//#include <boost/geometry/strategies/concepts/side_concept.hpp>
|
||||
|
||||
|
||||
namespace boost { namespace geometry
|
||||
{
|
||||
|
||||
|
||||
namespace strategy { namespace side
|
||||
{
|
||||
|
||||
/*!
|
||||
\brief Check at which side of a Great Circle segment a point lies
|
||||
left of segment (> 0), right of segment (< 0), on segment (0)
|
||||
\ingroup strategies
|
||||
\tparam CalculationType \tparam_calculation
|
||||
*/
|
||||
template <typename CalculationType = void>
|
||||
class side_by_cross_track
|
||||
{
|
||||
|
||||
public :
|
||||
template <typename P1, typename P2, typename P>
|
||||
static inline int apply(P1 const& p1, P2 const& p2, P const& p)
|
||||
{
|
||||
typedef typename promote_floating_point
|
||||
<
|
||||
typename select_calculation_type_alt
|
||||
<
|
||||
CalculationType,
|
||||
P1, P2, P
|
||||
>::type
|
||||
>::type calc_t;
|
||||
|
||||
calc_t d1 = 0.001; // m_strategy.apply(sp1, p);
|
||||
calc_t crs_AD = geometry::detail::course<calc_t>(p1, p);
|
||||
calc_t crs_AB = geometry::detail::course<calc_t>(p1, p2);
|
||||
calc_t XTD = asin(sin(d1) * sin(crs_AD - crs_AB));
|
||||
|
||||
return math::equals(XTD, 0) ? 0 : XTD < 0 ? 1 : -1;
|
||||
}
|
||||
};
|
||||
|
||||
}} // namespace strategy::side
|
||||
|
||||
|
||||
}} // namespace boost::geometry
|
||||
|
||||
|
||||
#endif // BOOST_GEOMETRY_STRATEGIES_SPHERICAL_SIDE_BY_CROSS_TRACK_HPP
|
||||
@@ -0,0 +1,141 @@
|
||||
// Boost.Geometry (aka GGL, Generic Geometry Library)
|
||||
|
||||
// Copyright (c) 2011-2012 Barend Gehrels, Amsterdam, the Netherlands.
|
||||
|
||||
// This file was modified by Oracle on 2016.
|
||||
// Modifications copyright (c) 2016, Oracle and/or its affiliates.
|
||||
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
|
||||
|
||||
// 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_SPHERICAL_SSF_HPP
|
||||
#define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_SSF_HPP
|
||||
|
||||
|
||||
#include <boost/geometry/core/cs.hpp>
|
||||
#include <boost/geometry/core/access.hpp>
|
||||
#include <boost/geometry/core/radian_access.hpp>
|
||||
|
||||
#include <boost/geometry/util/math.hpp>
|
||||
#include <boost/geometry/util/promote_floating_point.hpp>
|
||||
#include <boost/geometry/util/select_calculation_type.hpp>
|
||||
|
||||
#include <boost/geometry/strategies/side.hpp>
|
||||
//#include <boost/geometry/strategies/concepts/side_concept.hpp>
|
||||
|
||||
|
||||
namespace boost { namespace geometry
|
||||
{
|
||||
|
||||
|
||||
namespace strategy { namespace side
|
||||
{
|
||||
|
||||
#ifndef DOXYGEN_NO_DETAIL
|
||||
namespace detail
|
||||
{
|
||||
|
||||
template <typename T>
|
||||
int spherical_side_formula(T const& lambda1, T const& delta1,
|
||||
T const& lambda2, T const& delta2,
|
||||
T const& lambda, T const& delta)
|
||||
{
|
||||
// Create temporary points (vectors) on unit a sphere
|
||||
T const cos_delta1 = cos(delta1);
|
||||
T const c1x = cos_delta1 * cos(lambda1);
|
||||
T const c1y = cos_delta1 * sin(lambda1);
|
||||
T const c1z = sin(delta1);
|
||||
|
||||
T const cos_delta2 = cos(delta2);
|
||||
T const c2x = cos_delta2 * cos(lambda2);
|
||||
T const c2y = cos_delta2 * sin(lambda2);
|
||||
T const c2z = sin(delta2);
|
||||
|
||||
// (Third point is converted directly)
|
||||
T const cos_delta = cos(delta);
|
||||
|
||||
// Apply the "Spherical Side Formula" as presented on my blog
|
||||
T const dist
|
||||
= (c1y * c2z - c1z * c2y) * cos_delta * cos(lambda)
|
||||
+ (c1z * c2x - c1x * c2z) * cos_delta * sin(lambda)
|
||||
+ (c1x * c2y - c1y * c2x) * sin(delta);
|
||||
|
||||
T zero = T();
|
||||
return math::equals(dist, zero) ? 0
|
||||
: dist > zero ? 1
|
||||
: -1; // dist < zero
|
||||
}
|
||||
|
||||
}
|
||||
#endif // DOXYGEN_NO_DETAIL
|
||||
|
||||
/*!
|
||||
\brief Check at which side of a Great Circle segment a point lies
|
||||
left of segment (> 0), right of segment (< 0), on segment (0)
|
||||
\ingroup strategies
|
||||
\tparam CalculationType \tparam_calculation
|
||||
*/
|
||||
template <typename CalculationType = void>
|
||||
class spherical_side_formula
|
||||
{
|
||||
|
||||
public :
|
||||
template <typename P1, typename P2, typename P>
|
||||
static inline int apply(P1 const& p1, P2 const& p2, P const& p)
|
||||
{
|
||||
typedef typename promote_floating_point
|
||||
<
|
||||
typename select_calculation_type_alt
|
||||
<
|
||||
CalculationType,
|
||||
P1, P2, P
|
||||
>::type
|
||||
>::type calculation_type;
|
||||
|
||||
calculation_type const lambda1 = get_as_radian<0>(p1);
|
||||
calculation_type const delta1 = get_as_radian<1>(p1);
|
||||
calculation_type const lambda2 = get_as_radian<0>(p2);
|
||||
calculation_type const delta2 = get_as_radian<1>(p2);
|
||||
calculation_type const lambda = get_as_radian<0>(p);
|
||||
calculation_type const delta = get_as_radian<1>(p);
|
||||
|
||||
return detail::spherical_side_formula(lambda1, delta1,
|
||||
lambda2, delta2,
|
||||
lambda, delta);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
|
||||
namespace services
|
||||
{
|
||||
|
||||
/*template <typename CalculationType>
|
||||
struct default_strategy<spherical_polar_tag, CalculationType>
|
||||
{
|
||||
typedef spherical_side_formula<CalculationType> type;
|
||||
};*/
|
||||
|
||||
template <typename CalculationType>
|
||||
struct default_strategy<spherical_equatorial_tag, CalculationType>
|
||||
{
|
||||
typedef spherical_side_formula<CalculationType> type;
|
||||
};
|
||||
|
||||
template <typename CalculationType>
|
||||
struct default_strategy<geographic_tag, CalculationType>
|
||||
{
|
||||
typedef spherical_side_formula<CalculationType> type;
|
||||
};
|
||||
|
||||
}
|
||||
#endif
|
||||
|
||||
}} // namespace strategy::side
|
||||
|
||||
}} // namespace boost::geometry
|
||||
|
||||
|
||||
#endif // BOOST_GEOMETRY_STRATEGIES_SPHERICAL_SSF_HPP
|
||||
Reference in New Issue
Block a user