Added thirdparty: boost library

This commit is contained in:
Viacheslav Demydiuk
2024-01-06 19:55:56 +02:00
parent bf49f439e1
commit bccd1e7051
15683 changed files with 3239840 additions and 0 deletions
+124
View File
@@ -0,0 +1,124 @@
// Boost.Geometry
// Copyright (c) 2021, Oracle and/or its affiliates.
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
// Licensed under the Boost Software License version 1.0.
// http://www.boost.org/users/license.html
#ifndef BOOST_GEOMETRY_STRATEGIES_SIMPLIFY_CARTESIAN_HPP
#define BOOST_GEOMETRY_STRATEGIES_SIMPLIFY_CARTESIAN_HPP
#include <boost/geometry/strategies/agnostic/simplify_douglas_peucker.hpp>
#include <boost/geometry/strategies/cartesian/distance_projected_point.hpp>
#include <boost/geometry/strategies/cartesian/distance_pythagoras.hpp>
#include <boost/geometry/strategies/cartesian/point_in_point.hpp>
#include <boost/geometry/strategies/detail.hpp>
#include <boost/geometry/strategies/distance/comparable.hpp>
#include <boost/geometry/strategies/distance/detail.hpp>
#include <boost/geometry/strategies/simplify/services.hpp>
#include <boost/geometry/strategy/cartesian/area.hpp>
#include <boost/geometry/util/type_traits.hpp>
namespace boost { namespace geometry
{
namespace strategies { namespace simplify
{
template <typename CalculationType = void>
struct cartesian
: public strategies::detail::cartesian_base
{
// TODO: Replace this if calculate_point_order() is used in simplify
template <typename Geometry>
static auto area(Geometry const&)
{
return strategy::area::cartesian<CalculationType>();
}
// For perimeter()
template <typename Geometry1, typename Geometry2>
static auto distance(Geometry1 const&, Geometry2 const&,
distance::detail::enable_if_pp_t<Geometry1, Geometry2> * = nullptr)
{
return strategy::distance::pythagoras<CalculationType>();
}
// For douglas_peucker
template <typename Geometry1, typename Geometry2>
static auto distance(Geometry1 const&, Geometry2 const&,
distance::detail::enable_if_ps_t<Geometry1, Geometry2> * = nullptr)
{
return strategy::distance::projected_point
<
CalculationType,
strategy::distance::pythagoras<CalculationType>
>();
}
// For equals()
template <typename Geometry1, typename Geometry2>
static auto relate(Geometry1 const&, Geometry2 const&,
std::enable_if_t
<
util::is_pointlike<Geometry1>::value
&& util::is_pointlike<Geometry2>::value
> * = nullptr)
{
return strategy::within::cartesian_point_point();
}
};
namespace services
{
template <typename Geometry>
struct default_strategy<Geometry, cartesian_tag>
{
using type = strategies::simplify::cartesian<>;
};
template <typename P, typename CT, typename S>
struct strategy_converter
<
strategy::simplify::douglas_peucker
<
P,
strategy::distance::projected_point<CT, S>
>
>
{
template <typename Strategy>
static auto get(Strategy const& )
{
typedef strategies::simplify::cartesian<CT> strategy_type;
return std::conditional_t
<
std::is_same
<
S,
typename strategy::distance::services::comparable_type<S>::type
>::value,
strategies::distance::detail::comparable<strategy_type>,
strategy_type
>();
}
};
} // namespace services
}} // namespace strategies::simplify
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_STRATEGIES_SIMPLIFY_CARTESIAN_HPP
+132
View File
@@ -0,0 +1,132 @@
// Boost.Geometry
// Copyright (c) 2021, Oracle and/or its affiliates.
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
// Licensed under the Boost Software License version 1.0.
// http://www.boost.org/users/license.html
#ifndef BOOST_GEOMETRY_STRATEGIES_SIMPLIFY_GEOGRAPHIC_HPP
#define BOOST_GEOMETRY_STRATEGIES_SIMPLIFY_GEOGRAPHIC_HPP
#include <boost/geometry/strategies/detail.hpp>
#include <boost/geometry/strategies/distance/detail.hpp>
#include <boost/geometry/strategies/simplify/services.hpp>
#include <boost/geometry/strategies/agnostic/simplify_douglas_peucker.hpp>
#include <boost/geometry/strategies/geographic/distance_cross_track.hpp>
#include <boost/geometry/strategies/spherical/point_in_point.hpp>
#include <boost/geometry/strategy/geographic/area.hpp>
namespace boost { namespace geometry
{
namespace strategies { namespace simplify
{
template
<
typename FormulaPolicy = strategy::andoyer,
typename Spheroid = srs::spheroid<double>,
typename CalculationType = void
>
class geographic
: public strategies::detail::geographic_base<Spheroid>
{
using base_t = strategies::detail::geographic_base<Spheroid>;
public:
geographic() = default;
explicit geographic(Spheroid const& spheroid)
: base_t(spheroid)
{}
// TODO: Replace this if calculate_point_order() is used in simplify
template <typename Geometry>
auto area(Geometry const&) const
{
return strategy::area::geographic
<
FormulaPolicy,
strategy::default_order<FormulaPolicy>::value,
Spheroid,
CalculationType
>(base_t::m_spheroid);
}
// For perimeter()
template <typename Geometry1, typename Geometry2>
auto distance(Geometry1 const&, Geometry2 const&,
distance::detail::enable_if_pp_t<Geometry1, Geometry2> * = nullptr) const
{
return strategy::distance::geographic
<
FormulaPolicy, Spheroid, CalculationType
>(base_t::m_spheroid);
}
// For douglas_peucker
template <typename Geometry1, typename Geometry2>
auto distance(Geometry1 const&, Geometry2 const&,
distance::detail::enable_if_ps_t<Geometry1, Geometry2> * = nullptr) const
{
return strategy::distance::geographic_cross_track
<
FormulaPolicy, Spheroid, CalculationType
>(base_t::m_spheroid);
}
// For equals()
template <typename Geometry1, typename Geometry2>
static auto relate(Geometry1 const&, Geometry2 const&,
std::enable_if_t
<
util::is_pointlike<Geometry1>::value
&& util::is_pointlike<Geometry2>::value
> * = nullptr)
{
return strategy::within::spherical_point_point();
}
};
namespace services
{
template <typename Geometry>
struct default_strategy<Geometry, geographic_tag>
{
using type = strategies::simplify::geographic<>;
};
template <typename P, typename FP, typename S, typename CT>
struct strategy_converter
<
strategy::simplify::douglas_peucker
<
P,
strategy::distance::geographic_cross_track<FP, S, CT>
>
>
{
template <typename Strategy>
static auto get(Strategy const& )
{
return strategies::simplify::geographic<FP, S, CT>();
}
};
} // namespace services
}} // namespace strategies::simplify
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_STRATEGIES_SIMPLIFY_GEOGRAPHIC_HPP
+54
View File
@@ -0,0 +1,54 @@
// Boost.Geometry
// Copyright (c) 2021, Oracle and/or its affiliates.
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
// Licensed under the Boost Software License version 1.0.
// http://www.boost.org/users/license.html
#ifndef BOOST_GEOMETRY_STRATEGIES_SIMPLIFY_SERVICES_HPP
#define BOOST_GEOMETRY_STRATEGIES_SIMPLIFY_SERVICES_HPP
#include <boost/geometry/core/cs.hpp>
#include <boost/geometry/core/static_assert.hpp>
namespace boost { namespace geometry
{
namespace strategies { namespace simplify
{
namespace services
{
template
<
typename Geometry,
typename CSTag = typename geometry::cs_tag<Geometry>::type
>
struct default_strategy
{
BOOST_GEOMETRY_STATIC_ASSERT_FALSE(
"Not implemented for this Geometry's coordinate systems.",
Geometry, CSTag);
};
template <typename Strategy>
struct strategy_converter
{
BOOST_GEOMETRY_STATIC_ASSERT_FALSE(
"Not implemented for this Strategy.",
Strategy);
};
} // namespace services
}} // namespace strategies::simplify
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_STRATEGIES_SIMPLIFY_SERVICES_HPP
+151
View File
@@ -0,0 +1,151 @@
// Boost.Geometry
// Copyright (c) 2021, Oracle and/or its affiliates.
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
// Licensed under the Boost Software License version 1.0.
// http://www.boost.org/users/license.html
#ifndef BOOST_GEOMETRY_STRATEGIES_SIMPLIFY_SPHERICAL_HPP
#define BOOST_GEOMETRY_STRATEGIES_SIMPLIFY_SPHERICAL_HPP
#include <boost/geometry/strategies/detail.hpp>
#include <boost/geometry/strategies/distance/comparable.hpp>
#include <boost/geometry/strategies/distance/detail.hpp>
#include <boost/geometry/strategies/simplify/services.hpp>
#include <boost/geometry/strategies/agnostic/simplify_douglas_peucker.hpp>
#include <boost/geometry/strategies/spherical/distance_haversine.hpp>
#include <boost/geometry/strategies/spherical/distance_cross_track.hpp>
#include <boost/geometry/strategies/spherical/point_in_point.hpp>
#include <boost/geometry/strategy/spherical/area.hpp>
namespace boost { namespace geometry
{
namespace strategies { namespace simplify
{
template
<
typename RadiusTypeOrSphere = double,
typename CalculationType = void
>
class spherical
: public strategies::detail::spherical_base<RadiusTypeOrSphere>
{
using base_t = strategies::detail::spherical_base<RadiusTypeOrSphere>;
public:
spherical() = default;
template <typename RadiusOrSphere>
explicit spherical(RadiusOrSphere const& radius_or_sphere)
: base_t(radius_or_sphere)
{}
// TODO: Replace this if calculate_point_order() is used in simplify
template <typename Geometry>
auto area(Geometry const&) const
{
return strategy::area::spherical
<
typename base_t::radius_type, CalculationType
>(base_t::radius());
}
// For perimeter()
template <typename Geometry1, typename Geometry2>
auto distance(Geometry1 const&, Geometry2 const&,
distance::detail::enable_if_pp_t<Geometry1, Geometry2> * = nullptr) const
{
return strategy::distance::haversine
<
typename base_t::radius_type, CalculationType
>(base_t::radius());
}
// For douglas_peucker
template <typename Geometry1, typename Geometry2>
auto distance(Geometry1 const&, Geometry2 const&,
distance::detail::enable_if_ps_t<Geometry1, Geometry2> * = nullptr) const
{
return strategy::distance::cross_track
<
CalculationType,
strategy::distance::haversine<typename base_t::radius_type, CalculationType>
>(base_t::radius());
}
// For equals()
template <typename Geometry1, typename Geometry2>
static auto relate(Geometry1 const&, Geometry2 const&,
std::enable_if_t
<
util::is_pointlike<Geometry1>::value
&& util::is_pointlike<Geometry2>::value
> * = nullptr)
{
return strategy::within::spherical_point_point();
}
};
namespace services
{
template <typename Geometry>
struct default_strategy<Geometry, spherical_equatorial_tag>
{
using type = strategies::simplify::spherical<>;
};
template <typename P, typename CT, typename S>
struct strategy_converter
<
strategy::simplify::douglas_peucker
<
P,
strategy::distance::cross_track<CT, S>
>
>
{
template <typename Strategy>
static auto get(Strategy const& )
{
return strategies::simplify::spherical<typename S::radius_type, CT>();
}
};
template <typename P, typename CT, typename S>
struct strategy_converter
<
strategy::simplify::douglas_peucker
<
P,
strategy::distance::comparable::cross_track<CT, S>
>
>
{
template <typename Strategy>
static auto get(Strategy const& )
{
return strategies::distance::detail::comparable
<
strategies::simplify::spherical<typename S::radius_type, CT>
>();
}
};
} // namespace services
}} // namespace strategies::simplify
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_STRATEGIES_SIMPLIFY_SPHERICAL_HPP