Chris@16: // Boost.Geometry (aka GGL, Generic Geometry Library)
Chris@16: 
Chris@101: // Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
Chris@101: // Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
Chris@101: 
Chris@101: // This file was modified by Oracle on 2014.
Chris@101: // Modifications copyright (c) 2014, Oracle and/or its affiliates.
Chris@101: 
Chris@101: // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
Chris@101: // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
Chris@16: 
Chris@16: // Use, modification and distribution is subject to the Boost Software License,
Chris@16: // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
Chris@16: // http://www.boost.org/LICENSE_1_0.txt)
Chris@16: 
Chris@16: #ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_INTERSECTION_HPP
Chris@16: #define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_INTERSECTION_HPP
Chris@16: 
Chris@16: #include <algorithm>
Chris@16: 
Chris@16: #include <boost/geometry/core/exception.hpp>
Chris@16: 
Chris@16: #include <boost/geometry/geometries/concepts/point_concept.hpp>
Chris@16: #include <boost/geometry/geometries/concepts/segment_concept.hpp>
Chris@16: 
Chris@16: #include <boost/geometry/arithmetic/determinant.hpp>
Chris@16: #include <boost/geometry/algorithms/detail/assign_values.hpp>
Chris@101: #include <boost/geometry/algorithms/detail/assign_indexed_point.hpp>
Chris@101: #include <boost/geometry/algorithms/detail/equals/point_point.hpp>
Chris@101: #include <boost/geometry/algorithms/detail/recalculate.hpp>
Chris@16: 
Chris@16: #include <boost/geometry/util/math.hpp>
Chris@16: #include <boost/geometry/util/select_calculation_type.hpp>
Chris@16: 
Chris@16: // Temporary / will be Strategy as template parameter
Chris@16: #include <boost/geometry/strategies/side.hpp>
Chris@16: #include <boost/geometry/strategies/cartesian/side_by_triangle.hpp>
Chris@16: 
Chris@16: #include <boost/geometry/strategies/side_info.hpp>
Chris@101: #include <boost/geometry/strategies/intersection_result.hpp>
Chris@101: 
Chris@101: #include <boost/geometry/policies/robustness/robust_point_type.hpp>
Chris@101: #include <boost/geometry/policies/robustness/segment_ratio_type.hpp>
Chris@101: 
Chris@101: 
Chris@101: #if defined(BOOST_GEOMETRY_DEBUG_ROBUSTNESS)
Chris@101: #  include <boost/geometry/io/wkt/write.hpp>
Chris@101: #endif
Chris@16: 
Chris@16: 
Chris@16: namespace boost { namespace geometry
Chris@16: {
Chris@16: 
Chris@16: 
Chris@16: namespace strategy { namespace intersection
Chris@16: {
Chris@16: 
Chris@16: 
Chris@16: /*!
Chris@16:     \see http://mathworld.wolfram.com/Line-LineIntersection.html
Chris@16:  */
Chris@16: template <typename Policy, typename CalculationType = void>
Chris@16: struct relate_cartesian_segments
Chris@16: {
Chris@16:     typedef typename Policy::return_type return_type;
Chris@16: 
Chris@101:     template <typename D, typename W, typename ResultType>
Chris@101:     static inline void cramers_rule(D const& dx_a, D const& dy_a,
Chris@101:         D const& dx_b, D const& dy_b, W const& wx, W const& wy,
Chris@101:         // out:
Chris@101:         ResultType& d, ResultType& da)
Chris@16:     {
Chris@101:         // Cramers rule
Chris@101:         d = geometry::detail::determinant<ResultType>(dx_a, dy_a, dx_b, dy_b);
Chris@101:         da = geometry::detail::determinant<ResultType>(dx_b, dy_b, wx, wy);
Chris@101:         // Ratio is da/d , collinear if d == 0, intersecting if 0 <= r <= 1
Chris@101:         // IntersectionPoint = (x1 + r * dx_a, y1 + r * dy_a)
Chris@16:     }
Chris@16: 
Chris@16: 
Chris@101:     // Relate segments a and b
Chris@101:     template <typename Segment1, typename Segment2, typename RobustPolicy>
Chris@101:     static inline return_type apply(Segment1 const& a, Segment2 const& b,
Chris@101:                 RobustPolicy const& robust_policy)
Chris@16:     {
Chris@101:         // type them all as in Segment1 - TODO reconsider this, most precise?
Chris@101:         typedef typename geometry::point_type<Segment1>::type point_type;
Chris@101: 
Chris@101:         typedef typename geometry::robust_point_type
Chris@101:             <
Chris@101:                 point_type, RobustPolicy
Chris@101:             >::type robust_point_type;
Chris@101: 
Chris@101:         point_type a0, a1, b0, b1;
Chris@101:         robust_point_type a0_rob, a1_rob, b0_rob, b1_rob;
Chris@101: 
Chris@101:         detail::assign_point_from_index<0>(a, a0);
Chris@101:         detail::assign_point_from_index<1>(a, a1);
Chris@101:         detail::assign_point_from_index<0>(b, b0);
Chris@101:         detail::assign_point_from_index<1>(b, b1);
Chris@101: 
Chris@101:         geometry::recalculate(a0_rob, a0, robust_policy);
Chris@101:         geometry::recalculate(a1_rob, a1, robust_policy);
Chris@101:         geometry::recalculate(b0_rob, b0, robust_policy);
Chris@101:         geometry::recalculate(b1_rob, b1, robust_policy);
Chris@101: 
Chris@101:         return apply(a, b, robust_policy, a0_rob, a1_rob, b0_rob, b1_rob);
Chris@101:     }
Chris@101: 
Chris@101:     // The main entry-routine, calculating intersections of segments a / b
Chris@101:     template <typename Segment1, typename Segment2, typename RobustPolicy, typename RobustPoint>
Chris@101:     static inline return_type apply(Segment1 const& a, Segment2 const& b,
Chris@101:             RobustPolicy const& robust_policy,
Chris@101:             RobustPoint const& robust_a1, RobustPoint const& robust_a2,
Chris@101:             RobustPoint const& robust_b1, RobustPoint const& robust_b2)
Chris@101:     {
Chris@101:         BOOST_CONCEPT_ASSERT( (concept::ConstSegment<Segment1>) );
Chris@101:         BOOST_CONCEPT_ASSERT( (concept::ConstSegment<Segment2>) );
Chris@101: 
Chris@101:         boost::ignore_unused_variable_warning(robust_policy);
Chris@101: 
Chris@101:         typedef typename select_calculation_type
Chris@101:             <Segment1, Segment2, CalculationType>::type coordinate_type;
Chris@101: 
Chris@101:         using geometry::detail::equals::equals_point_point;
Chris@101:         bool const a_is_point = equals_point_point(robust_a1, robust_a2);
Chris@101:         bool const b_is_point = equals_point_point(robust_b1, robust_b2);
Chris@101: 
Chris@16:         typedef side::side_by_triangle<coordinate_type> side;
Chris@16: 
Chris@16:         if(a_is_point && b_is_point)
Chris@16:         {
Chris@101:             return equals_point_point(robust_a1, robust_b2)
Chris@101:                 ? Policy::degenerate(a, true)
Chris@101:                 : Policy::disjoint()
Chris@101:                 ;
Chris@16:         }
Chris@16: 
Chris@101:         side_info sides;
Chris@101:         sides.set<0>(side::apply(robust_b1, robust_b2, robust_a1),
Chris@101:                      side::apply(robust_b1, robust_b2, robust_a2));
Chris@101:         sides.set<1>(side::apply(robust_a1, robust_a2, robust_b1),
Chris@101:                      side::apply(robust_a1, robust_a2, robust_b2));
Chris@16: 
Chris@16:         bool collinear = sides.collinear();
Chris@16: 
Chris@16:         if (sides.same<0>() || sides.same<1>())
Chris@16:         {
Chris@16:             // Both points are at same side of other segment, we can leave
Chris@101:             return Policy::disjoint();
Chris@16:         }
Chris@16: 
Chris@16:         typedef typename select_most_precise
Chris@16:             <
Chris@16:                 coordinate_type, double
Chris@16:             >::type promoted_type;
Chris@16: 
Chris@101:         typedef typename geometry::coordinate_type
Chris@101:             <
Chris@101:                 RobustPoint
Chris@101:             >::type robust_coordinate_type;
Chris@101: 
Chris@101:         typedef typename segment_ratio_type
Chris@101:         <
Chris@101:             typename geometry::point_type<Segment1>::type, // TODO: most precise point?
Chris@101:             RobustPolicy
Chris@101:         >::type ratio_type;
Chris@101: 
Chris@101:         segment_intersection_info
Chris@101:         <
Chris@101:             coordinate_type,
Chris@101:             promoted_type,
Chris@101:             ratio_type
Chris@101:         > sinfo;
Chris@101: 
Chris@101:         sinfo.dx_a = get<1, 0>(a) - get<0, 0>(a); // distance in x-dir
Chris@101:         sinfo.dx_b = get<1, 0>(b) - get<0, 0>(b);
Chris@101:         sinfo.dy_a = get<1, 1>(a) - get<0, 1>(a); // distance in y-dir
Chris@101:         sinfo.dy_b = get<1, 1>(b) - get<0, 1>(b);
Chris@101: 
Chris@101:         robust_coordinate_type const robust_dx_a = get<0>(robust_a2) - get<0>(robust_a1);
Chris@101:         robust_coordinate_type const robust_dx_b = get<0>(robust_b2) - get<0>(robust_b1);
Chris@101:         robust_coordinate_type const robust_dy_a = get<1>(robust_a2) - get<1>(robust_a1);
Chris@101:         robust_coordinate_type const robust_dy_b = get<1>(robust_b2) - get<1>(robust_b1);
Chris@101: 
Chris@16:         // r: ratio 0-1 where intersection divides A/B
Chris@16:         // (only calculated for non-collinear segments)
Chris@16:         if (! collinear)
Chris@16:         {
Chris@101:             robust_coordinate_type robust_da0, robust_da;
Chris@101:             robust_coordinate_type robust_db0, robust_db;
Chris@16: 
Chris@101:             cramers_rule(robust_dx_a, robust_dy_a, robust_dx_b, robust_dy_b,
Chris@101:                 get<0>(robust_a1) - get<0>(robust_b1),
Chris@101:                 get<1>(robust_a1) - get<1>(robust_b1),
Chris@101:                 robust_da0, robust_da);
Chris@101: 
Chris@101:             cramers_rule(robust_dx_b, robust_dy_b, robust_dx_a, robust_dy_a,
Chris@101:                 get<0>(robust_b1) - get<0>(robust_a1),
Chris@101:                 get<1>(robust_b1) - get<1>(robust_a1),
Chris@101:                 robust_db0, robust_db);
Chris@101: 
Chris@101:             math::detail::equals_factor_policy<robust_coordinate_type>
Chris@101:                 policy(robust_dx_a, robust_dy_a, robust_dx_b, robust_dy_b);
Chris@101:             robust_coordinate_type const zero = 0;
Chris@101:             if (math::detail::equals_by_policy(robust_da0, zero, policy)
Chris@101:              || math::detail::equals_by_policy(robust_db0, zero, policy))
Chris@16:             {
Chris@101:                 // If this is the case, no rescaling is done for FP precision.
Chris@101:                 // We set it to collinear, but it indicates a robustness issue.
Chris@16:                 sides.set<0>(0,0);
Chris@16:                 sides.set<1>(0,0);
Chris@16:                 collinear = true;
Chris@16:             }
Chris@16:             else
Chris@16:             {
Chris@101:                 sinfo.robust_ra.assign(robust_da, robust_da0);
Chris@101:                 sinfo.robust_rb.assign(robust_db, robust_db0);
Chris@16:             }
Chris@16:         }
Chris@16: 
Chris@101:         if (collinear)
Chris@16:         {
Chris@101:             std::pair<bool, bool> const collinear_use_first
Chris@101:                     = is_x_more_significant(geometry::math::abs(robust_dx_a),
Chris@101:                                             geometry::math::abs(robust_dy_a),
Chris@101:                                             geometry::math::abs(robust_dx_b),
Chris@101:                                             geometry::math::abs(robust_dy_b),
Chris@101:                                             a_is_point, b_is_point);
Chris@101: 
Chris@101:             if (collinear_use_first.second)
Chris@16:             {
Chris@101:                 // Degenerate cases: segments of single point, lying on other segment, are not disjoint
Chris@101:                 // This situation is collinear too
Chris@101: 
Chris@101:                 if (collinear_use_first.first)
Chris@101:                 {
Chris@101:                     return relate_collinear<0, ratio_type>(a, b,
Chris@101:                             robust_a1, robust_a2, robust_b1, robust_b2,
Chris@101:                             a_is_point, b_is_point);
Chris@101:                 }
Chris@101:                 else
Chris@101:                 {
Chris@101:                     // Y direction contains larger segments (maybe dx is zero)
Chris@101:                     return relate_collinear<1, ratio_type>(a, b,
Chris@101:                             robust_a1, robust_a2, robust_b1, robust_b2,
Chris@101:                             a_is_point, b_is_point);
Chris@101:                 }
Chris@16:             }
Chris@16:         }
Chris@16: 
Chris@101:         return Policy::segments_crosses(sides, sinfo, a, b);
Chris@16:     }
Chris@16: 
Chris@101: private:
Chris@101:     // first is true if x is more significant
Chris@101:     // second is true if the more significant difference is not 0
Chris@101:     template <typename RobustCoordinateType>
Chris@101:     static inline std::pair<bool, bool>
Chris@101:         is_x_more_significant(RobustCoordinateType const& abs_robust_dx_a,
Chris@101:                               RobustCoordinateType const& abs_robust_dy_a,
Chris@101:                               RobustCoordinateType const& abs_robust_dx_b,
Chris@101:                               RobustCoordinateType const& abs_robust_dy_b,
Chris@101:                               bool const a_is_point,
Chris@101:                               bool const b_is_point)
Chris@101:     {
Chris@101:         //BOOST_ASSERT_MSG(!(a_is_point && b_is_point), "both segments shouldn't be degenerated");
Chris@16: 
Chris@101:         // for degenerated segments the second is always true because this function
Chris@101:         // shouldn't be called if both segments were degenerated
Chris@16: 
Chris@101:         if (a_is_point)
Chris@16:         {
Chris@101:             return std::make_pair(abs_robust_dx_b >= abs_robust_dy_b, true);
Chris@16:         }
Chris@101:         else if (b_is_point)
Chris@16:         {
Chris@101:             return std::make_pair(abs_robust_dx_a >= abs_robust_dy_a, true);
Chris@101:         }
Chris@101:         else
Chris@101:         {
Chris@101:             RobustCoordinateType const min_dx = (std::min)(abs_robust_dx_a, abs_robust_dx_b);
Chris@101:             RobustCoordinateType const min_dy = (std::min)(abs_robust_dy_a, abs_robust_dy_b);
Chris@101:             return min_dx == min_dy ?
Chris@101:                     std::make_pair(true, min_dx > RobustCoordinateType(0)) :
Chris@101:                     std::make_pair(min_dx > min_dy, true);
Chris@16:         }
Chris@16:     }
Chris@16: 
Chris@101:     template
Chris@101:     <
Chris@101:         std::size_t Dimension,
Chris@101:         typename RatioType,
Chris@101:         typename Segment1,
Chris@101:         typename Segment2,
Chris@101:         typename RobustPoint
Chris@101:     >
Chris@101:     static inline return_type relate_collinear(Segment1 const& a,
Chris@101:             Segment2 const& b,
Chris@101:             RobustPoint const& robust_a1, RobustPoint const& robust_a2,
Chris@101:             RobustPoint const& robust_b1, RobustPoint const& robust_b2,
Chris@101:             bool a_is_point, bool b_is_point)
Chris@16:     {
Chris@101:         if (a_is_point)
Chris@16:         {
Chris@101:             return relate_one_degenerate<RatioType>(a,
Chris@101:                 get<Dimension>(robust_a1),
Chris@101:                 get<Dimension>(robust_b1), get<Dimension>(robust_b2),
Chris@101:                 true);
Chris@16:         }
Chris@101:         if (b_is_point)
Chris@101:         {
Chris@101:             return relate_one_degenerate<RatioType>(b,
Chris@101:                 get<Dimension>(robust_b1),
Chris@101:                 get<Dimension>(robust_a1), get<Dimension>(robust_a2),
Chris@101:                 false);
Chris@101:         }
Chris@101:         return relate_collinear<RatioType>(a, b,
Chris@101:                                 get<Dimension>(robust_a1),
Chris@101:                                 get<Dimension>(robust_a2),
Chris@101:                                 get<Dimension>(robust_b1),
Chris@101:                                 get<Dimension>(robust_b2));
Chris@16:     }
Chris@16: 
Chris@101:     /// Relate segments known collinear
Chris@101:     template
Chris@101:     <
Chris@101:         typename RatioType,
Chris@101:         typename Segment1,
Chris@101:         typename Segment2,
Chris@101:         typename RobustType
Chris@101:     >
Chris@101:     static inline return_type relate_collinear(Segment1 const& a
Chris@101:             , Segment2 const& b
Chris@101:             , RobustType oa_1, RobustType oa_2
Chris@101:             , RobustType ob_1, RobustType ob_2
Chris@101:             )
Chris@16:     {
Chris@101:         // Calculate the ratios where a starts in b, b starts in a
Chris@101:         //         a1--------->a2         (2..7)
Chris@101:         //                b1----->b2      (5..8)
Chris@101:         // length_a: 7-2=5
Chris@101:         // length_b: 8-5=3
Chris@101:         // b1 is located w.r.t. a at ratio: (5-2)/5=3/5 (on a)
Chris@101:         // b2 is located w.r.t. a at ratio: (8-2)/5=6/5 (right of a)
Chris@101:         // a1 is located w.r.t. b at ratio: (2-5)/3=-3/3 (left of b)
Chris@101:         // a2 is located w.r.t. b at ratio: (7-5)/3=2/3 (on b)
Chris@101:         // A arrives (a2 on b), B departs (b1 on a)
Chris@101: 
Chris@101:         // If both are reversed:
Chris@101:         //         a2<---------a1         (7..2)
Chris@101:         //                b2<-----b1      (8..5)
Chris@101:         // length_a: 2-7=-5
Chris@101:         // length_b: 5-8=-3
Chris@101:         // b1 is located w.r.t. a at ratio: (8-7)/-5=-1/5 (before a starts)
Chris@101:         // b2 is located w.r.t. a at ratio: (5-7)/-5=2/5 (on a)
Chris@101:         // a1 is located w.r.t. b at ratio: (7-8)/-3=1/3 (on b)
Chris@101:         // a2 is located w.r.t. b at ratio: (2-8)/-3=6/3 (after b ends)
Chris@101: 
Chris@101:         // If both one is reversed:
Chris@101:         //         a1--------->a2         (2..7)
Chris@101:         //                b2<-----b1      (8..5)
Chris@101:         // length_a: 7-2=+5
Chris@101:         // length_b: 5-8=-3
Chris@101:         // b1 is located w.r.t. a at ratio: (8-2)/5=6/5 (after a ends)
Chris@101:         // b2 is located w.r.t. a at ratio: (5-2)/5=3/5 (on a)
Chris@101:         // a1 is located w.r.t. b at ratio: (2-8)/-3=6/3 (after b ends)
Chris@101:         // a2 is located w.r.t. b at ratio: (7-8)/-3=1/3 (on b)
Chris@101:         RobustType const length_a = oa_2 - oa_1; // no abs, see above
Chris@101:         RobustType const length_b = ob_2 - ob_1;
Chris@101: 
Chris@101:         RatioType ra_from(oa_1 - ob_1, length_b);
Chris@101:         RatioType ra_to(oa_2 - ob_1, length_b);
Chris@101:         RatioType rb_from(ob_1 - oa_1, length_a);
Chris@101:         RatioType rb_to(ob_2 - oa_1, length_a);
Chris@101: 
Chris@101:         // use absolute measure to detect endpoints intersection
Chris@101:         // NOTE: it'd be possible to calculate bx_wrt_a using ax_wrt_b values
Chris@101:         int const a1_wrt_b = position_value(oa_1, ob_1, ob_2);
Chris@101:         int const a2_wrt_b = position_value(oa_2, ob_1, ob_2);
Chris@101:         int const b1_wrt_a = position_value(ob_1, oa_1, oa_2);
Chris@101:         int const b2_wrt_a = position_value(ob_2, oa_1, oa_2);
Chris@101:         
Chris@101:         // fix the ratios if necessary
Chris@101:         // CONSIDER: fixing ratios also in other cases, if they're inconsistent
Chris@101:         // e.g. if ratio == 1 or 0 (so IP at the endpoint)
Chris@101:         // but position value indicates that the IP is in the middle of the segment
Chris@101:         // because one of the segments is very long
Chris@101:         // In such case the ratios could be moved into the middle direction
Chris@101:         // by some small value (e.g. EPS+1ULP)
Chris@101:         if (a1_wrt_b == 1)
Chris@16:         {
Chris@101:             ra_from.assign(0, 1);
Chris@101:             rb_from.assign(0, 1);
Chris@16:         }
Chris@101:         else if (a1_wrt_b == 3)
Chris@16:         {
Chris@101:             ra_from.assign(1, 1);
Chris@101:             rb_to.assign(0, 1);
Chris@101:         } 
Chris@101: 
Chris@101:         if (a2_wrt_b == 1)
Chris@101:         {
Chris@101:             ra_to.assign(0, 1);
Chris@101:             rb_from.assign(1, 1);
Chris@101:         }
Chris@101:         else if (a2_wrt_b == 3)
Chris@101:         {
Chris@101:             ra_to.assign(1, 1);
Chris@101:             rb_to.assign(1, 1);
Chris@16:         }
Chris@16: 
Chris@101:         if ((a1_wrt_b < 1 && a2_wrt_b < 1) || (a1_wrt_b > 3 && a2_wrt_b > 3))
Chris@101:         //if ((ra_from.left() && ra_to.left()) || (ra_from.right() && ra_to.right()))
Chris@16:         {
Chris@16:             return Policy::disjoint();
Chris@16:         }
Chris@101: 
Chris@101:         bool const opposite = math::sign(length_a) != math::sign(length_b);
Chris@101: 
Chris@101:         return Policy::segments_collinear(a, b, opposite,
Chris@101:                                           a1_wrt_b, a2_wrt_b, b1_wrt_a, b2_wrt_a,
Chris@101:                                           ra_from, ra_to, rb_from, rb_to);
Chris@16:     }
Chris@16: 
Chris@101:     /// Relate segments where one is degenerate
Chris@101:     template
Chris@101:     <
Chris@101:         typename RatioType,
Chris@101:         typename DegenerateSegment,
Chris@101:         typename RobustType
Chris@101:     >
Chris@101:     static inline return_type relate_one_degenerate(
Chris@101:             DegenerateSegment const& degenerate_segment
Chris@101:             , RobustType d
Chris@101:             , RobustType s1, RobustType s2
Chris@101:             , bool a_degenerate
Chris@101:             )
Chris@16:     {
Chris@101:         // Calculate the ratios where ds starts in s
Chris@101:         //         a1--------->a2         (2..6)
Chris@101:         //              b1/b2      (4..4)
Chris@101:         // Ratio: (4-2)/(6-2)
Chris@101:         RatioType const ratio(d - s1, s2 - s1);
Chris@16: 
Chris@101:         if (!ratio.on_segment())
Chris@16:         {
Chris@101:             return Policy::disjoint();
Chris@16:         }
Chris@16: 
Chris@101:         return Policy::one_degenerate(degenerate_segment, ratio, a_degenerate);
Chris@101:     }
Chris@16: 
Chris@101:     template <typename ProjCoord1, typename ProjCoord2>
Chris@101:     static inline int position_value(ProjCoord1 const& ca1,
Chris@101:                                      ProjCoord2 const& cb1,
Chris@101:                                      ProjCoord2 const& cb2)
Chris@101:     {
Chris@101:         // S1x  0   1    2     3   4
Chris@101:         // S2       |---------->
Chris@101:         return math::equals(ca1, cb1) ? 1
Chris@101:              : math::equals(ca1, cb2) ? 3
Chris@101:              : cb1 < cb2 ?
Chris@101:                 ( ca1 < cb1 ? 0
Chris@101:                 : ca1 > cb2 ? 4
Chris@101:                 : 2 )
Chris@101:               : ( ca1 > cb1 ? 0
Chris@101:                 : ca1 < cb2 ? 4
Chris@101:                 : 2 );
Chris@16:     }
Chris@16: };
Chris@16: 
Chris@16: 
Chris@16: }} // namespace strategy::intersection
Chris@16: 
Chris@16: }} // namespace boost::geometry
Chris@16: 
Chris@16: 
Chris@16: #endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_INTERSECTION_HPP