diff --git a/include/boost/polygon/detail/boolean_op.hpp b/include/boost/polygon/detail/boolean_op.hpp
index d3e3614..70ca4a9 100644
--- a/include/boost/polygon/detail/boolean_op.hpp
+++ b/include/boost/polygon/detail/boolean_op.hpp
@@ -381,7 +381,7 @@ namespace boolean_op {
   }
 
   template <typename Unit>
-  inline void applyUnaryXOr(std::vector<std::pair<Unit, std::pair<Unit, int> > >& input) {
+  inline void applyUnaryXOr(std::vector<std::pair<Unit, std::pair<Unit, int> > >& ) {
     BooleanOp<UnaryCount, Unit> booleanXOr;
 
   }
diff --git a/include/boost/polygon/detail/boolean_op_45.hpp b/include/boost/polygon/detail/boolean_op_45.hpp
index b2130ce..9930072 100644
--- a/include/boost/polygon/detail/boolean_op_45.hpp
+++ b/include/boost/polygon/detail/boolean_op_45.hpp
@@ -272,12 +272,12 @@ namespace boost { namespace polygon{
       inline Vertex45T(const Vertex45T& vertex) : pt(vertex.pt), rise(vertex.rise), count(vertex.count) {}
       inline Vertex45T& operator=(const Vertex45T& vertex){
         pt = vertex.pt; rise = vertex.rise; count = vertex.count; return *this; }
-      inline Vertex45T(const std::pair<Point, Point>& vertex) : pt(), rise(), count() {}
-      inline Vertex45T& operator=(const std::pair<Point, Point>& vertex){ return *this; }
+      inline Vertex45T(const std::pair<Point, Point>& ) : pt(), rise(), count() {}
+      inline Vertex45T& operator=(const std::pair<Point, Point>& ){ return *this; }
       inline bool operator==(const Vertex45T& vertex) const {
         return pt == vertex.pt && rise == vertex.rise && count == vertex.count; }
       inline bool operator!=(const Vertex45T& vertex) const { return !((*this) == vertex); }
-      inline bool operator==(const std::pair<Point, Point>& vertex) const { return false; }
+      inline bool operator==(const std::pair<Point, Point>& ) const { return false; }
       inline bool operator!=(const std::pair<Point, Point>& vertex) const { return !((*this) == vertex); }
       inline bool operator<(const Vertex45T& vertex) const {
         if(pt.x() < vertex.pt.x()) return true;
diff --git a/include/boost/polygon/detail/polygon_45_formation.hpp b/include/boost/polygon/detail/polygon_45_formation.hpp
index 2e16570..030aecc 100644
--- a/include/boost/polygon/detail/polygon_45_formation.hpp
+++ b/include/boost/polygon/detail/polygon_45_formation.hpp
@@ -506,7 +506,7 @@ namespace boost { namespace polygon{
       inline bool operator==(const Vertex45CompactT& vertex) const {
         return pt == vertex.pt && count == vertex.count; }
       inline bool operator!=(const Vertex45CompactT& vertex) const { return !((*this) == vertex); }
-      inline bool operator==(const std::pair<Point, Point>& vertex) const { return false; }
+      inline bool operator==(const std::pair<Point, Point>& ) const { return false; }
       inline bool operator!=(const std::pair<Point, Point>& vertex) const { return !((*this) == vertex); }
       inline bool operator<(const Vertex45CompactT& vertex) const {
         if(pt.x() < vertex.pt.x()) return true;
@@ -2153,7 +2153,7 @@ namespace boost { namespace polygon{
     inline iterator end() const { return p_->getTail()->end(); }
     inline std::size_t size() const { return 0; }
     template<class iT>
-    inline PolyLine45HoleData& set(iT inputBegin, iT inputEnd) {
+    inline PolyLine45HoleData& set(iT , iT ) {
       return *this;
     }
   private:
@@ -2222,14 +2222,14 @@ namespace boost { namespace polygon{
     inline std::size_t size_holes() const { return 0; }
     inline std::size_t size() const { return 0; }
     template<class iT>
-    inline PolyLine45PolygonData& set(iT inputBegin, iT inputEnd) {
+    inline PolyLine45PolygonData& set(iT , iT ) {
       return *this;
     }
 
     // initialize a polygon from x,y values, it is assumed that the first is an x
     // and that the input is a well behaved polygon
     template<class iT>
-    inline PolyLine45PolygonData& set_holes(iT inputBegin, iT inputEnd) {
+    inline PolyLine45PolygonData& set_holes(iT , iT ) {
       return *this;
     }
   private:
diff --git a/include/boost/polygon/detail/polygon_90_set_view.hpp b/include/boost/polygon/detail/polygon_90_set_view.hpp
index f6ee36c..c2502d3 100644
--- a/include/boost/polygon/detail/polygon_90_set_view.hpp
+++ b/include/boost/polygon/detail/polygon_90_set_view.hpp
@@ -200,11 +200,11 @@ namespace boost { namespace polygon{
     return polygon_set.orient(); }
   template <typename ltype, typename rtype, typename op_type>
   bool polygon_90_set_traits<polygon_90_set_view<ltype, rtype, op_type> >::
-  clean(const polygon_90_set_view<ltype, rtype, op_type>& polygon_set) {
+  clean(const polygon_90_set_view<ltype, rtype, op_type>& ) {
     return true; }
   template <typename ltype, typename rtype, typename op_type>
   bool polygon_90_set_traits<polygon_90_set_view<ltype, rtype, op_type> >::
-  sorted(const polygon_90_set_view<ltype, rtype, op_type>& polygon_set) {
+  sorted(const polygon_90_set_view<ltype, rtype, op_type>& ) {
     return true; }
 
   template <typename value_type, typename arg_type>
diff --git a/include/boost/polygon/detail/polygon_arbitrary_formation.hpp b/include/boost/polygon/detail/polygon_arbitrary_formation.hpp
index 6f9eb73..2b62c6b 100644
--- a/include/boost/polygon/detail/polygon_arbitrary_formation.hpp
+++ b/include/boost/polygon/detail/polygon_arbitrary_formation.hpp
@@ -338,7 +338,7 @@ namespace boost { namespace polygon{
     };
 
     template <typename unsigned_product_type>
-    static inline void unsigned_mod(unsigned_product_type& result, int& result_sign, unsigned_product_type a, int a_sign, unsigned_product_type b, int b_sign) {
+    static inline void unsigned_mod(unsigned_product_type& result, int& result_sign, unsigned_product_type a, int a_sign, unsigned_product_type b, int ) {
       result = a % b;
       result_sign = a_sign;
     }
@@ -739,12 +739,12 @@ namespace boost { namespace polygon{
       inline vertex_half_edge(const vertex_half_edge& vertex) : pt(vertex.pt), other_pt(vertex.other_pt), count(vertex.count) {}
       inline vertex_half_edge& operator=(const vertex_half_edge& vertex){
         pt = vertex.pt; other_pt = vertex.other_pt; count = vertex.count; return *this; }
-      inline vertex_half_edge(const std::pair<Point, Point>& vertex) : pt(), other_pt(), count() {}
-      inline vertex_half_edge& operator=(const std::pair<Point, Point>& vertex){ return *this; }
+      inline vertex_half_edge(const std::pair<Point, Point>& ) : pt(), other_pt(), count() {}
+      inline vertex_half_edge& operator=(const std::pair<Point, Point>& ){ return *this; }
       inline bool operator==(const vertex_half_edge& vertex) const {
         return pt == vertex.pt && other_pt == vertex.other_pt && count == vertex.count; }
       inline bool operator!=(const vertex_half_edge& vertex) const { return !((*this) == vertex); }
-      inline bool operator==(const std::pair<Point, Point>& vertex) const { return false; }
+      inline bool operator==(const std::pair<Point, Point>& ) const { return false; }
       inline bool operator!=(const std::pair<Point, Point>& vertex) const { return !((*this) == vertex); }
       inline bool operator<(const vertex_half_edge& vertex) const {
         if(pt.get(HORIZONTAL) < vertex.pt.get(HORIZONTAL)) return true;
@@ -1284,11 +1284,11 @@ namespace boost { namespace polygon{
       inline vertex_arbitrary_compact& operator=(const vertex_arbitrary_compact& vertex){
         pt = vertex.pt; count = vertex.count; return *this; }
       //inline vertex_arbitrary_compact(const std::pair<Point, Point>& vertex) {}
-      inline vertex_arbitrary_compact& operator=(const std::pair<Point, Point>& vertex){ return *this; }
+      inline vertex_arbitrary_compact& operator=(const std::pair<Point, Point>& ){ return *this; }
       inline bool operator==(const vertex_arbitrary_compact& vertex) const {
         return pt == vertex.pt && count == vertex.count; }
       inline bool operator!=(const vertex_arbitrary_compact& vertex) const { return !((*this) == vertex); }
-      inline bool operator==(const std::pair<Point, Point>& vertex) const { return false; }
+      inline bool operator==(const std::pair<Point, Point>& ) const { return false; }
       inline bool operator!=(const std::pair<Point, Point>& vertex) const { return !((*this) == vertex); }
       inline bool operator<(const vertex_arbitrary_compact& vertex) const {
         if(pt.get(HORIZONTAL) < vertex.pt.get(HORIZONTAL)) return true;
@@ -2144,12 +2144,12 @@ namespace boost { namespace polygon{
     //inline compact_iterator_type end_compact() const { return compact_iterator_type(end()); }
     inline std::size_t size() const { return 0; }
     template<class iT>
-    inline poly_line_arbitrary_hole_data& set(iT inputBegin, iT inputEnd) {
+    inline poly_line_arbitrary_hole_data& set(iT , iT ) {
       //assert this is not called
       return *this;
     }
     template<class iT>
-    inline poly_line_arbitrary_hole_data& set_compact(iT inputBegin, iT inputEnd) {
+    inline poly_line_arbitrary_hole_data& set_compact(iT , iT ) {
       //assert this is not called
       return *this;
     }
@@ -2220,15 +2220,15 @@ namespace boost { namespace polygon{
     inline std::size_t size_holes() const { return 0; }
     inline std::size_t size() const { return 0; }
     template<class iT>
-    inline poly_line_arbitrary_polygon_data& set(iT inputBegin, iT inputEnd) {
+    inline poly_line_arbitrary_polygon_data& set(iT , iT ) {
       return *this;
     }
     template<class iT>
-    inline poly_line_arbitrary_polygon_data& set_compact(iT inputBegin, iT inputEnd) {
+    inline poly_line_arbitrary_polygon_data& set_compact(iT , iT ) {
       return *this;
     }
     template<class iT>
-    inline poly_line_arbitrary_polygon_data& set_holes(iT inputBegin, iT inputEnd) {
+    inline poly_line_arbitrary_polygon_data& set_holes(iT , iT ) {
       return *this;
     }
   };
diff --git a/include/boost/polygon/detail/polygon_formation.hpp b/include/boost/polygon/detail/polygon_formation.hpp
index be2f543..7342fef 100644
--- a/include/boost/polygon/detail/polygon_formation.hpp
+++ b/include/boost/polygon/detail/polygon_formation.hpp
@@ -617,11 +617,11 @@ namespace polygon_formation {
     }
     inline ActiveTail<Unit>* yield() { return p_; }
     template<class iT>
-    inline PolyLineHoleData& set(iT inputBegin, iT inputEnd) {
+    inline PolyLineHoleData& set(iT , iT ) {
       return *this;
     }
     template<class iT>
-    inline PolyLineHoleData& set_compact(iT inputBegin, iT inputEnd) {
+    inline PolyLineHoleData& set_compact(iT , iT ) {
       return *this;
     }
    
@@ -677,18 +677,18 @@ namespace polygon_formation {
     inline std::size_t size_holes() const { return 0; }
     inline std::size_t size() const { return 0; }
     template<class iT>
-    inline PolyLinePolygonWithHolesData& set(iT inputBegin, iT inputEnd) {
+    inline PolyLinePolygonWithHolesData& set(iT , iT ) {
       return *this;
     }
     template<class iT>
-    inline PolyLinePolygonWithHolesData& set_compact(iT inputBegin, iT inputEnd) {
+    inline PolyLinePolygonWithHolesData& set_compact(iT , iT ) {
       return *this;
     }
    
     // initialize a polygon from x,y values, it is assumed that the first is an x
     // and that the input is a well behaved polygon
     template<class iT>
-    inline PolyLinePolygonWithHolesData& set_holes(iT inputBegin, iT inputEnd) {
+    inline PolyLinePolygonWithHolesData& set_holes(iT , iT ) {
       return *this;
     }
   };
diff --git a/include/boost/polygon/detail/property_merge.hpp b/include/boost/polygon/detail/property_merge.hpp
index b0c843b..3f4dc17 100644
--- a/include/boost/polygon/detail/property_merge.hpp
+++ b/include/boost/polygon/detail/property_merge.hpp
@@ -509,7 +509,7 @@ private:
   }
 
   template <typename T, typename T2>
-  inline void writeGraph(coordinate_type x, T& graph, edge_property_vector& output, T2& scanline) {
+  inline void writeGraph(coordinate_type , T& graph, edge_property_vector& output, T2& scanline) {
     if(output.empty()) return;
     edge_property* previousEdgeP = &(output[0]);
     bool firstIteration = true;
diff --git a/include/boost/polygon/detail/scan_arbitrary.hpp b/include/boost/polygon/detail/scan_arbitrary.hpp
index cee2331..8b06724 100644
--- a/include/boost/polygon/detail/scan_arbitrary.hpp
+++ b/include/boost/polygon/detail/scan_arbitrary.hpp
@@ -1641,7 +1641,7 @@ namespace boost { namespace polygon{
 
     template <typename polygon_with_holes_type>
     void insert(const polygon_with_holes_type& polygon_with_holes_object, const property_type& property_value, bool is_hole,
-                polygon_with_holes_concept tag) {
+                polygon_with_holes_concept ) {
       insert(polygon_with_holes_object, property_value, is_hole, polygon_concept());
       for(typename polygon_with_holes_traits<polygon_with_holes_type>::iterator_holes_type itr =
             begin_holes(polygon_with_holes_object);
diff --git a/include/boost/polygon/polygon_90_set_data.hpp b/include/boost/polygon/polygon_90_set_data.hpp
index 305aa3e..e0a1f9b 100644
--- a/include/boost/polygon/polygon_90_set_data.hpp
+++ b/include/boost/polygon/polygon_90_set_data.hpp
@@ -46,7 +46,7 @@ namespace boost { namespace polygon{
 
     // constructor from an iterator pair over vertex data
     template <typename iT>
-    inline polygon_90_set_data(orientation_2d orient, iT input_begin, iT input_end) :
+    inline polygon_90_set_data(orientation_2d , iT input_begin, iT input_end) :
       orient_(HORIZONTAL), data_(), dirty_(false), unsorted_(false) {
       dirty_ = true;
       unsorted_ = true;
@@ -119,7 +119,7 @@ namespace boost { namespace polygon{
     }
 
     inline void insert(const std::pair<std::pair<point_data<coordinate_type>, point_data<coordinate_type> >, int>& edge, bool is_hole = false,
-                       orientation_2d orient = HORIZONTAL) {
+                       orientation_2d = HORIZONTAL) {
       std::pair<coordinate_type, std::pair<coordinate_type, int> > vertex;
       vertex.first = edge.first.first.x();
       vertex.second.first = edge.first.first.y();
diff --git a/include/boost/polygon/polygon_set_data.hpp b/include/boost/polygon/polygon_set_data.hpp
index 9c6420d..dc05736 100644
--- a/include/boost/polygon/polygon_set_data.hpp
+++ b/include/boost/polygon/polygon_set_data.hpp
@@ -399,7 +399,7 @@ namespace boost { namespace polygon {
     }
 
     template <typename scaling_type>
-    inline polygon_set_data& scale(polygon_set_data& polygon_set,
+    inline polygon_set_data& scale(polygon_set_data& ,
                                    const scaling_type& scaling) {
       for(typename value_type::iterator itr = begin(); itr != end(); ++itr) {
         bool vb = (*itr).first.first.x() == (*itr).first.second.x();
@@ -574,7 +574,7 @@ namespace boost { namespace polygon {
     template <typename geometry_type>
     inline polygon_set_data&
     insert_with_resize_dispatch(const geometry_type& poly, coordinate_type resizing, bool corner_fill_arc, unsigned int num_circle_segments, bool hole,
-                               polygon_with_holes_concept tag) {
+                               polygon_with_holes_concept ) {
       insert_with_resize_dispatch(poly, resizing, corner_fill_arc, num_circle_segments, hole, polygon_concept());
       for(typename polygon_with_holes_traits<geometry_type>::iterator_holes_type itr =
             begin_holes(poly); itr != end_holes(poly);
@@ -587,7 +587,7 @@ namespace boost { namespace polygon {
     template <typename geometry_type>
     inline polygon_set_data&
     insert_with_resize_dispatch(const geometry_type& poly, coordinate_type resizing, bool corner_fill_arc, unsigned int num_circle_segments, bool hole,
-                          polygon_concept tag) {
+                          polygon_concept ) {
 
       if (resizing==0)
          return *this;
diff --git a/include/boost/polygon/polygon_traits.hpp b/include/boost/polygon/polygon_traits.hpp
index dddbf34..20835ef 100644
--- a/include/boost/polygon/polygon_traits.hpp
+++ b/include/boost/polygon/polygon_traits.hpp
@@ -185,7 +185,7 @@ namespace boost { namespace polygon{
     template <typename iT>
     static inline T& set_compact(T& t, iT input_begin, iT input_end) {
       typedef iterator_points_to_compact<iT, typename polygon_traits<T>::point_type> iTp;
-      t.set_points(iTp(polygon_traits<T>::begin_points(t)), iTp(polygon_traits<T>::end_points(t)));
+      t.set_points(iTp(input_begin), iTp(input_end));
       return t;
     }
   };
@@ -1567,7 +1567,7 @@ namespace boost { namespace polygon{
     typedef const hole_type* iterator_holes_type;
     static inline iterator_holes_type begin_holes(const hole_type& t) { return &t; }
     static inline iterator_holes_type end_holes(const hole_type& t) { return &t; }
-    static inline std::size_t size_holes(const hole_type& t) { return 0; }
+    static inline std::size_t size_holes(const hole_type& ) { return 0; }
   };
 
   template <typename T>