@@ -107,7 +107,7 @@ struct ring_area
         auto const end = boost::end(view);
 
         strategy_type const strategy = strategies.area(ring);
-        typename strategy_type::template state<Ring> state;        
+        typename strategy_type::template state<Ring> state;
 
         for (auto previous = it++; it != end; ++previous, ++it)
         {
 
@@ -231,7 +231,7 @@ struct assign
         concepts::check<Geometry1>();
         concepts::check<Geometry2 const>();
         concepts::check_concepts_and_equal_dimensions<Geometry1, Geometry2 const>();
-            
+
         static bool const same_point_order
             = point_order<Geometry1>::value == point_order<Geometry2>::value;
         BOOST_GEOMETRY_STATIC_ASSERT(
@@ -244,23 +244,23 @@ struct assign
             same_closure,
             "Assign is not supported for different closures.",
             Geometry1, Geometry2);
-            
+
         dispatch::convert<Geometry2, Geometry1>::apply(geometry2, geometry1);
     }
 };
-    
-    
+
+
 template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
 struct assign<variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
 {
     struct visitor: static_visitor<void>
     {
         Geometry2 const& m_geometry2;
-            
+
         visitor(Geometry2 const& geometry2)
         : m_geometry2(geometry2)
         {}
-            
+
         template <typename Geometry1>
         result_type operator()(Geometry1& geometry1) const
         {
@@ -272,27 +272,27 @@ struct assign<variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
             (geometry1, m_geometry2);
         }
     };
-        
+
     static inline void
     apply(variant<BOOST_VARIANT_ENUM_PARAMS(T)>& geometry1,
           Geometry2 const& geometry2)
     {
         return boost::apply_visitor(visitor(geometry2), geometry1);
     }
 };
-    
-    
+
+
 template <typename Geometry1, BOOST_VARIANT_ENUM_PARAMS(typename T)>
 struct assign<Geometry1, variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
 {
     struct visitor: static_visitor<void>
     {
         Geometry1& m_geometry1;
-            
+
         visitor(Geometry1 const& geometry1)
         : m_geometry1(geometry1)
         {}
-            
+
         template <typename Geometry2>
         result_type operator()(Geometry2 const& geometry2) const
         {
@@ -304,16 +304,16 @@ struct assign<Geometry1, variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
             (m_geometry1, geometry2);
         }
     };
-        
+
     static inline void
     apply(Geometry1& geometry1,
           variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry2)
     {
         return boost::apply_visitor(visitor(geometry1), geometry2);
     }
 };
-    
-    
+
+
 template <BOOST_VARIANT_ENUM_PARAMS(typename T1), BOOST_VARIANT_ENUM_PARAMS(typename T2)>
 struct assign<variant<BOOST_VARIANT_ENUM_PARAMS(T1)>, variant<BOOST_VARIANT_ENUM_PARAMS(T2)> >
 {
@@ -332,17 +332,17 @@ struct assign<variant<BOOST_VARIANT_ENUM_PARAMS(T1)>, variant<BOOST_VARIANT_ENUM
             (geometry1, geometry2);
         }
     };
-        
+
     static inline void
     apply(variant<BOOST_VARIANT_ENUM_PARAMS(T1)>& geometry1,
           variant<BOOST_VARIANT_ENUM_PARAMS(T2)> const& geometry2)
     {
         return boost::apply_visitor(visitor(), geometry1, geometry2);
     }
 };
-    
+
 } // namespace resolve_variant
-    
+
 
 /*!
 \brief Assigns one geometry to another geometry
 
@@ -40,7 +40,7 @@ namespace boost { namespace geometry
 #ifndef DOXYGEN_NO_DETAIL
 namespace detail
 {
-       
+
 } // namespace detail
 #endif // DOXYGEN_NO_DETAIL
 
@@ -183,7 +183,7 @@ inline auto azimuth(Point1 const& point1, Point2 const& point2)
 {
     concepts::check<Point1 const>();
     concepts::check<Point2 const>();
-    
+
     return resolve_strategy::azimuth
             <
                 default_strategy
 
@@ -218,15 +218,15 @@ struct centroid_range
         {
             // prepare translation transformer
             translating_transformer<Range> transformer(*boost::begin(range));
-            
+
             typename Strategy::template state_type
                 <
                     typename geometry::point_type<Range>::type,
                     Point
                 >::type state;
 
             centroid_range_state::apply(range, transformer, strategy, state);
-            
+
             if ( strategy.result(state, centroid) )
             {
                 // translate the result back
@@ -277,15 +277,15 @@ struct centroid_polygon
             // prepare translation transformer
             translating_transformer<Polygon>
                 transformer(*boost::begin(exterior_ring(poly)));
-            
+
             typename Strategy::template state_type
                 <
                     typename geometry::point_type<Polygon>::type,
                     Point
                 >::type state;
 
             centroid_polygon_state::apply(poly, transformer, strategy, state);
-            
+
             if ( strategy.result(state, centroid) )
             {
                 // translate the result back
@@ -366,7 +366,7 @@ struct centroid_multi
             transformer.apply_reverse(centroid);
             return true;
         }
-        
+
         return false;
     }
 };
 
@@ -152,7 +152,7 @@ struct range_to_range
             geometry::detail::conversion::convert_point_to_point(point1, point2);
         }
     };
-    
+
     static inline void apply(Range1 const& source, Range2& destination)
     {
         apply(source, destination, default_policy());
 
@@ -231,7 +231,7 @@ struct crosses
             >::apply(geometry1, geometry2, strategy);
     }
 };
-    
+
 
 template <typename DynamicGeometry1, typename Geometry2, typename Tag2>
 struct crosses<DynamicGeometry1, Geometry2, dynamic_geometry_tag, Tag2>
@@ -295,10 +295,10 @@ struct crosses<DynamicGeometry1, DynamicGeometry2, dynamic_geometry_tag, dynamic
     }
 };
 
-    
+
 } // namespace resolve_dynamic
-    
-    
+
+
 /*!
 \brief \brief_check2{crosses}
 \ingroup crosses
 
@@ -88,7 +88,7 @@ struct densify_range
         {
             return;
         }
-            
+
         auto strategy = strategies.densify(rng);
         push_back_policy<MutRng> policy(rng_out);
 
@@ -349,7 +349,7 @@ struct densify<default_strategy, false>
             <
                 Geometry
             >::type strategies_type;
-        
+
         dispatch::densify
             <
                 Geometry, Geometry
 
@@ -32,7 +32,7 @@ namespace detail { namespace buffer
 {
 
 
-template <typename Strategy>    
+template <typename Strategy>
 struct original_get_box
 {
     explicit original_get_box(Strategy const& strategy)
 
@@ -128,14 +128,14 @@ struct calculate_point_order_by_azimuth
         {
             // Add point
             cleaned.push_back(clean_point_t(it));
-            
+
             while (cleaned.size() >= 3)
             {
                 cleaned_iter_t it0 = cleaned.end() - 3;
                 cleaned_iter_t it1 = cleaned.end() - 2;
                 cleaned_iter_t it2 = cleaned.end() - 1;
 
-                calc_t diff;                
+                calc_t diff;
                 if (get_or_calculate_azimuths_difference(*it0, *it1, *it2, diff, strategy)
                     && ! math::equals(math::abs(diff), pi))
                 {
@@ -148,7 +148,7 @@ struct calculate_point_order_by_azimuth
                     // TODO: angles have to be invalidated only if spike is detected
                     // for duplicates it'd be ok to leave them
                     it0->set_azimuth_invalid();
-                    it0->set_azimuth_difference_invalid();                    
+                    it0->set_azimuth_difference_invalid();
                     it2->set_azimuth_difference_invalid();
                     cleaned.erase(it1);
                 }
@@ -269,7 +269,7 @@ struct calculate_point_order_by_azimuth
             razi = p0.reverse_azimuth();
             return true;
         }
-        
+
         if (strategy.apply(p0.ref(), p1.ref(), azi, razi))
         {
             p0.set_azimuths(azi, razi);
 
@@ -75,7 +75,7 @@ struct translating_transformer<Geometry, areal_tag, cartesian_tag>
 {
     typedef typename geometry::point_type<Geometry>::type point_type;
     typedef point_type result_type;
-    
+
     explicit translating_transformer(Geometry const& geom)
         : m_origin(NULL)
     {
Original file line number	Diff line number	Diff line change
`@@ -107,7 +107,7 @@ struct ring_area`
`107`	`107`	`auto const end = boost::end(view);`
`108`	`108`
`109`	`109`	`strategy_type const strategy = strategies.area(ring);`
`110`		`- typename strategy_type::template state<Ring> state;`
	`110`	`+ typename strategy_type::template state<Ring> state;`
`111`	`111`
`112`	`112`	`for (auto previous = it++; it != end; ++previous, ++it)`
`113`	`113`	`{`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ namespace boost { namespace geometry`
`40`	`40`	`#ifndef DOXYGEN_NO_DETAIL`
`41`	`41`	`namespace detail`
`42`	`42`	`{`
`43`		`-`
	`43`	`+`
`44`	`44`	`} // namespace detail`
`45`	`45`	`#endif // DOXYGEN_NO_DETAIL`
`46`	`46`
`@@ -183,7 +183,7 @@ inline auto azimuth(Point1 const& point1, Point2 const& point2)`
`183`	`183`	`{`
`184`	`184`	`concepts::check<Point1 const>();`
`185`	`185`	`concepts::check<Point2 const>();`
`186`		`-`
	`186`	`+`
`187`	`187`	`return resolve_strategy::azimuth`
`188`	`188`	`<`
`189`	`189`	`default_strategy`
Original file line number	Diff line number	Diff line change
`@@ -152,7 +152,7 @@ struct range_to_range`
`152`	`152`	`geometry::detail::conversion::convert_point_to_point(point1, point2);`
`153`	`153`	`}`
`154`	`154`	`};`
`155`		`-`
	`155`	`+`
`156`	`156`	`static inline void apply(Range1 const& source, Range2& destination)`
`157`	`157`	`{`
`158`	`158`	`apply(source, destination, default_policy());`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ struct densify_range`
`88`	`88`	`{`
`89`	`89`	`return;`
`90`	`90`	`}`
`91`		`-`
	`91`	`+`
`92`	`92`	`auto strategy = strategies.densify(rng);`
`93`	`93`	`push_back_policy<MutRng> policy(rng_out);`
`94`	`94`
`@@ -349,7 +349,7 @@ struct densify<default_strategy, false>`
`349`	`349`	`<`
`350`	`350`	`Geometry`
`351`	`351`	`>::type strategies_type;`
`352`		`-`
	`352`	`+`
`353`	`353`	`dispatch::densify`
`354`	`354`	`<`
`355`	`355`	`Geometry, Geometry`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ namespace detail { namespace buffer`
`32`	`32`	`{`
`33`	`33`
`34`	`34`
`35`		`-template <typename Strategy>`
	`35`	`+template <typename Strategy>`
`36`	`36`	`struct original_get_box`
`37`	`37`	`{`
`38`	`38`	`explicit original_get_box(Strategy const& strategy)`
Original file line number	Diff line number	Diff line change
`@@ -128,14 +128,14 @@ struct calculate_point_order_by_azimuth`
`128`	`128`	`{`
`129`	`129`	`// Add point`
`130`	`130`	`cleaned.push_back(clean_point_t(it));`
`131`		`-`
	`131`	`+`
`132`	`132`	`while (cleaned.size() >= 3)`
`133`	`133`	`{`
`134`	`134`	`cleaned_iter_t it0 = cleaned.end() - 3;`
`135`	`135`	`cleaned_iter_t it1 = cleaned.end() - 2;`
`136`	`136`	`cleaned_iter_t it2 = cleaned.end() - 1;`
`137`	`137`
`138`		`- calc_t diff;`
	`138`	`+ calc_t diff;`
`139`	`139`	`if (get_or_calculate_azimuths_difference(it0, it1, *it2, diff, strategy)`
`140`	`140`	`&& ! math::equals(math::abs(diff), pi))`
`141`	`141`	`{`
`@@ -148,7 +148,7 @@ struct calculate_point_order_by_azimuth`
`148`	`148`	`// TODO: angles have to be invalidated only if spike is detected`
`149`	`149`	`// for duplicates it'd be ok to leave them`
`150`	`150`	`it0->set_azimuth_invalid();`
`151`		`- it0->set_azimuth_difference_invalid();`
	`151`	`+ it0->set_azimuth_difference_invalid();`
`152`	`152`	`it2->set_azimuth_difference_invalid();`
`153`	`153`	`cleaned.erase(it1);`
`154`	`154`	`}`
`@@ -269,7 +269,7 @@ struct calculate_point_order_by_azimuth`
`269`	`269`	`razi = p0.reverse_azimuth();`
`270`	`270`	`return true;`
`271`	`271`	`}`
`272`		`-`
	`272`	`+`
`273`	`273`	`if (strategy.apply(p0.ref(), p1.ref(), azi, razi))`
`274`	`274`	`{`
`275`	`275`	`p0.set_azimuths(azi, razi);`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ struct translating_transformer<Geometry, areal_tag, cartesian_tag>`
`75`	`75`	`{`
`76`	`76`	`typedef typename geometry::point_type<Geometry>::type point_type;`
`77`	`77`	`typedef point_type result_type;`
`78`		`-`
	`78`	`+`
`79`	`79`	`explicit translating_transformer(Geometry const& geom)`
`80`	`80`	`: m_origin(NULL)`
`81`	`81`	`{`