[Boost-commit] svn:boost r68226 - trunk/boost/geometry/extensions/algorithms

Subject: [Boost-commit] svn:boost r68226 - trunk/boost/geometry/extensions/algorithms
From: barend.gehrels_at_[hidden]
Date: 2011-01-18 07:57:27

Author: barendgehrels
Date: 2011-01-18 07:57:25 EST (Tue, 18 Jan 2011)
New Revision: 68226
URL: http://svn.boost.org/trac/boost/changeset/68226

Log:
Reimplemented remove_spikes by first marking and after that removing, the algorithm is also changed.
This can not only remove "spikes" but also larger indentations, exdentations (intrusions/extrusions).
We need the marking to check before if there are spikes.
(Note: this is payed-project-related work)

Plus small trailing needs for model:: namespace here
Added:
   trunk/boost/geometry/extensions/algorithms/mark_spikes.hpp   (contents, props changed)
   trunk/boost/geometry/extensions/algorithms/remove_marked.hpp   (contents, props changed)
Text files modified: 
   trunk/boost/geometry/extensions/algorithms/offset.hpp        |     2 +-                                      
   trunk/boost/geometry/extensions/algorithms/remove_spikes.hpp |     4 +++-                                    
   2 files changed, 4 insertions(+), 2 deletions(-)

Added: trunk/boost/geometry/extensions/algorithms/mark_spikes.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/geometry/extensions/algorithms/mark_spikes.hpp	2011-01-18 07:57:25 EST (Tue, 18 Jan 2011)
@@ -0,0 +1,513 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+//
+// Copyright Barend Gehrels 2011, Geodan, Amsterdam, the Netherlands.
+// 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_EXTENSIONS_ALGORITHMS_MARK_SPIKES_HPP
+#define BOOST_GEOMETRY_EXTENSIONS_ALGORITHMS_MARK_SPIKES_HPP
+
+#include <algorithm>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/multi/core/tags.hpp>
+
+
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/strategies/cartesian/distance_pythagoras.hpp>
+#include <boost/geometry/strategies/cartesian/area_by_triangles.hpp>
+#include <boost/geometry/util/math.hpp>
+
+#include <boost/geometry/algorithms/detail/sections/sectionalize.hpp>
+
+#include <boost/geometry/algorithms/area.hpp>
+#include <boost/geometry/algorithms/buffer.hpp>
+#include <boost/geometry/algorithms/distance.hpp>
+#include <boost/geometry/algorithms/perimeter.hpp>
+
+
+/*
+Mark spikes in a ring/polygon.
+Ring
++---------+
+|         |
+|         |
+|   +=====  ^this "indentation" or "intrusion" or "spikey feature" is marked
+|   ||    |
+|   ||    |
+|   ++    |
++---------+
+(the actualy determination if it is marked is done by a policy)
+(things are only marked, removal is done afterwards)
+
+*/
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace mark_spikes
+{
+
+template <typename Range, typename Iterator>
+inline Iterator circular_next(Range const& range, Iterator it)
+{
+    ++it;
+    if (it == boost::end(range))
+    {
+        it = boost::begin(range);
+    }
+    return it;
+}
+
+inline std::size_t circular_next_i(std::size_t i, std::size_t const n)
+{
+    if (++i == n)
+    {
+        i = 0;
+    }
+    return i;
+}
+
+
+// Calculate the distance over the ring, in the range [it1 .. it2]
+// if it1 < it2: walk from it1 .. it2
+// if it1 > it2: walk from it1 .. end(ring) and from begin(ring) to it2
+// Do NOT call this using begin(ring), end(ring) or 0.0 will be returned
+template
+<
+    typename Range,
+    typename Iterator,
+    typename AreaStrategy,
+    typename DistanceStrategy
+>
+inline void part_area_and_perimeter(Range const& range,
+            Iterator it1, Iterator it2,
+            AreaStrategy const& area_strategy,
+            DistanceStrategy const& distance_strategy,
+            double& area, double& perimeter, int& count)
+{
+    perimeter = 0;
+    area = 0;
+    count = 0;
+    if (it1 == boost::end(range) || it2 == boost::end(range) || it1 == it2)
+    {
+        return;
+    }
+
+    typename AreaStrategy::state_type area_state;
+    Iterator it = circular_next(range, it1), previous = it1;
+    Iterator end = circular_next(range, it2);
+    while (it != end)
+    {
+        area_strategy.apply(*previous, *it, area_state);
+        perimeter += distance_strategy.apply(*previous, *it);
+        previous = it;
+        it = circular_next(range, it);
+        count++;
+    }
+
+    // Close the ring, for area
+    area_strategy.apply(*it2, *it1, area_state);
+    // Do the same for distance to get correct ratio (though this might be discussed)
+    perimeter += distance_strategy.apply(*it2, *it1);
+
+    area = abs(area_strategy.result(area_state));
+}
+
+
+template <typename Iterator>
+struct helper
+{
+    helper(int i1, int i2, Iterator t1, Iterator t2,
+        double g, double a, double p, int c)
+        : index1(i1)
+        , index2(i2)
+        , it1(t1)
+        , it2(t2)
+        , gap_distance(g)
+        , area(a)
+        , perimeter(p)
+        , count(c)
+    {
+    }
+
+    int index1, index2;
+    Iterator it1, it2;
+    double area, perimeter, gap_distance;
+    int count;
+
+    inline bool operator<(helper<Iterator> const& other) const
+    {
+        return this->count > other.count;
+    }
+};
+
+
+template <typename Range, typename MarkMap, typename Policy>
+struct range_mark_spikes
+{
+    typedef typename point_type<Range>::type point_type;
+
+    typedef typename strategy_side
+    <
+        typename cs_tag<Range>::type
+    >::type side_strategy_type;
+
+    typedef typename strategy::area::services::default_strategy
+        <
+            typename cs_tag<point_type>::type,
+            point_type
+        >::type area_strategy_type;
+
+    typedef typename strategy::distance::services::default_strategy
+        <
+            point_tag,
+            point_type,
+            point_type
+        >::type distance_strategy_type;
+
+    static inline void apply(Range const& range, ring_identifier id, 
+                    MarkMap& mark_map, Policy const& policy)
+    {
+        std::size_t const n = boost::size(range);
+        if (n < 5)
+        {
+            return;
+        }
+
+        typedef typename boost::range_iterator<Range const>::type iterator_type;
+
+        // Divide polygon in monotonic sections (in two directions)
+        typedef model::box<point_type> box_type;
+        typedef boost::geometry::sections<box_type, 2> sections_type;
+        sections_type sections;
+        boost::geometry::sectionalize<false>(range, sections);
+
+        for (typename boost::range_iterator<sections_type>::type it = boost::begin(sections);
+            it != boost::end(sections);
+            ++it)
+        {
+            // Enlarge each box with the wished max with of the gap to be sure that
+            // when walking through sections all point-pairs are considered
+            boost::geometry::buffer(it->bounding_box, it->bounding_box, policy.gap_width() * 1.001);
+        }
+
+        double const whole_area = geometry::area(range);
+
+
+        typedef typename boost::range_iterator<sections_type>::type section_iterator_type;
+
+
+        // Find pair-of-points lying the most close to each other,
+        // where:
+        // - it is in another section
+        // - the distance over the ring-part is larger than X
+        // - the area of the polygon formed by that ring-part smaller than X
+
+        typedef helper<iterator_type> helper_type;
+        typedef std::vector<helper_type> helper_vector_type;
+        helper_vector_type candidates;
+
+        // Quadratic loop over all sections (note this normally does not result in a quadratic loop
+        // over all points).
+        for(section_iterator_type sit1 = boost::begin(sections); sit1 != boost::end(sections); ++sit1)
+        {
+            // Note, even though combination sit1/sit2 is handled, the combination sit2/sit1 travels
+            // another part over the ring and should be handled as well
+            for(section_iterator_type sit2 = boost::begin(sections); sit2 != boost::end(sections); ++sit2)
+            {
+                if (sit1->id != sit2->id
+                    && ! geometry::disjoint(sit1->bounding_box, sit2->bounding_box))
+                {
+                    // Check all point combinations in these boxes
+                    int index1 = sit1->begin_index;
+                    iterator_type it1 = boost::begin(range) + sit1->begin_index;
+                    for (unsigned int i = 0; i < sit1->count; i++, ++it1, ++index1)
+                    {
+                        iterator_type it2 = boost::begin(range) + sit2->begin_index;
+                        int index2 = sit2->begin_index;
+                        for (unsigned int j = 0; j < sit2->count; j++, ++it2, ++index2)
+                        {
+                            double dg = geometry::distance(*it1, *it2);
+                            if (dg < policy.gap_width())
+                            {
+                                double area, perimeter;
+                                int count;
+                                part_area_and_perimeter(range, it1, it2,
+                                    area_strategy_type(), distance_strategy_type(),
+                                    area, perimeter, count);
+
+                                if (count >= 2
+                                    && policy.apply(dg, whole_area, count, area, perimeter))
+                                {
+                                    candidates.push_back(
+                                        helper_type(index1, index2, it1, it2, dg, area, perimeter, count));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if (boost::size(candidates) == 0)
+        {
+            return;
+        }
+
+        std::sort(candidates.begin(), candidates.end());
+
+        /***
+        if (boost::size(candidates) > 1)
+        {
+
+            // Remove overlaps
+            bool first = true;
+            typename boost::range_iterator<helper_vector_type>::type it = boost::begin(candidates);
+            typename boost::range_iterator<helper_vector_type>::type prev = it;
+            ++it;
+            while (it != boost::end(candidates))
+            {
+
+                if ((it->index1 >= prev->index1 && it->index2 <= prev->index2)
+
+                    )
+                {
+                    candidates.erase(it);
+                    it = prev + 1;
+                }
+                else
+                {
+                    prev = it;
+                }
+            }
+        }
+        ***/
+
+        // Check if some index combinations refer to larger combinations
+#if defined(BOOST_GEOMETRY_DEBUG_MARK_SPIKES)
+        for(typename boost::range_iterator<helper_vector_type>::type it
+            = boost::begin(candidates); it != boost::end(candidates); ++it)
+        {
+            std::cout << it->count << " " << it->index1 << " " << it->index2
+                << " gd=" << it->gap_distance
+                << " a=" << it->area << " p=" << it->perimeter
+                << " r=" << (it->perimeter > 0 ? it->area / it->perimeter : 0)
+                // << " p1=" << geometry::wkt(*it->it1) << " p2=" << geometry::wkt(*it->it2)
+                << std::endl;
+        }
+#endif
+
+        typedef typename MarkMap::mapped_type bit_vector_type;
+
+        // Add new vector to map if necessary
+        if (mark_map.find(id) == mark_map.end())
+        {
+            // Add one to vector
+            mark_map[id] = bit_vector_type();
+
+            // Initialize it
+            bit_vector_type& bits = mark_map[id];
+            for (std::size_t i = 0; i < n; i++)
+            {
+                bits.push_back(false);
+            }
+        }
+
+        bit_vector_type& bits = mark_map[id];
+
+        // Mark this range or these ranges
+        // TODO: we might use the fact that it is sorted and that ranges are inside others,
+        // so skip those...
+        for(typename boost::range_iterator<helper_vector_type const>::type it
+            = boost::begin(candidates); it != boost::end(candidates); ++it)
+        {
+            iterator_type pit = boost::begin(range) + it->index1;
+            iterator_type end = boost::begin(range) + it->index2;
+            int i = it->index1;
+            while (pit != end)
+            {
+                if (i != it->index1 && i != it->index2)
+                {
+                    bits[i] = true;                                        
+                }
+                pit = circular_next(range, pit);
+                i = circular_next_i(i, n);
+            }
+        }
+    }
+};
+
+
+template <typename Polygon, typename MarkMap, typename Policy>
+struct polygon_mark_spikes
+{
+    static inline void apply(Polygon const& polygon, ring_identifier id, 
+                    MarkMap& mark_map, Policy const& policy)
+    {
+        typedef typename geometry::ring_type<Polygon>::type ring_type;
+
+        typedef range_mark_spikes<ring_type, MarkMap, Policy> per_range;
+
+        // Exterior ring (-1)
+        id.ring_index = -1;
+        per_range::apply(exterior_ring(polygon), id, mark_map, policy);
+
+        typename interior_return_type<Polygon const>::type rings
+                    = interior_rings(polygon);
+        for (BOOST_AUTO(it, boost::begin(rings)); it != boost::end(rings); ++it)
+        {
+            // Interior ring (zero based)
+            id.ring_index++;
+            per_range::apply(*it, id, mark_map, policy);
+        }
+    }
+};
+
+
+template <typename MultiGeometry, typename MarkMap, typename Policy, typename SinglePolicy>
+struct multi_mark_spikes
+{
+    static inline void apply(MultiGeometry const& multi, ring_identifier id, 
+                    MarkMap& mark_map, Policy const& policy)
+    {
+        id.multi_index = 0;
+        for (typename boost::range_iterator<MultiGeometry const>::type
+                it = boost::begin(multi);
+            it != boost::end(multi);
+            ++it)
+        {
+            SinglePolicy::apply(*it, id, mark_map, policy);
+            id.multi_index++;
+        }
+    }
+};
+
+
+}} // namespace detail::mark_spikes
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template
+<
+    typename Tag,
+    typename Geometry,
+    typename MarkMap,
+    typename Policy
+>
+struct mark_spikes
+{
+    static inline void apply(Geometry&, Policy const&)
+    {}
+};
+
+
+template <typename Ring, typename MarkMap, typename Policy>
+struct mark_spikes<ring_tag, Ring, MarkMap, Policy>
+    : detail::mark_spikes::range_mark_spikes<Ring, MarkMap, Policy>
+{};
+
+
+
+template <typename Polygon, typename MarkMap, typename Policy>
+struct mark_spikes<polygon_tag, Polygon, MarkMap, Policy>
+    : detail::mark_spikes::polygon_mark_spikes<Polygon, MarkMap, Policy>
+{};
+
+
+template <typename MultiPolygon, typename MarkMap, typename Policy>
+struct mark_spikes<multi_polygon_tag, MultiPolygon, MarkMap, Policy>
+    : detail::mark_spikes::multi_mark_spikes
+        <
+            MultiPolygon,
+            MarkMap,
+            Policy,
+            detail::mark_spikes::polygon_mark_spikes
+            <
+                typename boost::range_value<MultiPolygon>::type,
+                MarkMap,
+                Policy
+            >
+        >
+{};
+
+
+
+} // namespace dispatch
+#endif
+
+
+/*!
+    \ingroup mark_spikes
+    \tparam Geometry geometry type
+    \param geometry the geometry to make mark_spikes
+*/
+template <typename Geometry, typename MarkMap, typename Policy>
+inline bool mark_spikes(Geometry const& geometry, 
+        MarkMap& mark_map,                            
+        Policy const& policy)
+{
+    concept::check<Geometry const>();
+
+    ring_identifier id;
+
+    dispatch::mark_spikes
+        <
+            typename tag<Geometry>::type,
+            Geometry,
+            MarkMap,
+            Policy
+        >::apply(geometry, id, mark_map, policy);
+    return mark_map.size() > 0;
+}
+
+template <typename T = double>
+class select_gapped_spike
+{
+public :
+    inline select_gapped_spike(T const gap_width, T const ratio = 0.1)
+        : m_gap_width(gap_width)
+        , m_ratio(ratio)
+    {}
+
+
+    inline T gap_width() const
+    {
+        return m_gap_width;
+    }
+
+    inline bool apply(T const gap_distance, T const whole_area, 
+                int count, T const area, T const perimeter) const
+    {
+        T const ratio = perimeter == 0 ? 0 : area / perimeter;
+        return 
+            perimeter > gap_distance
+            && area < whole_area / 10.0
+            && ratio < m_ratio;
+    }
+
+
+private :
+    T m_gap_width;
+    T m_ratio;
+};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_EXTENSIONS_ALGORITHMS_MARK_SPIKES_HPP

Modified: trunk/boost/geometry/extensions/algorithms/offset.hpp
==============================================================================
--- trunk/boost/geometry/extensions/algorithms/offset.hpp	(original)
+++ trunk/boost/geometry/extensions/algorithms/offset.hpp	2011-01-18 07:57:25 EST (Tue, 18 Jan 2011)
@@ -38,7 +38,7 @@
 {
     typedef typename coordinate_type<RangeOut>::type coordinate_type;
     typedef typename point_type<RangeOut>::type output_point_type;
-    typedef segment<output_point_type const> segment_type;
+    typedef model::referring_segment<output_point_type const> segment_type;
     typedef typename boost::range_iterator<Range const>::type iterator_type;
 
     static inline void apply(Range const& range, 

Added: trunk/boost/geometry/extensions/algorithms/remove_marked.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/geometry/extensions/algorithms/remove_marked.hpp	2011-01-18 07:57:25 EST (Tue, 18 Jan 2011)
@@ -0,0 +1,220 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+//
+// Copyright Barend Gehrels 2011, Geodan, Amsterdam, the Netherlands.
+// 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_EXTENSIONS_ALGORITHMS_REMOVE_MARKED_HPP
+#define BOOST_GEOMETRY_EXTENSIONS_ALGORITHMS_REMOVE_MARKED_HPP
+
+
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/multi/core/tags.hpp>
+
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/util/math.hpp>
+
+#include <boost/geometry/algorithms/area.hpp>
+#include <boost/geometry/algorithms/distance.hpp>
+#include <boost/geometry/algorithms/perimeter.hpp>
+
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace remove_marked
+{
+
+
+template <typename Range, typename MarkMap>
+struct range_remove_marked
+{
+    typedef typename strategy_side
+    <
+        typename cs_tag<Range>::type
+    >::type side_strategy_type;
+
+    typedef typename coordinate_type<Range>::type coordinate_type;
+
+
+    static inline void apply(Range const& range_in, ring_identifier id, 
+                    Range& range_out, MarkMap const& mark_map)
+    {
+        typename MarkMap::const_iterator mit = mark_map.find(id);
+        if (mit == mark_map.end())
+        {
+            range_out = range_in;
+            return;
+        }
+        typedef typename MarkMap::mapped_type bit_vector_type;
+
+        if (boost::size(range_in) != boost::size(mit->second))
+        {
+            throw std::runtime_error("ERROR in size of mark_map");
+            return;
+        }
+
+        range_out.clear();
+
+        typename boost::range_iterator<bit_vector_type const>::type bit = boost::begin(mit->second);
+        for (typename boost::range_iterator<Range const>::type it = boost::begin(range_in);
+            it != boost::end(range_in); ++it, ++bit)
+        {
+            bool const& marked = *bit;
+            if (! marked)
+            {
+                range_out.push_back(*it);
+            }
+        }
+    }
+};
+
+
+template <typename Polygon, typename MarkMap>
+struct polygon_remove_marked
+{
+    static inline void apply(Polygon const& polygon_in, ring_identifier id, 
+                Polygon& polygon_out, MarkMap const& mark_map)
+    {
+        typedef typename geometry::ring_type<Polygon>::type ring_type;
+
+        typedef range_remove_marked<ring_type, MarkMap> per_range;
+        id.ring_index = -1;
+        per_range::apply(exterior_ring(polygon_in), id, exterior_ring(polygon_out), mark_map);
+
+
+        typename interior_return_type<Polygon const>::type rings_in
+                    = interior_rings(polygon_in);
+        typename interior_return_type<Polygon>::type rings_out
+                    = interior_rings(polygon_out);
+
+        rings_out.resize(boost::size(interior_rings(polygon_in)));
+        BOOST_AUTO(out, boost::begin(rings_out));
+
+        for (BOOST_AUTO(it, boost::begin(rings_in)); 
+            it != boost::end(rings_in); 
+            ++it, ++out)
+        {
+            id.ring_index++;
+            per_range::apply(*it, id, *out, mark_map);
+        }
+    }
+};
+
+
+template <typename MultiGeometry, typename MarkMap, typename SinglePolicy>
+struct multi_remove_marked
+{
+    static inline void apply(MultiGeometry const& multi_in, ring_identifier id, 
+                MultiGeometry& multi_out, MarkMap const& mark_map)
+    {
+        id.multi_index = 0;
+
+        multi_out.resize(boost::size(multi_in));
+
+        typename boost::range_iterator<MultiGeometry>::type out = boost::begin(multi_out);
+        for (typename boost::range_iterator<MultiGeometry const>::type
+                it = boost::begin(multi_in);
+            it != boost::end(multi_in);
+            ++it, ++out)
+        {
+            SinglePolicy::apply(*it, id, *out, mark_map);
+            id.multi_index++;
+        }
+    }
+};
+
+
+}} // namespace detail::remove_marked
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template
+<
+    typename Tag,
+    typename Geometry,
+    typename MarkMap
+>
+struct remove_marked
+{
+    static inline void apply(Geometry const&, ring_identifier, Geometry&, MarkMap const&)
+    {}
+};
+
+
+template <typename Ring, typename MarkMap>
+struct remove_marked<ring_tag, Ring, MarkMap>
+    : detail::remove_marked::range_remove_marked<Ring, MarkMap>
+{};
+
+
+
+template <typename Polygon, typename MarkMap>
+struct remove_marked<polygon_tag, Polygon, MarkMap>
+    : detail::remove_marked::polygon_remove_marked<Polygon, MarkMap>
+{};
+
+
+template <typename MultiPolygon, typename MarkMap>
+struct remove_marked<multi_polygon_tag, MultiPolygon, MarkMap>
+    : detail::remove_marked::multi_remove_marked
+        <
+            MultiPolygon,
+            MarkMap,
+            detail::remove_marked::polygon_remove_marked
+            <
+                typename boost::range_value<MultiPolygon>::type,
+                MarkMap
+            >
+        >
+{};
+
+
+
+} // namespace dispatch
+#endif
+
+
+/*!
+    \ingroup remove_marked
+    \tparam Geometry geometry type
+    \param geometry the geometry to make remove_marked
+*/
+template <typename Geometry, typename MarkMap>
+inline void remove_marked(Geometry const& geometry_in, Geometry& geometry_out,
+            MarkMap const& mark_map)
+{
+    concept::check<Geometry>();
+
+    ring_identifier id;
+    dispatch::remove_marked
+        <
+            typename tag<Geometry>::type,
+            Geometry,
+            MarkMap
+        >::apply(geometry_in, id, geometry_out, mark_map);
+}
+
+
+
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_EXTENSIONS_ALGORITHMS_REMOVE_MARKED_HPP

Modified: trunk/boost/geometry/extensions/algorithms/remove_spikes.hpp
==============================================================================
--- trunk/boost/geometry/extensions/algorithms/remove_spikes.hpp	(original)
+++ trunk/boost/geometry/extensions/algorithms/remove_spikes.hpp	2011-01-18 07:57:25 EST (Tue, 18 Jan 2011)
@@ -8,6 +8,8 @@
 #ifndef BOOST_GEOMETRY_EXTENSIONS_ALGORITHMS_REMOVE_SPIKES_HPP
 #define BOOST_GEOMETRY_EXTENSIONS_ALGORITHMS_REMOVE_SPIKES_HPP
 
+// NOTE: obsolete by "mark_spikes"
+
 #include <algorithm>
 #include <deque>
 
@@ -260,7 +262,7 @@
         coordinate_type d1 = geometry::distance(prev, current);
         if (d1 < m_distance_limit)
         {
-            geometry::linear_ring<Point> triangle;
+            geometry::model::linear_ring<Point> triangle;
             triangle.push_back(prev);
             triangle.push_back(current);
             triangle.push_back(next);