diff --git include/boost/polygon/polygon_set_data.hpp include/boost/polygon/polygon_set_data.hpp
index 41a1b59..3c761d3 100644
      
        
          
        
        
          
            | 
             | 
            
             | 
            
               namespace boost { namespace polygon {
               
             | 
          
        
        
          
            | 197 | 197 |  | 
          
          
            | 198 | 198 |     template <class iT> | 
          
          
            | 199 | 199 |     inline void insert_vertex_sequence(iT begin_vertex, iT end_vertex, direction_1d winding, bool is_hole) { | 
          
        
        
          
            | 200 |   |       bool first_iteration = true; | 
          
          
            | 201 |   |       point_type first_point; | 
          
          
            | 202 |   |       point_type previous_point; | 
          
          
            | 203 |   |       point_type current_point; | 
          
          
            | 204 |   |       direction_1d winding_dir = winding; | 
          
          
            | 205 |   |       int multiplier = winding_dir == COUNTERCLOCKWISE ? 1 : -1; | 
          
          
            | 206 |   |       if(is_hole) multiplier *= -1; | 
          
          
            | 207 |   |       for( ; begin_vertex != end_vertex; ++begin_vertex) { | 
          
          
            | 208 |   |         assign(current_point, *begin_vertex); | 
          
          
            | 209 |   |         if(first_iteration) { | 
          
          
            | 210 |   |           first_iteration = false; | 
          
          
            | 211 |   |           first_point = previous_point = current_point; | 
          
          
            | 212 |   |         } else { | 
          
          
            | 213 |   |           if(previous_point != current_point) { | 
          
          
            | 214 |   |             element_type elem(edge_type(previous_point, current_point), | 
          
          
            | 215 |   |                               ( previous_point.get(HORIZONTAL) == current_point.get(HORIZONTAL) ? -1 : 1) * multiplier); | 
          
          
            | 216 |   |             insert_clean(elem); | 
          
          
            | 217 |   |           } | 
          
          
            | 218 |   |         } | 
          
          
            | 219 |   |         previous_point = current_point; | 
          
          
            |   | 200 |       if (begin_vertex == end_vertex) { | 
          
          
            |   | 201 |         // No edges to insert. | 
          
          
            |   | 202 |         return; | 
          
          
            |   | 203 |       } | 
          
          
            |   | 204 |       // Current edge endpoints. | 
          
          
            |   | 205 |       iT vertex0 = begin_vertex; | 
          
          
            |   | 206 |       iT vertex1 = begin_vertex; | 
          
          
            |   | 207 |       if (++vertex1 == end_vertex) { | 
          
          
            |   | 208 |         // No edges to insert. | 
          
          
            |   | 209 |         return; | 
          
        
        
          
            | 220 | 210 |       } | 
          
        
        
          
            | 221 |   |       current_point = first_point; | 
          
          
            | 222 |   |       if(!first_iteration) { | 
          
          
            | 223 |   |         if(previous_point != current_point) { | 
          
          
            | 224 |   |           element_type elem(edge_type(previous_point, current_point), | 
          
          
            | 225 |   |                             ( previous_point.get(HORIZONTAL) == current_point.get(HORIZONTAL) ? -1 : 1) * multiplier); | 
          
          
            |   | 211 |       int wmultiplier = (winding == COUNTERCLOCKWISE) ? 1 : -1; | 
          
          
            |   | 212 |       dirty_ = true; | 
          
          
            |   | 213 |       unsorted_ = true; | 
          
          
            |   | 214 |       while (vertex0 != end_vertex) { | 
          
          
            |   | 215 |         point_type p0, p1; | 
          
          
            |   | 216 |         assign(p0, *vertex0); | 
          
          
            |   | 217 |         assign(p1, *vertex1); | 
          
          
            |   | 218 |         if (p0 != p1) { | 
          
          
            |   | 219 |           int hmultiplier = (p0.get(HORIZONTAL) == p1.get(HORIZONTAL)) ? -1 : 1; | 
          
          
            |   | 220 |           element_type elem(edge_type(p0, p1), hmultiplier * wmultiplier); | 
          
        
        
          
            | 226 | 221 |           insert_clean(elem); | 
          
          
            | 227 | 222 |         } | 
          
        
        
          
            | 228 |   |         dirty_ = true; | 
          
          
            | 229 |   |         unsorted_ = true; | 
          
          
            |   | 223 |         ++vertex0; | 
          
          
            |   | 224 |         ++vertex1; | 
          
          
            |   | 225 |         if (vertex1 == end_vertex) { | 
          
          
            |   | 226 |           vertex1 = begin_vertex; | 
          
          
            |   | 227 |         } | 
          
        
        
          
            | 230 | 228 |       } | 
          
          
            | 231 | 229 |     } | 
          
          
            | 232 | 230 |  | 
          
        
        
          
            | … | 
            … | 
            
               namespace boost { namespace polygon {
               
             | 
          
        
        
          
            | 271 | 269 |  | 
          
          
            | 272 | 270 |     // equivalence operator | 
          
          
            | 273 | 271 |     inline bool operator==(const polygon_set_data& p) const; | 
          
        
        
          
            | 274 |   |      | 
          
          
            |   | 272 |  | 
          
        
        
          
            | 275 | 273 |     // inequivalence operator | 
          
          
            | 276 | 274 |     inline bool operator!=(const polygon_set_data& p) const { | 
          
          
            | 277 | 275 |       return !((*this) == p); |