1 // Boost.Geometry (aka GGL, Generic Geometry Library)
2 
3 // Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
4 // Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
5 // Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
6 // Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
7 
8 // This file was modified by Oracle on 2013-2017.
9 // Modifications copyright (c) 2013-2017, Oracle and/or its affiliates.
10 
11 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
12 // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
13 
14 // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
15 // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
16 
17 // Use, modification and distribution is subject to the Boost Software License,
18 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
19 // http://www.boost.org/LICENSE_1_0.txt)
20 
21 #ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_LINEAR_LINEAR_HPP
22 #define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_LINEAR_LINEAR_HPP
23 
24 #include <cstddef>
25 #include <deque>
26 
27 #include <boost/range.hpp>
28 #include <boost/geometry/util/range.hpp>
29 
30 #include <boost/geometry/core/point_type.hpp>
31 #include <boost/geometry/core/tag.hpp>
32 #include <boost/geometry/core/tags.hpp>
33 
34 #include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
35 #include <boost/geometry/algorithms/detail/overlay/get_turns.hpp>
36 #include <boost/geometry/algorithms/detail/overlay/do_reverse.hpp>
37 
38 #include <boost/geometry/policies/disjoint_interrupt_policy.hpp>
39 #include <boost/geometry/policies/robustness/no_rescale_policy.hpp>
40 #include <boost/geometry/policies/robustness/segment_ratio_type.hpp>
41 
42 #include <boost/geometry/algorithms/dispatch/disjoint.hpp>
43 
44 
45 namespace boost { namespace geometry
46 {
47 
48 
49 #ifndef DOXYGEN_NO_DETAIL
50 namespace detail { namespace disjoint
51 {
52 
53 template <typename Segment1, typename Segment2>
54 struct disjoint_segment
55 {
56     template <typename Strategy>
applyboost::geometry::detail::disjoint::disjoint_segment57     static inline bool apply(Segment1 const& segment1, Segment2 const& segment2,
58                              Strategy const& strategy)
59     {
60         typedef typename point_type<Segment1>::type point_type;
61 
62         // We don't need to rescale to detect disjointness
63         typedef no_rescale_policy rescale_policy_type;
64         rescale_policy_type robust_policy;
65 
66         typedef segment_intersection_points
67             <
68                 point_type,
69                 typename segment_ratio_type
70                     <
71                         point_type,
72                         rescale_policy_type
73                     >::type
74             > intersection_return_type;
75 
76         typedef policies::relate::segments_intersection_points
77             <
78                 intersection_return_type
79             > intersection_policy;
80 
81         intersection_return_type is = strategy.apply(segment1, segment2,
82                                                      intersection_policy(),
83                                                      robust_policy);
84 
85         return is.count == 0;
86     }
87 };
88 
89 
90 struct assign_disjoint_policy
91 {
92     // We want to include all points:
93     static bool const include_no_turn = true;
94     static bool const include_degenerate = true;
95     static bool const include_opposite = true;
96 
97     // We don't assign extra info:
98     template
99     <
100         typename Info,
101         typename Point1,
102         typename Point2,
103         typename IntersectionInfo
104     >
applyboost::geometry::detail::disjoint::assign_disjoint_policy105     static inline void apply(Info& , Point1 const& , Point2 const&,
106                 IntersectionInfo const&)
107     {}
108 };
109 
110 
111 template <typename Geometry1, typename Geometry2>
112 struct disjoint_linear
113 {
114     template <typename Strategy>
applyboost::geometry::detail::disjoint::disjoint_linear115     static inline bool apply(Geometry1 const& geometry1,
116                              Geometry2 const& geometry2,
117                              Strategy const& strategy)
118     {
119         typedef typename geometry::point_type<Geometry1>::type point_type;
120         typedef detail::no_rescale_policy rescale_policy_type;
121         typedef typename geometry::segment_ratio_type
122             <
123                 point_type, rescale_policy_type
124             >::type segment_ratio_type;
125         typedef overlay::turn_info
126             <
127                 point_type,
128                 segment_ratio_type,
129                 typename detail::get_turns::turn_operation_type
130                         <
131                             Geometry1, Geometry2, segment_ratio_type
132                         >::type
133             > turn_info_type;
134 
135         std::deque<turn_info_type> turns;
136 
137         // Specify two policies:
138         // 1) Stop at any intersection
139         // 2) In assignment, include also degenerate points (which are normally skipped)
140         disjoint_interrupt_policy interrupt_policy;
141         dispatch::get_turns
142             <
143                 typename geometry::tag<Geometry1>::type,
144                 typename geometry::tag<Geometry2>::type,
145                 Geometry1,
146                 Geometry2,
147                 overlay::do_reverse<geometry::point_order<Geometry1>::value>::value, // should be false
148                 overlay::do_reverse<geometry::point_order<Geometry2>::value>::value, // should be false
149                 detail::get_turns::get_turn_info_type
150                     <
151                         Geometry1, Geometry2, assign_disjoint_policy
152                     >
153             >::apply(0, geometry1, 1, geometry2,
154                      strategy, rescale_policy_type(), turns, interrupt_policy);
155 
156         return !interrupt_policy.has_intersections;
157     }
158 };
159 
160 
161 }} // namespace detail::disjoint
162 #endif // DOXYGEN_NO_DETAIL
163 
164 
165 
166 
167 #ifndef DOXYGEN_NO_DISPATCH
168 namespace dispatch
169 {
170 
171 
172 template <typename Linear1, typename Linear2>
173 struct disjoint<Linear1, Linear2, 2, linear_tag, linear_tag, false>
174     : detail::disjoint::disjoint_linear<Linear1, Linear2>
175 {};
176 
177 
178 template <typename Segment1, typename Segment2>
179 struct disjoint<Segment1, Segment2, 2, segment_tag, segment_tag, false>
180     : detail::disjoint::disjoint_segment<Segment1, Segment2>
181 {};
182 
183 
184 } // namespace dispatch
185 #endif // DOXYGEN_NO_DISPATCH
186 
187 
188 }} // namespace boost::geometry
189 
190 
191 #endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_LINEAR_LINEAR_HPP
192