diff --git a/headers/libs/agg/agg_basics.h b/headers/libs/agg/agg_basics.h
index ad1e5c78c8..309713002b 100644
--- a/headers/libs/agg/agg_basics.h
+++ b/headers/libs/agg/agg_basics.h
@@ -143,10 +143,18 @@ namespace agg
         __asm mov eax, dword ptr [t]
     }
 #pragma warning(pop)
+    AGG_INLINE int ifloor(double v)
+    {
+        return int(floor(v));
+    }
     AGG_INLINE unsigned ufloor(double v)         //-------ufloor
     {
         return unsigned(floor(v));
     }
+    AGG_INLINE int iceil(double v)
+    {
+        return int(ceil(v));
+    }
     AGG_INLINE unsigned uceil(double v)          //--------uceil
     {
         return unsigned(ceil(v));
@@ -160,10 +168,18 @@ namespace agg
     {
         return unsigned(v);
     }
+    AGG_INLINE int ifloor(double v)
+    {
+        return int(floor(v));
+    }
     AGG_INLINE unsigned ufloor(double v)
     {
         return unsigned(floor(v));
     }
+    AGG_INLINE int iceil(double v)
+    {
+        return int(ceil(v));
+    }
     AGG_INLINE unsigned uceil(double v)
     {
         return unsigned(ceil(v));
@@ -177,10 +193,19 @@ namespace agg
     {
         return unsigned(v + 0.5);
     }
+    AGG_INLINE int ifloor(double v)
+    {
+        int i = int(v);
+        return i - (i > v);
+    }
     AGG_INLINE unsigned ufloor(double v)
     {
         return unsigned(v);
     }
+    AGG_INLINE int iceil(double v)
+    {
+        return int(ceil(v));
+    }
     AGG_INLINE unsigned uceil(double v)
     {
         return unsigned(ceil(v));
@@ -203,7 +228,7 @@ namespace agg
     {
         AGG_INLINE static unsigned mul(unsigned a, unsigned b)
         {
-            register unsigned q = a * b + (1 << (Shift-1));
+            unsigned q = a * b + (1 << (Shift-1));
             return (q + (q >> Shift)) >> Shift;
         }
     };
@@ -229,7 +254,7 @@ namespace agg
     {
         poly_subpixel_shift = 8,                      //----poly_subpixel_shift
         poly_subpixel_scale = 1<<poly_subpixel_shift, //----poly_subpixel_scale 
-        poly_subpixel_mask  = poly_subpixel_scale-1,  //----poly_subpixel_mask 
+        poly_subpixel_mask  = poly_subpixel_scale-1   //----poly_subpixel_mask 
     };
 
     //----------------------------------------------------------filling_rule_e
@@ -257,16 +282,19 @@ namespace agg
     //----------------------------------------------------------------rect_base
     template<class T> struct rect_base
     {
+        typedef T            value_type;
         typedef rect_base<T> self_type;
-        T x1;
-        T y1;
-        T x2;
-        T y2;
+        T x1, y1, x2, y2;
 
         rect_base() {}
         rect_base(T x1_, T y1_, T x2_, T y2_) :
             x1(x1_), y1(y1_), x2(x2_), y2(y2_) {}
 
+        void init(T x1_, T y1_, T x2_, T y2_) 
+        {
+            x1 = x1_; y1 = y1_; x2 = x2_; y2 = y2_; 
+        }
+
         const self_type& normalize()
         {
             T t;
@@ -288,6 +316,17 @@ namespace agg
         {
             return x1 <= x2 && y1 <= y2;
         }
+
+        bool hit_test(T x, T y) const
+        {
+            return (x >= x1 && x <= x2 && y >= y1 && y <= y2);
+        }
+        
+        bool overlaps(const self_type& r) const
+        {
+            return !(r.x1 > x2 || r.x2 < x1
+                  || r.y1 > y2 || r.y2 < y1);
+        }
     };
 
     //-----------------------------------------------------intersect_rectangles
@@ -490,6 +529,30 @@ namespace agg
     typedef vertex_base<float>  vertex_f; //-----vertex_f
     typedef vertex_base<double> vertex_d; //-----vertex_d
 
+    //----------------------------------------------------------------row_info
+    template<class T> struct row_info
+    {
+        int x1, x2;
+        T* ptr;
+        row_info() {}
+        row_info(int x1_, int x2_, T* ptr_) : x1(x1_), x2(x2_), ptr(ptr_) {}
+    };
+
+    //----------------------------------------------------------const_row_info
+    template<class T> struct const_row_info
+    {
+        int x1, x2;
+        const T* ptr;
+        const_row_info() {}
+        const_row_info(int x1_, int x2_, const T* ptr_) : 
+            x1(x1_), x2(x2_), ptr(ptr_) {}
+    };
+
+    //------------------------------------------------------------is_equal_eps
+    template<class T> inline bool is_equal_eps(T v1, T v2, T epsilon)
+    {
+        return fabs(v1 - v2) <= double(epsilon);
+    }
 }
 
 
diff --git a/headers/libs/agg/agg_scanline_u.h b/headers/libs/agg/agg_scanline_u.h
index 7a78de1a46..630eb9deac 100644
--- a/headers/libs/agg/agg_scanline_u.h
+++ b/headers/libs/agg/agg_scanline_u.h
@@ -252,7 +252,7 @@ namespace agg
         typedef base_type::coord_type coord_type;
 
         scanline_u8_am() : base_type(), m_alpha_mask(0) {}
-        scanline_u8_am(const AlphaMask& am) : base_type(), m_alpha_mask(&am) {}
+        scanline_u8_am(AlphaMask& am) : base_type(), m_alpha_mask(&am) {}
 
         //--------------------------------------------------------------------
         void finalize(int span_y)
@@ -275,7 +275,7 @@ namespace agg
         }
 
     private:
-        const AlphaMask* m_alpha_mask;
+        AlphaMask* m_alpha_mask;
     };
 
 
@@ -464,28 +464,21 @@ namespace agg
         typedef base_type::coord_type coord_type;
 
 
-        scanline32_u8_am() : m_alpha_mask(0)
-		{
-			this->base_type();
-		}
-
-        scanline32_u8_am(const AlphaMask& am) : m_alpha_mask(&am)
-		{
-			this->base_type();
-		}
+        scanline32_u8_am() : base_type(), m_alpha_mask(0) {}
+        scanline32_u8_am(AlphaMask& am) : base_type(), m_alpha_mask(&am) {}
 
         //--------------------------------------------------------------------
         void finalize(int span_y)
         {
-            this->base_type::finalize(span_y);
+            base_type::finalize(span_y);
             if(m_alpha_mask)
             {
-                typename base_type::iterator span = this->base_type::begin();
-                unsigned count = this->base_type::num_spans();
+                typename base_type::iterator span = base_type::begin();
+                unsigned count = base_type::num_spans();
                 do
                 {
                     m_alpha_mask->combine_hspan(span->x, 
-                                                this->base_type::y(),
+                                                base_type::y(), 
                                                 span->covers, 
                                                 span->len);
                     ++span;
@@ -495,7 +488,7 @@ namespace agg
         }
 
     private:
-        const AlphaMask* m_alpha_mask;
+        AlphaMask* m_alpha_mask;
     };