[ceph.git] / ceph / src / boost / boost / geometry / algorithms / detail / intersection / interface.hpp

// Boost.Geometry (aka GGL, Generic Geometry Library)

// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.

// This file was modified by Oracle on 2014, 2017.
// Modifications copyright (c) 2014-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_ALGORITHMS_DETAIL_INTERSECTION_INTERFACE_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERSECTION_INTERFACE_HPP


#include <boost/variant/apply_visitor.hpp>
#include <boost/variant/static_visitor.hpp>
#include <boost/variant/variant_fwd.hpp>

#include <boost/geometry/algorithms/detail/overlay/intersection_insert.hpp>
#include <boost/geometry/policies/robustness/get_rescale_policy.hpp>
#include <boost/geometry/strategies/default_strategy.hpp>
#include <boost/geometry/util/range.hpp>


namespace boost { namespace geometry
{


#ifndef DOXYGEN_NO_DISPATCH
namespace dispatch
{

// By default, all is forwarded to the intersection_insert-dispatcher
template
<
    typename Geometry1, typename Geometry2,
    typename Tag1 = typename geometry::tag<Geometry1>::type,
    typename Tag2 = typename geometry::tag<Geometry2>::type,
    bool Reverse = reverse_dispatch<Geometry1, Geometry2>::type::value
>
struct intersection
{
    template <typename RobustPolicy, typename GeometryOut, typename Strategy>
    static inline bool apply(Geometry1 const& geometry1,
            Geometry2 const& geometry2,
            RobustPolicy const& robust_policy,
            GeometryOut& geometry_out,
            Strategy const& strategy)
    {
        typedef typename boost::range_value<GeometryOut>::type OneOut;

        intersection_insert
            <
                Geometry1, Geometry2, OneOut,
                overlay_intersection
            >::apply(geometry1, geometry2, robust_policy,
                     range::back_inserter(geometry_out), strategy);

        return true;
    }

};


// If reversal is needed, perform it
template
<
    typename Geometry1, typename Geometry2,
    typename Tag1, typename Tag2
>
struct intersection
<
    Geometry1, Geometry2,
    Tag1, Tag2,
    true
>
    : intersection<Geometry2, Geometry1, Tag2, Tag1, false>
{
    template <typename RobustPolicy, typename GeometryOut, typename Strategy>
    static inline bool apply(
        Geometry1 const& g1,
        Geometry2 const& g2,
        RobustPolicy const& robust_policy,
        GeometryOut& out,
        Strategy const& strategy)
    {
        return intersection
            <
                Geometry2, Geometry1,
                Tag2, Tag1,
                false
            >::apply(g2, g1, robust_policy, out, strategy);
    }
};


} // namespace dispatch
#endif // DOXYGEN_NO_DISPATCH


namespace resolve_strategy {

struct intersection
{
    template
    <
        typename Geometry1,
        typename Geometry2,
        typename RobustPolicy,
        typename GeometryOut,
        typename Strategy
    >
    static inline bool apply(Geometry1 const& geometry1,
                             Geometry2 const& geometry2,
                             RobustPolicy const& robust_policy,
                             GeometryOut & geometry_out,
                             Strategy const& strategy)
    {
        return dispatch::intersection
            <
                Geometry1,
                Geometry2
            >::apply(geometry1, geometry2, robust_policy, geometry_out,
                     strategy);
    }

    template
    <
        typename Geometry1,
        typename Geometry2,
        typename RobustPolicy,
        typename GeometryOut
    >
    static inline bool apply(Geometry1 const& geometry1,
                             Geometry2 const& geometry2,
                             RobustPolicy const& robust_policy,
                             GeometryOut & geometry_out,
                             default_strategy)
    {
        typedef typename strategy::relate::services::default_strategy
            <
                Geometry1, Geometry2
            >::type strategy_type;
        
        return dispatch::intersection
            <
                Geometry1,
                Geometry2
            >::apply(geometry1, geometry2, robust_policy, geometry_out,
                     strategy_type());
    }
};

} // resolve_strategy


namespace resolve_variant
{
    
template <typename Geometry1, typename Geometry2>
struct intersection
{
    template <typename GeometryOut, typename Strategy>
    static inline bool apply(Geometry1 const& geometry1,
                             Geometry2 const& geometry2,
                             GeometryOut& geometry_out,
                             Strategy const& strategy)
    {
        concepts::check<Geometry1 const>();
        concepts::check<Geometry2 const>();
        
        typedef typename geometry::rescale_overlay_policy_type
            <
                Geometry1,
                Geometry2
            >::type rescale_policy_type;
        
        rescale_policy_type robust_policy
            = geometry::get_rescale_policy<rescale_policy_type>(geometry1,
                                                                geometry2);
        
        return resolve_strategy::intersection::apply(geometry1,
                                                     geometry2,
                                                     robust_policy,
                                                     geometry_out,
                                                     strategy);
    }
};


template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
struct intersection<variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
{
    template <typename GeometryOut, typename Strategy>
    struct visitor: static_visitor<bool>
    {
        Geometry2 const& m_geometry2;
        GeometryOut& m_geometry_out;
        Strategy const& m_strategy;
        
        visitor(Geometry2 const& geometry2,
                GeometryOut& geometry_out,
                Strategy const& strategy)
            : m_geometry2(geometry2)
            , m_geometry_out(geometry_out)
            , m_strategy(strategy)
        {}
        
        template <typename Geometry1>
        bool operator()(Geometry1 const& geometry1) const
        {
            return intersection
                <
                    Geometry1,
                    Geometry2
                >::apply(geometry1, m_geometry2, m_geometry_out, m_strategy);
        }
    };
    
    template <typename GeometryOut, typename Strategy>
    static inline bool
    apply(variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry1,
          Geometry2 const& geometry2,
          GeometryOut& geometry_out,
          Strategy const& strategy)
    {
        return boost::apply_visitor(visitor<GeometryOut, Strategy>(geometry2,
                                                                   geometry_out,
                                                                   strategy),
                                    geometry1);
    }
};


template <typename Geometry1, BOOST_VARIANT_ENUM_PARAMS(typename T)>
struct intersection<Geometry1, variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
{
    template <typename GeometryOut, typename Strategy>
    struct visitor: static_visitor<bool>
    {
        Geometry1 const& m_geometry1;
        GeometryOut& m_geometry_out;
        Strategy const& m_strategy;
        
        visitor(Geometry1 const& geometry1,
                GeometryOut& geometry_out,
                Strategy const& strategy)
            : m_geometry1(geometry1)
            , m_geometry_out(geometry_out)
            , m_strategy(strategy)
        {}
        
        template <typename Geometry2>
        bool operator()(Geometry2 const& geometry2) const
        {
            return intersection
                <
                    Geometry1,
                    Geometry2
                >::apply(m_geometry1, geometry2, m_geometry_out, m_strategy);
        }
    };
    
    template <typename GeometryOut, typename Strategy>
    static inline bool
    apply(Geometry1 const& geometry1,
          variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry2,
          GeometryOut& geometry_out,
          Strategy const& strategy)
    {
        return boost::apply_visitor(visitor<GeometryOut, Strategy>(geometry1,
                                                                   geometry_out,
                                                                   strategy),
                                    geometry2);
    }
};


template <BOOST_VARIANT_ENUM_PARAMS(typename T1), BOOST_VARIANT_ENUM_PARAMS(typename T2)>
struct intersection<variant<BOOST_VARIANT_ENUM_PARAMS(T1)>, variant<BOOST_VARIANT_ENUM_PARAMS(T2)> >
{
    template <typename GeometryOut, typename Strategy>
    struct visitor: static_visitor<bool>
    {
        GeometryOut& m_geometry_out;
        Strategy const& m_strategy;
        
        visitor(GeometryOut& geometry_out, Strategy const& strategy)
            : m_geometry_out(geometry_out)
            , m_strategy(strategy)
        {}
        
        template <typename Geometry1, typename Geometry2>
        bool operator()(Geometry1 const& geometry1,
                        Geometry2 const& geometry2) const
        {
            return intersection
                <
                    Geometry1,
                    Geometry2
                >::apply(geometry1, geometry2, m_geometry_out, m_strategy);
        }
    };
    
    template <typename GeometryOut, typename Strategy>
    static inline bool
    apply(variant<BOOST_VARIANT_ENUM_PARAMS(T1)> const& geometry1,
          variant<BOOST_VARIANT_ENUM_PARAMS(T2)> const& geometry2,
          GeometryOut& geometry_out,
          Strategy const& strategy)
    {
        return boost::apply_visitor(visitor<GeometryOut, Strategy>(geometry_out,
                                                                   strategy),
                                    geometry1, geometry2);
    }
};
    
} // namespace resolve_variant
    

/*!
\brief \brief_calc2{intersection}
\ingroup intersection
\details \details_calc2{intersection, spatial set theoretic intersection}.
\tparam Geometry1 \tparam_geometry
\tparam Geometry2 \tparam_geometry
\tparam GeometryOut Collection of geometries (e.g. std::vector, std::deque, boost::geometry::multi*) of which
    the value_type fulfills a \p_l_or_c concept, or it is the output geometry (e.g. for a box)
\tparam Strategy \tparam_strategy{Intersection}
\param geometry1 \param_geometry
\param geometry2 \param_geometry
\param geometry_out The output geometry, either a multi_point, multi_polygon,
    multi_linestring, or a box (for intersection of two boxes)
\param strategy \param_strategy{intersection}

\qbk{distinguish,with strategy}
\qbk{[include reference/algorithms/intersection.qbk]}
*/
template
<
    typename Geometry1,
    typename Geometry2,
    typename GeometryOut,
    typename Strategy
>
inline bool intersection(Geometry1 const& geometry1,
                         Geometry2 const& geometry2,
                         GeometryOut& geometry_out,
                         Strategy const& strategy)
{
    return resolve_variant::intersection
        <
            Geometry1,
            Geometry2
        >::apply(geometry1, geometry2, geometry_out, strategy);
}


/*!
\brief \brief_calc2{intersection}
\ingroup intersection
\details \details_calc2{intersection, spatial set theoretic intersection}.
\tparam Geometry1 \tparam_geometry
\tparam Geometry2 \tparam_geometry
\tparam GeometryOut Collection of geometries (e.g. std::vector, std::deque, boost::geometry::multi*) of which
    the value_type fulfills a \p_l_or_c concept, or it is the output geometry (e.g. for a box)
\param geometry1 \param_geometry
\param geometry2 \param_geometry
\param geometry_out The output geometry, either a multi_point, multi_polygon,
    multi_linestring, or a box (for intersection of two boxes)

\qbk{[include reference/algorithms/intersection.qbk]}
*/
template
<
    typename Geometry1,
    typename Geometry2,
    typename GeometryOut
>
inline bool intersection(Geometry1 const& geometry1,
                         Geometry2 const& geometry2,
                         GeometryOut& geometry_out)
{
    return resolve_variant::intersection
        <
            Geometry1,
            Geometry2
        >::apply(geometry1, geometry2, geometry_out, default_strategy());
}


}} // namespace boost::geometry


#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERSECTION_INTERFACE_HPP
Commit	Line	Data
b32b8144 FG	1	// Boost.Geometry (aka GGL, Generic Geometry Library)
	2
	3	// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
	4
	5	// This file was modified by Oracle on 2014, 2017.
	6	// Modifications copyright (c) 2014-2017, Oracle and/or its affiliates.
	7
	8	// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
	9
	10	// Use, modification and distribution is subject to the Boost Software License,
	11	// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
	12	// http://www.boost.org/LICENSE_1_0.txt)
	13
	14	#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERSECTION_INTERFACE_HPP
	15	#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERSECTION_INTERFACE_HPP
	16
	17
	18	#include <boost/variant/apply_visitor.hpp>
	19	#include <boost/variant/static_visitor.hpp>
	20	#include <boost/variant/variant_fwd.hpp>
	21
	22	#include <boost/geometry/algorithms/detail/overlay/intersection_insert.hpp>
	23	#include <boost/geometry/policies/robustness/get_rescale_policy.hpp>
	24	#include <boost/geometry/strategies/default_strategy.hpp>
	25	#include <boost/geometry/util/range.hpp>
	26
	27
	28	namespace boost { namespace geometry
	29	{
	30
	31
	32	#ifndef DOXYGEN_NO_DISPATCH
	33	namespace dispatch
	34	{
	35
	36	// By default, all is forwarded to the intersection_insert-dispatcher
	37	template
	38	<
	39	typename Geometry1, typename Geometry2,
	40	typename Tag1 = typename geometry::tag<Geometry1>::type,
	41	typename Tag2 = typename geometry::tag<Geometry2>::type,
	42	bool Reverse = reverse_dispatch<Geometry1, Geometry2>::type::value
	43	>
	44	struct intersection
	45	{
	46	template <typename RobustPolicy, typename GeometryOut, typename Strategy>
	47	static inline bool apply(Geometry1 const& geometry1,
	48	Geometry2 const& geometry2,
	49	RobustPolicy const& robust_policy,
	50	GeometryOut& geometry_out,
	51	Strategy const& strategy)
	52	{
	53	typedef typename boost::range_value<GeometryOut>::type OneOut;
	54
	55	intersection_insert
	56	<
	57	Geometry1, Geometry2, OneOut,
	58	overlay_intersection
	59	>::apply(geometry1, geometry2, robust_policy,
	60	range::back_inserter(geometry_out), strategy);
	61
	62	return true;
	63	}
	64
65	};
66
67
68	// If reversal is needed, perform it
69	template
70	<
71	typename Geometry1, typename Geometry2,
72	typename Tag1, typename Tag2
73	>
74	struct intersection
75	<
76	Geometry1, Geometry2,
77	Tag1, Tag2,
78	true
79	>
80	: intersection<Geometry2, Geometry1, Tag2, Tag1, false>
81	{
82	template <typename RobustPolicy, typename GeometryOut, typename Strategy>
83	static inline bool apply(
84	Geometry1 const& g1,
85	Geometry2 const& g2,
86	RobustPolicy const& robust_policy,
87	GeometryOut& out,
88	Strategy const& strategy)
89	{
90	return intersection
91	<
92	Geometry2, Geometry1,
93	Tag2, Tag1,
94	false
95	>::apply(g2, g1, robust_policy, out, strategy);
96	}
97	};
98
99
100	} // namespace dispatch
101	#endif // DOXYGEN_NO_DISPATCH
102
103
104	namespace resolve_strategy {
105
106	struct intersection
107	{
108	template
109	<
110	typename Geometry1,
111	typename Geometry2,
112	typename RobustPolicy,
113	typename GeometryOut,
114	typename Strategy
115	>
116	static inline bool apply(Geometry1 const& geometry1,
117	Geometry2 const& geometry2,
118	RobustPolicy const& robust_policy,
119	GeometryOut & geometry_out,
120	Strategy const& strategy)
121	{
122	return dispatch::intersection
123	<
124	Geometry1,
125	Geometry2
126	>::apply(geometry1, geometry2, robust_policy, geometry_out,
127	strategy);
128	}
129
130	template
131	<
132	typename Geometry1,
133	typename Geometry2,
134	typename RobustPolicy,
135	typename GeometryOut
136	>
137	static inline bool apply(Geometry1 const& geometry1,
138	Geometry2 const& geometry2,
139	RobustPolicy const& robust_policy,
140	GeometryOut & geometry_out,
141	default_strategy)
142	{
143	typedef typename strategy::relate::services::default_strategy
144	<
145	Geometry1, Geometry2
146	>::type strategy_type;
147
148	return dispatch::intersection
149	<
150	Geometry1,
151	Geometry2
152	>::apply(geometry1, geometry2, robust_policy, geometry_out,
153	strategy_type());
154	}
155	};
156
157	} // resolve_strategy
158
159
160	namespace resolve_variant
161	{
162
163	template <typename Geometry1, typename Geometry2>
164	struct intersection
165	{
166	template <typename GeometryOut, typename Strategy>
167	static inline bool apply(Geometry1 const& geometry1,
168	Geometry2 const& geometry2,
169	GeometryOut& geometry_out,
170	Strategy const& strategy)
171	{
172	concepts::check<Geometry1 const>();
173	concepts::check<Geometry2 const>();
174
175	typedef typename geometry::rescale_overlay_policy_type
176	<
177	Geometry1,
178	Geometry2
179	>::type rescale_policy_type;
180
181	rescale_policy_type robust_policy
182	= geometry::get_rescale_policy<rescale_policy_type>(geometry1,
183	geometry2);
184
185	return resolve_strategy::intersection::apply(geometry1,
186	geometry2,
187	robust_policy,
188	geometry_out,
189	strategy);
190	}
191	};
192
193
194	template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
195	struct intersection<variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
196	{
197	template <typename GeometryOut, typename Strategy>
198	struct visitor: static_visitor<bool>
199	{
200	Geometry2 const& m_geometry2;
201	GeometryOut& m_geometry_out;
202	Strategy const& m_strategy;
203
204	visitor(Geometry2 const& geometry2,
205	GeometryOut& geometry_out,
206	Strategy const& strategy)
207	: m_geometry2(geometry2)
208	, m_geometry_out(geometry_out)
209	, m_strategy(strategy)
210	{}
211
212	template <typename Geometry1>
213	bool operator()(Geometry1 const& geometry1) const
214	{
215	return intersection
216	<
217	Geometry1,
218	Geometry2
219	>::apply(geometry1, m_geometry2, m_geometry_out, m_strategy);
220	}
221	};
222
223	template <typename GeometryOut, typename Strategy>
224	static inline bool
225	apply(variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry1,
226	Geometry2 const& geometry2,
227	GeometryOut& geometry_out,
228	Strategy const& strategy)
229	{
230	return boost::apply_visitor(visitor<GeometryOut, Strategy>(geometry2,
231	geometry_out,
232	strategy),
233	geometry1);
234	}
235	};
236
237
238	template <typename Geometry1, BOOST_VARIANT_ENUM_PARAMS(typename T)>
239	struct intersection<Geometry1, variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
240	{
241	template <typename GeometryOut, typename Strategy>
242	struct visitor: static_visitor<bool>
243	{
244	Geometry1 const& m_geometry1;
245	GeometryOut& m_geometry_out;
246	Strategy const& m_strategy;
247
248	visitor(Geometry1 const& geometry1,
249	GeometryOut& geometry_out,
250	Strategy const& strategy)
251	: m_geometry1(geometry1)
252	, m_geometry_out(geometry_out)
253	, m_strategy(strategy)
254	{}
255
256	template <typename Geometry2>
257	bool operator()(Geometry2 const& geometry2) const
258	{
259	return intersection
260	<
261	Geometry1,
262	Geometry2
263	>::apply(m_geometry1, geometry2, m_geometry_out, m_strategy);
264	}
265	};
266
267	template <typename GeometryOut, typename Strategy>
268	static inline bool
269	apply(Geometry1 const& geometry1,
270	variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry2,
271	GeometryOut& geometry_out,
272	Strategy const& strategy)
273	{
274	return boost::apply_visitor(visitor<GeometryOut, Strategy>(geometry1,
275	geometry_out,
276	strategy),
277	geometry2);
278	}
279	};
280
281
282	template <BOOST_VARIANT_ENUM_PARAMS(typename T1), BOOST_VARIANT_ENUM_PARAMS(typename T2)>
283	struct intersection<variant<BOOST_VARIANT_ENUM_PARAMS(T1)>, variant<BOOST_VARIANT_ENUM_PARAMS(T2)> >
284	{
285	template <typename GeometryOut, typename Strategy>
286	struct visitor: static_visitor<bool>
287	{
288	GeometryOut& m_geometry_out;
289	Strategy const& m_strategy;
290
291	visitor(GeometryOut& geometry_out, Strategy const& strategy)
292	: m_geometry_out(geometry_out)
293	, m_strategy(strategy)
294	{}
295
296	template <typename Geometry1, typename Geometry2>
297	bool operator()(Geometry1 const& geometry1,
298	Geometry2 const& geometry2) const
299	{
300	return intersection
301	<
302	Geometry1,
303	Geometry2
304	>::apply(geometry1, geometry2, m_geometry_out, m_strategy);
305	}
306	};
307
308	template <typename GeometryOut, typename Strategy>
309	static inline bool
310	apply(variant<BOOST_VARIANT_ENUM_PARAMS(T1)> const& geometry1,
311	variant<BOOST_VARIANT_ENUM_PARAMS(T2)> const& geometry2,
312	GeometryOut& geometry_out,
313	Strategy const& strategy)
314	{
315	return boost::apply_visitor(visitor<GeometryOut, Strategy>(geometry_out,
316	strategy),
317	geometry1, geometry2);
318	}
319	};
320
321	} // namespace resolve_variant
322
323
324	/*!
325	\brief \brief_calc2{intersection}
326	\ingroup intersection
327	\details \details_calc2{intersection, spatial set theoretic intersection}.
328	\tparam Geometry1 \tparam_geometry
329	\tparam Geometry2 \tparam_geometry
330	\tparam GeometryOut Collection of geometries (e.g. std::vector, std::deque, boost::geometry::multi*) of which
331	the value_type fulfills a \p_l_or_c concept, or it is the output geometry (e.g. for a box)
332	\tparam Strategy \tparam_strategy{Intersection}
333	\param geometry1 \param_geometry
334	\param geometry2 \param_geometry
335	\param geometry_out The output geometry, either a multi_point, multi_polygon,
336	multi_linestring, or a box (for intersection of two boxes)
337	\param strategy \param_strategy{intersection}
338
339	\qbk{distinguish,with strategy}
340	\qbk{[include reference/algorithms/intersection.qbk]}
341	*/
342	template
343	<
344	typename Geometry1,
345	typename Geometry2,
346	typename GeometryOut,
347	typename Strategy
348	>
349	inline bool intersection(Geometry1 const& geometry1,
350	Geometry2 const& geometry2,
351	GeometryOut& geometry_out,
352	Strategy const& strategy)
353	{
354	return resolve_variant::intersection
355	<
356	Geometry1,
357	Geometry2
358	>::apply(geometry1, geometry2, geometry_out, strategy);
359	}
360
361
362	/*!
363	\brief \brief_calc2{intersection}
364	\ingroup intersection
365	\details \details_calc2{intersection, spatial set theoretic intersection}.
366	\tparam Geometry1 \tparam_geometry
367	\tparam Geometry2 \tparam_geometry
368	\tparam GeometryOut Collection of geometries (e.g. std::vector, std::deque, boost::geometry::multi*) of which
369	the value_type fulfills a \p_l_or_c concept, or it is the output geometry (e.g. for a box)
370	\param geometry1 \param_geometry
371	\param geometry2 \param_geometry
372	\param geometry_out The output geometry, either a multi_point, multi_polygon,
373	multi_linestring, or a box (for intersection of two boxes)
374
375	\qbk{[include reference/algorithms/intersection.qbk]}
376	*/
377	template
378	<
379	typename Geometry1,
380	typename Geometry2,
381	typename GeometryOut
382	>
383	inline bool intersection(Geometry1 const& geometry1,
384	Geometry2 const& geometry2,
385	GeometryOut& geometry_out)
386	{
387	return resolve_variant::intersection
388	<
389	Geometry1,
390	Geometry2
391	>::apply(geometry1, geometry2, geometry_out, default_strategy());
392	}
393
394
395	}} // namespace boost::geometry
396
397
398	#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERSECTION_INTERFACE_HPP