KIKIMR-19287: add task_stats_drawing script

73 files changed, 28525 insertions, 0 deletions

diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_alpha_mask_u8.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_alpha_mask_u8.h
new file mode 100644
index 0000000000..e301c10088
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_alpha_mask_u8.h
@@ -0,0 +1,499 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// scanline_u8 class
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_ALPHA_MASK_U8_INCLUDED
+#define AGG_ALPHA_MASK_U8_INCLUDED
+
+#include <string.h>
+#include "agg_basics.h"
+#include "agg_rendering_buffer.h"
+
+namespace agg
+{
+    //===================================================one_component_mask_u8
+    struct one_component_mask_u8
+    {
+        static unsigned calculate(const int8u* p) { return *p; }
+    };
+    
+
+    //=====================================================rgb_to_gray_mask_u8
+    template<unsigned R, unsigned G, unsigned B>
+    struct rgb_to_gray_mask_u8
+    {
+        static unsigned calculate(const int8u* p) 
+        { 
+            return (p[R]*77 + p[G]*150 + p[B]*29) >> 8; 
+        }
+    };
+
+    //==========================================================alpha_mask_u8
+    template<unsigned Step=1, unsigned Offset=0, class MaskF=one_component_mask_u8>
+    class alpha_mask_u8
+    {
+    public:
+        typedef int8u cover_type;
+        typedef alpha_mask_u8<Step, Offset, MaskF> self_type;
+        enum cover_scale_e
+        { 
+            cover_shift = 8,
+            cover_none  = 0,
+            cover_full  = 255
+        };
+
+        alpha_mask_u8() : m_rbuf(0) {}
+        explicit alpha_mask_u8(rendering_buffer& rbuf) : m_rbuf(&rbuf) {}
+
+        void attach(rendering_buffer& rbuf) { m_rbuf = &rbuf; }
+
+        MaskF& mask_function() { return m_mask_function; }
+        const MaskF& mask_function() const { return m_mask_function; }
+
+        
+        //--------------------------------------------------------------------
+        cover_type pixel(int x, int y) const
+        {
+            if(x >= 0 && y >= 0 && 
+               x < (int)m_rbuf->width() && 
+               y < (int)m_rbuf->height())
+            {
+                return (cover_type)m_mask_function.calculate(
+                                        m_rbuf->row_ptr(y) + x * Step + Offset);
+            }
+            return 0;
+        }
+
+        //--------------------------------------------------------------------
+        cover_type combine_pixel(int x, int y, cover_type val) const
+        {
+            if(x >= 0 && y >= 0 && 
+               x < (int)m_rbuf->width() && 
+               y < (int)m_rbuf->height())
+            {
+                return (cover_type)((cover_full + val * 
+                                     m_mask_function.calculate(
+                                        m_rbuf->row_ptr(y) + x * Step + Offset)) >> 
+                                     cover_shift);
+            }
+            return 0;
+        }
+
+
+        //--------------------------------------------------------------------
+        void fill_hspan(int x, int y, cover_type* dst, int num_pix) const
+        {
+            int xmax = m_rbuf->width() - 1;
+            int ymax = m_rbuf->height() - 1;
+
+            int count = num_pix;
+            cover_type* covers = dst;
+
+            if(y < 0 || y > ymax)
+            {
+                memset(dst, 0, num_pix * sizeof(cover_type));
+                return;
+            }
+
+            if(x < 0)
+            {
+                count += x;
+                if(count <= 0) 
+                {
+                    memset(dst, 0, num_pix * sizeof(cover_type));
+                    return;
+                }
+                memset(covers, 0, -x * sizeof(cover_type));
+                covers -= x;
+                x = 0;
+            }
+
+            if(x + count > xmax)
+            {
+                int rest = x + count - xmax - 1;
+                count -= rest;
+                if(count <= 0) 
+                {
+                    memset(dst, 0, num_pix * sizeof(cover_type));
+                    return;
+                }
+                memset(covers + count, 0, rest * sizeof(cover_type));
+            }
+
+            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+            do
+            {
+                *covers++ = (cover_type)m_mask_function.calculate(mask);
+                mask += Step;
+            }
+            while(--count);
+        }
+
+
+        //--------------------------------------------------------------------
+        void combine_hspan(int x, int y, cover_type* dst, int num_pix) const
+        {
+            int xmax = m_rbuf->width() - 1;
+            int ymax = m_rbuf->height() - 1;
+
+            int count = num_pix;
+            cover_type* covers = dst;
+
+            if(y < 0 || y > ymax)
+            {
+                memset(dst, 0, num_pix * sizeof(cover_type));
+                return;
+            }
+
+            if(x < 0)
+            {
+                count += x;
+                if(count <= 0) 
+                {
+                    memset(dst, 0, num_pix * sizeof(cover_type));
+                    return;
+                }
+                memset(covers, 0, -x * sizeof(cover_type));
+                covers -= x;
+                x = 0;
+            }
+
+            if(x + count > xmax)
+            {
+                int rest = x + count - xmax - 1;
+                count -= rest;
+                if(count <= 0) 
+                {
+                    memset(dst, 0, num_pix * sizeof(cover_type));
+                    return;
+                }
+                memset(covers + count, 0, rest * sizeof(cover_type));
+            }
+
+            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+            do
+            {
+                *covers = (cover_type)((cover_full + (*covers) * 
+                                       m_mask_function.calculate(mask)) >> 
+                                       cover_shift);
+                ++covers;
+                mask += Step;
+            }
+            while(--count);
+        }
+
+        //--------------------------------------------------------------------
+        void fill_vspan(int x, int y, cover_type* dst, int num_pix) const
+        {
+            int xmax = m_rbuf->width() - 1;
+            int ymax = m_rbuf->height() - 1;
+
+            int count = num_pix;
+            cover_type* covers = dst;
+
+            if(x < 0 || x > xmax)
+            {
+                memset(dst, 0, num_pix * sizeof(cover_type));
+                return;
+            }
+
+            if(y < 0)
+            {
+                count += y;
+                if(count <= 0) 
+                {
+                    memset(dst, 0, num_pix * sizeof(cover_type));
+                    return;
+                }
+                memset(covers, 0, -y * sizeof(cover_type));
+                covers -= y;
+                y = 0;
+            }
+
+            if(y + count > ymax)
+            {
+                int rest = y + count - ymax - 1;
+                count -= rest;
+                if(count <= 0) 
+                {
+                    memset(dst, 0, num_pix * sizeof(cover_type));
+                    return;
+                }
+                memset(covers + count, 0, rest * sizeof(cover_type));
+            }
+
+            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+            do
+            {
+                *covers++ = (cover_type)m_mask_function.calculate(mask);
+                mask += m_rbuf->stride();
+            }
+            while(--count);
+        }
+
+        //--------------------------------------------------------------------
+        void combine_vspan(int x, int y, cover_type* dst, int num_pix) const
+        {
+            int xmax = m_rbuf->width() - 1;
+            int ymax = m_rbuf->height() - 1;
+
+            int count = num_pix;
+            cover_type* covers = dst;
+
+            if(x < 0 || x > xmax)
+            {
+                memset(dst, 0, num_pix * sizeof(cover_type));
+                return;
+            }
+
+            if(y < 0)
+            {
+                count += y;
+                if(count <= 0) 
+                {
+                    memset(dst, 0, num_pix * sizeof(cover_type));
+                    return;
+                }
+                memset(covers, 0, -y * sizeof(cover_type));
+                covers -= y;
+                y = 0;
+            }
+
+            if(y + count > ymax)
+            {
+                int rest = y + count - ymax - 1;
+                count -= rest;
+                if(count <= 0) 
+                {
+                    memset(dst, 0, num_pix * sizeof(cover_type));
+                    return;
+                }
+                memset(covers + count, 0, rest * sizeof(cover_type));
+            }
+
+            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+            do
+            {
+                *covers = (cover_type)((cover_full + (*covers) * 
+                                       m_mask_function.calculate(mask)) >> 
+                                       cover_shift);
+                ++covers;
+                mask += m_rbuf->stride();
+            }
+            while(--count);
+        }
+
+
+    private:
+        alpha_mask_u8(const self_type&);
+        const self_type& operator = (const self_type&);
+
+        rendering_buffer* m_rbuf;
+        MaskF             m_mask_function;
+    };
+    
+
+    typedef alpha_mask_u8<1, 0> alpha_mask_gray8;   //----alpha_mask_gray8
+
+    typedef alpha_mask_u8<3, 0> alpha_mask_rgb24r;  //----alpha_mask_rgb24r
+    typedef alpha_mask_u8<3, 1> alpha_mask_rgb24g;  //----alpha_mask_rgb24g
+    typedef alpha_mask_u8<3, 2> alpha_mask_rgb24b;  //----alpha_mask_rgb24b
+
+    typedef alpha_mask_u8<3, 2> alpha_mask_bgr24r;  //----alpha_mask_bgr24r
+    typedef alpha_mask_u8<3, 1> alpha_mask_bgr24g;  //----alpha_mask_bgr24g
+    typedef alpha_mask_u8<3, 0> alpha_mask_bgr24b;  //----alpha_mask_bgr24b
+
+    typedef alpha_mask_u8<4, 0> alpha_mask_rgba32r; //----alpha_mask_rgba32r
+    typedef alpha_mask_u8<4, 1> alpha_mask_rgba32g; //----alpha_mask_rgba32g
+    typedef alpha_mask_u8<4, 2> alpha_mask_rgba32b; //----alpha_mask_rgba32b
+    typedef alpha_mask_u8<4, 3> alpha_mask_rgba32a; //----alpha_mask_rgba32a
+
+    typedef alpha_mask_u8<4, 1> alpha_mask_argb32r; //----alpha_mask_argb32r
+    typedef alpha_mask_u8<4, 2> alpha_mask_argb32g; //----alpha_mask_argb32g
+    typedef alpha_mask_u8<4, 3> alpha_mask_argb32b; //----alpha_mask_argb32b
+    typedef alpha_mask_u8<4, 0> alpha_mask_argb32a; //----alpha_mask_argb32a
+
+    typedef alpha_mask_u8<4, 2> alpha_mask_bgra32r; //----alpha_mask_bgra32r
+    typedef alpha_mask_u8<4, 1> alpha_mask_bgra32g; //----alpha_mask_bgra32g
+    typedef alpha_mask_u8<4, 0> alpha_mask_bgra32b; //----alpha_mask_bgra32b
+    typedef alpha_mask_u8<4, 3> alpha_mask_bgra32a; //----alpha_mask_bgra32a
+
+    typedef alpha_mask_u8<4, 3> alpha_mask_abgr32r; //----alpha_mask_abgr32r
+    typedef alpha_mask_u8<4, 2> alpha_mask_abgr32g; //----alpha_mask_abgr32g
+    typedef alpha_mask_u8<4, 1> alpha_mask_abgr32b; //----alpha_mask_abgr32b
+    typedef alpha_mask_u8<4, 0> alpha_mask_abgr32a; //----alpha_mask_abgr32a
+
+    typedef alpha_mask_u8<3, 0, rgb_to_gray_mask_u8<0, 1, 2> > alpha_mask_rgb24gray;  //----alpha_mask_rgb24gray
+    typedef alpha_mask_u8<3, 0, rgb_to_gray_mask_u8<2, 1, 0> > alpha_mask_bgr24gray;  //----alpha_mask_bgr24gray
+    typedef alpha_mask_u8<4, 0, rgb_to_gray_mask_u8<0, 1, 2> > alpha_mask_rgba32gray; //----alpha_mask_rgba32gray
+    typedef alpha_mask_u8<4, 1, rgb_to_gray_mask_u8<0, 1, 2> > alpha_mask_argb32gray; //----alpha_mask_argb32gray
+    typedef alpha_mask_u8<4, 0, rgb_to_gray_mask_u8<2, 1, 0> > alpha_mask_bgra32gray; //----alpha_mask_bgra32gray
+    typedef alpha_mask_u8<4, 1, rgb_to_gray_mask_u8<2, 1, 0> > alpha_mask_abgr32gray; //----alpha_mask_abgr32gray
+
+
+
+    //==========================================================amask_no_clip_u8
+    template<unsigned Step=1, unsigned Offset=0, class MaskF=one_component_mask_u8>
+    class amask_no_clip_u8
+    {
+    public:
+        typedef int8u cover_type;
+        typedef amask_no_clip_u8<Step, Offset, MaskF> self_type;
+        enum cover_scale_e
+        { 
+            cover_shift = 8,
+            cover_none  = 0,
+            cover_full  = 255
+        };
+
+        amask_no_clip_u8() : m_rbuf(0) {}
+        explicit amask_no_clip_u8(rendering_buffer& rbuf) : m_rbuf(&rbuf) {}
+
+        void attach(rendering_buffer& rbuf) { m_rbuf = &rbuf; }
+
+        MaskF& mask_function() { return m_mask_function; }
+        const MaskF& mask_function() const { return m_mask_function; }
+
+
+        //--------------------------------------------------------------------
+        cover_type pixel(int x, int y) const
+        {
+            return (cover_type)m_mask_function.calculate(
+                                   m_rbuf->row_ptr(y) + x * Step + Offset);
+        }
+
+        
+        //--------------------------------------------------------------------
+        cover_type combine_pixel(int x, int y, cover_type val) const
+        {
+            return (cover_type)((cover_full + val * 
+                                 m_mask_function.calculate(
+                                    m_rbuf->row_ptr(y) + x * Step + Offset)) >> 
+                                 cover_shift);
+        }
+
+
+        //--------------------------------------------------------------------
+        void fill_hspan(int x, int y, cover_type* dst, int num_pix) const
+        {
+            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+            do
+            {
+                *dst++ = (cover_type)m_mask_function.calculate(mask);
+                mask += Step;
+            }
+            while(--num_pix);
+        }
+
+
+
+        //--------------------------------------------------------------------
+        void combine_hspan(int x, int y, cover_type* dst, int num_pix) const
+        {
+            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+            do
+            {
+                *dst = (cover_type)((cover_full + (*dst) * 
+                                    m_mask_function.calculate(mask)) >> 
+                                    cover_shift);
+                ++dst;
+                mask += Step;
+            }
+            while(--num_pix);
+        }
+
+
+        //--------------------------------------------------------------------
+        void fill_vspan(int x, int y, cover_type* dst, int num_pix) const
+        {
+            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+            do
+            {
+                *dst++ = (cover_type)m_mask_function.calculate(mask);
+                mask += m_rbuf->stride();
+            }
+            while(--num_pix);
+        }
+
+
+        //--------------------------------------------------------------------
+        void combine_vspan(int x, int y, cover_type* dst, int num_pix) const
+        {
+            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+            do
+            {
+                *dst = (cover_type)((cover_full + (*dst) * 
+                                    m_mask_function.calculate(mask)) >> 
+                                    cover_shift);
+                ++dst;
+                mask += m_rbuf->stride();
+            }
+            while(--num_pix);
+        }
+
+    private:
+        amask_no_clip_u8(const self_type&);
+        const self_type& operator = (const self_type&);
+
+        rendering_buffer* m_rbuf;
+        MaskF             m_mask_function;
+    };
+    
+
+    typedef amask_no_clip_u8<1, 0> amask_no_clip_gray8;   //----amask_no_clip_gray8
+
+    typedef amask_no_clip_u8<3, 0> amask_no_clip_rgb24r;  //----amask_no_clip_rgb24r
+    typedef amask_no_clip_u8<3, 1> amask_no_clip_rgb24g;  //----amask_no_clip_rgb24g
+    typedef amask_no_clip_u8<3, 2> amask_no_clip_rgb24b;  //----amask_no_clip_rgb24b
+
+    typedef amask_no_clip_u8<3, 2> amask_no_clip_bgr24r;  //----amask_no_clip_bgr24r
+    typedef amask_no_clip_u8<3, 1> amask_no_clip_bgr24g;  //----amask_no_clip_bgr24g
+    typedef amask_no_clip_u8<3, 0> amask_no_clip_bgr24b;  //----amask_no_clip_bgr24b
+
+    typedef amask_no_clip_u8<4, 0> amask_no_clip_rgba32r; //----amask_no_clip_rgba32r
+    typedef amask_no_clip_u8<4, 1> amask_no_clip_rgba32g; //----amask_no_clip_rgba32g
+    typedef amask_no_clip_u8<4, 2> amask_no_clip_rgba32b; //----amask_no_clip_rgba32b
+    typedef amask_no_clip_u8<4, 3> amask_no_clip_rgba32a; //----amask_no_clip_rgba32a
+
+    typedef amask_no_clip_u8<4, 1> amask_no_clip_argb32r; //----amask_no_clip_argb32r
+    typedef amask_no_clip_u8<4, 2> amask_no_clip_argb32g; //----amask_no_clip_argb32g
+    typedef amask_no_clip_u8<4, 3> amask_no_clip_argb32b; //----amask_no_clip_argb32b
+    typedef amask_no_clip_u8<4, 0> amask_no_clip_argb32a; //----amask_no_clip_argb32a
+
+    typedef amask_no_clip_u8<4, 2> amask_no_clip_bgra32r; //----amask_no_clip_bgra32r
+    typedef amask_no_clip_u8<4, 1> amask_no_clip_bgra32g; //----amask_no_clip_bgra32g
+    typedef amask_no_clip_u8<4, 0> amask_no_clip_bgra32b; //----amask_no_clip_bgra32b
+    typedef amask_no_clip_u8<4, 3> amask_no_clip_bgra32a; //----amask_no_clip_bgra32a
+
+    typedef amask_no_clip_u8<4, 3> amask_no_clip_abgr32r; //----amask_no_clip_abgr32r
+    typedef amask_no_clip_u8<4, 2> amask_no_clip_abgr32g; //----amask_no_clip_abgr32g
+    typedef amask_no_clip_u8<4, 1> amask_no_clip_abgr32b; //----amask_no_clip_abgr32b
+    typedef amask_no_clip_u8<4, 0> amask_no_clip_abgr32a; //----amask_no_clip_abgr32a
+
+    typedef amask_no_clip_u8<3, 0, rgb_to_gray_mask_u8<0, 1, 2> > amask_no_clip_rgb24gray;  //----amask_no_clip_rgb24gray
+    typedef amask_no_clip_u8<3, 0, rgb_to_gray_mask_u8<2, 1, 0> > amask_no_clip_bgr24gray;  //----amask_no_clip_bgr24gray
+    typedef amask_no_clip_u8<4, 0, rgb_to_gray_mask_u8<0, 1, 2> > amask_no_clip_rgba32gray; //----amask_no_clip_rgba32gray
+    typedef amask_no_clip_u8<4, 1, rgb_to_gray_mask_u8<0, 1, 2> > amask_no_clip_argb32gray; //----amask_no_clip_argb32gray
+    typedef amask_no_clip_u8<4, 0, rgb_to_gray_mask_u8<2, 1, 0> > amask_no_clip_bgra32gray; //----amask_no_clip_bgra32gray
+    typedef amask_no_clip_u8<4, 1, rgb_to_gray_mask_u8<2, 1, 0> > amask_no_clip_abgr32gray; //----amask_no_clip_abgr32gray
+
+
+}
+
+
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_array.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_array.h
new file mode 100644
index 0000000000..8d56683840
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_array.h
@@ -0,0 +1,1119 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+#ifndef AGG_ARRAY_INCLUDED
+#define AGG_ARRAY_INCLUDED
+
+#include <stddef.h>
+#include <string.h>
+#include "agg_basics.h"
+
+namespace agg
+{
+
+    //-------------------------------------------------------pod_array_adaptor
+    template<class T> class pod_array_adaptor
+    {
+    public:
+        typedef T value_type;
+        pod_array_adaptor(T* array, unsigned size) : 
+            m_array(array), m_size(size) {}
+
+        unsigned size() const { return m_size; }
+        const T& operator [] (unsigned i) const { return m_array[i]; }
+              T& operator [] (unsigned i)       { return m_array[i]; }
+        const T& at(unsigned i) const           { return m_array[i]; }
+              T& at(unsigned i)                 { return m_array[i]; }
+        T  value_at(unsigned i) const           { return m_array[i]; }
+
+    private:
+        T*       m_array;
+        unsigned m_size;
+    };
+
+
+    //---------------------------------------------------------pod_auto_array
+    template<class T, unsigned Size> class pod_auto_array
+    {
+    public:
+        typedef T value_type;
+        typedef pod_auto_array<T, Size> self_type;
+
+        pod_auto_array() {}
+        explicit pod_auto_array(const T* c)
+        {
+            memcpy(m_array, c, sizeof(T) * Size);
+        }
+
+        const self_type& operator = (const T* c)
+        {
+            memcpy(m_array, c, sizeof(T) * Size);
+            return *this;
+        }
+
+        static unsigned size() { return Size; }
+        const T& operator [] (unsigned i) const { return m_array[i]; }
+              T& operator [] (unsigned i)       { return m_array[i]; }
+        const T& at(unsigned i) const           { return m_array[i]; }
+              T& at(unsigned i)                 { return m_array[i]; }
+        T  value_at(unsigned i) const           { return m_array[i]; }
+
+    private:
+        T m_array[Size];
+    };
+
+
+    //--------------------------------------------------------pod_auto_vector
+    template<class T, unsigned Size> class pod_auto_vector
+    {
+    public:
+        typedef T value_type;
+        typedef pod_auto_vector<T, Size> self_type;
+
+        pod_auto_vector() : m_size(0) {}
+
+        void remove_all()            { m_size = 0; }
+        void clear()                 { m_size = 0; }
+        void add(const T& v)         { m_array[m_size++] = v; }
+        void push_back(const T& v)   { m_array[m_size++] = v; }
+        void inc_size(unsigned size) { m_size += size; }
+        
+        unsigned size() const { return m_size; }
+        const T& operator [] (unsigned i) const { return m_array[i]; }
+              T& operator [] (unsigned i)       { return m_array[i]; }
+        const T& at(unsigned i) const           { return m_array[i]; }
+              T& at(unsigned i)                 { return m_array[i]; }
+        T  value_at(unsigned i) const           { return m_array[i]; }
+
+    private:
+        T m_array[Size];
+        unsigned m_size;
+    };
+
+
+    //---------------------------------------------------------------pod_array
+    template<class T> class pod_array
+    {
+    public:
+        typedef T value_type;
+        typedef pod_array<T> self_type;
+
+        ~pod_array() { pod_allocator<T>::deallocate(m_array, m_size); }
+        pod_array() : m_array(0), m_size(0) {}
+
+        pod_array(unsigned size) : 
+            m_array(pod_allocator<T>::allocate(size)), 
+            m_size(size) 
+        {}
+
+        pod_array(const self_type& v) : 
+            m_array(pod_allocator<T>::allocate(v.m_size)), 
+            m_size(v.m_size) 
+        {
+            memcpy(m_array, v.m_array, sizeof(T) * m_size);
+        }
+
+        void resize(unsigned size)
+        {
+            if(size != m_size)
+            {
+                pod_allocator<T>::deallocate(m_array, m_size);
+                m_array = pod_allocator<T>::allocate(m_size = size);
+            }
+        }
+        const self_type& operator = (const self_type& v)
+        {
+            resize(v.size());
+            memcpy(m_array, v.m_array, sizeof(T) * m_size);
+            return *this;
+        }
+
+        unsigned size() const { return m_size; }
+        const T& operator [] (unsigned i) const { return m_array[i]; }
+              T& operator [] (unsigned i)       { return m_array[i]; }
+        const T& at(unsigned i) const           { return m_array[i]; }
+              T& at(unsigned i)                 { return m_array[i]; }
+        T  value_at(unsigned i) const           { return m_array[i]; }
+
+        const T* data() const { return m_array; }
+              T* data()       { return m_array; }
+    private:
+        T*       m_array;
+        unsigned m_size;
+    };
+
+
+
+    //--------------------------------------------------------------pod_vector
+    // A simple class template to store Plain Old Data, a vector
+    // of a fixed size. The data is continous in memory
+    //------------------------------------------------------------------------
+    template<class T> class pod_vector
+    {
+    public:
+        typedef T value_type;
+
+        ~pod_vector() { pod_allocator<T>::deallocate(m_array, m_capacity); }
+        pod_vector() : m_size(0), m_capacity(0), m_array(0) {}
+        pod_vector(unsigned cap, unsigned extra_tail=0);
+
+        // Copying
+        pod_vector(const pod_vector<T>&);
+        const pod_vector<T>& operator = (const pod_vector<T>&);
+
+        // Set new capacity. All data is lost, size is set to zero.
+        void capacity(unsigned cap, unsigned extra_tail=0);
+        unsigned capacity() const { return m_capacity; }
+
+        // Allocate n elements. All data is lost, 
+        // but elements can be accessed in range 0...size-1. 
+        void allocate(unsigned size, unsigned extra_tail=0);
+
+        // Resize keeping the content.
+        void resize(unsigned new_size);
+
+        void zero()
+        {
+            memset(m_array, 0, sizeof(T) * m_size);
+        }
+
+        void add(const T& v)         { m_array[m_size++] = v; }
+        void push_back(const T& v)   { m_array[m_size++] = v; }
+        void insert_at(unsigned pos, const T& val);
+        void inc_size(unsigned size) { m_size += size; }
+        unsigned size()      const   { return m_size; }
+        unsigned byte_size() const   { return m_size * sizeof(T); }
+        void serialize(int8u* ptr) const;
+        void deserialize(const int8u* data, unsigned byte_size);
+        const T& operator [] (unsigned i) const { return m_array[i]; }
+              T& operator [] (unsigned i)       { return m_array[i]; }
+        const T& at(unsigned i) const           { return m_array[i]; }
+              T& at(unsigned i)                 { return m_array[i]; }
+        T  value_at(unsigned i) const           { return m_array[i]; }
+
+        const T* data() const { return m_array; }
+              T* data()       { return m_array; }
+
+        void remove_all()         { m_size = 0; }
+        void clear()              { m_size = 0; }
+        void cut_at(unsigned num) { if(num < m_size) m_size = num; }
+
+    private:
+        unsigned m_size;
+        unsigned m_capacity;
+        T*       m_array;
+    };
+
+    //------------------------------------------------------------------------
+    template<class T> 
+    void pod_vector<T>::capacity(unsigned cap, unsigned extra_tail)
+    {
+        m_size = 0;
+        if(cap > m_capacity)
+        {
+            pod_allocator<T>::deallocate(m_array, m_capacity);
+            m_capacity = cap + extra_tail;
+            m_array = m_capacity ? pod_allocator<T>::allocate(m_capacity) : 0;
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class T> 
+    void pod_vector<T>::allocate(unsigned size, unsigned extra_tail)
+    {
+        capacity(size, extra_tail);
+        m_size = size;
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class T> 
+    void pod_vector<T>::resize(unsigned new_size)
+    {
+        if(new_size > m_size)
+        {
+            if(new_size > m_capacity)
+            {
+                T* data = pod_allocator<T>::allocate(new_size);
+                memcpy(data, m_array, m_size * sizeof(T));
+                pod_allocator<T>::deallocate(m_array, m_capacity);
+                m_array = data;
+            }
+        }
+        else
+        {
+            m_size = new_size;
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class T> pod_vector<T>::pod_vector(unsigned cap, unsigned extra_tail) :
+        m_size(0), 
+        m_capacity(cap + extra_tail), 
+        m_array(pod_allocator<T>::allocate(m_capacity)) {}
+
+    //------------------------------------------------------------------------
+    template<class T> pod_vector<T>::pod_vector(const pod_vector<T>& v) :
+        m_size(v.m_size),
+        m_capacity(v.m_capacity),
+        m_array(v.m_capacity ? pod_allocator<T>::allocate(v.m_capacity) : 0)
+    {
+        memcpy(m_array, v.m_array, sizeof(T) * v.m_size);
+    }
+
+    //------------------------------------------------------------------------
+    template<class T> const pod_vector<T>& 
+    pod_vector<T>::operator = (const pod_vector<T>&v)
+    {
+        allocate(v.m_size);
+        if(v.m_size) memcpy(m_array, v.m_array, sizeof(T) * v.m_size);
+        return *this;
+    }
+
+    //------------------------------------------------------------------------
+    template<class T> void pod_vector<T>::serialize(int8u* ptr) const
+    { 
+        if(m_size) memcpy(ptr, m_array, m_size * sizeof(T)); 
+    }
+
+    //------------------------------------------------------------------------
+    template<class T> 
+    void pod_vector<T>::deserialize(const int8u* data, unsigned byte_size)
+    {
+        byte_size /= sizeof(T);
+        allocate(byte_size);
+        if(byte_size) memcpy(m_array, data, byte_size * sizeof(T));
+    }
+
+    //------------------------------------------------------------------------
+    template<class T> 
+    void pod_vector<T>::insert_at(unsigned pos, const T& val)
+    {
+        if(pos >= m_size) 
+        {
+            m_array[m_size] = val;
+        }
+        else
+        {
+            memmove(m_array + pos + 1, m_array + pos, (m_size - pos) * sizeof(T));
+            m_array[pos] = val;
+        }
+        ++m_size;
+    }
+
+    //---------------------------------------------------------------pod_bvector
+    // A simple class template to store Plain Old Data, similar to std::deque
+    // It doesn't reallocate memory but instead, uses blocks of data of size 
+    // of (1 << S), that is, power of two. The data is NOT contiguous in memory, 
+    // so the only valid access method is operator [] or curr(), prev(), next()
+    // 
+    // There reallocs occure only when the pool of pointers to blocks needs 
+    // to be extended (it happens very rarely). You can control the value 
+    // of increment to reallocate the pointer buffer. See the second constructor.
+    // By default, the incremeent value equals (1 << S), i.e., the block size.
+    //------------------------------------------------------------------------
+    template<class T, unsigned S=6> class pod_bvector
+    {
+    public:
+        enum block_scale_e
+        {   
+            block_shift = S,
+            block_size  = 1 << block_shift,
+            block_mask  = block_size - 1
+        };
+
+        typedef T value_type;
+
+        ~pod_bvector();
+        pod_bvector();
+        pod_bvector(unsigned block_ptr_inc);
+
+        // Copying
+        pod_bvector(const pod_bvector<T, S>& v);
+        const pod_bvector<T, S>& operator = (const pod_bvector<T, S>& v);
+
+        void remove_all() { m_size = 0; }
+        void clear()      { m_size = 0; }
+        void free_all()   { free_tail(0); }
+        void free_tail(unsigned size);
+        void add(const T& val);
+        void push_back(const T& val) { add(val); }
+        void modify_last(const T& val);
+        void remove_last();
+
+        int allocate_continuous_block(unsigned num_elements);
+
+        void add_array(const T* ptr, unsigned num_elem)
+        {
+            while(num_elem--)
+            {
+                add(*ptr++);
+            }
+        }
+
+        template<class DataAccessor> void add_data(DataAccessor& data)
+        {
+            while(data.size())
+            {
+                add(*data);
+                ++data;
+            }
+        }
+
+        void cut_at(unsigned size)
+        {
+            if(size < m_size) m_size = size;
+        }
+
+        unsigned size() const { return m_size; }
+
+        const T& operator [] (unsigned i) const
+        {
+            return m_blocks[i >> block_shift][i & block_mask];
+        }
+
+        T& operator [] (unsigned i)
+        {
+            return m_blocks[i >> block_shift][i & block_mask];
+        }
+
+        const T& at(unsigned i) const
+        { 
+            return m_blocks[i >> block_shift][i & block_mask];
+        }
+
+        T& at(unsigned i) 
+        { 
+            return m_blocks[i >> block_shift][i & block_mask];
+        }
+
+        T value_at(unsigned i) const
+        { 
+            return m_blocks[i >> block_shift][i & block_mask];
+        }
+
+        const T& curr(unsigned idx) const
+        {
+            return (*this)[idx];
+        }
+
+        T& curr(unsigned idx)
+        {
+            return (*this)[idx];
+        }
+
+        const T& prev(unsigned idx) const
+        {
+            return (*this)[(idx + m_size - 1) % m_size];
+        }
+
+        T& prev(unsigned idx)
+        {
+            return (*this)[(idx + m_size - 1) % m_size];
+        }
+
+        const T& next(unsigned idx) const
+        {
+            return (*this)[(idx + 1) % m_size];
+        }
+
+        T& next(unsigned idx)
+        {
+            return (*this)[(idx + 1) % m_size];
+        }
+
+        const T& last() const
+        {
+            return (*this)[m_size - 1];
+        }
+
+        T& last()
+        {
+            return (*this)[m_size - 1];
+        }
+
+        unsigned byte_size() const;
+        void serialize(int8u* ptr) const;
+        void deserialize(const int8u* data, unsigned byte_size);
+        void deserialize(unsigned start, const T& empty_val, 
+                         const int8u* data, unsigned byte_size);
+
+        template<class ByteAccessor> 
+        void deserialize(ByteAccessor data)
+        {
+            remove_all();
+            unsigned elem_size = data.size() / sizeof(T);
+
+            for(unsigned i = 0; i < elem_size; ++i)
+            {
+                int8u* ptr = (int8u*)data_ptr();
+                for(unsigned j = 0; j < sizeof(T); ++j)
+                {
+                    *ptr++ = *data;
+                    ++data;
+                }
+                ++m_size;
+            }
+        }
+
+        template<class ByteAccessor>
+        void deserialize(unsigned start, const T& empty_val, ByteAccessor data)
+        {
+            while(m_size < start)
+            {
+                add(empty_val);
+            }
+
+            unsigned elem_size = data.size() / sizeof(T);
+            for(unsigned i = 0; i < elem_size; ++i)
+            {
+                int8u* ptr;
+                if(start + i < m_size)
+                {
+                    ptr = (int8u*)(&((*this)[start + i]));
+                }
+                else
+                {
+                    ptr = (int8u*)data_ptr();
+                    ++m_size;
+                }
+                for(unsigned j = 0; j < sizeof(T); ++j)
+                {
+                    *ptr++ = *data;
+                    ++data;
+                }
+            }
+        }
+
+        const T* block(unsigned nb) const { return m_blocks[nb]; }
+
+    private:
+        void allocate_block(unsigned nb);
+        T*   data_ptr();
+
+        unsigned        m_size;
+        unsigned        m_num_blocks;
+        unsigned        m_max_blocks;
+        T**             m_blocks;
+        unsigned        m_block_ptr_inc;
+    };
+
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S> pod_bvector<T, S>::~pod_bvector()
+    {
+        if(m_num_blocks)
+        {
+            T** blk = m_blocks + m_num_blocks - 1;
+            while(m_num_blocks--)
+            {
+                pod_allocator<T>::deallocate(*blk, block_size);
+                --blk;
+            }
+        }
+        pod_allocator<T*>::deallocate(m_blocks, m_max_blocks);
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S> 
+    void pod_bvector<T, S>::free_tail(unsigned size)
+    {
+        if(size < m_size)
+        {
+            unsigned nb = (size + block_mask) >> block_shift;
+            while(m_num_blocks > nb)
+            {
+                pod_allocator<T>::deallocate(m_blocks[--m_num_blocks], block_size);
+            }
+            if(m_num_blocks == 0)
+            {
+                pod_allocator<T*>::deallocate(m_blocks, m_max_blocks);
+                m_blocks = 0;
+                m_max_blocks = 0;
+            }
+            m_size = size;
+        }
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S> pod_bvector<T, S>::pod_bvector() :
+        m_size(0),
+        m_num_blocks(0),
+        m_max_blocks(0),
+        m_blocks(0),
+        m_block_ptr_inc(block_size)
+    {
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S> 
+    pod_bvector<T, S>::pod_bvector(unsigned block_ptr_inc) :
+        m_size(0),
+        m_num_blocks(0),
+        m_max_blocks(0),
+        m_blocks(0),
+        m_block_ptr_inc(block_ptr_inc)
+    {
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S> 
+    pod_bvector<T, S>::pod_bvector(const pod_bvector<T, S>& v) :
+        m_size(v.m_size),
+        m_num_blocks(v.m_num_blocks),
+        m_max_blocks(v.m_max_blocks),
+        m_blocks(v.m_max_blocks ? 
+                 pod_allocator<T*>::allocate(v.m_max_blocks) : 
+                 0),
+        m_block_ptr_inc(v.m_block_ptr_inc)
+    {
+        unsigned i;
+        for(i = 0; i < v.m_num_blocks; ++i)
+        {
+            m_blocks[i] = pod_allocator<T>::allocate(block_size);
+            memcpy(m_blocks[i], v.m_blocks[i], block_size * sizeof(T));
+        }
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S> 
+    const pod_bvector<T, S>& 
+    pod_bvector<T, S>::operator = (const pod_bvector<T, S>& v)
+    {
+        unsigned i;
+        for(i = m_num_blocks; i < v.m_num_blocks; ++i)
+        {
+            allocate_block(i);
+        }
+        for(i = 0; i < v.m_num_blocks; ++i)
+        {
+            memcpy(m_blocks[i], v.m_blocks[i], block_size * sizeof(T));
+        }
+        m_size = v.m_size;
+        return *this;
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S>
+    void pod_bvector<T, S>::allocate_block(unsigned nb)
+    {
+        if(nb >= m_max_blocks) 
+        {
+            T** new_blocks = pod_allocator<T*>::allocate(m_max_blocks + m_block_ptr_inc);
+
+            if(m_blocks)
+            {
+                memcpy(new_blocks, 
+                       m_blocks, 
+                       m_num_blocks * sizeof(T*));
+
+                pod_allocator<T*>::deallocate(m_blocks, m_max_blocks);
+            }
+            m_blocks = new_blocks;
+            m_max_blocks += m_block_ptr_inc;
+        }
+        m_blocks[nb] = pod_allocator<T>::allocate(block_size);
+        m_num_blocks++;
+    }
+
+
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S>
+    inline T* pod_bvector<T, S>::data_ptr()
+    {
+        unsigned nb = m_size >> block_shift;
+        if(nb >= m_num_blocks)
+        {
+            allocate_block(nb);
+        }
+        return m_blocks[nb] + (m_size & block_mask);
+    }
+
+
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S> 
+    inline void pod_bvector<T, S>::add(const T& val)
+    {
+        *data_ptr() = val;
+        ++m_size;
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S> 
+    inline void pod_bvector<T, S>::remove_last()
+    {
+        if(m_size) --m_size;
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S> 
+    void pod_bvector<T, S>::modify_last(const T& val)
+    {
+        remove_last();
+        add(val);
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S> 
+    int pod_bvector<T, S>::allocate_continuous_block(unsigned num_elements)
+    {
+        if(num_elements < block_size)
+        {
+            data_ptr(); // Allocate initial block if necessary
+            unsigned rest = block_size - (m_size & block_mask);
+            unsigned index;
+            if(num_elements <= rest)
+            {
+                // The rest of the block is good, we can use it
+                //-----------------
+                index = m_size;
+                m_size += num_elements;
+                return index;
+            }
+
+            // New block
+            //---------------
+            m_size += rest;
+            data_ptr();
+            index = m_size;
+            m_size += num_elements;
+            return index;
+        }
+        return -1; // Impossible to allocate
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S> 
+    unsigned pod_bvector<T, S>::byte_size() const
+    {
+        return m_size * sizeof(T);
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S> 
+    void pod_bvector<T, S>::serialize(int8u* ptr) const
+    {
+        unsigned i;
+        for(i = 0; i < m_size; i++)
+        {
+            memcpy(ptr, &(*this)[i], sizeof(T));
+            ptr += sizeof(T);
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S> 
+    void pod_bvector<T, S>::deserialize(const int8u* data, unsigned byte_size)
+    {
+        remove_all();
+        byte_size /= sizeof(T);
+        for(unsigned i = 0; i < byte_size; ++i)
+        {
+            T* ptr = data_ptr();
+            memcpy(ptr, data, sizeof(T));
+            ++m_size;
+            data += sizeof(T);
+        }
+    }
+
+
+    // Replace or add a number of elements starting from "start" position
+    //------------------------------------------------------------------------
+    template<class T, unsigned S> 
+    void pod_bvector<T, S>::deserialize(unsigned start, const T& empty_val, 
+                                        const int8u* data, unsigned byte_size)
+    {
+        while(m_size < start)
+        {
+            add(empty_val);
+        }
+
+        byte_size /= sizeof(T);
+        for(unsigned i = 0; i < byte_size; ++i)
+        {
+            if(start + i < m_size)
+            {
+                memcpy(&((*this)[start + i]), data, sizeof(T));
+            }
+            else
+            {
+                T* ptr = data_ptr();
+                memcpy(ptr, data, sizeof(T));
+                ++m_size;
+            }
+            data += sizeof(T);
+        }
+    }
+
+
+    //---------------------------------------------------------block_allocator
+    // Allocator for arbitrary POD data. Most usable in different cache
+    // systems for efficient memory allocations. 
+    // Memory is allocated with blocks of fixed size ("block_size" in
+    // the constructor). If required size exceeds the block size the allocator
+    // creates a new block of the required size. However, the most efficient
+    // use is when the average reqired size is much less than the block size. 
+    //------------------------------------------------------------------------
+    class block_allocator
+    {
+        struct block_type
+        {
+            int8u*   data;
+            unsigned size;
+        };
+
+    public:
+        void remove_all()
+        {
+            if(m_num_blocks)
+            {
+                block_type* blk = m_blocks + m_num_blocks - 1;
+                while(m_num_blocks--)
+                {
+                    pod_allocator<int8u>::deallocate(blk->data, blk->size);
+                    --blk;
+                }
+                pod_allocator<block_type>::deallocate(m_blocks, m_max_blocks);
+            }
+            m_num_blocks = 0;
+            m_max_blocks = 0;
+            m_blocks = 0;
+            m_buf_ptr = 0;
+            m_rest = 0;
+        }
+
+        ~block_allocator()
+        {
+            remove_all();
+        }
+
+        block_allocator(unsigned block_size, unsigned block_ptr_inc=256-8) :
+            m_block_size(block_size),
+            m_block_ptr_inc(block_ptr_inc),
+            m_num_blocks(0),
+            m_max_blocks(0),
+            m_blocks(0),
+            m_buf_ptr(0),
+            m_rest(0)
+        {
+        }
+       
+
+        int8u* allocate(unsigned size, unsigned alignment=1)
+        {
+            if(size == 0) return 0;
+            if(size <= m_rest)
+            {
+                int8u* ptr = m_buf_ptr;
+                if(alignment > 1)
+                {
+                    unsigned align = 
+                        (alignment - unsigned((size_t)ptr) % alignment) % alignment;
+
+                    size += align;
+                    ptr += align;
+                    if(size <= m_rest)
+                    {
+                        m_rest -= size;
+                        m_buf_ptr += size;
+                        return ptr;
+                    }
+                    allocate_block(size);
+                    return allocate(size - align, alignment);
+                }
+                m_rest -= size;
+                m_buf_ptr += size;
+                return ptr;
+            }
+            allocate_block(size + alignment - 1);
+            return allocate(size, alignment);
+        }
+
+
+    private:
+        void allocate_block(unsigned size)
+        {
+            if(size < m_block_size) size = m_block_size;
+            if(m_num_blocks >= m_max_blocks) 
+            {
+                block_type* new_blocks = 
+                    pod_allocator<block_type>::allocate(m_max_blocks + m_block_ptr_inc);
+
+                if(m_blocks)
+                {
+                    memcpy(new_blocks, 
+                           m_blocks, 
+                           m_num_blocks * sizeof(block_type));
+                    pod_allocator<block_type>::deallocate(m_blocks, m_max_blocks);
+                }
+                m_blocks = new_blocks;
+                m_max_blocks += m_block_ptr_inc;
+            }
+
+            m_blocks[m_num_blocks].size = size;
+            m_blocks[m_num_blocks].data = 
+                m_buf_ptr =
+                pod_allocator<int8u>::allocate(size);
+
+            m_num_blocks++;
+            m_rest = size;
+        }
+
+        unsigned    m_block_size;
+        unsigned    m_block_ptr_inc;
+        unsigned    m_num_blocks;
+        unsigned    m_max_blocks;
+        block_type* m_blocks;
+        int8u*      m_buf_ptr;
+        unsigned    m_rest;
+    };
+
+
+
+
+
+
+
+
+    //------------------------------------------------------------------------
+    enum quick_sort_threshold_e
+    {
+        quick_sort_threshold = 9
+    };
+
+    
+    //-----------------------------------------------------------swap_elements
+    template<class T> inline void swap_elements(T& a, T& b)
+    {
+        T temp = a;
+        a = b;
+        b = temp;
+    }
+
+
+    //--------------------------------------------------------------quick_sort
+    template<class Array, class Less>
+    void quick_sort(Array& arr, Less less)
+    {
+        if(arr.size() < 2) return;
+
+        typename Array::value_type* e1;
+        typename Array::value_type* e2;
+
+        int  stack[80];
+        int* top = stack; 
+        int  limit = arr.size();
+        int  base = 0;
+
+        for(;;)
+        {
+            int len = limit - base;
+
+            int i;
+            int j;
+            int pivot;
+
+            if(len > quick_sort_threshold)
+            {
+                // we use base + len/2 as the pivot
+                pivot = base + len / 2;
+                swap_elements(arr[base], arr[pivot]);
+
+                i = base + 1;
+                j = limit - 1;
+
+                // now ensure that *i <= *base <= *j 
+                e1 = &(arr[j]); 
+                e2 = &(arr[i]);
+                if(less(*e1, *e2)) swap_elements(*e1, *e2);
+
+                e1 = &(arr[base]); 
+                e2 = &(arr[i]);
+                if(less(*e1, *e2)) swap_elements(*e1, *e2);
+
+                e1 = &(arr[j]); 
+                e2 = &(arr[base]);
+                if(less(*e1, *e2)) swap_elements(*e1, *e2);
+
+                for(;;)
+                {
+                    do i++; while( less(arr[i], arr[base]) );
+                    do j--; while( less(arr[base], arr[j]) );
+
+                    if( i > j )
+                    {
+                        break;
+                    }
+
+                    swap_elements(arr[i], arr[j]);
+                }
+
+                swap_elements(arr[base], arr[j]);
+
+                // now, push the largest sub-array
+                if(j - base > limit - i)
+                {
+                    top[0] = base;
+                    top[1] = j;
+                    base   = i;
+                }
+                else
+                {
+                    top[0] = i;
+                    top[1] = limit;
+                    limit  = j;
+                }
+                top += 2;
+            }
+            else
+            {
+                // the sub-array is small, perform insertion sort
+                j = base;
+                i = j + 1;
+
+                for(; i < limit; j = i, i++)
+                {
+                    for(; less(*(e1 = &(arr[j + 1])), *(e2 = &(arr[j]))); j--)
+                    {
+                        swap_elements(*e1, *e2);
+                        if(j == base)
+                        {
+                            break;
+                        }
+                    }
+                }
+                if(top > stack)
+                {
+                    top  -= 2;
+                    base  = top[0];
+                    limit = top[1];
+                }
+                else
+                {
+                    break;
+                }
+            }
+        }
+    }
+
+
+
+
+    //------------------------------------------------------remove_duplicates
+    // Remove duplicates from a sorted array. It doesn't cut the 
+    // tail of the array, it just returns the number of remaining elements.
+    //-----------------------------------------------------------------------
+    template<class Array, class Equal>
+    unsigned remove_duplicates(Array& arr, Equal equal)
+    {
+        if(arr.size() < 2) return arr.size();
+
+        unsigned i, j;
+        for(i = 1, j = 1; i < arr.size(); i++)
+        {
+            typename Array::value_type& e = arr[i];
+            if(!equal(e, arr[i - 1]))
+            {
+                arr[j++] = e;
+            }
+        }
+        return j;
+    }
+
+    //--------------------------------------------------------invert_container
+    template<class Array> void invert_container(Array& arr)
+    {
+        int i = 0;
+        int j = arr.size() - 1;
+        while(i < j)
+        {
+            swap_elements(arr[i++], arr[j--]);
+        }
+    }
+
+    //------------------------------------------------------binary_search_pos
+    template<class Array, class Value, class Less>
+    unsigned binary_search_pos(const Array& arr, const Value& val, Less less)
+    {
+        if(arr.size() == 0) return 0;
+
+        unsigned beg = 0;
+        unsigned end = arr.size() - 1;
+
+        if(less(val, arr[0])) return 0;
+        if(less(arr[end], val)) return end + 1;
+
+        while(end - beg > 1)
+        {
+            unsigned mid = (end + beg) >> 1;
+            if(less(val, arr[mid])) end = mid; 
+            else                    beg = mid;
+        }
+
+        //if(beg <= 0 && less(val, arr[0])) return 0;
+        //if(end >= arr.size() - 1 && less(arr[end], val)) ++end;
+
+        return end;
+    }
+
+    //----------------------------------------------------------range_adaptor
+    template<class Array> class range_adaptor
+    {
+    public:
+        typedef typename Array::value_type value_type;
+
+        range_adaptor(Array& array, unsigned start, unsigned size) :
+            m_array(array), m_start(start), m_size(size)
+        {}
+
+        unsigned size() const { return m_size; }
+        const value_type& operator [] (unsigned i) const { return m_array[m_start + i]; }
+              value_type& operator [] (unsigned i)       { return m_array[m_start + i]; }
+        const value_type& at(unsigned i) const           { return m_array[m_start + i]; }
+              value_type& at(unsigned i)                 { return m_array[m_start + i]; }
+        value_type  value_at(unsigned i) const           { return m_array[m_start + i]; }
+
+    private:
+        Array& m_array;
+        unsigned m_start;
+        unsigned m_size;
+    };
+
+    //---------------------------------------------------------------int_less
+    inline bool int_less(int a, int b) { return a < b; }
+
+    //------------------------------------------------------------int_greater
+    inline bool int_greater(int a, int b) { return a > b; }
+
+    //----------------------------------------------------------unsigned_less
+    inline bool unsigned_less(unsigned a, unsigned b) { return a < b; }
+
+    //-------------------------------------------------------unsigned_greater
+    inline bool unsigned_greater(unsigned a, unsigned b) { return a > b; }
+}
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_basics.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_basics.h
new file mode 100644
index 0000000000..309713002b
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_basics.h
@@ -0,0 +1,560 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_BASICS_INCLUDED
+#define AGG_BASICS_INCLUDED
+
+#include <math.h>
+#include "agg_config.h"
+
+//---------------------------------------------------------AGG_CUSTOM_ALLOCATOR
+#ifdef AGG_CUSTOM_ALLOCATOR
+#include "agg_allocator.h"
+#else
+namespace agg
+{
+    // The policy of all AGG containers and memory allocation strategy 
+    // in general is that no allocated data requires explicit construction.
+    // It means that the allocator can be really simple; you can even
+    // replace new/delete to malloc/free. The constructors and destructors 
+    // won't be called in this case, however everything will remain working. 
+    // The second argument of deallocate() is the size of the allocated 
+    // block. You can use this information if you wish.
+    //------------------------------------------------------------pod_allocator
+    template<class T> struct pod_allocator
+    {
+        static T*   allocate(unsigned num)       { return new T [num]; }
+        static void deallocate(T* ptr, unsigned) { delete [] ptr;      }
+    };
+
+    // Single object allocator. It's also can be replaced with your custom
+    // allocator. The difference is that it can only allocate a single 
+    // object and the constructor and destructor must be called. 
+    // In AGG there is no need to allocate an array of objects with
+    // calling their constructors (only single ones). So that, if you
+    // replace these new/delete to malloc/free make sure that the in-place
+    // new is called and take care of calling the destructor too.
+    //------------------------------------------------------------obj_allocator
+    template<class T> struct obj_allocator
+    {
+        static T*   allocate()         { return new T; }
+        static void deallocate(T* ptr) { delete ptr;   }
+    };
+}
+#endif
+
+
+//-------------------------------------------------------- Default basic types
+//
+// If the compiler has different capacity of the basic types you can redefine
+// them via the compiler command line or by generating agg_config.h that is
+// empty by default.
+//
+#ifndef AGG_INT8
+#define AGG_INT8 signed char
+#endif
+
+#ifndef AGG_INT8U
+#define AGG_INT8U unsigned char
+#endif
+
+#ifndef AGG_INT16
+#define AGG_INT16 short
+#endif
+
+#ifndef AGG_INT16U
+#define AGG_INT16U unsigned short
+#endif
+
+#ifndef AGG_INT32
+#define AGG_INT32 int
+#endif
+
+#ifndef AGG_INT32U
+#define AGG_INT32U unsigned
+#endif
+
+#ifndef AGG_INT64
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+#define AGG_INT64 signed __int64
+#else
+#define AGG_INT64 signed long long
+#endif
+#endif
+
+#ifndef AGG_INT64U
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+#define AGG_INT64U unsigned __int64
+#else
+#define AGG_INT64U unsigned long long
+#endif
+#endif
+
+//------------------------------------------------ Some fixes for MS Visual C++
+#if defined(_MSC_VER)
+#pragma warning(disable:4786) // Identifier was truncated...
+#endif
+
+#if defined(_MSC_VER)
+#define AGG_INLINE __forceinline
+#else
+#define AGG_INLINE inline
+#endif
+
+namespace agg
+{
+    //-------------------------------------------------------------------------
+    typedef AGG_INT8   int8;         //----int8
+    typedef AGG_INT8U  int8u;        //----int8u
+    typedef AGG_INT16  int16;        //----int16
+    typedef AGG_INT16U int16u;       //----int16u
+    typedef AGG_INT32  int32;        //----int32
+    typedef AGG_INT32U int32u;       //----int32u
+    typedef AGG_INT64  int64;        //----int64
+    typedef AGG_INT64U int64u;       //----int64u
+
+#if defined(AGG_FISTP)
+#pragma warning(push)
+#pragma warning(disable : 4035) //Disable warning "no return value"
+    AGG_INLINE int iround(double v)              //-------iround
+    {
+        int t;
+        __asm fld   qword ptr [v]
+        __asm fistp dword ptr [t]
+        __asm mov eax, dword ptr [t]
+    }
+    AGG_INLINE unsigned uround(double v)         //-------uround
+    {
+        unsigned t;
+        __asm fld   qword ptr [v]
+        __asm fistp dword ptr [t]
+        __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));
+    }
+#elif defined(AGG_QIFIST)
+    AGG_INLINE int iround(double v)
+    {
+        return int(v);
+    }
+    AGG_INLINE int uround(double v)
+    {
+        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));
+    }
+#else
+    AGG_INLINE int iround(double v)
+    {
+        return int((v < 0.0) ? v - 0.5 : v + 0.5);
+    }
+    AGG_INLINE int uround(double v)
+    {
+        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));
+    }
+#endif
+
+    //---------------------------------------------------------------saturation
+    template<int Limit> struct saturation
+    {
+        AGG_INLINE static int iround(double v)
+        {
+            if(v < double(-Limit)) return -Limit;
+            if(v > double( Limit)) return  Limit;
+            return agg::iround(v);
+        }
+    };
+
+    //------------------------------------------------------------------mul_one
+    template<unsigned Shift> struct mul_one
+    {
+        AGG_INLINE static unsigned mul(unsigned a, unsigned b)
+        {
+            unsigned q = a * b + (1 << (Shift-1));
+            return (q + (q >> Shift)) >> Shift;
+        }
+    };
+
+    //-------------------------------------------------------------------------
+    typedef unsigned char cover_type;    //----cover_type
+    enum cover_scale_e
+    {
+        cover_shift = 8,                 //----cover_shift
+        cover_size  = 1 << cover_shift,  //----cover_size 
+        cover_mask  = cover_size - 1,    //----cover_mask 
+        cover_none  = 0,                 //----cover_none 
+        cover_full  = cover_mask         //----cover_full 
+    };
+
+    //----------------------------------------------------poly_subpixel_scale_e
+    // These constants determine the subpixel accuracy, to be more precise, 
+    // the number of bits of the fractional part of the coordinates. 
+    // The possible coordinate capacity in bits can be calculated by formula:
+    // sizeof(int) * 8 - poly_subpixel_shift, i.e, for 32-bit integers and
+    // 8-bits fractional part the capacity is 24 bits.
+    enum poly_subpixel_scale_e
+    {
+        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 
+    };
+
+    //----------------------------------------------------------filling_rule_e
+    enum filling_rule_e
+    {
+        fill_non_zero,
+        fill_even_odd
+    };
+
+    //-----------------------------------------------------------------------pi
+    const double pi = 3.14159265358979323846;
+
+    //------------------------------------------------------------------deg2rad
+    inline double deg2rad(double deg)
+    {
+        return deg * pi / 180.0;
+    }
+
+    //------------------------------------------------------------------rad2deg
+    inline double rad2deg(double rad)
+    {
+        return rad * 180.0 / pi;
+    }
+ 
+    //----------------------------------------------------------------rect_base
+    template<class T> struct rect_base
+    {
+        typedef T            value_type;
+        typedef rect_base<T> self_type;
+        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;
+            if(x1 > x2) { t = x1; x1 = x2; x2 = t; }
+            if(y1 > y2) { t = y1; y1 = y2; y2 = t; }
+            return *this;
+        }
+
+        bool clip(const self_type& r)
+        {
+            if(x2 > r.x2) x2 = r.x2;
+            if(y2 > r.y2) y2 = r.y2;
+            if(x1 < r.x1) x1 = r.x1;
+            if(y1 < r.y1) y1 = r.y1;
+            return x1 <= x2 && y1 <= y2;
+        }
+
+        bool is_valid() const
+        {
+            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
+    template<class Rect> 
+    inline Rect intersect_rectangles(const Rect& r1, const Rect& r2)
+    {
+        Rect r = r1;
+
+        // First process x2,y2 because the other order 
+        // results in Internal Compiler Error under 
+        // Microsoft Visual C++ .NET 2003 69462-335-0000007-18038 in 
+        // case of "Maximize Speed" optimization option.
+        //-----------------
+        if(r.x2 > r2.x2) r.x2 = r2.x2; 
+        if(r.y2 > r2.y2) r.y2 = r2.y2;
+        if(r.x1 < r2.x1) r.x1 = r2.x1;
+        if(r.y1 < r2.y1) r.y1 = r2.y1;
+        return r;
+    }
+
+
+    //---------------------------------------------------------unite_rectangles
+    template<class Rect> 
+    inline Rect unite_rectangles(const Rect& r1, const Rect& r2)
+    {
+        Rect r = r1;
+        if(r.x2 < r2.x2) r.x2 = r2.x2;
+        if(r.y2 < r2.y2) r.y2 = r2.y2;
+        if(r.x1 > r2.x1) r.x1 = r2.x1;
+        if(r.y1 > r2.y1) r.y1 = r2.y1;
+        return r;
+    }
+
+    typedef rect_base<int>    rect_i; //----rect_i
+    typedef rect_base<float>  rect_f; //----rect_f
+    typedef rect_base<double> rect_d; //----rect_d
+
+    //---------------------------------------------------------path_commands_e
+    enum path_commands_e
+    {
+        path_cmd_stop     = 0,        //----path_cmd_stop    
+        path_cmd_move_to  = 1,        //----path_cmd_move_to 
+        path_cmd_line_to  = 2,        //----path_cmd_line_to 
+        path_cmd_curve3   = 3,        //----path_cmd_curve3  
+        path_cmd_curve4   = 4,        //----path_cmd_curve4  
+        path_cmd_curveN   = 5,        //----path_cmd_curveN
+        path_cmd_catrom   = 6,        //----path_cmd_catrom
+        path_cmd_ubspline = 7,        //----path_cmd_ubspline
+        path_cmd_end_poly = 0x0F,     //----path_cmd_end_poly
+        path_cmd_mask     = 0x0F      //----path_cmd_mask    
+    };
+
+    //------------------------------------------------------------path_flags_e
+    enum path_flags_e
+    {
+        path_flags_none  = 0,         //----path_flags_none 
+        path_flags_ccw   = 0x10,      //----path_flags_ccw  
+        path_flags_cw    = 0x20,      //----path_flags_cw   
+        path_flags_close = 0x40,      //----path_flags_close
+        path_flags_mask  = 0xF0       //----path_flags_mask 
+    };
+
+    //---------------------------------------------------------------is_vertex
+    inline bool is_vertex(unsigned c)
+    {
+        return c >= path_cmd_move_to && c < path_cmd_end_poly;
+    }
+
+    //--------------------------------------------------------------is_drawing
+    inline bool is_drawing(unsigned c)
+    {
+        return c >= path_cmd_line_to && c < path_cmd_end_poly;
+    }
+
+    //-----------------------------------------------------------------is_stop
+    inline bool is_stop(unsigned c)
+    { 
+        return c == path_cmd_stop;
+    }
+
+    //--------------------------------------------------------------is_move_to
+    inline bool is_move_to(unsigned c)
+    {
+        return c == path_cmd_move_to;
+    }
+
+    //--------------------------------------------------------------is_line_to
+    inline bool is_line_to(unsigned c)
+    {
+        return c == path_cmd_line_to;
+    }
+
+    //----------------------------------------------------------------is_curve
+    inline bool is_curve(unsigned c)
+    {
+        return c == path_cmd_curve3 || c == path_cmd_curve4;
+    }
+
+    //---------------------------------------------------------------is_curve3
+    inline bool is_curve3(unsigned c)
+    {
+        return c == path_cmd_curve3;
+    }
+
+    //---------------------------------------------------------------is_curve4
+    inline bool is_curve4(unsigned c)
+    {
+        return c == path_cmd_curve4;
+    }
+
+    //-------------------------------------------------------------is_end_poly
+    inline bool is_end_poly(unsigned c)
+    {
+        return (c & path_cmd_mask) == path_cmd_end_poly;
+    }
+
+    //----------------------------------------------------------------is_close
+    inline bool is_close(unsigned c)
+    {
+        return (c & ~(path_flags_cw | path_flags_ccw)) ==
+               (path_cmd_end_poly | path_flags_close); 
+    }
+
+    //------------------------------------------------------------is_next_poly
+    inline bool is_next_poly(unsigned c)
+    {
+        return is_stop(c) || is_move_to(c) || is_end_poly(c);
+    }
+
+    //-------------------------------------------------------------------is_cw
+    inline bool is_cw(unsigned c)
+    {
+        return (c & path_flags_cw) != 0;
+    }
+
+    //------------------------------------------------------------------is_ccw
+    inline bool is_ccw(unsigned c)
+    {
+        return (c & path_flags_ccw) != 0;
+    }
+
+    //-------------------------------------------------------------is_oriented
+    inline bool is_oriented(unsigned c)
+    {
+        return (c & (path_flags_cw | path_flags_ccw)) != 0; 
+    }
+
+    //---------------------------------------------------------------is_closed
+    inline bool is_closed(unsigned c)
+    {
+        return (c & path_flags_close) != 0; 
+    }
+
+    //----------------------------------------------------------get_close_flag
+    inline unsigned get_close_flag(unsigned c)
+    {
+        return c & path_flags_close; 
+    }
+
+    //-------------------------------------------------------clear_orientation
+    inline unsigned clear_orientation(unsigned c)
+    {
+        return c & ~(path_flags_cw | path_flags_ccw);
+    }
+
+    //---------------------------------------------------------get_orientation
+    inline unsigned get_orientation(unsigned c)
+    {
+        return c & (path_flags_cw | path_flags_ccw);
+    }
+
+    //---------------------------------------------------------set_orientation
+    inline unsigned set_orientation(unsigned c, unsigned o)
+    {
+        return clear_orientation(c) | o;
+    }
+
+    //--------------------------------------------------------------point_base
+    template<class T> struct point_base
+    {
+        typedef T value_type;
+        T x,y;
+        point_base() {}
+        point_base(T x_, T y_) : x(x_), y(y_) {}
+    };
+    typedef point_base<int>    point_i; //-----point_i
+    typedef point_base<float>  point_f; //-----point_f
+    typedef point_base<double> point_d; //-----point_d
+
+    //-------------------------------------------------------------vertex_base
+    template<class T> struct vertex_base
+    {
+        typedef T value_type;
+        T x,y;
+        unsigned cmd;
+        vertex_base() {}
+        vertex_base(T x_, T y_, unsigned cmd_) : x(x_), y(y_), cmd(cmd_) {}
+    };
+    typedef vertex_base<int>    vertex_i; //-----vertex_i
+    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);
+    }
+}
+
+
+#endif
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_bezier_arc.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_bezier_arc.h
new file mode 100644
index 0000000000..6d98d1a9f0
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_bezier_arc.h
@@ -0,0 +1,159 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Arc generator. Produces at most 4 consecutive cubic bezier curves, i.e., 
+// 4, 7, 10, or 13 vertices.
+//
+//----------------------------------------------------------------------------
+
+#ifndef AGG_BEZIER_ARC_INCLUDED
+#define AGG_BEZIER_ARC_INCLUDED
+
+#include "agg_conv_transform.h"
+
+namespace agg
+{
+
+    //-----------------------------------------------------------------------
+    void arc_to_bezier(double cx, double cy, double rx, double ry, 
+                       double start_angle, double sweep_angle,
+                       double* curve);
+
+
+    //==============================================================bezier_arc
+    // 
+    // See implemantaion agg_bezier_arc.cpp
+    //
+    class bezier_arc
+    {
+    public:
+        //--------------------------------------------------------------------
+        bezier_arc() : m_vertex(26), m_num_vertices(0), m_cmd(path_cmd_line_to) {}
+        bezier_arc(double x,  double y, 
+                   double rx, double ry, 
+                   double start_angle, 
+                   double sweep_angle)
+        {
+            init(x, y, rx, ry, start_angle, sweep_angle);
+        }
+
+        //--------------------------------------------------------------------
+        void init(double x,  double y, 
+                  double rx, double ry, 
+                  double start_angle, 
+                  double sweep_angle);
+
+        //--------------------------------------------------------------------
+        void rewind(unsigned)
+        {
+            m_vertex = 0;
+        }
+
+        //--------------------------------------------------------------------
+        unsigned vertex(double* x, double* y)
+        {
+            if(m_vertex >= m_num_vertices) return path_cmd_stop;
+            *x = m_vertices[m_vertex];
+            *y = m_vertices[m_vertex + 1];
+            m_vertex += 2;
+            return (m_vertex == 2) ? path_cmd_move_to : m_cmd;
+        }
+
+        // Supplemantary functions. num_vertices() actually returns doubled 
+        // number of vertices. That is, for 1 vertex it returns 2.
+        //--------------------------------------------------------------------
+        unsigned  num_vertices() const { return m_num_vertices; }
+        const double* vertices() const { return m_vertices;     }
+        double*       vertices()       { return m_vertices;     }
+ 
+    private:
+        unsigned m_vertex;
+        unsigned m_num_vertices;
+        double   m_vertices[26];
+        unsigned m_cmd;
+    };
+
+
+
+    //==========================================================bezier_arc_svg
+    // Compute an SVG-style bezier arc. 
+    //
+    // Computes an elliptical arc from (x1, y1) to (x2, y2). The size and 
+    // orientation of the ellipse are defined by two radii (rx, ry) 
+    // and an x-axis-rotation, which indicates how the ellipse as a whole 
+    // is rotated relative to the current coordinate system. The center 
+    // (cx, cy) of the ellipse is calculated automatically to satisfy the 
+    // constraints imposed by the other parameters. 
+    // large-arc-flag and sweep-flag contribute to the automatic calculations 
+    // and help determine how the arc is drawn.
+    class bezier_arc_svg
+    {
+    public:
+        //--------------------------------------------------------------------
+        bezier_arc_svg() : m_arc(), m_radii_ok(false) {}
+
+        bezier_arc_svg(double x1, double y1, 
+                       double rx, double ry, 
+                       double angle,
+                       bool large_arc_flag,
+                       bool sweep_flag,
+                       double x2, double y2) : 
+            m_arc(), m_radii_ok(false)
+        {
+            init(x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2);
+        }
+
+        //--------------------------------------------------------------------
+        void init(double x1, double y1, 
+                  double rx, double ry, 
+                  double angle,
+                  bool large_arc_flag,
+                  bool sweep_flag,
+                  double x2, double y2);
+
+        //--------------------------------------------------------------------
+        bool radii_ok() const { return m_radii_ok; }
+
+        //--------------------------------------------------------------------
+        void rewind(unsigned)
+        {
+            m_arc.rewind(0);
+        }
+
+        //--------------------------------------------------------------------
+        unsigned vertex(double* x, double* y)
+        {
+            return m_arc.vertex(x, y);
+        }
+
+        // Supplemantary functions. num_vertices() actually returns doubled 
+        // number of vertices. That is, for 1 vertex it returns 2.
+        //--------------------------------------------------------------------
+        unsigned  num_vertices() const { return m_arc.num_vertices(); }
+        const double* vertices() const { return m_arc.vertices();     }
+        double*       vertices()       { return m_arc.vertices();     }
+
+    private:
+        bezier_arc m_arc;
+        bool       m_radii_ok;
+    };
+
+
+
+
+}
+
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_clip_liang_barsky.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_clip_liang_barsky.h
new file mode 100644
index 0000000000..4b5fedbab5
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_clip_liang_barsky.h
@@ -0,0 +1,333 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Liang-Barsky clipping 
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_CLIP_LIANG_BARSKY_INCLUDED
+#define AGG_CLIP_LIANG_BARSKY_INCLUDED
+
+#include "agg_basics.h"
+
+namespace agg
+{
+
+    //------------------------------------------------------------------------
+    enum clipping_flags_e
+    {
+        clipping_flags_x1_clipped = 4,
+        clipping_flags_x2_clipped = 1,
+        clipping_flags_y1_clipped = 8,
+        clipping_flags_y2_clipped = 2,
+        clipping_flags_x_clipped = clipping_flags_x1_clipped | clipping_flags_x2_clipped,
+        clipping_flags_y_clipped = clipping_flags_y1_clipped | clipping_flags_y2_clipped
+    };
+
+    //----------------------------------------------------------clipping_flags
+    // Determine the clipping code of the vertex according to the 
+    // Cyrus-Beck line clipping algorithm
+    //
+    //        |        |
+    //  0110  |  0010  | 0011
+    //        |        |
+    // -------+--------+-------- clip_box.y2
+    //        |        |
+    //  0100  |  0000  | 0001
+    //        |        |
+    // -------+--------+-------- clip_box.y1
+    //        |        |
+    //  1100  |  1000  | 1001
+    //        |        |
+    //  clip_box.x1  clip_box.x2
+    //
+    // 
+    template<class T>
+    inline unsigned clipping_flags(T x, T y, const rect_base<T>& clip_box)
+    {
+        return  (x > clip_box.x2) |
+               ((y > clip_box.y2) << 1) |
+               ((x < clip_box.x1) << 2) |
+               ((y < clip_box.y1) << 3);
+    }
+
+    //--------------------------------------------------------clipping_flags_x
+    template<class T>
+    inline unsigned clipping_flags_x(T x, const rect_base<T>& clip_box)
+    {
+        return  (x > clip_box.x2) | ((x < clip_box.x1) << 2);
+    }
+
+
+    //--------------------------------------------------------clipping_flags_y
+    template<class T>
+    inline unsigned clipping_flags_y(T y, const rect_base<T>& clip_box)
+    {
+        return ((y > clip_box.y2) << 1) | ((y < clip_box.y1) << 3);
+    }
+
+
+    //-------------------------------------------------------clip_liang_barsky
+    template<class T>
+    inline unsigned clip_liang_barsky(T x1, T y1, T x2, T y2,
+                                      const rect_base<T>& clip_box,
+                                      T* x, T* y)
+    {
+        const double nearzero = 1e-30;
+
+        double deltax = x2 - x1;
+        double deltay = y2 - y1; 
+        double xin;
+        double xout;
+        double yin;
+        double yout;
+        double tinx;
+        double tiny;
+        double toutx;
+        double touty;  
+        double tin1;
+        double tin2;
+        double tout1;
+        unsigned np = 0;
+
+        if(deltax == 0.0) 
+        {   
+            // bump off of the vertical
+            deltax = (x1 > clip_box.x1) ? -nearzero : nearzero;
+        }
+
+        if(deltay == 0.0) 
+        { 
+            // bump off of the horizontal 
+            deltay = (y1 > clip_box.y1) ? -nearzero : nearzero;
+        }
+        
+        if(deltax > 0.0) 
+        {                
+            // points to right
+            xin  = clip_box.x1;
+            xout = clip_box.x2;
+        }
+        else 
+        {
+            xin  = clip_box.x2;
+            xout = clip_box.x1;
+        }
+
+        if(deltay > 0.0) 
+        {
+            // points up
+            yin  = clip_box.y1;
+            yout = clip_box.y2;
+        }
+        else 
+        {
+            yin  = clip_box.y2;
+            yout = clip_box.y1;
+        }
+        
+        tinx = (xin - x1) / deltax;
+        tiny = (yin - y1) / deltay;
+        
+        if (tinx < tiny) 
+        {
+            // hits x first
+            tin1 = tinx;
+            tin2 = tiny;
+        }
+        else
+        {
+            // hits y first
+            tin1 = tiny;
+            tin2 = tinx;
+        }
+        
+        if(tin1 <= 1.0) 
+        {
+            if(0.0 < tin1) 
+            {
+                *x++ = (T)xin;
+                *y++ = (T)yin;
+                ++np;
+            }
+
+            if(tin2 <= 1.0)
+            {
+                toutx = (xout - x1) / deltax;
+                touty = (yout - y1) / deltay;
+                
+                tout1 = (toutx < touty) ? toutx : touty;
+                
+                if(tin2 > 0.0 || tout1 > 0.0) 
+                {
+                    if(tin2 <= tout1) 
+                    {
+                        if(tin2 > 0.0) 
+                        {
+                            if(tinx > tiny) 
+                            {
+                                *x++ = (T)xin;
+                                *y++ = (T)(y1 + tinx * deltay);
+                            }
+                            else 
+                            {
+                                *x++ = (T)(x1 + tiny * deltax);
+                                *y++ = (T)yin;
+                            }
+                            ++np;
+                        }
+
+                        if(tout1 < 1.0) 
+                        {
+                            if(toutx < touty) 
+                            {
+                                *x++ = (T)xout;
+                                *y++ = (T)(y1 + toutx * deltay);
+                            }
+                            else 
+                            {
+                                *x++ = (T)(x1 + touty * deltax);
+                                *y++ = (T)yout;
+                            }
+                        }
+                        else 
+                        {
+                            *x++ = x2;
+                            *y++ = y2;
+                        }
+                        ++np;
+                    }
+                    else 
+                    {
+                        if(tinx > tiny) 
+                        {
+                            *x++ = (T)xin;
+                            *y++ = (T)yout;
+                        }
+                        else 
+                        {
+                            *x++ = (T)xout;
+                            *y++ = (T)yin;
+                        }
+                        ++np;
+                    }
+                }
+            }
+        }
+        return np;
+    }
+
+
+    //----------------------------------------------------------------------------
+    template<class T>
+    bool clip_move_point(T x1, T y1, T x2, T y2, 
+                         const rect_base<T>& clip_box, 
+                         T* x, T* y, unsigned flags)
+    {
+       T bound;
+
+       if(flags & clipping_flags_x_clipped)
+       {
+           if(x1 == x2)
+           {
+               return false;
+           }
+           bound = (flags & clipping_flags_x1_clipped) ? clip_box.x1 : clip_box.x2;
+           *y = (T)(double(bound - x1) * (y2 - y1) / (x2 - x1) + y1);
+           *x = bound;
+       }
+
+       flags = clipping_flags_y(*y, clip_box);
+       if(flags & clipping_flags_y_clipped)
+       {
+           if(y1 == y2)
+           {
+               return false;
+           }
+           bound = (flags & clipping_flags_y1_clipped) ? clip_box.y1 : clip_box.y2;
+           *x = (T)(double(bound - y1) * (x2 - x1) / (y2 - y1) + x1);
+           *y = bound;
+       }
+       return true;
+    }
+
+    //-------------------------------------------------------clip_line_segment
+    // Returns: ret >= 4        - Fully clipped
+    //          (ret & 1) != 0  - First point has been moved
+    //          (ret & 2) != 0  - Second point has been moved
+    //
+    template<class T>
+    unsigned clip_line_segment(T* x1, T* y1, T* x2, T* y2,
+                               const rect_base<T>& clip_box)
+    {
+        unsigned f1 = clipping_flags(*x1, *y1, clip_box);
+        unsigned f2 = clipping_flags(*x2, *y2, clip_box);
+        unsigned ret = 0;
+
+        if((f2 | f1) == 0)
+        {
+            // Fully visible
+            return 0;
+        }
+
+        if((f1 & clipping_flags_x_clipped) != 0 && 
+           (f1 & clipping_flags_x_clipped) == (f2 & clipping_flags_x_clipped))
+        {
+            // Fully clipped
+            return 4;
+        }
+
+        if((f1 & clipping_flags_y_clipped) != 0 && 
+           (f1 & clipping_flags_y_clipped) == (f2 & clipping_flags_y_clipped))
+        {
+            // Fully clipped
+            return 4;
+        }
+
+        T tx1 = *x1;
+        T ty1 = *y1;
+        T tx2 = *x2;
+        T ty2 = *y2;
+        if(f1) 
+        {   
+            if(!clip_move_point(tx1, ty1, tx2, ty2, clip_box, x1, y1, f1)) 
+            {
+                return 4;
+            }
+            if(*x1 == *x2 && *y1 == *y2) 
+            {
+                return 4;
+            }
+            ret |= 1;
+        }
+        if(f2) 
+        {
+            if(!clip_move_point(tx1, ty1, tx2, ty2, clip_box, x2, y2, f2))
+            {
+                return 4;
+            }
+            if(*x1 == *x2 && *y1 == *y2) 
+            {
+                return 4;
+            }
+            ret |= 2;
+        }
+        return ret;
+    }
+
+
+}
+
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_color_gray.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_color_gray.h
new file mode 100644
index 0000000000..8d5f2ed8d0
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_color_gray.h
@@ -0,0 +1,1047 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Adaptation for high precision colors has been sponsored by
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+//
+//----------------------------------------------------------------------------
+//
+// color types gray8, gray16
+//
+//----------------------------------------------------------------------------
+
+#ifndef AGG_COLOR_GRAY_INCLUDED
+#define AGG_COLOR_GRAY_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_color_rgba.h"
+
+namespace agg
+{
+
+    //===================================================================gray8
+    template<class Colorspace>
+    struct gray8T
+    {
+        typedef int8u  value_type;
+        typedef int32u calc_type;
+        typedef int32  long_type;
+        enum base_scale_e
+        {
+            base_shift = 8,
+            base_scale = 1 << base_shift,
+            base_mask  = base_scale - 1,
+            base_MSB = 1 << (base_shift - 1)
+        };
+        typedef gray8T self_type;
+
+        value_type v;
+        value_type a;
+
+        static value_type luminance(const rgba& c)
+        {
+            // Calculate grayscale value as per ITU-R BT.709.
+            return value_type(uround((0.2126 * c.r + 0.7152 * c.g + 0.0722 * c.b) * base_mask));
+        }
+
+        static value_type luminance(const rgba8& c)
+        {
+            // Calculate grayscale value as per ITU-R BT.709.
+            return value_type((55u * c.r + 184u * c.g + 18u * c.b) >> 8);
+        }
+
+        static void convert(gray8T<linear>& dst, const gray8T<sRGB>& src)
+        {
+            dst.v = sRGB_conv<value_type>::rgb_from_sRGB(src.v);
+            dst.a = src.a;
+        }
+
+        static void convert(gray8T<sRGB>& dst, const gray8T<linear>& src)
+        {
+            dst.v = sRGB_conv<value_type>::rgb_to_sRGB(src.v);
+            dst.a = src.a;
+        }
+
+        static void convert(gray8T<linear>& dst, const rgba8& src)
+        {
+            dst.v = luminance(src);
+            dst.a = src.a;
+        }
+
+        static void convert(gray8T<linear>& dst, const srgba8& src)
+        {
+            // The RGB weights are only valid for linear values.
+            convert(dst, rgba8(src));
+        }
+
+        static void convert(gray8T<sRGB>& dst, const rgba8& src)
+        {
+            dst.v = sRGB_conv<value_type>::rgb_to_sRGB(luminance(src));
+            dst.a = src.a;
+        }
+
+        static void convert(gray8T<sRGB>& dst, const srgba8& src)
+        {
+            // The RGB weights are only valid for linear values.
+            convert(dst, rgba8(src));
+        }
+
+        //--------------------------------------------------------------------
+        gray8T() {}
+
+        //--------------------------------------------------------------------
+        explicit gray8T(unsigned v_, unsigned a_ = base_mask) :
+            v(int8u(v_)), a(int8u(a_)) {}
+
+        //--------------------------------------------------------------------
+        gray8T(const self_type& c, unsigned a_) :
+            v(c.v), a(value_type(a_)) {}
+
+        //--------------------------------------------------------------------
+        gray8T(const rgba& c) :
+            v(luminance(c)),
+            a(value_type(uround(c.a * base_mask))) {}
+
+        //--------------------------------------------------------------------
+        template<class T>
+        gray8T(const gray8T<T>& c)
+        {
+            convert(*this, c);
+        }
+
+        //--------------------------------------------------------------------
+        template<class T>
+        gray8T(const rgba8T<T>& c)
+        {
+            convert(*this, c);
+        }
+
+        //--------------------------------------------------------------------
+        template<class T>
+        T convert_from_sRGB() const
+        {
+            typename T::value_type y = sRGB_conv<typename T::value_type>::rgb_from_sRGB(v);
+            return T(y, y, y, sRGB_conv<typename T::value_type>::alpha_from_sRGB(a));
+        }
+
+        template<class T>
+        T convert_to_sRGB() const
+        {
+            typename T::value_type y = sRGB_conv<typename T::value_type>::rgb_to_sRGB(v);
+            return T(y, y, y, sRGB_conv<typename T::value_type>::alpha_to_sRGB(a));
+        }
+
+        //--------------------------------------------------------------------
+        rgba8 make_rgba8(const linear&) const
+        {
+            return rgba8(v, v, v, a);
+        }
+
+        rgba8 make_rgba8(const sRGB&) const
+        {
+            return convert_from_sRGB<srgba8>();
+        }
+
+        operator rgba8() const
+        {
+            return make_rgba8(Colorspace());
+        }
+
+        //--------------------------------------------------------------------
+        srgba8 make_srgba8(const linear&) const
+        {
+            return convert_to_sRGB<rgba8>();
+        }
+
+        srgba8 make_srgba8(const sRGB&) const
+        {
+            return srgba8(v, v, v, a);
+        }
+
+        operator srgba8() const
+        {
+            return make_rgba8(Colorspace());
+        }
+
+        //--------------------------------------------------------------------
+        rgba16 make_rgba16(const linear&) const
+        {
+            rgba16::value_type rgb = (v << 8) | v;
+            return rgba16(rgb, rgb, rgb, (a << 8) | a);
+        }
+
+        rgba16 make_rgba16(const sRGB&) const
+        {
+            return convert_from_sRGB<rgba16>();
+        }
+
+        operator rgba16() const
+        {
+            return make_rgba16(Colorspace());
+        }
+
+        //--------------------------------------------------------------------
+        rgba32 make_rgba32(const linear&) const
+        {
+            rgba32::value_type v32 = v / 255.0f;
+            return rgba32(v32, v32, v32, a / 255.0f);
+        }
+
+        rgba32 make_rgba32(const sRGB&) const
+        {
+            return convert_from_sRGB<rgba32>();
+        }
+
+        operator rgba32() const
+        {
+            return make_rgba32(Colorspace());
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE double to_double(value_type a)
+        {
+            return double(a) / base_mask;
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type from_double(double a)
+        {
+            return value_type(uround(a * base_mask));
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type empty_value()
+        {
+            return 0;
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type full_value()
+        {
+            return base_mask;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE bool is_transparent() const
+        {
+            return a == 0;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE bool is_opaque() const
+        {
+            return a == base_mask;
+        }
+
+        //--------------------------------------------------------------------
+        // Fixed-point multiply, exact over int8u.
+        static AGG_INLINE value_type multiply(value_type a, value_type b)
+        {
+            calc_type t = a * b + base_MSB;
+            return value_type(((t >> base_shift) + t) >> base_shift);
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type demultiply(value_type a, value_type b)
+        {
+            if (a * b == 0)
+            {
+                return 0;
+            }
+            else if (a >= b)
+            {
+                return base_mask;
+            }
+            else return value_type((a * base_mask + (b >> 1)) / b);
+        }
+
+        //--------------------------------------------------------------------
+        template<typename T>
+        static AGG_INLINE T downscale(T a)
+        {
+            return a >> base_shift;
+        }
+
+        //--------------------------------------------------------------------
+        template<typename T>
+        static AGG_INLINE T downshift(T a, unsigned n)
+        {
+            return a >> n;
+        }
+
+        //--------------------------------------------------------------------
+        // Fixed-point multiply, exact over int8u.
+        // Specifically for multiplying a color component by a cover.
+        static AGG_INLINE value_type mult_cover(value_type a, value_type b)
+        {
+            return multiply(a, b);
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
+        {
+            return multiply(b, a);
+        }
+
+        //--------------------------------------------------------------------
+        // Interpolate p to q by a, assuming q is premultiplied by a.
+        static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a)
+        {
+            return p + q - multiply(p, a);
+        }
+
+        //--------------------------------------------------------------------
+        // Interpolate p to q by a.
+        static AGG_INLINE value_type lerp(value_type p, value_type q, value_type a)
+        {
+            int t = (q - p) * a + base_MSB - (p > q);
+            return value_type(p + (((t >> base_shift) + t) >> base_shift));
+        }
+
+        //--------------------------------------------------------------------
+        self_type& clear()
+        {
+            v = a = 0;
+			return *this;
+        }
+
+        //--------------------------------------------------------------------
+        self_type& transparent()
+        {
+            a = 0;
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        self_type& opacity(double a_)
+        {
+            if (a_ < 0) a = 0;
+            else if (a_ > 1) a = 1;
+            else a = (value_type)uround(a_ * double(base_mask));
+			return *this;
+        }
+
+        //--------------------------------------------------------------------
+        double opacity() const
+        {
+            return double(a) / double(base_mask);
+        }
+
+        //--------------------------------------------------------------------
+        self_type& premultiply()
+        {
+            if (a < base_mask)
+            {
+                if (a == 0) v = 0;
+                else v = multiply(v, a);
+            }
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        self_type& demultiply()
+        {
+            if (a < base_mask)
+            {
+                if (a == 0)
+                {
+                    v = 0;
+                }
+                else
+                {
+                    calc_type v_ = (calc_type(v) * base_mask) / a;
+                    v = value_type((v_ > base_mask) ? (value_type)base_mask : v_);
+                }
+            }
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        self_type gradient(self_type c, double k) const
+        {
+            self_type ret;
+            calc_type ik = uround(k * base_scale);
+            ret.v = lerp(v, c.v, ik);
+            ret.a = lerp(a, c.a, ik);
+            return ret;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void add(const self_type& c, unsigned cover)
+        {
+            calc_type cv, ca;
+            if (cover == cover_mask)
+            {
+                if (c.a == base_mask)
+                {
+                    *this = c;
+                    return;
+                }
+                else
+                {
+                    cv = v + c.v;
+                    ca = a + c.a;
+                }
+            }
+            else
+            {
+                cv = v + mult_cover(c.v, cover);
+                ca = a + mult_cover(c.a, cover);
+            }
+            v = (value_type)((cv > calc_type(base_mask)) ? calc_type(base_mask) : cv);
+            a = (value_type)((ca > calc_type(base_mask)) ? calc_type(base_mask) : ca);
+        }
+
+        //--------------------------------------------------------------------
+        static self_type no_color() { return self_type(0,0); }
+    };
+
+    typedef gray8T<linear> gray8;
+    typedef gray8T<sRGB> sgray8;
+
+
+    //==================================================================gray16
+    struct gray16
+    {
+        typedef int16u value_type;
+        typedef int32u calc_type;
+        typedef int64  long_type;
+        enum base_scale_e
+        {
+            base_shift = 16,
+            base_scale = 1 << base_shift,
+            base_mask  = base_scale - 1,
+            base_MSB = 1 << (base_shift - 1)
+        };
+        typedef gray16 self_type;
+
+        value_type v;
+        value_type a;
+
+        static value_type luminance(const rgba& c)
+        {
+            // Calculate grayscale value as per ITU-R BT.709.
+            return value_type(uround((0.2126 * c.r + 0.7152 * c.g + 0.0722 * c.b) * base_mask));
+        }
+
+        static value_type luminance(const rgba16& c)
+        {
+            // Calculate grayscale value as per ITU-R BT.709.
+            return value_type((13933u * c.r + 46872u * c.g + 4732u * c.b) >> 16);
+        }
+
+        static value_type luminance(const rgba8& c)
+        {
+            return luminance(rgba16(c));
+        }
+
+        static value_type luminance(const srgba8& c)
+        {
+            return luminance(rgba16(c));
+        }
+
+        static value_type luminance(const rgba32& c)
+        {
+            return luminance(rgba(c));
+        }
+
+        //--------------------------------------------------------------------
+        gray16() {}
+
+        //--------------------------------------------------------------------
+        explicit gray16(unsigned v_, unsigned a_ = base_mask) :
+            v(int16u(v_)), a(int16u(a_)) {}
+
+        //--------------------------------------------------------------------
+        gray16(const self_type& c, unsigned a_) :
+            v(c.v), a(value_type(a_)) {}
+
+        //--------------------------------------------------------------------
+        gray16(const rgba& c) :
+            v(luminance(c)),
+            a((value_type)uround(c.a * double(base_mask))) {}
+
+        //--------------------------------------------------------------------
+        gray16(const rgba8& c) :
+            v(luminance(c)),
+            a((value_type(c.a) << 8) | c.a) {}
+
+        //--------------------------------------------------------------------
+        gray16(const srgba8& c) :
+            v(luminance(c)),
+            a((value_type(c.a) << 8) | c.a) {}
+
+        //--------------------------------------------------------------------
+        gray16(const rgba16& c) :
+            v(luminance(c)),
+            a(c.a) {}
+
+        //--------------------------------------------------------------------
+        gray16(const gray8& c) :
+            v((value_type(c.v) << 8) | c.v),
+            a((value_type(c.a) << 8) | c.a) {}
+
+        //--------------------------------------------------------------------
+        gray16(const sgray8& c) :
+            v(sRGB_conv<value_type>::rgb_from_sRGB(c.v)),
+            a(sRGB_conv<value_type>::alpha_from_sRGB(c.a)) {}
+
+        //--------------------------------------------------------------------
+        operator rgba8() const
+        {
+            return rgba8(v >> 8, v >> 8, v >> 8, a >> 8);
+        }
+
+        //--------------------------------------------------------------------
+        operator srgba8() const
+        {
+            value_type y = sRGB_conv<value_type>::rgb_to_sRGB(v);
+            return srgba8(y, y, y, sRGB_conv<value_type>::alpha_to_sRGB(a));
+        }
+
+        //--------------------------------------------------------------------
+        operator rgba16() const
+        {
+            return rgba16(v, v, v, a);
+        }
+
+		//--------------------------------------------------------------------
+		operator rgba32() const
+		{
+			rgba32::value_type v32 = v / 65535.0f;
+			return rgba32(v32, v32, v32, a / 65535.0f);
+		}
+
+		//--------------------------------------------------------------------
+        operator gray8() const
+        {
+            return gray8(v >> 8, a >> 8);
+        }
+
+        //--------------------------------------------------------------------
+        operator sgray8() const
+        {
+            return sgray8(
+                sRGB_conv<value_type>::rgb_to_sRGB(v),
+                sRGB_conv<value_type>::alpha_to_sRGB(a));
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE double to_double(value_type a)
+        {
+            return double(a) / base_mask;
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type from_double(double a)
+        {
+            return value_type(uround(a * base_mask));
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type empty_value()
+        {
+            return 0;
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type full_value()
+        {
+            return base_mask;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE bool is_transparent() const
+        {
+            return a == 0;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE bool is_opaque() const
+        {
+            return a == base_mask;
+        }
+
+        //--------------------------------------------------------------------
+        // Fixed-point multiply, exact over int16u.
+        static AGG_INLINE value_type multiply(value_type a, value_type b)
+        {
+            calc_type t = a * b + base_MSB;
+            return value_type(((t >> base_shift) + t) >> base_shift);
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type demultiply(value_type a, value_type b)
+        {
+            if (a * b == 0)
+            {
+                return 0;
+            }
+            else if (a >= b)
+            {
+                return base_mask;
+            }
+            else return value_type((a * base_mask + (b >> 1)) / b);
+        }
+
+        //--------------------------------------------------------------------
+        template<typename T>
+        static AGG_INLINE T downscale(T a)
+        {
+            return a >> base_shift;
+        }
+
+        //--------------------------------------------------------------------
+        template<typename T>
+        static AGG_INLINE T downshift(T a, unsigned n)
+        {
+            return a >> n;
+        }
+
+        //--------------------------------------------------------------------
+        // Fixed-point multiply, almost exact over int16u.
+        // Specifically for multiplying a color component by a cover.
+        static AGG_INLINE value_type mult_cover(value_type a, cover_type b)
+        {
+            return multiply(a, b << 8 | b);
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
+        {
+            return mult_cover(b, a) >> 8;
+        }
+
+        //--------------------------------------------------------------------
+        // Interpolate p to q by a, assuming q is premultiplied by a.
+        static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a)
+        {
+            return p + q - multiply(p, a);
+        }
+
+        //--------------------------------------------------------------------
+        // Interpolate p to q by a.
+        static AGG_INLINE value_type lerp(value_type p, value_type q, value_type a)
+        {
+            int t = (q - p) * a + base_MSB - (p > q);
+            return value_type(p + (((t >> base_shift) + t) >> base_shift));
+        }
+
+        //--------------------------------------------------------------------
+        self_type& clear()
+        {
+            v = a = 0;
+			return *this;
+        }
+
+        //--------------------------------------------------------------------
+        self_type& transparent()
+        {
+            a = 0;
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        self_type& opacity(double a_)
+        {
+            if (a_ < 0) a = 0;
+            else if(a_ > 1) a = 1;
+            else a = (value_type)uround(a_ * double(base_mask));
+			return *this;
+        }
+
+        //--------------------------------------------------------------------
+        double opacity() const
+        {
+            return double(a) / double(base_mask);
+        }
+
+
+        //--------------------------------------------------------------------
+        self_type& premultiply()
+        {
+            if (a < base_mask)
+            {
+                if(a == 0) v = 0;
+                else v = multiply(v, a);
+            }
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        self_type& demultiply()
+        {
+            if (a < base_mask)
+            {
+                if (a == 0)
+                {
+                    v = 0;
+                }
+                else
+                {
+                    calc_type v_ = (calc_type(v) * base_mask) / a;
+                    v = value_type((v_ > base_mask) ? base_mask : v_);
+                }
+            }
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        self_type gradient(self_type c, double k) const
+        {
+            self_type ret;
+            calc_type ik = uround(k * base_scale);
+            ret.v = lerp(v, c.v, ik);
+            ret.a = lerp(a, c.a, ik);
+            return ret;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void add(const self_type& c, unsigned cover)
+        {
+            calc_type cv, ca;
+            if (cover == cover_mask)
+            {
+                if (c.a == base_mask)
+                {
+                    *this = c;
+                    return;
+                }
+                else
+                {
+                    cv = v + c.v;
+                    ca = a + c.a;
+                }
+            }
+            else
+            {
+                cv = v + mult_cover(c.v, cover);
+                ca = a + mult_cover(c.a, cover);
+            }
+            v = (value_type)((cv > calc_type(base_mask)) ? calc_type(base_mask) : cv);
+            a = (value_type)((ca > calc_type(base_mask)) ? calc_type(base_mask) : ca);
+        }
+
+        //--------------------------------------------------------------------
+        static self_type no_color() { return self_type(0,0); }
+    };
+
+
+    //===================================================================gray32
+    struct gray32
+    {
+        typedef float value_type;
+        typedef double calc_type;
+        typedef double long_type;
+        typedef gray32 self_type;
+
+        value_type v;
+        value_type a;
+
+        // Calculate grayscale value as per ITU-R BT.709.
+        static value_type luminance(double r, double g, double b)
+        {
+            return value_type(0.2126 * r + 0.7152 * g + 0.0722 * b);
+        }
+
+        static value_type luminance(const rgba& c)
+        {
+            return luminance(c.r, c.g, c.b);
+        }
+
+        static value_type luminance(const rgba32& c)
+        {
+            return luminance(c.r, c.g, c.b);
+        }
+
+        static value_type luminance(const rgba8& c)
+        {
+            return luminance(c.r / 255.0, c.g / 255.0, c.g / 255.0);
+        }
+
+        static value_type luminance(const rgba16& c)
+        {
+            return luminance(c.r / 65535.0, c.g / 65535.0, c.g / 65535.0);
+        }
+
+        //--------------------------------------------------------------------
+        gray32() {}
+
+        //--------------------------------------------------------------------
+        explicit gray32(value_type v_, value_type a_ = 1) :
+            v(v_), a(a_) {}
+
+        //--------------------------------------------------------------------
+        gray32(const self_type& c, value_type a_) :
+            v(c.v), a(a_) {}
+
+        //--------------------------------------------------------------------
+        gray32(const rgba& c) :
+            v(luminance(c)),
+            a(value_type(c.a)) {}
+
+        //--------------------------------------------------------------------
+        gray32(const rgba8& c) :
+            v(luminance(c)),
+            a(value_type(c.a / 255.0)) {}
+
+        //--------------------------------------------------------------------
+        gray32(const srgba8& c) :
+            v(luminance(rgba32(c))),
+            a(value_type(c.a / 255.0)) {}
+
+        //--------------------------------------------------------------------
+        gray32(const rgba16& c) :
+            v(luminance(c)),
+            a(value_type(c.a / 65535.0)) {}
+
+        //--------------------------------------------------------------------
+        gray32(const rgba32& c) :
+            v(luminance(c)),
+            a(value_type(c.a)) {}
+
+        //--------------------------------------------------------------------
+        gray32(const gray8& c) :
+            v(value_type(c.v / 255.0)),
+            a(value_type(c.a / 255.0)) {}
+
+        //--------------------------------------------------------------------
+        gray32(const sgray8& c) :
+            v(sRGB_conv<value_type>::rgb_from_sRGB(c.v)),
+            a(sRGB_conv<value_type>::alpha_from_sRGB(c.a)) {}
+
+        //--------------------------------------------------------------------
+        gray32(const gray16& c) :
+            v(value_type(c.v / 65535.0)),
+            a(value_type(c.a / 65535.0)) {}
+
+        //--------------------------------------------------------------------
+        operator rgba() const
+        {
+            return rgba(v, v, v, a);
+        }
+
+        //--------------------------------------------------------------------
+        operator gray8() const
+        {
+            return gray8(uround(v * 255.0), uround(a * 255.0));
+        }
+
+        //--------------------------------------------------------------------
+        operator sgray8() const
+        {
+            // Return (non-premultiplied) sRGB values.
+            return sgray8(
+                sRGB_conv<value_type>::rgb_to_sRGB(v),
+                sRGB_conv<value_type>::alpha_to_sRGB(a));
+        }
+
+        //--------------------------------------------------------------------
+        operator gray16() const
+        {
+            return gray16(uround(v * 65535.0), uround(a * 65535.0));
+        }
+
+        //--------------------------------------------------------------------
+        operator rgba8() const
+        {
+            rgba8::value_type y = uround(v * 255.0);
+            return rgba8(y, y, y, uround(a * 255.0));
+        }
+
+        //--------------------------------------------------------------------
+        operator srgba8() const
+        {
+            srgba8::value_type y = sRGB_conv<value_type>::rgb_to_sRGB(v);
+            return srgba8(y, y, y, sRGB_conv<value_type>::alpha_to_sRGB(a));
+        }
+
+		//--------------------------------------------------------------------
+		operator rgba16() const
+		{
+			rgba16::value_type y = uround(v * 65535.0);
+			return rgba16(y, y, y, uround(a * 65535.0));
+		}
+
+		//--------------------------------------------------------------------
+		operator rgba32() const
+		{
+            return rgba32(v, v, v, a);
+		}
+
+		//--------------------------------------------------------------------
+        static AGG_INLINE double to_double(value_type a)
+        {
+            return a;
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type from_double(double a)
+        {
+            return value_type(a);
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type empty_value()
+        {
+            return 0;
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type full_value()
+        {
+            return 1;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE bool is_transparent() const
+        {
+            return a <= 0;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE bool is_opaque() const
+        {
+            return a >= 1;
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type invert(value_type x)
+        {
+            return 1 - x;
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type multiply(value_type a, value_type b)
+        {
+            return value_type(a * b);
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type demultiply(value_type a, value_type b)
+        {
+            return (b == 0) ? 0 : value_type(a / b);
+        }
+
+        //--------------------------------------------------------------------
+        template<typename T>
+        static AGG_INLINE T downscale(T a)
+        {
+            return a;
+        }
+
+        //--------------------------------------------------------------------
+        template<typename T>
+        static AGG_INLINE T downshift(T a, unsigned n)
+        {
+            return n > 0 ? a / (1 << n) : a;
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type mult_cover(value_type a, cover_type b)
+        {
+            return value_type(a * b / cover_mask);
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
+        {
+            return cover_type(uround(a * b));
+        }
+
+        //--------------------------------------------------------------------
+        // Interpolate p to q by a, assuming q is premultiplied by a.
+        static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a)
+        {
+            return (1 - a) * p + q; // more accurate than "p + q - p * a"
+        }
+
+        //--------------------------------------------------------------------
+        // Interpolate p to q by a.
+        static AGG_INLINE value_type lerp(value_type p, value_type q, value_type a)
+        {
+			// The form "p + a * (q - p)" avoids a multiplication, but may produce an
+			// inaccurate result. For example, "p + (q - p)" may not be exactly equal
+			// to q. Therefore, stick to the basic expression, which at least produces
+			// the correct result at either extreme.
+			return (1 - a) * p + a * q;
+        }
+
+        //--------------------------------------------------------------------
+        self_type& clear()
+        {
+            v = a = 0;
+			return *this;
+        }
+
+        //--------------------------------------------------------------------
+        self_type& transparent()
+        {
+            a = 0;
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        self_type& opacity(double a_)
+        {
+            if (a_ < 0) a = 0;
+            else if (a_ > 1) a = 1;
+            else a = value_type(a_);
+			return *this;
+        }
+
+        //--------------------------------------------------------------------
+        double opacity() const
+        {
+            return a;
+        }
+
+
+        //--------------------------------------------------------------------
+        self_type& premultiply()
+        {
+            if (a < 0) v = 0;
+            else if(a < 1) v *= a;
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        self_type& demultiply()
+        {
+            if (a < 0) v = 0;
+            else if (a < 1) v /= a;
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        self_type gradient(self_type c, double k) const
+        {
+            return self_type(
+                value_type(v + (c.v - v) * k),
+                value_type(a + (c.a - a) * k));
+        }
+
+        //--------------------------------------------------------------------
+        static self_type no_color() { return self_type(0,0); }
+    };
+}
+
+
+
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_color_rgba.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_color_rgba.h
new file mode 100644
index 0000000000..74f871be17
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_color_rgba.h
@@ -0,0 +1,1353 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+//
+// Adaptation for high precision colors has been sponsored by
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_COLOR_RGBA_INCLUDED
+#define AGG_COLOR_RGBA_INCLUDED
+
+#include <math.h>
+#include "agg_basics.h"
+#include "agg_gamma_lut.h"
+
+namespace agg
+{
+    // Supported component orders for RGB and RGBA pixel formats
+    //=======================================================================
+    struct order_rgb  { enum rgb_e  { R=0, G=1, B=2, N=3 }; };
+    struct order_bgr  { enum bgr_e  { B=0, G=1, R=2, N=3 }; };
+    struct order_rgba { enum rgba_e { R=0, G=1, B=2, A=3, N=4 }; };
+    struct order_argb { enum argb_e { A=0, R=1, G=2, B=3, N=4 }; };
+    struct order_abgr { enum abgr_e { A=0, B=1, G=2, R=3, N=4 }; };
+    struct order_bgra { enum bgra_e { B=0, G=1, R=2, A=3, N=4 }; };
+
+    // Colorspace tag types.
+    struct linear {};
+    struct sRGB {};
+
+    //====================================================================rgba
+    struct rgba
+    {
+        typedef double value_type;
+
+        double r;
+        double g;
+        double b;
+        double a;
+
+        //--------------------------------------------------------------------
+        rgba() {}
+
+        //--------------------------------------------------------------------
+        rgba(double r_, double g_, double b_, double a_=1.0) :
+            r(r_), g(g_), b(b_), a(a_) {}
+
+        //--------------------------------------------------------------------
+        rgba(const rgba& c, double a_) : r(c.r), g(c.g), b(c.b), a(a_) {}
+
+        //--------------------------------------------------------------------
+        rgba& clear()
+        {
+            r = g = b = a = 0;
+			return *this;
+        }
+
+        //--------------------------------------------------------------------
+        rgba& transparent()
+        {
+            a = 0;
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        rgba& opacity(double a_)
+        {
+            if (a_ < 0) a = 0;
+            else if (a_ > 1) a = 1;
+            else a = a_;
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        double opacity() const
+        {
+            return a;
+        }
+
+        //--------------------------------------------------------------------
+        rgba& premultiply()
+        {
+            r *= a;
+            g *= a;
+            b *= a;
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        rgba& premultiply(double a_)
+        {
+            if (a <= 0 || a_ <= 0)
+            {
+                r = g = b = a = 0;
+            }
+            else
+            {
+                a_ /= a;
+                r *= a_;
+                g *= a_;
+                b *= a_;
+                a  = a_;
+            }
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        rgba& demultiply()
+        {
+            if (a == 0)
+            {
+                r = g = b = 0;
+            }
+            else
+            {
+                double a_ = 1.0 / a;
+                r *= a_;
+                g *= a_;
+                b *= a_;
+            }
+            return *this;
+        }
+
+
+        //--------------------------------------------------------------------
+        rgba gradient(rgba c, double k) const
+        {
+            rgba ret;
+            ret.r = r + (c.r - r) * k;
+            ret.g = g + (c.g - g) * k;
+            ret.b = b + (c.b - b) * k;
+            ret.a = a + (c.a - a) * k;
+            return ret;
+        }
+
+        rgba& operator+=(const rgba& c)
+        {
+            r += c.r;
+            g += c.g;
+            b += c.b;
+            a += c.a;
+            return *this;
+        }
+
+        rgba& operator*=(double k)
+        {
+            r *= k;
+            g *= k;
+            b *= k;
+            a *= k;
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        static rgba no_color() { return rgba(0,0,0,0); }
+
+        //--------------------------------------------------------------------
+        static rgba from_wavelength(double wl, double gamma = 1.0);
+
+        //--------------------------------------------------------------------
+        explicit rgba(double wavelen, double gamma=1.0)
+        {
+            *this = from_wavelength(wavelen, gamma);
+        }
+
+    };
+
+    inline rgba operator+(const rgba& a, const rgba& b)
+    {
+        return rgba(a) += b;
+    }
+
+    inline rgba operator*(const rgba& a, double b)
+    {
+        return rgba(a) *= b;
+    }
+
+    //------------------------------------------------------------------------
+    inline rgba rgba::from_wavelength(double wl, double gamma)
+    {
+        rgba t(0.0, 0.0, 0.0);
+
+        if (wl >= 380.0 && wl <= 440.0)
+        {
+            t.r = -1.0 * (wl - 440.0) / (440.0 - 380.0);
+            t.b = 1.0;
+        }
+        else if (wl >= 440.0 && wl <= 490.0)
+        {
+            t.g = (wl - 440.0) / (490.0 - 440.0);
+            t.b = 1.0;
+        }
+        else if (wl >= 490.0 && wl <= 510.0)
+        {
+            t.g = 1.0;
+            t.b = -1.0 * (wl - 510.0) / (510.0 - 490.0);
+        }
+        else if (wl >= 510.0 && wl <= 580.0)
+        {
+            t.r = (wl - 510.0) / (580.0 - 510.0);
+            t.g = 1.0;
+        }
+        else if (wl >= 580.0 && wl <= 645.0)
+        {
+            t.r = 1.0;
+            t.g = -1.0 * (wl - 645.0) / (645.0 - 580.0);
+        }
+        else if (wl >= 645.0 && wl <= 780.0)
+        {
+            t.r = 1.0;
+        }
+
+        double s = 1.0;
+        if (wl > 700.0)       s = 0.3 + 0.7 * (780.0 - wl) / (780.0 - 700.0);
+        else if (wl <  420.0) s = 0.3 + 0.7 * (wl - 380.0) / (420.0 - 380.0);
+
+        t.r = pow(t.r * s, gamma);
+        t.g = pow(t.g * s, gamma);
+        t.b = pow(t.b * s, gamma);
+        return t;
+    }
+
+    inline rgba rgba_pre(double r, double g, double b, double a)
+    {
+        return rgba(r, g, b, a).premultiply();
+    }
+
+
+    //===================================================================rgba8
+    template<class Colorspace>
+    struct rgba8T
+    {
+        typedef int8u  value_type;
+        typedef int32u calc_type;
+        typedef int32  long_type;
+        enum base_scale_e
+        {
+            base_shift = 8,
+            base_scale = 1 << base_shift,
+            base_mask  = base_scale - 1,
+            base_MSB = 1 << (base_shift - 1)
+        };
+        typedef rgba8T self_type;
+
+
+        value_type r;
+        value_type g;
+        value_type b;
+        value_type a;
+
+        static void convert(rgba8T<linear>& dst, const rgba8T<sRGB>& src)
+        {
+            dst.r = sRGB_conv<value_type>::rgb_from_sRGB(src.r);
+            dst.g = sRGB_conv<value_type>::rgb_from_sRGB(src.g);
+            dst.b = sRGB_conv<value_type>::rgb_from_sRGB(src.b);
+            dst.a = src.a;
+        }
+
+        static void convert(rgba8T<sRGB>& dst, const rgba8T<linear>& src)
+        {
+            dst.r = sRGB_conv<value_type>::rgb_to_sRGB(src.r);
+            dst.g = sRGB_conv<value_type>::rgb_to_sRGB(src.g);
+            dst.b = sRGB_conv<value_type>::rgb_to_sRGB(src.b);
+            dst.a = src.a;
+        }
+
+        static void convert(rgba8T<linear>& dst, const rgba& src)
+        {
+            dst.r = value_type(uround(src.r * base_mask));
+            dst.g = value_type(uround(src.g * base_mask));
+            dst.b = value_type(uround(src.b * base_mask));
+            dst.a = value_type(uround(src.a * base_mask));
+        }
+
+        static void convert(rgba8T<sRGB>& dst, const rgba& src)
+        {
+            // Use the "float" table.
+            dst.r = sRGB_conv<float>::rgb_to_sRGB(float(src.r));
+            dst.g = sRGB_conv<float>::rgb_to_sRGB(float(src.g));
+            dst.b = sRGB_conv<float>::rgb_to_sRGB(float(src.b));
+            dst.a = sRGB_conv<float>::alpha_to_sRGB(float(src.a));
+        }
+
+        static void convert(rgba& dst, const rgba8T<linear>& src)
+        {
+            dst.r = src.r / 255.0;
+            dst.g = src.g / 255.0;
+            dst.b = src.b / 255.0;
+            dst.a = src.a / 255.0;
+        }
+
+        static void convert(rgba& dst, const rgba8T<sRGB>& src)
+        {
+            // Use the "float" table.
+            dst.r = sRGB_conv<float>::rgb_from_sRGB(src.r);
+            dst.g = sRGB_conv<float>::rgb_from_sRGB(src.g);
+            dst.b = sRGB_conv<float>::rgb_from_sRGB(src.b);
+            dst.a = sRGB_conv<float>::alpha_from_sRGB(src.a);
+        }
+
+        //--------------------------------------------------------------------
+        rgba8T() {}
+
+        //--------------------------------------------------------------------
+        rgba8T(unsigned r_, unsigned g_, unsigned b_, unsigned a_ = base_mask) :
+            r(value_type(r_)),
+            g(value_type(g_)),
+            b(value_type(b_)),
+            a(value_type(a_)) {}
+
+        //--------------------------------------------------------------------
+        rgba8T(const rgba& c)
+        {
+            convert(*this, c);
+        }
+
+        //--------------------------------------------------------------------
+        rgba8T(const self_type& c, unsigned a_) :
+            r(c.r), g(c.g), b(c.b), a(value_type(a_)) {}
+
+        //--------------------------------------------------------------------
+        template<class T>
+        rgba8T(const rgba8T<T>& c)
+        {
+            convert(*this, c);
+        }
+
+        //--------------------------------------------------------------------
+        operator rgba() const
+        {
+            rgba c;
+            convert(c, *this);
+            return c;
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE double to_double(value_type a)
+        {
+            return double(a) / base_mask;
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type from_double(double a)
+        {
+            return value_type(uround(a * base_mask));
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type empty_value()
+        {
+            return 0;
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type full_value()
+        {
+            return base_mask;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE bool is_transparent() const
+        {
+            return a == 0;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE bool is_opaque() const
+        {
+            return a == base_mask;
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type invert(value_type x)
+        {
+            return base_mask - x;
+        }
+
+        //--------------------------------------------------------------------
+        // Fixed-point multiply, exact over int8u.
+        static AGG_INLINE value_type multiply(value_type a, value_type b)
+        {
+            calc_type t = a * b + base_MSB;
+            return value_type(((t >> base_shift) + t) >> base_shift);
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type demultiply(value_type a, value_type b)
+        {
+            if (a * b == 0)
+            {
+                return 0;
+            }
+            else if (a >= b)
+            {
+                return base_mask;
+            }
+            else return value_type((a * base_mask + (b >> 1)) / b);
+        }
+
+        //--------------------------------------------------------------------
+        template<typename T>
+        static AGG_INLINE T downscale(T a)
+        {
+            return a >> base_shift;
+        }
+
+        //--------------------------------------------------------------------
+        template<typename T>
+        static AGG_INLINE T downshift(T a, unsigned n)
+        {
+            return a >> n;
+        }
+
+        //--------------------------------------------------------------------
+        // Fixed-point multiply, exact over int8u.
+        // Specifically for multiplying a color component by a cover.
+        static AGG_INLINE value_type mult_cover(value_type a, cover_type b)
+        {
+            return multiply(a, b);
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
+        {
+            return multiply(b, a);
+        }
+
+        //--------------------------------------------------------------------
+        // Interpolate p to q by a, assuming q is premultiplied by a.
+        static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a)
+        {
+            return p + q - multiply(p, a);
+        }
+
+        //--------------------------------------------------------------------
+        // Interpolate p to q by a.
+        static AGG_INLINE value_type lerp(value_type p, value_type q, value_type a)
+        {
+            int t = (q - p) * a + base_MSB - (p > q);
+            return value_type(p + (((t >> base_shift) + t) >> base_shift));
+        }
+
+        //--------------------------------------------------------------------
+        self_type& clear()
+        {
+            r = g = b = a = 0;
+			return *this;
+        }
+
+        //--------------------------------------------------------------------
+        self_type& transparent()
+        {
+            a = 0;
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        self_type& opacity(double a_)
+        {
+            if (a_ < 0) a = 0;
+            else if (a_ > 1) a = 1;
+            else a = (value_type)uround(a_ * double(base_mask));
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        double opacity() const
+        {
+            return double(a) / double(base_mask);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE self_type& premultiply()
+        {
+            if (a != base_mask)
+            {
+                if (a == 0)
+                {
+                    r = g = b = 0;
+                }
+                else
+                {
+                    r = multiply(r, a);
+                    g = multiply(g, a);
+                    b = multiply(b, a);
+                }
+            }
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE self_type& premultiply(unsigned a_)
+        {
+            if (a != base_mask || a_ < base_mask)
+            {
+                if (a == 0 || a_ == 0)
+                {
+                    r = g = b = a = 0;
+                }
+                else
+                {
+                    calc_type r_ = (calc_type(r) * a_) / a;
+                    calc_type g_ = (calc_type(g) * a_) / a;
+                    calc_type b_ = (calc_type(b) * a_) / a;
+                    r = value_type((r_ > a_) ? a_ : r_);
+                    g = value_type((g_ > a_) ? a_ : g_);
+                    b = value_type((b_ > a_) ? a_ : b_);
+                    a = value_type(a_);
+                }
+            }
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE self_type& demultiply()
+        {
+            if (a < base_mask)
+            {
+                if (a == 0)
+                {
+                    r = g = b = 0;
+                }
+                else
+                {
+                    calc_type r_ = (calc_type(r) * base_mask) / a;
+                    calc_type g_ = (calc_type(g) * base_mask) / a;
+                    calc_type b_ = (calc_type(b) * base_mask) / a;
+                    r = value_type((r_ > calc_type(base_mask)) ? calc_type(base_mask) : r_);
+                    g = value_type((g_ > calc_type(base_mask)) ? calc_type(base_mask) : g_);
+                    b = value_type((b_ > calc_type(base_mask)) ? calc_type(base_mask) : b_);
+                }
+            }
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE self_type gradient(const self_type& c, double k) const
+        {
+            self_type ret;
+            calc_type ik = uround(k * base_mask);
+            ret.r = lerp(r, c.r, ik);
+            ret.g = lerp(g, c.g, ik);
+            ret.b = lerp(b, c.b, ik);
+            ret.a = lerp(a, c.a, ik);
+            return ret;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void add(const self_type& c, unsigned cover)
+        {
+            calc_type cr, cg, cb, ca;
+            if (cover == cover_mask)
+            {
+                if (c.a == base_mask)
+                {
+                    *this = c;
+                    return;
+                }
+                else
+                {
+                    cr = r + c.r;
+                    cg = g + c.g;
+                    cb = b + c.b;
+                    ca = a + c.a;
+                }
+            }
+            else
+            {
+                cr = r + mult_cover(c.r, cover);
+                cg = g + mult_cover(c.g, cover);
+                cb = b + mult_cover(c.b, cover);
+                ca = a + mult_cover(c.a, cover);
+            }
+            r = (value_type)((cr > calc_type(base_mask)) ? calc_type(base_mask) : cr);
+            g = (value_type)((cg > calc_type(base_mask)) ? calc_type(base_mask) : cg);
+            b = (value_type)((cb > calc_type(base_mask)) ? calc_type(base_mask) : cb);
+            a = (value_type)((ca > calc_type(base_mask)) ? calc_type(base_mask) : ca);
+        }
+
+        //--------------------------------------------------------------------
+        template<class GammaLUT>
+        AGG_INLINE void apply_gamma_dir(const GammaLUT& gamma)
+        {
+            r = gamma.dir(r);
+            g = gamma.dir(g);
+            b = gamma.dir(b);
+        }
+
+        //--------------------------------------------------------------------
+        template<class GammaLUT>
+        AGG_INLINE void apply_gamma_inv(const GammaLUT& gamma)
+        {
+            r = gamma.inv(r);
+            g = gamma.inv(g);
+            b = gamma.inv(b);
+        }
+
+        //--------------------------------------------------------------------
+        static self_type no_color() { return self_type(0,0,0,0); }
+
+        //--------------------------------------------------------------------
+        static self_type from_wavelength(double wl, double gamma = 1.0)
+        {
+            return self_type(rgba::from_wavelength(wl, gamma));
+        }
+    };
+
+    typedef rgba8T<linear> rgba8;
+    typedef rgba8T<sRGB> srgba8;
+
+
+    //-------------------------------------------------------------rgb8_packed
+    inline rgba8 rgb8_packed(unsigned v)
+    {
+        return rgba8((v >> 16) & 0xFF, (v >> 8) & 0xFF, v & 0xFF);
+    }
+
+    //-------------------------------------------------------------bgr8_packed
+    inline rgba8 bgr8_packed(unsigned v)
+    {
+        return rgba8(v & 0xFF, (v >> 8) & 0xFF, (v >> 16) & 0xFF);
+    }
+
+    //------------------------------------------------------------argb8_packed
+    inline rgba8 argb8_packed(unsigned v)
+    {
+        return rgba8((v >> 16) & 0xFF, (v >> 8) & 0xFF, v & 0xFF, v >> 24);
+    }
+
+    //---------------------------------------------------------rgba8_gamma_dir
+    template<class GammaLUT>
+    rgba8 rgba8_gamma_dir(rgba8 c, const GammaLUT& gamma)
+    {
+        return rgba8(gamma.dir(c.r), gamma.dir(c.g), gamma.dir(c.b), c.a);
+    }
+
+    //---------------------------------------------------------rgba8_gamma_inv
+    template<class GammaLUT>
+    rgba8 rgba8_gamma_inv(rgba8 c, const GammaLUT& gamma)
+    {
+        return rgba8(gamma.inv(c.r), gamma.inv(c.g), gamma.inv(c.b), c.a);
+    }
+
+
+
+    //==================================================================rgba16
+    struct rgba16
+    {
+        typedef int16u value_type;
+        typedef int32u calc_type;
+        typedef int64  long_type;
+        enum base_scale_e
+        {
+            base_shift = 16,
+            base_scale = 1 << base_shift,
+            base_mask  = base_scale - 1,
+            base_MSB = 1 << (base_shift - 1)
+        };
+        typedef rgba16 self_type;
+
+        value_type r;
+        value_type g;
+        value_type b;
+        value_type a;
+
+        //--------------------------------------------------------------------
+        rgba16() {}
+
+        //--------------------------------------------------------------------
+        rgba16(unsigned r_, unsigned g_, unsigned b_, unsigned a_=base_mask) :
+            r(value_type(r_)),
+            g(value_type(g_)),
+            b(value_type(b_)),
+            a(value_type(a_)) {}
+
+        //--------------------------------------------------------------------
+        rgba16(const self_type& c, unsigned a_) :
+            r(c.r), g(c.g), b(c.b), a(value_type(a_)) {}
+
+        //--------------------------------------------------------------------
+        rgba16(const rgba& c) :
+            r((value_type)uround(c.r * double(base_mask))),
+            g((value_type)uround(c.g * double(base_mask))),
+            b((value_type)uround(c.b * double(base_mask))),
+            a((value_type)uround(c.a * double(base_mask))) {}
+
+        //--------------------------------------------------------------------
+        rgba16(const rgba8& c) :
+            r(value_type((value_type(c.r) << 8) | c.r)),
+            g(value_type((value_type(c.g) << 8) | c.g)),
+            b(value_type((value_type(c.b) << 8) | c.b)),
+            a(value_type((value_type(c.a) << 8) | c.a)) {}
+
+        //--------------------------------------------------------------------
+        rgba16(const srgba8& c) :
+            r(sRGB_conv<value_type>::rgb_from_sRGB(c.r)),
+            g(sRGB_conv<value_type>::rgb_from_sRGB(c.g)),
+            b(sRGB_conv<value_type>::rgb_from_sRGB(c.b)),
+            a(sRGB_conv<value_type>::alpha_from_sRGB(c.a)) {}
+
+        //--------------------------------------------------------------------
+        operator rgba() const
+        {
+            return rgba(
+                r / 65535.0,
+                g / 65535.0,
+                b / 65535.0,
+                a / 65535.0);
+        }
+
+        //--------------------------------------------------------------------
+        operator rgba8() const
+        {
+            return rgba8(r >> 8, g >> 8, b >> 8, a >> 8);
+        }
+
+        //--------------------------------------------------------------------
+        operator srgba8() const
+        {
+            // Return (non-premultiplied) sRGB values.
+            return srgba8(
+                sRGB_conv<value_type>::rgb_to_sRGB(r),
+                sRGB_conv<value_type>::rgb_to_sRGB(g),
+                sRGB_conv<value_type>::rgb_to_sRGB(b),
+                sRGB_conv<value_type>::alpha_to_sRGB(a));
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE double to_double(value_type a)
+        {
+            return double(a) / base_mask;
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type from_double(double a)
+        {
+            return value_type(uround(a * base_mask));
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type empty_value()
+        {
+            return 0;
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type full_value()
+        {
+            return base_mask;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE bool is_transparent() const
+        {
+            return a == 0;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE bool is_opaque() const
+        {
+            return a == base_mask;
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type invert(value_type x)
+        {
+            return base_mask - x;
+        }
+
+        //--------------------------------------------------------------------
+        // Fixed-point multiply, exact over int16u.
+        static AGG_INLINE value_type multiply(value_type a, value_type b)
+        {
+            calc_type t = a * b + base_MSB;
+            return value_type(((t >> base_shift) + t) >> base_shift);
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type demultiply(value_type a, value_type b)
+        {
+            if (a * b == 0)
+            {
+                return 0;
+            }
+            else if (a >= b)
+            {
+                return base_mask;
+            }
+            else return value_type((a * base_mask + (b >> 1)) / b);
+        }
+
+        //--------------------------------------------------------------------
+        template<typename T>
+        static AGG_INLINE T downscale(T a)
+        {
+            return a >> base_shift;
+        }
+
+        //--------------------------------------------------------------------
+        template<typename T>
+        static AGG_INLINE T downshift(T a, unsigned n)
+        {
+            return a >> n;
+        }
+
+        //--------------------------------------------------------------------
+        // Fixed-point multiply, almost exact over int16u.
+        // Specifically for multiplying a color component by a cover.
+        static AGG_INLINE value_type mult_cover(value_type a, cover_type b)
+        {
+            return multiply(a, (b << 8) | b);
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
+        {
+            return multiply((a << 8) | a, b) >> 8;
+        }
+
+        //--------------------------------------------------------------------
+        // Interpolate p to q by a, assuming q is premultiplied by a.
+        static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a)
+        {
+            return p + q - multiply(p, a);
+        }
+
+        //--------------------------------------------------------------------
+        // Interpolate p to q by a.
+        static AGG_INLINE value_type lerp(value_type p, value_type q, value_type a)
+        {
+            int t = (q - p) * a + base_MSB - (p > q);
+            return value_type(p + (((t >> base_shift) + t) >> base_shift));
+        }
+
+        //--------------------------------------------------------------------
+        self_type& clear()
+        {
+            r = g = b = a = 0;
+			return *this;
+        }
+
+        //--------------------------------------------------------------------
+        self_type& transparent()
+        {
+            a = 0;
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE self_type& opacity(double a_)
+        {
+            if (a_ < 0) a = 0;
+            if (a_ > 1) a = 1;
+            a = value_type(uround(a_ * double(base_mask)));
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        double opacity() const
+        {
+            return double(a) / double(base_mask);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE self_type& premultiply()
+        {
+            if (a != base_mask)
+            {
+                if (a == 0)
+                {
+                    r = g = b = 0;
+                }
+                else
+                {
+                    r = multiply(r, a);
+                    g = multiply(g, a);
+                    b = multiply(b, a);
+                }
+            }
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE self_type& premultiply(unsigned a_)
+        {
+            if (a < base_mask || a_ < base_mask)
+            {
+                if (a == 0 || a_ == 0)
+                {
+                    r = g = b = a = 0;
+                }
+                else
+                {
+                    calc_type r_ = (calc_type(r) * a_) / a;
+                    calc_type g_ = (calc_type(g) * a_) / a;
+                    calc_type b_ = (calc_type(b) * a_) / a;
+                    r = value_type((r_ > a_) ? a_ : r_);
+                    g = value_type((g_ > a_) ? a_ : g_);
+                    b = value_type((b_ > a_) ? a_ : b_);
+                    a = value_type(a_);
+                }
+            }
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE self_type& demultiply()
+        {
+            if (a < base_mask)
+            {
+                if (a == 0)
+                {
+                    r = g = b = 0;
+                }
+                else
+                {
+                    calc_type r_ = (calc_type(r) * base_mask) / a;
+                    calc_type g_ = (calc_type(g) * base_mask) / a;
+                    calc_type b_ = (calc_type(b) * base_mask) / a;
+                    r = value_type((r_ > calc_type(base_mask)) ? calc_type(base_mask) : r_);
+                    g = value_type((g_ > calc_type(base_mask)) ? calc_type(base_mask) : g_);
+                    b = value_type((b_ > calc_type(base_mask)) ? calc_type(base_mask) : b_);
+                }
+            }
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE self_type gradient(const self_type& c, double k) const
+        {
+            self_type ret;
+            calc_type ik = uround(k * base_mask);
+            ret.r = lerp(r, c.r, ik);
+            ret.g = lerp(g, c.g, ik);
+            ret.b = lerp(b, c.b, ik);
+            ret.a = lerp(a, c.a, ik);
+            return ret;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void add(const self_type& c, unsigned cover)
+        {
+            calc_type cr, cg, cb, ca;
+            if (cover == cover_mask)
+            {
+                if (c.a == base_mask)
+                {
+                    *this = c;
+                    return;
+                }
+                else
+                {
+                    cr = r + c.r;
+                    cg = g + c.g;
+                    cb = b + c.b;
+                    ca = a + c.a;
+                }
+            }
+            else
+            {
+                cr = r + mult_cover(c.r, cover);
+                cg = g + mult_cover(c.g, cover);
+                cb = b + mult_cover(c.b, cover);
+                ca = a + mult_cover(c.a, cover);
+            }
+            r = (value_type)((cr > calc_type(base_mask)) ? calc_type(base_mask) : cr);
+            g = (value_type)((cg > calc_type(base_mask)) ? calc_type(base_mask) : cg);
+            b = (value_type)((cb > calc_type(base_mask)) ? calc_type(base_mask) : cb);
+            a = (value_type)((ca > calc_type(base_mask)) ? calc_type(base_mask) : ca);
+        }
+
+        //--------------------------------------------------------------------
+        template<class GammaLUT>
+        AGG_INLINE void apply_gamma_dir(const GammaLUT& gamma)
+        {
+            r = gamma.dir(r);
+            g = gamma.dir(g);
+            b = gamma.dir(b);
+        }
+
+        //--------------------------------------------------------------------
+        template<class GammaLUT>
+        AGG_INLINE void apply_gamma_inv(const GammaLUT& gamma)
+        {
+            r = gamma.inv(r);
+            g = gamma.inv(g);
+            b = gamma.inv(b);
+        }
+
+        //--------------------------------------------------------------------
+        static self_type no_color() { return self_type(0,0,0,0); }
+
+        //--------------------------------------------------------------------
+        static self_type from_wavelength(double wl, double gamma = 1.0)
+        {
+            return self_type(rgba::from_wavelength(wl, gamma));
+        }
+    };
+
+
+    //------------------------------------------------------rgba16_gamma_dir
+    template<class GammaLUT>
+    rgba16 rgba16_gamma_dir(rgba16 c, const GammaLUT& gamma)
+    {
+        return rgba16(gamma.dir(c.r), gamma.dir(c.g), gamma.dir(c.b), c.a);
+    }
+
+    //------------------------------------------------------rgba16_gamma_inv
+    template<class GammaLUT>
+    rgba16 rgba16_gamma_inv(rgba16 c, const GammaLUT& gamma)
+    {
+        return rgba16(gamma.inv(c.r), gamma.inv(c.g), gamma.inv(c.b), c.a);
+    }
+
+    //====================================================================rgba32
+    struct rgba32
+    {
+        typedef float value_type;
+        typedef double calc_type;
+        typedef double long_type;
+        typedef rgba32 self_type;
+
+        value_type r;
+        value_type g;
+        value_type b;
+        value_type a;
+
+        //--------------------------------------------------------------------
+        rgba32() {}
+
+        //--------------------------------------------------------------------
+        rgba32(value_type r_, value_type g_, value_type b_, value_type a_= 1) :
+            r(r_), g(g_), b(b_), a(a_) {}
+
+        //--------------------------------------------------------------------
+        rgba32(const self_type& c, float a_) :
+            r(c.r), g(c.g), b(c.b), a(a_) {}
+
+        //--------------------------------------------------------------------
+        rgba32(const rgba& c) :
+            r(value_type(c.r)), g(value_type(c.g)), b(value_type(c.b)), a(value_type(c.a)) {}
+
+        //--------------------------------------------------------------------
+        rgba32(const rgba8& c) :
+            r(value_type(c.r / 255.0)),
+            g(value_type(c.g / 255.0)),
+            b(value_type(c.b / 255.0)),
+            a(value_type(c.a / 255.0)) {}
+
+        //--------------------------------------------------------------------
+        rgba32(const srgba8& c) :
+            r(sRGB_conv<value_type>::rgb_from_sRGB(c.r)),
+            g(sRGB_conv<value_type>::rgb_from_sRGB(c.g)),
+            b(sRGB_conv<value_type>::rgb_from_sRGB(c.b)),
+            a(sRGB_conv<value_type>::alpha_from_sRGB(c.a)) {}
+
+        //--------------------------------------------------------------------
+        rgba32(const rgba16& c) :
+            r(value_type(c.r / 65535.0)),
+            g(value_type(c.g / 65535.0)),
+            b(value_type(c.b / 65535.0)),
+            a(value_type(c.a / 65535.0)) {}
+
+        //--------------------------------------------------------------------
+        operator rgba() const
+        {
+            return rgba(r, g, b, a);
+        }
+
+        //--------------------------------------------------------------------
+        operator rgba8() const
+        {
+            return rgba8(
+                uround(r * 255.0),
+                uround(g * 255.0),
+                uround(b * 255.0),
+                uround(a * 255.0));
+        }
+
+        //--------------------------------------------------------------------
+        operator srgba8() const
+        {
+            return srgba8(
+                sRGB_conv<value_type>::rgb_to_sRGB(r),
+                sRGB_conv<value_type>::rgb_to_sRGB(g),
+                sRGB_conv<value_type>::rgb_to_sRGB(b),
+                sRGB_conv<value_type>::alpha_to_sRGB(a));
+        }
+
+        //--------------------------------------------------------------------
+        operator rgba16() const
+        {
+            return rgba8(
+                uround(r * 65535.0),
+                uround(g * 65535.0),
+                uround(b * 65535.0),
+                uround(a * 65535.0));
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE double to_double(value_type a)
+        {
+            return a;
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type from_double(double a)
+        {
+            return value_type(a);
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type empty_value()
+        {
+            return 0;
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type full_value()
+        {
+            return 1;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE bool is_transparent() const
+        {
+            return a <= 0;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE bool is_opaque() const
+        {
+            return a >= 1;
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type invert(value_type x)
+        {
+            return 1 - x;
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type multiply(value_type a, value_type b)
+        {
+            return value_type(a * b);
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type demultiply(value_type a, value_type b)
+        {
+            return (b == 0) ? 0 : value_type(a / b);
+        }
+
+        //--------------------------------------------------------------------
+        template<typename T>
+        static AGG_INLINE T downscale(T a)
+        {
+            return a;
+        }
+
+        //--------------------------------------------------------------------
+        template<typename T>
+        static AGG_INLINE T downshift(T a, unsigned n)
+        {
+            return n > 0 ? a / (1 << n) : a;
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE value_type mult_cover(value_type a, cover_type b)
+        {
+            return value_type(a * b / cover_mask);
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
+        {
+            return cover_type(uround(a * b));
+        }
+
+        //--------------------------------------------------------------------
+        // Interpolate p to q by a, assuming q is premultiplied by a.
+        static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a)
+        {
+            return (1 - a) * p + q; // more accurate than "p + q - p * a"
+        }
+
+        //--------------------------------------------------------------------
+        // Interpolate p to q by a.
+        static AGG_INLINE value_type lerp(value_type p, value_type q, value_type a)
+        {
+			// The form "p + a * (q - p)" avoids a multiplication, but may produce an
+			// inaccurate result. For example, "p + (q - p)" may not be exactly equal
+			// to q. Therefore, stick to the basic expression, which at least produces
+			// the correct result at either extreme.
+			return (1 - a) * p + a * q;
+        }
+
+        //--------------------------------------------------------------------
+        self_type& clear()
+        {
+            r = g = b = a = 0;
+			return *this;
+        }
+
+        //--------------------------------------------------------------------
+        self_type& transparent()
+        {
+            a = 0;
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE self_type& opacity(double a_)
+        {
+            if (a_ < 0) a = 0;
+            else if (a_ > 1) a = 1;
+            else a = value_type(a_);
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        double opacity() const
+        {
+            return a;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE self_type& premultiply()
+        {
+            if (a < 1)
+            {
+                if (a <= 0)
+                {
+                    r = g = b = 0;
+                }
+                else
+                {
+                    r *= a;
+                    g *= a;
+                    b *= a;
+                }
+            }
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE self_type& demultiply()
+        {
+            if (a < 1)
+            {
+                if (a <= 0)
+                {
+                    r = g = b = 0;
+                }
+                else
+                {
+                    r /= a;
+                    g /= a;
+                    b /= a;
+                }
+            }
+            return *this;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE self_type gradient(const self_type& c, double k) const
+        {
+            self_type ret;
+            ret.r = value_type(r + (c.r - r) * k);
+            ret.g = value_type(g + (c.g - g) * k);
+            ret.b = value_type(b + (c.b - b) * k);
+            ret.a = value_type(a + (c.a - a) * k);
+            return ret;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void add(const self_type& c, unsigned cover)
+        {
+            if (cover == cover_mask)
+            {
+                if (c.is_opaque())
+                {
+                    *this = c;
+                    return;
+                }
+                else
+                {
+                    r += c.r;
+                    g += c.g;
+                    b += c.b;
+                    a += c.a;
+                }
+            }
+            else
+            {
+                r += mult_cover(c.r, cover);
+                g += mult_cover(c.g, cover);
+                b += mult_cover(c.b, cover);
+                a += mult_cover(c.a, cover);
+            }
+            if (a > 1) a = 1;
+            if (r > a) r = a;
+            if (g > a) g = a;
+            if (b > a) b = a;
+        }
+
+        //--------------------------------------------------------------------
+        template<class GammaLUT>
+        AGG_INLINE void apply_gamma_dir(const GammaLUT& gamma)
+        {
+            r = gamma.dir(r);
+            g = gamma.dir(g);
+            b = gamma.dir(b);
+        }
+
+        //--------------------------------------------------------------------
+        template<class GammaLUT>
+        AGG_INLINE void apply_gamma_inv(const GammaLUT& gamma)
+        {
+            r = gamma.inv(r);
+            g = gamma.inv(g);
+            b = gamma.inv(b);
+        }
+
+        //--------------------------------------------------------------------
+        static self_type no_color() { return self_type(0,0,0,0); }
+
+        //--------------------------------------------------------------------
+        static self_type from_wavelength(double wl, double gamma = 1)
+        {
+            return self_type(rgba::from_wavelength(wl, gamma));
+        }
+    };
+}
+
+
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_config.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_config.h
new file mode 100644
index 0000000000..fa1dae2ba7
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_config.h
@@ -0,0 +1,44 @@
+#ifndef AGG_CONFIG_INCLUDED
+#define AGG_CONFIG_INCLUDED
+
+// This file can be used to redefine certain data types.
+
+//---------------------------------------
+// 1. Default basic types such as:
+// 
+// AGG_INT8
+// AGG_INT8U
+// AGG_INT16
+// AGG_INT16U
+// AGG_INT32
+// AGG_INT32U
+// AGG_INT64
+// AGG_INT64U
+//
+// Just replace this file with new defines if necessary. 
+// For example, if your compiler doesn't have a 64 bit integer type
+// you can still use AGG if you define the follows:
+//
+// #define AGG_INT64  int
+// #define AGG_INT64U unsigned
+//
+// It will result in overflow in 16 bit-per-component image/pattern resampling
+// but it won't result any crash and the rest of the library will remain 
+// fully functional.
+
+
+//---------------------------------------
+// 2. Default rendering_buffer type. Can be:
+//
+// Provides faster access for massive pixel operations, 
+// such as blur, image filtering:
+// #define AGG_RENDERING_BUFFER row_ptr_cache<int8u>
+// 
+// Provides cheaper creation and destruction (no mem allocs):
+// #define AGG_RENDERING_BUFFER row_accessor<int8u>
+//
+// You can still use both of them simultaneously in your applications 
+// This #define is used only for default rendering_buffer type,
+// in short hand typedefs like pixfmt_rgba32.
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_adaptor_vcgen.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_adaptor_vcgen.h
new file mode 100644
index 0000000000..a79f2208c6
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_adaptor_vcgen.h
@@ -0,0 +1,157 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_CONV_ADAPTOR_VCGEN_INCLUDED
+#define AGG_CONV_ADAPTOR_VCGEN_INCLUDED
+
+#include "agg_basics.h"
+
+namespace agg
+{
+    //------------------------------------------------------------null_markers
+    struct null_markers
+    {
+        void remove_all() {}
+        void add_vertex(double, double, unsigned) {}
+        void prepare_src() {}
+
+        void rewind(unsigned) {}
+        unsigned vertex(double*, double*) { return path_cmd_stop; }
+    };
+
+
+    //------------------------------------------------------conv_adaptor_vcgen
+    template<class VertexSource, 
+             class Generator, 
+             class Markers=null_markers> class conv_adaptor_vcgen
+    {
+        enum status
+        {
+            initial,
+            accumulate,
+            generate
+        };
+
+    public:
+        explicit conv_adaptor_vcgen(VertexSource& source) :
+            m_source(&source), 
+            m_status(initial)
+        {}
+        void attach(VertexSource& source) { m_source = &source; }
+
+        Generator& generator() { return m_generator; }
+        const Generator& generator() const { return m_generator; }
+
+        Markers& markers() { return m_markers; }
+        const Markers& markers() const { return m_markers; }
+        
+        void rewind(unsigned path_id) 
+        { 
+            m_source->rewind(path_id); 
+            m_status = initial;
+        }
+
+        unsigned vertex(double* x, double* y);
+
+    private:
+        // Prohibit copying
+        conv_adaptor_vcgen(const conv_adaptor_vcgen<VertexSource, Generator, Markers>&);
+        const conv_adaptor_vcgen<VertexSource, Generator, Markers>& 
+            operator = (const conv_adaptor_vcgen<VertexSource, Generator, Markers>&);
+
+        VertexSource* m_source;
+        Generator     m_generator;
+        Markers       m_markers;
+        status        m_status;
+        unsigned      m_last_cmd;
+        double        m_start_x;
+        double        m_start_y;
+    };
+
+
+
+
+
+    //------------------------------------------------------------------------
+    template<class VertexSource, class Generator, class Markers> 
+    unsigned conv_adaptor_vcgen<VertexSource, Generator, Markers>::vertex(double* x, double* y)
+    {
+        unsigned cmd = path_cmd_stop;
+        bool done = false;
+        while(!done)
+        {
+            switch(m_status)
+            {
+            case initial:
+                m_markers.remove_all();
+                m_last_cmd = m_source->vertex(&m_start_x, &m_start_y);
+                m_status = accumulate;
+
+            case accumulate:
+                if(is_stop(m_last_cmd)) return path_cmd_stop;
+
+                m_generator.remove_all();
+                m_generator.add_vertex(m_start_x, m_start_y, path_cmd_move_to);
+                m_markers.add_vertex(m_start_x, m_start_y, path_cmd_move_to);
+
+                for(;;)
+                {
+                    cmd = m_source->vertex(x, y);
+                    if(is_vertex(cmd))
+                    {
+                        m_last_cmd = cmd;
+                        if(is_move_to(cmd))
+                        {
+                            m_start_x = *x;
+                            m_start_y = *y;
+                            break;
+                        }
+                        m_generator.add_vertex(*x, *y, cmd);
+                        m_markers.add_vertex(*x, *y, path_cmd_line_to);
+                    }
+                    else
+                    {
+                        if(is_stop(cmd))
+                        {
+                            m_last_cmd = path_cmd_stop;
+                            break;
+                        }
+                        if(is_end_poly(cmd))
+                        {
+                            m_generator.add_vertex(*x, *y, cmd);
+                            break;
+                        }
+                    }
+                }
+                m_generator.rewind(0);
+                m_status = generate;
+
+            case generate:
+                cmd = m_generator.vertex(x, y);
+                if(is_stop(cmd))
+                {
+                    m_status = accumulate;
+                    break;
+                }
+                done = true;
+                break;
+            }
+        }
+        return cmd;
+    }
+
+}
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_adaptor_vpgen.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_adaptor_vpgen.h
new file mode 100644
index 0000000000..d6b545ef1f
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_adaptor_vpgen.h
@@ -0,0 +1,159 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_CONV_ADAPTOR_VPGEN_INCLUDED
+#define AGG_CONV_ADAPTOR_VPGEN_INCLUDED
+
+#include "agg_basics.h"
+
+namespace agg
+{
+
+    //======================================================conv_adaptor_vpgen
+    template<class VertexSource, class VPGen> class conv_adaptor_vpgen
+    {
+    public:
+        explicit conv_adaptor_vpgen(VertexSource& source) : m_source(&source) {}
+        void attach(VertexSource& source) { m_source = &source; }
+
+        VPGen& vpgen() { return m_vpgen; }
+        const VPGen& vpgen() const { return m_vpgen; }
+
+        void rewind(unsigned path_id);
+        unsigned vertex(double* x, double* y);
+
+    private:
+        conv_adaptor_vpgen(const conv_adaptor_vpgen<VertexSource, VPGen>&);
+        const conv_adaptor_vpgen<VertexSource, VPGen>& 
+            operator = (const conv_adaptor_vpgen<VertexSource, VPGen>&);
+
+        VertexSource* m_source;
+        VPGen         m_vpgen;
+        double        m_start_x;
+        double        m_start_y;
+        unsigned      m_poly_flags;
+        int           m_vertices;
+    };
+
+
+
+    //------------------------------------------------------------------------
+    template<class VertexSource, class VPGen>
+    void conv_adaptor_vpgen<VertexSource, VPGen>::rewind(unsigned path_id) 
+    { 
+        m_source->rewind(path_id);
+        m_vpgen.reset();
+        m_start_x    = 0;
+        m_start_y    = 0;
+        m_poly_flags = 0;
+        m_vertices   = 0;
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class VertexSource, class VPGen>
+    unsigned conv_adaptor_vpgen<VertexSource, VPGen>::vertex(double* x, double* y)
+    {
+        unsigned cmd = path_cmd_stop;
+        for(;;)
+        {
+            cmd = m_vpgen.vertex(x, y);
+            if(!is_stop(cmd)) break;
+
+            if(m_poly_flags && !m_vpgen.auto_unclose())
+            {
+                *x = 0.0;
+                *y = 0.0;
+                cmd = m_poly_flags;
+                m_poly_flags = 0;
+                break;
+            }
+
+            if(m_vertices < 0)
+            {
+                if(m_vertices < -1) 
+                {
+                    m_vertices = 0;
+                    return path_cmd_stop;
+                }
+                m_vpgen.move_to(m_start_x, m_start_y);
+                m_vertices = 1;
+                continue;
+            }
+
+            double tx, ty;
+            cmd = m_source->vertex(&tx, &ty);
+            if(is_vertex(cmd))
+            {
+                if(is_move_to(cmd)) 
+                {
+                    if(m_vpgen.auto_close() && m_vertices > 2)
+                    {
+                        m_vpgen.line_to(m_start_x, m_start_y);
+                        m_poly_flags = path_cmd_end_poly | path_flags_close;
+                        m_start_x    = tx;
+                        m_start_y    = ty;
+                        m_vertices   = -1;
+                        continue;
+                    }
+                    m_vpgen.move_to(tx, ty);
+                    m_start_x  = tx;
+                    m_start_y  = ty;
+                    m_vertices = 1;
+                }
+                else 
+                {
+                    m_vpgen.line_to(tx, ty);
+                    ++m_vertices;
+                }
+            }
+            else
+            {
+                if(is_end_poly(cmd))
+                {
+                    m_poly_flags = cmd;
+                    if(is_closed(cmd) || m_vpgen.auto_close())
+                    {
+                        if(m_vpgen.auto_close()) m_poly_flags |= path_flags_close;
+                        if(m_vertices > 2)
+                        {
+                            m_vpgen.line_to(m_start_x, m_start_y);
+                        }
+                        m_vertices = 0;
+                    }
+                }
+                else
+                {
+                    // path_cmd_stop
+                    if(m_vpgen.auto_close() && m_vertices > 2)
+                    {
+                        m_vpgen.line_to(m_start_x, m_start_y);
+                        m_poly_flags = path_cmd_end_poly | path_flags_close;
+                        m_vertices   = -2;
+                        continue;
+                    }
+                    break;
+                }
+            }
+        }
+        return cmd;
+    }
+
+
+}
+
+
+#endif
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_contour.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_contour.h
new file mode 100644
index 0000000000..b4b5a9047e
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_contour.h
@@ -0,0 +1,65 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// conv_stroke
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_CONV_CONTOUR_INCLUDED
+#define AGG_CONV_CONTOUR_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_vcgen_contour.h"
+#include "agg_conv_adaptor_vcgen.h"
+
+namespace agg
+{
+
+    //-----------------------------------------------------------conv_contour
+    template<class VertexSource> 
+    struct conv_contour : public conv_adaptor_vcgen<VertexSource, vcgen_contour>
+    {
+        typedef conv_adaptor_vcgen<VertexSource, vcgen_contour> base_type;
+
+        conv_contour(VertexSource& vs) : 
+            conv_adaptor_vcgen<VertexSource, vcgen_contour>(vs)
+        {
+        }
+
+        void line_join(line_join_e lj) { base_type::generator().line_join(lj); }
+        void inner_join(inner_join_e ij) { base_type::generator().inner_join(ij); }
+        void width(double w) { base_type::generator().width(w); }
+        void miter_limit(double ml) { base_type::generator().miter_limit(ml); }
+        void miter_limit_theta(double t) { base_type::generator().miter_limit_theta(t); }
+        void inner_miter_limit(double ml) { base_type::generator().inner_miter_limit(ml); }
+        void approximation_scale(double as) { base_type::generator().approximation_scale(as); }
+        void auto_detect_orientation(bool v) { base_type::generator().auto_detect_orientation(v); }
+
+        line_join_e line_join() const { return base_type::generator().line_join(); }
+        inner_join_e inner_join() const { return base_type::generator().inner_join(); }
+        double width() const { return base_type::generator().width(); }
+        double miter_limit() const { return base_type::generator().miter_limit(); }
+        double inner_miter_limit() const { return base_type::generator().inner_miter_limit(); }
+        double approximation_scale() const { return base_type::generator().approximation_scale(); }
+        bool auto_detect_orientation() const { return base_type::generator().auto_detect_orientation(); }
+
+    private:
+        conv_contour(const conv_contour<VertexSource>&);
+        const conv_contour<VertexSource>& 
+            operator = (const conv_contour<VertexSource>&);
+    };
+
+}
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_curve.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_curve.h
new file mode 100644
index 0000000000..d5b475de7a
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_curve.h
@@ -0,0 +1,201 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// classes conv_curve
+//
+//----------------------------------------------------------------------------
+
+#ifndef AGG_CONV_CURVE_INCLUDED
+#define AGG_CONV_CURVE_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_curves.h"
+
+namespace agg
+{
+
+
+    //---------------------------------------------------------------conv_curve
+    // Curve converter class. Any path storage can have Bezier curves defined 
+    // by their control points. There're two types of curves supported: curve3 
+    // and curve4. Curve3 is a conic Bezier curve with 2 endpoints and 1 control
+    // point. Curve4 has 2 control points (4 points in total) and can be used
+    // to interpolate more complicated curves. Curve4, unlike curve3 can be used 
+    // to approximate arcs, both circular and elliptical. Curves are approximated 
+    // with straight lines and one of the approaches is just to store the whole 
+    // sequence of vertices that approximate our curve. It takes additional 
+    // memory, and at the same time the consecutive vertices can be calculated 
+    // on demand. 
+    //
+    // Initially, path storages are not suppose to keep all the vertices of the
+    // curves (although, nothing prevents us from doing so). Instead, path_storage
+    // keeps only vertices, needed to calculate a curve on demand. Those vertices
+    // are marked with special commands. So, if the path_storage contains curves 
+    // (which are not real curves yet), and we render this storage directly, 
+    // all we will see is only 2 or 3 straight line segments (for curve3 and 
+    // curve4 respectively). If we need to see real curves drawn we need to 
+    // include this class into the conversion pipeline. 
+    //
+    // Class conv_curve recognizes commands path_cmd_curve3 and path_cmd_curve4 
+    // and converts these vertices into a move_to/line_to sequence. 
+    //-----------------------------------------------------------------------
+    template<class VertexSource, 
+             class Curve3=curve3, 
+             class Curve4=curve4> class conv_curve
+    {
+    public:
+        typedef Curve3 curve3_type;
+        typedef Curve4 curve4_type;
+        typedef conv_curve<VertexSource, Curve3, Curve4> self_type;
+
+        explicit conv_curve(VertexSource& source) :
+          m_source(&source), m_last_x(0.0), m_last_y(0.0) {}
+        void attach(VertexSource& source) { m_source = &source; }
+
+        void approximation_method(curve_approximation_method_e v) 
+        { 
+            m_curve3.approximation_method(v);
+            m_curve4.approximation_method(v);
+        }
+
+        curve_approximation_method_e approximation_method() const 
+        { 
+            return m_curve4.approximation_method();
+        }
+
+        void approximation_scale(double s) 
+        { 
+            m_curve3.approximation_scale(s); 
+            m_curve4.approximation_scale(s); 
+        }
+
+        double approximation_scale() const 
+        { 
+            return m_curve4.approximation_scale();  
+        }
+
+        void angle_tolerance(double v) 
+        { 
+            m_curve3.angle_tolerance(v); 
+            m_curve4.angle_tolerance(v); 
+        }
+
+        double angle_tolerance() const 
+        { 
+            return m_curve4.angle_tolerance();  
+        }
+
+        void cusp_limit(double v) 
+        { 
+            m_curve3.cusp_limit(v); 
+            m_curve4.cusp_limit(v); 
+        }
+
+        double cusp_limit() const 
+        { 
+            return m_curve4.cusp_limit();  
+        }
+
+        void     rewind(unsigned path_id); 
+        unsigned vertex(double* x, double* y);
+
+    private:
+        conv_curve(const self_type&);
+        const self_type& operator = (const self_type&);
+
+        VertexSource* m_source;
+        double        m_last_x;
+        double        m_last_y;
+        curve3_type   m_curve3;
+        curve4_type   m_curve4;
+    };
+
+
+
+    //------------------------------------------------------------------------
+    template<class VertexSource, class Curve3, class Curve4>
+    void conv_curve<VertexSource, Curve3, Curve4>::rewind(unsigned path_id)
+    {
+        m_source->rewind(path_id);
+        m_last_x = 0.0;
+        m_last_y = 0.0;
+        m_curve3.reset();
+        m_curve4.reset();
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class VertexSource, class Curve3, class Curve4>
+    unsigned conv_curve<VertexSource, Curve3, Curve4>::vertex(double* x, double* y)
+    {
+        if(!is_stop(m_curve3.vertex(x, y)))
+        {
+            m_last_x = *x;
+            m_last_y = *y;
+            return path_cmd_line_to;
+        }
+
+        if(!is_stop(m_curve4.vertex(x, y)))
+        {
+            m_last_x = *x;
+            m_last_y = *y;
+            return path_cmd_line_to;
+        }
+
+        double ct2_x;
+        double ct2_y;
+        double end_x;
+        double end_y;
+
+        unsigned cmd = m_source->vertex(x, y);
+        switch(cmd)
+        {
+        case path_cmd_curve3:
+            m_source->vertex(&end_x, &end_y);
+
+            m_curve3.init(m_last_x, m_last_y, 
+                          *x,       *y, 
+                          end_x,     end_y);
+
+            m_curve3.vertex(x, y);    // First call returns path_cmd_move_to
+            m_curve3.vertex(x, y);    // This is the first vertex of the curve
+            cmd = path_cmd_line_to;
+            break;
+
+        case path_cmd_curve4:
+            m_source->vertex(&ct2_x, &ct2_y);
+            m_source->vertex(&end_x, &end_y);
+
+            m_curve4.init(m_last_x, m_last_y, 
+                          *x,       *y, 
+                          ct2_x,    ct2_y, 
+                          end_x,    end_y);
+
+            m_curve4.vertex(x, y);    // First call returns path_cmd_move_to
+            m_curve4.vertex(x, y);    // This is the first vertex of the curve
+            cmd = path_cmd_line_to;
+            break;
+        }
+        m_last_x = *x;
+        m_last_y = *y;
+        return cmd;
+    }
+
+
+}
+
+
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_dash.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_dash.h
new file mode 100644
index 0000000000..23c13ad0ab
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_dash.h
@@ -0,0 +1,68 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// conv_dash
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_CONV_DASH_INCLUDED
+#define AGG_CONV_DASH_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_vcgen_dash.h"
+#include "agg_conv_adaptor_vcgen.h"
+
+namespace agg
+{
+
+    //---------------------------------------------------------------conv_dash
+    template<class VertexSource, class Markers=null_markers> 
+    struct conv_dash : public conv_adaptor_vcgen<VertexSource, vcgen_dash, Markers>
+    {
+        typedef Markers marker_type;
+        typedef conv_adaptor_vcgen<VertexSource, vcgen_dash, Markers> base_type;
+
+        conv_dash(VertexSource& vs) : 
+            conv_adaptor_vcgen<VertexSource, vcgen_dash, Markers>(vs)
+        {
+        }
+
+        void remove_all_dashes() 
+        { 
+            base_type::generator().remove_all_dashes(); 
+        }
+
+        void add_dash(double dash_len, double gap_len) 
+        { 
+            base_type::generator().add_dash(dash_len, gap_len); 
+        }
+
+        void dash_start(double ds) 
+        { 
+            base_type::generator().dash_start(ds); 
+        }
+
+        void shorten(double s) { base_type::generator().shorten(s); }
+        double shorten() const { return base_type::generator().shorten(); }
+
+    private:
+        conv_dash(const conv_dash<VertexSource, Markers>&);
+        const conv_dash<VertexSource, Markers>& 
+            operator = (const conv_dash<VertexSource, Markers>&);
+    };
+
+
+}
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_segmentator.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_segmentator.h
new file mode 100644
index 0000000000..e69a9e7d7d
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_segmentator.h
@@ -0,0 +1,48 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_CONV_SEGMENTATOR_INCLUDED
+#define AGG_CONV_SEGMENTATOR_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_conv_adaptor_vpgen.h"
+#include "agg_vpgen_segmentator.h"
+
+namespace agg
+{
+
+    //========================================================conv_segmentator
+    template<class VertexSource> 
+    struct conv_segmentator : public conv_adaptor_vpgen<VertexSource, vpgen_segmentator>
+    {
+        typedef conv_adaptor_vpgen<VertexSource, vpgen_segmentator> base_type;
+
+        conv_segmentator(VertexSource& vs) : 
+            conv_adaptor_vpgen<VertexSource, vpgen_segmentator>(vs) {}
+
+        void approximation_scale(double s) { base_type::vpgen().approximation_scale(s);        }
+        double approximation_scale() const { return base_type::vpgen().approximation_scale();  }
+
+    private:
+        conv_segmentator(const conv_segmentator<VertexSource>&);
+        const conv_segmentator<VertexSource>& 
+            operator = (const conv_segmentator<VertexSource>&);
+    };
+
+
+}
+
+#endif
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_stroke.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_stroke.h
new file mode 100644
index 0000000000..e19a6b61f4
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_stroke.h
@@ -0,0 +1,73 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// conv_stroke
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_CONV_STROKE_INCLUDED
+#define AGG_CONV_STROKE_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_vcgen_stroke.h"
+#include "agg_conv_adaptor_vcgen.h"
+
+namespace agg
+{
+
+    //-------------------------------------------------------------conv_stroke
+    template<class VertexSource, class Markers=null_markers> 
+    struct conv_stroke : 
+    public conv_adaptor_vcgen<VertexSource, vcgen_stroke, Markers>
+    {
+        typedef Markers marker_type;
+        typedef conv_adaptor_vcgen<VertexSource, vcgen_stroke, Markers> base_type;
+
+        conv_stroke(VertexSource& vs) : 
+            conv_adaptor_vcgen<VertexSource, vcgen_stroke, Markers>(vs)
+        {
+        }
+
+        void line_cap(line_cap_e lc)     { base_type::generator().line_cap(lc);  }
+        void line_join(line_join_e lj)   { base_type::generator().line_join(lj); }
+        void inner_join(inner_join_e ij) { base_type::generator().inner_join(ij); }
+
+        line_cap_e   line_cap()   const { return base_type::generator().line_cap();  }
+        line_join_e  line_join()  const { return base_type::generator().line_join(); }
+        inner_join_e inner_join() const { return base_type::generator().inner_join(); }
+
+        void width(double w) { base_type::generator().width(w); }
+        void miter_limit(double ml) { base_type::generator().miter_limit(ml); }
+        void miter_limit_theta(double t) { base_type::generator().miter_limit_theta(t); }
+        void inner_miter_limit(double ml) { base_type::generator().inner_miter_limit(ml); }
+        void approximation_scale(double as) { base_type::generator().approximation_scale(as); }
+
+        double width() const { return base_type::generator().width(); }
+        double miter_limit() const { return base_type::generator().miter_limit(); }
+        double inner_miter_limit() const { return base_type::generator().inner_miter_limit(); }
+        double approximation_scale() const { return base_type::generator().approximation_scale(); }
+
+        void shorten(double s) { base_type::generator().shorten(s); }
+        double shorten() const { return base_type::generator().shorten(); }
+
+    private:
+       conv_stroke(const conv_stroke<VertexSource, Markers>&);
+       const conv_stroke<VertexSource, Markers>& 
+           operator = (const conv_stroke<VertexSource, Markers>&);
+
+    };
+
+}
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_transform.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_transform.h
new file mode 100644
index 0000000000..0c88a245bd
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_conv_transform.h
@@ -0,0 +1,68 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// class conv_transform
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_CONV_TRANSFORM_INCLUDED
+#define AGG_CONV_TRANSFORM_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_trans_affine.h"
+
+namespace agg
+{
+
+    //----------------------------------------------------------conv_transform
+    template<class VertexSource, class Transformer=trans_affine> class conv_transform
+    {
+    public:
+        conv_transform(VertexSource& source, Transformer& tr) :
+            m_source(&source), m_trans(&tr) {}
+        void attach(VertexSource& source) { m_source = &source; }
+
+        void rewind(unsigned path_id) 
+        { 
+            m_source->rewind(path_id); 
+        }
+
+        unsigned vertex(double* x, double* y)
+        {
+            unsigned cmd = m_source->vertex(x, y);
+            if(is_vertex(cmd))
+            {
+                m_trans->transform(x, y);
+            }
+            return cmd;
+        }
+
+        void transformer(Transformer& tr)
+        {
+            m_trans = &tr;
+        }
+
+    private:
+        conv_transform(const conv_transform<VertexSource>&);
+        const conv_transform<VertexSource>& 
+            operator = (const conv_transform<VertexSource>&);
+
+        VertexSource*      m_source;
+        Transformer* m_trans;
+    };
+
+
+}
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_curves.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_curves.h
new file mode 100644
index 0000000000..1ef02e8783
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_curves.h
@@ -0,0 +1,693 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+// Copyright (C) 2005 Tony Juricic (tonygeek@yahoo.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_CURVES_INCLUDED
+#define AGG_CURVES_INCLUDED
+
+#include "agg_array.h"
+
+namespace agg
+{
+
+    // See Implementation agg_curves.cpp
+
+    //--------------------------------------------curve_approximation_method_e
+    enum curve_approximation_method_e
+    {
+        curve_inc,
+        curve_div
+    };
+    
+    //--------------------------------------------------------------curve3_inc
+    class curve3_inc
+    {
+    public:
+        curve3_inc() :
+          m_num_steps(0), m_step(0), m_scale(1.0) { }
+
+        curve3_inc(double x1, double y1, 
+                   double x2, double y2, 
+                   double x3, double y3) :
+            m_num_steps(0), m_step(0), m_scale(1.0) 
+        { 
+            init(x1, y1, x2, y2, x3, y3);
+        }
+
+        void reset() { m_num_steps = 0; m_step = -1; }
+        void init(double x1, double y1, 
+                  double x2, double y2, 
+                  double x3, double y3);
+
+        void approximation_method(curve_approximation_method_e) {}
+        curve_approximation_method_e approximation_method() const { return curve_inc; }
+
+        void approximation_scale(double s);
+        double approximation_scale() const;
+
+        void angle_tolerance(double) {}
+        double angle_tolerance() const { return 0.0; }
+
+        void cusp_limit(double) {}
+        double cusp_limit() const { return 0.0; }
+
+        void     rewind(unsigned path_id);
+        unsigned vertex(double* x, double* y);
+
+    private:
+        int      m_num_steps;
+        int      m_step;
+        double   m_scale;
+        double   m_start_x; 
+        double   m_start_y;
+        double   m_end_x; 
+        double   m_end_y;
+        double   m_fx; 
+        double   m_fy;
+        double   m_dfx; 
+        double   m_dfy;
+        double   m_ddfx; 
+        double   m_ddfy;
+        double   m_saved_fx; 
+        double   m_saved_fy;
+        double   m_saved_dfx; 
+        double   m_saved_dfy;
+    };
+
+
+
+
+
+    //-------------------------------------------------------------curve3_div
+    class curve3_div
+    {
+    public:
+        curve3_div() : 
+            m_approximation_scale(1.0),
+            m_angle_tolerance(0.0),
+            m_count(0)
+        {}
+
+        curve3_div(double x1, double y1, 
+                   double x2, double y2, 
+                   double x3, double y3) :
+            m_approximation_scale(1.0),
+            m_angle_tolerance(0.0),
+            m_count(0)
+        { 
+            init(x1, y1, x2, y2, x3, y3);
+        }
+
+        void reset() { m_points.remove_all(); m_count = 0; }
+        void init(double x1, double y1, 
+                  double x2, double y2, 
+                  double x3, double y3);
+
+        void approximation_method(curve_approximation_method_e) {}
+        curve_approximation_method_e approximation_method() const { return curve_div; }
+
+        void approximation_scale(double s) { m_approximation_scale = s; }
+        double approximation_scale() const { return m_approximation_scale;  }
+
+        void angle_tolerance(double a) { m_angle_tolerance = a; }
+        double angle_tolerance() const { return m_angle_tolerance;  }
+
+        void cusp_limit(double) {}
+        double cusp_limit() const { return 0.0; }
+
+        void rewind(unsigned)
+        {
+            m_count = 0;
+        }
+
+        unsigned vertex(double* x, double* y)
+        {
+            if(m_count >= m_points.size()) return path_cmd_stop;
+            const point_d& p = m_points[m_count++];
+            *x = p.x;
+            *y = p.y;
+            return (m_count == 1) ? path_cmd_move_to : path_cmd_line_to;
+        }
+
+    private:
+        void bezier(double x1, double y1, 
+                    double x2, double y2, 
+                    double x3, double y3);
+        void recursive_bezier(double x1, double y1, 
+                              double x2, double y2, 
+                              double x3, double y3,
+                              unsigned level);
+
+        double               m_approximation_scale;
+        double               m_distance_tolerance_square;
+        double               m_angle_tolerance;
+        unsigned             m_count;
+        pod_bvector<point_d> m_points;
+    };
+
+
+
+
+
+
+
+    //-------------------------------------------------------------curve4_points
+    struct curve4_points
+    {
+        double cp[8];
+        curve4_points() {}
+        curve4_points(double x1, double y1,
+                      double x2, double y2,
+                      double x3, double y3,
+                      double x4, double y4)
+        {
+            cp[0] = x1; cp[1] = y1; cp[2] = x2; cp[3] = y2;
+            cp[4] = x3; cp[5] = y3; cp[6] = x4; cp[7] = y4;
+        }
+        void init(double x1, double y1,
+                  double x2, double y2,
+                  double x3, double y3,
+                  double x4, double y4)
+        {
+            cp[0] = x1; cp[1] = y1; cp[2] = x2; cp[3] = y2;
+            cp[4] = x3; cp[5] = y3; cp[6] = x4; cp[7] = y4;
+        }
+        double  operator [] (unsigned i) const { return cp[i]; }
+        double& operator [] (unsigned i)       { return cp[i]; }
+    };
+
+
+
+    //-------------------------------------------------------------curve4_inc
+    class curve4_inc
+    {
+    public:
+        curve4_inc() :
+            m_num_steps(0), m_step(0), m_scale(1.0) { }
+
+        curve4_inc(double x1, double y1, 
+                   double x2, double y2, 
+                   double x3, double y3,
+                   double x4, double y4) :
+            m_num_steps(0), m_step(0), m_scale(1.0) 
+        { 
+            init(x1, y1, x2, y2, x3, y3, x4, y4);
+        }
+
+        curve4_inc(const curve4_points& cp) :
+            m_num_steps(0), m_step(0), m_scale(1.0) 
+        { 
+            init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
+        }
+
+        void reset() { m_num_steps = 0; m_step = -1; }
+        void init(double x1, double y1, 
+                  double x2, double y2, 
+                  double x3, double y3,
+                  double x4, double y4);
+
+        void init(const curve4_points& cp)
+        {
+            init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
+        }
+
+        void approximation_method(curve_approximation_method_e) {}
+        curve_approximation_method_e approximation_method() const { return curve_inc; }
+
+        void approximation_scale(double s);
+        double approximation_scale() const;
+
+        void angle_tolerance(double) {}
+        double angle_tolerance() const { return 0.0; }
+
+        void cusp_limit(double) {}
+        double cusp_limit() const { return 0.0; }
+
+        void     rewind(unsigned path_id);
+        unsigned vertex(double* x, double* y);
+
+    private:
+        int      m_num_steps;
+        int      m_step;
+        double   m_scale;
+        double   m_start_x; 
+        double   m_start_y;
+        double   m_end_x; 
+        double   m_end_y;
+        double   m_fx; 
+        double   m_fy;
+        double   m_dfx; 
+        double   m_dfy;
+        double   m_ddfx; 
+        double   m_ddfy;
+        double   m_dddfx; 
+        double   m_dddfy;
+        double   m_saved_fx; 
+        double   m_saved_fy;
+        double   m_saved_dfx; 
+        double   m_saved_dfy;
+        double   m_saved_ddfx; 
+        double   m_saved_ddfy;
+    };
+
+
+
+    //-------------------------------------------------------catrom_to_bezier
+    inline curve4_points catrom_to_bezier(double x1, double y1, 
+                                          double x2, double y2, 
+                                          double x3, double y3,
+                                          double x4, double y4)
+    {
+        // Trans. matrix Catmull-Rom to Bezier
+        //
+        //  0       1       0       0
+        //  -1/6    1       1/6     0
+        //  0       1/6     1       -1/6
+        //  0       0       1       0
+        //
+        return curve4_points(
+            x2,
+            y2,
+            (-x1 + 6*x2 + x3) / 6,
+            (-y1 + 6*y2 + y3) / 6,
+            ( x2 + 6*x3 - x4) / 6,
+            ( y2 + 6*y3 - y4) / 6,
+            x3,
+            y3);
+    }
+
+
+    //-----------------------------------------------------------------------
+    inline curve4_points
+    catrom_to_bezier(const curve4_points& cp)
+    {
+        return catrom_to_bezier(cp[0], cp[1], cp[2], cp[3], 
+                                cp[4], cp[5], cp[6], cp[7]);
+    }
+
+
+
+    //-----------------------------------------------------ubspline_to_bezier
+    inline curve4_points ubspline_to_bezier(double x1, double y1, 
+                                            double x2, double y2, 
+                                            double x3, double y3,
+                                            double x4, double y4)
+    {
+        // Trans. matrix Uniform BSpline to Bezier
+        //
+        //  1/6     4/6     1/6     0
+        //  0       4/6     2/6     0
+        //  0       2/6     4/6     0
+        //  0       1/6     4/6     1/6
+        //
+        return curve4_points(
+            (x1 + 4*x2 + x3) / 6,
+            (y1 + 4*y2 + y3) / 6,
+            (4*x2 + 2*x3) / 6,
+            (4*y2 + 2*y3) / 6,
+            (2*x2 + 4*x3) / 6,
+            (2*y2 + 4*y3) / 6,
+            (x2 + 4*x3 + x4) / 6,
+            (y2 + 4*y3 + y4) / 6);
+    }
+
+
+    //-----------------------------------------------------------------------
+    inline curve4_points 
+    ubspline_to_bezier(const curve4_points& cp)
+    {
+        return ubspline_to_bezier(cp[0], cp[1], cp[2], cp[3], 
+                                  cp[4], cp[5], cp[6], cp[7]);
+    }
+
+
+
+
+    //------------------------------------------------------hermite_to_bezier
+    inline curve4_points hermite_to_bezier(double x1, double y1, 
+                                           double x2, double y2, 
+                                           double x3, double y3,
+                                           double x4, double y4)
+    {
+        // Trans. matrix Hermite to Bezier
+        //
+        //  1       0       0       0
+        //  1       0       1/3     0
+        //  0       1       0       -1/3
+        //  0       1       0       0
+        //
+        return curve4_points(
+            x1,
+            y1,
+            (3*x1 + x3) / 3,
+            (3*y1 + y3) / 3,
+            (3*x2 - x4) / 3,
+            (3*y2 - y4) / 3,
+            x2,
+            y2);
+    }
+
+
+
+    //-----------------------------------------------------------------------
+    inline curve4_points 
+    hermite_to_bezier(const curve4_points& cp)
+    {
+        return hermite_to_bezier(cp[0], cp[1], cp[2], cp[3], 
+                                 cp[4], cp[5], cp[6], cp[7]);
+    }
+
+
+    //-------------------------------------------------------------curve4_div
+    class curve4_div
+    {
+    public:
+        curve4_div() : 
+            m_approximation_scale(1.0),
+            m_angle_tolerance(0.0),
+            m_cusp_limit(0.0),
+            m_count(0)
+        {}
+
+        curve4_div(double x1, double y1, 
+                   double x2, double y2, 
+                   double x3, double y3,
+                   double x4, double y4) :
+            m_approximation_scale(1.0),
+            m_angle_tolerance(0.0),
+            m_cusp_limit(0.0),
+            m_count(0)
+        { 
+            init(x1, y1, x2, y2, x3, y3, x4, y4);
+        }
+
+        curve4_div(const curve4_points& cp) :
+            m_approximation_scale(1.0),
+            m_angle_tolerance(0.0),
+            m_count(0)
+        { 
+            init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
+        }
+
+        void reset() { m_points.remove_all(); m_count = 0; }
+        void init(double x1, double y1, 
+                  double x2, double y2, 
+                  double x3, double y3,
+                  double x4, double y4);
+
+        void init(const curve4_points& cp)
+        {
+            init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
+        }
+
+        void approximation_method(curve_approximation_method_e) {}
+
+        curve_approximation_method_e approximation_method() const 
+        { 
+            return curve_div; 
+        }
+
+        void approximation_scale(double s) { m_approximation_scale = s; }
+        double approximation_scale() const { return m_approximation_scale;  }
+
+        void angle_tolerance(double a) { m_angle_tolerance = a; }
+        double angle_tolerance() const { return m_angle_tolerance;  }
+
+        void cusp_limit(double v) 
+        { 
+            m_cusp_limit = (v == 0.0) ? 0.0 : pi - v; 
+        }
+
+        double cusp_limit() const 
+        { 
+            return (m_cusp_limit == 0.0) ? 0.0 : pi - m_cusp_limit; 
+        }
+
+        void rewind(unsigned)
+        {
+            m_count = 0;
+        }
+
+        unsigned vertex(double* x, double* y)
+        {
+            if(m_count >= m_points.size()) return path_cmd_stop;
+            const point_d& p = m_points[m_count++];
+            *x = p.x;
+            *y = p.y;
+            return (m_count == 1) ? path_cmd_move_to : path_cmd_line_to;
+        }
+
+    private:
+        void bezier(double x1, double y1, 
+                    double x2, double y2, 
+                    double x3, double y3, 
+                    double x4, double y4);
+
+        void recursive_bezier(double x1, double y1, 
+                              double x2, double y2, 
+                              double x3, double y3, 
+                              double x4, double y4,
+                              unsigned level);
+
+        double               m_approximation_scale;
+        double               m_distance_tolerance_square;
+        double               m_angle_tolerance;
+        double               m_cusp_limit;
+        unsigned             m_count;
+        pod_bvector<point_d> m_points;
+    };
+
+
+    //-----------------------------------------------------------------curve3
+    class curve3
+    {
+    public:
+        curve3() : m_approximation_method(curve_div) {}
+        curve3(double x1, double y1, 
+               double x2, double y2, 
+               double x3, double y3) :
+            m_approximation_method(curve_div)
+        { 
+            init(x1, y1, x2, y2, x3, y3);
+        }
+
+        void reset() 
+        { 
+            m_curve_inc.reset();
+            m_curve_div.reset();
+        }
+
+        void init(double x1, double y1, 
+                  double x2, double y2, 
+                  double x3, double y3)
+        {
+            if(m_approximation_method == curve_inc) 
+            {
+                m_curve_inc.init(x1, y1, x2, y2, x3, y3);
+            }
+            else
+            {
+                m_curve_div.init(x1, y1, x2, y2, x3, y3);
+            }
+        }
+
+        void approximation_method(curve_approximation_method_e v) 
+        { 
+            m_approximation_method = v; 
+        }
+
+        curve_approximation_method_e approximation_method() const 
+        { 
+            return m_approximation_method; 
+        }
+
+        void approximation_scale(double s) 
+        { 
+            m_curve_inc.approximation_scale(s);
+            m_curve_div.approximation_scale(s);
+        }
+
+        double approximation_scale() const 
+        { 
+            return m_curve_inc.approximation_scale(); 
+        }
+
+        void angle_tolerance(double a) 
+        { 
+            m_curve_div.angle_tolerance(a); 
+        }
+
+        double angle_tolerance() const 
+        { 
+            return m_curve_div.angle_tolerance(); 
+        }
+
+        void cusp_limit(double v) 
+        { 
+            m_curve_div.cusp_limit(v); 
+        }
+
+        double cusp_limit() const 
+        { 
+            return m_curve_div.cusp_limit();  
+        }
+
+        void rewind(unsigned path_id)
+        {
+            if(m_approximation_method == curve_inc) 
+            {
+                m_curve_inc.rewind(path_id);
+            }
+            else
+            {
+                m_curve_div.rewind(path_id);
+            }
+        }
+
+        unsigned vertex(double* x, double* y)
+        {
+            if(m_approximation_method == curve_inc) 
+            {
+                return m_curve_inc.vertex(x, y);
+            }
+            return m_curve_div.vertex(x, y);
+        }
+
+    private:
+        curve3_inc m_curve_inc;
+        curve3_div m_curve_div;
+        curve_approximation_method_e m_approximation_method;
+    };
+
+
+
+
+
+    //-----------------------------------------------------------------curve4
+    class curve4
+    {
+    public:
+        curve4() : m_approximation_method(curve_div) {}
+        curve4(double x1, double y1, 
+               double x2, double y2, 
+               double x3, double y3,
+               double x4, double y4) : 
+            m_approximation_method(curve_div)
+        { 
+            init(x1, y1, x2, y2, x3, y3, x4, y4);
+        }
+
+        curve4(const curve4_points& cp) :
+            m_approximation_method(curve_div)
+        { 
+            init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
+        }
+
+        void reset() 
+        { 
+            m_curve_inc.reset();
+            m_curve_div.reset();
+        }
+
+        void init(double x1, double y1, 
+                  double x2, double y2, 
+                  double x3, double y3,
+                  double x4, double y4)
+        {
+            if(m_approximation_method == curve_inc) 
+            {
+                m_curve_inc.init(x1, y1, x2, y2, x3, y3, x4, y4);
+            }
+            else
+            {
+                m_curve_div.init(x1, y1, x2, y2, x3, y3, x4, y4);
+            }
+        }
+
+        void init(const curve4_points& cp)
+        {
+            init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
+        }
+
+        void approximation_method(curve_approximation_method_e v) 
+        { 
+            m_approximation_method = v; 
+        }
+
+        curve_approximation_method_e approximation_method() const 
+        { 
+            return m_approximation_method; 
+        }
+
+        void approximation_scale(double s) 
+        { 
+            m_curve_inc.approximation_scale(s);
+            m_curve_div.approximation_scale(s);
+        }
+        double approximation_scale() const { return m_curve_inc.approximation_scale(); }
+
+        void angle_tolerance(double v) 
+        { 
+            m_curve_div.angle_tolerance(v); 
+        }
+
+        double angle_tolerance() const 
+        { 
+            return m_curve_div.angle_tolerance();  
+        }
+
+        void cusp_limit(double v) 
+        { 
+            m_curve_div.cusp_limit(v); 
+        }
+
+        double cusp_limit() const 
+        { 
+            return m_curve_div.cusp_limit();  
+        }
+
+        void rewind(unsigned path_id)
+        {
+            if(m_approximation_method == curve_inc) 
+            {
+                m_curve_inc.rewind(path_id);
+            }
+            else
+            {
+                m_curve_div.rewind(path_id);
+            }
+        }
+
+        unsigned vertex(double* x, double* y)
+        {
+            if(m_approximation_method == curve_inc) 
+            {
+                return m_curve_inc.vertex(x, y);
+            }
+            return m_curve_div.vertex(x, y);
+        }
+
+    private:
+        curve4_inc m_curve_inc;
+        curve4_div m_curve_div;
+        curve_approximation_method_e m_approximation_method;
+    };
+
+
+
+
+}
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_dda_line.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_dda_line.h
new file mode 100644
index 0000000000..f589e76b83
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_dda_line.h
@@ -0,0 +1,290 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// classes dda_line_interpolator, dda2_line_interpolator
+//
+//----------------------------------------------------------------------------
+
+#ifndef AGG_DDA_LINE_INCLUDED
+#define AGG_DDA_LINE_INCLUDED
+
+#include <stdlib.h>
+#include "agg_basics.h"
+
+namespace agg
+{
+
+    //===================================================dda_line_interpolator
+    template<int FractionShift, int YShift=0> class dda_line_interpolator
+    {
+    public:
+        //--------------------------------------------------------------------
+        dda_line_interpolator() {}
+
+        //--------------------------------------------------------------------
+        dda_line_interpolator(int y1, int y2, unsigned count) :
+            m_y(y1),
+            m_inc(((y2 - y1) << FractionShift) / int(count)),
+            m_dy(0)
+        {
+        }
+
+        //--------------------------------------------------------------------
+        void operator ++ ()
+        {
+            m_dy += m_inc;
+        }
+
+        //--------------------------------------------------------------------
+        void operator -- ()
+        {
+            m_dy -= m_inc;
+        }
+
+        //--------------------------------------------------------------------
+        void operator += (unsigned n)
+        {
+            m_dy += m_inc * n;
+        }
+
+        //--------------------------------------------------------------------
+        void operator -= (unsigned n)
+        {
+            m_dy -= m_inc * n;
+        }
+
+
+        //--------------------------------------------------------------------
+        int y()  const { return m_y + (m_dy >> (FractionShift-YShift)); }
+        int dy() const { return m_dy; }
+
+
+    private:
+        int m_y;
+        int m_inc;
+        int m_dy;
+    };
+
+
+
+
+
+    //=================================================dda2_line_interpolator
+    class dda2_line_interpolator
+    {
+    public:
+        typedef int save_data_type;
+        enum save_size_e { save_size = 2 };
+
+        //--------------------------------------------------------------------
+        dda2_line_interpolator() {}
+
+        //-------------------------------------------- Forward-adjusted line
+        dda2_line_interpolator(int y1, int y2, int count) :
+            m_cnt(count <= 0 ? 1 : count),
+            m_lft((y2 - y1) / m_cnt),
+            m_rem((y2 - y1) % m_cnt),
+            m_mod(m_rem),
+            m_y(y1)
+        {
+            if(m_mod <= 0)
+            {
+                m_mod += count;
+                m_rem += count;
+                m_lft--;
+            }
+            m_mod -= count;
+        }
+
+        //-------------------------------------------- Backward-adjusted line
+        dda2_line_interpolator(int y1, int y2, int count, int) :
+            m_cnt(count <= 0 ? 1 : count),
+            m_lft((y2 - y1) / m_cnt),
+            m_rem((y2 - y1) % m_cnt),
+            m_mod(m_rem),
+            m_y(y1)
+        {
+            if(m_mod <= 0)
+            {
+                m_mod += count;
+                m_rem += count;
+                m_lft--;
+            }
+        }
+
+        //-------------------------------------------- Backward-adjusted line
+        dda2_line_interpolator(int y, int count) :
+            m_cnt(count <= 0 ? 1 : count),
+            m_lft(y / m_cnt),
+            m_rem(y % m_cnt),
+            m_mod(m_rem),
+            m_y(0)
+        {
+            if(m_mod <= 0)
+            {
+                m_mod += count;
+                m_rem += count;
+                m_lft--;
+            }
+        }
+
+
+        //--------------------------------------------------------------------
+        void save(save_data_type* data) const
+        {
+            data[0] = m_mod;
+            data[1] = m_y;
+        }
+
+        //--------------------------------------------------------------------
+        void load(const save_data_type* data)
+        {
+            m_mod = data[0];
+            m_y   = data[1];
+        }
+
+        //--------------------------------------------------------------------
+        void operator++()
+        {
+            m_mod += m_rem;
+            m_y += m_lft;
+            if(m_mod > 0)
+            {
+                m_mod -= m_cnt;
+                m_y++;
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void operator--()
+        {
+            if(m_mod <= m_rem)
+            {
+                m_mod += m_cnt;
+                m_y--;
+            }
+            m_mod -= m_rem;
+            m_y -= m_lft;
+        }
+
+        //--------------------------------------------------------------------
+        void adjust_forward()
+        {
+            m_mod -= m_cnt;
+        }
+
+        //--------------------------------------------------------------------
+        void adjust_backward()
+        {
+            m_mod += m_cnt;
+        }
+
+        //--------------------------------------------------------------------
+        int mod() const { return m_mod; }
+        int rem() const { return m_rem; }
+        int lft() const { return m_lft; }
+
+        //--------------------------------------------------------------------
+        int y() const { return m_y; }
+
+    private:
+        int m_cnt;
+        int m_lft;
+        int m_rem;
+        int m_mod;
+        int m_y;
+    };
+
+
+
+
+
+
+
+    //---------------------------------------------line_bresenham_interpolator
+    class line_bresenham_interpolator
+    {
+    public:
+        enum subpixel_scale_e
+        {
+            subpixel_shift = 8,
+            subpixel_scale = 1 << subpixel_shift,
+            subpixel_mask  = subpixel_scale - 1
+        };
+
+        //--------------------------------------------------------------------
+        static int line_lr(int v) { return v >> subpixel_shift; }
+
+        //--------------------------------------------------------------------
+        line_bresenham_interpolator(int x1, int y1, int x2, int y2) :
+            m_x1_lr(line_lr(x1)),
+            m_y1_lr(line_lr(y1)),
+            m_x2_lr(line_lr(x2)),
+            m_y2_lr(line_lr(y2)),
+            m_ver(abs(m_x2_lr - m_x1_lr) < abs(m_y2_lr - m_y1_lr)),
+            m_len(m_ver ? abs(m_y2_lr - m_y1_lr) : 
+                          abs(m_x2_lr - m_x1_lr)),
+            m_inc(m_ver ? ((y2 > y1) ? 1 : -1) : ((x2 > x1) ? 1 : -1)),
+            m_interpolator(m_ver ? x1 : y1, 
+                           m_ver ? x2 : y2, 
+                           m_len)
+        {
+        }
+    
+        //--------------------------------------------------------------------
+        bool     is_ver() const { return m_ver; }
+        unsigned len()    const { return m_len; }
+        int      inc()    const { return m_inc; }
+
+        //--------------------------------------------------------------------
+        void hstep()
+        {
+            ++m_interpolator;
+            m_x1_lr += m_inc;
+        }
+
+        //--------------------------------------------------------------------
+        void vstep()
+        {
+            ++m_interpolator;
+            m_y1_lr += m_inc;
+        }
+
+        //--------------------------------------------------------------------
+        int x1() const { return m_x1_lr; }
+        int y1() const { return m_y1_lr; }
+        int x2() const { return line_lr(m_interpolator.y()); }
+        int y2() const { return line_lr(m_interpolator.y()); }
+        int x2_hr() const { return m_interpolator.y(); }
+        int y2_hr() const { return m_interpolator.y(); }
+
+    private:
+        int                    m_x1_lr;
+        int                    m_y1_lr;
+        int                    m_x2_lr;
+        int                    m_y2_lr;
+        bool                   m_ver;
+        unsigned               m_len;
+        int                    m_inc;
+        dda2_line_interpolator m_interpolator;
+
+    };
+
+
+}
+
+
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_gamma_functions.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_gamma_functions.h
new file mode 100644
index 0000000000..5d720daa9a
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_gamma_functions.h
@@ -0,0 +1,132 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_GAMMA_FUNCTIONS_INCLUDED
+#define AGG_GAMMA_FUNCTIONS_INCLUDED
+
+#include <math.h>
+#include "agg_basics.h"
+
+namespace agg
+{
+    //===============================================================gamma_none
+    struct gamma_none
+    {
+        double operator()(double x) const { return x; }
+    };
+
+
+    //==============================================================gamma_power
+    class gamma_power
+    {
+    public:
+        gamma_power() : m_gamma(1.0) {}
+        gamma_power(double g) : m_gamma(g) {}
+
+        void gamma(double g) { m_gamma = g; }
+        double gamma() const { return m_gamma; }
+
+        double operator() (double x) const
+        {
+            return pow(x, m_gamma);
+        }
+
+    private:
+        double m_gamma;
+    };
+
+
+    //==========================================================gamma_threshold
+    class gamma_threshold
+    {
+    public:
+        gamma_threshold() : m_threshold(0.5) {}
+        gamma_threshold(double t) : m_threshold(t) {}
+
+        void threshold(double t) { m_threshold = t; }
+        double threshold() const { return m_threshold; }
+
+        double operator() (double x) const
+        {
+            return (x < m_threshold) ? 0.0 : 1.0;
+        }
+
+    private:
+        double m_threshold;
+    };
+
+
+    //============================================================gamma_linear
+    class gamma_linear
+    {
+    public:
+        gamma_linear() : m_start(0.0), m_end(1.0) {}
+        gamma_linear(double s, double e) : m_start(s), m_end(e) {}
+
+        void set(double s, double e) { m_start = s; m_end = e; }
+        void start(double s) { m_start = s; }
+        void end(double e) { m_end = e; }
+        double start() const { return m_start; }
+        double end() const { return m_end; }
+
+        double operator() (double x) const
+        {
+            if(x < m_start) return 0.0;
+            if(x > m_end) return 1.0;
+            return (x - m_start) / (m_end - m_start);
+        }
+
+    private:
+        double m_start;
+        double m_end;
+    };
+
+
+    //==========================================================gamma_multiply
+    class gamma_multiply
+    {
+    public:
+        gamma_multiply() : m_mul(1.0) {}
+        gamma_multiply(double v) : m_mul(v) {}
+
+        void value(double v) { m_mul = v; }
+        double value() const { return m_mul; }
+
+        double operator() (double x) const
+        {
+            double y = x * m_mul;
+            if(y > 1.0) y = 1.0;
+            return y;
+        }
+
+    private:
+        double m_mul;
+    };
+
+    inline double sRGB_to_linear(double x)
+    {
+        return (x <= 0.04045) ? (x / 12.92) : pow((x + 0.055) / (1.055), 2.4);
+    }
+
+    inline double linear_to_sRGB(double x)
+    {
+        return (x <= 0.0031308) ? (x * 12.92) : (1.055 * pow(x, 1 / 2.4) - 0.055);
+    }
+}
+
+#endif
+
+
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_gamma_lut.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_gamma_lut.h
new file mode 100644
index 0000000000..ef1e38d809
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_gamma_lut.h
@@ -0,0 +1,305 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_GAMMA_LUT_INCLUDED
+#define AGG_GAMMA_LUT_INCLUDED
+
+#include <math.h>
+#include "agg_basics.h"
+#include "agg_gamma_functions.h"
+
+namespace agg
+{
+    template<class LoResT=int8u, 
+             class HiResT=int8u, 
+             unsigned GammaShift=8, 
+             unsigned HiResShift=8> class gamma_lut
+    {
+    public:
+        typedef gamma_lut<LoResT, HiResT, GammaShift, HiResShift> self_type;
+
+        enum gamma_scale_e
+        {
+            gamma_shift = GammaShift,
+            gamma_size  = 1 << gamma_shift,
+            gamma_mask  = gamma_size - 1
+        };
+
+        enum hi_res_scale_e
+        {
+            hi_res_shift = HiResShift,
+            hi_res_size  = 1 << hi_res_shift,
+            hi_res_mask  = hi_res_size - 1
+        };
+
+        ~gamma_lut()
+        {
+            pod_allocator<LoResT>::deallocate(m_inv_gamma, hi_res_size);
+            pod_allocator<HiResT>::deallocate(m_dir_gamma, gamma_size);
+        }
+
+        gamma_lut() : 
+            m_gamma(1.0), 
+            m_dir_gamma(pod_allocator<HiResT>::allocate(gamma_size)),
+            m_inv_gamma(pod_allocator<LoResT>::allocate(hi_res_size))
+        {
+            unsigned i;
+            for(i = 0; i < gamma_size; i++)
+            {
+                m_dir_gamma[i] = HiResT(i << (hi_res_shift - gamma_shift));
+            }
+
+            for(i = 0; i < hi_res_size; i++)
+            {
+                m_inv_gamma[i] = LoResT(i >> (hi_res_shift - gamma_shift));
+            }
+        }
+
+        gamma_lut(double g) :
+            m_gamma(1.0), 
+            m_dir_gamma(pod_allocator<HiResT>::allocate(gamma_size)),
+            m_inv_gamma(pod_allocator<LoResT>::allocate(hi_res_size))
+        {
+            gamma(g);
+        }
+
+        void gamma(double g) 
+        {
+            m_gamma = g;
+
+            unsigned i;
+            for(i = 0; i < gamma_size; i++)
+            {
+                m_dir_gamma[i] = (HiResT)
+                    uround(pow(i / double(gamma_mask), m_gamma) * double(hi_res_mask));
+            }
+
+            double inv_g = 1.0 / g;
+            for(i = 0; i < hi_res_size; i++)
+            {
+                m_inv_gamma[i] = (LoResT)
+                    uround(pow(i / double(hi_res_mask), inv_g) * double(gamma_mask));
+            }
+        }
+
+        double gamma() const
+        {
+            return m_gamma;
+        }
+
+        HiResT dir(LoResT v) const 
+        { 
+            return m_dir_gamma[unsigned(v)]; 
+        }
+
+        LoResT inv(HiResT v) const 
+        { 
+            return m_inv_gamma[unsigned(v)];
+        }
+
+    private:
+        gamma_lut(const self_type&);
+        const self_type& operator = (const self_type&);
+
+        double m_gamma;
+        HiResT* m_dir_gamma;
+        LoResT* m_inv_gamma;
+    };
+
+    //
+    // sRGB support classes
+    //
+
+    // Optimized sRGB lookup table. The direct conversion (sRGB to linear) 
+    // is a straightforward lookup. The inverse conversion (linear to sRGB) 
+    // is implemented using binary search.
+    template<class LinearType>
+    class sRGB_lut_base
+    {
+    public:
+        LinearType dir(int8u v) const
+        {
+            return m_dir_table[v];
+        }
+
+        int8u inv(LinearType v) const
+        {
+            // Unrolled binary search.
+            int8u x = 0;
+            if (v > m_inv_table[128]) x = 128;
+            if (v > m_inv_table[x + 64]) x += 64;
+            if (v > m_inv_table[x + 32]) x += 32;
+            if (v > m_inv_table[x + 16]) x += 16;
+            if (v > m_inv_table[x + 8]) x += 8;
+            if (v > m_inv_table[x + 4]) x += 4;
+            if (v > m_inv_table[x + 2]) x += 2;
+            if (v > m_inv_table[x + 1]) x += 1;
+            return x;
+        }
+
+    protected:
+        LinearType m_dir_table[256];
+        LinearType m_inv_table[256];
+
+        // Only derived classes may instantiate.
+        sRGB_lut_base() 
+        {
+        }
+    };
+
+    // sRGB_lut - implements sRGB conversion for the various types.
+    // Base template is undefined, specializations are provided below.
+    template<class LinearType>
+    class sRGB_lut;
+
+    template<>
+    class sRGB_lut<float> : public sRGB_lut_base<float>
+    {
+    public:
+        sRGB_lut()
+        {
+            // Generate lookup tables.
+            m_dir_table[0] = 0;
+            m_inv_table[0] = 0;
+            for (unsigned i = 1; i <= 255; ++i)
+            {
+                // Floating-point RGB is in range [0,1].
+                m_dir_table[i] = float(sRGB_to_linear(i / 255.0));
+                m_inv_table[i] = float(sRGB_to_linear((i - 0.5) / 255.0));
+            }
+        }
+    };
+
+    template<>
+    class sRGB_lut<int16u> : public sRGB_lut_base<int16u>
+    {
+    public:
+        sRGB_lut()
+        {
+            // Generate lookup tables.
+            m_dir_table[0] = 0;
+            m_inv_table[0] = 0;
+            for (unsigned i = 1; i <= 255; ++i)
+            {
+                // 16-bit RGB is in range [0,65535].
+                m_dir_table[i] = uround(65535.0 * sRGB_to_linear(i / 255.0));
+                m_inv_table[i] = uround(65535.0 * sRGB_to_linear((i - 0.5) / 255.0));
+            }
+        }
+    };
+
+    template<>
+    class sRGB_lut<int8u> : public sRGB_lut_base<int8u>
+    {
+    public:
+        sRGB_lut()
+        {
+            // Generate lookup tables. 
+            m_dir_table[0] = 0;
+            m_inv_table[0] = 0;
+            for (unsigned i = 1; i <= 255; ++i)
+            {
+                // 8-bit RGB is handled with simple bidirectional lookup tables.
+                m_dir_table[i] = uround(255.0 * sRGB_to_linear(i / 255.0));
+                m_inv_table[i] = uround(255.0 * linear_to_sRGB(i / 255.0));
+            }
+        }
+
+        int8u inv(int8u v) const
+        {
+            // In this case, the inverse transform is a simple lookup.
+            return m_inv_table[v];
+        }
+    };
+
+    // Common base class for sRGB_conv objects. Defines an internal 
+    // sRGB_lut object so that users don't have to.
+    template<class T>
+    class sRGB_conv_base
+    {
+    public:
+        static T rgb_from_sRGB(int8u x)
+        {
+            return lut.dir(x);
+        }
+
+        static int8u rgb_to_sRGB(T x)
+        {
+            return lut.inv(x);
+        }
+
+    private:
+        static sRGB_lut<T> lut;
+    };
+
+    // Definition of sRGB_conv_base::lut. Due to the fact that this a template, 
+    // we don't need to place the definition in a cpp file. Hurrah.
+    template<class T>
+    sRGB_lut<T> sRGB_conv_base<T>::lut;
+
+    // Wrapper for sRGB-linear conversion. 
+    // Base template is undefined, specializations are provided below.
+    template<class T>
+    class sRGB_conv;
+
+    template<>
+    class sRGB_conv<float> : public sRGB_conv_base<float>
+    {
+    public:
+        static float alpha_from_sRGB(int8u x)
+        {
+            return float(x / 255.0);
+        }
+
+        static int8u alpha_to_sRGB(float x)
+        {
+            if (x <= 0) return 0;
+            else if (x >= 1) return 255;
+            else return int8u(0.5 + x * 255);
+        }
+    };
+
+    template<>
+    class sRGB_conv<int16u> : public sRGB_conv_base<int16u>
+    {
+    public:
+        static int16u alpha_from_sRGB(int8u x)
+        {
+            return (x << 8) | x;
+        }
+
+        static int8u alpha_to_sRGB(int16u x)
+        {
+            return x >> 8;
+        }
+    };
+
+    template<>
+    class sRGB_conv<int8u> : public sRGB_conv_base<int8u>
+    {
+    public:
+        static int8u alpha_from_sRGB(int8u x)
+        {
+            return x;
+        }
+
+        static int8u alpha_to_sRGB(int8u x)
+        {
+            return x;
+        }
+    };
+}
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_image_accessors.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_image_accessors.h
new file mode 100644
index 0000000000..c651d6d2e8
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_image_accessors.h
@@ -0,0 +1,481 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_IMAGE_ACCESSORS_INCLUDED
+#define AGG_IMAGE_ACCESSORS_INCLUDED
+
+#include "agg_basics.h"
+
+namespace agg
+{
+
+    //-----------------------------------------------------image_accessor_clip
+    template<class PixFmt> class image_accessor_clip
+    {
+    public:
+        typedef PixFmt   pixfmt_type;
+        typedef typename pixfmt_type::color_type color_type;
+        typedef typename pixfmt_type::order_type order_type;
+        typedef typename pixfmt_type::value_type value_type;
+        enum pix_width_e { pix_width = pixfmt_type::pix_width };
+
+        image_accessor_clip() {}
+        explicit image_accessor_clip(pixfmt_type& pixf, 
+                                     const color_type& bk) : 
+            m_pixf(&pixf)
+        {
+            pixfmt_type::make_pix(m_bk_buf, bk);
+        }
+
+        void attach(pixfmt_type& pixf)
+        {
+            m_pixf = &pixf;
+        }
+
+        void background_color(const color_type& bk)
+        {
+            pixfmt_type::make_pix(m_bk_buf, bk);
+        }
+
+    private:
+        AGG_INLINE const int8u* pixel() const
+        {
+            if(m_y >= 0 && m_y < (int)m_pixf->height() &&
+               m_x >= 0 && m_x < (int)m_pixf->width())
+            {
+                return m_pixf->pix_ptr(m_x, m_y);
+            }
+            return m_bk_buf;
+        }
+
+    public:
+        AGG_INLINE const int8u* span(int x, int y, unsigned len)
+        {
+            m_x = m_x0 = x;
+            m_y = y;
+            if(y >= 0 && y < (int)m_pixf->height() &&
+               x >= 0 && x+(int)len <= (int)m_pixf->width())
+            {
+                return m_pix_ptr = m_pixf->pix_ptr(x, y);
+            }
+            m_pix_ptr = 0;
+            return pixel();
+        }
+
+        AGG_INLINE const int8u* next_x()
+        {
+            if(m_pix_ptr) return m_pix_ptr += pix_width;
+            ++m_x;
+            return pixel();
+        }
+
+        AGG_INLINE const int8u* next_y()
+        {
+            ++m_y;
+            m_x = m_x0;
+            if(m_pix_ptr && 
+               m_y >= 0 && m_y < (int)m_pixf->height())
+            {
+                return m_pix_ptr = m_pixf->pix_ptr(m_x, m_y);
+            }
+            m_pix_ptr = 0;
+            return pixel();
+        }
+
+    private:
+        const pixfmt_type* m_pixf;
+        int8u              m_bk_buf[pix_width];
+        int                m_x, m_x0, m_y;
+        const int8u*       m_pix_ptr;
+    };
+
+
+
+
+    //--------------------------------------------------image_accessor_no_clip
+    template<class PixFmt> class image_accessor_no_clip
+    {
+    public:
+        typedef PixFmt   pixfmt_type;
+        typedef typename pixfmt_type::color_type color_type;
+        typedef typename pixfmt_type::order_type order_type;
+        typedef typename pixfmt_type::value_type value_type;
+        enum pix_width_e { pix_width = pixfmt_type::pix_width };
+
+        image_accessor_no_clip() {}
+        explicit image_accessor_no_clip(pixfmt_type& pixf) : 
+            m_pixf(&pixf) 
+        {}
+
+        void attach(pixfmt_type& pixf)
+        {
+            m_pixf = &pixf;
+        }
+
+        AGG_INLINE const int8u* span(int x, int y, unsigned)
+        {
+            m_x = x;
+            m_y = y;
+            return m_pix_ptr = m_pixf->pix_ptr(x, y);
+        }
+
+        AGG_INLINE const int8u* next_x()
+        {
+            return m_pix_ptr += pix_width;
+        }
+
+        AGG_INLINE const int8u* next_y()
+        {
+            ++m_y;
+            return m_pix_ptr = m_pixf->pix_ptr(m_x, m_y);
+        }
+
+    private:
+        const pixfmt_type* m_pixf;
+        int                m_x, m_y;
+        const int8u*       m_pix_ptr;
+    };
+
+
+
+
+    //----------------------------------------------------image_accessor_clone
+    template<class PixFmt> class image_accessor_clone
+    {
+    public:
+        typedef PixFmt   pixfmt_type;
+        typedef typename pixfmt_type::color_type color_type;
+        typedef typename pixfmt_type::order_type order_type;
+        typedef typename pixfmt_type::value_type value_type;
+        enum pix_width_e { pix_width = pixfmt_type::pix_width };
+
+        image_accessor_clone() {}
+        explicit image_accessor_clone(pixfmt_type& pixf) : 
+            m_pixf(&pixf) 
+        {}
+
+        void attach(pixfmt_type& pixf)
+        {
+            m_pixf = &pixf;
+        }
+
+    private:
+        AGG_INLINE const int8u* pixel() const
+        {
+            int x = m_x;
+            int y = m_y;
+            if(x < 0) x = 0;
+            if(y < 0) y = 0;
+            if(x >= (int)m_pixf->width())  x = m_pixf->width() - 1;
+            if(y >= (int)m_pixf->height()) y = m_pixf->height() - 1;
+            return m_pixf->pix_ptr(x, y);
+        }
+
+    public:
+        AGG_INLINE const int8u* span(int x, int y, unsigned len)
+        {
+            m_x = m_x0 = x;
+            m_y = y;
+            if(y >= 0 && y < (int)m_pixf->height() &&
+               x >= 0 && x+len <= (int)m_pixf->width())
+            {
+                return m_pix_ptr = m_pixf->pix_ptr(x, y);
+            }
+            m_pix_ptr = 0;
+            return pixel();
+        }
+
+        AGG_INLINE const int8u* next_x()
+        {
+            if(m_pix_ptr) return m_pix_ptr += pix_width;
+            ++m_x;
+            return pixel();
+        }
+
+        AGG_INLINE const int8u* next_y()
+        {
+            ++m_y;
+            m_x = m_x0;
+            if(m_pix_ptr && 
+               m_y >= 0 && m_y < (int)m_pixf->height())
+            {
+                return m_pix_ptr = m_pixf->pix_ptr(m_x, m_y);
+            }
+            m_pix_ptr = 0;
+            return pixel();
+        }
+
+    private:
+        const pixfmt_type* m_pixf;
+        int                m_x, m_x0, m_y;
+        const int8u*       m_pix_ptr;
+    };
+
+
+
+
+
+    //-----------------------------------------------------image_accessor_wrap
+    template<class PixFmt, class WrapX, class WrapY> class image_accessor_wrap
+    {
+    public:
+        typedef PixFmt   pixfmt_type;
+        typedef typename pixfmt_type::color_type color_type;
+        typedef typename pixfmt_type::order_type order_type;
+        typedef typename pixfmt_type::value_type value_type;
+        enum pix_width_e { pix_width = pixfmt_type::pix_width };
+
+        image_accessor_wrap() {}
+        explicit image_accessor_wrap(pixfmt_type& pixf) : 
+            m_pixf(&pixf), 
+            m_wrap_x(pixf.width()), 
+            m_wrap_y(pixf.height())
+        {}
+
+        void attach(pixfmt_type& pixf)
+        {
+            m_pixf = &pixf;
+        }
+
+        AGG_INLINE const int8u* span(int x, int y, unsigned)
+        {
+            m_x = x;
+            m_row_ptr = m_pixf->pix_ptr(0, m_wrap_y(y));
+            return m_row_ptr + m_wrap_x(x) * pix_width;
+        }
+
+        AGG_INLINE const int8u* next_x()
+        {
+            int x = ++m_wrap_x;
+            return m_row_ptr + x * pix_width;
+        }
+
+        AGG_INLINE const int8u* next_y()
+        {
+            m_row_ptr = m_pixf->pix_ptr(0, ++m_wrap_y);
+            return m_row_ptr + m_wrap_x(m_x) * pix_width;
+        }
+
+    private:
+        const pixfmt_type* m_pixf;
+        const int8u*       m_row_ptr;
+        int                m_x;
+        WrapX              m_wrap_x;
+        WrapY              m_wrap_y;
+    };
+
+
+
+
+    //--------------------------------------------------------wrap_mode_repeat
+    class wrap_mode_repeat
+    {
+    public:
+        wrap_mode_repeat() {}
+        wrap_mode_repeat(unsigned size) : 
+            m_size(size), 
+            m_add(size * (0x3FFFFFFF / size)),
+            m_value(0)
+        {}
+
+        AGG_INLINE unsigned operator() (int v)
+        { 
+            return m_value = (unsigned(v) + m_add) % m_size; 
+        }
+
+        AGG_INLINE unsigned operator++ ()
+        {
+            ++m_value;
+            if(m_value >= m_size) m_value = 0;
+            return m_value;
+        }
+    private:
+        unsigned m_size;
+        unsigned m_add;
+        unsigned m_value;
+    };
+
+
+    //---------------------------------------------------wrap_mode_repeat_pow2
+    class wrap_mode_repeat_pow2
+    {
+    public:
+        wrap_mode_repeat_pow2() {}
+        wrap_mode_repeat_pow2(unsigned size) : m_value(0)
+        {
+            m_mask = 1;
+            while(m_mask < size) m_mask = (m_mask << 1) | 1;
+            m_mask >>= 1;
+        }
+        AGG_INLINE unsigned operator() (int v)
+        { 
+            return m_value = unsigned(v) & m_mask;
+        }
+        AGG_INLINE unsigned operator++ ()
+        {
+            ++m_value;
+            if(m_value > m_mask) m_value = 0;
+            return m_value;
+        }
+    private:
+        unsigned m_mask;
+        unsigned m_value;
+    };
+
+
+    //----------------------------------------------wrap_mode_repeat_auto_pow2
+    class wrap_mode_repeat_auto_pow2
+    {
+    public:
+        wrap_mode_repeat_auto_pow2() {}
+        wrap_mode_repeat_auto_pow2(unsigned size) :
+            m_size(size),
+            m_add(size * (0x3FFFFFFF / size)),
+            m_mask((m_size & (m_size-1)) ? 0 : m_size-1),
+            m_value(0)
+        {}
+
+        AGG_INLINE unsigned operator() (int v) 
+        { 
+            if(m_mask) return m_value = unsigned(v) & m_mask;
+            return m_value = (unsigned(v) + m_add) % m_size;
+        }
+        AGG_INLINE unsigned operator++ ()
+        {
+            ++m_value;
+            if(m_value >= m_size) m_value = 0;
+            return m_value;
+        }
+
+    private:
+        unsigned m_size;
+        unsigned m_add;
+        unsigned m_mask;
+        unsigned m_value;
+    };
+
+
+    //-------------------------------------------------------wrap_mode_reflect
+    class wrap_mode_reflect
+    {
+    public:
+        wrap_mode_reflect() {}
+        wrap_mode_reflect(unsigned size) : 
+            m_size(size), 
+            m_size2(size * 2),
+            m_add(m_size2 * (0x3FFFFFFF / m_size2)),
+            m_value(0)
+        {}
+
+        AGG_INLINE unsigned operator() (int v)
+        { 
+            m_value = (unsigned(v) + m_add) % m_size2;
+            if(m_value >= m_size) return m_size2 - m_value - 1;
+            return m_value;
+        }
+
+        AGG_INLINE unsigned operator++ ()
+        {
+            ++m_value;
+            if(m_value >= m_size2) m_value = 0;
+            if(m_value >= m_size) return m_size2 - m_value - 1;
+            return m_value;
+        }
+    private:
+        unsigned m_size;
+        unsigned m_size2;
+        unsigned m_add;
+        unsigned m_value;
+    };
+
+
+
+    //--------------------------------------------------wrap_mode_reflect_pow2
+    class wrap_mode_reflect_pow2
+    {
+    public:
+        wrap_mode_reflect_pow2() {}
+        wrap_mode_reflect_pow2(unsigned size) : m_value(0)
+        {
+            m_mask = 1;
+            m_size = 1;
+            while(m_mask < size) 
+            {
+                m_mask = (m_mask << 1) | 1;
+                m_size <<= 1;
+            }
+        }
+        AGG_INLINE unsigned operator() (int v)
+        { 
+            m_value = unsigned(v) & m_mask;
+            if(m_value >= m_size) return m_mask - m_value;
+            return m_value;
+        }
+        AGG_INLINE unsigned operator++ ()
+        {
+            ++m_value;
+            m_value &= m_mask;
+            if(m_value >= m_size) return m_mask - m_value;
+            return m_value;
+        }
+    private:
+        unsigned m_size;
+        unsigned m_mask;
+        unsigned m_value;
+    };
+
+
+
+    //---------------------------------------------wrap_mode_reflect_auto_pow2
+    class wrap_mode_reflect_auto_pow2
+    {
+    public:
+        wrap_mode_reflect_auto_pow2() {}
+        wrap_mode_reflect_auto_pow2(unsigned size) :
+            m_size(size),
+            m_size2(size * 2),
+            m_add(m_size2 * (0x3FFFFFFF / m_size2)),
+            m_mask((m_size2 & (m_size2-1)) ? 0 : m_size2-1),
+            m_value(0)
+        {}
+
+        AGG_INLINE unsigned operator() (int v) 
+        { 
+            m_value = m_mask ? unsigned(v) & m_mask : 
+                              (unsigned(v) + m_add) % m_size2;
+            if(m_value >= m_size) return m_size2 - m_value - 1;
+            return m_value;            
+        }
+        AGG_INLINE unsigned operator++ ()
+        {
+            ++m_value;
+            if(m_value >= m_size2) m_value = 0;
+            if(m_value >= m_size) return m_size2 - m_value - 1;
+            return m_value;
+        }
+
+    private:
+        unsigned m_size;
+        unsigned m_size2;
+        unsigned m_add;
+        unsigned m_mask;
+        unsigned m_value;
+    };
+
+
+}
+
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_image_filters.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_image_filters.h
new file mode 100644
index 0000000000..8e1bc8f0db
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_image_filters.h
@@ -0,0 +1,448 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Image transformation filters,
+// Filtering classes (image_filter_lut, image_filter),
+// Basic filter shape classes
+//----------------------------------------------------------------------------
+#ifndef AGG_IMAGE_FILTERS_INCLUDED
+#define AGG_IMAGE_FILTERS_INCLUDED
+
+#include "agg_array.h"
+#include "agg_math.h"
+
+namespace agg
+{
+
+    // See Implementation agg_image_filters.cpp 
+
+    enum image_filter_scale_e
+    {
+        image_filter_shift = 14,                      //----image_filter_shift
+        image_filter_scale = 1 << image_filter_shift, //----image_filter_scale 
+        image_filter_mask  = image_filter_scale - 1   //----image_filter_mask 
+    };
+
+    enum image_subpixel_scale_e
+    {
+        image_subpixel_shift = 8,                         //----image_subpixel_shift
+        image_subpixel_scale = 1 << image_subpixel_shift, //----image_subpixel_scale 
+        image_subpixel_mask  = image_subpixel_scale - 1   //----image_subpixel_mask 
+    };
+
+
+    //-----------------------------------------------------image_filter_lut
+    class image_filter_lut
+    {
+    public:
+        template<class FilterF> void calculate(const FilterF& filter,
+                                               bool normalization=true)
+        {
+            double r = filter.radius();
+            realloc_lut(r);
+            unsigned i;
+            unsigned pivot = diameter() << (image_subpixel_shift - 1);
+            for(i = 0; i < pivot; i++)
+            {
+                double x = double(i) / double(image_subpixel_scale);
+                double y = filter.calc_weight(x);
+                m_weight_array[pivot + i] = 
+                m_weight_array[pivot - i] = (int16)iround(y * image_filter_scale);
+            }
+            unsigned end = (diameter() << image_subpixel_shift) - 1;
+            m_weight_array[0] = m_weight_array[end];
+            if(normalization) 
+            {
+                normalize();
+            }
+        }
+
+        image_filter_lut() : m_radius(0), m_diameter(0), m_start(0) {}
+
+        template<class FilterF> image_filter_lut(const FilterF& filter, 
+                                                 bool normalization=true)
+        {
+            calculate(filter, normalization);
+        }
+
+        double       radius()       const { return m_radius;   }
+        unsigned     diameter()     const { return m_diameter; }
+        int          start()        const { return m_start;    }
+        const int16* weight_array() const { return &m_weight_array[0]; }
+        void         normalize();
+
+    private:
+        void realloc_lut(double radius);
+        image_filter_lut(const image_filter_lut&);
+        const image_filter_lut& operator = (const image_filter_lut&);
+
+        double           m_radius;
+        unsigned         m_diameter;
+        int              m_start;
+        pod_array<int16> m_weight_array;
+    };
+
+
+
+    //--------------------------------------------------------image_filter
+    template<class FilterF> class image_filter : public image_filter_lut
+    {
+    public:
+        image_filter()
+        {
+            calculate(m_filter_function);
+        }
+    private:
+        FilterF m_filter_function;
+    };
+
+
+    //-----------------------------------------------image_filter_bilinear
+    struct image_filter_bilinear
+    {
+        static double radius() { return 1.0; }
+        static double calc_weight(double x)
+        {
+            return 1.0 - x;
+        }
+    };
+
+
+    //-----------------------------------------------image_filter_hanning
+    struct image_filter_hanning
+    {
+        static double radius() { return 1.0; }
+        static double calc_weight(double x)
+        {
+            return 0.5 + 0.5 * cos(pi * x);
+        }
+    };
+
+
+    //-----------------------------------------------image_filter_hamming
+    struct image_filter_hamming
+    {
+        static double radius() { return 1.0; }
+        static double calc_weight(double x)
+        {
+            return 0.54 + 0.46 * cos(pi * x);
+        }
+    };
+
+    //-----------------------------------------------image_filter_hermite
+    struct image_filter_hermite
+    {
+        static double radius() { return 1.0; }
+        static double calc_weight(double x)
+        {
+            return (2.0 * x - 3.0) * x * x + 1.0;
+        }
+    };
+   
+    //------------------------------------------------image_filter_quadric
+    struct image_filter_quadric
+    {
+        static double radius() { return 1.5; }
+        static double calc_weight(double x)
+        {
+            double t;
+            if(x <  0.5) return 0.75 - x * x;
+            if(x <  1.5) {t = x - 1.5; return 0.5 * t * t;}
+            return 0.0;
+        }
+    };
+
+    //------------------------------------------------image_filter_bicubic
+    class image_filter_bicubic
+    {
+        static double pow3(double x)
+        {
+            return (x <= 0.0) ? 0.0 : x * x * x;
+        }
+
+    public:
+        static double radius() { return 2.0; }
+        static double calc_weight(double x)
+        {
+            return
+                (1.0/6.0) * 
+                (pow3(x + 2) - 4 * pow3(x + 1) + 6 * pow3(x) - 4 * pow3(x - 1));
+        }
+    };
+
+    //-------------------------------------------------image_filter_kaiser
+    class image_filter_kaiser
+    {
+        double a;
+        double i0a;
+        double epsilon;
+
+    public:
+        image_filter_kaiser(double b = 6.33) :
+            a(b), epsilon(1e-12)
+        {
+            i0a = 1.0 / bessel_i0(b);
+        }
+
+        static double radius() { return 1.0; }
+        double calc_weight(double x) const
+        {
+            return bessel_i0(a * sqrt(1. - x * x)) * i0a;
+        }
+
+    private:
+        double bessel_i0(double x) const
+        {
+            int i;
+            double sum, y, t;
+
+            sum = 1.;
+            y = x * x / 4.;
+            t = y;
+        
+            for(i = 2; t > epsilon; i++)
+            {
+                sum += t;
+                t *= (double)y / (i * i);
+            }
+            return sum;
+        }
+    };
+
+    //----------------------------------------------image_filter_catrom
+    struct image_filter_catrom
+    {
+        static double radius() { return 2.0; }
+        static double calc_weight(double x)
+        {
+            if(x <  1.0) return 0.5 * (2.0 + x * x * (-5.0 + x * 3.0));
+            if(x <  2.0) return 0.5 * (4.0 + x * (-8.0 + x * (5.0 - x)));
+            return 0.;
+        }
+    };
+
+    //---------------------------------------------image_filter_mitchell
+    class image_filter_mitchell
+    {
+        double p0, p2, p3;
+        double q0, q1, q2, q3;
+
+    public:
+        image_filter_mitchell(double b = 1.0/3.0, double c = 1.0/3.0) :
+            p0((6.0 - 2.0 * b) / 6.0),
+            p2((-18.0 + 12.0 * b + 6.0 * c) / 6.0),
+            p3((12.0 - 9.0 * b - 6.0 * c) / 6.0),
+            q0((8.0 * b + 24.0 * c) / 6.0),
+            q1((-12.0 * b - 48.0 * c) / 6.0),
+            q2((6.0 * b + 30.0 * c) / 6.0),
+            q3((-b - 6.0 * c) / 6.0)
+        {}
+
+        static double radius() { return 2.0; }
+        double calc_weight(double x) const
+        {
+            if(x < 1.0) return p0 + x * x * (p2 + x * p3);
+            if(x < 2.0) return q0 + x * (q1 + x * (q2 + x * q3));
+            return 0.0;
+        }
+    };
+
+
+    //----------------------------------------------image_filter_spline16
+    struct image_filter_spline16
+    {
+        static double radius() { return 2.0; }
+        static double calc_weight(double x)
+        {
+            if(x < 1.0)
+            {
+                return ((x - 9.0/5.0 ) * x - 1.0/5.0 ) * x + 1.0;
+            }
+            return ((-1.0/3.0 * (x-1) + 4.0/5.0) * (x-1) - 7.0/15.0 ) * (x-1);
+        }
+    };
+
+
+    //---------------------------------------------image_filter_spline36
+    struct image_filter_spline36
+    {
+        static double radius() { return 3.0; }
+        static double calc_weight(double x)
+        {
+           if(x < 1.0)
+           {
+              return ((13.0/11.0 * x - 453.0/209.0) * x - 3.0/209.0) * x + 1.0;
+           }
+           if(x < 2.0)
+           {
+              return ((-6.0/11.0 * (x-1) + 270.0/209.0) * (x-1) - 156.0/ 209.0) * (x-1);
+           }
+           return ((1.0/11.0 * (x-2) - 45.0/209.0) * (x-2) +  26.0/209.0) * (x-2);
+        }
+    };
+
+
+    //----------------------------------------------image_filter_gaussian
+    struct image_filter_gaussian
+    {
+        static double radius() { return 2.0; }
+        static double calc_weight(double x) 
+        {
+            return exp(-2.0 * x * x) * sqrt(2.0 / pi);
+        }
+    };
+
+
+    //------------------------------------------------image_filter_bessel
+    struct image_filter_bessel
+    {
+        static double radius() { return 3.2383; } 
+        static double calc_weight(double x)
+        {
+            return (x == 0.0) ? pi / 4.0 : besj(pi * x, 1) / (2.0 * x);
+        }
+    };
+
+
+    //-------------------------------------------------image_filter_sinc
+    class image_filter_sinc
+    {
+    public:
+        image_filter_sinc(double r) : m_radius(r < 2.0 ? 2.0 : r) {}
+        double radius() const { return m_radius; }
+        double calc_weight(double x) const
+        {
+            if(x == 0.0) return 1.0;
+            x *= pi;
+            return sin(x) / x;
+        }
+    private:
+        double m_radius;
+    };
+
+
+    //-----------------------------------------------image_filter_lanczos
+    class image_filter_lanczos
+    {
+    public:
+        image_filter_lanczos(double r) : m_radius(r < 2.0 ? 2.0 : r) {}
+        double radius() const { return m_radius; }
+        double calc_weight(double x) const
+        {
+           if(x == 0.0) return 1.0;
+           if(x > m_radius) return 0.0;
+           x *= pi;
+           double xr = x / m_radius;
+           return (sin(x) / x) * (sin(xr) / xr);
+        }
+    private:
+        double m_radius;
+    };
+
+
+    //----------------------------------------------image_filter_blackman
+    class image_filter_blackman
+    {
+    public:
+        image_filter_blackman(double r) : m_radius(r < 2.0 ? 2.0 : r) {}
+        double radius() const { return m_radius; }
+        double calc_weight(double x) const
+        {
+           if(x == 0.0) return 1.0;
+           if(x > m_radius) return 0.0;
+           x *= pi;
+           double xr = x / m_radius;
+           return (sin(x) / x) * (0.42 + 0.5*cos(xr) + 0.08*cos(2*xr));
+        }
+    private:
+        double m_radius;
+    };
+
+    //------------------------------------------------image_filter_sinc36
+    class image_filter_sinc36 : public image_filter_sinc
+    { public: image_filter_sinc36() : image_filter_sinc(3.0){} };
+
+    //------------------------------------------------image_filter_sinc64
+    class image_filter_sinc64 : public image_filter_sinc
+    { public: image_filter_sinc64() : image_filter_sinc(4.0){} };
+
+    //-----------------------------------------------image_filter_sinc100
+    class image_filter_sinc100 : public image_filter_sinc
+    { public: image_filter_sinc100() : image_filter_sinc(5.0){} };
+
+    //-----------------------------------------------image_filter_sinc144
+    class image_filter_sinc144 : public image_filter_sinc
+    { public: image_filter_sinc144() : image_filter_sinc(6.0){} };
+
+    //-----------------------------------------------image_filter_sinc196
+    class image_filter_sinc196 : public image_filter_sinc
+    { public: image_filter_sinc196() : image_filter_sinc(7.0){} };
+
+    //-----------------------------------------------image_filter_sinc256
+    class image_filter_sinc256 : public image_filter_sinc
+    { public: image_filter_sinc256() : image_filter_sinc(8.0){} };
+
+    //---------------------------------------------image_filter_lanczos36
+    class image_filter_lanczos36 : public image_filter_lanczos
+    { public: image_filter_lanczos36() : image_filter_lanczos(3.0){} };
+
+    //---------------------------------------------image_filter_lanczos64
+    class image_filter_lanczos64 : public image_filter_lanczos
+    { public: image_filter_lanczos64() : image_filter_lanczos(4.0){} };
+
+    //--------------------------------------------image_filter_lanczos100
+    class image_filter_lanczos100 : public image_filter_lanczos
+    { public: image_filter_lanczos100() : image_filter_lanczos(5.0){} };
+
+    //--------------------------------------------image_filter_lanczos144
+    class image_filter_lanczos144 : public image_filter_lanczos
+    { public: image_filter_lanczos144() : image_filter_lanczos(6.0){} };
+
+    //--------------------------------------------image_filter_lanczos196
+    class image_filter_lanczos196 : public image_filter_lanczos
+    { public: image_filter_lanczos196() : image_filter_lanczos(7.0){} };
+
+    //--------------------------------------------image_filter_lanczos256
+    class image_filter_lanczos256 : public image_filter_lanczos
+    { public: image_filter_lanczos256() : image_filter_lanczos(8.0){} };
+
+    //--------------------------------------------image_filter_blackman36
+    class image_filter_blackman36 : public image_filter_blackman
+    { public: image_filter_blackman36() : image_filter_blackman(3.0){} };
+
+    //--------------------------------------------image_filter_blackman64
+    class image_filter_blackman64 : public image_filter_blackman
+    { public: image_filter_blackman64() : image_filter_blackman(4.0){} };
+
+    //-------------------------------------------image_filter_blackman100
+    class image_filter_blackman100 : public image_filter_blackman
+    { public: image_filter_blackman100() : image_filter_blackman(5.0){} };
+
+    //-------------------------------------------image_filter_blackman144
+    class image_filter_blackman144 : public image_filter_blackman
+    { public: image_filter_blackman144() : image_filter_blackman(6.0){} };
+
+    //-------------------------------------------image_filter_blackman196
+    class image_filter_blackman196 : public image_filter_blackman
+    { public: image_filter_blackman196() : image_filter_blackman(7.0){} };
+
+    //-------------------------------------------image_filter_blackman256
+    class image_filter_blackman256 : public image_filter_blackman
+    { public: image_filter_blackman256() : image_filter_blackman(8.0){} };
+
+
+}
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_math.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_math.h
new file mode 100644
index 0000000000..2ec49cf3ff
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_math.h
@@ -0,0 +1,437 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+// Bessel function (besj) was adapted for use in AGG library by Andy Wilk 
+// Contact: castor.vulgaris@gmail.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_MATH_INCLUDED
+#define AGG_MATH_INCLUDED
+
+#include <math.h>
+#include "agg_basics.h"
+
+namespace agg
+{
+
+    //------------------------------------------------------vertex_dist_epsilon
+    // Coinciding points maximal distance (Epsilon)
+    const double vertex_dist_epsilon = 1e-14;
+
+    //-----------------------------------------------------intersection_epsilon
+    // See calc_intersection
+    const double intersection_epsilon = 1.0e-30;
+
+    //------------------------------------------------------------cross_product
+    AGG_INLINE double cross_product(double x1, double y1, 
+                                    double x2, double y2, 
+                                    double x,  double y)
+    {
+        return (x - x2) * (y2 - y1) - (y - y2) * (x2 - x1);
+    }
+
+    //--------------------------------------------------------point_in_triangle
+    AGG_INLINE bool point_in_triangle(double x1, double y1, 
+                                      double x2, double y2, 
+                                      double x3, double y3, 
+                                      double x,  double y)
+    {
+        bool cp1 = cross_product(x1, y1, x2, y2, x, y) < 0.0;
+        bool cp2 = cross_product(x2, y2, x3, y3, x, y) < 0.0;
+        bool cp3 = cross_product(x3, y3, x1, y1, x, y) < 0.0;
+        return cp1 == cp2 && cp2 == cp3 && cp3 == cp1;
+    }
+
+    //-----------------------------------------------------------calc_distance
+    AGG_INLINE double calc_distance(double x1, double y1, double x2, double y2)
+    {
+        double dx = x2-x1;
+        double dy = y2-y1;
+        return sqrt(dx * dx + dy * dy);
+    }
+
+    //--------------------------------------------------------calc_sq_distance
+    AGG_INLINE double calc_sq_distance(double x1, double y1, double x2, double y2)
+    {
+        double dx = x2-x1;
+        double dy = y2-y1;
+        return dx * dx + dy * dy;
+    }
+
+    //------------------------------------------------calc_line_point_distance
+    AGG_INLINE double calc_line_point_distance(double x1, double y1, 
+                                               double x2, double y2, 
+                                               double x,  double y)
+    {
+        double dx = x2-x1;
+        double dy = y2-y1;
+        double d = sqrt(dx * dx + dy * dy);
+        if(d < vertex_dist_epsilon)
+        {
+            return calc_distance(x1, y1, x, y);
+        }
+        return ((x - x2) * dy - (y - y2) * dx) / d;
+    }
+
+    //-------------------------------------------------------calc_line_point_u
+    AGG_INLINE double calc_segment_point_u(double x1, double y1, 
+                                           double x2, double y2, 
+                                           double x,  double y)
+    {
+        double dx = x2 - x1;
+        double dy = y2 - y1;
+
+        if(dx == 0 && dy == 0)
+        {
+	        return 0;
+        }
+
+        double pdx = x - x1;
+        double pdy = y - y1;
+
+        return (pdx * dx + pdy * dy) / (dx * dx + dy * dy);
+    }
+
+    //---------------------------------------------calc_line_point_sq_distance
+    AGG_INLINE double calc_segment_point_sq_distance(double x1, double y1, 
+                                                     double x2, double y2, 
+                                                     double x,  double y,
+                                                     double u)
+    {
+        if(u <= 0)
+        {
+	        return calc_sq_distance(x, y, x1, y1);
+        }
+        else 
+        if(u >= 1)
+        {
+	        return calc_sq_distance(x, y, x2, y2);
+        }
+        return calc_sq_distance(x, y, x1 + u * (x2 - x1), y1 + u * (y2 - y1));
+    }
+
+    //---------------------------------------------calc_line_point_sq_distance
+    AGG_INLINE double calc_segment_point_sq_distance(double x1, double y1, 
+                                                     double x2, double y2, 
+                                                     double x,  double y)
+    {
+        return 
+            calc_segment_point_sq_distance(
+                x1, y1, x2, y2, x, y,
+                calc_segment_point_u(x1, y1, x2, y2, x, y));
+    }
+
+    //-------------------------------------------------------calc_intersection
+    AGG_INLINE bool calc_intersection(double ax, double ay, double bx, double by,
+                                      double cx, double cy, double dx, double dy,
+                                      double* x, double* y)
+    {
+        double num = (ay-cy) * (dx-cx) - (ax-cx) * (dy-cy);
+        double den = (bx-ax) * (dy-cy) - (by-ay) * (dx-cx);
+        if(fabs(den) < intersection_epsilon) return false;
+        double r = num / den;
+        *x = ax + r * (bx-ax);
+        *y = ay + r * (by-ay);
+        return true;
+    }
+
+    //-----------------------------------------------------intersection_exists
+    AGG_INLINE bool intersection_exists(double x1, double y1, double x2, double y2,
+                                        double x3, double y3, double x4, double y4)
+    {
+        // It's less expensive but you can't control the 
+        // boundary conditions: Less or LessEqual
+        double dx1 = x2 - x1;
+        double dy1 = y2 - y1;
+        double dx2 = x4 - x3;
+        double dy2 = y4 - y3;
+        return ((x3 - x2) * dy1 - (y3 - y2) * dx1 < 0.0) != 
+               ((x4 - x2) * dy1 - (y4 - y2) * dx1 < 0.0) &&
+               ((x1 - x4) * dy2 - (y1 - y4) * dx2 < 0.0) !=
+               ((x2 - x4) * dy2 - (y2 - y4) * dx2 < 0.0);
+
+        // It's is more expensive but more flexible 
+        // in terms of boundary conditions.
+        //--------------------
+        //double den  = (x2-x1) * (y4-y3) - (y2-y1) * (x4-x3);
+        //if(fabs(den) < intersection_epsilon) return false;
+        //double nom1 = (x4-x3) * (y1-y3) - (y4-y3) * (x1-x3);
+        //double nom2 = (x2-x1) * (y1-y3) - (y2-y1) * (x1-x3);
+        //double ua = nom1 / den;
+        //double ub = nom2 / den;
+        //return ua >= 0.0 && ua <= 1.0 && ub >= 0.0 && ub <= 1.0;
+    }
+
+    //--------------------------------------------------------calc_orthogonal
+    AGG_INLINE void calc_orthogonal(double thickness,
+                                    double x1, double y1,
+                                    double x2, double y2,
+                                    double* x, double* y)
+    {
+        double dx = x2 - x1;
+        double dy = y2 - y1;
+        double d = sqrt(dx*dx + dy*dy); 
+        *x =  thickness * dy / d;
+        *y = -thickness * dx / d;
+    }
+
+    //--------------------------------------------------------dilate_triangle
+    AGG_INLINE void dilate_triangle(double x1, double y1,
+                                    double x2, double y2,
+                                    double x3, double y3,
+                                    double *x, double* y,
+                                    double d)
+    {
+        double dx1=0.0;
+        double dy1=0.0; 
+        double dx2=0.0;
+        double dy2=0.0; 
+        double dx3=0.0;
+        double dy3=0.0; 
+        double loc = cross_product(x1, y1, x2, y2, x3, y3);
+        if(fabs(loc) > intersection_epsilon)
+        {
+            if(cross_product(x1, y1, x2, y2, x3, y3) > 0.0) 
+            {
+                d = -d;
+            }
+            calc_orthogonal(d, x1, y1, x2, y2, &dx1, &dy1);
+            calc_orthogonal(d, x2, y2, x3, y3, &dx2, &dy2);
+            calc_orthogonal(d, x3, y3, x1, y1, &dx3, &dy3);
+        }
+        *x++ = x1 + dx1;  *y++ = y1 + dy1;
+        *x++ = x2 + dx1;  *y++ = y2 + dy1;
+        *x++ = x2 + dx2;  *y++ = y2 + dy2;
+        *x++ = x3 + dx2;  *y++ = y3 + dy2;
+        *x++ = x3 + dx3;  *y++ = y3 + dy3;
+        *x++ = x1 + dx3;  *y++ = y1 + dy3;
+    }
+
+    //------------------------------------------------------calc_triangle_area
+    AGG_INLINE double calc_triangle_area(double x1, double y1,
+                                         double x2, double y2,
+                                         double x3, double y3)
+    {
+        return (x1*y2 - x2*y1 + x2*y3 - x3*y2 + x3*y1 - x1*y3) * 0.5;
+    }
+
+    //-------------------------------------------------------calc_polygon_area
+    template<class Storage> double calc_polygon_area(const Storage& st)
+    {
+        unsigned i;
+        double sum = 0.0;
+        double x  = st[0].x;
+        double y  = st[0].y;
+        double xs = x;
+        double ys = y;
+
+        for(i = 1; i < st.size(); i++)
+        {
+            const typename Storage::value_type& v = st[i];
+            sum += x * v.y - y * v.x;
+            x = v.x;
+            y = v.y;
+        }
+        return (sum + x * ys - y * xs) * 0.5;
+    }
+
+    //------------------------------------------------------------------------
+    // Tables for fast sqrt
+    extern int16u g_sqrt_table[1024];
+    extern int8   g_elder_bit_table[256];
+
+
+    //---------------------------------------------------------------fast_sqrt
+    //Fast integer Sqrt - really fast: no cycles, divisions or multiplications
+    #if defined(_MSC_VER)
+    #pragma warning(push)
+    #pragma warning(disable : 4035) //Disable warning "no return value"
+    #endif
+    AGG_INLINE unsigned fast_sqrt(unsigned val)
+    {
+    #if defined(_M_IX86) && defined(_MSC_VER) && !defined(AGG_NO_ASM)
+        //For Ix86 family processors this assembler code is used. 
+        //The key command here is bsr - determination the number of the most 
+        //significant bit of the value. For other processors
+        //(and maybe compilers) the pure C "#else" section is used.
+        __asm
+        {
+            mov ebx, val
+            mov edx, 11
+            bsr ecx, ebx
+            sub ecx, 9
+            jle less_than_9_bits
+            shr ecx, 1
+            adc ecx, 0
+            sub edx, ecx
+            shl ecx, 1
+            shr ebx, cl
+    less_than_9_bits:
+            xor eax, eax
+            mov  ax, g_sqrt_table[ebx*2]
+            mov ecx, edx
+            shr eax, cl
+        }
+    #else
+
+        //This code is actually pure C and portable to most 
+        //arcitectures including 64bit ones. 
+        unsigned t = val;
+        int bit=0;
+        unsigned shift = 11;
+
+        //The following piece of code is just an emulation of the
+        //Ix86 assembler command "bsr" (see above). However on old
+        //Intels (like Intel MMX 233MHz) this code is about twice 
+        //faster (sic!) then just one "bsr". On PIII and PIV the
+        //bsr is optimized quite well.
+        bit = t >> 24;
+        if(bit)
+        {
+            bit = g_elder_bit_table[bit] + 24;
+        }
+        else
+        {
+            bit = (t >> 16) & 0xFF;
+            if(bit)
+            {
+                bit = g_elder_bit_table[bit] + 16;
+            }
+            else
+            {
+                bit = (t >> 8) & 0xFF;
+                if(bit)
+                {
+                    bit = g_elder_bit_table[bit] + 8;
+                }
+                else
+                {
+                    bit = g_elder_bit_table[t];
+                }
+            }
+        }
+
+        //This code calculates the sqrt.
+        bit -= 9;
+        if(bit > 0)
+        {
+            bit = (bit >> 1) + (bit & 1);
+            shift -= bit;
+            val >>= (bit << 1);
+        }
+        return g_sqrt_table[val] >> shift;
+    #endif
+    }
+    #if defined(_MSC_VER)
+    #pragma warning(pop)
+    #endif
+
+
+
+
+    //--------------------------------------------------------------------besj
+    // Function BESJ calculates Bessel function of first kind of order n
+    // Arguments:
+    //     n - an integer (>=0), the order
+    //     x - value at which the Bessel function is required
+    //--------------------
+    // C++ Mathematical Library
+    // Convereted from equivalent FORTRAN library
+    // Converetd by Gareth Walker for use by course 392 computational project
+    // All functions tested and yield the same results as the corresponding
+    // FORTRAN versions.
+    //
+    // If you have any problems using these functions please report them to
+    // M.Muldoon@UMIST.ac.uk
+    //
+    // Documentation available on the web
+    // http://www.ma.umist.ac.uk/mrm/Teaching/392/libs/392.html
+    // Version 1.0   8/98
+    // 29 October, 1999
+    //--------------------
+    // Adapted for use in AGG library by Andy Wilk (castor.vulgaris@gmail.com)
+    //------------------------------------------------------------------------
+    inline double besj(double x, int n)
+    {
+        if(n < 0)
+        {
+            return 0;
+        }
+        double d = 1E-6;
+        double b = 0;
+        if(fabs(x) <= d) 
+        {
+            if(n != 0) return 0;
+            return 1;
+        }
+        double b1 = 0; // b1 is the value from the previous iteration
+        // Set up a starting order for recurrence
+        int m1 = (int)fabs(x) + 6;
+        if(fabs(x) > 5) 
+        {
+            m1 = (int)(fabs(1.4 * x + 60 / x));
+        }
+        int m2 = (int)(n + 2 + fabs(x) / 4);
+        if (m1 > m2) 
+        {
+            m2 = m1;
+        }
+    
+        // Apply recurrence down from curent max order
+        for(;;) 
+        {
+            double c3 = 0;
+            double c2 = 1E-30;
+            double c4 = 0;
+            int m8 = 1;
+            if (m2 / 2 * 2 == m2) 
+            {
+                m8 = -1;
+            }
+            int imax = m2 - 2;
+            for (int i = 1; i <= imax; i++) 
+            {
+                double c6 = 2 * (m2 - i) * c2 / x - c3;
+                c3 = c2;
+                c2 = c6;
+                if(m2 - i - 1 == n)
+                {
+                    b = c6;
+                }
+                m8 = -1 * m8;
+                if (m8 > 0)
+                {
+                    c4 = c4 + 2 * c6;
+                }
+            }
+            double c6 = 2 * c2 / x - c3;
+            if(n == 0)
+            {
+                b = c6;
+            }
+            c4 += c6;
+            b /= c4;
+            if(fabs(b - b1) < d)
+            {
+                return b;
+            }
+            b1 = b;
+            m2 += 3;
+        }
+    }
+
+}
+
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_math_stroke.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_math_stroke.h
new file mode 100644
index 0000000000..4871d96cef
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_math_stroke.h
@@ -0,0 +1,527 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Stroke math
+//
+//----------------------------------------------------------------------------
+
+#ifndef AGG_STROKE_MATH_INCLUDED
+#define AGG_STROKE_MATH_INCLUDED
+
+#include "agg_math.h"
+#include "agg_vertex_sequence.h"
+
+namespace agg
+{
+    //-------------------------------------------------------------line_cap_e
+    enum line_cap_e
+    {
+        butt_cap,
+        square_cap,
+        round_cap
+    };
+
+    //------------------------------------------------------------line_join_e
+    enum line_join_e
+    {
+        miter_join         = 0,
+        miter_join_revert  = 1,
+        round_join         = 2,
+        bevel_join         = 3,
+        miter_join_round   = 4
+    };
+
+
+    //-----------------------------------------------------------inner_join_e
+    enum inner_join_e
+    {
+        inner_bevel,
+        inner_miter,
+        inner_jag,
+        inner_round
+    };
+
+    //------------------------------------------------------------math_stroke
+    template<class VertexConsumer> class math_stroke
+    {
+    public:
+        typedef typename VertexConsumer::value_type coord_type;
+
+        math_stroke();
+
+        void line_cap(line_cap_e lc)     { m_line_cap = lc; }
+        void line_join(line_join_e lj)   { m_line_join = lj; }
+        void inner_join(inner_join_e ij) { m_inner_join = ij; }
+
+        line_cap_e   line_cap()   const { return m_line_cap; }
+        line_join_e  line_join()  const { return m_line_join; }
+        inner_join_e inner_join() const { return m_inner_join; }
+
+        void width(double w);
+        void miter_limit(double ml) { m_miter_limit = ml; }
+        void miter_limit_theta(double t);
+        void inner_miter_limit(double ml) { m_inner_miter_limit = ml; }
+        void approximation_scale(double as) { m_approx_scale = as; }
+
+        double width() const { return m_width * 2.0; }
+        double miter_limit() const { return m_miter_limit; }
+        double inner_miter_limit() const { return m_inner_miter_limit; }
+        double approximation_scale() const { return m_approx_scale; }
+
+        void calc_cap(VertexConsumer& vc,
+                      const vertex_dist& v0, 
+                      const vertex_dist& v1, 
+                      double len);
+
+        void calc_join(VertexConsumer& vc,
+                       const vertex_dist& v0, 
+                       const vertex_dist& v1, 
+                       const vertex_dist& v2,
+                       double len1, 
+                       double len2);
+
+    private:
+        AGG_INLINE void add_vertex(VertexConsumer& vc, double x, double y)
+        {
+            vc.add(coord_type(x, y));
+        }
+
+        void calc_arc(VertexConsumer& vc,
+                      double x,   double y, 
+                      double dx1, double dy1, 
+                      double dx2, double dy2);
+
+        void calc_miter(VertexConsumer& vc,
+                        const vertex_dist& v0, 
+                        const vertex_dist& v1, 
+                        const vertex_dist& v2,
+                        double dx1, double dy1, 
+                        double dx2, double dy2,
+                        line_join_e lj,
+                        double mlimit,
+                        double dbevel);
+
+        double       m_width;
+        double       m_width_abs;
+        double       m_width_eps;
+        int          m_width_sign;
+        double       m_miter_limit;
+        double       m_inner_miter_limit;
+        double       m_approx_scale;
+        line_cap_e   m_line_cap;
+        line_join_e  m_line_join;
+        inner_join_e m_inner_join;
+    };
+
+    //-----------------------------------------------------------------------
+    template<class VC> math_stroke<VC>::math_stroke() :
+        m_width(0.5),
+        m_width_abs(0.5),
+        m_width_eps(0.5/1024.0),
+        m_width_sign(1),
+        m_miter_limit(4.0),
+        m_inner_miter_limit(1.01),
+        m_approx_scale(1.0),
+        m_line_cap(butt_cap),
+        m_line_join(miter_join),
+        m_inner_join(inner_miter)
+    {
+    }
+
+    //-----------------------------------------------------------------------
+    template<class VC> void math_stroke<VC>::width(double w)
+    { 
+        m_width = w * 0.5; 
+        if(m_width < 0)
+        {
+            m_width_abs  = -m_width;
+            m_width_sign = -1;
+        }
+        else
+        {
+            m_width_abs  = m_width;
+            m_width_sign = 1;
+        }
+        m_width_eps = m_width / 1024.0;
+    }
+
+    //-----------------------------------------------------------------------
+    template<class VC> void math_stroke<VC>::miter_limit_theta(double t)
+    { 
+        m_miter_limit = 1.0 / sin(t * 0.5) ;
+    }
+
+    //-----------------------------------------------------------------------
+    template<class VC> 
+    void math_stroke<VC>::calc_arc(VC& vc,
+                                   double x,   double y, 
+                                   double dx1, double dy1, 
+                                   double dx2, double dy2)
+    {
+        double a1 = atan2(dy1 * m_width_sign, dx1 * m_width_sign);
+        double a2 = atan2(dy2 * m_width_sign, dx2 * m_width_sign);
+        double da = a1 - a2;
+        int i, n;
+
+        da = acos(m_width_abs / (m_width_abs + 0.125 / m_approx_scale)) * 2;
+
+        add_vertex(vc, x + dx1, y + dy1);
+        if(m_width_sign > 0)
+        {
+            if(a1 > a2) a2 += 2 * pi;
+            n = int((a2 - a1) / da);
+            da = (a2 - a1) / (n + 1);
+            a1 += da;
+            for(i = 0; i < n; i++)
+            {
+                add_vertex(vc, x + cos(a1) * m_width, y + sin(a1) * m_width);
+                a1 += da;
+            }
+        }
+        else
+        {
+            if(a1 < a2) a2 -= 2 * pi;
+            n = int((a1 - a2) / da);
+            da = (a1 - a2) / (n + 1);
+            a1 -= da;
+            for(i = 0; i < n; i++)
+            {
+                add_vertex(vc, x + cos(a1) * m_width, y + sin(a1) * m_width);
+                a1 -= da;
+            }
+        }
+        add_vertex(vc, x + dx2, y + dy2);
+    }
+
+    //-----------------------------------------------------------------------
+    template<class VC> 
+    void math_stroke<VC>::calc_miter(VC& vc,
+                                     const vertex_dist& v0, 
+                                     const vertex_dist& v1, 
+                                     const vertex_dist& v2,
+                                     double dx1, double dy1, 
+                                     double dx2, double dy2,
+                                     line_join_e lj,
+                                     double mlimit,
+                                     double dbevel)
+    {
+        double xi  = v1.x;
+        double yi  = v1.y;
+        double di  = 1;
+        double lim = m_width_abs * mlimit;
+        bool miter_limit_exceeded = true; // Assume the worst
+        bool intersection_failed  = true; // Assume the worst
+
+        if(calc_intersection(v0.x + dx1, v0.y - dy1,
+                             v1.x + dx1, v1.y - dy1,
+                             v1.x + dx2, v1.y - dy2,
+                             v2.x + dx2, v2.y - dy2,
+                             &xi, &yi))
+        {
+            // Calculation of the intersection succeeded
+            //---------------------
+            di = calc_distance(v1.x, v1.y, xi, yi);
+            if(di <= lim)
+            {
+                // Inside the miter limit
+                //---------------------
+                add_vertex(vc, xi, yi);
+                miter_limit_exceeded = false;
+            }
+            intersection_failed = false;
+        }
+        else
+        {
+            // Calculation of the intersection failed, most probably
+            // the three points lie one straight line. 
+            // First check if v0 and v2 lie on the opposite sides of vector: 
+            // (v1.x, v1.y) -> (v1.x+dx1, v1.y-dy1), that is, the perpendicular
+            // to the line determined by vertices v0 and v1.
+            // This condition determines whether the next line segments continues
+            // the previous one or goes back.
+            //----------------
+            double x2 = v1.x + dx1;
+            double y2 = v1.y - dy1;
+            if((cross_product(v0.x, v0.y, v1.x, v1.y, x2, y2) < 0.0) == 
+               (cross_product(v1.x, v1.y, v2.x, v2.y, x2, y2) < 0.0))
+            {
+                // This case means that the next segment continues 
+                // the previous one (straight line)
+                //-----------------
+                add_vertex(vc, v1.x + dx1, v1.y - dy1);
+                miter_limit_exceeded = false;
+            }
+        }
+
+        if(miter_limit_exceeded)
+        {
+            // Miter limit exceeded
+            //------------------------
+            switch(lj)
+            {
+            case miter_join_revert:
+                // For the compatibility with SVG, PDF, etc, 
+                // we use a simple bevel join instead of
+                // "smart" bevel
+                //-------------------
+                add_vertex(vc, v1.x + dx1, v1.y - dy1);
+                add_vertex(vc, v1.x + dx2, v1.y - dy2);
+                break;
+
+            case miter_join_round:
+                calc_arc(vc, v1.x, v1.y, dx1, -dy1, dx2, -dy2);
+                break;
+
+            default:
+                // If no miter-revert, calculate new dx1, dy1, dx2, dy2
+                //----------------
+                if(intersection_failed)
+                {
+                    mlimit *= m_width_sign;
+                    add_vertex(vc, v1.x + dx1 + dy1 * mlimit, 
+                                   v1.y - dy1 + dx1 * mlimit);
+                    add_vertex(vc, v1.x + dx2 - dy2 * mlimit, 
+                                   v1.y - dy2 - dx2 * mlimit);
+                }
+                else
+                {
+                    double x1 = v1.x + dx1;
+                    double y1 = v1.y - dy1;
+                    double x2 = v1.x + dx2;
+                    double y2 = v1.y - dy2;
+                    di = (lim - dbevel) / (di - dbevel);
+                    add_vertex(vc, x1 + (xi - x1) * di, 
+                                   y1 + (yi - y1) * di);
+                    add_vertex(vc, x2 + (xi - x2) * di, 
+                                   y2 + (yi - y2) * di);
+                }
+                break;
+            }
+        }
+    }
+
+    //--------------------------------------------------------stroke_calc_cap
+    template<class VC> 
+    void math_stroke<VC>::calc_cap(VC& vc,
+                                   const vertex_dist& v0, 
+                                   const vertex_dist& v1, 
+                                   double len)
+    {
+        vc.remove_all();
+
+        double dx1 = (v1.y - v0.y) / len;
+        double dy1 = (v1.x - v0.x) / len;
+        double dx2 = 0;
+        double dy2 = 0;
+
+        dx1 *= m_width;
+        dy1 *= m_width;
+
+        if(m_line_cap != round_cap)
+        {
+            if(m_line_cap == square_cap)
+            {
+                dx2 = dy1 * m_width_sign;
+                dy2 = dx1 * m_width_sign;
+            }
+            add_vertex(vc, v0.x - dx1 - dx2, v0.y + dy1 - dy2);
+            add_vertex(vc, v0.x + dx1 - dx2, v0.y - dy1 - dy2);
+        }
+        else
+        {
+            double da = acos(m_width_abs / (m_width_abs + 0.125 / m_approx_scale)) * 2;
+            double a1;
+            int i;
+            int n = int(pi / da);
+
+            da = pi / (n + 1);
+            add_vertex(vc, v0.x - dx1, v0.y + dy1);
+            if(m_width_sign > 0)
+            {
+                a1 = atan2(dy1, -dx1);
+                a1 += da;
+                for(i = 0; i < n; i++)
+                {
+                    add_vertex(vc, v0.x + cos(a1) * m_width, 
+                                   v0.y + sin(a1) * m_width);
+                    a1 += da;
+                }
+            }
+            else
+            {
+                a1 = atan2(-dy1, dx1);
+                a1 -= da;
+                for(i = 0; i < n; i++)
+                {
+                    add_vertex(vc, v0.x + cos(a1) * m_width, 
+                                   v0.y + sin(a1) * m_width);
+                    a1 -= da;
+                }
+            }
+            add_vertex(vc, v0.x + dx1, v0.y - dy1);
+        }
+    }
+
+    //-----------------------------------------------------------------------
+    template<class VC> 
+    void math_stroke<VC>::calc_join(VC& vc,
+                                    const vertex_dist& v0, 
+                                    const vertex_dist& v1, 
+                                    const vertex_dist& v2,
+                                    double len1, 
+                                    double len2)
+    {
+        double dx1 = m_width * (v1.y - v0.y) / len1;
+        double dy1 = m_width * (v1.x - v0.x) / len1;
+        double dx2 = m_width * (v2.y - v1.y) / len2;
+        double dy2 = m_width * (v2.x - v1.x) / len2;
+
+        vc.remove_all();
+
+        double cp = cross_product(v0.x, v0.y, v1.x, v1.y, v2.x, v2.y);
+        if ((cp > agg::vertex_dist_epsilon && m_width > 0) ||
+            (cp < -agg::vertex_dist_epsilon && m_width < 0))
+        {
+            // Inner join
+            //---------------
+            double limit = ((len1 < len2) ? len1 : len2) / m_width_abs;
+            if(limit < m_inner_miter_limit)
+            {
+                limit = m_inner_miter_limit;
+            }
+
+            switch(m_inner_join)
+            {
+            default: // inner_bevel
+                add_vertex(vc, v1.x + dx1, v1.y - dy1);
+                add_vertex(vc, v1.x + dx2, v1.y - dy2);
+                break;
+
+            case inner_miter:
+                calc_miter(vc,
+                           v0, v1, v2, dx1, dy1, dx2, dy2, 
+                           miter_join_revert, 
+                           limit, 0);
+                break;
+
+            case inner_jag:
+            case inner_round:
+                cp = (dx1-dx2) * (dx1-dx2) + (dy1-dy2) * (dy1-dy2);
+                if(cp < len1 * len1 && cp < len2 * len2)
+                {
+                    calc_miter(vc,
+                               v0, v1, v2, dx1, dy1, dx2, dy2, 
+                               miter_join_revert, 
+                               limit, 0);
+                }
+                else
+                {
+                    if(m_inner_join == inner_jag)
+                    {
+                        add_vertex(vc, v1.x + dx1, v1.y - dy1);
+                        add_vertex(vc, v1.x,       v1.y      );
+                        add_vertex(vc, v1.x + dx2, v1.y - dy2);
+                    }
+                    else
+                    {
+                        add_vertex(vc, v1.x + dx1, v1.y - dy1);
+                        add_vertex(vc, v1.x,       v1.y      );
+                        calc_arc(vc, v1.x, v1.y, dx2, -dy2, dx1, -dy1);
+                        add_vertex(vc, v1.x,       v1.y      );
+                        add_vertex(vc, v1.x + dx2, v1.y - dy2);
+                    }
+                }
+                break;
+            }
+        }
+        else
+        {
+            // Outer join
+            //---------------
+
+            // Calculate the distance between v1 and 
+            // the central point of the bevel line segment
+            //---------------
+            double dx = (dx1 + dx2) / 2;
+            double dy = (dy1 + dy2) / 2;
+            double dbevel = sqrt(dx * dx + dy * dy);
+
+            if(m_line_join == round_join || m_line_join == bevel_join)
+            {
+                // This is an optimization that reduces the number of points 
+                // in cases of almost collinear segments. If there's no
+                // visible difference between bevel and miter joins we'd rather
+                // use miter join because it adds only one point instead of two. 
+                //
+                // Here we calculate the middle point between the bevel points 
+                // and then, the distance between v1 and this middle point. 
+                // At outer joins this distance always less than stroke width, 
+                // because it's actually the height of an isosceles triangle of
+                // v1 and its two bevel points. If the difference between this
+                // width and this value is small (no visible bevel) we can 
+                // add just one point. 
+                //
+                // The constant in the expression makes the result approximately 
+                // the same as in round joins and caps. You can safely comment 
+                // out this entire "if".
+                //-------------------
+                if(m_approx_scale * (m_width_abs - dbevel) < m_width_eps)
+                {
+                    if(calc_intersection(v0.x + dx1, v0.y - dy1,
+                                         v1.x + dx1, v1.y - dy1,
+                                         v1.x + dx2, v1.y - dy2,
+                                         v2.x + dx2, v2.y - dy2,
+                                         &dx, &dy))
+                    {
+                        add_vertex(vc, dx, dy);
+                    }
+                    else
+                    {
+                        add_vertex(vc, v1.x + dx1, v1.y - dy1);
+                    }
+                    return;
+                }
+            }
+
+            switch(m_line_join)
+            {
+            case miter_join:
+            case miter_join_revert:
+            case miter_join_round:
+                calc_miter(vc, 
+                           v0, v1, v2, dx1, dy1, dx2, dy2, 
+                           m_line_join, 
+                           m_miter_limit,
+                           dbevel);
+                break;
+
+            case round_join:
+                calc_arc(vc, v1.x, v1.y, dx1, -dy1, dx2, -dy2);
+                break;
+
+            default: // Bevel join
+                add_vertex(vc, v1.x + dx1, v1.y - dy1);
+                add_vertex(vc, v1.x + dx2, v1.y - dy2);
+                break;
+            }
+        }
+    }
+
+
+
+
+}
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_path_storage.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_path_storage.h
new file mode 100644
index 0000000000..c01b867f26
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_path_storage.h
@@ -0,0 +1,1545 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_PATH_STORAGE_INCLUDED
+#define AGG_PATH_STORAGE_INCLUDED
+
+#include <string.h>
+#include <math.h>
+#include "agg_math.h"
+#include "agg_array.h"
+#include "agg_bezier_arc.h"
+
+namespace agg
+{
+
+
+    //----------------------------------------------------vertex_block_storage
+    template<class T, unsigned BlockShift=8, unsigned BlockPool=256>
+    class vertex_block_storage
+    {
+    public:
+        // Allocation parameters
+        enum block_scale_e
+        {
+            block_shift = BlockShift,
+            block_size  = 1 << block_shift,
+            block_mask  = block_size - 1,
+            block_pool  = BlockPool
+        };
+
+        typedef T value_type;
+        typedef vertex_block_storage<T, BlockShift, BlockPool> self_type;
+
+        ~vertex_block_storage();
+        vertex_block_storage();
+        vertex_block_storage(const self_type& v);
+        const self_type& operator = (const self_type& ps);
+
+        void remove_all();
+        void free_all();
+
+        void add_vertex(double x, double y, unsigned cmd);
+        void modify_vertex(unsigned idx, double x, double y);
+        void modify_vertex(unsigned idx, double x, double y, unsigned cmd);
+        void modify_command(unsigned idx, unsigned cmd);
+        void swap_vertices(unsigned v1, unsigned v2);
+
+        unsigned last_command() const;
+        unsigned last_vertex(double* x, double* y) const;
+        unsigned prev_vertex(double* x, double* y) const;
+
+        double last_x() const;
+        double last_y() const;
+
+        unsigned total_vertices() const;
+        unsigned vertex(unsigned idx, double* x, double* y) const;
+        unsigned command(unsigned idx) const;
+
+    private:
+        void   allocate_block(unsigned nb);
+        int8u* storage_ptrs(T** xy_ptr);
+
+    private:
+        unsigned m_total_vertices;
+        unsigned m_total_blocks;
+        unsigned m_max_blocks;
+        T**      m_coord_blocks;
+        int8u**  m_cmd_blocks;
+    };
+
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S, unsigned P>
+    void vertex_block_storage<T,S,P>::free_all()
+    {
+        if(m_total_blocks)
+        {
+            T** coord_blk = m_coord_blocks + m_total_blocks - 1;
+            while(m_total_blocks--)
+            {
+                pod_allocator<T>::deallocate(
+                    *coord_blk,
+                    block_size * 2 + 
+                    block_size / (sizeof(T) / sizeof(unsigned char)));
+                --coord_blk;
+            }
+            pod_allocator<T*>::deallocate(m_coord_blocks, m_max_blocks * 2);
+            m_total_blocks   = 0;
+            m_max_blocks     = 0;
+            m_coord_blocks   = 0;
+            m_cmd_blocks     = 0;
+            m_total_vertices = 0;
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S, unsigned P>
+    vertex_block_storage<T,S,P>::~vertex_block_storage()
+    {
+        free_all();
+    }
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S, unsigned P>
+    vertex_block_storage<T,S,P>::vertex_block_storage() :
+        m_total_vertices(0),
+        m_total_blocks(0),
+        m_max_blocks(0),
+        m_coord_blocks(0),
+        m_cmd_blocks(0)
+    {
+    }
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S, unsigned P>
+    vertex_block_storage<T,S,P>::vertex_block_storage(const vertex_block_storage<T,S,P>& v) :
+        m_total_vertices(0),
+        m_total_blocks(0),
+        m_max_blocks(0),
+        m_coord_blocks(0),
+        m_cmd_blocks(0)
+    {
+        *this = v;
+    }
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S, unsigned P>
+    const vertex_block_storage<T,S,P>& 
+    vertex_block_storage<T,S,P>::operator = (const vertex_block_storage<T,S,P>& v)
+    {
+        remove_all();
+        unsigned i;
+        for(i = 0; i < v.total_vertices(); i++)
+        {
+            double x, y;
+            unsigned cmd = v.vertex(i, &x, &y);
+            add_vertex(x, y, cmd);
+        }
+	    return *this;
+    }
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S, unsigned P>
+    inline void vertex_block_storage<T,S,P>::remove_all()
+    {
+        m_total_vertices = 0;
+    }
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S, unsigned P>
+    inline void vertex_block_storage<T,S,P>::add_vertex(double x, double y, 
+                                                        unsigned cmd)
+    {
+        T* coord_ptr = 0;
+        *storage_ptrs(&coord_ptr) = (int8u)cmd;
+        coord_ptr[0] = T(x);
+        coord_ptr[1] = T(y);
+        m_total_vertices++;
+    }
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S, unsigned P>
+    inline void vertex_block_storage<T,S,P>::modify_vertex(unsigned idx, 
+                                                           double x, double y)
+    {
+        T* pv = m_coord_blocks[idx >> block_shift] + ((idx & block_mask) << 1);
+        pv[0] = T(x);
+        pv[1] = T(y);
+    }
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S, unsigned P>
+    inline void vertex_block_storage<T,S,P>::modify_vertex(unsigned idx, 
+                                                           double x, double y, 
+                                                           unsigned cmd)
+    {
+        unsigned block = idx >> block_shift;
+        unsigned offset = idx & block_mask;
+        T* pv = m_coord_blocks[block] + (offset << 1);
+        pv[0] = T(x);
+        pv[1] = T(y);
+        m_cmd_blocks[block][offset] = (int8u)cmd;
+    }
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S, unsigned P>
+    inline void vertex_block_storage<T,S,P>::modify_command(unsigned idx, 
+                                                            unsigned cmd)
+    {
+        m_cmd_blocks[idx >> block_shift][idx & block_mask] = (int8u)cmd;
+    }
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S, unsigned P>
+    inline void vertex_block_storage<T,S,P>::swap_vertices(unsigned v1, unsigned v2)
+    {
+        unsigned b1 = v1 >> block_shift;
+        unsigned b2 = v2 >> block_shift;
+        unsigned o1 = v1 & block_mask;
+        unsigned o2 = v2 & block_mask;
+        T* pv1 = m_coord_blocks[b1] + (o1 << 1);
+        T* pv2 = m_coord_blocks[b2] + (o2 << 1);
+        T  val;
+        val = pv1[0]; pv1[0] = pv2[0]; pv2[0] = val;
+        val = pv1[1]; pv1[1] = pv2[1]; pv2[1] = val;
+        int8u cmd = m_cmd_blocks[b1][o1];
+        m_cmd_blocks[b1][o1] = m_cmd_blocks[b2][o2];
+        m_cmd_blocks[b2][o2] = cmd;
+    }
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S, unsigned P>
+    inline unsigned vertex_block_storage<T,S,P>::last_command() const
+    {
+        if(m_total_vertices) return command(m_total_vertices - 1);
+        return path_cmd_stop;
+    }
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S, unsigned P>
+    inline unsigned vertex_block_storage<T,S,P>::last_vertex(double* x, double* y) const
+    {
+        if(m_total_vertices) return vertex(m_total_vertices - 1, x, y);
+        return path_cmd_stop;
+    }
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S, unsigned P>
+    inline unsigned vertex_block_storage<T,S,P>::prev_vertex(double* x, double* y) const
+    {
+        if(m_total_vertices > 1) return vertex(m_total_vertices - 2, x, y);
+        return path_cmd_stop;
+    }
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S, unsigned P>
+    inline double vertex_block_storage<T,S,P>::last_x() const
+    {
+        if(m_total_vertices)
+        {
+            unsigned idx = m_total_vertices - 1;
+            return m_coord_blocks[idx >> block_shift][(idx & block_mask) << 1];
+        }
+        return 0.0;
+    }
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S, unsigned P>
+    inline double vertex_block_storage<T,S,P>::last_y() const
+    {
+        if(m_total_vertices)
+        {
+            unsigned idx = m_total_vertices - 1;
+            return m_coord_blocks[idx >> block_shift][((idx & block_mask) << 1) + 1];
+        }
+        return 0.0;
+    }
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S, unsigned P>
+    inline unsigned vertex_block_storage<T,S,P>::total_vertices() const
+    {
+        return m_total_vertices;
+    }
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S, unsigned P>
+    inline unsigned vertex_block_storage<T,S,P>::vertex(unsigned idx, 
+                                                        double* x, double* y) const
+    {
+        unsigned nb = idx >> block_shift;
+        const T* pv = m_coord_blocks[nb] + ((idx & block_mask) << 1);
+        *x = pv[0];
+        *y = pv[1];
+        return m_cmd_blocks[nb][idx & block_mask];
+    }
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S, unsigned P>
+    inline unsigned vertex_block_storage<T,S,P>::command(unsigned idx) const
+    {
+        return m_cmd_blocks[idx >> block_shift][idx & block_mask];
+    }
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S, unsigned P>
+    void vertex_block_storage<T,S,P>::allocate_block(unsigned nb)
+    {
+        if(nb >= m_max_blocks) 
+        {
+            T** new_coords = 
+                pod_allocator<T*>::allocate((m_max_blocks + block_pool) * 2);
+
+            unsigned char** new_cmds = 
+                (unsigned char**)(new_coords + m_max_blocks + block_pool);
+
+            if(m_coord_blocks)
+            {
+                memcpy(new_coords, 
+                       m_coord_blocks, 
+                       m_max_blocks * sizeof(T*));
+
+                memcpy(new_cmds, 
+                       m_cmd_blocks, 
+                       m_max_blocks * sizeof(unsigned char*));
+
+                pod_allocator<T*>::deallocate(m_coord_blocks, m_max_blocks * 2);
+            }
+            m_coord_blocks = new_coords;
+            m_cmd_blocks   = new_cmds;
+            m_max_blocks  += block_pool;
+        }
+        m_coord_blocks[nb] = 
+            pod_allocator<T>::allocate(block_size * 2 + 
+                   block_size / (sizeof(T) / sizeof(unsigned char)));
+
+        m_cmd_blocks[nb]  = 
+            (unsigned char*)(m_coord_blocks[nb] + block_size * 2);
+
+        m_total_blocks++;
+    }
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S, unsigned P>
+    int8u* vertex_block_storage<T,S,P>::storage_ptrs(T** xy_ptr)
+    {
+        unsigned nb = m_total_vertices >> block_shift;
+        if(nb >= m_total_blocks)
+        {
+            allocate_block(nb);
+        }
+        *xy_ptr = m_coord_blocks[nb] + ((m_total_vertices & block_mask) << 1);
+        return m_cmd_blocks[nb] + (m_total_vertices & block_mask);
+    }
+
+
+
+
+    //-----------------------------------------------------poly_plain_adaptor
+    template<class T> class poly_plain_adaptor
+    {
+    public:
+        typedef T value_type;
+
+        poly_plain_adaptor() : 
+            m_data(0), 
+            m_ptr(0),
+            m_end(0),
+            m_closed(false),
+            m_stop(false)
+        {}
+
+        poly_plain_adaptor(const T* data, unsigned num_points, bool closed) :
+            m_data(data), 
+            m_ptr(data),
+            m_end(data + num_points * 2),
+            m_closed(closed),
+            m_stop(false)
+        {}
+
+        void init(const T* data, unsigned num_points, bool closed)
+        {
+            m_data = data;
+            m_ptr = data;
+            m_end = data + num_points * 2;
+            m_closed = closed;
+            m_stop = false;
+        }
+
+        void rewind(unsigned)
+        {
+            m_ptr = m_data;
+            m_stop = false;
+        }
+
+        unsigned vertex(double* x, double* y)
+        {
+            if(m_ptr < m_end)
+            {
+                bool first = m_ptr == m_data;
+                *x = *m_ptr++;
+                *y = *m_ptr++;
+                return first ? path_cmd_move_to : path_cmd_line_to;
+            }
+            *x = *y = 0.0;
+            if(m_closed && !m_stop)
+            {
+                m_stop = true;
+                return path_cmd_end_poly | path_flags_close;
+            }
+            return path_cmd_stop;
+        }
+
+    private:
+        const T* m_data;
+        const T* m_ptr;
+        const T* m_end;
+        bool     m_closed;
+        bool     m_stop;
+    };
+
+
+
+
+
+    //-------------------------------------------------poly_container_adaptor
+    template<class Container> class poly_container_adaptor
+    {
+    public:
+        typedef typename Container::value_type vertex_type;
+
+        poly_container_adaptor() : 
+            m_container(0), 
+            m_index(0),
+            m_closed(false),
+            m_stop(false)
+        {}
+
+        poly_container_adaptor(const Container& data, bool closed) :
+            m_container(&data), 
+            m_index(0),
+            m_closed(closed),
+            m_stop(false)
+        {}
+
+        void init(const Container& data, bool closed)
+        {
+            m_container = &data;
+            m_index = 0;
+            m_closed = closed;
+            m_stop = false;
+        }
+
+        void rewind(unsigned)
+        {
+            m_index = 0;
+            m_stop = false;
+        }
+
+        unsigned vertex(double* x, double* y)
+        {
+            if(m_index < m_container->size())
+            {
+                bool first = m_index == 0;
+                const vertex_type& v = (*m_container)[m_index++];
+                *x = v.x;
+                *y = v.y;
+                return first ? path_cmd_move_to : path_cmd_line_to;
+            }
+            *x = *y = 0.0;
+            if(m_closed && !m_stop)
+            {
+                m_stop = true;
+                return path_cmd_end_poly | path_flags_close;
+            }
+            return path_cmd_stop;
+        }
+
+    private:
+        const Container* m_container;
+        unsigned m_index;
+        bool     m_closed;
+        bool     m_stop;
+    };
+
+
+
+    //-----------------------------------------poly_container_reverse_adaptor
+    template<class Container> class poly_container_reverse_adaptor
+    {
+    public:
+        typedef typename Container::value_type vertex_type;
+
+        poly_container_reverse_adaptor() : 
+            m_container(0), 
+            m_index(-1),
+            m_closed(false),
+            m_stop(false)
+        {}
+
+        poly_container_reverse_adaptor(Container& data, bool closed) :
+            m_container(&data), 
+            m_index(-1),
+            m_closed(closed),
+            m_stop(false)
+        {}
+
+        void init(Container& data, bool closed)
+        {
+            m_container = &data;
+            m_index = m_container->size() - 1;
+            m_closed = closed;
+            m_stop = false;
+        }
+
+        void rewind(unsigned)
+        {
+            m_index = m_container->size() - 1;
+            m_stop = false;
+        }
+
+        unsigned vertex(double* x, double* y)
+        {
+            if(m_index >= 0)
+            {
+                bool first = m_index == int(m_container->size() - 1);
+                const vertex_type& v = (*m_container)[m_index--];
+                *x = v.x;
+                *y = v.y;
+                return first ? path_cmd_move_to : path_cmd_line_to;
+            }
+            *x = *y = 0.0;
+            if(m_closed && !m_stop)
+            {
+                m_stop = true;
+                return path_cmd_end_poly | path_flags_close;
+            }
+            return path_cmd_stop;
+        }
+
+    private:
+        Container* m_container;
+        int  m_index;
+        bool m_closed;
+        bool m_stop;
+    };
+
+
+
+
+
+    //--------------------------------------------------------line_adaptor
+    class line_adaptor
+    {
+    public:
+        typedef double value_type;
+
+        line_adaptor() : m_line(m_coord, 2, false) {}
+        line_adaptor(double x1, double y1, double x2, double y2) :
+            m_line(m_coord, 2, false)
+        {
+            m_coord[0] = x1;
+            m_coord[1] = y1;
+            m_coord[2] = x2;
+            m_coord[3] = y2;
+        }
+        
+        void init(double x1, double y1, double x2, double y2)
+        {
+            m_coord[0] = x1;
+            m_coord[1] = y1;
+            m_coord[2] = x2;
+            m_coord[3] = y2;
+            m_line.rewind(0);
+        }
+
+        void rewind(unsigned)
+        {
+            m_line.rewind(0);
+        }
+
+        unsigned vertex(double* x, double* y)
+        {
+            return m_line.vertex(x, y);
+        }
+
+    private:
+        double                     m_coord[4];
+        poly_plain_adaptor<double> m_line;
+    };
+
+
+
+
+
+
+
+
+
+
+
+
+
+    //---------------------------------------------------------------path_base
+    // A container to store vertices with their flags. 
+    // A path consists of a number of contours separated with "move_to" 
+    // commands. The path storage can keep and maintain more than one
+    // path. 
+    // To navigate to the beginning of a particular path, use rewind(path_id);
+    // Where path_id is what start_new_path() returns. So, when you call
+    // start_new_path() you need to store its return value somewhere else
+    // to navigate to the path afterwards.
+    //
+    // See also: vertex_source concept
+    //------------------------------------------------------------------------
+    template<class VertexContainer> class path_base
+    {
+    public:
+        typedef VertexContainer            container_type;
+        typedef path_base<VertexContainer> self_type;
+
+        //--------------------------------------------------------------------
+        path_base() : m_vertices(), m_iterator(0) {}
+        void remove_all() { m_vertices.remove_all(); m_iterator = 0; }
+        void free_all()   { m_vertices.free_all();   m_iterator = 0; }
+
+        // Make path functions
+        //--------------------------------------------------------------------
+        unsigned start_new_path();
+
+        void move_to(double x, double y);
+        void move_rel(double dx, double dy);
+
+        void line_to(double x, double y);
+        void line_rel(double dx, double dy);
+
+        void hline_to(double x);
+        void hline_rel(double dx);
+
+        void vline_to(double y);
+        void vline_rel(double dy);
+
+        void arc_to(double rx, double ry,
+                    double angle,
+                    bool large_arc_flag,
+                    bool sweep_flag,
+                    double x, double y);
+
+        void arc_rel(double rx, double ry,
+                     double angle,
+                     bool large_arc_flag,
+                     bool sweep_flag,
+                     double dx, double dy);
+
+        void curve3(double x_ctrl, double y_ctrl, 
+                    double x_to,   double y_to);
+
+        void curve3_rel(double dx_ctrl, double dy_ctrl, 
+                        double dx_to,   double dy_to);
+
+        void curve3(double x_to, double y_to);
+
+        void curve3_rel(double dx_to, double dy_to);
+
+        void curve4(double x_ctrl1, double y_ctrl1, 
+                    double x_ctrl2, double y_ctrl2, 
+                    double x_to,    double y_to);
+
+        void curve4_rel(double dx_ctrl1, double dy_ctrl1, 
+                        double dx_ctrl2, double dy_ctrl2, 
+                        double dx_to,    double dy_to);
+
+        void curve4(double x_ctrl2, double y_ctrl2, 
+                    double x_to,    double y_to);
+
+        void curve4_rel(double x_ctrl2, double y_ctrl2, 
+                        double x_to,    double y_to);
+
+
+        void end_poly(unsigned flags = path_flags_close);
+        void close_polygon(unsigned flags = path_flags_none);
+
+        // Accessors
+        //--------------------------------------------------------------------
+        const container_type& vertices() const { return m_vertices; } 
+              container_type& vertices()       { return m_vertices; } 
+
+        unsigned total_vertices() const;
+
+        void rel_to_abs(double* x, double* y) const;
+
+        unsigned last_vertex(double* x, double* y) const;
+        unsigned prev_vertex(double* x, double* y) const;
+
+        double last_x() const;
+        double last_y() const;
+
+        unsigned vertex(unsigned idx, double* x, double* y) const;
+        unsigned command(unsigned idx) const;
+
+        void modify_vertex(unsigned idx, double x, double y);
+        void modify_vertex(unsigned idx, double x, double y, unsigned cmd);
+        void modify_command(unsigned idx, unsigned cmd);
+
+        // VertexSource interface
+        //--------------------------------------------------------------------
+        void     rewind(unsigned path_id);
+        unsigned vertex(double* x, double* y);
+
+        // Arrange the orientation of a polygon, all polygons in a path, 
+        // or in all paths. After calling arrange_orientations() or 
+        // arrange_orientations_all_paths(), all the polygons will have 
+        // the same orientation, i.e. path_flags_cw or path_flags_ccw
+        //--------------------------------------------------------------------
+        unsigned arrange_polygon_orientation(unsigned start, path_flags_e orientation);
+        unsigned arrange_orientations(unsigned path_id, path_flags_e orientation);
+        void     arrange_orientations_all_paths(path_flags_e orientation);
+        void     invert_polygon(unsigned start);
+
+        // Flip all vertices horizontally or vertically, 
+        // between x1 and x2, or between y1 and y2 respectively
+        //--------------------------------------------------------------------
+        void flip_x(double x1, double x2);
+        void flip_y(double y1, double y2);
+
+        // Concatenate path. The path is added as is.
+        //--------------------------------------------------------------------
+        template<class VertexSource> 
+        void concat_path(VertexSource& vs, unsigned path_id = 0)
+        {
+            double x, y;
+            unsigned cmd;
+            vs.rewind(path_id);
+            while(!is_stop(cmd = vs.vertex(&x, &y)))
+            {
+                m_vertices.add_vertex(x, y, cmd);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        // Join path. The path is joined with the existing one, that is, 
+        // it behaves as if the pen of a plotter was always down (drawing)
+        template<class VertexSource> 
+        void join_path(VertexSource& vs, unsigned path_id = 0)
+        {
+            double x, y;
+            unsigned cmd;
+            vs.rewind(path_id);
+            cmd = vs.vertex(&x, &y);
+            if(!is_stop(cmd))
+            {
+                if(is_vertex(cmd))
+                {
+                    double x0, y0;
+                    unsigned cmd0 = last_vertex(&x0, &y0);
+                    if(is_vertex(cmd0))
+                    {
+                        if(calc_distance(x, y, x0, y0) > vertex_dist_epsilon)
+                        {
+                            if(is_move_to(cmd)) cmd = path_cmd_line_to;
+                            m_vertices.add_vertex(x, y, cmd);
+                        }
+                    }
+                    else
+                    {
+                        if(is_stop(cmd0))
+                        {
+                            cmd = path_cmd_move_to;
+                        }
+                        else
+                        {
+                            if(is_move_to(cmd)) cmd = path_cmd_line_to;
+                        }
+                        m_vertices.add_vertex(x, y, cmd);
+                    }
+                }
+                while(!is_stop(cmd = vs.vertex(&x, &y)))
+                {
+                    m_vertices.add_vertex(x, y, is_move_to(cmd) ? 
+                                                    unsigned(path_cmd_line_to) : 
+                                                    cmd);
+                }
+            }
+        }
+
+        // Concatenate polygon/polyline. 
+        //--------------------------------------------------------------------
+        template<class T> void concat_poly(const T* data, 
+                                           unsigned num_points,
+                                           bool closed)
+        {
+            poly_plain_adaptor<T> poly(data, num_points, closed);
+            concat_path(poly);
+        }
+
+        // Join polygon/polyline continuously.
+        //--------------------------------------------------------------------
+        template<class T> void join_poly(const T* data, 
+                                         unsigned num_points,
+                                         bool closed)
+        {
+            poly_plain_adaptor<T> poly(data, num_points, closed);
+            join_path(poly);
+        }
+
+        //--------------------------------------------------------------------
+        void translate(double dx, double dy, unsigned path_id=0);
+        void translate_all_paths(double dx, double dy);
+
+        //--------------------------------------------------------------------
+        template<class Trans>
+        void transform(const Trans& trans, unsigned path_id=0)
+        {
+            unsigned num_ver = m_vertices.total_vertices();
+            for(; path_id < num_ver; path_id++)
+            {
+                double x, y;
+                unsigned cmd = m_vertices.vertex(path_id, &x, &y);
+                if(is_stop(cmd)) break;
+                if(is_vertex(cmd))
+                {
+                    trans.transform(&x, &y);
+                    m_vertices.modify_vertex(path_id, x, y);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        template<class Trans>
+        void transform_all_paths(const Trans& trans)
+        {
+            unsigned idx;
+            unsigned num_ver = m_vertices.total_vertices();
+            for(idx = 0; idx < num_ver; idx++)
+            {
+                double x, y;
+                if(is_vertex(m_vertices.vertex(idx, &x, &y)))
+                {
+                    trans.transform(&x, &y);
+                    m_vertices.modify_vertex(idx, x, y);
+                }
+            }
+        }
+
+
+
+    private:
+        unsigned perceive_polygon_orientation(unsigned start, unsigned end);
+        void     invert_polygon(unsigned start, unsigned end);
+
+        VertexContainer m_vertices;
+        unsigned        m_iterator;
+    };
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    unsigned path_base<VC>::start_new_path()
+    {
+        if(!is_stop(m_vertices.last_command()))
+        {
+            m_vertices.add_vertex(0.0, 0.0, path_cmd_stop);
+        }
+        return m_vertices.total_vertices();
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    inline void path_base<VC>::rel_to_abs(double* x, double* y) const
+    {
+        if(m_vertices.total_vertices())
+        {
+            double x2;
+            double y2;
+            if(is_vertex(m_vertices.last_vertex(&x2, &y2)))
+            {
+                *x += x2;
+                *y += y2;
+            }
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    inline void path_base<VC>::move_to(double x, double y)
+    {
+        m_vertices.add_vertex(x, y, path_cmd_move_to);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    inline void path_base<VC>::move_rel(double dx, double dy)
+    {
+        rel_to_abs(&dx, &dy);
+        m_vertices.add_vertex(dx, dy, path_cmd_move_to);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    inline void path_base<VC>::line_to(double x, double y)
+    {
+        m_vertices.add_vertex(x, y, path_cmd_line_to);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    inline void path_base<VC>::line_rel(double dx, double dy)
+    {
+        rel_to_abs(&dx, &dy);
+        m_vertices.add_vertex(dx, dy, path_cmd_line_to);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    inline void path_base<VC>::hline_to(double x)
+    {
+        m_vertices.add_vertex(x, last_y(), path_cmd_line_to);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    inline void path_base<VC>::hline_rel(double dx)
+    {
+        double dy = 0;
+        rel_to_abs(&dx, &dy);
+        m_vertices.add_vertex(dx, dy, path_cmd_line_to);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    inline void path_base<VC>::vline_to(double y)
+    {
+        m_vertices.add_vertex(last_x(), y, path_cmd_line_to);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    inline void path_base<VC>::vline_rel(double dy)
+    {
+        double dx = 0;
+        rel_to_abs(&dx, &dy);
+        m_vertices.add_vertex(dx, dy, path_cmd_line_to);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    void path_base<VC>::arc_to(double rx, double ry,
+                               double angle,
+                               bool large_arc_flag,
+                               bool sweep_flag,
+                               double x, double y)
+    {
+        if(m_vertices.total_vertices() && is_vertex(m_vertices.last_command()))
+        {
+            const double epsilon = 1e-30;
+            double x0 = 0.0;
+            double y0 = 0.0;
+            m_vertices.last_vertex(&x0, &y0);
+
+            rx = fabs(rx);
+            ry = fabs(ry);
+
+            // Ensure radii are valid
+            //-------------------------
+            if(rx < epsilon || ry < epsilon) 
+            {
+                line_to(x, y);
+                return;
+            }
+
+            if(calc_distance(x0, y0, x, y) < epsilon)
+            {
+                // If the endpoints (x, y) and (x0, y0) are identical, then this
+                // is equivalent to omitting the elliptical arc segment entirely.
+                return;
+            }
+            bezier_arc_svg a(x0, y0, rx, ry, angle, large_arc_flag, sweep_flag, x, y);
+            if(a.radii_ok())
+            {
+                join_path(a);
+            }
+            else
+            {
+                line_to(x, y);
+            }
+        }
+        else
+        {
+            move_to(x, y);
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    void path_base<VC>::arc_rel(double rx, double ry,
+                                double angle,
+                                bool large_arc_flag,
+                                bool sweep_flag,
+                                double dx, double dy)
+    {
+        rel_to_abs(&dx, &dy);
+        arc_to(rx, ry, angle, large_arc_flag, sweep_flag, dx, dy);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    void path_base<VC>::curve3(double x_ctrl, double y_ctrl, 
+                               double x_to,   double y_to)
+    {
+        m_vertices.add_vertex(x_ctrl, y_ctrl, path_cmd_curve3);
+        m_vertices.add_vertex(x_to,   y_to,   path_cmd_curve3);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    void path_base<VC>::curve3_rel(double dx_ctrl, double dy_ctrl, 
+                                   double dx_to,   double dy_to)
+    {
+        rel_to_abs(&dx_ctrl, &dy_ctrl);
+        rel_to_abs(&dx_to,   &dy_to);
+        m_vertices.add_vertex(dx_ctrl, dy_ctrl, path_cmd_curve3);
+        m_vertices.add_vertex(dx_to,   dy_to,   path_cmd_curve3);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    void path_base<VC>::curve3(double x_to, double y_to)
+    {
+        double x0;
+        double y0;
+        if(is_vertex(m_vertices.last_vertex(&x0, &y0)))
+        {
+            double x_ctrl;
+            double y_ctrl; 
+            unsigned cmd = m_vertices.prev_vertex(&x_ctrl, &y_ctrl);
+            if(is_curve(cmd))
+            {
+                x_ctrl = x0 + x0 - x_ctrl;
+                y_ctrl = y0 + y0 - y_ctrl;
+            }
+            else
+            {
+                x_ctrl = x0;
+                y_ctrl = y0;
+            }
+            curve3(x_ctrl, y_ctrl, x_to, y_to);
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    void path_base<VC>::curve3_rel(double dx_to, double dy_to)
+    {
+        rel_to_abs(&dx_to, &dy_to);
+        curve3(dx_to, dy_to);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    void path_base<VC>::curve4(double x_ctrl1, double y_ctrl1, 
+                               double x_ctrl2, double y_ctrl2, 
+                               double x_to,    double y_to)
+    {
+        m_vertices.add_vertex(x_ctrl1, y_ctrl1, path_cmd_curve4);
+        m_vertices.add_vertex(x_ctrl2, y_ctrl2, path_cmd_curve4);
+        m_vertices.add_vertex(x_to,    y_to,    path_cmd_curve4);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    void path_base<VC>::curve4_rel(double dx_ctrl1, double dy_ctrl1, 
+                                   double dx_ctrl2, double dy_ctrl2, 
+                                   double dx_to,    double dy_to)
+    {
+        rel_to_abs(&dx_ctrl1, &dy_ctrl1);
+        rel_to_abs(&dx_ctrl2, &dy_ctrl2);
+        rel_to_abs(&dx_to,    &dy_to);
+        m_vertices.add_vertex(dx_ctrl1, dy_ctrl1, path_cmd_curve4);
+        m_vertices.add_vertex(dx_ctrl2, dy_ctrl2, path_cmd_curve4);
+        m_vertices.add_vertex(dx_to,    dy_to,    path_cmd_curve4);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    void path_base<VC>::curve4(double x_ctrl2, double y_ctrl2, 
+                               double x_to,    double y_to)
+    {
+        double x0;
+        double y0;
+        if(is_vertex(last_vertex(&x0, &y0)))
+        {
+            double x_ctrl1;
+            double y_ctrl1; 
+            unsigned cmd = prev_vertex(&x_ctrl1, &y_ctrl1);
+            if(is_curve(cmd))
+            {
+                x_ctrl1 = x0 + x0 - x_ctrl1;
+                y_ctrl1 = y0 + y0 - y_ctrl1;
+            }
+            else
+            {
+                x_ctrl1 = x0;
+                y_ctrl1 = y0;
+            }
+            curve4(x_ctrl1, y_ctrl1, x_ctrl2, y_ctrl2, x_to, y_to);
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    void path_base<VC>::curve4_rel(double dx_ctrl2, double dy_ctrl2, 
+                                   double dx_to,    double dy_to)
+    {
+        rel_to_abs(&dx_ctrl2, &dy_ctrl2);
+        rel_to_abs(&dx_to,    &dy_to);
+        curve4(dx_ctrl2, dy_ctrl2, dx_to, dy_to);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    inline void path_base<VC>::end_poly(unsigned flags)
+    {
+        if(is_vertex(m_vertices.last_command()))
+        {
+            m_vertices.add_vertex(0.0, 0.0, path_cmd_end_poly | flags);
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    inline void path_base<VC>::close_polygon(unsigned flags)
+    {
+        end_poly(path_flags_close | flags);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    inline unsigned path_base<VC>::total_vertices() const
+    {
+        return m_vertices.total_vertices();
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    inline unsigned path_base<VC>::last_vertex(double* x, double* y) const
+    {
+        return m_vertices.last_vertex(x, y);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    inline unsigned path_base<VC>::prev_vertex(double* x, double* y) const
+    {
+        return m_vertices.prev_vertex(x, y);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    inline double path_base<VC>::last_x() const
+    {
+        return m_vertices.last_x();
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    inline double path_base<VC>::last_y() const
+    {
+        return m_vertices.last_y();
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    inline unsigned path_base<VC>::vertex(unsigned idx, double* x, double* y) const
+    {
+        return m_vertices.vertex(idx, x, y);
+    }
+ 
+    //------------------------------------------------------------------------
+    template<class VC> 
+    inline unsigned path_base<VC>::command(unsigned idx) const
+    {
+        return m_vertices.command(idx);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    void path_base<VC>::modify_vertex(unsigned idx, double x, double y)
+    {
+        m_vertices.modify_vertex(idx, x, y);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    void path_base<VC>::modify_vertex(unsigned idx, double x, double y, unsigned cmd)
+    {
+        m_vertices.modify_vertex(idx, x, y, cmd);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    void path_base<VC>::modify_command(unsigned idx, unsigned cmd)
+    {
+        m_vertices.modify_command(idx, cmd);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    inline void path_base<VC>::rewind(unsigned path_id)
+    {
+        m_iterator = path_id;
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    inline unsigned path_base<VC>::vertex(double* x, double* y)
+    {
+        if(m_iterator >= m_vertices.total_vertices()) return path_cmd_stop;
+        return m_vertices.vertex(m_iterator++, x, y);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    unsigned path_base<VC>::perceive_polygon_orientation(unsigned start,
+                                                         unsigned end)
+    {
+        // Calculate signed area (double area to be exact)
+        //---------------------
+        unsigned np = end - start;
+        double area = 0.0;
+        unsigned i;
+        for(i = 0; i < np; i++)
+        {
+            double x1, y1, x2, y2;
+            m_vertices.vertex(start + i,            &x1, &y1);
+            m_vertices.vertex(start + (i + 1) % np, &x2, &y2);
+            area += x1 * y2 - y1 * x2;
+        }
+        return (area < 0.0) ? path_flags_cw : path_flags_ccw;
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    void path_base<VC>::invert_polygon(unsigned start, unsigned end)
+    {
+        unsigned i;
+        unsigned tmp_cmd = m_vertices.command(start);
+        
+        --end; // Make "end" inclusive
+
+        // Shift all commands to one position
+        for(i = start; i < end; i++)
+        {
+            m_vertices.modify_command(i, m_vertices.command(i + 1));
+        }
+
+        // Assign starting command to the ending command
+        m_vertices.modify_command(end, tmp_cmd);
+
+        // Reverse the polygon
+        while(end > start)
+        {
+            m_vertices.swap_vertices(start++, end--);
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    void path_base<VC>::invert_polygon(unsigned start)
+    {
+        // Skip all non-vertices at the beginning
+        while(start < m_vertices.total_vertices() && 
+              !is_vertex(m_vertices.command(start))) ++start;
+
+        // Skip all insignificant move_to
+        while(start+1 < m_vertices.total_vertices() && 
+              is_move_to(m_vertices.command(start)) &&
+              is_move_to(m_vertices.command(start+1))) ++start;
+
+        // Find the last vertex
+        unsigned end = start + 1;
+        while(end < m_vertices.total_vertices() && 
+              !is_next_poly(m_vertices.command(end))) ++end;
+
+        invert_polygon(start, end);
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    unsigned path_base<VC>::arrange_polygon_orientation(unsigned start, 
+                                                        path_flags_e orientation)
+    {
+        if(orientation == path_flags_none) return start;
+        
+        // Skip all non-vertices at the beginning
+        while(start < m_vertices.total_vertices() && 
+              !is_vertex(m_vertices.command(start))) ++start;
+
+        // Skip all insignificant move_to
+        while(start+1 < m_vertices.total_vertices() && 
+              is_move_to(m_vertices.command(start)) &&
+              is_move_to(m_vertices.command(start+1))) ++start;
+
+        // Find the last vertex
+        unsigned end = start + 1;
+        while(end < m_vertices.total_vertices() && 
+              !is_next_poly(m_vertices.command(end))) ++end;
+
+        if(end - start > 2)
+        {
+            if(perceive_polygon_orientation(start, end) != unsigned(orientation))
+            {
+                // Invert polygon, set orientation flag, and skip all end_poly
+                invert_polygon(start, end);
+                unsigned cmd;
+                while(end < m_vertices.total_vertices() && 
+                      is_end_poly(cmd = m_vertices.command(end)))
+                {
+                    m_vertices.modify_command(end++, set_orientation(cmd, orientation));
+                }
+            }
+        }
+        return end;
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    unsigned path_base<VC>::arrange_orientations(unsigned start, 
+                                                 path_flags_e orientation)
+    {
+        if(orientation != path_flags_none)
+        {
+            while(start < m_vertices.total_vertices())
+            {
+                start = arrange_polygon_orientation(start, orientation);
+                if(is_stop(m_vertices.command(start)))
+                {
+                    ++start;
+                    break;
+                }
+            }
+        }
+        return start;
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    void path_base<VC>::arrange_orientations_all_paths(path_flags_e orientation)
+    {
+        if(orientation != path_flags_none)
+        {
+            unsigned start = 0;
+            while(start < m_vertices.total_vertices())
+            {
+                start = arrange_orientations(start, orientation);
+            }
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    void path_base<VC>::flip_x(double x1, double x2)
+    {
+        unsigned i;
+        double x, y;
+        for(i = 0; i < m_vertices.total_vertices(); i++)
+        {
+            unsigned cmd = m_vertices.vertex(i, &x, &y);
+            if(is_vertex(cmd))
+            {
+                m_vertices.modify_vertex(i, x2 - x + x1, y);
+            }
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    void path_base<VC>::flip_y(double y1, double y2)
+    {
+        unsigned i;
+        double x, y;
+        for(i = 0; i < m_vertices.total_vertices(); i++)
+        {
+            unsigned cmd = m_vertices.vertex(i, &x, &y);
+            if(is_vertex(cmd))
+            {
+                m_vertices.modify_vertex(i, x, y2 - y + y1);
+            }
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    void path_base<VC>::translate(double dx, double dy, unsigned path_id)
+    {
+        unsigned num_ver = m_vertices.total_vertices();
+        for(; path_id < num_ver; path_id++)
+        {
+            double x, y;
+            unsigned cmd = m_vertices.vertex(path_id, &x, &y);
+            if(is_stop(cmd)) break;
+            if(is_vertex(cmd))
+            {
+                x += dx;
+                y += dy;
+                m_vertices.modify_vertex(path_id, x, y);
+            }
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class VC> 
+    void path_base<VC>::translate_all_paths(double dx, double dy)
+    {
+        unsigned idx;
+        unsigned num_ver = m_vertices.total_vertices();
+        for(idx = 0; idx < num_ver; idx++)
+        {
+            double x, y;
+            if(is_vertex(m_vertices.vertex(idx, &x, &y)))
+            {
+                x += dx;
+                y += dy;
+                m_vertices.modify_vertex(idx, x, y);
+            }
+        }
+    }
+
+    //-----------------------------------------------------vertex_stl_storage
+    template<class Container> class vertex_stl_storage
+    {
+    public:
+        typedef typename Container::value_type vertex_type;
+        typedef typename vertex_type::value_type value_type;
+
+        void remove_all() { m_vertices.clear(); }
+        void free_all()   { m_vertices.clear(); }
+
+        void add_vertex(double x, double y, unsigned cmd)
+        {
+            m_vertices.push_back(vertex_type(value_type(x), 
+                                             value_type(y), 
+                                             int8u(cmd)));
+        }
+
+        void modify_vertex(unsigned idx, double x, double y)
+        {
+            vertex_type& v = m_vertices[idx];
+            v.x = value_type(x);
+            v.y = value_type(y);
+        }
+
+        void modify_vertex(unsigned idx, double x, double y, unsigned cmd)
+        {
+            vertex_type& v = m_vertices[idx];
+            v.x   = value_type(x);
+            v.y   = value_type(y);
+            v.cmd = int8u(cmd);
+        }
+
+        void modify_command(unsigned idx, unsigned cmd)
+        {
+            m_vertices[idx].cmd = int8u(cmd);
+        }
+
+        void swap_vertices(unsigned v1, unsigned v2)
+        {
+            vertex_type t = m_vertices[v1];
+            m_vertices[v1] = m_vertices[v2];
+            m_vertices[v2] = t;
+        }
+
+        unsigned last_command() const
+        {
+            return m_vertices.size() ? 
+                m_vertices[m_vertices.size() - 1].cmd : 
+                path_cmd_stop;
+        }
+
+        unsigned last_vertex(double* x, double* y) const
+        {
+            if(m_vertices.size() == 0)
+            {
+                *x = *y = 0.0;
+                return path_cmd_stop;
+            }
+            return vertex(m_vertices.size() - 1, x, y);
+        }
+
+        unsigned prev_vertex(double* x, double* y) const
+        {
+            if(m_vertices.size() < 2)
+            {
+                *x = *y = 0.0;
+                return path_cmd_stop;
+            }
+            return vertex(m_vertices.size() - 2, x, y);
+        }
+
+        double last_x() const
+        {
+            return m_vertices.size() ? m_vertices[m_vertices.size() - 1].x : 0.0;
+        }
+
+        double last_y() const
+        {
+            return m_vertices.size() ? m_vertices[m_vertices.size() - 1].y : 0.0;
+        }
+
+        unsigned total_vertices() const
+        {
+            return m_vertices.size();
+        }
+
+        unsigned vertex(unsigned idx, double* x, double* y) const
+        {
+            const vertex_type& v = m_vertices[idx];
+            *x = v.x;
+            *y = v.y;
+            return v.cmd;
+        }
+
+        unsigned command(unsigned idx) const
+        {
+            return m_vertices[idx].cmd;
+        }
+
+    private:
+        Container m_vertices;
+    };
+
+    //-----------------------------------------------------------path_storage
+    typedef path_base<vertex_block_storage<double> > path_storage;
+
+    // Example of declarations path_storage with pod_bvector as a container
+    //-----------------------------------------------------------------------
+    //typedef path_base<vertex_stl_storage<pod_bvector<vertex_d> > > path_storage;
+
+}
+
+
+
+// Example of declarations path_storage with std::vector as a container
+//---------------------------------------------------------------------------
+//#include <vector>
+//namespace agg
+//{
+//    typedef path_base<vertex_stl_storage<std::vector<vertex_d> > > stl_path_storage; 
+//}
+
+
+
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_pixfmt_amask_adaptor.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_pixfmt_amask_adaptor.h
new file mode 100644
index 0000000000..cf39c54ad5
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_pixfmt_amask_adaptor.h
@@ -0,0 +1,240 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_PIXFMT_AMASK_ADAPTOR_INCLUDED
+#define AGG_PIXFMT_AMASK_ADAPTOR_INCLUDED
+
+
+#include <string.h>
+#include "agg_array.h"
+#include "agg_rendering_buffer.h"
+
+
+namespace agg
+{
+    //==================================================pixfmt_amask_adaptor
+    template<class PixFmt, class AlphaMask> class pixfmt_amask_adaptor
+    {
+    public:
+        typedef PixFmt pixfmt_type;
+        typedef typename pixfmt_type::color_type color_type;
+        typedef typename pixfmt_type::row_data row_data;
+        typedef AlphaMask amask_type;
+        typedef typename amask_type::cover_type cover_type;
+
+    private:
+        enum span_extra_tail_e { span_extra_tail = 256 };
+
+        void realloc_span(unsigned len)
+        {
+            if(len > m_span.size())
+            {
+                m_span.resize(len + span_extra_tail);
+            }
+        }
+
+        void init_span(unsigned len)
+        {
+            realloc_span(len);
+            memset(&m_span[0], amask_type::cover_full, len * sizeof(cover_type));
+        }
+
+        void init_span(unsigned len, const cover_type* covers)
+        {
+            realloc_span(len);
+            memcpy(&m_span[0], covers, len * sizeof(cover_type));
+        }
+
+
+    public:
+        pixfmt_amask_adaptor(pixfmt_type& pixf, amask_type& mask) :
+            m_pixf(&pixf), m_mask(&mask), m_span()
+        {}
+
+        void attach_pixfmt(pixfmt_type& pixf) { m_pixf = &pixf; }
+        void attach_alpha_mask(amask_type& mask) { m_mask = &mask; }
+
+        //--------------------------------------------------------------------
+        template<class PixFmt2>
+        bool attach_pixfmt(PixFmt2& pixf, int x1, int y1, int x2, int y2)
+        {
+            return m_pixf->attach(pixf, x1, y1, x2, y2);
+        }
+
+        //--------------------------------------------------------------------
+        unsigned width()  const { return m_pixf->width();  }
+        unsigned height() const { return m_pixf->height(); }
+
+        //--------------------------------------------------------------------
+        color_type pixel(int x, int y)
+        {
+            return m_pixf->pixel(x, y);
+        }
+
+        //--------------------------------------------------------------------
+        void copy_pixel(int x, int y, const color_type& c)
+        {
+            m_pixf->blend_pixel(x, y, c, m_mask->pixel(x, y));
+        }
+
+        //--------------------------------------------------------------------
+        void blend_pixel(int x, int y, const color_type& c, cover_type cover)
+        {
+            m_pixf->blend_pixel(x, y, c, m_mask->combine_pixel(x, y, cover));
+        }
+
+        //--------------------------------------------------------------------
+        void copy_hline(int x, int y, 
+                        unsigned len, 
+                        const color_type& c)
+        {
+            realloc_span(len);
+            m_mask->fill_hspan(x, y, &m_span[0], len);
+            m_pixf->blend_solid_hspan(x, y, len, c, &m_span[0]);
+        }
+
+        //--------------------------------------------------------------------
+        void blend_hline(int x, int y,
+                         unsigned len, 
+                         const color_type& c,
+                         cover_type cover)
+        {
+            init_span(len);
+            m_mask->combine_hspan(x, y, &m_span[0], len);
+            m_pixf->blend_solid_hspan(x, y, len, c, &m_span[0]);
+        }
+
+        //--------------------------------------------------------------------
+        void copy_vline(int x, int y,
+                        unsigned len, 
+                        const color_type& c)
+        {
+            realloc_span(len);
+            m_mask->fill_vspan(x, y, &m_span[0], len);
+            m_pixf->blend_solid_vspan(x, y, len, c, &m_span[0]);
+        }
+
+        //--------------------------------------------------------------------
+        void blend_vline(int x, int y,
+                         unsigned len, 
+                         const color_type& c,
+                         cover_type cover)
+        {
+            init_span(len);
+            m_mask->combine_vspan(x, y, &m_span[0], len);
+            m_pixf->blend_solid_vspan(x, y, len, c, &m_span[0]);
+        }
+
+        //--------------------------------------------------------------------
+        void copy_from(const rendering_buffer& from, 
+                       int xdst, int ydst,
+                       int xsrc, int ysrc,
+                       unsigned len)
+        {
+            m_pixf->copy_from(from, xdst, ydst, xsrc, ysrc, len);
+        }
+
+
+        //--------------------------------------------------------------------
+        void blend_solid_hspan(int x, int y,
+                               unsigned len, 
+                               const color_type& c,
+                               const cover_type* covers)
+        {
+            init_span(len, covers);
+            m_mask->combine_hspan(x, y, &m_span[0], len);
+            m_pixf->blend_solid_hspan(x, y, len, c, &m_span[0]);
+        }
+
+
+        //--------------------------------------------------------------------
+        void blend_solid_vspan(int x, int y,
+                               unsigned len, 
+                               const color_type& c,
+                               const cover_type* covers)
+        {
+            init_span(len, covers);
+            m_mask->combine_vspan(x, y, &m_span[0], len);
+            m_pixf->blend_solid_vspan(x, y, len, c, &m_span[0]);
+        }
+
+
+        //--------------------------------------------------------------------
+        void copy_color_hspan(int x, int y, unsigned len, const color_type* colors)
+        {
+            realloc_span(len);
+            m_mask->fill_hspan(x, y, &m_span[0], len);
+            m_pixf->blend_color_hspan(x, y, len, colors, &m_span[0], cover_full);
+        }
+
+        //--------------------------------------------------------------------
+        void copy_color_vspan(int x, int y, unsigned len, const color_type* colors)
+        {
+            realloc_span(len);
+            m_mask->fill_vspan(x, y, &m_span[0], len);
+            m_pixf->blend_color_vspan(x, y, len, colors, &m_span[0], cover_full);
+        }
+
+        //--------------------------------------------------------------------
+        void blend_color_hspan(int x, int y,
+                               unsigned len, 
+                               const color_type* colors,
+                               const cover_type* covers,
+                               cover_type cover = cover_full)
+        {
+            if(covers) 
+            {
+                init_span(len, covers);
+                m_mask->combine_hspan(x, y, &m_span[0], len);
+            }
+            else
+            {
+                realloc_span(len);
+                m_mask->fill_hspan(x, y, &m_span[0], len);
+            }
+            m_pixf->blend_color_hspan(x, y, len, colors, &m_span[0], cover);
+        }
+
+
+        //--------------------------------------------------------------------
+        void blend_color_vspan(int x, int y,
+                               unsigned len, 
+                               const color_type* colors,
+                               const cover_type* covers,
+                               cover_type cover = cover_full)
+        {
+            if(covers) 
+            {
+                init_span(len, covers);
+                m_mask->combine_vspan(x, y, &m_span[0], len);
+            }
+            else
+            {
+                realloc_span(len);
+                m_mask->fill_vspan(x, y, &m_span[0], len);
+            }
+            m_pixf->blend_color_vspan(x, y, len, colors, &m_span[0], cover);
+        }
+
+    private:
+        pixfmt_type*          m_pixf;
+        const amask_type*     m_mask;
+        pod_array<cover_type> m_span;
+    };
+
+}
+
+#endif
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_pixfmt_base.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_pixfmt_base.h
new file mode 100644
index 0000000000..57ae19cfe0
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_pixfmt_base.h
@@ -0,0 +1,97 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_PIXFMT_BASE_INCLUDED
+#define AGG_PIXFMT_BASE_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_color_gray.h"
+#include "agg_color_rgba.h"
+
+namespace agg
+{
+    struct pixfmt_gray_tag
+    {
+    };
+
+    struct pixfmt_rgb_tag
+    {
+    };
+
+    struct pixfmt_rgba_tag
+    {
+    };
+
+    //--------------------------------------------------------------blender_base
+    template<class ColorT, class Order = void> 
+    struct blender_base
+    {
+        typedef ColorT color_type;
+        typedef Order order_type;
+        typedef typename color_type::value_type value_type;
+
+        static rgba get(value_type r, value_type g, value_type b, value_type a, cover_type cover = cover_full)
+        {
+            if (cover > cover_none)
+            {
+                rgba c(
+                    color_type::to_double(r), 
+                    color_type::to_double(g), 
+                    color_type::to_double(b), 
+                    color_type::to_double(a));
+
+                if (cover < cover_full)
+                {
+                    double x = double(cover) / cover_full;
+                    c.r *= x;
+                    c.g *= x;
+                    c.b *= x;
+                    c.a *= x;
+                }
+
+                return c;
+            }
+            else return rgba::no_color();
+        }
+
+        static rgba get(const value_type* p, cover_type cover = cover_full)
+        {
+            return get(
+                p[order_type::R], 
+                p[order_type::G], 
+                p[order_type::B], 
+                p[order_type::A], 
+                cover);
+        }
+
+        static void set(value_type* p, value_type r, value_type g, value_type b, value_type a)
+        {
+            p[order_type::R] = r;
+            p[order_type::G] = g;
+            p[order_type::B] = b;
+            p[order_type::A] = a;
+        }
+
+        static void set(value_type* p, const rgba& c)
+        {
+            p[order_type::R] = color_type::from_double(c.r);
+            p[order_type::G] = color_type::from_double(c.g);
+            p[order_type::B] = color_type::from_double(c.b);
+            p[order_type::A] = color_type::from_double(c.a);
+        }
+    };
+}
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_pixfmt_gray.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_pixfmt_gray.h
new file mode 100644
index 0000000000..438f04d33d
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_pixfmt_gray.h
@@ -0,0 +1,737 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Adaptation for high precision colors has been sponsored by 
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+// 
+//----------------------------------------------------------------------------
+
+#ifndef AGG_PIXFMT_GRAY_INCLUDED
+#define AGG_PIXFMT_GRAY_INCLUDED
+
+#include <string.h>
+#include "agg_pixfmt_base.h"
+#include "agg_rendering_buffer.h"
+
+namespace agg
+{
+ 
+    //============================================================blender_gray
+    template<class ColorT> struct blender_gray
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        // Blend pixels using the non-premultiplied form of Alvy-Ray Smith's
+        // compositing function. Since the render buffer is opaque we skip the
+        // initial premultiply and final demultiply.
+
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type cv, value_type alpha, cover_type cover)
+        {
+            blend_pix(p, cv, color_type::mult_cover(alpha, cover));
+        }
+
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type cv, value_type alpha)
+        {
+            *p = color_type::lerp(*p, cv, alpha);
+        }
+    };
+
+
+    //======================================================blender_gray_pre
+    template<class ColorT> struct blender_gray_pre
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        // Blend pixels using the premultiplied form of Alvy-Ray Smith's
+        // compositing function. 
+
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type cv, value_type alpha, cover_type cover)
+        {
+            blend_pix(p, color_type::mult_cover(cv, cover), color_type::mult_cover(alpha, cover));
+        }
+
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type cv, value_type alpha)
+        {
+            *p = color_type::prelerp(*p, cv, alpha);
+        }
+    };
+    
+
+
+    //=====================================================apply_gamma_dir_gray
+    template<class ColorT, class GammaLut> class apply_gamma_dir_gray
+    {
+    public:
+        typedef typename ColorT::value_type value_type;
+
+        apply_gamma_dir_gray(const GammaLut& gamma) : m_gamma(gamma) {}
+
+        AGG_INLINE void operator () (value_type* p)
+        {
+            *p = m_gamma.dir(*p);
+        }
+
+    private:
+        const GammaLut& m_gamma;
+    };
+
+
+
+    //=====================================================apply_gamma_inv_gray
+    template<class ColorT, class GammaLut> class apply_gamma_inv_gray
+    {
+    public:
+        typedef typename ColorT::value_type value_type;
+
+        apply_gamma_inv_gray(const GammaLut& gamma) : m_gamma(gamma) {}
+
+        AGG_INLINE void operator () (value_type* p)
+        {
+            *p = m_gamma.inv(*p);
+        }
+
+    private:
+        const GammaLut& m_gamma;
+    };
+
+
+
+    //=================================================pixfmt_alpha_blend_gray
+    template<class Blender, class RenBuf, unsigned Step = 1, unsigned Offset = 0>
+    class pixfmt_alpha_blend_gray
+    {
+    public:
+        typedef pixfmt_gray_tag pixfmt_category;
+        typedef RenBuf   rbuf_type;
+        typedef typename rbuf_type::row_data row_data;
+        typedef Blender  blender_type;
+        typedef typename blender_type::color_type color_type;
+        typedef int                               order_type; // A fake one
+        typedef typename color_type::value_type   value_type;
+        typedef typename color_type::calc_type    calc_type;
+        enum 
+        {
+            pix_width = sizeof(value_type) * Step,
+            pix_step = Step,
+            pix_offset = Offset,
+        };
+        struct pixel_type
+        {
+            value_type c[pix_step];
+
+            void set(value_type v)
+            {
+                c[0] = v;
+            }
+
+            void set(const color_type& color)
+            {
+                set(color.v);
+            }
+
+            void get(value_type& v) const
+            {
+                v = c[0];
+            }
+
+            color_type get() const
+            {
+                return color_type(c[0]);
+            }
+
+            pixel_type* next()
+            {
+                return this + 1;
+            }
+
+            const pixel_type* next() const
+            {
+                return this + 1;
+            }
+
+            pixel_type* advance(int n)
+            {
+                return this + n;
+            }
+
+            const pixel_type* advance(int n) const
+            {
+                return this + n;
+            }
+        };
+
+    private:
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pix(pixel_type* p, 
+            value_type v, value_type a, 
+            unsigned cover)
+        {
+            blender_type::blend_pix(p->c, v, a, cover);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pix(pixel_type* p, value_type v, value_type a)
+        {
+            blender_type::blend_pix(p->c, v, a);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pix(pixel_type* p, const color_type& c, unsigned cover)
+        {
+            blender_type::blend_pix(p->c, c.v, c.a, cover);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pix(pixel_type* p, const color_type& c)
+        {
+            blender_type::blend_pix(p->c, c.v, c.a);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_or_blend_pix(pixel_type* p, const color_type& c, unsigned cover)
+        {
+            if (!c.is_transparent())
+            {
+                if (c.is_opaque() && cover == cover_mask)
+                {
+                    p->set(c);
+                }
+                else
+                {
+                    blend_pix(p, c, cover);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_or_blend_pix(pixel_type* p, const color_type& c)
+        {
+            if (!c.is_transparent())
+            {
+                if (c.is_opaque())
+                {
+                    p->set(c);
+                }
+                else
+                {
+                    blend_pix(p, c);
+                }
+            }
+        }
+
+    public:
+        //--------------------------------------------------------------------
+        explicit pixfmt_alpha_blend_gray(rbuf_type& rb) :
+            m_rbuf(&rb)
+        {}
+        void attach(rbuf_type& rb) { m_rbuf = &rb; }
+        //--------------------------------------------------------------------
+
+        template<class PixFmt>
+        bool attach(PixFmt& pixf, int x1, int y1, int x2, int y2)
+        {
+            rect_i r(x1, y1, x2, y2);
+            if (r.clip(rect_i(0, 0, pixf.width()-1, pixf.height()-1)))
+            {
+                int stride = pixf.stride();
+                m_rbuf->attach(pixf.pix_ptr(r.x1, stride < 0 ? r.y2 : r.y1), 
+                               (r.x2 - r.x1) + 1,
+                               (r.y2 - r.y1) + 1,
+                               stride);
+                return true;
+            }
+            return false;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE unsigned width()  const { return m_rbuf->width();  }
+        AGG_INLINE unsigned height() const { return m_rbuf->height(); }
+        AGG_INLINE int      stride() const { return m_rbuf->stride(); }
+
+        //--------------------------------------------------------------------
+        int8u* row_ptr(int y)       { return m_rbuf->row_ptr(y); }
+        const int8u* row_ptr(int y) const { return m_rbuf->row_ptr(y); }
+        row_data     row(int y)     const { return m_rbuf->row(y); }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE int8u* pix_ptr(int x, int y) 
+        { 
+            return m_rbuf->row_ptr(y) + sizeof(value_type) * (x * pix_step + pix_offset);
+        }
+
+        AGG_INLINE const int8u* pix_ptr(int x, int y) const 
+        { 
+            return m_rbuf->row_ptr(y) + sizeof(value_type) * (x * pix_step + pix_offset);
+        }
+
+        // Return pointer to pixel value, forcing row to be allocated.
+        AGG_INLINE pixel_type* pix_value_ptr(int x, int y, unsigned len) 
+        {
+            return (pixel_type*)(m_rbuf->row_ptr(x, y, len) + sizeof(value_type) * (x * pix_step + pix_offset));
+        }
+
+        // Return pointer to pixel value, or null if row not allocated.
+        AGG_INLINE const pixel_type* pix_value_ptr(int x, int y) const 
+        {
+            int8u* p = m_rbuf->row_ptr(y);
+            return p ? (pixel_type*)(p + sizeof(value_type) * (x * pix_step + pix_offset)) : 0;
+        }
+
+        // Get pixel pointer from raw buffer pointer.
+        AGG_INLINE static pixel_type* pix_value_ptr(void* p) 
+        {
+            return (pixel_type*)((value_type*)p + pix_offset);
+        }
+
+        // Get pixel pointer from raw buffer pointer.
+        AGG_INLINE static const pixel_type* pix_value_ptr(const void* p) 
+        {
+            return (const pixel_type*)((const value_type*)p + pix_offset);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE static void write_plain_color(void* p, color_type c)
+        {
+            // Grayscale formats are implicitly premultiplied.
+            c.premultiply();
+            pix_value_ptr(p)->set(c);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE static color_type read_plain_color(const void* p)
+        {
+            return pix_value_ptr(p)->get();
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE static void make_pix(int8u* p, const color_type& c)
+        {
+            ((pixel_type*)p)->set(c);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE color_type pixel(int x, int y) const
+        {
+            if (const pixel_type* p = pix_value_ptr(x, y))
+            {
+                return p->get();
+            }
+            return color_type::no_color();
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_pixel(int x, int y, const color_type& c)
+        {
+            pix_value_ptr(x, y, 1)->set(c);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pixel(int x, int y, const color_type& c, int8u cover)
+        {
+            copy_or_blend_pix(pix_value_ptr(x, y, 1), c, cover);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_hline(int x, int y, 
+                                   unsigned len, 
+                                   const color_type& c)
+        {
+            pixel_type* p = pix_value_ptr(x, y, len);
+            do
+            {
+                p->set(c);
+                p = p->next();
+            }
+            while(--len);
+        }
+
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_vline(int x, int y,
+                                   unsigned len, 
+                                   const color_type& c)
+        {
+            do
+            {
+                pix_value_ptr(x, y++, 1)->set(c);
+            }
+            while (--len);
+        }
+
+
+        //--------------------------------------------------------------------
+        void blend_hline(int x, int y,
+                         unsigned len, 
+                         const color_type& c,
+                         int8u cover)
+        {
+            if (!c.is_transparent())
+            {
+                pixel_type* p = pix_value_ptr(x, y, len);
+
+                if (c.is_opaque() && cover == cover_mask)
+                {
+                    do
+                    {
+                        p->set(c);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+                else
+                {
+                    do
+                    {
+                        blend_pix(p, c, cover);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+
+        //--------------------------------------------------------------------
+        void blend_vline(int x, int y,
+                         unsigned len, 
+                         const color_type& c,
+                         int8u cover)
+        {
+            if (!c.is_transparent())
+            {
+                if (c.is_opaque() && cover == cover_mask)
+                {
+                    do
+                    {
+                        pix_value_ptr(x, y++, 1)->set(c);
+                    }
+                    while (--len);
+                }
+                else
+                {
+                    do
+                    {
+                        blend_pix(pix_value_ptr(x, y++, 1), c, cover);
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+
+        //--------------------------------------------------------------------
+        void blend_solid_hspan(int x, int y,
+                               unsigned len, 
+                               const color_type& c,
+                               const int8u* covers)
+        {
+            if (!c.is_transparent())
+            {
+                pixel_type* p = pix_value_ptr(x, y, len);
+
+                do 
+                {
+                    if (c.is_opaque() && *covers == cover_mask)
+                    {
+                        p->set(c);
+                    }
+                    else
+                    {
+                        blend_pix(p, c, *covers);
+                    }
+                    p = p->next();
+                    ++covers;
+                }
+                while (--len);
+            }
+        }
+
+
+        //--------------------------------------------------------------------
+        void blend_solid_vspan(int x, int y,
+                               unsigned len, 
+                               const color_type& c,
+                               const int8u* covers)
+        {
+            if (!c.is_transparent())
+            {
+                do 
+                {
+                    pixel_type* p = pix_value_ptr(x, y++, 1);
+
+                    if (c.is_opaque() && *covers == cover_mask)
+                    {
+                        p->set(c);
+                    }
+                    else
+                    {
+                        blend_pix(p, c, *covers);
+                    }
+                    ++covers;
+                }
+                while (--len);
+            }
+        }
+
+
+        //--------------------------------------------------------------------
+        void copy_color_hspan(int x, int y,
+                              unsigned len, 
+                              const color_type* colors)
+        {
+            pixel_type* p = pix_value_ptr(x, y, len);
+
+            do 
+            {
+                p->set(*colors++);
+                p = p->next();
+            }
+            while (--len);
+        }
+
+
+        //--------------------------------------------------------------------
+        void copy_color_vspan(int x, int y,
+                              unsigned len, 
+                              const color_type* colors)
+        {
+            do 
+            {
+                pix_value_ptr(x, y++, 1)->set(*colors++);
+            }
+            while (--len);
+        }
+
+
+        //--------------------------------------------------------------------
+        void blend_color_hspan(int x, int y,
+                               unsigned len, 
+                               const color_type* colors,
+                               const int8u* covers,
+                               int8u cover)
+        {
+            pixel_type* p = pix_value_ptr(x, y, len);
+
+            if (covers)
+            {
+                do 
+                {
+                    copy_or_blend_pix(p, *colors++, *covers++);
+                    p = p->next();
+                }
+                while (--len);
+            }
+            else
+            {
+                if (cover == cover_mask)
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(p, *colors++);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+                else
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(p, *colors++, cover);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+            }
+        }
+        
+
+        //--------------------------------------------------------------------
+        void blend_color_vspan(int x, int y,
+                               unsigned len, 
+                               const color_type* colors,
+                               const int8u* covers,
+                               int8u cover)
+        {
+            if (covers)
+            {
+                do 
+                {
+                    copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++, *covers++);
+                }
+                while (--len);
+            }
+            else
+            {
+                if (cover == cover_mask)
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++);
+                    }
+                    while (--len);
+                }
+                else
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++, cover);
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        template<class Function> void for_each_pixel(Function f)
+        {
+            unsigned y;
+            for (y = 0; y < height(); ++y)
+            {
+                row_data r = m_rbuf->row(y);
+                if (r.ptr)
+                {
+                    unsigned len = r.x2 - r.x1 + 1;
+                    pixel_type* p = pix_value_ptr(r.x1, y, len);
+                    do
+                    {
+                        f(p->c);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        template<class GammaLut> void apply_gamma_dir(const GammaLut& g)
+        {
+            for_each_pixel(apply_gamma_dir_gray<color_type, GammaLut>(g));
+        }
+
+        //--------------------------------------------------------------------
+        template<class GammaLut> void apply_gamma_inv(const GammaLut& g)
+        {
+            for_each_pixel(apply_gamma_inv_gray<color_type, GammaLut>(g));
+        }
+
+        //--------------------------------------------------------------------
+        template<class RenBuf2>
+        void copy_from(const RenBuf2& from, 
+                       int xdst, int ydst,
+                       int xsrc, int ysrc,
+                       unsigned len)
+        {
+            if (const int8u* p = from.row_ptr(ysrc))
+            {
+                memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width, 
+                        p + xsrc * pix_width, 
+                        len * pix_width);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        // Blend from single color, using grayscale surface as alpha channel.
+        template<class SrcPixelFormatRenderer>
+        void blend_from_color(const SrcPixelFormatRenderer& from, 
+                              const color_type& color,
+                              int xdst, int ydst,
+                              int xsrc, int ysrc,
+                              unsigned len,
+                              int8u cover)
+        {
+            typedef typename SrcPixelFormatRenderer::pixel_type src_pixel_type;
+            typedef typename SrcPixelFormatRenderer::color_type src_color_type;
+
+            if (const src_pixel_type* psrc = from.pix_value_ptr(xsrc, ysrc))
+            {
+                pixel_type* pdst = pix_value_ptr(xdst, ydst, len);
+
+                do 
+                {
+                    copy_or_blend_pix(pdst, color, src_color_type::scale_cover(cover, psrc->c[0]));
+                    psrc = psrc->next();
+                    pdst = pdst->next();
+                }
+                while (--len);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        // Blend from color table, using grayscale surface as indexes into table.
+        // Obviously, this only works for integer value types.
+        template<class SrcPixelFormatRenderer>
+        void blend_from_lut(const SrcPixelFormatRenderer& from, 
+                            const color_type* color_lut,
+                            int xdst, int ydst,
+                            int xsrc, int ysrc,
+                            unsigned len,
+                            int8u cover)
+        {
+            typedef typename SrcPixelFormatRenderer::pixel_type src_pixel_type;
+
+            if (const src_pixel_type* psrc = from.pix_value_ptr(xsrc, ysrc))
+            {
+                pixel_type* pdst = pix_value_ptr(xdst, ydst, len);
+
+                do 
+                {
+                    copy_or_blend_pix(pdst, color_lut[psrc->c[0]], cover);
+                    psrc = psrc->next();
+                    pdst = pdst->next();
+                }
+                while (--len);
+            }
+        }
+
+    private:
+        rbuf_type* m_rbuf;
+    };
+
+    typedef blender_gray<gray8> blender_gray8;
+    typedef blender_gray<sgray8> blender_sgray8;
+    typedef blender_gray<gray16> blender_gray16;
+    typedef blender_gray<gray32> blender_gray32;
+
+    typedef blender_gray_pre<gray8> blender_gray8_pre;
+    typedef blender_gray_pre<sgray8> blender_sgray8_pre;
+    typedef blender_gray_pre<gray16> blender_gray16_pre;
+    typedef blender_gray_pre<gray32> blender_gray32_pre;
+
+    typedef pixfmt_alpha_blend_gray<blender_gray8, rendering_buffer> pixfmt_gray8;
+    typedef pixfmt_alpha_blend_gray<blender_sgray8, rendering_buffer> pixfmt_sgray8;
+    typedef pixfmt_alpha_blend_gray<blender_gray16, rendering_buffer> pixfmt_gray16;
+    typedef pixfmt_alpha_blend_gray<blender_gray32, rendering_buffer> pixfmt_gray32;
+
+    typedef pixfmt_alpha_blend_gray<blender_gray8_pre, rendering_buffer> pixfmt_gray8_pre;
+    typedef pixfmt_alpha_blend_gray<blender_sgray8_pre, rendering_buffer> pixfmt_sgray8_pre;
+    typedef pixfmt_alpha_blend_gray<blender_gray16_pre, rendering_buffer> pixfmt_gray16_pre;
+    typedef pixfmt_alpha_blend_gray<blender_gray32_pre, rendering_buffer> pixfmt_gray32_pre;
+}
+
+#endif
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_pixfmt_rgb.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_pixfmt_rgb.h
new file mode 100644
index 0000000000..7095fbce58
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_pixfmt_rgb.h
@@ -0,0 +1,994 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Adaptation for high precision colors has been sponsored by 
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+// 
+//----------------------------------------------------------------------------
+
+#ifndef AGG_PIXFMT_RGB_INCLUDED
+#define AGG_PIXFMT_RGB_INCLUDED
+
+#include <string.h>
+#include "agg_pixfmt_base.h"
+#include "agg_rendering_buffer.h"
+
+namespace agg
+{
+
+    //=====================================================apply_gamma_dir_rgb
+    template<class ColorT, class Order, class GammaLut> class apply_gamma_dir_rgb
+    {
+    public:
+        typedef typename ColorT::value_type value_type;
+
+        apply_gamma_dir_rgb(const GammaLut& gamma) : m_gamma(gamma) {}
+
+        AGG_INLINE void operator () (value_type* p)
+        {
+            p[Order::R] = m_gamma.dir(p[Order::R]);
+            p[Order::G] = m_gamma.dir(p[Order::G]);
+            p[Order::B] = m_gamma.dir(p[Order::B]);
+        }
+
+    private:
+        const GammaLut& m_gamma;
+    };
+
+
+
+    //=====================================================apply_gamma_inv_rgb
+    template<class ColorT, class Order, class GammaLut> class apply_gamma_inv_rgb
+    {
+    public:
+        typedef typename ColorT::value_type value_type;
+
+        apply_gamma_inv_rgb(const GammaLut& gamma) : m_gamma(gamma) {}
+
+        AGG_INLINE void operator () (value_type* p)
+        {
+            p[Order::R] = m_gamma.inv(p[Order::R]);
+            p[Order::G] = m_gamma.inv(p[Order::G]);
+            p[Order::B] = m_gamma.inv(p[Order::B]);
+        }
+
+    private:
+        const GammaLut& m_gamma;
+    };
+
+
+    //=========================================================blender_rgb
+    template<class ColorT, class Order> 
+    struct blender_rgb
+    {
+        typedef ColorT color_type;
+        typedef Order order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        // Blend pixels using the non-premultiplied form of Alvy-Ray Smith's
+        // compositing function. Since the render buffer is opaque we skip the
+        // initial premultiply and final demultiply.
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type cr, value_type cg, value_type cb, value_type alpha, cover_type cover)
+        {
+            blend_pix(p, cr, cg, cb, color_type::mult_cover(alpha, cover));
+        }
+        
+        //--------------------------------------------------------------------
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type cr, value_type cg, value_type cb, value_type alpha)
+        {
+            p[Order::R] = color_type::lerp(p[Order::R], cr, alpha);
+            p[Order::G] = color_type::lerp(p[Order::G], cg, alpha);
+            p[Order::B] = color_type::lerp(p[Order::B], cb, alpha);
+        }
+    };
+
+    //======================================================blender_rgb_pre
+    template<class ColorT, class Order> 
+    struct blender_rgb_pre
+    {
+        typedef ColorT color_type;
+        typedef Order order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        // Blend pixels using the premultiplied form of Alvy-Ray Smith's
+        // compositing function. 
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type cr, value_type cg, value_type cb, value_type alpha, cover_type cover)
+        {
+            blend_pix(p, 
+                color_type::mult_cover(cr, cover), 
+                color_type::mult_cover(cg, cover), 
+                color_type::mult_cover(cb, cover), 
+                color_type::mult_cover(alpha, cover));
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type cr, value_type cg, value_type cb, value_type alpha)
+        {
+            p[Order::R] = color_type::prelerp(p[Order::R], cr, alpha);
+            p[Order::G] = color_type::prelerp(p[Order::G], cg, alpha);
+            p[Order::B] = color_type::prelerp(p[Order::B], cb, alpha);
+        }
+    };
+
+    //===================================================blender_rgb_gamma
+    template<class ColorT, class Order, class Gamma> 
+    class blender_rgb_gamma : public blender_base<ColorT, Order>
+    {
+    public:
+        typedef ColorT color_type;
+        typedef Order order_type;
+        typedef Gamma gamma_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        //--------------------------------------------------------------------
+        blender_rgb_gamma() : m_gamma(0) {}
+        void gamma(const gamma_type& g) { m_gamma = &g; }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pix(value_type* p, 
+            value_type cr, value_type cg, value_type cb, value_type alpha, cover_type cover)
+        {
+            blend_pix(p, cr, cg, cb, color_type::mult_cover(alpha, cover));
+        }
+        
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pix(value_type* p, 
+            value_type cr, value_type cg, value_type cb, value_type alpha)
+        {
+            calc_type r = m_gamma->dir(p[Order::R]);
+            calc_type g = m_gamma->dir(p[Order::G]);
+            calc_type b = m_gamma->dir(p[Order::B]);
+            p[Order::R] = m_gamma->inv(color_type::downscale((m_gamma->dir(cr) - r) * alpha) + r);
+            p[Order::G] = m_gamma->inv(color_type::downscale((m_gamma->dir(cg) - g) * alpha) + g);
+            p[Order::B] = m_gamma->inv(color_type::downscale((m_gamma->dir(cb) - b) * alpha) + b);
+        }
+        
+    private:
+        const gamma_type* m_gamma;
+    };
+
+
+    //==================================================pixfmt_alpha_blend_rgb
+    template<class Blender, class RenBuf, unsigned Step, unsigned Offset = 0> 
+    class pixfmt_alpha_blend_rgb
+    {
+    public:
+        typedef pixfmt_rgb_tag pixfmt_category;
+        typedef RenBuf   rbuf_type;
+        typedef Blender  blender_type;
+        typedef typename rbuf_type::row_data row_data;
+        typedef typename blender_type::color_type color_type;
+        typedef typename blender_type::order_type order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        enum 
+        {
+            pix_step = Step,
+            pix_offset = Offset,
+            pix_width = sizeof(value_type) * pix_step
+        };
+        struct pixel_type
+        {
+            value_type c[pix_step];
+
+            void set(value_type r, value_type g, value_type b)
+            {
+                c[order_type::R] = r;
+                c[order_type::G] = g;
+                c[order_type::B] = b;
+            }
+
+            void set(const color_type& color)
+            {
+                set(color.r, color.g, color.b);
+            }
+
+            void get(value_type& r, value_type& g, value_type& b) const
+            {
+                r = c[order_type::R];
+                g = c[order_type::G];
+                b = c[order_type::B];
+            }
+
+            color_type get() const
+            {
+                return color_type(
+                    c[order_type::R], 
+                    c[order_type::G], 
+                    c[order_type::B]);
+            }
+
+            pixel_type* next()
+            {
+                return this + 1;
+            }
+
+            const pixel_type* next() const
+            {
+                return this + 1;
+            }
+
+            pixel_type* advance(int n)
+            {
+                return this + n;
+            }
+
+            const pixel_type* advance(int n) const
+            {
+                return this + n;
+            }
+        };
+
+    private:
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pix(pixel_type* p, 
+            value_type r, value_type g, value_type b, value_type a, 
+            unsigned cover)
+        {
+            m_blender.blend_pix(p->c, r, g, b, a, cover);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pix(pixel_type* p, 
+            value_type r, value_type g, value_type b, value_type a)
+        {
+            m_blender.blend_pix(p->c, r, g, b, a);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pix(pixel_type* p, const color_type& c, unsigned cover)
+        {
+            m_blender.blend_pix(p->c, c.r, c.g, c.b, c.a, cover);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pix(pixel_type* p, const color_type& c)
+        {
+            m_blender.blend_pix(p->c, c.r, c.g, c.b, c.a);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_or_blend_pix(pixel_type* p, const color_type& c, unsigned cover)
+        {
+            if (!c.is_transparent())
+            {
+                if (c.is_opaque() && cover == cover_mask)
+                {
+                    p->set(c);
+                }
+                else
+                {
+                    blend_pix(p, c, cover);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_or_blend_pix(pixel_type* p, const color_type& c)
+        {
+            if (!c.is_transparent())
+            {
+                if (c.is_opaque())
+                {
+                    p->set(c);
+                }
+                else
+                {
+                    blend_pix(p, c);
+                }
+            }
+        }
+
+    public:
+        //--------------------------------------------------------------------
+        explicit pixfmt_alpha_blend_rgb(rbuf_type& rb) :
+            m_rbuf(&rb)
+        {}
+        void attach(rbuf_type& rb) { m_rbuf = &rb; }
+
+        //--------------------------------------------------------------------
+        template<class PixFmt>
+        bool attach(PixFmt& pixf, int x1, int y1, int x2, int y2)
+        {
+            rect_i r(x1, y1, x2, y2);
+            if (r.clip(rect_i(0, 0, pixf.width()-1, pixf.height()-1)))
+            {
+                int stride = pixf.stride();
+                m_rbuf->attach(pixf.pix_ptr(r.x1, stride < 0 ? r.y2 : r.y1), 
+                               (r.x2 - r.x1) + 1,
+                               (r.y2 - r.y1) + 1,
+                               stride);
+                return true;
+            }
+            return false;
+        }
+
+        //--------------------------------------------------------------------
+        Blender& blender() { return m_blender; }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE unsigned width()  const { return m_rbuf->width();  }
+        AGG_INLINE unsigned height() const { return m_rbuf->height(); }
+        AGG_INLINE int      stride() const { return m_rbuf->stride(); }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE       int8u* row_ptr(int y)       { return m_rbuf->row_ptr(y); }
+        AGG_INLINE const int8u* row_ptr(int y) const { return m_rbuf->row_ptr(y); }
+        AGG_INLINE row_data     row(int y)     const { return m_rbuf->row(y); }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE int8u* pix_ptr(int x, int y) 
+        { 
+            return m_rbuf->row_ptr(y) + sizeof(value_type) * (x * pix_step + pix_offset);
+        }
+
+        AGG_INLINE const int8u* pix_ptr(int x, int y) const 
+        { 
+            return m_rbuf->row_ptr(y) + sizeof(value_type) * (x * pix_step + pix_offset);
+        }
+
+        // Return pointer to pixel value, forcing row to be allocated.
+        AGG_INLINE pixel_type* pix_value_ptr(int x, int y, unsigned len) 
+        {
+            return (pixel_type*)(m_rbuf->row_ptr(x, y, len) + sizeof(value_type) * (x * pix_step + pix_offset));
+        }
+
+        // Return pointer to pixel value, or null if row not allocated.
+        AGG_INLINE const pixel_type* pix_value_ptr(int x, int y) const 
+        {
+            int8u* p = m_rbuf->row_ptr(y);
+            return p ? (pixel_type*)(p + sizeof(value_type) * (x * pix_step + pix_offset)) : 0;
+        }
+
+        // Get pixel pointer from raw buffer pointer.
+        AGG_INLINE static pixel_type* pix_value_ptr(void* p) 
+        {
+            return (pixel_type*)((value_type*)p + pix_offset);
+        }
+
+        // Get pixel pointer from raw buffer pointer.
+        AGG_INLINE static const pixel_type* pix_value_ptr(const void* p) 
+        {
+            return (const pixel_type*)((const value_type*)p + pix_offset);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE static void write_plain_color(void* p, color_type c)
+        {
+            // RGB formats are implicitly premultiplied.
+            c.premultiply();
+            pix_value_ptr(p)->set(c);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE static color_type read_plain_color(const void* p)
+        {
+            return pix_value_ptr(p)->get();
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE static void make_pix(int8u* p, const color_type& c)
+        {
+            ((pixel_type*)p)->set(c);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE color_type pixel(int x, int y) const
+        {
+            if (const pixel_type* p = pix_value_ptr(x, y))
+            {
+                return p->get();
+            }
+            return color_type::no_color();
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_pixel(int x, int y, const color_type& c)
+        {
+            pix_value_ptr(x, y, 1)->set(c);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pixel(int x, int y, const color_type& c, int8u cover)
+        {
+            copy_or_blend_pix(pix_value_ptr(x, y, 1), c, cover);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_hline(int x, int y, 
+                                   unsigned len, 
+                                   const color_type& c)
+        {
+            pixel_type* p = pix_value_ptr(x, y, len);
+            do
+            {
+                p->set(c);
+                p = p->next();
+            }
+            while(--len);
+        }
+
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_vline(int x, int y,
+                                   unsigned len, 
+                                   const color_type& c)
+        {
+            do
+            {
+                pix_value_ptr(x, y++, 1)->set(c);
+            }
+            while (--len);
+        }
+
+        //--------------------------------------------------------------------
+        void blend_hline(int x, int y,
+                         unsigned len, 
+                         const color_type& c,
+                         int8u cover)
+        {
+            if (!c.is_transparent())
+            {
+                pixel_type* p = pix_value_ptr(x, y, len);
+
+                if (c.is_opaque() && cover == cover_mask)
+                {
+                    do
+                    {
+                        p->set(c);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+                else
+                {
+                    do
+                    {
+                        blend_pix(p, c, cover);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+
+        //--------------------------------------------------------------------
+        void blend_vline(int x, int y,
+                         unsigned len, 
+                         const color_type& c,
+                         int8u cover)
+        {
+            if (!c.is_transparent())
+            {
+                if (c.is_opaque() && cover == cover_mask)
+                {
+                    do
+                    {
+                        pix_value_ptr(x, y++, 1)->set(c);
+                    }
+                    while (--len);
+                }
+                else
+                {
+                    do
+                    {
+                        blend_pix(pix_value_ptr(x, y++, 1), c, cover);
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void blend_solid_hspan(int x, int y,
+                               unsigned len, 
+                               const color_type& c,
+                               const int8u* covers)
+        {
+            if (!c.is_transparent())
+            {
+                pixel_type* p = pix_value_ptr(x, y, len);
+
+                do 
+                {
+                    if (c.is_opaque() && *covers == cover_mask)
+                    {
+                        p->set(c);
+                    }
+                    else
+                    {
+                        blend_pix(p, c, *covers);
+                    }
+                    p = p->next();
+                    ++covers;
+                }
+                while (--len);
+            }
+        }
+
+
+        //--------------------------------------------------------------------
+        void blend_solid_vspan(int x, int y,
+                               unsigned len, 
+                               const color_type& c,
+                               const int8u* covers)
+        {
+            if (!c.is_transparent())
+            {
+                do 
+                {
+                    pixel_type* p = pix_value_ptr(x, y++, 1);
+
+                    if (c.is_opaque() && *covers == cover_mask)
+                    {
+                        p->set(c);
+                    }
+                    else
+                    {
+                        blend_pix(p, c, *covers);
+                    }
+                    ++covers;
+                }
+                while (--len);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void copy_color_hspan(int x, int y,
+                              unsigned len, 
+                              const color_type* colors)
+        {
+            pixel_type* p = pix_value_ptr(x, y, len);
+
+            do 
+            {
+                p->set(*colors++);
+                p = p->next();
+            }
+            while (--len);
+        }
+
+
+        //--------------------------------------------------------------------
+        void copy_color_vspan(int x, int y,
+                              unsigned len, 
+                              const color_type* colors)
+        {
+            do 
+            {
+                pix_value_ptr(x, y++, 1)->set(*colors++);
+            }
+            while (--len);
+        }
+
+        //--------------------------------------------------------------------
+        void blend_color_hspan(int x, int y,
+                               unsigned len, 
+                               const color_type* colors,
+                               const int8u* covers,
+                               int8u cover)
+        {
+            pixel_type* p = pix_value_ptr(x, y, len);
+
+            if (covers)
+            {
+                do 
+                {
+                    copy_or_blend_pix(p, *colors++, *covers++);
+                    p = p->next();
+                }
+                while (--len);
+            }
+            else
+            {
+                if (cover == cover_mask)
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(p, *colors++);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+                else
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(p, *colors++, cover);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void blend_color_vspan(int x, int y,
+                               unsigned len, 
+                               const color_type* colors,
+                               const int8u* covers,
+                               int8u cover)
+        {
+            if (covers)
+            {
+                do 
+                {
+                    copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++, *covers++);
+                }
+                while (--len);
+            }
+            else
+            {
+                if (cover == cover_mask)
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++);
+                    }
+                    while (--len);
+                }
+                else
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++, cover);
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        template<class Function> void for_each_pixel(Function f)
+        {
+            for (unsigned y = 0; y < height(); ++y)
+            {
+                row_data r = m_rbuf->row(y);
+                if (r.ptr)
+                {
+                    unsigned len = r.x2 - r.x1 + 1;
+                    pixel_type* p = pix_value_ptr(r.x1, y, len);
+                    do
+                    {
+                        f(p->c);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        template<class GammaLut> void apply_gamma_dir(const GammaLut& g)
+        {
+            for_each_pixel(apply_gamma_dir_rgb<color_type, order_type, GammaLut>(g));
+        }
+
+        //--------------------------------------------------------------------
+        template<class GammaLut> void apply_gamma_inv(const GammaLut& g)
+        {
+            for_each_pixel(apply_gamma_inv_rgb<color_type, order_type, GammaLut>(g));
+        }
+
+        //--------------------------------------------------------------------
+        template<class RenBuf2>
+        void copy_from(const RenBuf2& from, 
+                       int xdst, int ydst,
+                       int xsrc, int ysrc,
+                       unsigned len)
+        {
+            if (const int8u* p = from.row_ptr(ysrc))
+            {
+                memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width, 
+                        p + xsrc * pix_width, 
+                        len * pix_width);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        // Blend from an RGBA surface.
+        template<class SrcPixelFormatRenderer>
+        void blend_from(const SrcPixelFormatRenderer& from, 
+                        int xdst, int ydst,
+                        int xsrc, int ysrc,
+                        unsigned len,
+                        int8u cover)
+        {
+            typedef typename SrcPixelFormatRenderer::pixel_type src_pixel_type;
+            typedef typename SrcPixelFormatRenderer::order_type src_order;
+
+            if (const src_pixel_type* psrc = from.pix_value_ptr(xsrc, ysrc))
+            {
+                pixel_type* pdst = pix_value_ptr(xdst, ydst, len);
+
+                if (cover == cover_mask)
+                {
+                    do 
+                    {
+                        value_type alpha = psrc->c[src_order::A];
+                        if (alpha <= color_type::empty_value())
+                        {
+                            if (alpha >= color_type::full_value())
+                            {
+                                pdst->c[order_type::R] = psrc->c[src_order::R];
+                                pdst->c[order_type::G] = psrc->c[src_order::G];
+                                pdst->c[order_type::B] = psrc->c[src_order::B];
+                            }
+                            else
+                            {
+                                blend_pix(pdst, 
+                                    psrc->c[src_order::R],
+                                    psrc->c[src_order::G],
+                                    psrc->c[src_order::B],
+                                    alpha);
+                            }
+                        }
+                        psrc = psrc->next();
+                        pdst = pdst->next();
+                    }
+                    while(--len);
+                }
+                else
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(pdst, psrc->get(), cover);
+                        psrc = psrc->next();
+                        pdst = pdst->next();
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        // Blend from single color, using grayscale surface as alpha channel.
+        template<class SrcPixelFormatRenderer>
+        void blend_from_color(const SrcPixelFormatRenderer& from, 
+                              const color_type& color,
+                              int xdst, int ydst,
+                              int xsrc, int ysrc,
+                              unsigned len,
+                              int8u cover)
+        {
+            typedef typename SrcPixelFormatRenderer::pixel_type src_pixel_type;
+            typedef typename SrcPixelFormatRenderer::color_type src_color_type;
+
+            if (const src_pixel_type* psrc = from.pix_value_ptr(xsrc, ysrc))
+            {
+                pixel_type* pdst = pix_value_ptr(xdst, ydst, len);
+
+                do 
+                {
+                    copy_or_blend_pix(pdst, color, src_color_type::scale_cover(cover, psrc->c[0]));
+                    psrc = psrc->next();
+                    pdst = pdst->next();
+                }
+                while (--len);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        // Blend from color table, using grayscale surface as indexes into table. 
+        // Obviously, this only works for integer value types.
+        template<class SrcPixelFormatRenderer>
+        void blend_from_lut(const SrcPixelFormatRenderer& from, 
+                            const color_type* color_lut,
+                            int xdst, int ydst,
+                            int xsrc, int ysrc,
+                            unsigned len,
+                            int8u cover)
+        {
+            typedef typename SrcPixelFormatRenderer::pixel_type src_pixel_type;
+
+            if (const src_pixel_type* psrc = from.pix_value_ptr(xsrc, ysrc))
+            {
+                pixel_type* pdst = pix_value_ptr(xdst, ydst, len);
+
+                if (cover == cover_mask)
+                {
+                    do 
+                    {
+                        const color_type& color = color_lut[psrc->c[0]];
+                        blend_pix(pdst, color);
+                        psrc = psrc->next();
+                        pdst = pdst->next();
+                    }
+                    while(--len);
+                }
+                else
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(pdst, color_lut[psrc->c[0]], cover);
+                        psrc = psrc->next();
+                        pdst = pdst->next();
+                    }
+                    while(--len);
+                }
+            }
+        }
+
+    private:
+        rbuf_type* m_rbuf;
+        Blender    m_blender;
+    };
+    
+    //-----------------------------------------------------------------------
+    typedef blender_rgb<rgba8, order_rgb> blender_rgb24;
+    typedef blender_rgb<rgba8, order_bgr> blender_bgr24;
+    typedef blender_rgb<srgba8, order_rgb> blender_srgb24;
+    typedef blender_rgb<srgba8, order_bgr> blender_sbgr24;
+    typedef blender_rgb<rgba16, order_rgb> blender_rgb48;
+    typedef blender_rgb<rgba16, order_bgr> blender_bgr48;
+    typedef blender_rgb<rgba32, order_rgb> blender_rgb96;
+    typedef blender_rgb<rgba32, order_bgr> blender_bgr96;
+
+    typedef blender_rgb_pre<rgba8, order_rgb> blender_rgb24_pre;
+    typedef blender_rgb_pre<rgba8, order_bgr> blender_bgr24_pre;
+    typedef blender_rgb_pre<srgba8, order_rgb> blender_srgb24_pre;
+    typedef blender_rgb_pre<srgba8, order_bgr> blender_sbgr24_pre;
+    typedef blender_rgb_pre<rgba16, order_rgb> blender_rgb48_pre;
+    typedef blender_rgb_pre<rgba16, order_bgr> blender_bgr48_pre;
+    typedef blender_rgb_pre<rgba32, order_rgb> blender_rgb96_pre;
+    typedef blender_rgb_pre<rgba32, order_bgr> blender_bgr96_pre;
+
+    typedef pixfmt_alpha_blend_rgb<blender_rgb24, rendering_buffer, 3> pixfmt_rgb24;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr24, rendering_buffer, 3> pixfmt_bgr24;
+    typedef pixfmt_alpha_blend_rgb<blender_srgb24, rendering_buffer, 3> pixfmt_srgb24;
+    typedef pixfmt_alpha_blend_rgb<blender_sbgr24, rendering_buffer, 3> pixfmt_sbgr24;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb48, rendering_buffer, 3> pixfmt_rgb48;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr48, rendering_buffer, 3> pixfmt_bgr48;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb96, rendering_buffer, 3> pixfmt_rgb96;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr96, rendering_buffer, 3> pixfmt_bgr96;
+
+    typedef pixfmt_alpha_blend_rgb<blender_rgb24_pre, rendering_buffer, 3> pixfmt_rgb24_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr24_pre, rendering_buffer, 3> pixfmt_bgr24_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_srgb24_pre, rendering_buffer, 3> pixfmt_srgb24_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_sbgr24_pre, rendering_buffer, 3> pixfmt_sbgr24_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb48_pre, rendering_buffer, 3> pixfmt_rgb48_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr48_pre, rendering_buffer, 3> pixfmt_bgr48_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb96_pre, rendering_buffer, 3> pixfmt_rgb96_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr96_pre, rendering_buffer, 3> pixfmt_bgr96_pre;
+
+    typedef pixfmt_alpha_blend_rgb<blender_rgb24, rendering_buffer, 4, 0> pixfmt_rgbx32;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb24, rendering_buffer, 4, 1> pixfmt_xrgb32;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr24, rendering_buffer, 4, 1> pixfmt_xbgr32;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr24, rendering_buffer, 4, 0> pixfmt_bgrx32;
+    typedef pixfmt_alpha_blend_rgb<blender_srgb24, rendering_buffer, 4, 0> pixfmt_srgbx32;
+    typedef pixfmt_alpha_blend_rgb<blender_srgb24, rendering_buffer, 4, 1> pixfmt_sxrgb32;
+    typedef pixfmt_alpha_blend_rgb<blender_sbgr24, rendering_buffer, 4, 1> pixfmt_sxbgr32;
+    typedef pixfmt_alpha_blend_rgb<blender_sbgr24, rendering_buffer, 4, 0> pixfmt_sbgrx32;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb48, rendering_buffer, 4, 0> pixfmt_rgbx64;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb48, rendering_buffer, 4, 1> pixfmt_xrgb64;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr48, rendering_buffer, 4, 1> pixfmt_xbgr64;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr48, rendering_buffer, 4, 0> pixfmt_bgrx64;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb96, rendering_buffer, 4, 0> pixfmt_rgbx128;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb96, rendering_buffer, 4, 1> pixfmt_xrgb128;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr96, rendering_buffer, 4, 1> pixfmt_xbgr128;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr96, rendering_buffer, 4, 0> pixfmt_bgrx128;
+
+    typedef pixfmt_alpha_blend_rgb<blender_rgb24_pre, rendering_buffer, 4, 0> pixfmt_rgbx32_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb24_pre, rendering_buffer, 4, 1> pixfmt_xrgb32_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr24_pre, rendering_buffer, 4, 1> pixfmt_xbgr32_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr24_pre, rendering_buffer, 4, 0> pixfmt_bgrx32_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_srgb24_pre, rendering_buffer, 4, 0> pixfmt_srgbx32_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_srgb24_pre, rendering_buffer, 4, 1> pixfmt_sxrgb32_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_sbgr24_pre, rendering_buffer, 4, 1> pixfmt_sxbgr32_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_sbgr24_pre, rendering_buffer, 4, 0> pixfmt_sbgrx32_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb48_pre, rendering_buffer, 4, 0> pixfmt_rgbx64_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb48_pre, rendering_buffer, 4, 1> pixfmt_xrgb64_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr48_pre, rendering_buffer, 4, 1> pixfmt_xbgr64_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr48_pre, rendering_buffer, 4, 0> pixfmt_bgrx64_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb96_pre, rendering_buffer, 4, 0> pixfmt_rgbx128_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb96_pre, rendering_buffer, 4, 1> pixfmt_xrgb128_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr96_pre, rendering_buffer, 4, 1> pixfmt_xbgr128_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr96_pre, rendering_buffer, 4, 0> pixfmt_bgrx128_pre;
+    
+
+    //-----------------------------------------------------pixfmt_rgb24_gamma
+    template<class Gamma> class pixfmt_rgb24_gamma : 
+    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_rgb, Gamma>, rendering_buffer, 3>
+    {
+    public:
+        pixfmt_rgb24_gamma(rendering_buffer& rb, const Gamma& g) :
+            pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_rgb, Gamma>, rendering_buffer, 3>(rb) 
+        {
+            this->blender().gamma(g);
+        }
+    };
+        
+    //-----------------------------------------------------pixfmt_srgb24_gamma
+    template<class Gamma> class pixfmt_srgb24_gamma : 
+    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<srgba8, order_rgb, Gamma>, rendering_buffer, 3>
+    {
+    public:
+        pixfmt_srgb24_gamma(rendering_buffer& rb, const Gamma& g) :
+            pixfmt_alpha_blend_rgb<blender_rgb_gamma<srgba8, order_rgb, Gamma>, rendering_buffer, 3>(rb) 
+        {
+            this->blender().gamma(g);
+        }
+    };
+        
+    //-----------------------------------------------------pixfmt_bgr24_gamma
+    template<class Gamma> class pixfmt_bgr24_gamma : 
+    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_bgr, Gamma>, rendering_buffer, 3>
+    {
+    public:
+        pixfmt_bgr24_gamma(rendering_buffer& rb, const Gamma& g) :
+            pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_bgr, Gamma>, rendering_buffer, 3>(rb) 
+        {
+            this->blender().gamma(g);
+        }
+    };
+
+    //-----------------------------------------------------pixfmt_sbgr24_gamma
+    template<class Gamma> class pixfmt_sbgr24_gamma : 
+    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<srgba8, order_bgr, Gamma>, rendering_buffer, 3>
+    {
+    public:
+        pixfmt_sbgr24_gamma(rendering_buffer& rb, const Gamma& g) :
+            pixfmt_alpha_blend_rgb<blender_rgb_gamma<srgba8, order_bgr, Gamma>, rendering_buffer, 3>(rb) 
+        {
+            this->blender().gamma(g);
+        }
+    };
+
+    //-----------------------------------------------------pixfmt_rgb48_gamma
+    template<class Gamma> class pixfmt_rgb48_gamma : 
+    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_rgb, Gamma>, rendering_buffer, 3>
+    {
+    public:
+        pixfmt_rgb48_gamma(rendering_buffer& rb, const Gamma& g) :
+            pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_rgb, Gamma>, rendering_buffer, 3>(rb) 
+        {
+            this->blender().gamma(g);
+        }
+    };
+        
+    //-----------------------------------------------------pixfmt_bgr48_gamma
+    template<class Gamma> class pixfmt_bgr48_gamma : 
+    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_bgr, Gamma>, rendering_buffer, 3>
+    {
+    public:
+        pixfmt_bgr48_gamma(rendering_buffer& rb, const Gamma& g) :
+            pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_bgr, Gamma>, rendering_buffer, 3>(rb) 
+        {
+            this->blender().gamma(g);
+        }
+    };
+    
+}
+
+#endif
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_pixfmt_rgba.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_pixfmt_rgba.h
new file mode 100644
index 0000000000..e9cd523b37
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_pixfmt_rgba.h
@@ -0,0 +1,2801 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Adaptation for high precision colors has been sponsored by 
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+// 
+//----------------------------------------------------------------------------
+
+#ifndef AGG_PIXFMT_RGBA_INCLUDED
+#define AGG_PIXFMT_RGBA_INCLUDED
+
+#include <string.h>
+#include <math.h>
+#include "agg_pixfmt_base.h"
+#include "agg_rendering_buffer.h"
+
+namespace agg
+{
+    template<class T> inline T sd_min(T a, T b) { return (a < b) ? a : b; }
+    template<class T> inline T sd_max(T a, T b) { return (a > b) ? a : b; }
+
+    inline rgba & clip(rgba & c)
+    {
+        if (c.a > 1) c.a = 1; else if (c.a < 0) c.a = 0;
+        if (c.r > c.a) c.r = c.a; else if (c.r < 0) c.r = 0;
+        if (c.g > c.a) c.g = c.a; else if (c.g < 0) c.g = 0;
+        if (c.b > c.a) c.b = c.a; else if (c.b < 0) c.b = 0;
+        return c;
+    }
+
+    //=========================================================multiplier_rgba
+    template<class ColorT, class Order> 
+    struct multiplier_rgba
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE void premultiply(value_type* p)
+        {
+            value_type a = p[Order::A];
+            p[Order::R] = color_type::multiply(p[Order::R], a);
+            p[Order::G] = color_type::multiply(p[Order::G], a);
+            p[Order::B] = color_type::multiply(p[Order::B], a);
+        }
+
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE void demultiply(value_type* p)
+        {
+            value_type a = p[Order::A];
+            p[Order::R] = color_type::demultiply(p[Order::R], a);
+            p[Order::G] = color_type::demultiply(p[Order::G], a);
+            p[Order::B] = color_type::demultiply(p[Order::B], a);
+        }
+    };
+
+    //=====================================================apply_gamma_dir_rgba
+    template<class ColorT, class Order, class GammaLut> 
+    class apply_gamma_dir_rgba
+    {
+    public:
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+
+        apply_gamma_dir_rgba(const GammaLut& gamma) : m_gamma(gamma) {}
+
+        AGG_INLINE void operator () (value_type* p)
+        {
+            p[Order::R] = m_gamma.dir(p[Order::R]);
+            p[Order::G] = m_gamma.dir(p[Order::G]);
+            p[Order::B] = m_gamma.dir(p[Order::B]);
+        }
+
+    private:
+        const GammaLut& m_gamma;
+    };
+
+    //=====================================================apply_gamma_inv_rgba
+    template<class ColorT, class Order, class GammaLut> class apply_gamma_inv_rgba
+    {
+    public:
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+
+        apply_gamma_inv_rgba(const GammaLut& gamma) : m_gamma(gamma) {}
+
+        AGG_INLINE void operator () (value_type* p)
+        {
+            p[Order::R] = m_gamma.inv(p[Order::R]);
+            p[Order::G] = m_gamma.inv(p[Order::G]);
+            p[Order::B] = m_gamma.inv(p[Order::B]);
+        }
+
+    private:
+        const GammaLut& m_gamma;
+    };
+
+
+    template<class ColorT, class Order> 
+    struct conv_rgba_pre
+    {
+        typedef ColorT color_type;
+        typedef Order order_type;
+        typedef typename color_type::value_type value_type;
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE void set_plain_color(value_type* p, color_type c)
+        {
+            c.premultiply();
+            p[Order::R] = c.r;
+            p[Order::G] = c.g;
+            p[Order::B] = c.b;
+            p[Order::A] = c.a;
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE color_type get_plain_color(const value_type* p)
+        {
+            return color_type(
+                p[Order::R],
+                p[Order::G],
+                p[Order::B],
+                p[Order::A]).demultiply();
+        }
+    };
+
+    template<class ColorT, class Order> 
+    struct conv_rgba_plain
+    {
+        typedef ColorT color_type;
+        typedef Order order_type;
+        typedef typename color_type::value_type value_type;
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE void set_plain_color(value_type* p, color_type c)
+        {
+            p[Order::R] = c.r;
+            p[Order::G] = c.g;
+            p[Order::B] = c.b;
+            p[Order::A] = c.a;
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE color_type get_plain_color(const value_type* p)
+        {
+            return color_type(
+                p[Order::R],
+                p[Order::G],
+                p[Order::B],
+                p[Order::A]);
+        }
+    };
+
+    //=============================================================blender_rgba
+    // Blends "plain" (i.e. non-premultiplied) colors into a premultiplied buffer.
+    template<class ColorT, class Order> 
+    struct blender_rgba : conv_rgba_pre<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef Order order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        // Blend pixels using the non-premultiplied form of Alvy-Ray Smith's
+        // compositing function. Since the render buffer is in fact premultiplied
+        // we omit the initial premultiplication and final demultiplication.
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type cr, value_type cg, value_type cb, value_type alpha, cover_type cover)
+        {
+            blend_pix(p, cr, cg, cb, color_type::mult_cover(alpha, cover));
+        }
+        
+        //--------------------------------------------------------------------
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type cr, value_type cg, value_type cb, value_type alpha)
+        {
+            p[Order::R] = color_type::lerp(p[Order::R], cr, alpha);
+            p[Order::G] = color_type::lerp(p[Order::G], cg, alpha);
+            p[Order::B] = color_type::lerp(p[Order::B], cb, alpha);
+            p[Order::A] = color_type::prelerp(p[Order::A], alpha, alpha);
+        }
+    };
+
+
+    //========================================================blender_rgba_pre
+    // Blends premultiplied colors into a premultiplied buffer.
+    template<class ColorT, class Order> 
+    struct blender_rgba_pre : conv_rgba_pre<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef Order order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        // Blend pixels using the premultiplied form of Alvy-Ray Smith's
+        // compositing function. 
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type cr, value_type cg, value_type cb, value_type alpha, cover_type cover)
+        {
+            blend_pix(p, 
+                color_type::mult_cover(cr, cover), 
+                color_type::mult_cover(cg, cover), 
+                color_type::mult_cover(cb, cover), 
+                color_type::mult_cover(alpha, cover));
+        }
+        
+        //--------------------------------------------------------------------
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type cr, value_type cg, value_type cb, value_type alpha)
+        {
+            p[Order::R] = color_type::prelerp(p[Order::R], cr, alpha);
+            p[Order::G] = color_type::prelerp(p[Order::G], cg, alpha);
+            p[Order::B] = color_type::prelerp(p[Order::B], cb, alpha);
+            p[Order::A] = color_type::prelerp(p[Order::A], alpha, alpha);
+        }
+    };
+
+    //======================================================blender_rgba_plain
+    // Blends "plain" (non-premultiplied) colors into a plain (non-premultiplied) buffer.
+    template<class ColorT, class Order> 
+    struct blender_rgba_plain : conv_rgba_plain<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef Order order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        // Blend pixels using the non-premultiplied form of Alvy-Ray Smith's
+        // compositing function. 
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type cr, value_type cg, value_type cb, value_type alpha, cover_type cover)
+        {
+            blend_pix(p, cr, cg, cb, color_type::mult_cover(alpha, cover));
+        }
+        
+        //--------------------------------------------------------------------
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type cr, value_type cg, value_type cb, value_type alpha)
+        {
+            if (alpha > color_type::empty_value())
+            {
+                calc_type a = p[Order::A];
+                calc_type r = color_type::multiply(p[Order::R], a);
+                calc_type g = color_type::multiply(p[Order::G], a);
+                calc_type b = color_type::multiply(p[Order::B], a);
+                p[Order::R] = color_type::lerp(r, cr, alpha);
+                p[Order::G] = color_type::lerp(g, cg, alpha);
+                p[Order::B] = color_type::lerp(b, cb, alpha);
+                p[Order::A] = color_type::prelerp(a, alpha, alpha);
+                multiplier_rgba<ColorT, Order>::demultiply(p);
+            }
+        }
+    };
+
+    // SVG compositing operations.
+    // For specifications, see http://www.w3.org/TR/SVGCompositing/
+
+    //=========================================================comp_op_rgba_clear
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_clear : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // Dca' = 0
+        // Da'  = 0
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            if (cover >= cover_full)
+            {
+                p[0] = p[1] = p[2] = p[3] = color_type::empty_value(); 
+            }
+            else if (cover > cover_none)
+            {
+                set(p, get(p, cover_full - cover));
+            }
+        }
+    };
+
+    //===========================================================comp_op_rgba_src
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_src : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // Dca' = Sca
+        // Da'  = Sa
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            if (cover >= cover_full)
+            {
+                set(p, r, g, b, a);
+            }
+            else
+            {
+                rgba s = get(r, g, b, a, cover);
+                rgba d = get(p, cover_full - cover);
+                d.r += s.r;
+                d.g += s.g;
+                d.b += s.b;
+                d.a += s.a;
+                set(p, d);
+            }
+        }
+    };
+
+    //===========================================================comp_op_rgba_dst
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_dst : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+
+        // Dca' = Dca.Sa + Dca.(1 - Sa) = Dca
+        // Da'  = Da.Sa + Da.(1 - Sa) = Da
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            // Well, that was easy!
+        }
+    };
+
+    //======================================================comp_op_rgba_src_over
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_src_over : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // Dca' = Sca + Dca.(1 - Sa) = Dca + Sca - Dca.Sa
+        // Da'  = Sa + Da - Sa.Da 
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+#if 1
+            blender_rgba_pre<ColorT, Order>::blend_pix(p, r, g, b, a, cover);
+#else
+            rgba s = get(r, g, b, a, cover);
+            rgba d = get(p);
+            d.r += s.r - d.r * s.a;
+            d.g += s.g - d.g * s.a;
+            d.b += s.b - d.b * s.a;
+            d.a += s.a - d.a * s.a;
+            set(p, d);
+#endif
+        }
+    };
+
+    //======================================================comp_op_rgba_dst_over
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_dst_over : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // Dca' = Dca + Sca.(1 - Da)
+        // Da'  = Sa + Da - Sa.Da = Da + Sa.(1 - Da)
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            rgba s = get(r, g, b, a, cover);
+            rgba d = get(p);
+            double d1a = 1 - d.a;
+            d.r += s.r * d1a;
+            d.g += s.g * d1a;
+            d.b += s.b * d1a;
+            d.a += s.a * d1a;
+            set(p, d);
+        }
+    };
+
+    //======================================================comp_op_rgba_src_in
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_src_in : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // Dca' = Sca.Da
+        // Da'  = Sa.Da 
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            double da = ColorT::to_double(p[Order::A]);
+            if (da > 0)
+            {
+                rgba s = get(r, g, b, a, cover);
+                rgba d = get(p, cover_full - cover);
+                d.r += s.r * da;
+                d.g += s.g * da;
+                d.b += s.b * da;
+                d.a += s.a * da;
+                set(p, d);
+            }
+        }
+    };
+
+    //======================================================comp_op_rgba_dst_in
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_dst_in : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // Dca' = Dca.Sa
+        // Da'  = Sa.Da 
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            double sa = ColorT::to_double(a);
+            rgba d = get(p, cover_full - cover);
+            rgba d2 = get(p, cover);
+            d.r += d2.r * sa;
+            d.g += d2.g * sa;
+            d.b += d2.b * sa;
+            d.a += d2.a * sa;
+            set(p, d);
+        }
+    };
+
+    //======================================================comp_op_rgba_src_out
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_src_out : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // Dca' = Sca.(1 - Da)
+        // Da'  = Sa.(1 - Da) 
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            rgba s = get(r, g, b, a, cover);
+            rgba d = get(p, cover_full - cover);
+            double d1a = 1 - ColorT::to_double(p[Order::A]);
+            d.r += s.r * d1a;
+            d.g += s.g * d1a;
+            d.b += s.b * d1a;
+            d.a += s.a * d1a;
+            set(p, d);
+        }
+    };
+
+    //======================================================comp_op_rgba_dst_out
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_dst_out : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // Dca' = Dca.(1 - Sa) 
+        // Da'  = Da.(1 - Sa) 
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            rgba d = get(p, cover_full - cover);
+            rgba dc = get(p, cover);
+            double s1a = 1 - ColorT::to_double(a);
+            d.r += dc.r * s1a;
+            d.g += dc.g * s1a;
+            d.b += dc.b * s1a;
+            d.a += dc.a * s1a;
+            set(p, d);
+        }
+    };
+
+    //=====================================================comp_op_rgba_src_atop
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_src_atop : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // Dca' = Sca.Da + Dca.(1 - Sa)
+        // Da'  = Da
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            rgba s = get(r, g, b, a, cover);
+            rgba d = get(p);
+            double s1a = 1 - s.a;
+            d.r = s.r * d.a + d.r * s1a;
+            d.g = s.g * d.a + d.g * s1a;
+            d.b = s.b * d.a + d.g * s1a;
+            set(p, d);
+        }
+    };
+
+    //=====================================================comp_op_rgba_dst_atop
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_dst_atop : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // Dca' = Dca.Sa + Sca.(1 - Da)
+        // Da'  = Sa 
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            rgba sc = get(r, g, b, a, cover);
+            rgba dc = get(p, cover);
+            rgba d = get(p, cover_full - cover);
+            double sa = ColorT::to_double(a);
+            double d1a = 1 - ColorT::to_double(p[Order::A]);
+            d.r += dc.r * sa + sc.r * d1a;
+            d.g += dc.g * sa + sc.g * d1a;
+            d.b += dc.b * sa + sc.b * d1a;
+            d.a += sc.a;
+            set(p, d);
+        }
+    };
+
+    //=========================================================comp_op_rgba_xor
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_xor : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // Dca' = Sca.(1 - Da) + Dca.(1 - Sa)
+        // Da'  = Sa + Da - 2.Sa.Da 
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            rgba s = get(r, g, b, a, cover);
+            rgba d = get(p);
+            double s1a = 1 - s.a;
+            double d1a = 1 - ColorT::to_double(p[Order::A]);
+            d.r = s.r * d1a + d.r * s1a;
+            d.g = s.g * d1a + d.g * s1a;
+            d.b = s.b * d1a + d.b * s1a;
+            d.a = s.a + d.a - 2 * s.a * d.a;
+            set(p, d);
+        }
+    };
+
+    //=========================================================comp_op_rgba_plus
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_plus : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // Dca' = Sca + Dca
+        // Da'  = Sa + Da 
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            rgba s = get(r, g, b, a, cover);
+            if (s.a > 0)
+            {
+                rgba d = get(p);
+                d.a = sd_min(d.a + s.a, 1.0);
+                d.r = sd_min(d.r + s.r, d.a);
+                d.g = sd_min(d.g + s.g, d.a);
+                d.b = sd_min(d.b + s.b, d.a);
+                set(p, clip(d));
+            }
+        }
+    };
+
+    //========================================================comp_op_rgba_minus
+    // Note: not included in SVG spec.
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_minus : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // Dca' = Dca - Sca
+        // Da' = 1 - (1 - Sa).(1 - Da) = Da + Sa - Sa.Da
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            rgba s = get(r, g, b, a, cover);
+            if (s.a > 0)
+            {
+                rgba d = get(p);
+                d.a += s.a - s.a * d.a;
+                d.r = sd_max(d.r - s.r, 0.0);
+                d.g = sd_max(d.g - s.g, 0.0);
+                d.b = sd_max(d.b - s.b, 0.0);
+                set(p, clip(d));
+            }
+        }
+    };
+
+    //=====================================================comp_op_rgba_multiply
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_multiply : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // Dca' = Sca.Dca + Sca.(1 - Da) + Dca.(1 - Sa)
+        // Da'  = Sa + Da - Sa.Da 
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            rgba s = get(r, g, b, a, cover);
+            if (s.a > 0)
+            {
+                rgba d = get(p);
+                double s1a = 1 - s.a;
+                double d1a = 1 - d.a;
+                d.r = s.r * d.r + s.r * d1a + d.r * s1a;
+                d.g = s.g * d.g + s.g * d1a + d.g * s1a;
+                d.b = s.b * d.b + s.b * d1a + d.b * s1a;
+                d.a += s.a - s.a * d.a;
+                set(p, clip(d));
+            }
+        }
+    };
+
+    //=====================================================comp_op_rgba_screen
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_screen : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // Dca' = Sca + Dca - Sca.Dca
+        // Da'  = Sa + Da - Sa.Da 
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            rgba s = get(r, g, b, a, cover);
+            if (s.a > 0)
+            {
+                rgba d = get(p);
+                d.r += s.r - s.r * d.r;
+                d.g += s.g - s.g * d.g;
+                d.b += s.b - s.b * d.b;
+                d.a += s.a - s.a * d.a;
+                set(p, clip(d));
+            }
+        }
+    };
+
+    //=====================================================comp_op_rgba_overlay
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_overlay : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // if 2.Dca <= Da
+        //   Dca' = 2.Sca.Dca + Sca.(1 - Da) + Dca.(1 - Sa)
+        // otherwise
+        //   Dca' = Sa.Da - 2.(Da - Dca).(Sa - Sca) + Sca.(1 - Da) + Dca.(1 - Sa)
+        // 
+        // Da' = Sa + Da - Sa.Da
+        static AGG_INLINE double calc(double dca, double sca, double da, double sa, double sada, double d1a, double s1a)
+        {
+            return (2 * dca <= da) ? 
+                2 * sca * dca + sca * d1a + dca * s1a : 
+                sada - 2 * (da - dca) * (sa - sca) + sca * d1a + dca * s1a;
+        }
+
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            rgba s = get(r, g, b, a, cover);
+            if (s.a > 0)
+            {
+                rgba d = get(p);
+                double d1a = 1 - d.a;
+                double s1a = 1 - s.a;
+                double sada = s.a * d.a;
+                d.r = calc(d.r, s.r, d.a, s.a, sada, d1a, s1a);
+                d.g = calc(d.g, s.g, d.a, s.a, sada, d1a, s1a);
+                d.b = calc(d.b, s.b, d.a, s.a, sada, d1a, s1a);
+                d.a += s.a - s.a * d.a;
+                set(p, clip(d));
+            }
+        }
+    };
+
+    //=====================================================comp_op_rgba_darken
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_darken : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // Dca' = min(Sca.Da, Dca.Sa) + Sca.(1 - Da) + Dca.(1 - Sa)
+        // Da'  = Sa + Da - Sa.Da 
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            rgba s = get(r, g, b, a, cover);
+            if (s.a > 0)
+            {
+                rgba d = get(p);
+                double d1a = 1 - d.a;
+                double s1a = 1 - s.a;
+                d.r = sd_min(s.r * d.a, d.r * s.a) + s.r * d1a + d.r * s1a;
+                d.g = sd_min(s.g * d.a, d.g * s.a) + s.g * d1a + d.g * s1a;
+                d.b = sd_min(s.b * d.a, d.b * s.a) + s.b * d1a + d.b * s1a;
+                d.a += s.a - s.a * d.a;
+                set(p, clip(d));
+            }
+        }
+    };
+
+    //=====================================================comp_op_rgba_lighten
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_lighten : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // Dca' = max(Sca.Da, Dca.Sa) + Sca.(1 - Da) + Dca.(1 - Sa)
+        // Da'  = Sa + Da - Sa.Da 
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            rgba s = get(r, g, b, a, cover);
+            if (s.a > 0)
+            {
+                rgba d = get(p);
+                double d1a = 1 - d.a;
+                double s1a = 1 - s.a;
+                d.r = sd_max(s.r * d.a, d.r * s.a) + s.r * d1a + d.r * s1a;
+                d.g = sd_max(s.g * d.a, d.g * s.a) + s.g * d1a + d.g * s1a;
+                d.b = sd_max(s.b * d.a, d.b * s.a) + s.b * d1a + d.b * s1a;
+                d.a += s.a - s.a * d.a;
+                set(p, clip(d));
+            }
+        }
+    };
+
+    //=====================================================comp_op_rgba_color_dodge
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_color_dodge : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // if Sca == Sa and Dca == 0
+        //     Dca' = Sca.(1 - Da) + Dca.(1 - Sa) = Sca.(1 - Da)
+        // otherwise if Sca == Sa
+        //     Dca' = Sa.Da + Sca.(1 - Da) + Dca.(1 - Sa)
+        // otherwise if Sca < Sa
+        //     Dca' = Sa.Da.min(1, Dca/Da.Sa/(Sa - Sca)) + Sca.(1 - Da) + Dca.(1 - Sa)
+        //
+        // Da'  = Sa + Da - Sa.Da
+        static AGG_INLINE double calc(double dca, double sca, double da, double sa, double sada, double d1a, double s1a)
+        {
+            if (sca < sa) return sada * sd_min(1.0, (dca / da) * sa / (sa - sca)) + sca * d1a + dca * s1a;
+            if (dca > 0) return sada + sca * d1a + dca * s1a;
+            return sca * d1a;
+        }
+
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            rgba s = get(r, g, b, a, cover);
+            if (s.a > 0)
+            {
+                rgba d = get(p);
+                if (d.a > 0)
+                {
+                    double sada = s.a * d.a;
+                    double s1a = 1 - s.a;
+                    double d1a = 1 - d.a;
+                    d.r = calc(d.r, s.r, d.a, s.a, sada, d1a, s1a);
+                    d.g = calc(d.g, s.g, d.a, s.a, sada, d1a, s1a);
+                    d.b = calc(d.b, s.b, d.a, s.a, sada, d1a, s1a);
+                    d.a += s.a - s.a * d.a;
+                    set(p, clip(d));
+                }
+                else set(p, s);
+            }
+        }
+    };
+
+    //=====================================================comp_op_rgba_color_burn
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_color_burn : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // if Sca == 0 and Dca == Da
+        //   Dca' = Sa.Da + Dca.(1 - Sa)
+        // otherwise if Sca == 0
+        //   Dca' = Dca.(1 - Sa)
+        // otherwise if Sca > 0
+        //   Dca' =  Sa.Da.(1 - min(1, (1 - Dca/Da).Sa/Sca)) + Sca.(1 - Da) + Dca.(1 - Sa)
+        static AGG_INLINE double calc(double dca, double sca, double da, double sa, double sada, double d1a, double s1a)
+        {
+            if (sca > 0) return sada * (1 - sd_min(1.0, (1 - dca / da) * sa / sca)) + sca * d1a + dca * s1a;
+            if (dca > da) return sada + dca * s1a;
+            return dca * s1a;
+        }
+
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            rgba s = get(r, g, b, a, cover);
+            if (s.a > 0)
+            {
+                rgba d = get(p);
+                if (d.a > 0)
+                {
+                    double sada = s.a * d.a;
+                    double s1a = 1 - s.a;
+                    double d1a = 1 - d.a;
+                    d.r = calc(d.r, s.r, d.a, s.a, sada, d1a, s1a);
+                    d.g = calc(d.g, s.g, d.a, s.a, sada, d1a, s1a);
+                    d.b = calc(d.b, s.b, d.a, s.a, sada, d1a, s1a);
+                    d.a += s.a - sada;
+                    set(p, clip(d));
+                }
+                else set(p, s);
+            }
+        }
+    };
+
+    //=====================================================comp_op_rgba_hard_light
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_hard_light : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // if 2.Sca < Sa
+        //    Dca' = 2.Sca.Dca + Sca.(1 - Da) + Dca.(1 - Sa)
+        // otherwise
+        //    Dca' = Sa.Da - 2.(Da - Dca).(Sa - Sca) + Sca.(1 - Da) + Dca.(1 - Sa)
+        // 
+        // Da'  = Sa + Da - Sa.Da
+        static AGG_INLINE double calc(double dca, double sca, double da, double sa, double sada, double d1a, double s1a)
+        {
+            return (2 * sca < sa) ? 
+                2 * sca * dca + sca * d1a + dca * s1a : 
+                sada - 2 * (da - dca) * (sa - sca) + sca * d1a + dca * s1a;
+        }
+
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            rgba s = get(r, g, b, a, cover);
+            if (s.a > 0)
+            {
+                rgba d = get(p);
+                double d1a = 1 - d.a;
+                double s1a = 1 - s.a;
+                double sada = s.a * d.a;
+                d.r = calc(d.r, s.r, d.a, s.a, sada, d1a, s1a);
+                d.g = calc(d.g, s.g, d.a, s.a, sada, d1a, s1a);
+                d.b = calc(d.b, s.b, d.a, s.a, sada, d1a, s1a);
+                d.a += s.a - sada;
+                set(p, clip(d));
+            }
+        }
+    };
+
+    //=====================================================comp_op_rgba_soft_light
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_soft_light : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // if 2.Sca <= Sa
+        //   Dca' = Dca.Sa - (Sa.Da - 2.Sca.Da).Dca.Sa.(Sa.Da - Dca.Sa) + Sca.(1 - Da) + Dca.(1 - Sa)
+        // otherwise if 2.Sca > Sa and 4.Dca <= Da
+        //   Dca' = Dca.Sa + (2.Sca.Da - Sa.Da).((((16.Dsa.Sa - 12).Dsa.Sa + 4).Dsa.Da) - Dsa.Da) + Sca.(1 - Da) + Dca.(1 - Sa)
+        // otherwise if 2.Sca > Sa and 4.Dca > Da
+        //   Dca' = Dca.Sa + (2.Sca.Da - Sa.Da).((Dca.Sa)^0.5 - Dca.Sa) + Sca.(1 - Da) + Dca.(1 - Sa)
+        // 
+        // Da'  = Sa + Da - Sa.Da 
+        static AGG_INLINE double calc(double dca, double sca, double da, double sa, double sada, double d1a, double s1a)
+        {
+            double dcasa = dca * sa;
+            if (2 * sca <= sa) return dcasa - (sada - 2 * sca * da) * dcasa * (sada - dcasa) + sca * d1a + dca * s1a;
+            if (4 * dca <= da) return dcasa + (2 * sca * da - sada) * ((((16 * dcasa - 12) * dcasa + 4) * dca * da) - dca * da) + sca * d1a + dca * s1a;
+            return dcasa + (2 * sca * da - sada) * (sqrt(dcasa) - dcasa) + sca * d1a + dca * s1a;
+        }
+
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            rgba s = get(r, g, b, a, cover);
+            if (s.a > 0)
+            {
+                rgba d = get(p);
+                if (d.a > 0)
+                {
+                    double sada = s.a * d.a;
+                    double s1a = 1 - s.a;
+                    double d1a = 1 - d.a;
+                    d.r = calc(d.r, s.r, d.a, s.a, sada, d1a, s1a);
+                    d.g = calc(d.g, s.g, d.a, s.a, sada, d1a, s1a);
+                    d.b = calc(d.b, s.b, d.a, s.a, sada, d1a, s1a);
+                    d.a += s.a - sada;
+                    set(p, clip(d));
+                }
+                else set(p, s);
+            }
+        }
+    };
+
+    //=====================================================comp_op_rgba_difference
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_difference : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // Dca' = Sca + Dca - 2.min(Sca.Da, Dca.Sa)
+        // Da'  = Sa + Da - Sa.Da 
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            rgba s = get(r, g, b, a, cover);
+            if (s.a > 0)
+            {
+                rgba d = get(p);
+                d.r += s.r - 2 * sd_min(s.r * d.a, d.r * s.a);
+                d.g += s.g - 2 * sd_min(s.g * d.a, d.g * s.a);
+                d.b += s.b - 2 * sd_min(s.b * d.a, d.b * s.a);
+                d.a += s.a - s.a * d.a;
+                set(p, clip(d));
+            }
+        }
+    };
+
+    //=====================================================comp_op_rgba_exclusion
+    template<class ColorT, class Order> 
+    struct comp_op_rgba_exclusion : blender_base<ColorT, Order>
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        using blender_base<ColorT, Order>::get;
+        using blender_base<ColorT, Order>::set;
+
+        // Dca' = (Sca.Da + Dca.Sa - 2.Sca.Dca) + Sca.(1 - Da) + Dca.(1 - Sa)
+        // Da'  = Sa + Da - Sa.Da 
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            rgba s = get(r, g, b, a, cover);
+            if (s.a > 0)
+            {
+                rgba d = get(p);
+                double d1a = 1 - d.a;
+                double s1a = 1 - s.a;
+                d.r = (s.r * d.a + d.r * s.a - 2 * s.r * d.r) + s.r * d1a + d.r * s1a;
+                d.g = (s.g * d.a + d.g * s.a - 2 * s.g * d.g) + s.g * d1a + d.g * s1a;
+                d.b = (s.b * d.a + d.b * s.a - 2 * s.b * d.b) + s.b * d1a + d.b * s1a;
+                d.a += s.a - s.a * d.a;
+                set(p, clip(d));
+            }
+        }
+    };
+
+#if 0
+    //=====================================================comp_op_rgba_contrast
+    template<class ColorT, class Order> struct comp_op_rgba_contrast
+    {
+        typedef ColorT color_type;
+        typedef Order order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+        enum base_scale_e
+        { 
+            base_shift = color_type::base_shift,
+            base_mask  = color_type::base_mask
+        };
+
+
+        static AGG_INLINE void blend_pix(value_type* p, 
+                                         unsigned sr, unsigned sg, unsigned sb, 
+                                         unsigned sa, unsigned cover)
+        {
+            if (cover < 255)
+            {
+                sr = (sr * cover + 255) >> 8;
+                sg = (sg * cover + 255) >> 8;
+                sb = (sb * cover + 255) >> 8;
+                sa = (sa * cover + 255) >> 8;
+            }
+            long_type dr = p[Order::R];
+            long_type dg = p[Order::G];
+            long_type db = p[Order::B];
+            int       da = p[Order::A];
+            long_type d2a = da >> 1;
+            unsigned s2a = sa >> 1;
+
+            int r = (int)((((dr - d2a) * int((sr - s2a)*2 + base_mask)) >> base_shift) + d2a); 
+            int g = (int)((((dg - d2a) * int((sg - s2a)*2 + base_mask)) >> base_shift) + d2a); 
+            int b = (int)((((db - d2a) * int((sb - s2a)*2 + base_mask)) >> base_shift) + d2a); 
+
+            r = (r < 0) ? 0 : r;
+            g = (g < 0) ? 0 : g;
+            b = (b < 0) ? 0 : b;
+
+            p[Order::R] = (value_type)((r > da) ? da : r);
+            p[Order::G] = (value_type)((g > da) ? da : g);
+            p[Order::B] = (value_type)((b > da) ? da : b);
+        }
+    };
+
+    //=====================================================comp_op_rgba_invert
+    template<class ColorT, class Order> struct comp_op_rgba_invert
+    {
+        typedef ColorT color_type;
+        typedef Order order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+        enum base_scale_e
+        { 
+            base_shift = color_type::base_shift,
+            base_mask  = color_type::base_mask
+        };
+
+        // Dca' = (Da - Dca) * Sa + Dca.(1 - Sa)
+        // Da'  = Sa + Da - Sa.Da 
+        static AGG_INLINE void blend_pix(value_type* p, 
+                                         unsigned sr, unsigned sg, unsigned sb, 
+                                         unsigned sa, unsigned cover)
+        {
+            sa = (sa * cover + 255) >> 8;
+            if (sa)
+            {
+                calc_type da = p[Order::A];
+                calc_type dr = ((da - p[Order::R]) * sa + base_mask) >> base_shift;
+                calc_type dg = ((da - p[Order::G]) * sa + base_mask) >> base_shift;
+                calc_type db = ((da - p[Order::B]) * sa + base_mask) >> base_shift;
+                calc_type s1a = base_mask - sa;
+                p[Order::R] = (value_type)(dr + ((p[Order::R] * s1a + base_mask) >> base_shift));
+                p[Order::G] = (value_type)(dg + ((p[Order::G] * s1a + base_mask) >> base_shift));
+                p[Order::B] = (value_type)(db + ((p[Order::B] * s1a + base_mask) >> base_shift));
+                p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
+            }
+        }
+    };
+
+    //=================================================comp_op_rgba_invert_rgb
+    template<class ColorT, class Order> struct comp_op_rgba_invert_rgb
+    {
+        typedef ColorT color_type;
+        typedef Order order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+        enum base_scale_e
+        { 
+            base_shift = color_type::base_shift,
+            base_mask  = color_type::base_mask
+        };
+
+        // Dca' = (Da - Dca) * Sca + Dca.(1 - Sa)
+        // Da'  = Sa + Da - Sa.Da 
+        static AGG_INLINE void blend_pix(value_type* p, 
+                                         unsigned sr, unsigned sg, unsigned sb, 
+                                         unsigned sa, unsigned cover)
+        {
+            if (cover < 255)
+            {
+                sr = (sr * cover + 255) >> 8;
+                sg = (sg * cover + 255) >> 8;
+                sb = (sb * cover + 255) >> 8;
+                sa = (sa * cover + 255) >> 8;
+            }
+            if (sa)
+            {
+                calc_type da = p[Order::A];
+                calc_type dr = ((da - p[Order::R]) * sr + base_mask) >> base_shift;
+                calc_type dg = ((da - p[Order::G]) * sg + base_mask) >> base_shift;
+                calc_type db = ((da - p[Order::B]) * sb + base_mask) >> base_shift;
+                calc_type s1a = base_mask - sa;
+                p[Order::R] = (value_type)(dr + ((p[Order::R] * s1a + base_mask) >> base_shift));
+                p[Order::G] = (value_type)(dg + ((p[Order::G] * s1a + base_mask) >> base_shift));
+                p[Order::B] = (value_type)(db + ((p[Order::B] * s1a + base_mask) >> base_shift));
+                p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
+            }
+        }
+    };
+#endif
+
+
+    //======================================================comp_op_table_rgba
+    template<class ColorT, class Order> struct comp_op_table_rgba
+    {
+        typedef typename ColorT::value_type value_type;
+        typedef typename ColorT::calc_type calc_type;
+        typedef void (*comp_op_func_type)(value_type* p, 
+                                          value_type cr, 
+                                          value_type cg, 
+                                          value_type cb,
+                                          value_type ca,
+                                          cover_type cover);
+        static comp_op_func_type g_comp_op_func[];
+    };
+
+    //==========================================================g_comp_op_func
+    template<class ColorT, class Order> 
+    typename comp_op_table_rgba<ColorT, Order>::comp_op_func_type
+    comp_op_table_rgba<ColorT, Order>::g_comp_op_func[] = 
+    {
+        comp_op_rgba_clear      <ColorT,Order>::blend_pix,
+        comp_op_rgba_src        <ColorT,Order>::blend_pix,
+        comp_op_rgba_dst        <ColorT,Order>::blend_pix,
+        comp_op_rgba_src_over   <ColorT,Order>::blend_pix,
+        comp_op_rgba_dst_over   <ColorT,Order>::blend_pix,
+        comp_op_rgba_src_in     <ColorT,Order>::blend_pix,
+        comp_op_rgba_dst_in     <ColorT,Order>::blend_pix,
+        comp_op_rgba_src_out    <ColorT,Order>::blend_pix,
+        comp_op_rgba_dst_out    <ColorT,Order>::blend_pix,
+        comp_op_rgba_src_atop   <ColorT,Order>::blend_pix,
+        comp_op_rgba_dst_atop   <ColorT,Order>::blend_pix,
+        comp_op_rgba_xor        <ColorT,Order>::blend_pix,
+        comp_op_rgba_plus       <ColorT,Order>::blend_pix,
+        //comp_op_rgba_minus      <ColorT,Order>::blend_pix,
+        comp_op_rgba_multiply   <ColorT,Order>::blend_pix,
+        comp_op_rgba_screen     <ColorT,Order>::blend_pix,
+        comp_op_rgba_overlay    <ColorT,Order>::blend_pix,
+        comp_op_rgba_darken     <ColorT,Order>::blend_pix,
+        comp_op_rgba_lighten    <ColorT,Order>::blend_pix,
+        comp_op_rgba_color_dodge<ColorT,Order>::blend_pix,
+        comp_op_rgba_color_burn <ColorT,Order>::blend_pix,
+        comp_op_rgba_hard_light <ColorT,Order>::blend_pix,
+        comp_op_rgba_soft_light <ColorT,Order>::blend_pix,
+        comp_op_rgba_difference <ColorT,Order>::blend_pix,
+        comp_op_rgba_exclusion  <ColorT,Order>::blend_pix,
+        //comp_op_rgba_contrast   <ColorT,Order>::blend_pix,
+        //comp_op_rgba_invert     <ColorT,Order>::blend_pix,
+        //comp_op_rgba_invert_rgb <ColorT,Order>::blend_pix,
+        0
+    };
+
+
+    //==============================================================comp_op_e
+    enum comp_op_e
+    {
+        comp_op_clear,         //----comp_op_clear
+        comp_op_src,           //----comp_op_src
+        comp_op_dst,           //----comp_op_dst
+        comp_op_src_over,      //----comp_op_src_over
+        comp_op_dst_over,      //----comp_op_dst_over
+        comp_op_src_in,        //----comp_op_src_in
+        comp_op_dst_in,        //----comp_op_dst_in
+        comp_op_src_out,       //----comp_op_src_out
+        comp_op_dst_out,       //----comp_op_dst_out
+        comp_op_src_atop,      //----comp_op_src_atop
+        comp_op_dst_atop,      //----comp_op_dst_atop
+        comp_op_xor,           //----comp_op_xor
+        comp_op_plus,          //----comp_op_plus
+        //comp_op_minus,         //----comp_op_minus
+        comp_op_multiply,      //----comp_op_multiply
+        comp_op_screen,        //----comp_op_screen
+        comp_op_overlay,       //----comp_op_overlay
+        comp_op_darken,        //----comp_op_darken
+        comp_op_lighten,       //----comp_op_lighten
+        comp_op_color_dodge,   //----comp_op_color_dodge
+        comp_op_color_burn,    //----comp_op_color_burn
+        comp_op_hard_light,    //----comp_op_hard_light
+        comp_op_soft_light,    //----comp_op_soft_light
+        comp_op_difference,    //----comp_op_difference
+        comp_op_exclusion,     //----comp_op_exclusion
+        //comp_op_contrast,      //----comp_op_contrast
+        //comp_op_invert,        //----comp_op_invert
+        //comp_op_invert_rgb,    //----comp_op_invert_rgb
+
+        end_of_comp_op_e
+    };
+
+
+
+
+
+
+
+    //====================================================comp_op_adaptor_rgba
+    template<class ColorT, class Order> 
+    struct comp_op_adaptor_rgba
+    {
+        typedef ColorT color_type;
+        typedef Order order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        static AGG_INLINE void blend_pix(unsigned op, value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            comp_op_table_rgba<ColorT, Order>::g_comp_op_func[op](p, 
+                color_type::multiply(r, a), 
+                color_type::multiply(g, a), 
+                color_type::multiply(b, a), 
+                a, cover);
+        }
+    };
+
+    //=========================================comp_op_adaptor_clip_to_dst_rgba
+    template<class ColorT, class Order> 
+    struct comp_op_adaptor_clip_to_dst_rgba
+    {
+        typedef ColorT color_type;
+        typedef Order order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        static AGG_INLINE void blend_pix(unsigned op, value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            r = color_type::multiply(r, a);
+            g = color_type::multiply(g, a);
+            b = color_type::multiply(b, a);
+            value_type da = p[Order::A];
+            comp_op_table_rgba<ColorT, Order>::g_comp_op_func[op](p, 
+                color_type::multiply(r, da), 
+                color_type::multiply(g, da), 
+                color_type::multiply(b, da), 
+                color_type::multiply(a, da), cover);
+        }
+    };
+
+    //================================================comp_op_adaptor_rgba_pre
+    template<class ColorT, class Order> 
+    struct comp_op_adaptor_rgba_pre
+    {
+        typedef ColorT color_type;
+        typedef Order order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        static AGG_INLINE void blend_pix(unsigned op, value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            comp_op_table_rgba<ColorT, Order>::g_comp_op_func[op](p, r, g, b, a, cover);
+        }
+    };
+
+    //=====================================comp_op_adaptor_clip_to_dst_rgba_pre
+    template<class ColorT, class Order> 
+    struct comp_op_adaptor_clip_to_dst_rgba_pre
+    {
+        typedef ColorT color_type;
+        typedef Order order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        static AGG_INLINE void blend_pix(unsigned op, value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            value_type da = p[Order::A];
+            comp_op_table_rgba<ColorT, Order>::g_comp_op_func[op](p, 
+                color_type::multiply(r, da), 
+                color_type::multiply(g, da), 
+                color_type::multiply(b, da), 
+                color_type::multiply(a, da), cover);
+        }
+    };
+
+    //====================================================comp_op_adaptor_rgba_plain
+    template<class ColorT, class Order> 
+    struct comp_op_adaptor_rgba_plain
+    {
+        typedef ColorT color_type;
+        typedef Order order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        static AGG_INLINE void blend_pix(unsigned op, value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            multiplier_rgba<ColorT, Order>::premultiply(p);
+            comp_op_adaptor_rgba<ColorT, Order>::blend_pix(op, p, r, g, b, a, cover);
+            multiplier_rgba<ColorT, Order>::demultiply(p);
+        }
+    };
+
+    //=========================================comp_op_adaptor_clip_to_dst_rgba_plain
+    template<class ColorT, class Order> 
+    struct comp_op_adaptor_clip_to_dst_rgba_plain
+    {
+        typedef ColorT color_type;
+        typedef Order order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        static AGG_INLINE void blend_pix(unsigned op, value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            multiplier_rgba<ColorT, Order>::premultiply(p);
+            comp_op_adaptor_clip_to_dst_rgba<ColorT, Order>::blend_pix(op, p, r, g, b, a, cover);
+            multiplier_rgba<ColorT, Order>::demultiply(p);
+        }
+    };
+
+    //=======================================================comp_adaptor_rgba
+    template<class BlenderPre> 
+    struct comp_adaptor_rgba
+    {
+        typedef typename BlenderPre::color_type color_type;
+        typedef typename BlenderPre::order_type order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        static AGG_INLINE void blend_pix(unsigned op, value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            BlenderPre::blend_pix(p, 
+                color_type::multiply(r, a), 
+                color_type::multiply(g, a), 
+                color_type::multiply(b, a), 
+                a, cover);
+        }
+    };
+
+    //==========================================comp_adaptor_clip_to_dst_rgba
+    template<class BlenderPre> 
+    struct comp_adaptor_clip_to_dst_rgba
+    {
+        typedef typename BlenderPre::color_type color_type;
+        typedef typename BlenderPre::order_type order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        static AGG_INLINE void blend_pix(unsigned op, value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            r = color_type::multiply(r, a);
+            g = color_type::multiply(g, a);
+            b = color_type::multiply(b, a);
+            value_type da = p[order_type::A];
+            BlenderPre::blend_pix(p, 
+                color_type::multiply(r, da), 
+                color_type::multiply(g, da), 
+                color_type::multiply(b, da), 
+                color_type::multiply(a, da), cover);
+        }
+    };
+
+    //=======================================================comp_adaptor_rgba_pre
+    template<class BlenderPre> 
+    struct comp_adaptor_rgba_pre
+    {
+        typedef typename BlenderPre::color_type color_type;
+        typedef typename BlenderPre::order_type order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        static AGG_INLINE void blend_pix(unsigned op, value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            BlenderPre::blend_pix(p, r, g, b, a, cover);
+        }
+    };
+
+    //======================================comp_adaptor_clip_to_dst_rgba_pre
+    template<class BlenderPre> 
+    struct comp_adaptor_clip_to_dst_rgba_pre
+    {
+        typedef typename BlenderPre::color_type color_type;
+        typedef typename BlenderPre::order_type order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        static AGG_INLINE void blend_pix(unsigned op, value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            unsigned da = p[order_type::A];
+            BlenderPre::blend_pix(p, 
+                color_type::multiply(r, da), 
+                color_type::multiply(g, da), 
+                color_type::multiply(b, da), 
+                color_type::multiply(a, da), 
+                cover);
+        }
+    };
+
+    //=======================================================comp_adaptor_rgba_plain
+    template<class BlenderPre> 
+    struct comp_adaptor_rgba_plain
+    {
+        typedef typename BlenderPre::color_type color_type;
+        typedef typename BlenderPre::order_type order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        static AGG_INLINE void blend_pix(unsigned op, value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            multiplier_rgba<color_type, order_type>::premultiply(p);
+            comp_adaptor_rgba<BlenderPre>::blend_pix(op, p, r, g, b, a, cover);
+            multiplier_rgba<color_type, order_type>::demultiply(p);
+        }
+    };
+
+    //==========================================comp_adaptor_clip_to_dst_rgba_plain
+    template<class BlenderPre> 
+    struct comp_adaptor_clip_to_dst_rgba_plain
+    {
+        typedef typename BlenderPre::color_type color_type;
+        typedef typename BlenderPre::order_type order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        static AGG_INLINE void blend_pix(unsigned op, value_type* p, 
+            value_type r, value_type g, value_type b, value_type a, cover_type cover)
+        {
+            multiplier_rgba<color_type, order_type>::premultiply(p);
+            comp_adaptor_clip_to_dst_rgba<BlenderPre>::blend_pix(op, p, r, g, b, a, cover);
+            multiplier_rgba<color_type, order_type>::demultiply(p);
+        }
+    };
+
+
+    //=================================================pixfmt_alpha_blend_rgba
+    template<class Blender, class RenBuf> 
+    class pixfmt_alpha_blend_rgba
+    {
+    public:
+        typedef pixfmt_rgba_tag pixfmt_category;
+        typedef RenBuf   rbuf_type;
+        typedef typename rbuf_type::row_data row_data;
+        typedef Blender  blender_type;
+        typedef typename blender_type::color_type color_type;
+        typedef typename blender_type::order_type order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        enum 
+        {
+            pix_step = 4,
+            pix_width = sizeof(value_type) * pix_step,
+        };
+        struct pixel_type
+        {
+            value_type c[pix_step];
+
+            void set(value_type r, value_type g, value_type b, value_type a)
+            {
+                c[order_type::R] = r;
+                c[order_type::G] = g;
+                c[order_type::B] = b;
+                c[order_type::A] = a;
+            }
+
+            void set(const color_type& color)
+            {
+                set(color.r, color.g, color.b, color.a);
+            }
+
+            void get(value_type& r, value_type& g, value_type& b, value_type& a) const
+            {
+                r = c[order_type::R];
+                g = c[order_type::G];
+                b = c[order_type::B];
+                a = c[order_type::A];
+            }
+
+            color_type get() const
+            {
+                return color_type(
+                    c[order_type::R], 
+                    c[order_type::G], 
+                    c[order_type::B],
+                    c[order_type::A]);
+            }
+
+            pixel_type* next()
+            {
+                return this + 1;
+            }
+
+            const pixel_type* next() const
+            {
+                return this + 1;
+            }
+
+            pixel_type* advance(int n)
+            {
+                return this + n;
+            }
+
+            const pixel_type* advance(int n) const
+            {
+                return this + n;
+            }
+        };
+
+    private:
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pix(pixel_type* p, const color_type& c, unsigned cover)
+        {
+            m_blender.blend_pix(p->c, c.r, c.g, c.b, c.a, cover);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pix(pixel_type* p, const color_type& c)
+        {
+            m_blender.blend_pix(p->c, c.r, c.g, c.b, c.a);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_or_blend_pix(pixel_type* p, const color_type& c, unsigned cover)
+        {
+            if (!c.is_transparent())
+            {
+                if (c.is_opaque() && cover == cover_mask)
+                {
+                    p->set(c.r, c.g, c.b, c.a);
+                }
+                else
+                {
+                    m_blender.blend_pix(p->c, c.r, c.g, c.b, c.a, cover);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_or_blend_pix(pixel_type* p, const color_type& c)
+        {
+            if (!c.is_transparent())
+            {
+                if (c.is_opaque())
+                {
+                    p->set(c.r, c.g, c.b, c.a);
+                }
+                else
+                {
+                    m_blender.blend_pix(p->c, c.r, c.g, c.b, c.a);
+                }
+            }
+        }
+
+    public:
+        //--------------------------------------------------------------------
+        pixfmt_alpha_blend_rgba() : m_rbuf(0) {}
+        explicit pixfmt_alpha_blend_rgba(rbuf_type& rb) : m_rbuf(&rb) {}
+        void attach(rbuf_type& rb) { m_rbuf = &rb; }
+
+        //--------------------------------------------------------------------
+        template<class PixFmt>
+        bool attach(PixFmt& pixf, int x1, int y1, int x2, int y2)
+        {
+            rect_i r(x1, y1, x2, y2);
+            if (r.clip(rect_i(0, 0, pixf.width()-1, pixf.height()-1)))
+            {
+                int stride = pixf.stride();
+                m_rbuf->attach(pixf.pix_ptr(r.x1, stride < 0 ? r.y2 : r.y1), 
+                               (r.x2 - r.x1) + 1,
+                               (r.y2 - r.y1) + 1,
+                               stride);
+                return true;
+            }
+            return false;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE unsigned width()  const { return m_rbuf->width();  }
+        AGG_INLINE unsigned height() const { return m_rbuf->height(); }
+        AGG_INLINE int      stride() const { return m_rbuf->stride(); }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE       int8u* row_ptr(int y)       { return m_rbuf->row_ptr(y); }
+        AGG_INLINE const int8u* row_ptr(int y) const { return m_rbuf->row_ptr(y); }
+        AGG_INLINE row_data     row(int y)     const { return m_rbuf->row(y); }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE int8u* pix_ptr(int x, int y) 
+        { 
+            return m_rbuf->row_ptr(y) + sizeof(value_type) * (x * pix_step);
+        }
+
+        AGG_INLINE const int8u* pix_ptr(int x, int y) const 
+        { 
+            return m_rbuf->row_ptr(y) + sizeof(value_type) * (x * pix_step);
+        }
+
+        // Return pointer to pixel value, forcing row to be allocated.
+        AGG_INLINE pixel_type* pix_value_ptr(int x, int y, unsigned len) 
+        {
+            return (pixel_type*)(m_rbuf->row_ptr(x, y, len) + sizeof(value_type) * (x * pix_step));
+        }
+
+        // Return pointer to pixel value, or null if row not allocated.
+        AGG_INLINE const pixel_type* pix_value_ptr(int x, int y) const 
+        {
+            int8u* p = m_rbuf->row_ptr(y);
+            return p ? (pixel_type*)(p + sizeof(value_type) * (x * pix_step)) : 0;
+        }
+
+        // Get pixel pointer from raw buffer pointer.
+        AGG_INLINE static pixel_type* pix_value_ptr(void* p) 
+        {
+            return (pixel_type*)p;
+        }
+
+        // Get pixel pointer from raw buffer pointer.
+        AGG_INLINE static const pixel_type* pix_value_ptr(const void* p) 
+        {
+            return (const pixel_type*)p;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE static void write_plain_color(void* p, color_type c)
+        {
+            blender_type::set_plain_color(pix_value_ptr(p)->c, c);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE static color_type read_plain_color(const void* p)
+        {
+            return blender_type::get_plain_color(pix_value_ptr(p)->c);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE static void make_pix(int8u* p, const color_type& c)
+        {
+            ((pixel_type*)p)->set(c);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE color_type pixel(int x, int y) const
+        {
+            if (const pixel_type* p = pix_value_ptr(x, y))
+            {
+                return p->get();
+            }
+            return color_type::no_color();
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_pixel(int x, int y, const color_type& c)
+        {
+            pix_value_ptr(x, y, 1)->set(c);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pixel(int x, int y, const color_type& c, int8u cover)
+        {
+            copy_or_blend_pix(pix_value_ptr(x, y, 1), c, cover);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_hline(int x, int y, 
+                                   unsigned len, 
+                                   const color_type& c)
+        {
+            pixel_type v;
+            v.set(c);
+            pixel_type* p = pix_value_ptr(x, y, len);
+            do
+            {
+                *p = v;
+                p = p->next();
+            }
+            while (--len);
+        }
+
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_vline(int x, int y,
+                                   unsigned len, 
+                                   const color_type& c)
+        {
+            pixel_type v;
+            v.set(c);
+            do
+            {
+                *pix_value_ptr(x, y++, 1) = v;
+            }
+            while (--len);
+        }
+
+        //--------------------------------------------------------------------
+        void blend_hline(int x, int y,
+                         unsigned len, 
+                         const color_type& c,
+                         int8u cover)
+        {
+            if (!c.is_transparent())
+            {
+                pixel_type* p = pix_value_ptr(x, y, len);
+                if (c.is_opaque() && cover == cover_mask)
+                {
+                    pixel_type v;
+                    v.set(c);
+                    do
+                    {
+                        *p = v;
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+                else
+                {
+                    if (cover == cover_mask)
+                    {
+                        do
+                        {
+                            blend_pix(p, c);
+                            p = p->next();
+                        }
+                        while (--len);
+                    }
+                    else
+                    {
+                        do
+                        {
+                            blend_pix(p, c, cover);
+                            p = p->next();
+                        }
+                        while (--len);
+                    }
+                }
+            }
+        }
+
+
+        //--------------------------------------------------------------------
+        void blend_vline(int x, int y,
+                         unsigned len, 
+                         const color_type& c,
+                         int8u cover)
+        {
+            if (!c.is_transparent())
+            {
+                if (c.is_opaque() && cover == cover_mask)
+                {
+                    pixel_type v;
+                    v.set(c);
+                    do
+                    {
+                        *pix_value_ptr(x, y++, 1) = v;
+                    }
+                    while (--len);
+                }
+                else
+                {
+                    if (cover == cover_mask)
+                    {
+                        do
+                        {
+                            blend_pix(pix_value_ptr(x, y++, 1), c, c.a);
+                        }
+                        while (--len);
+                    }
+                    else
+                    {
+                        do
+                        {
+                            blend_pix(pix_value_ptr(x, y++, 1), c, cover);
+                        }
+                        while (--len);
+                    }
+                }
+            }
+        }
+
+
+        //--------------------------------------------------------------------
+        void blend_solid_hspan(int x, int y,
+                               unsigned len, 
+                               const color_type& c,
+                               const int8u* covers)
+        {
+            if (!c.is_transparent())
+            {
+                pixel_type* p = pix_value_ptr(x, y, len);
+                do 
+                {
+                    if (c.is_opaque() && *covers == cover_mask)
+                    {
+                        p->set(c);
+                    }
+                    else
+                    {
+                        blend_pix(p, c, *covers);
+                    }
+                    p = p->next();
+                    ++covers;
+                }
+                while (--len);
+            }
+        }
+
+
+        //--------------------------------------------------------------------
+        void blend_solid_vspan(int x, int y,
+                               unsigned len, 
+                               const color_type& c,
+                               const int8u* covers)
+        {
+            if (!c.is_transparent())
+            {
+                do 
+                {
+                    pixel_type* p = pix_value_ptr(x, y++, 1);
+                    if (c.is_opaque() && *covers == cover_mask)
+                    {
+                        p->set(c);
+                    }
+                    else
+                    {
+                        blend_pix(p, c, *covers);
+                    }
+                    ++covers;
+                }
+                while (--len);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void copy_color_hspan(int x, int y,
+                              unsigned len, 
+                              const color_type* colors)
+        {
+            pixel_type* p = pix_value_ptr(x, y, len);
+            do 
+            {
+                p->set(*colors++);
+                p = p->next();
+            }
+            while (--len);
+        }
+
+
+        //--------------------------------------------------------------------
+        void copy_color_vspan(int x, int y,
+                              unsigned len, 
+                              const color_type* colors)
+        {
+            do 
+            {
+                pix_value_ptr(x, y++, 1)->set(*colors++);
+            }
+            while (--len);
+        }
+
+        //--------------------------------------------------------------------
+        void blend_color_hspan(int x, int y,
+                               unsigned len, 
+                               const color_type* colors,
+                               const int8u* covers,
+                               int8u cover)
+        {
+            pixel_type* p = pix_value_ptr(x, y, len);
+            if (covers)
+            {
+                do 
+                {
+                    copy_or_blend_pix(p, *colors++, *covers++);
+                    p = p->next();
+                }
+                while (--len);
+            }
+            else
+            {
+                if (cover == cover_mask)
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(p, *colors++);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+                else
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(p, *colors++, cover);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void blend_color_vspan(int x, int y,
+                               unsigned len, 
+                               const color_type* colors,
+                               const int8u* covers,
+                               int8u cover)
+        {
+            if (covers)
+            {
+                do 
+                {
+                    copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++, *covers++);
+                }
+                while (--len);
+            }
+            else
+            {
+                if (cover == cover_mask)
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++);
+                    }
+                    while (--len);
+                }
+                else
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++, cover);
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        template<class Function> void for_each_pixel(Function f)
+        {
+            for (unsigned y = 0; y < height(); ++y)
+            {
+                row_data r = m_rbuf->row(y);
+                if (r.ptr)
+                {
+                    unsigned len = r.x2 - r.x1 + 1;
+                    pixel_type* p = pix_value_ptr(r.x1, y, len);
+                    do
+                    {
+                        f(p->c);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void premultiply()
+        {
+            for_each_pixel(multiplier_rgba<color_type, order_type>::premultiply);
+        }
+
+        //--------------------------------------------------------------------
+        void demultiply()
+        {
+            for_each_pixel(multiplier_rgba<color_type, order_type>::demultiply);
+        }
+
+        //--------------------------------------------------------------------
+        template<class GammaLut> void apply_gamma_dir(const GammaLut& g)
+        {
+            for_each_pixel(apply_gamma_dir_rgba<color_type, order_type, GammaLut>(g));
+        }
+
+        //--------------------------------------------------------------------
+        template<class GammaLut> void apply_gamma_inv(const GammaLut& g)
+        {
+            for_each_pixel(apply_gamma_inv_rgba<color_type, order_type, GammaLut>(g));
+        }
+
+        //--------------------------------------------------------------------
+        template<class RenBuf2> void copy_from(const RenBuf2& from, 
+                                               int xdst, int ydst,
+                                               int xsrc, int ysrc,
+                                               unsigned len)
+        {
+            if (const int8u* p = from.row_ptr(ysrc))
+            {
+                memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width, 
+                        p + xsrc * pix_width, 
+                        len * pix_width);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        // Blend from another RGBA surface.
+        template<class SrcPixelFormatRenderer>
+        void blend_from(const SrcPixelFormatRenderer& from, 
+                        int xdst, int ydst,
+                        int xsrc, int ysrc,
+                        unsigned len,
+                        int8u cover)
+        {
+            typedef typename SrcPixelFormatRenderer::pixel_type src_pixel_type;
+
+            if (const src_pixel_type* psrc = from.pix_value_ptr(xsrc, ysrc))
+            {
+                pixel_type* pdst = pix_value_ptr(xdst, ydst, len);
+                int srcinc = 1;
+                int dstinc = 1;
+
+                if (xdst > xsrc)
+                {
+                    psrc = psrc->advance(len - 1);
+                    pdst = pdst->advance(len - 1);
+                    srcinc = -1;
+                    dstinc = -1;
+                }
+
+                if (cover == cover_mask)
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(pdst, psrc->get());
+                        psrc = psrc->advance(srcinc);
+                        pdst = pdst->advance(dstinc);
+                    }
+                    while (--len);
+                }
+                else
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(pdst, psrc->get(), cover);
+                        psrc = psrc->advance(srcinc);
+                        pdst = pdst->advance(dstinc);
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        // Combine single color with grayscale surface and blend.
+        template<class SrcPixelFormatRenderer>
+        void blend_from_color(const SrcPixelFormatRenderer& from, 
+                              const color_type& color,
+                              int xdst, int ydst,
+                              int xsrc, int ysrc,
+                              unsigned len,
+                              int8u cover)
+        {
+            typedef typename SrcPixelFormatRenderer::pixel_type src_pixel_type;
+            typedef typename SrcPixelFormatRenderer::color_type src_color_type;
+
+            if (const src_pixel_type* psrc = from.pix_value_ptr(xsrc, ysrc))
+            {
+                pixel_type* pdst = pix_value_ptr(xdst, ydst, len);
+
+                do 
+                {
+                    copy_or_blend_pix(pdst, color, 
+                        src_color_type::scale_cover(cover, psrc->c[0]));
+                    psrc = psrc->next();
+                    pdst = pdst->next();
+                }
+                while (--len);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        // Blend from color table, using grayscale surface as indexes into table.
+        // Obviously, this only works for integer value types.
+        template<class SrcPixelFormatRenderer>
+        void blend_from_lut(const SrcPixelFormatRenderer& from, 
+                            const color_type* color_lut,
+                            int xdst, int ydst,
+                            int xsrc, int ysrc,
+                            unsigned len,
+                            int8u cover)
+        {
+            typedef typename SrcPixelFormatRenderer::pixel_type src_pixel_type;
+
+            if (const src_pixel_type* psrc = from.pix_value_ptr(xsrc, ysrc))
+            {
+                pixel_type* pdst = pix_value_ptr(xdst, ydst, len);
+
+                if (cover == cover_mask)
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(pdst, color_lut[psrc->c[0]]);
+                        psrc = psrc->next();
+                        pdst = pdst->next();
+                    }
+                    while (--len);
+                }
+                else
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(pdst, color_lut[psrc->c[0]], cover);
+                        psrc = psrc->next();
+                        pdst = pdst->next();
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+    private:
+        rbuf_type* m_rbuf;
+        Blender    m_blender;
+    };
+
+    //================================================pixfmt_custom_blend_rgba
+    template<class Blender, class RenBuf> class pixfmt_custom_blend_rgba
+    {
+    public:
+        typedef pixfmt_rgba_tag pixfmt_category;
+        typedef RenBuf   rbuf_type;
+        typedef typename rbuf_type::row_data row_data;
+        typedef Blender  blender_type;
+        typedef typename blender_type::color_type color_type;
+        typedef typename blender_type::order_type order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        enum 
+        {
+            pix_step = 4,
+            pix_width  = sizeof(value_type) * pix_step,
+        };
+        struct pixel_type
+        {
+            value_type c[pix_step];
+
+            void set(value_type r, value_type g, value_type b, value_type a)
+            {
+                c[order_type::R] = r;
+                c[order_type::G] = g;
+                c[order_type::B] = b;
+                c[order_type::A] = a;
+            }
+
+            void set(const color_type& color)
+            {
+                set(color.r, color.g, color.b, color.a);
+            }
+
+            void get(value_type& r, value_type& g, value_type& b, value_type& a) const
+            {
+                r = c[order_type::R];
+                g = c[order_type::G];
+                b = c[order_type::B];
+                a = c[order_type::A];
+            }
+
+            color_type get() const
+            {
+                return color_type(
+                    c[order_type::R], 
+                    c[order_type::G], 
+                    c[order_type::B],
+                    c[order_type::A]);
+            }
+
+            pixel_type* next()
+            {
+                return this + 1;
+            }
+
+            const pixel_type* next() const
+            {
+                return this + 1;
+            }
+
+            pixel_type* advance(int n)
+            {
+                return this + n;
+            }
+
+            const pixel_type* advance(int n) const
+            {
+                return this + n;
+            }
+        };
+
+
+    private:
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pix(pixel_type* p, const color_type& c, unsigned cover = cover_full)
+        {
+            m_blender.blend_pix(m_comp_op, p->c, c.r, c.g, c.b, c.a, cover);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_or_blend_pix(pixel_type* p, const color_type& c, unsigned cover = cover_full)
+        {
+            if (!c.is_transparent())
+            {
+                if (c.is_opaque() && cover == cover_mask)
+                {
+                    p->set(c.r, c.g, c.b, c.a);
+                }
+                else
+                {
+                    blend_pix(p, c, cover);
+                }
+            }
+        }
+
+    public:
+        //--------------------------------------------------------------------
+        pixfmt_custom_blend_rgba() : m_rbuf(0), m_comp_op(3) {}
+        explicit pixfmt_custom_blend_rgba(rbuf_type& rb, unsigned comp_op=3) : 
+            m_rbuf(&rb),
+            m_comp_op(comp_op)
+        {}
+        void attach(rbuf_type& rb) { m_rbuf = &rb; }
+
+        //--------------------------------------------------------------------
+        template<class PixFmt>
+        bool attach(PixFmt& pixf, int x1, int y1, int x2, int y2)
+        {
+            rect_i r(x1, y1, x2, y2);
+            if (r.clip(rect_i(0, 0, pixf.width()-1, pixf.height()-1)))
+            {
+                int stride = pixf.stride();
+                m_rbuf->attach(pixf.pix_ptr(r.x1, stride < 0 ? r.y2 : r.y1), 
+                               (r.x2 - r.x1) + 1,
+                               (r.y2 - r.y1) + 1,
+                               stride);
+                return true;
+            }
+            return false;
+        }
+
+        //--------------------------------------------------------------------
+        void comp_op(unsigned op) { m_comp_op = op; }
+        unsigned comp_op() const  { return m_comp_op; }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE unsigned width()  const { return m_rbuf->width();  }
+        AGG_INLINE unsigned height() const { return m_rbuf->height(); }
+        AGG_INLINE int      stride() const { return m_rbuf->stride(); }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE       int8u* row_ptr(int y)       { return m_rbuf->row_ptr(y); }
+        AGG_INLINE const int8u* row_ptr(int y) const { return m_rbuf->row_ptr(y); }
+        AGG_INLINE row_data     row(int y)     const { return m_rbuf->row(y); }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE int8u* pix_ptr(int x, int y) 
+        { 
+            return m_rbuf->row_ptr(y) + sizeof(value_type) * (x * pix_step);
+        }
+
+        AGG_INLINE const int8u* pix_ptr(int x, int y) const 
+        { 
+            return m_rbuf->row_ptr(y) + sizeof(value_type) * (x * pix_step);
+        }
+
+        // Return pointer to pixel value, forcing row to be allocated.
+        AGG_INLINE pixel_type* pix_value_ptr(int x, int y, unsigned len) 
+        {
+            return (pixel_type*)(m_rbuf->row_ptr(x, y, len) + sizeof(value_type) * (x * pix_step));
+        }
+
+        // Return pointer to pixel value, or null if row not allocated.
+        AGG_INLINE const pixel_type* pix_value_ptr(int x, int y) const 
+        {
+            int8u* p = m_rbuf->row_ptr(y);
+            return p ? (pixel_type*)(p + sizeof(value_type) * (x * pix_step)) : 0;
+        }
+
+        // Get pixel pointer from raw buffer pointer.
+        AGG_INLINE static pixel_type* pix_value_ptr(void* p) 
+        {
+            return (pixel_type*)p;
+        }
+
+        // Get pixel pointer from raw buffer pointer.
+        AGG_INLINE static const pixel_type* pix_value_ptr(const void* p) 
+        {
+            return (const pixel_type*)p;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE static void make_pix(int8u* p, const color_type& c)
+        {
+            ((pixel_type*)p)->set(c);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE color_type pixel(int x, int y) const
+        {
+            if (const pixel_type* p = pix_value_ptr(x, y))
+            {
+                return p->get();
+            }
+            return color_type::no_color();
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_pixel(int x, int y, const color_type& c)
+        {
+            make_pix(pix_value_ptr(x, y, 1), c);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pixel(int x, int y, const color_type& c, int8u cover)
+        {
+            blend_pix(pix_value_ptr(x, y, 1), c, cover);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_hline(int x, int y, 
+                                   unsigned len, 
+                                   const color_type& c)
+        {
+            pixel_type v;
+            v.set(c);
+            pixel_type* p = pix_value_ptr(x, y, len);
+            do
+            {
+                *p = v;
+                p = p->next();
+            }
+            while (--len);
+        }
+
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_vline(int x, int y,
+                                   unsigned len, 
+                                   const color_type& c)
+        {
+            pixel_type v;
+            v.set(c);
+            do
+            {
+                *pix_value_ptr(x, y++, 1) = v;
+            }
+            while (--len);
+        }
+
+        //--------------------------------------------------------------------
+        void blend_hline(int x, int y, unsigned len, 
+                         const color_type& c, int8u cover)
+        {
+
+            pixel_type* p = pix_value_ptr(x, y, len);
+            do
+            {
+                blend_pix(p, c, cover);
+                p = p->next();
+            }
+            while (--len);
+        }
+
+        //--------------------------------------------------------------------
+        void blend_vline(int x, int y, unsigned len, 
+                         const color_type& c, int8u cover)
+        {
+            do
+            {
+                blend_pix(pix_value_ptr(x, y++, 1), c, cover);
+            }
+            while (--len);
+        }
+
+        //--------------------------------------------------------------------
+        void blend_solid_hspan(int x, int y, unsigned len, 
+                               const color_type& c, const int8u* covers)
+        {
+            pixel_type* p = pix_value_ptr(x, y, len);
+
+            do 
+            {
+                blend_pix(p, c, *covers++);
+                p = p->next();
+            }
+            while (--len);
+        }
+
+        //--------------------------------------------------------------------
+        void blend_solid_vspan(int x, int y, unsigned len, 
+                               const color_type& c, const int8u* covers)
+        {
+            do 
+            {
+                blend_pix(pix_value_ptr(x, y++, 1), c, *covers++);
+            }
+            while (--len);
+        }
+
+        //--------------------------------------------------------------------
+        void copy_color_hspan(int x, int y,
+                              unsigned len, 
+                              const color_type* colors)
+        {
+            pixel_type* p = pix_value_ptr(x, y, len);
+
+            do 
+            {
+                p->set(*colors++);
+                p = p->next();
+            }
+            while (--len);
+        }
+
+        //--------------------------------------------------------------------
+        void copy_color_vspan(int x, int y,
+                              unsigned len, 
+                              const color_type* colors)
+        {
+            do 
+            {
+                pix_value_ptr(x, y++, 1)->set(*colors++);
+            }
+            while (--len);
+        }
+
+        //--------------------------------------------------------------------
+        void blend_color_hspan(int x, int y, unsigned len, 
+                               const color_type* colors, 
+                               const int8u* covers,
+                               int8u cover)
+        {
+            pixel_type* p = pix_value_ptr(x, y, len);
+
+            do 
+            {
+                blend_pix(p, *colors++, covers ? *covers++ : cover);
+                p = p->next();
+            }
+            while (--len);
+        }
+
+        //--------------------------------------------------------------------
+        void blend_color_vspan(int x, int y, unsigned len, 
+                               const color_type* colors, 
+                               const int8u* covers,
+                               int8u cover)
+        {
+            do 
+            {
+                blend_pix(pix_value_ptr(x, y++, 1), *colors++, covers ? *covers++ : cover);
+            }
+            while (--len);
+
+        }
+
+        //--------------------------------------------------------------------
+        template<class Function> void for_each_pixel(Function f)
+        {
+            unsigned y;
+            for (y = 0; y < height(); ++y)
+            {
+                row_data r = m_rbuf->row(y);
+                if (r.ptr)
+                {
+                    unsigned len = r.x2 - r.x1 + 1;
+                    pixel_type* p = pix_value_ptr(r.x1, y, len);
+                    do
+                    {
+                        f(p->c);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void premultiply()
+        {
+            for_each_pixel(multiplier_rgba<color_type, order_type>::premultiply);
+        }
+
+        //--------------------------------------------------------------------
+        void demultiply()
+        {
+            for_each_pixel(multiplier_rgba<color_type, order_type>::demultiply);
+        }
+
+        //--------------------------------------------------------------------
+        template<class GammaLut> void apply_gamma_dir(const GammaLut& g)
+        {
+            for_each_pixel(apply_gamma_dir_rgba<color_type, order_type, GammaLut>(g));
+        }
+
+        //--------------------------------------------------------------------
+        template<class GammaLut> void apply_gamma_inv(const GammaLut& g)
+        {
+            for_each_pixel(apply_gamma_inv_rgba<color_type, order_type, GammaLut>(g));
+        }
+
+        //--------------------------------------------------------------------
+        template<class RenBuf2> void copy_from(const RenBuf2& from, 
+                                               int xdst, int ydst,
+                                               int xsrc, int ysrc,
+                                               unsigned len)
+        {
+            if (const int8u* p = from.row_ptr(ysrc))
+            {
+                memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width, 
+                        p + xsrc * pix_width, 
+                        len * pix_width);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        // Blend from another RGBA surface.
+        template<class SrcPixelFormatRenderer> 
+        void blend_from(const SrcPixelFormatRenderer& from, 
+                        int xdst, int ydst,
+                        int xsrc, int ysrc,
+                        unsigned len,
+                        int8u cover)
+        {
+            typedef typename SrcPixelFormatRenderer::pixel_type src_pixel_type;
+
+            if (const src_pixel_type* psrc = from.pix_value_ptr(xsrc, ysrc))
+            {
+                pixel_type* pdst = pix_value_ptr(xdst, ydst, len);
+                int srcinc = 1;
+                int dstinc = 1;
+
+                if (xdst > xsrc)
+                {
+                    psrc = psrc->advance(len - 1);
+                    pdst = pdst->advance(len - 1);
+                    srcinc = -1;
+                    dstinc = -1;
+                }
+
+                do 
+                {
+                    blend_pix(pdst, psrc->get(), cover);
+                    psrc = psrc->advance(srcinc);
+                    pdst = pdst->advance(dstinc);
+                }
+                while (--len);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        // Blend from single color, using grayscale surface as alpha channel.
+        template<class SrcPixelFormatRenderer>
+        void blend_from_color(const SrcPixelFormatRenderer& from, 
+                              const color_type& color,
+                              int xdst, int ydst,
+                              int xsrc, int ysrc,
+                              unsigned len,
+                              int8u cover)
+        {
+            typedef typename SrcPixelFormatRenderer::pixel_type src_pixel_type;
+            typedef typename SrcPixelFormatRenderer::color_type src_color_type;
+
+            if (const src_pixel_type* psrc = from.pix_value_ptr(xsrc, ysrc))
+            {
+                pixel_type* pdst = pix_value_ptr(xdst, ydst, len);
+
+                do 
+                {
+                    blend_pix(pdst, color,
+                        src_color_type::scale_cover(cover, psrc->c[0]));
+                    psrc = psrc->next();
+                    pdst = pdst->next();
+                }
+                while (--len);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        // Blend from color table, using grayscale surface as indexes into table.
+        // Obviously, this only works for integer value types.
+        template<class SrcPixelFormatRenderer>
+        void blend_from_lut(const SrcPixelFormatRenderer& from, 
+                            const color_type* color_lut,
+                            int xdst, int ydst,
+                            int xsrc, int ysrc,
+                            unsigned len,
+                            int8u cover)
+        {
+            typedef typename SrcPixelFormatRenderer::pixel_type src_pixel_type;
+
+            if (const src_pixel_type* psrc = from.pix_value_ptr(xsrc, ysrc))
+            {
+                pixel_type* pdst = pix_value_ptr(xdst, ydst, len);
+
+                do 
+                {
+                    blend_pix(pdst, color_lut[psrc->c[0]], cover);
+                    psrc = psrc->next();
+                    pdst = pdst->next();
+                }
+                while (--len);
+            }
+        }
+
+    private:
+        rbuf_type* m_rbuf;
+        Blender m_blender;
+        unsigned m_comp_op;
+    };
+
+
+    //-----------------------------------------------------------------------
+    typedef blender_rgba<rgba8, order_rgba> blender_rgba32;
+    typedef blender_rgba<rgba8, order_argb> blender_argb32;
+    typedef blender_rgba<rgba8, order_abgr> blender_abgr32;
+    typedef blender_rgba<rgba8, order_bgra> blender_bgra32;
+
+    typedef blender_rgba<srgba8, order_rgba> blender_srgba32;
+    typedef blender_rgba<srgba8, order_argb> blender_sargb32;
+    typedef blender_rgba<srgba8, order_abgr> blender_sabgr32;
+    typedef blender_rgba<srgba8, order_bgra> blender_sbgra32;
+
+    typedef blender_rgba_pre<rgba8, order_rgba> blender_rgba32_pre;
+    typedef blender_rgba_pre<rgba8, order_argb> blender_argb32_pre;
+    typedef blender_rgba_pre<rgba8, order_abgr> blender_abgr32_pre;
+    typedef blender_rgba_pre<rgba8, order_bgra> blender_bgra32_pre;
+
+    typedef blender_rgba_pre<srgba8, order_rgba> blender_srgba32_pre;
+    typedef blender_rgba_pre<srgba8, order_argb> blender_sargb32_pre;
+    typedef blender_rgba_pre<srgba8, order_abgr> blender_sabgr32_pre;
+    typedef blender_rgba_pre<srgba8, order_bgra> blender_sbgra32_pre;
+
+    typedef blender_rgba_plain<rgba8, order_rgba> blender_rgba32_plain;
+    typedef blender_rgba_plain<rgba8, order_argb> blender_argb32_plain;
+    typedef blender_rgba_plain<rgba8, order_abgr> blender_abgr32_plain;
+    typedef blender_rgba_plain<rgba8, order_bgra> blender_bgra32_plain;
+
+    typedef blender_rgba_plain<srgba8, order_rgba> blender_srgba32_plain;
+    typedef blender_rgba_plain<srgba8, order_argb> blender_sargb32_plain;
+    typedef blender_rgba_plain<srgba8, order_abgr> blender_sabgr32_plain;
+    typedef blender_rgba_plain<srgba8, order_bgra> blender_sbgra32_plain;
+
+    typedef blender_rgba<rgba16, order_rgba> blender_rgba64;
+    typedef blender_rgba<rgba16, order_argb> blender_argb64;
+    typedef blender_rgba<rgba16, order_abgr> blender_abgr64;
+    typedef blender_rgba<rgba16, order_bgra> blender_bgra64;
+
+    typedef blender_rgba_pre<rgba16, order_rgba> blender_rgba64_pre;
+    typedef blender_rgba_pre<rgba16, order_argb> blender_argb64_pre;
+    typedef blender_rgba_pre<rgba16, order_abgr> blender_abgr64_pre;
+    typedef blender_rgba_pre<rgba16, order_bgra> blender_bgra64_pre;
+
+	typedef blender_rgba_plain<rgba16, order_rgba> blender_rgba64_plain;
+	typedef blender_rgba_plain<rgba16, order_argb> blender_argb64_plain;
+	typedef blender_rgba_plain<rgba16, order_abgr> blender_abgr64_plain;
+	typedef blender_rgba_plain<rgba16, order_bgra> blender_bgra64_plain;
+
+	typedef blender_rgba<rgba32, order_rgba> blender_rgba128;
+    typedef blender_rgba<rgba32, order_argb> blender_argb128;
+    typedef blender_rgba<rgba32, order_abgr> blender_abgr128;
+    typedef blender_rgba<rgba32, order_bgra> blender_bgra128;
+
+    typedef blender_rgba_pre<rgba32, order_rgba> blender_rgba128_pre;
+    typedef blender_rgba_pre<rgba32, order_argb> blender_argb128_pre;
+    typedef blender_rgba_pre<rgba32, order_abgr> blender_abgr128_pre;
+    typedef blender_rgba_pre<rgba32, order_bgra> blender_bgra128_pre;
+
+    typedef blender_rgba_plain<rgba32, order_rgba> blender_rgba128_plain;
+    typedef blender_rgba_plain<rgba32, order_argb> blender_argb128_plain;
+    typedef blender_rgba_plain<rgba32, order_abgr> blender_abgr128_plain;
+    typedef blender_rgba_plain<rgba32, order_bgra> blender_bgra128_plain;
+
+
+    //-----------------------------------------------------------------------
+    typedef pixfmt_alpha_blend_rgba<blender_rgba32, rendering_buffer> pixfmt_rgba32;
+    typedef pixfmt_alpha_blend_rgba<blender_argb32, rendering_buffer> pixfmt_argb32;
+    typedef pixfmt_alpha_blend_rgba<blender_abgr32, rendering_buffer> pixfmt_abgr32;
+    typedef pixfmt_alpha_blend_rgba<blender_bgra32, rendering_buffer> pixfmt_bgra32;
+
+    typedef pixfmt_alpha_blend_rgba<blender_srgba32, rendering_buffer> pixfmt_srgba32;
+    typedef pixfmt_alpha_blend_rgba<blender_sargb32, rendering_buffer> pixfmt_sargb32;
+    typedef pixfmt_alpha_blend_rgba<blender_sabgr32, rendering_buffer> pixfmt_sabgr32;
+    typedef pixfmt_alpha_blend_rgba<blender_sbgra32, rendering_buffer> pixfmt_sbgra32;
+
+    typedef pixfmt_alpha_blend_rgba<blender_rgba32_pre, rendering_buffer> pixfmt_rgba32_pre;
+    typedef pixfmt_alpha_blend_rgba<blender_argb32_pre, rendering_buffer> pixfmt_argb32_pre;
+    typedef pixfmt_alpha_blend_rgba<blender_abgr32_pre, rendering_buffer> pixfmt_abgr32_pre;
+    typedef pixfmt_alpha_blend_rgba<blender_bgra32_pre, rendering_buffer> pixfmt_bgra32_pre;
+
+    typedef pixfmt_alpha_blend_rgba<blender_srgba32_pre, rendering_buffer> pixfmt_srgba32_pre;
+    typedef pixfmt_alpha_blend_rgba<blender_sargb32_pre, rendering_buffer> pixfmt_sargb32_pre;
+    typedef pixfmt_alpha_blend_rgba<blender_sabgr32_pre, rendering_buffer> pixfmt_sabgr32_pre;
+    typedef pixfmt_alpha_blend_rgba<blender_sbgra32_pre, rendering_buffer> pixfmt_sbgra32_pre;
+
+    typedef pixfmt_alpha_blend_rgba<blender_rgba32_plain, rendering_buffer> pixfmt_rgba32_plain;
+    typedef pixfmt_alpha_blend_rgba<blender_argb32_plain, rendering_buffer> pixfmt_argb32_plain;
+    typedef pixfmt_alpha_blend_rgba<blender_abgr32_plain, rendering_buffer> pixfmt_abgr32_plain;
+    typedef pixfmt_alpha_blend_rgba<blender_bgra32_plain, rendering_buffer> pixfmt_bgra32_plain;
+
+    typedef pixfmt_alpha_blend_rgba<blender_srgba32_plain, rendering_buffer> pixfmt_srgba32_plain;
+    typedef pixfmt_alpha_blend_rgba<blender_sargb32_plain, rendering_buffer> pixfmt_sargb32_plain;
+    typedef pixfmt_alpha_blend_rgba<blender_sabgr32_plain, rendering_buffer> pixfmt_sabgr32_plain;
+    typedef pixfmt_alpha_blend_rgba<blender_sbgra32_plain, rendering_buffer> pixfmt_sbgra32_plain;
+
+    typedef pixfmt_alpha_blend_rgba<blender_rgba64, rendering_buffer> pixfmt_rgba64;
+    typedef pixfmt_alpha_blend_rgba<blender_argb64, rendering_buffer> pixfmt_argb64;
+    typedef pixfmt_alpha_blend_rgba<blender_abgr64, rendering_buffer> pixfmt_abgr64;
+    typedef pixfmt_alpha_blend_rgba<blender_bgra64, rendering_buffer> pixfmt_bgra64;
+
+    typedef pixfmt_alpha_blend_rgba<blender_rgba64_pre, rendering_buffer> pixfmt_rgba64_pre;
+    typedef pixfmt_alpha_blend_rgba<blender_argb64_pre, rendering_buffer> pixfmt_argb64_pre;
+    typedef pixfmt_alpha_blend_rgba<blender_abgr64_pre, rendering_buffer> pixfmt_abgr64_pre;
+    typedef pixfmt_alpha_blend_rgba<blender_bgra64_pre, rendering_buffer> pixfmt_bgra64_pre;
+
+	typedef pixfmt_alpha_blend_rgba<blender_rgba64_plain, rendering_buffer> pixfmt_rgba64_plain;
+	typedef pixfmt_alpha_blend_rgba<blender_argb64_plain, rendering_buffer> pixfmt_argb64_plain;
+	typedef pixfmt_alpha_blend_rgba<blender_abgr64_plain, rendering_buffer> pixfmt_abgr64_plain;
+	typedef pixfmt_alpha_blend_rgba<blender_bgra64_plain, rendering_buffer> pixfmt_bgra64_plain;
+
+	typedef pixfmt_alpha_blend_rgba<blender_rgba128, rendering_buffer> pixfmt_rgba128;
+    typedef pixfmt_alpha_blend_rgba<blender_argb128, rendering_buffer> pixfmt_argb128;
+    typedef pixfmt_alpha_blend_rgba<blender_abgr128, rendering_buffer> pixfmt_abgr128;
+    typedef pixfmt_alpha_blend_rgba<blender_bgra128, rendering_buffer> pixfmt_bgra128;
+
+    typedef pixfmt_alpha_blend_rgba<blender_rgba128_pre, rendering_buffer> pixfmt_rgba128_pre;
+    typedef pixfmt_alpha_blend_rgba<blender_argb128_pre, rendering_buffer> pixfmt_argb128_pre;
+    typedef pixfmt_alpha_blend_rgba<blender_abgr128_pre, rendering_buffer> pixfmt_abgr128_pre;
+    typedef pixfmt_alpha_blend_rgba<blender_bgra128_pre, rendering_buffer> pixfmt_bgra128_pre;
+
+    typedef pixfmt_alpha_blend_rgba<blender_rgba128_plain, rendering_buffer> pixfmt_rgba128_plain;
+    typedef pixfmt_alpha_blend_rgba<blender_argb128_plain, rendering_buffer> pixfmt_argb128_plain;
+    typedef pixfmt_alpha_blend_rgba<blender_abgr128_plain, rendering_buffer> pixfmt_abgr128_plain;
+    typedef pixfmt_alpha_blend_rgba<blender_bgra128_plain, rendering_buffer> pixfmt_bgra128_plain;
+
+}
+
+#endif
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_rasterizer_cells_aa.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_rasterizer_cells_aa.h
new file mode 100644
index 0000000000..d1cc705405
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_rasterizer_cells_aa.h
@@ -0,0 +1,743 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+//
+// The author gratefully acknowleges the support of David Turner,
+// Robert Wilhelm, and Werner Lemberg - the authors of the FreeType
+// libray - in producing this work. See http://www.freetype.org for details.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Adaptation for 32-bit screen coordinates has been sponsored by
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_RASTERIZER_CELLS_AA_INCLUDED
+#define AGG_RASTERIZER_CELLS_AA_INCLUDED
+
+#include <stdexcept>
+#include <string.h>
+#include <math.h>
+#include "agg_math.h"
+#include "agg_array.h"
+
+
+namespace agg
+{
+
+    //-----------------------------------------------------rasterizer_cells_aa
+    // An internal class that implements the main rasterization algorithm.
+    // Used in the rasterizer. Should not be used direcly.
+    template<class Cell> class rasterizer_cells_aa
+    {
+        enum cell_block_scale_e
+        {
+            cell_block_shift = 12,
+            cell_block_size  = 1 << cell_block_shift,
+            cell_block_mask  = cell_block_size - 1,
+            cell_block_pool  = 256
+        };
+
+        struct sorted_y
+        {
+            unsigned start;
+            unsigned num;
+        };
+
+    public:
+        typedef Cell cell_type;
+        typedef rasterizer_cells_aa<Cell> self_type;
+
+        ~rasterizer_cells_aa();
+        rasterizer_cells_aa(unsigned cell_block_limit=1024);
+
+        void reset();
+        void style(const cell_type& style_cell);
+        void line(int x1, int y1, int x2, int y2);
+
+        int min_x() const { return m_min_x; }
+        int min_y() const { return m_min_y; }
+        int max_x() const { return m_max_x; }
+        int max_y() const { return m_max_y; }
+
+        void sort_cells();
+
+        unsigned total_cells() const
+        {
+            return m_num_cells;
+        }
+
+        unsigned scanline_num_cells(unsigned y) const
+        {
+            return m_sorted_y[y - m_min_y].num;
+        }
+
+        const cell_type* const* scanline_cells(unsigned y) const
+        {
+            return m_sorted_cells.data() + m_sorted_y[y - m_min_y].start;
+        }
+
+        bool sorted() const { return m_sorted; }
+
+    private:
+        rasterizer_cells_aa(const self_type&);
+        const self_type& operator = (const self_type&);
+
+        void set_curr_cell(int x, int y);
+        void add_curr_cell();
+        void render_hline(int ey, int x1, int y1, int x2, int y2);
+        void allocate_block();
+
+    private:
+        unsigned                m_num_blocks;
+        unsigned                m_max_blocks;
+        unsigned                m_curr_block;
+        unsigned                m_num_cells;
+        unsigned                m_cell_block_limit;
+        cell_type**             m_cells;
+        cell_type*              m_curr_cell_ptr;
+        pod_vector<cell_type*>  m_sorted_cells;
+        pod_vector<sorted_y>    m_sorted_y;
+        cell_type               m_curr_cell;
+        cell_type               m_style_cell;
+        int                     m_min_x;
+        int                     m_min_y;
+        int                     m_max_x;
+        int                     m_max_y;
+        bool                    m_sorted;
+    };
+
+
+
+
+    //------------------------------------------------------------------------
+    template<class Cell>
+    rasterizer_cells_aa<Cell>::~rasterizer_cells_aa()
+    {
+        if(m_num_blocks)
+        {
+            cell_type** ptr = m_cells + m_num_blocks - 1;
+            while(m_num_blocks--)
+            {
+                pod_allocator<cell_type>::deallocate(*ptr, cell_block_size);
+                ptr--;
+            }
+            pod_allocator<cell_type*>::deallocate(m_cells, m_max_blocks);
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class Cell>
+    rasterizer_cells_aa<Cell>::rasterizer_cells_aa(unsigned cell_block_limit) :
+        m_num_blocks(0),
+        m_max_blocks(0),
+        m_curr_block(0),
+        m_num_cells(0),
+        m_cell_block_limit(cell_block_limit),
+        m_cells(0),
+        m_curr_cell_ptr(0),
+        m_sorted_cells(),
+        m_sorted_y(),
+        m_min_x(0x7FFFFFFF),
+        m_min_y(0x7FFFFFFF),
+        m_max_x(-0x7FFFFFFF),
+        m_max_y(-0x7FFFFFFF),
+        m_sorted(false)
+    {
+        m_style_cell.initial();
+        m_curr_cell.initial();
+    }
+
+    //------------------------------------------------------------------------
+    template<class Cell>
+    void rasterizer_cells_aa<Cell>::reset()
+    {
+        m_num_cells = 0;
+        m_curr_block = 0;
+        m_curr_cell.initial();
+        m_style_cell.initial();
+        m_sorted = false;
+        m_min_x =  0x7FFFFFFF;
+        m_min_y =  0x7FFFFFFF;
+        m_max_x = -0x7FFFFFFF;
+        m_max_y = -0x7FFFFFFF;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Cell>
+    AGG_INLINE void rasterizer_cells_aa<Cell>::add_curr_cell()
+    {
+        if(m_curr_cell.area | m_curr_cell.cover)
+        {
+            if((m_num_cells & cell_block_mask) == 0)
+            {
+                if(m_num_blocks >= m_cell_block_limit) {
+                    throw std::overflow_error("Exceeded cell block limit");
+                }
+                allocate_block();
+            }
+            *m_curr_cell_ptr++ = m_curr_cell;
+            ++m_num_cells;
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class Cell>
+    AGG_INLINE void rasterizer_cells_aa<Cell>::set_curr_cell(int x, int y)
+    {
+        if(m_curr_cell.not_equal(x, y, m_style_cell))
+        {
+            add_curr_cell();
+            m_curr_cell.style(m_style_cell);
+            m_curr_cell.x     = x;
+            m_curr_cell.y     = y;
+            m_curr_cell.cover = 0;
+            m_curr_cell.area  = 0;
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class Cell>
+    AGG_INLINE void rasterizer_cells_aa<Cell>::render_hline(int ey,
+                                                            int x1, int y1,
+                                                            int x2, int y2)
+    {
+        int ex1 = x1 >> poly_subpixel_shift;
+        int ex2 = x2 >> poly_subpixel_shift;
+        int fx1 = x1 & poly_subpixel_mask;
+        int fx2 = x2 & poly_subpixel_mask;
+
+        int delta, p, first, dx;
+        int incr, lift, mod, rem;
+
+        //trivial case. Happens often
+        if(y1 == y2)
+        {
+            set_curr_cell(ex2, ey);
+            return;
+        }
+
+        //everything is located in a single cell.  That is easy!
+        if(ex1 == ex2)
+        {
+            delta = y2 - y1;
+            m_curr_cell.cover += delta;
+            m_curr_cell.area  += (fx1 + fx2) * delta;
+            return;
+        }
+
+        //ok, we'll have to render a run of adjacent cells on the same
+        //hline...
+        p     = (poly_subpixel_scale - fx1) * (y2 - y1);
+        first = poly_subpixel_scale;
+        incr  = 1;
+
+        dx = x2 - x1;
+
+        if(dx < 0)
+        {
+            p     = fx1 * (y2 - y1);
+            first = 0;
+            incr  = -1;
+            dx    = -dx;
+        }
+
+        delta = p / dx;
+        mod   = p % dx;
+
+        if(mod < 0)
+        {
+            delta--;
+            mod += dx;
+        }
+
+        m_curr_cell.cover += delta;
+        m_curr_cell.area  += (fx1 + first) * delta;
+
+        ex1 += incr;
+        set_curr_cell(ex1, ey);
+        y1  += delta;
+
+        if(ex1 != ex2)
+        {
+            p     = poly_subpixel_scale * (y2 - y1 + delta);
+            lift  = p / dx;
+            rem   = p % dx;
+
+            if (rem < 0)
+            {
+                lift--;
+                rem += dx;
+            }
+
+            mod -= dx;
+
+            while (ex1 != ex2)
+            {
+                delta = lift;
+                mod  += rem;
+                if(mod >= 0)
+                {
+                    mod -= dx;
+                    delta++;
+                }
+
+                m_curr_cell.cover += delta;
+                m_curr_cell.area  += poly_subpixel_scale * delta;
+                y1  += delta;
+                ex1 += incr;
+                set_curr_cell(ex1, ey);
+            }
+        }
+        delta = y2 - y1;
+        m_curr_cell.cover += delta;
+        m_curr_cell.area  += (fx2 + poly_subpixel_scale - first) * delta;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Cell>
+    AGG_INLINE void rasterizer_cells_aa<Cell>::style(const cell_type& style_cell)
+    {
+        m_style_cell.style(style_cell);
+    }
+
+    //------------------------------------------------------------------------
+    template<class Cell>
+    void rasterizer_cells_aa<Cell>::line(int x1, int y1, int x2, int y2)
+    {
+        enum dx_limit_e { dx_limit = 16384 << poly_subpixel_shift };
+
+        int dx = x2 - x1;
+
+        if(dx >= dx_limit || dx <= -dx_limit)
+        {
+            int cx = (x1 + x2) >> 1;
+            int cy = (y1 + y2) >> 1;
+            line(x1, y1, cx, cy);
+            line(cx, cy, x2, y2);
+            return;
+        }
+
+        int dy = y2 - y1;
+        int ex1 = x1 >> poly_subpixel_shift;
+        int ex2 = x2 >> poly_subpixel_shift;
+        int ey1 = y1 >> poly_subpixel_shift;
+        int ey2 = y2 >> poly_subpixel_shift;
+        int fy1 = y1 & poly_subpixel_mask;
+        int fy2 = y2 & poly_subpixel_mask;
+
+        int x_from, x_to;
+        int p, rem, mod, lift, delta, first, incr;
+
+        if(ex1 < m_min_x) m_min_x = ex1;
+        if(ex1 > m_max_x) m_max_x = ex1;
+        if(ey1 < m_min_y) m_min_y = ey1;
+        if(ey1 > m_max_y) m_max_y = ey1;
+        if(ex2 < m_min_x) m_min_x = ex2;
+        if(ex2 > m_max_x) m_max_x = ex2;
+        if(ey2 < m_min_y) m_min_y = ey2;
+        if(ey2 > m_max_y) m_max_y = ey2;
+
+        set_curr_cell(ex1, ey1);
+
+        //everything is on a single hline
+        if(ey1 == ey2)
+        {
+            render_hline(ey1, x1, fy1, x2, fy2);
+            return;
+        }
+
+        //Vertical line - we have to calculate start and end cells,
+        //and then - the common values of the area and coverage for
+        //all cells of the line. We know exactly there's only one
+        //cell, so, we don't have to call render_hline().
+        incr  = 1;
+        if(dx == 0)
+        {
+            int ex = x1 >> poly_subpixel_shift;
+            int two_fx = (x1 - (ex << poly_subpixel_shift)) << 1;
+            int area;
+
+            first = poly_subpixel_scale;
+            if(dy < 0)
+            {
+                first = 0;
+                incr  = -1;
+            }
+
+            x_from = x1;
+
+            //render_hline(ey1, x_from, fy1, x_from, first);
+            delta = first - fy1;
+            m_curr_cell.cover += delta;
+            m_curr_cell.area  += two_fx * delta;
+
+            ey1 += incr;
+            set_curr_cell(ex, ey1);
+
+            delta = first + first - poly_subpixel_scale;
+            area = two_fx * delta;
+            while(ey1 != ey2)
+            {
+                //render_hline(ey1, x_from, poly_subpixel_scale - first, x_from, first);
+                m_curr_cell.cover = delta;
+                m_curr_cell.area  = area;
+                ey1 += incr;
+                set_curr_cell(ex, ey1);
+            }
+            //render_hline(ey1, x_from, poly_subpixel_scale - first, x_from, fy2);
+            delta = fy2 - poly_subpixel_scale + first;
+            m_curr_cell.cover += delta;
+            m_curr_cell.area  += two_fx * delta;
+            return;
+        }
+
+        //ok, we have to render several hlines
+        p     = (poly_subpixel_scale - fy1) * dx;
+        first = poly_subpixel_scale;
+
+        if(dy < 0)
+        {
+            p     = fy1 * dx;
+            first = 0;
+            incr  = -1;
+            dy    = -dy;
+        }
+
+        delta = p / dy;
+        mod   = p % dy;
+
+        if(mod < 0)
+        {
+            delta--;
+            mod += dy;
+        }
+
+        x_from = x1 + delta;
+        render_hline(ey1, x1, fy1, x_from, first);
+
+        ey1 += incr;
+        set_curr_cell(x_from >> poly_subpixel_shift, ey1);
+
+        if(ey1 != ey2)
+        {
+            p     = poly_subpixel_scale * dx;
+            lift  = p / dy;
+            rem   = p % dy;
+
+            if(rem < 0)
+            {
+                lift--;
+                rem += dy;
+            }
+            mod -= dy;
+
+            while(ey1 != ey2)
+            {
+                delta = lift;
+                mod  += rem;
+                if (mod >= 0)
+                {
+                    mod -= dy;
+                    delta++;
+                }
+
+                x_to = x_from + delta;
+                render_hline(ey1, x_from, poly_subpixel_scale - first, x_to, first);
+                x_from = x_to;
+
+                ey1 += incr;
+                set_curr_cell(x_from >> poly_subpixel_shift, ey1);
+            }
+        }
+        render_hline(ey1, x_from, poly_subpixel_scale - first, x2, fy2);
+    }
+
+    //------------------------------------------------------------------------
+    template<class Cell>
+    void rasterizer_cells_aa<Cell>::allocate_block()
+    {
+        if(m_curr_block >= m_num_blocks)
+        {
+            if(m_num_blocks >= m_max_blocks)
+            {
+                cell_type** new_cells =
+                    pod_allocator<cell_type*>::allocate(m_max_blocks +
+                                                        cell_block_pool);
+
+                if(m_cells)
+                {
+                    memcpy(new_cells, m_cells, m_max_blocks * sizeof(cell_type*));
+                    pod_allocator<cell_type*>::deallocate(m_cells, m_max_blocks);
+                }
+                m_cells = new_cells;
+                m_max_blocks += cell_block_pool;
+            }
+
+            m_cells[m_num_blocks++] =
+                pod_allocator<cell_type>::allocate(cell_block_size);
+
+        }
+        m_curr_cell_ptr = m_cells[m_curr_block++];
+    }
+
+
+
+    //------------------------------------------------------------------------
+    template <class T> static AGG_INLINE void swap_cells(T* a, T* b)
+    {
+        T temp = *a;
+        *a = *b;
+        *b = temp;
+    }
+
+
+    //------------------------------------------------------------------------
+    enum
+    {
+        qsort_threshold = 9
+    };
+
+
+    //------------------------------------------------------------------------
+    template<class Cell>
+    void qsort_cells(Cell** start, unsigned num)
+    {
+        Cell**  stack[80];
+        Cell*** top;
+        Cell**  limit;
+        Cell**  base;
+
+        limit = start + num;
+        base  = start;
+        top   = stack;
+
+        for (;;)
+        {
+            int len = int(limit - base);
+
+            Cell** i;
+            Cell** j;
+            Cell** pivot;
+
+            if(len > qsort_threshold)
+            {
+                // we use base + len/2 as the pivot
+                pivot = base + len / 2;
+                swap_cells(base, pivot);
+
+                i = base + 1;
+                j = limit - 1;
+
+                // now ensure that *i <= *base <= *j
+                if((*j)->x < (*i)->x)
+                {
+                    swap_cells(i, j);
+                }
+
+                if((*base)->x < (*i)->x)
+                {
+                    swap_cells(base, i);
+                }
+
+                if((*j)->x < (*base)->x)
+                {
+                    swap_cells(base, j);
+                }
+
+                for(;;)
+                {
+                    int x = (*base)->x;
+                    do i++; while( (*i)->x < x );
+                    do j--; while( x < (*j)->x );
+
+                    if(i > j)
+                    {
+                        break;
+                    }
+
+                    swap_cells(i, j);
+                }
+
+                swap_cells(base, j);
+
+                // now, push the largest sub-array
+                if(j - base > limit - i)
+                {
+                    top[0] = base;
+                    top[1] = j;
+                    base   = i;
+                }
+                else
+                {
+                    top[0] = i;
+                    top[1] = limit;
+                    limit  = j;
+                }
+                top += 2;
+            }
+            else
+            {
+                // the sub-array is small, perform insertion sort
+                j = base;
+                i = j + 1;
+
+                for(; i < limit; j = i, i++)
+                {
+                    for(; j[1]->x < (*j)->x; j--)
+                    {
+                        swap_cells(j + 1, j);
+                        if (j == base)
+                        {
+                            break;
+                        }
+                    }
+                }
+
+                if(top > stack)
+                {
+                    top  -= 2;
+                    base  = top[0];
+                    limit = top[1];
+                }
+                else
+                {
+                    break;
+                }
+            }
+        }
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class Cell>
+    void rasterizer_cells_aa<Cell>::sort_cells()
+    {
+        if(m_sorted) return; //Perform sort only the first time.
+
+        add_curr_cell();
+        m_curr_cell.x     = 0x7FFFFFFF;
+        m_curr_cell.y     = 0x7FFFFFFF;
+        m_curr_cell.cover = 0;
+        m_curr_cell.area  = 0;
+
+        if(m_num_cells == 0) return;
+
+// DBG: Check to see if min/max works well.
+//for(unsigned nc = 0; nc < m_num_cells; nc++)
+//{
+//    cell_type* cell = m_cells[nc >> cell_block_shift] + (nc & cell_block_mask);
+//    if(cell->x < m_min_x ||
+//       cell->y < m_min_y ||
+//       cell->x > m_max_x ||
+//       cell->y > m_max_y)
+//    {
+//        cell = cell; // Breakpoint here
+//    }
+//}
+        // Allocate the array of cell pointers
+        m_sorted_cells.allocate(m_num_cells, 16);
+
+        // Allocate and zero the Y array
+        m_sorted_y.allocate(m_max_y - m_min_y + 1, 16);
+        m_sorted_y.zero();
+
+        // Create the Y-histogram (count the numbers of cells for each Y)
+        cell_type** block_ptr = m_cells;
+        cell_type*  cell_ptr;
+        unsigned nb = m_num_cells;
+        unsigned i;
+        while(nb)
+        {
+            cell_ptr = *block_ptr++;
+            i = (nb > cell_block_size) ? cell_block_size : nb;
+            nb -= i;
+            while(i--)
+            {
+                m_sorted_y[cell_ptr->y - m_min_y].start++;
+                ++cell_ptr;
+            }
+        }
+
+        // Convert the Y-histogram into the array of starting indexes
+        unsigned start = 0;
+        for(i = 0; i < m_sorted_y.size(); i++)
+        {
+            unsigned v = m_sorted_y[i].start;
+            m_sorted_y[i].start = start;
+            start += v;
+        }
+
+        // Fill the cell pointer array sorted by Y
+        block_ptr = m_cells;
+        nb = m_num_cells;
+        while(nb)
+        {
+            cell_ptr = *block_ptr++;
+            i = (nb > cell_block_size) ? cell_block_size : nb;
+            nb -= i;
+            while(i--)
+            {
+                sorted_y& curr_y = m_sorted_y[cell_ptr->y - m_min_y];
+                m_sorted_cells[curr_y.start + curr_y.num] = cell_ptr;
+                ++curr_y.num;
+                ++cell_ptr;
+            }
+        }
+
+        // Finally arrange the X-arrays
+        for(i = 0; i < m_sorted_y.size(); i++)
+        {
+            const sorted_y& curr_y = m_sorted_y[i];
+            if(curr_y.num)
+            {
+                qsort_cells(m_sorted_cells.data() + curr_y.start, curr_y.num);
+            }
+        }
+        m_sorted = true;
+    }
+
+
+
+    //------------------------------------------------------scanline_hit_test
+    class scanline_hit_test
+    {
+    public:
+        scanline_hit_test(int x) : m_x(x), m_hit(false) {}
+
+        void reset_spans() {}
+        void finalize(int) {}
+        void add_cell(int x, int)
+        {
+            if(m_x == x) m_hit = true;
+        }
+        void add_span(int x, int len, int)
+        {
+            if(m_x >= x && m_x < x+len) m_hit = true;
+        }
+        unsigned num_spans() const { return 1; }
+        bool hit() const { return m_hit; }
+
+    private:
+        int  m_x;
+        bool m_hit;
+    };
+
+
+}
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_rasterizer_scanline_aa.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_rasterizer_scanline_aa.h
new file mode 100644
index 0000000000..1583216646
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_rasterizer_scanline_aa.h
@@ -0,0 +1,481 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+//
+// The author gratefully acknowleges the support of David Turner, 
+// Robert Wilhelm, and Werner Lemberg - the authors of the FreeType 
+// libray - in producing this work. See http://www.freetype.org for details.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Adaptation for 32-bit screen coordinates has been sponsored by 
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+// 
+//----------------------------------------------------------------------------
+#ifndef AGG_RASTERIZER_SCANLINE_AA_INCLUDED
+#define AGG_RASTERIZER_SCANLINE_AA_INCLUDED
+
+#include "agg_rasterizer_cells_aa.h"
+#include "agg_rasterizer_sl_clip.h"
+#include "agg_rasterizer_scanline_aa_nogamma.h"
+#include "agg_gamma_functions.h"
+
+
+namespace agg
+{
+    //==================================================rasterizer_scanline_aa
+    // Polygon rasterizer that is used to render filled polygons with 
+    // high-quality Anti-Aliasing. Internally, by default, the class uses 
+    // integer coordinates in format 24.8, i.e. 24 bits for integer part 
+    // and 8 bits for fractional - see poly_subpixel_shift. This class can be 
+    // used in the following  way:
+    //
+    // 1. filling_rule(filling_rule_e ft) - optional.
+    //
+    // 2. gamma() - optional.
+    //
+    // 3. reset()
+    //
+    // 4. move_to(x, y) / line_to(x, y) - make the polygon. One can create 
+    //    more than one contour, but each contour must consist of at least 3
+    //    vertices, i.e. move_to(x1, y1); line_to(x2, y2); line_to(x3, y3);
+    //    is the absolute minimum of vertices that define a triangle.
+    //    The algorithm does not check either the number of vertices nor
+    //    coincidence of their coordinates, but in the worst case it just 
+    //    won't draw anything.
+    //    The orger of the vertices (clockwise or counterclockwise) 
+    //    is important when using the non-zero filling rule (fill_non_zero).
+    //    In this case the vertex order of all the contours must be the same
+    //    if you want your intersecting polygons to be without "holes".
+    //    You actually can use different vertices order. If the contours do not 
+    //    intersect each other the order is not important anyway. If they do, 
+    //    contours with the same vertex order will be rendered without "holes" 
+    //    while the intersecting contours with different orders will have "holes".
+    //
+    // filling_rule() and gamma() can be called anytime before "sweeping".
+    //------------------------------------------------------------------------
+    template<class Clip=rasterizer_sl_clip_int> class rasterizer_scanline_aa
+    {
+        enum status
+        {
+            status_initial,
+            status_move_to,
+            status_line_to,
+            status_closed
+        };
+
+    public:
+        typedef Clip                      clip_type;
+        typedef typename Clip::conv_type  conv_type;
+        typedef typename Clip::coord_type coord_type;
+
+        enum aa_scale_e
+        {
+            aa_shift  = 8,
+            aa_scale  = 1 << aa_shift,
+            aa_mask   = aa_scale - 1,
+            aa_scale2 = aa_scale * 2,
+            aa_mask2  = aa_scale2 - 1
+        };
+
+        //--------------------------------------------------------------------
+        rasterizer_scanline_aa(unsigned cell_block_limit=1024) :
+            m_outline(cell_block_limit),
+            m_clipper(),
+            m_filling_rule(fill_non_zero),
+            m_auto_close(true),
+            m_start_x(0),
+            m_start_y(0),
+            m_status(status_initial)
+        {
+            int i;
+            for(i = 0; i < aa_scale; i++) m_gamma[i] = i;
+        }
+
+        //--------------------------------------------------------------------
+        template<class GammaF>
+        rasterizer_scanline_aa(const GammaF& gamma_function, unsigned cell_block_limit) :
+            m_outline(cell_block_limit),
+            m_clipper(m_outline),
+            m_filling_rule(fill_non_zero),
+            m_auto_close(true),
+            m_start_x(0),
+            m_start_y(0),
+            m_status(status_initial)
+        {
+            gamma(gamma_function);
+        }
+
+        //--------------------------------------------------------------------
+        void reset(); 
+        void reset_clipping();
+        void clip_box(double x1, double y1, double x2, double y2);
+        void filling_rule(filling_rule_e filling_rule);
+        void auto_close(bool flag) { m_auto_close = flag; }
+
+        //--------------------------------------------------------------------
+        template<class GammaF> void gamma(const GammaF& gamma_function)
+        { 
+            int i;
+            for(i = 0; i < aa_scale; i++)
+            {
+                m_gamma[i] = uround(gamma_function(double(i) / aa_mask) * aa_mask);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        unsigned apply_gamma(unsigned cover) const 
+        { 
+            return m_gamma[cover]; 
+        }
+
+        //--------------------------------------------------------------------
+        void move_to(int x, int y);
+        void line_to(int x, int y);
+        void move_to_d(double x, double y);
+        void line_to_d(double x, double y);
+        void close_polygon();
+        void add_vertex(double x, double y, unsigned cmd);
+
+        void edge(int x1, int y1, int x2, int y2);
+        void edge_d(double x1, double y1, double x2, double y2);
+
+        //-------------------------------------------------------------------
+        template<class VertexSource>
+        void add_path(VertexSource& vs, unsigned path_id=0)
+        {
+            double x;
+            double y;
+
+            unsigned cmd;
+            vs.rewind(path_id);
+            if(m_outline.sorted()) reset();
+            while(!is_stop(cmd = vs.vertex(&x, &y)))
+            {
+                add_vertex(x, y, cmd);
+            }
+        }
+        
+        //--------------------------------------------------------------------
+        int min_x() const { return m_outline.min_x(); }
+        int min_y() const { return m_outline.min_y(); }
+        int max_x() const { return m_outline.max_x(); }
+        int max_y() const { return m_outline.max_y(); }
+
+        //--------------------------------------------------------------------
+        void sort();
+        bool rewind_scanlines();
+        bool navigate_scanline(int y);
+
+        //--------------------------------------------------------------------
+        AGG_INLINE unsigned calculate_alpha(int area) const
+        {
+            int cover = area >> (poly_subpixel_shift*2 + 1 - aa_shift);
+
+            if(cover < 0) cover = -cover;
+            if(m_filling_rule == fill_even_odd)
+            {
+                cover &= aa_mask2;
+                if(cover > aa_scale)
+                {
+                    cover = aa_scale2 - cover;
+                }
+            }
+            if(cover > aa_mask) cover = aa_mask;
+            return m_gamma[cover];
+        }
+
+        //--------------------------------------------------------------------
+        template<class Scanline> bool sweep_scanline(Scanline& sl)
+        {
+            for(;;)
+            {
+                if(m_scan_y > m_outline.max_y()) return false;
+                sl.reset_spans();
+                unsigned num_cells = m_outline.scanline_num_cells(m_scan_y);
+                const cell_aa* const* cells = m_outline.scanline_cells(m_scan_y);
+                int cover = 0;
+
+                while(num_cells)
+                {
+                    const cell_aa* cur_cell = *cells;
+                    int x    = cur_cell->x;
+                    int area = cur_cell->area;
+                    unsigned alpha;
+
+                    cover += cur_cell->cover;
+
+                    //accumulate all cells with the same X
+                    while(--num_cells)
+                    {
+                        cur_cell = *++cells;
+                        if(cur_cell->x != x) break;
+                        area  += cur_cell->area;
+                        cover += cur_cell->cover;
+                    }
+
+                    if(area)
+                    {
+                        alpha = calculate_alpha((cover << (poly_subpixel_shift + 1)) - area);
+                        if(alpha)
+                        {
+                            sl.add_cell(x, alpha);
+                        }
+                        x++;
+                    }
+
+                    if(num_cells && cur_cell->x > x)
+                    {
+                        alpha = calculate_alpha(cover << (poly_subpixel_shift + 1));
+                        if(alpha)
+                        {
+                            sl.add_span(x, cur_cell->x - x, alpha);
+                        }
+                    }
+                }
+        
+                if(sl.num_spans()) break;
+                ++m_scan_y;
+            }
+
+            sl.finalize(m_scan_y);
+            ++m_scan_y;
+            return true;
+        }
+
+        //--------------------------------------------------------------------
+        bool hit_test(int tx, int ty);
+
+
+    private:
+        //--------------------------------------------------------------------
+        // Disable copying
+        rasterizer_scanline_aa(const rasterizer_scanline_aa<Clip>&);
+        const rasterizer_scanline_aa<Clip>& 
+        operator = (const rasterizer_scanline_aa<Clip>&);
+
+    private:
+        rasterizer_cells_aa<cell_aa> m_outline;
+        clip_type      m_clipper;
+        int            m_gamma[aa_scale];
+        filling_rule_e m_filling_rule;
+        bool           m_auto_close;
+        coord_type     m_start_x;
+        coord_type     m_start_y;
+        unsigned       m_status;
+        int            m_scan_y;
+    };
+
+
+
+
+
+
+
+
+
+
+
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::reset() 
+    { 
+        m_outline.reset(); 
+        m_status = status_initial;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::filling_rule(filling_rule_e filling_rule) 
+    { 
+        m_filling_rule = filling_rule; 
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::clip_box(double x1, double y1, 
+                                                double x2, double y2)
+    {
+        reset();
+        m_clipper.clip_box(conv_type::upscale(x1), conv_type::upscale(y1), 
+                           conv_type::upscale(x2), conv_type::upscale(y2));
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::reset_clipping()
+    {
+        reset();
+        m_clipper.reset_clipping();
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::close_polygon()
+    {
+        if(m_status == status_line_to)
+        {
+            m_clipper.line_to(m_outline, m_start_x, m_start_y);
+            m_status = status_closed;
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::move_to(int x, int y)
+    {
+        if(m_outline.sorted()) reset();
+        if(m_auto_close) close_polygon();
+        m_clipper.move_to(m_start_x = conv_type::downscale(x), 
+                          m_start_y = conv_type::downscale(y));
+        m_status = status_move_to;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::line_to(int x, int y)
+    {
+        m_clipper.line_to(m_outline, 
+                          conv_type::downscale(x), 
+                          conv_type::downscale(y));
+        m_status = status_line_to;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::move_to_d(double x, double y) 
+    { 
+        if(m_outline.sorted()) reset();
+        if(m_auto_close) close_polygon();
+        m_clipper.move_to(m_start_x = conv_type::upscale(x), 
+                          m_start_y = conv_type::upscale(y)); 
+        m_status = status_move_to;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::line_to_d(double x, double y) 
+    { 
+        m_clipper.line_to(m_outline, 
+                          conv_type::upscale(x), 
+                          conv_type::upscale(y)); 
+        m_status = status_line_to;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::add_vertex(double x, double y, unsigned cmd)
+    {
+        if(is_move_to(cmd)) 
+        {
+            move_to_d(x, y);
+        }
+        else 
+        if(is_vertex(cmd))
+        {
+            line_to_d(x, y);
+        }
+        else
+        if(is_close(cmd))
+        {
+            close_polygon();
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::edge(int x1, int y1, int x2, int y2)
+    {
+        if(m_outline.sorted()) reset();
+        m_clipper.move_to(conv_type::downscale(x1), conv_type::downscale(y1));
+        m_clipper.line_to(m_outline, 
+                          conv_type::downscale(x2), 
+                          conv_type::downscale(y2));
+        m_status = status_move_to;
+    }
+    
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::edge_d(double x1, double y1, 
+                                              double x2, double y2)
+    {
+        if(m_outline.sorted()) reset();
+        m_clipper.move_to(conv_type::upscale(x1), conv_type::upscale(y1)); 
+        m_clipper.line_to(m_outline, 
+                          conv_type::upscale(x2), 
+                          conv_type::upscale(y2)); 
+        m_status = status_move_to;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::sort()
+    {
+        if(m_auto_close) close_polygon();
+        m_outline.sort_cells();
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    AGG_INLINE bool rasterizer_scanline_aa<Clip>::rewind_scanlines()
+    {
+        if(m_auto_close) close_polygon();
+        m_outline.sort_cells();
+        if(m_outline.total_cells() == 0) 
+        {
+            return false;
+        }
+        m_scan_y = m_outline.min_y();
+        return true;
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    AGG_INLINE bool rasterizer_scanline_aa<Clip>::navigate_scanline(int y)
+    {
+        if(m_auto_close) close_polygon();
+        m_outline.sort_cells();
+        if(m_outline.total_cells() == 0 || 
+           y < m_outline.min_y() || 
+           y > m_outline.max_y()) 
+        {
+            return false;
+        }
+        m_scan_y = y;
+        return true;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    bool rasterizer_scanline_aa<Clip>::hit_test(int tx, int ty)
+    {
+        if(!navigate_scanline(ty)) return false;
+        scanline_hit_test sl(tx);
+        sweep_scanline(sl);
+        return sl.hit();
+    }
+
+
+
+}
+
+
+
+#endif
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_rasterizer_scanline_aa_nogamma.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_rasterizer_scanline_aa_nogamma.h
new file mode 100644
index 0000000000..7729b3359a
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_rasterizer_scanline_aa_nogamma.h
@@ -0,0 +1,482 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+//
+// The author gratefully acknowleges the support of David Turner, 
+// Robert Wilhelm, and Werner Lemberg - the authors of the FreeType 
+// libray - in producing this work. See http://www.freetype.org for details.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Adaptation for 32-bit screen coordinates has been sponsored by 
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+// 
+//----------------------------------------------------------------------------
+#ifndef AGG_RASTERIZER_SCANLINE_AA_NOGAMMA_INCLUDED
+#define AGG_RASTERIZER_SCANLINE_AA_NOGAMMA_INCLUDED
+
+#include "agg_rasterizer_cells_aa.h"
+#include "agg_rasterizer_sl_clip.h"
+
+
+namespace agg
+{
+
+
+    //-----------------------------------------------------------------cell_aa
+    // A pixel cell. There're no constructors defined and it was done 
+    // intentionally in order to avoid extra overhead when allocating an 
+    // array of cells.
+    struct cell_aa
+    {
+        int x;
+        int y;
+        int cover;
+        int area;
+
+        void initial()
+        {
+            x = 0x7FFFFFFF;
+            y = 0x7FFFFFFF;
+            cover = 0;
+            area  = 0;
+        }
+
+        void style(const cell_aa&) {}
+
+        int not_equal(int ex, int ey, const cell_aa&) const
+        {
+            return ex != x || ey != y;
+        }
+    };
+
+
+    //==================================================rasterizer_scanline_aa_nogamma
+    // Polygon rasterizer that is used to render filled polygons with 
+    // high-quality Anti-Aliasing. Internally, by default, the class uses 
+    // integer coordinates in format 24.8, i.e. 24 bits for integer part 
+    // and 8 bits for fractional - see poly_subpixel_shift. This class can be 
+    // used in the following  way:
+    //
+    // 1. filling_rule(filling_rule_e ft) - optional.
+    //
+    // 2. gamma() - optional.
+    //
+    // 3. reset()
+    //
+    // 4. move_to(x, y) / line_to(x, y) - make the polygon. One can create 
+    //    more than one contour, but each contour must consist of at least 3
+    //    vertices, i.e. move_to(x1, y1); line_to(x2, y2); line_to(x3, y3);
+    //    is the absolute minimum of vertices that define a triangle.
+    //    The algorithm does not check either the number of vertices nor
+    //    coincidence of their coordinates, but in the worst case it just 
+    //    won't draw anything.
+    //    The orger of the vertices (clockwise or counterclockwise) 
+    //    is important when using the non-zero filling rule (fill_non_zero).
+    //    In this case the vertex order of all the contours must be the same
+    //    if you want your intersecting polygons to be without "holes".
+    //    You actually can use different vertices order. If the contours do not 
+    //    intersect each other the order is not important anyway. If they do, 
+    //    contours with the same vertex order will be rendered without "holes" 
+    //    while the intersecting contours with different orders will have "holes".
+    //
+    // filling_rule() and gamma() can be called anytime before "sweeping".
+    //------------------------------------------------------------------------
+    template<class Clip=rasterizer_sl_clip_int> class rasterizer_scanline_aa_nogamma
+    {
+        enum status
+        {
+            status_initial,
+            status_move_to,
+            status_line_to,
+            status_closed
+        };
+
+    public:
+        typedef Clip                      clip_type;
+        typedef typename Clip::conv_type  conv_type;
+        typedef typename Clip::coord_type coord_type;
+
+        enum aa_scale_e
+        {
+            aa_shift  = 8,
+            aa_scale  = 1 << aa_shift,
+            aa_mask   = aa_scale - 1,
+            aa_scale2 = aa_scale * 2,
+            aa_mask2  = aa_scale2 - 1
+        };
+
+        //--------------------------------------------------------------------
+        rasterizer_scanline_aa_nogamma(unsigned cell_block_limit=1024) :
+            m_outline(cell_block_limit),
+            m_clipper(),
+            m_filling_rule(fill_non_zero),
+            m_auto_close(true),
+            m_start_x(0),
+            m_start_y(0),
+            m_status(status_initial)
+        {
+        }
+
+        //--------------------------------------------------------------------
+        void reset(); 
+        void reset_clipping();
+        void clip_box(double x1, double y1, double x2, double y2);
+        void filling_rule(filling_rule_e filling_rule);
+        void auto_close(bool flag) { m_auto_close = flag; }
+
+        //--------------------------------------------------------------------
+        unsigned apply_gamma(unsigned cover) const 
+        { 
+            return cover;
+        }
+
+        //--------------------------------------------------------------------
+        void move_to(int x, int y);
+        void line_to(int x, int y);
+        void move_to_d(double x, double y);
+        void line_to_d(double x, double y);
+        void close_polygon();
+        void add_vertex(double x, double y, unsigned cmd);
+
+        void edge(int x1, int y1, int x2, int y2);
+        void edge_d(double x1, double y1, double x2, double y2);
+
+        //-------------------------------------------------------------------
+        template<class VertexSource>
+        void add_path(VertexSource& vs, unsigned path_id=0)
+        {
+            double x;
+            double y;
+
+            unsigned cmd;
+            vs.rewind(path_id);
+            if(m_outline.sorted()) reset();
+            while(!is_stop(cmd = vs.vertex(&x, &y)))
+            {
+                add_vertex(x, y, cmd);
+            }
+        }
+        
+        //--------------------------------------------------------------------
+        int min_x() const { return m_outline.min_x(); }
+        int min_y() const { return m_outline.min_y(); }
+        int max_x() const { return m_outline.max_x(); }
+        int max_y() const { return m_outline.max_y(); }
+
+        //--------------------------------------------------------------------
+        void sort();
+        bool rewind_scanlines();
+        bool navigate_scanline(int y);
+
+        //--------------------------------------------------------------------
+        AGG_INLINE unsigned calculate_alpha(int area) const
+        {
+            int cover = area >> (poly_subpixel_shift*2 + 1 - aa_shift);
+
+            if(cover < 0) cover = -cover;
+            if(m_filling_rule == fill_even_odd)
+            {
+                cover &= aa_mask2;
+                if(cover > aa_scale)
+                {
+                    cover = aa_scale2 - cover;
+                }
+            }
+            if(cover > aa_mask) cover = aa_mask;
+            return cover;
+        }
+
+        //--------------------------------------------------------------------
+        template<class Scanline> bool sweep_scanline(Scanline& sl)
+        {
+            for(;;)
+            {
+                if(m_scan_y > m_outline.max_y()) return false;
+                sl.reset_spans();
+                unsigned num_cells = m_outline.scanline_num_cells(m_scan_y);
+                const cell_aa* const* cells = m_outline.scanline_cells(m_scan_y);
+                int cover = 0;
+
+                while(num_cells)
+                {
+                    const cell_aa* cur_cell = *cells;
+                    int x    = cur_cell->x;
+                    int area = cur_cell->area;
+                    unsigned alpha;
+
+                    cover += cur_cell->cover;
+
+                    //accumulate all cells with the same X
+                    while(--num_cells)
+                    {
+                        cur_cell = *++cells;
+                        if(cur_cell->x != x) break;
+                        area  += cur_cell->area;
+                        cover += cur_cell->cover;
+                    }
+
+                    if(area)
+                    {
+                        alpha = calculate_alpha((cover << (poly_subpixel_shift + 1)) - area);
+                        if(alpha)
+                        {
+                            sl.add_cell(x, alpha);
+                        }
+                        x++;
+                    }
+
+                    if(num_cells && cur_cell->x > x)
+                    {
+                        alpha = calculate_alpha(cover << (poly_subpixel_shift + 1));
+                        if(alpha)
+                        {
+                            sl.add_span(x, cur_cell->x - x, alpha);
+                        }
+                    }
+                }
+        
+                if(sl.num_spans()) break;
+                ++m_scan_y;
+            }
+
+            sl.finalize(m_scan_y);
+            ++m_scan_y;
+            return true;
+        }
+
+        //--------------------------------------------------------------------
+        bool hit_test(int tx, int ty);
+
+
+    private:
+        //--------------------------------------------------------------------
+        // Disable copying
+        rasterizer_scanline_aa_nogamma(const rasterizer_scanline_aa_nogamma<Clip>&);
+        const rasterizer_scanline_aa_nogamma<Clip>& 
+        operator = (const rasterizer_scanline_aa_nogamma<Clip>&);
+
+    private:
+        rasterizer_cells_aa<cell_aa> m_outline;
+        clip_type      m_clipper;
+        filling_rule_e m_filling_rule;
+        bool           m_auto_close;
+        coord_type     m_start_x;
+        coord_type     m_start_y;
+        unsigned       m_status;
+        int            m_scan_y;
+    };
+
+
+
+
+
+
+
+
+
+
+
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::reset() 
+    { 
+        m_outline.reset(); 
+        m_status = status_initial;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::filling_rule(filling_rule_e filling_rule) 
+    { 
+        m_filling_rule = filling_rule; 
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::clip_box(double x1, double y1, 
+                                                double x2, double y2)
+    {
+        reset();
+        m_clipper.clip_box(conv_type::upscale(x1), conv_type::upscale(y1), 
+                           conv_type::upscale(x2), conv_type::upscale(y2));
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::reset_clipping()
+    {
+        reset();
+        m_clipper.reset_clipping();
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::close_polygon()
+    {
+        if(m_status == status_line_to)
+        {
+            m_clipper.line_to(m_outline, m_start_x, m_start_y);
+            m_status = status_closed;
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::move_to(int x, int y)
+    {
+        if(m_outline.sorted()) reset();
+        if(m_auto_close) close_polygon();
+        m_clipper.move_to(m_start_x = conv_type::downscale(x), 
+                          m_start_y = conv_type::downscale(y));
+        m_status = status_move_to;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::line_to(int x, int y)
+    {
+        m_clipper.line_to(m_outline, 
+                          conv_type::downscale(x), 
+                          conv_type::downscale(y));
+        m_status = status_line_to;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::move_to_d(double x, double y) 
+    { 
+        if(m_outline.sorted()) reset();
+        if(m_auto_close) close_polygon();
+        m_clipper.move_to(m_start_x = conv_type::upscale(x), 
+                          m_start_y = conv_type::upscale(y)); 
+        m_status = status_move_to;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::line_to_d(double x, double y) 
+    { 
+        m_clipper.line_to(m_outline, 
+                          conv_type::upscale(x), 
+                          conv_type::upscale(y)); 
+        m_status = status_line_to;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::add_vertex(double x, double y, unsigned cmd)
+    {
+        if(is_move_to(cmd)) 
+        {
+            move_to_d(x, y);
+        }
+        else 
+        if(is_vertex(cmd))
+        {
+            line_to_d(x, y);
+        }
+        else
+        if(is_close(cmd))
+        {
+            close_polygon();
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::edge(int x1, int y1, int x2, int y2)
+    {
+        if(m_outline.sorted()) reset();
+        m_clipper.move_to(conv_type::downscale(x1), conv_type::downscale(y1));
+        m_clipper.line_to(m_outline, 
+                          conv_type::downscale(x2), 
+                          conv_type::downscale(y2));
+        m_status = status_move_to;
+    }
+    
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::edge_d(double x1, double y1, 
+                                              double x2, double y2)
+    {
+        if(m_outline.sorted()) reset();
+        m_clipper.move_to(conv_type::upscale(x1), conv_type::upscale(y1)); 
+        m_clipper.line_to(m_outline, 
+                          conv_type::upscale(x2), 
+                          conv_type::upscale(y2)); 
+        m_status = status_move_to;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::sort()
+    {
+        if(m_auto_close) close_polygon();
+        m_outline.sort_cells();
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    AGG_INLINE bool rasterizer_scanline_aa_nogamma<Clip>::rewind_scanlines()
+    {
+        if(m_auto_close) close_polygon();
+        m_outline.sort_cells();
+        if(m_outline.total_cells() == 0) 
+        {
+            return false;
+        }
+        m_scan_y = m_outline.min_y();
+        return true;
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    AGG_INLINE bool rasterizer_scanline_aa_nogamma<Clip>::navigate_scanline(int y)
+    {
+        if(m_auto_close) close_polygon();
+        m_outline.sort_cells();
+        if(m_outline.total_cells() == 0 || 
+           y < m_outline.min_y() || 
+           y > m_outline.max_y()) 
+        {
+            return false;
+        }
+        m_scan_y = y;
+        return true;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    bool rasterizer_scanline_aa_nogamma<Clip>::hit_test(int tx, int ty)
+    {
+        if(!navigate_scanline(ty)) return false;
+        scanline_hit_test sl(tx);
+        sweep_scanline(sl);
+        return sl.hit();
+    }
+
+
+
+}
+
+
+
+#endif
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_rasterizer_sl_clip.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_rasterizer_sl_clip.h
new file mode 100644
index 0000000000..e7ba065acc
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_rasterizer_sl_clip.h
@@ -0,0 +1,351 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+#ifndef AGG_RASTERIZER_SL_CLIP_INCLUDED
+#define AGG_RASTERIZER_SL_CLIP_INCLUDED
+
+#include "agg_clip_liang_barsky.h"
+
+namespace agg
+{
+    //--------------------------------------------------------poly_max_coord_e
+    enum poly_max_coord_e
+    {
+        poly_max_coord = (1 << 30) - 1 //----poly_max_coord
+    };
+    
+    //------------------------------------------------------------ras_conv_int
+    struct ras_conv_int
+    {
+        typedef int coord_type;
+        static AGG_INLINE int mul_div(double a, double b, double c)
+        {
+            return iround(a * b / c);
+        }
+        static int xi(int v) { return v; }
+        static int yi(int v) { return v; }
+        static int upscale(double v) { return iround(v * poly_subpixel_scale); }
+        static int downscale(int v)  { return v; }
+    };
+
+    //--------------------------------------------------------ras_conv_int_sat
+    struct ras_conv_int_sat
+    {
+        typedef int coord_type;
+        static AGG_INLINE int mul_div(double a, double b, double c)
+        {
+            return saturation<poly_max_coord>::iround(a * b / c);
+        }
+        static int xi(int v) { return v; }
+        static int yi(int v) { return v; }
+        static int upscale(double v) 
+        { 
+            return saturation<poly_max_coord>::iround(v * poly_subpixel_scale); 
+        }
+        static int downscale(int v) { return v; }
+    };
+
+    //---------------------------------------------------------ras_conv_int_3x
+    struct ras_conv_int_3x
+    {
+        typedef int coord_type;
+        static AGG_INLINE int mul_div(double a, double b, double c)
+        {
+            return iround(a * b / c);
+        }
+        static int xi(int v) { return v * 3; }
+        static int yi(int v) { return v; }
+        static int upscale(double v) { return iround(v * poly_subpixel_scale); }
+        static int downscale(int v)  { return v; }
+    };
+
+    //-----------------------------------------------------------ras_conv_dbl
+    struct ras_conv_dbl
+    {
+        typedef double coord_type;
+        static AGG_INLINE double mul_div(double a, double b, double c)
+        {
+            return a * b / c;
+        }
+        static int xi(double v) { return iround(v * poly_subpixel_scale); }
+        static int yi(double v) { return iround(v * poly_subpixel_scale); }
+        static double upscale(double v) { return v; }
+        static double downscale(int v)  { return v / double(poly_subpixel_scale); }
+    };
+
+    //--------------------------------------------------------ras_conv_dbl_3x
+    struct ras_conv_dbl_3x
+    {
+        typedef double coord_type;
+        static AGG_INLINE double mul_div(double a, double b, double c)
+        {
+            return a * b / c;
+        }
+        static int xi(double v) { return iround(v * poly_subpixel_scale * 3); }
+        static int yi(double v) { return iround(v * poly_subpixel_scale); }
+        static double upscale(double v) { return v; }
+        static double downscale(int v)  { return v / double(poly_subpixel_scale); }
+    };
+
+
+
+
+
+    //------------------------------------------------------rasterizer_sl_clip
+    template<class Conv> class rasterizer_sl_clip
+    {
+    public:
+        typedef Conv                      conv_type;
+        typedef typename Conv::coord_type coord_type;
+        typedef rect_base<coord_type>     rect_type;
+
+        //--------------------------------------------------------------------
+        rasterizer_sl_clip() :  
+            m_clip_box(0,0,0,0),
+            m_x1(0),
+            m_y1(0),
+            m_f1(0),
+            m_clipping(false) 
+        {}
+
+        //--------------------------------------------------------------------
+        void reset_clipping()
+        {
+            m_clipping = false;
+        }
+
+        //--------------------------------------------------------------------
+        void clip_box(coord_type x1, coord_type y1, coord_type x2, coord_type y2)
+        {
+            m_clip_box = rect_type(x1, y1, x2, y2);
+            m_clip_box.normalize();
+            m_clipping = true;
+        }
+
+        //--------------------------------------------------------------------
+        void move_to(coord_type x1, coord_type y1)
+        {
+            m_x1 = x1;
+            m_y1 = y1;
+            if(m_clipping) m_f1 = clipping_flags(x1, y1, m_clip_box);
+        }
+
+    private:
+        //------------------------------------------------------------------------
+        template<class Rasterizer>
+        AGG_INLINE void line_clip_y(Rasterizer& ras,
+                                    coord_type x1, coord_type y1, 
+                                    coord_type x2, coord_type y2, 
+                                    unsigned   f1, unsigned   f2) const
+        {
+            f1 &= 10;
+            f2 &= 10;
+            if((f1 | f2) == 0)
+            {
+                // Fully visible
+                ras.line(Conv::xi(x1), Conv::yi(y1), Conv::xi(x2), Conv::yi(y2)); 
+            }
+            else
+            {
+                if(f1 == f2)
+                {
+                    // Invisible by Y
+                    return;
+                }
+
+                coord_type tx1 = x1;
+                coord_type ty1 = y1;
+                coord_type tx2 = x2;
+                coord_type ty2 = y2;
+
+                if(f1 & 8) // y1 < clip.y1
+                {
+                    tx1 = x1 + Conv::mul_div(m_clip_box.y1-y1, x2-x1, y2-y1);
+                    ty1 = m_clip_box.y1;
+                }
+
+                if(f1 & 2) // y1 > clip.y2
+                {
+                    tx1 = x1 + Conv::mul_div(m_clip_box.y2-y1, x2-x1, y2-y1);
+                    ty1 = m_clip_box.y2;
+                }
+
+                if(f2 & 8) // y2 < clip.y1
+                {
+                    tx2 = x1 + Conv::mul_div(m_clip_box.y1-y1, x2-x1, y2-y1);
+                    ty2 = m_clip_box.y1;
+                }
+
+                if(f2 & 2) // y2 > clip.y2
+                {
+                    tx2 = x1 + Conv::mul_div(m_clip_box.y2-y1, x2-x1, y2-y1);
+                    ty2 = m_clip_box.y2;
+                }
+                ras.line(Conv::xi(tx1), Conv::yi(ty1), 
+                         Conv::xi(tx2), Conv::yi(ty2)); 
+            }
+        }
+
+
+    public:
+        //--------------------------------------------------------------------
+        template<class Rasterizer>
+        void line_to(Rasterizer& ras, coord_type x2, coord_type y2)
+        {
+            if(m_clipping)
+            {
+                unsigned f2 = clipping_flags(x2, y2, m_clip_box);
+
+                if((m_f1 & 10) == (f2 & 10) && (m_f1 & 10) != 0)
+                {
+                    // Invisible by Y
+                    m_x1 = x2;
+                    m_y1 = y2;
+                    m_f1 = f2;
+                    return;
+                }
+
+                coord_type x1 = m_x1;
+                coord_type y1 = m_y1;
+                unsigned   f1 = m_f1;
+                coord_type y3, y4;
+                unsigned   f3, f4;
+
+                switch(((f1 & 5) << 1) | (f2 & 5))
+                {
+                case 0: // Visible by X
+                    line_clip_y(ras, x1, y1, x2, y2, f1, f2);
+                    break;
+
+                case 1: // x2 > clip.x2
+                    y3 = y1 + Conv::mul_div(m_clip_box.x2-x1, y2-y1, x2-x1);
+                    f3 = clipping_flags_y(y3, m_clip_box);
+                    line_clip_y(ras, x1, y1, m_clip_box.x2, y3, f1, f3);
+                    line_clip_y(ras, m_clip_box.x2, y3, m_clip_box.x2, y2, f3, f2);
+                    break;
+
+                case 2: // x1 > clip.x2
+                    y3 = y1 + Conv::mul_div(m_clip_box.x2-x1, y2-y1, x2-x1);
+                    f3 = clipping_flags_y(y3, m_clip_box);
+                    line_clip_y(ras, m_clip_box.x2, y1, m_clip_box.x2, y3, f1, f3);
+                    line_clip_y(ras, m_clip_box.x2, y3, x2, y2, f3, f2);
+                    break;
+
+                case 3: // x1 > clip.x2 && x2 > clip.x2
+                    line_clip_y(ras, m_clip_box.x2, y1, m_clip_box.x2, y2, f1, f2);
+                    break;
+
+                case 4: // x2 < clip.x1
+                    y3 = y1 + Conv::mul_div(m_clip_box.x1-x1, y2-y1, x2-x1);
+                    f3 = clipping_flags_y(y3, m_clip_box);
+                    line_clip_y(ras, x1, y1, m_clip_box.x1, y3, f1, f3);
+                    line_clip_y(ras, m_clip_box.x1, y3, m_clip_box.x1, y2, f3, f2);
+                    break;
+
+                case 6: // x1 > clip.x2 && x2 < clip.x1
+                    y3 = y1 + Conv::mul_div(m_clip_box.x2-x1, y2-y1, x2-x1);
+                    y4 = y1 + Conv::mul_div(m_clip_box.x1-x1, y2-y1, x2-x1);
+                    f3 = clipping_flags_y(y3, m_clip_box);
+                    f4 = clipping_flags_y(y4, m_clip_box);
+                    line_clip_y(ras, m_clip_box.x2, y1, m_clip_box.x2, y3, f1, f3);
+                    line_clip_y(ras, m_clip_box.x2, y3, m_clip_box.x1, y4, f3, f4);
+                    line_clip_y(ras, m_clip_box.x1, y4, m_clip_box.x1, y2, f4, f2);
+                    break;
+
+                case 8: // x1 < clip.x1
+                    y3 = y1 + Conv::mul_div(m_clip_box.x1-x1, y2-y1, x2-x1);
+                    f3 = clipping_flags_y(y3, m_clip_box);
+                    line_clip_y(ras, m_clip_box.x1, y1, m_clip_box.x1, y3, f1, f3);
+                    line_clip_y(ras, m_clip_box.x1, y3, x2, y2, f3, f2);
+                    break;
+
+                case 9:  // x1 < clip.x1 && x2 > clip.x2
+                    y3 = y1 + Conv::mul_div(m_clip_box.x1-x1, y2-y1, x2-x1);
+                    y4 = y1 + Conv::mul_div(m_clip_box.x2-x1, y2-y1, x2-x1);
+                    f3 = clipping_flags_y(y3, m_clip_box);
+                    f4 = clipping_flags_y(y4, m_clip_box);
+                    line_clip_y(ras, m_clip_box.x1, y1, m_clip_box.x1, y3, f1, f3);
+                    line_clip_y(ras, m_clip_box.x1, y3, m_clip_box.x2, y4, f3, f4);
+                    line_clip_y(ras, m_clip_box.x2, y4, m_clip_box.x2, y2, f4, f2);
+                    break;
+
+                case 12: // x1 < clip.x1 && x2 < clip.x1
+                    line_clip_y(ras, m_clip_box.x1, y1, m_clip_box.x1, y2, f1, f2);
+                    break;
+                }
+                m_f1 = f2;
+            }
+            else
+            {
+                ras.line(Conv::xi(m_x1), Conv::yi(m_y1), 
+                         Conv::xi(x2),   Conv::yi(y2)); 
+            }
+            m_x1 = x2;
+            m_y1 = y2;
+        }
+
+
+    private:
+        rect_type        m_clip_box;
+        coord_type       m_x1;
+        coord_type       m_y1;
+        unsigned         m_f1;
+        bool             m_clipping;
+    };
+
+
+
+
+    //---------------------------------------------------rasterizer_sl_no_clip
+    class rasterizer_sl_no_clip
+    {
+    public:
+        typedef ras_conv_int conv_type;
+        typedef int          coord_type;
+
+        rasterizer_sl_no_clip() : m_x1(0), m_y1(0) {}
+
+        void reset_clipping() {}
+        void clip_box(coord_type x1, coord_type y1, coord_type x2, coord_type y2) {}
+        void move_to(coord_type x1, coord_type y1) { m_x1 = x1; m_y1 = y1; }
+
+        template<class Rasterizer>
+        void line_to(Rasterizer& ras, coord_type x2, coord_type y2) 
+        { 
+            ras.line(m_x1, m_y1, x2, y2); 
+            m_x1 = x2; 
+            m_y1 = y2;
+        }
+
+    private:
+        int m_x1, m_y1;
+    };
+
+
+    //                                         -----rasterizer_sl_clip_int
+    //                                         -----rasterizer_sl_clip_int_sat
+    //                                         -----rasterizer_sl_clip_int_3x
+    //                                         -----rasterizer_sl_clip_dbl
+    //                                         -----rasterizer_sl_clip_dbl_3x
+    //------------------------------------------------------------------------
+    typedef rasterizer_sl_clip<ras_conv_int>     rasterizer_sl_clip_int;
+    typedef rasterizer_sl_clip<ras_conv_int_sat> rasterizer_sl_clip_int_sat;
+    typedef rasterizer_sl_clip<ras_conv_int_3x>  rasterizer_sl_clip_int_3x;
+    typedef rasterizer_sl_clip<ras_conv_dbl>     rasterizer_sl_clip_dbl;
+    typedef rasterizer_sl_clip<ras_conv_dbl_3x>  rasterizer_sl_clip_dbl_3x;
+
+
+}
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_renderer_base.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_renderer_base.h
new file mode 100644
index 0000000000..527c62f789
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_renderer_base.h
@@ -0,0 +1,731 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// class renderer_base
+//
+//----------------------------------------------------------------------------
+
+#ifndef AGG_RENDERER_BASE_INCLUDED
+#define AGG_RENDERER_BASE_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_rendering_buffer.h"
+
+namespace agg
+{
+
+    //-----------------------------------------------------------renderer_base
+    template<class PixelFormat> class renderer_base
+    {
+    public:
+        typedef PixelFormat pixfmt_type;
+        typedef typename pixfmt_type::color_type color_type;
+        typedef typename pixfmt_type::row_data row_data;
+
+        //--------------------------------------------------------------------
+        renderer_base() : m_ren(0), m_clip_box(1, 1, 0, 0) {}
+        explicit renderer_base(pixfmt_type& ren) :
+            m_ren(&ren),
+            m_clip_box(0, 0, ren.width() - 1, ren.height() - 1)
+        {}
+        void attach(pixfmt_type& ren)
+        {
+            m_ren = &ren;
+            m_clip_box = rect_i(0, 0, ren.width() - 1, ren.height() - 1);
+        }
+
+        //--------------------------------------------------------------------
+        const pixfmt_type& ren() const { return *m_ren;  }
+        pixfmt_type& ren() { return *m_ren;  }
+          
+        //--------------------------------------------------------------------
+        unsigned width()  const { return m_ren->width();  }
+        unsigned height() const { return m_ren->height(); }
+
+        //--------------------------------------------------------------------
+        bool clip_box(int x1, int y1, int x2, int y2)
+        {
+            rect_i cb(x1, y1, x2, y2);
+            cb.normalize();
+            if(cb.clip(rect_i(0, 0, width() - 1, height() - 1)))
+            {
+                m_clip_box = cb;
+                return true;
+            }
+            m_clip_box.x1 = 1;
+            m_clip_box.y1 = 1;
+            m_clip_box.x2 = 0;
+            m_clip_box.y2 = 0;
+            return false;
+        }
+
+        //--------------------------------------------------------------------
+        void reset_clipping(bool visibility)
+        {
+            if(visibility)
+            {
+                m_clip_box.x1 = 0;
+                m_clip_box.y1 = 0;
+                m_clip_box.x2 = width() - 1;
+                m_clip_box.y2 = height() - 1;
+            }
+            else
+            {
+                m_clip_box.x1 = 1;
+                m_clip_box.y1 = 1;
+                m_clip_box.x2 = 0;
+                m_clip_box.y2 = 0;
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void clip_box_naked(int x1, int y1, int x2, int y2)
+        {
+            m_clip_box.x1 = x1;
+            m_clip_box.y1 = y1;
+            m_clip_box.x2 = x2;
+            m_clip_box.y2 = y2;
+        }
+
+        //--------------------------------------------------------------------
+        bool inbox(int x, int y) const
+        {
+            return x >= m_clip_box.x1 && y >= m_clip_box.y1 &&
+                   x <= m_clip_box.x2 && y <= m_clip_box.y2;
+        }
+
+        //--------------------------------------------------------------------
+        const rect_i& clip_box() const { return m_clip_box;    }
+        int           xmin()     const { return m_clip_box.x1; }
+        int           ymin()     const { return m_clip_box.y1; }
+        int           xmax()     const { return m_clip_box.x2; }
+        int           ymax()     const { return m_clip_box.y2; }
+
+        //--------------------------------------------------------------------
+        const rect_i& bounding_clip_box() const { return m_clip_box;    }
+        int           bounding_xmin()     const { return m_clip_box.x1; }
+        int           bounding_ymin()     const { return m_clip_box.y1; }
+        int           bounding_xmax()     const { return m_clip_box.x2; }
+        int           bounding_ymax()     const { return m_clip_box.y2; }
+
+        //--------------------------------------------------------------------
+        void clear(const color_type& c)
+        {
+            unsigned y;
+            if(width())
+            {
+                for(y = 0; y < height(); y++)
+                {
+                    m_ren->copy_hline(0, y, width(), c);
+                }
+            }
+        }
+          
+
+        //--------------------------------------------------------------------
+        void fill(const color_type& c)
+        {
+            unsigned y;
+            if(width())
+            {
+                for(y = 0; y < height(); y++)
+                {
+                    m_ren->blend_hline(0, y, width(), c, cover_mask);
+                }
+            }
+        }
+        
+        //--------------------------------------------------------------------
+        void copy_pixel(int x, int y, const color_type& c)
+        {
+            if(inbox(x, y))
+            {
+                m_ren->copy_pixel(x, y, c);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void blend_pixel(int x, int y, const color_type& c, cover_type cover)
+        {
+            if(inbox(x, y))
+            {
+                m_ren->blend_pixel(x, y, c, cover);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        color_type pixel(int x, int y) const
+        {
+            return inbox(x, y) ? 
+                   m_ren->pixel(x, y) :
+                   color_type::no_color();
+        }
+
+        //--------------------------------------------------------------------
+        void copy_hline(int x1, int y, int x2, const color_type& c)
+        {
+            if(x1 > x2) { int t = x2; x2 = x1; x1 = t; }
+            if(y  > ymax()) return;
+            if(y  < ymin()) return;
+            if(x1 > xmax()) return;
+            if(x2 < xmin()) return;
+
+            if(x1 < xmin()) x1 = xmin();
+            if(x2 > xmax()) x2 = xmax();
+
+            m_ren->copy_hline(x1, y, x2 - x1 + 1, c);
+        }
+
+        //--------------------------------------------------------------------
+        void copy_vline(int x, int y1, int y2, const color_type& c)
+        {
+            if(y1 > y2) { int t = y2; y2 = y1; y1 = t; }
+            if(x  > xmax()) return;
+            if(x  < xmin()) return;
+            if(y1 > ymax()) return;
+            if(y2 < ymin()) return;
+
+            if(y1 < ymin()) y1 = ymin();
+            if(y2 > ymax()) y2 = ymax();
+
+            m_ren->copy_vline(x, y1, y2 - y1 + 1, c);
+        }
+
+        //--------------------------------------------------------------------
+        void blend_hline(int x1, int y, int x2, 
+                         const color_type& c, cover_type cover)
+        {
+            if(x1 > x2) { int t = x2; x2 = x1; x1 = t; }
+            if(y  > ymax()) return;
+            if(y  < ymin()) return;
+            if(x1 > xmax()) return;
+            if(x2 < xmin()) return;
+
+            if(x1 < xmin()) x1 = xmin();
+            if(x2 > xmax()) x2 = xmax();
+
+            m_ren->blend_hline(x1, y, x2 - x1 + 1, c, cover);
+        }
+
+        //--------------------------------------------------------------------
+        void blend_vline(int x, int y1, int y2, 
+                         const color_type& c, cover_type cover)
+        {
+            if(y1 > y2) { int t = y2; y2 = y1; y1 = t; }
+            if(x  > xmax()) return;
+            if(x  < xmin()) return;
+            if(y1 > ymax()) return;
+            if(y2 < ymin()) return;
+
+            if(y1 < ymin()) y1 = ymin();
+            if(y2 > ymax()) y2 = ymax();
+
+            m_ren->blend_vline(x, y1, y2 - y1 + 1, c, cover);
+        }
+
+
+        //--------------------------------------------------------------------
+        void copy_bar(int x1, int y1, int x2, int y2, const color_type& c)
+        {
+            rect_i rc(x1, y1, x2, y2);
+            rc.normalize();
+            if(rc.clip(clip_box()))
+            {
+                int y;
+                for(y = rc.y1; y <= rc.y2; y++)
+                {
+                    m_ren->copy_hline(rc.x1, y, unsigned(rc.x2 - rc.x1 + 1), c);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void blend_bar(int x1, int y1, int x2, int y2, 
+                       const color_type& c, cover_type cover)
+        {
+            rect_i rc(x1, y1, x2, y2);
+            rc.normalize();
+            if(rc.clip(clip_box()))
+            {
+                int y;
+                for(y = rc.y1; y <= rc.y2; y++)
+                {
+                    m_ren->blend_hline(rc.x1,
+                                       y,
+                                       unsigned(rc.x2 - rc.x1 + 1), 
+                                       c, 
+                                       cover);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void blend_solid_hspan(int x, int y, int len, 
+                               const color_type& c, 
+                               const cover_type* covers)
+        {
+            if(y > ymax()) return;
+            if(y < ymin()) return;
+
+            if(x < xmin())
+            {
+                len -= xmin() - x;
+                if(len <= 0) return;
+                covers += xmin() - x;
+                x = xmin();
+            }
+            if(x + len > xmax())
+            {
+                len = xmax() - x + 1;
+                if(len <= 0) return;
+            }
+            m_ren->blend_solid_hspan(x, y, len, c, covers);
+        }
+
+        //--------------------------------------------------------------------
+        void blend_solid_vspan(int x, int y, int len, 
+                               const color_type& c, 
+                               const cover_type* covers)
+        {
+            if(x > xmax()) return;
+            if(x < xmin()) return;
+
+            if(y < ymin())
+            {
+                len -= ymin() - y;
+                if(len <= 0) return;
+                covers += ymin() - y;
+                y = ymin();
+            }
+            if(y + len > ymax())
+            {
+                len = ymax() - y + 1;
+                if(len <= 0) return;
+            }
+            m_ren->blend_solid_vspan(x, y, len, c, covers);
+        }
+
+
+        //--------------------------------------------------------------------
+        void copy_color_hspan(int x, int y, int len, const color_type* colors)
+        {
+            if(y > ymax()) return;
+            if(y < ymin()) return;
+
+            if(x < xmin())
+            {
+                int d = xmin() - x;
+                len -= d;
+                if(len <= 0) return;
+                colors += d;
+                x = xmin();
+            }
+            if(x + len > xmax())
+            {
+                len = xmax() - x + 1;
+                if(len <= 0) return;
+            }
+            m_ren->copy_color_hspan(x, y, len, colors);
+        }
+
+
+        //--------------------------------------------------------------------
+        void copy_color_vspan(int x, int y, int len, const color_type* colors)
+        {
+            if(x > xmax()) return;
+            if(x < xmin()) return;
+
+            if(y < ymin())
+            {
+                int d = ymin() - y;
+                len -= d;
+                if(len <= 0) return;
+                colors += d;
+                y = ymin();
+            }
+            if(y + len > ymax())
+            {
+                len = ymax() - y + 1;
+                if(len <= 0) return;
+            }
+            m_ren->copy_color_vspan(x, y, len, colors);
+        }
+
+
+        //--------------------------------------------------------------------
+        void blend_color_hspan(int x, int y, int len, 
+                               const color_type* colors, 
+                               const cover_type* covers,
+                               cover_type cover = agg::cover_full)
+        {
+            if(y > ymax()) return;
+            if(y < ymin()) return;
+
+            if(x < xmin())
+            {
+                int d = xmin() - x;
+                len -= d;
+                if(len <= 0) return;
+                if(covers) covers += d;
+                colors += d;
+                x = xmin();
+            }
+            if(x + len > xmax())
+            {
+                len = xmax() - x + 1;
+                if(len <= 0) return;
+            }
+            m_ren->blend_color_hspan(x, y, len, colors, covers, cover);
+        }
+
+        //--------------------------------------------------------------------
+        void blend_color_vspan(int x, int y, int len, 
+                               const color_type* colors, 
+                               const cover_type* covers,
+                               cover_type cover = agg::cover_full)
+        {
+            if(x > xmax()) return;
+            if(x < xmin()) return;
+
+            if(y < ymin())
+            {
+                int d = ymin() - y;
+                len -= d;
+                if(len <= 0) return;
+                if(covers) covers += d;
+                colors += d;
+                y = ymin();
+            }
+            if(y + len > ymax())
+            {
+                len = ymax() - y + 1;
+                if(len <= 0) return;
+            }
+            m_ren->blend_color_vspan(x, y, len, colors, covers, cover);
+        }
+
+        //--------------------------------------------------------------------
+        rect_i clip_rect_area(rect_i& dst, rect_i& src, int wsrc, int hsrc) const
+        {
+            rect_i rc(0,0,0,0);
+            rect_i cb = clip_box();
+            ++cb.x2;
+            ++cb.y2;
+
+            if(src.x1 < 0)
+            {
+                dst.x1 -= src.x1;
+                src.x1 = 0;
+            }
+            if(src.y1 < 0)
+            {
+                dst.y1 -= src.y1;
+                src.y1 = 0;
+            }
+
+            if(src.x2 > wsrc) src.x2 = wsrc;
+            if(src.y2 > hsrc) src.y2 = hsrc;
+
+            if(dst.x1 < cb.x1)
+            {
+                src.x1 += cb.x1 - dst.x1;
+                dst.x1 = cb.x1;
+            }
+            if(dst.y1 < cb.y1)
+            {
+                src.y1 += cb.y1 - dst.y1;
+                dst.y1 = cb.y1;
+            }
+
+            if(dst.x2 > cb.x2) dst.x2 = cb.x2;
+            if(dst.y2 > cb.y2) dst.y2 = cb.y2;
+
+            rc.x2 = dst.x2 - dst.x1;
+            rc.y2 = dst.y2 - dst.y1;
+
+            if(rc.x2 > src.x2 - src.x1) rc.x2 = src.x2 - src.x1;
+            if(rc.y2 > src.y2 - src.y1) rc.y2 = src.y2 - src.y1;
+            return rc;
+        }
+
+        //--------------------------------------------------------------------
+        template<class RenBuf>
+        void copy_from(const RenBuf& src, 
+                       const rect_i* rect_src_ptr = 0, 
+                       int dx = 0, 
+                       int dy = 0)
+        {
+            rect_i rsrc(0, 0, src.width(), src.height());
+            if(rect_src_ptr)
+            {
+                rsrc.x1 = rect_src_ptr->x1; 
+                rsrc.y1 = rect_src_ptr->y1;
+                rsrc.x2 = rect_src_ptr->x2 + 1;
+                rsrc.y2 = rect_src_ptr->y2 + 1;
+            }
+
+            // Version with xdst, ydst (absolute positioning)
+            //rect_i rdst(xdst, ydst, xdst + rsrc.x2 - rsrc.x1, ydst + rsrc.y2 - rsrc.y1);
+
+            // Version with dx, dy (relative positioning)
+            rect_i rdst(rsrc.x1 + dx, rsrc.y1 + dy, rsrc.x2 + dx, rsrc.y2 + dy);
+
+            rect_i rc = clip_rect_area(rdst, rsrc, src.width(), src.height());
+
+            if(rc.x2 > 0)
+            {
+                int incy = 1;
+                if(rdst.y1 > rsrc.y1)
+                {
+                    rsrc.y1 += rc.y2 - 1;
+                    rdst.y1 += rc.y2 - 1;
+                    incy = -1;
+                }
+                while(rc.y2 > 0)
+                {
+                    m_ren->copy_from(src, 
+                                     rdst.x1, rdst.y1,
+                                     rsrc.x1, rsrc.y1,
+                                     rc.x2);
+                    rdst.y1 += incy;
+                    rsrc.y1 += incy;
+                    --rc.y2;
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        template<class SrcPixelFormatRenderer>
+        void blend_from(const SrcPixelFormatRenderer& src, 
+                        const rect_i* rect_src_ptr = 0, 
+                        int dx = 0, 
+                        int dy = 0,
+                        cover_type cover = agg::cover_full)
+        {
+            rect_i rsrc(0, 0, src.width(), src.height());
+            if(rect_src_ptr)
+            {
+                rsrc.x1 = rect_src_ptr->x1; 
+                rsrc.y1 = rect_src_ptr->y1;
+                rsrc.x2 = rect_src_ptr->x2 + 1;
+                rsrc.y2 = rect_src_ptr->y2 + 1;
+            }
+
+            // Version with xdst, ydst (absolute positioning)
+            //rect_i rdst(xdst, ydst, xdst + rsrc.x2 - rsrc.x1, ydst + rsrc.y2 - rsrc.y1);
+
+            // Version with dx, dy (relative positioning)
+            rect_i rdst(rsrc.x1 + dx, rsrc.y1 + dy, rsrc.x2 + dx, rsrc.y2 + dy);
+            rect_i rc = clip_rect_area(rdst, rsrc, src.width(), src.height());
+
+            if(rc.x2 > 0)
+            {
+                int incy = 1;
+                if(rdst.y1 > rsrc.y1)
+                {
+                    rsrc.y1 += rc.y2 - 1;
+                    rdst.y1 += rc.y2 - 1;
+                    incy = -1;
+                }
+                while(rc.y2 > 0)
+                {
+                    typename SrcPixelFormatRenderer::row_data rw = src.row(rsrc.y1);
+                    if(rw.ptr)
+                    {
+                        int x1src = rsrc.x1;
+                        int x1dst = rdst.x1;
+                        int len   = rc.x2;
+                        if(rw.x1 > x1src)
+                        {
+                            x1dst += rw.x1 - x1src;
+                            len   -= rw.x1 - x1src;
+                            x1src  = rw.x1;
+                        }
+                        if(len > 0)
+                        {
+                            if(x1src + len-1 > rw.x2)
+                            {
+                                len -= x1src + len - rw.x2 - 1;
+                            }
+                            if(len > 0)
+                            {
+                                m_ren->blend_from(src,
+                                                  x1dst, rdst.y1,
+                                                  x1src, rsrc.y1,
+                                                  len,
+                                                  cover);
+                            }
+                        }
+                    }
+                    rdst.y1 += incy;
+                    rsrc.y1 += incy;
+                    --rc.y2;
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        template<class SrcPixelFormatRenderer>
+        void blend_from_color(const SrcPixelFormatRenderer& src, 
+                              const color_type& color,
+                              const rect_i* rect_src_ptr = 0, 
+                              int dx = 0, 
+                              int dy = 0,
+                              cover_type cover = agg::cover_full)
+        {
+            rect_i rsrc(0, 0, src.width(), src.height());
+            if(rect_src_ptr)
+            {
+                rsrc.x1 = rect_src_ptr->x1; 
+                rsrc.y1 = rect_src_ptr->y1;
+                rsrc.x2 = rect_src_ptr->x2 + 1;
+                rsrc.y2 = rect_src_ptr->y2 + 1;
+            }
+
+            // Version with xdst, ydst (absolute positioning)
+            //rect_i rdst(xdst, ydst, xdst + rsrc.x2 - rsrc.x1, ydst + rsrc.y2 - rsrc.y1);
+
+            // Version with dx, dy (relative positioning)
+            rect_i rdst(rsrc.x1 + dx, rsrc.y1 + dy, rsrc.x2 + dx, rsrc.y2 + dy);
+            rect_i rc = clip_rect_area(rdst, rsrc, src.width(), src.height());
+
+            if(rc.x2 > 0)
+            {
+                int incy = 1;
+                if(rdst.y1 > rsrc.y1)
+                {
+                    rsrc.y1 += rc.y2 - 1;
+                    rdst.y1 += rc.y2 - 1;
+                    incy = -1;
+                }
+                while(rc.y2 > 0)
+                {
+                    typename SrcPixelFormatRenderer::row_data rw = src.row(rsrc.y1);
+                    if(rw.ptr)
+                    {
+                        int x1src = rsrc.x1;
+                        int x1dst = rdst.x1;
+                        int len   = rc.x2;
+                        if(rw.x1 > x1src)
+                        {
+                            x1dst += rw.x1 - x1src;
+                            len   -= rw.x1 - x1src;
+                            x1src  = rw.x1;
+                        }
+                        if(len > 0)
+                        {
+                            if(x1src + len-1 > rw.x2)
+                            {
+                                len -= x1src + len - rw.x2 - 1;
+                            }
+                            if(len > 0)
+                            {
+                                m_ren->blend_from_color(src,
+                                                        color,
+                                                        x1dst, rdst.y1,
+                                                        x1src, rsrc.y1,
+                                                        len,
+                                                        cover);
+                            }
+                        }
+                    }
+                    rdst.y1 += incy;
+                    rsrc.y1 += incy;
+                    --rc.y2;
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        template<class SrcPixelFormatRenderer>
+        void blend_from_lut(const SrcPixelFormatRenderer& src, 
+                            const color_type* color_lut,
+                            const rect_i* rect_src_ptr = 0, 
+                            int dx = 0, 
+                            int dy = 0,
+                            cover_type cover = agg::cover_full)
+        {
+            rect_i rsrc(0, 0, src.width(), src.height());
+            if(rect_src_ptr)
+            {
+                rsrc.x1 = rect_src_ptr->x1; 
+                rsrc.y1 = rect_src_ptr->y1;
+                rsrc.x2 = rect_src_ptr->x2 + 1;
+                rsrc.y2 = rect_src_ptr->y2 + 1;
+            }
+
+            // Version with xdst, ydst (absolute positioning)
+            //rect_i rdst(xdst, ydst, xdst + rsrc.x2 - rsrc.x1, ydst + rsrc.y2 - rsrc.y1);
+
+            // Version with dx, dy (relative positioning)
+            rect_i rdst(rsrc.x1 + dx, rsrc.y1 + dy, rsrc.x2 + dx, rsrc.y2 + dy);
+            rect_i rc = clip_rect_area(rdst, rsrc, src.width(), src.height());
+
+            if(rc.x2 > 0)
+            {
+                int incy = 1;
+                if(rdst.y1 > rsrc.y1)
+                {
+                    rsrc.y1 += rc.y2 - 1;
+                    rdst.y1 += rc.y2 - 1;
+                    incy = -1;
+                }
+                while(rc.y2 > 0)
+                {
+                    typename SrcPixelFormatRenderer::row_data rw = src.row(rsrc.y1);
+                    if(rw.ptr)
+                    {
+                        int x1src = rsrc.x1;
+                        int x1dst = rdst.x1;
+                        int len   = rc.x2;
+                        if(rw.x1 > x1src)
+                        {
+                            x1dst += rw.x1 - x1src;
+                            len   -= rw.x1 - x1src;
+                            x1src  = rw.x1;
+                        }
+                        if(len > 0)
+                        {
+                            if(x1src + len-1 > rw.x2)
+                            {
+                                len -= x1src + len - rw.x2 - 1;
+                            }
+                            if(len > 0)
+                            {
+                                m_ren->blend_from_lut(src,
+                                                      color_lut,
+                                                      x1dst, rdst.y1,
+                                                      x1src, rsrc.y1,
+                                                      len,
+                                                      cover);
+                            }
+                        }
+                    }
+                    rdst.y1 += incy;
+                    rsrc.y1 += incy;
+                    --rc.y2;
+                }
+            }
+        }
+
+    private:
+        pixfmt_type* m_ren;
+        rect_i       m_clip_box;
+    };
+
+
+}
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_renderer_scanline.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_renderer_scanline.h
new file mode 100644
index 0000000000..6d65056c53
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_renderer_scanline.h
@@ -0,0 +1,852 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_RENDERER_SCANLINE_INCLUDED
+#define AGG_RENDERER_SCANLINE_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_renderer_base.h"
+
+namespace agg
+{
+
+    //================================================render_scanline_aa_solid
+    template<class Scanline, class BaseRenderer, class ColorT> 
+    void render_scanline_aa_solid(const Scanline& sl, 
+                                  BaseRenderer& ren, 
+                                  const ColorT& color)
+    {
+        int y = sl.y();
+        unsigned num_spans = sl.num_spans();
+        typename Scanline::const_iterator span = sl.begin();
+
+        for(;;)
+        {
+            int x = span->x;
+            if(span->len > 0)
+            {
+                ren.blend_solid_hspan(x, y, (unsigned)span->len, 
+                                      color, 
+                                      span->covers);
+            }
+            else
+            {
+                ren.blend_hline(x, y, (unsigned)(x - span->len - 1), 
+                                color, 
+                                *(span->covers));
+            }
+            if(--num_spans == 0) break;
+            ++span;
+        }
+    }
+
+    //===============================================render_scanlines_aa_solid
+    template<class Rasterizer, class Scanline, 
+             class BaseRenderer, class ColorT>
+    void render_scanlines_aa_solid(Rasterizer& ras, Scanline& sl, 
+                                   BaseRenderer& ren, const ColorT& color)
+    {
+        if(ras.rewind_scanlines())
+        {
+            // Explicitly convert "color" to the BaseRenderer color type.
+            // For example, it can be called with color type "rgba", while
+            // "rgba8" is needed. Otherwise it will be implicitly 
+            // converted in the loop many times.
+            //----------------------
+            typename BaseRenderer::color_type ren_color(color);
+
+            sl.reset(ras.min_x(), ras.max_x());
+            while(ras.sweep_scanline(sl))
+            {
+                //render_scanline_aa_solid(sl, ren, ren_color);
+
+                // This code is equivalent to the above call (copy/paste). 
+                // It's just a "manual" optimization for old compilers,
+                // like Microsoft Visual C++ v6.0
+                //-------------------------------
+                int y = sl.y();
+                unsigned num_spans = sl.num_spans();
+                typename Scanline::const_iterator span = sl.begin();
+
+                for(;;)
+                {
+                    int x = span->x;
+                    if(span->len > 0)
+                    {
+                        ren.blend_solid_hspan(x, y, (unsigned)span->len, 
+                                              ren_color, 
+                                              span->covers);
+                    }
+                    else
+                    {
+                        ren.blend_hline(x, y, (unsigned)(x - span->len - 1), 
+                                        ren_color, 
+                                        *(span->covers));
+                    }
+                    if(--num_spans == 0) break;
+                    ++span;
+                }
+            }
+        }
+    }
+
+    //==============================================renderer_scanline_aa_solid
+    template<class BaseRenderer> class renderer_scanline_aa_solid
+    {
+    public:
+        typedef BaseRenderer base_ren_type;
+        typedef typename base_ren_type::color_type color_type;
+
+        //--------------------------------------------------------------------
+        renderer_scanline_aa_solid() : m_ren(0) {}
+        explicit renderer_scanline_aa_solid(base_ren_type& ren) : m_ren(&ren) {}
+        void attach(base_ren_type& ren)
+        {
+            m_ren = &ren;
+        }
+        
+        //--------------------------------------------------------------------
+        void color(const color_type& c) { m_color = c; }
+        const color_type& color() const { return m_color; }
+
+        //--------------------------------------------------------------------
+        void prepare() {}
+
+        //--------------------------------------------------------------------
+        template<class Scanline> void render(const Scanline& sl)
+        {
+            render_scanline_aa_solid(sl, *m_ren, m_color);
+        }
+        
+    private:
+        base_ren_type* m_ren;
+        color_type m_color;
+    };
+
+
+
+
+
+
+
+
+
+
+
+
+
+    //======================================================render_scanline_aa
+    template<class Scanline, class BaseRenderer, 
+             class SpanAllocator, class SpanGenerator> 
+    void render_scanline_aa(const Scanline& sl, BaseRenderer& ren, 
+                            SpanAllocator& alloc, SpanGenerator& span_gen)
+    {
+        int y = sl.y();
+
+        unsigned num_spans = sl.num_spans();
+        typename Scanline::const_iterator span = sl.begin();
+        for(;;)
+        {
+            int x = span->x;
+            int len = span->len;
+            const typename Scanline::cover_type* covers = span->covers;
+
+            if(len < 0) len = -len;
+            typename BaseRenderer::color_type* colors = alloc.allocate(len);
+            span_gen.generate(colors, x, y, len);
+            ren.blend_color_hspan(x, y, len, colors, 
+                                  (span->len < 0) ? 0 : covers, *covers);
+
+            if(--num_spans == 0) break;
+            ++span;
+        }
+    }
+
+    //=====================================================render_scanlines_aa
+    template<class Rasterizer, class Scanline, class BaseRenderer, 
+             class SpanAllocator, class SpanGenerator>
+    void render_scanlines_aa(Rasterizer& ras, Scanline& sl, BaseRenderer& ren, 
+                             SpanAllocator& alloc, SpanGenerator& span_gen)
+    {
+        if(ras.rewind_scanlines())
+        {
+            sl.reset(ras.min_x(), ras.max_x());
+            span_gen.prepare();
+            while(ras.sweep_scanline(sl))
+            {
+                render_scanline_aa(sl, ren, alloc, span_gen);
+            }
+        }
+    }
+
+    //====================================================renderer_scanline_aa
+    template<class BaseRenderer, class SpanAllocator, class SpanGenerator> 
+    class renderer_scanline_aa
+    {
+    public:
+        typedef BaseRenderer  base_ren_type;
+        typedef SpanAllocator alloc_type;
+        typedef SpanGenerator span_gen_type;
+
+        //--------------------------------------------------------------------
+        renderer_scanline_aa() : m_ren(0), m_alloc(0), m_span_gen(0) {}
+        renderer_scanline_aa(base_ren_type& ren, 
+                             alloc_type& alloc, 
+                             span_gen_type& span_gen) :
+            m_ren(&ren),
+            m_alloc(&alloc),
+            m_span_gen(&span_gen)
+        {}
+        void attach(base_ren_type& ren, 
+                    alloc_type& alloc, 
+                    span_gen_type& span_gen)
+        {
+            m_ren = &ren;
+            m_alloc = &alloc;
+            m_span_gen = &span_gen;
+        }
+        
+        //--------------------------------------------------------------------
+        void prepare() { m_span_gen->prepare(); }
+
+        //--------------------------------------------------------------------
+        template<class Scanline> void render(const Scanline& sl)
+        {
+            render_scanline_aa(sl, *m_ren, *m_alloc, *m_span_gen);
+        }
+
+    private:
+        base_ren_type* m_ren;
+        alloc_type*    m_alloc;
+        span_gen_type* m_span_gen;
+    };
+
+
+
+
+
+
+    //===============================================render_scanline_bin_solid
+    template<class Scanline, class BaseRenderer, class ColorT> 
+    void render_scanline_bin_solid(const Scanline& sl, 
+                                   BaseRenderer& ren, 
+                                   const ColorT& color)
+    {
+        unsigned num_spans = sl.num_spans();
+        typename Scanline::const_iterator span = sl.begin();
+        for(;;)
+        {
+            ren.blend_hline(span->x, 
+                            sl.y(), 
+                            span->x - 1 + ((span->len < 0) ? 
+                                              -span->len : 
+                                               span->len), 
+                               color, 
+                               cover_full);
+            if(--num_spans == 0) break;
+            ++span;
+        }
+    }
+
+    //==============================================render_scanlines_bin_solid
+    template<class Rasterizer, class Scanline, 
+             class BaseRenderer, class ColorT>
+    void render_scanlines_bin_solid(Rasterizer& ras, Scanline& sl, 
+                                    BaseRenderer& ren, const ColorT& color)
+    {
+        if(ras.rewind_scanlines())
+        {
+            // Explicitly convert "color" to the BaseRenderer color type.
+            // For example, it can be called with color type "rgba", while
+            // "rgba8" is needed. Otherwise it will be implicitly 
+            // converted in the loop many times.
+            //----------------------
+            typename BaseRenderer::color_type ren_color(color);
+
+            sl.reset(ras.min_x(), ras.max_x());
+            while(ras.sweep_scanline(sl))
+            {
+                //render_scanline_bin_solid(sl, ren, ren_color);
+
+                // This code is equivalent to the above call (copy/paste). 
+                // It's just a "manual" optimization for old compilers,
+                // like Microsoft Visual C++ v6.0
+                //-------------------------------
+                unsigned num_spans = sl.num_spans();
+                typename Scanline::const_iterator span = sl.begin();
+                for(;;)
+                {
+                    ren.blend_hline(span->x, 
+                                    sl.y(), 
+                                    span->x - 1 + ((span->len < 0) ? 
+                                                      -span->len : 
+                                                       span->len), 
+                                       ren_color, 
+                                       cover_full);
+                    if(--num_spans == 0) break;
+                    ++span;
+                }
+            }
+        }
+    }
+
+    //=============================================renderer_scanline_bin_solid
+    template<class BaseRenderer> class renderer_scanline_bin_solid
+    {
+    public:
+        typedef BaseRenderer base_ren_type;
+        typedef typename base_ren_type::color_type color_type;
+
+        //--------------------------------------------------------------------
+        renderer_scanline_bin_solid() : m_ren(0) {}
+        explicit renderer_scanline_bin_solid(base_ren_type& ren) : m_ren(&ren) {}
+        void attach(base_ren_type& ren)
+        {
+            m_ren = &ren;
+        }
+        
+        //--------------------------------------------------------------------
+        void color(const color_type& c) { m_color = c; }
+        const color_type& color() const { return m_color; }
+
+        //--------------------------------------------------------------------
+        void prepare() {}
+
+        //--------------------------------------------------------------------
+        template<class Scanline> void render(const Scanline& sl)
+        {
+            render_scanline_bin_solid(sl, *m_ren, m_color);
+        }
+        
+    private:
+        base_ren_type* m_ren;
+        color_type m_color;
+    };
+
+
+
+
+
+
+
+
+    //======================================================render_scanline_bin
+    template<class Scanline, class BaseRenderer, 
+             class SpanAllocator, class SpanGenerator> 
+    void render_scanline_bin(const Scanline& sl, BaseRenderer& ren, 
+                             SpanAllocator& alloc, SpanGenerator& span_gen)
+    {
+        int y = sl.y();
+
+        unsigned num_spans = sl.num_spans();
+        typename Scanline::const_iterator span = sl.begin();
+        for(;;)
+        {
+            int x = span->x;
+            int len = span->len;
+            if(len < 0) len = -len;
+            typename BaseRenderer::color_type* colors = alloc.allocate(len);
+            span_gen.generate(colors, x, y, len);
+            ren.blend_color_hspan(x, y, len, colors, 0, cover_full); 
+            if(--num_spans == 0) break;
+            ++span;
+        }
+    }
+
+    //=====================================================render_scanlines_bin
+    template<class Rasterizer, class Scanline, class BaseRenderer, 
+             class SpanAllocator, class SpanGenerator>
+    void render_scanlines_bin(Rasterizer& ras, Scanline& sl, BaseRenderer& ren, 
+                              SpanAllocator& alloc, SpanGenerator& span_gen)
+    {
+        if(ras.rewind_scanlines())
+        {
+            sl.reset(ras.min_x(), ras.max_x());
+            span_gen.prepare();
+            while(ras.sweep_scanline(sl))
+            {
+                render_scanline_bin(sl, ren, alloc, span_gen);
+            }
+        }
+    }
+
+    //====================================================renderer_scanline_bin
+    template<class BaseRenderer, class SpanAllocator, class SpanGenerator> 
+    class renderer_scanline_bin
+    {
+    public:
+        typedef BaseRenderer  base_ren_type;
+        typedef SpanAllocator alloc_type;
+        typedef SpanGenerator span_gen_type;
+
+        //--------------------------------------------------------------------
+        renderer_scanline_bin() : m_ren(0), m_alloc(0), m_span_gen(0) {}
+        renderer_scanline_bin(base_ren_type& ren, 
+                              alloc_type& alloc, 
+                              span_gen_type& span_gen) :
+            m_ren(&ren),
+            m_alloc(&alloc),
+            m_span_gen(&span_gen)
+        {}
+        void attach(base_ren_type& ren, 
+                    alloc_type& alloc, 
+                    span_gen_type& span_gen)
+        {
+            m_ren = &ren;
+            m_alloc = &alloc;
+            m_span_gen = &span_gen;
+        }
+        
+        //--------------------------------------------------------------------
+        void prepare() { m_span_gen->prepare(); }
+
+        //--------------------------------------------------------------------
+        template<class Scanline> void render(const Scanline& sl)
+        {
+            render_scanline_bin(sl, *m_ren, *m_alloc, *m_span_gen);
+        }
+
+    private:
+        base_ren_type* m_ren;
+        alloc_type*    m_alloc;
+        span_gen_type* m_span_gen;
+    };
+
+
+
+
+
+
+
+
+
+
+    //========================================================render_scanlines
+    template<class Rasterizer, class Scanline, class Renderer>
+    void render_scanlines(Rasterizer& ras, Scanline& sl, Renderer& ren)
+    {
+        if(ras.rewind_scanlines())
+        {
+            sl.reset(ras.min_x(), ras.max_x());
+            ren.prepare();
+            while(ras.sweep_scanline(sl))
+            {
+                ren.render(sl);
+            }
+        }
+    }
+
+    //========================================================render_all_paths
+    template<class Rasterizer, class Scanline, class Renderer, 
+             class VertexSource, class ColorStorage, class PathId>
+    void render_all_paths(Rasterizer& ras, 
+                          Scanline& sl,
+                          Renderer& r, 
+                          VertexSource& vs, 
+                          const ColorStorage& as, 
+                          const PathId& path_id,
+                          unsigned num_paths)
+    {
+        for(unsigned i = 0; i < num_paths; i++)
+        {
+            ras.reset();
+            ras.add_path(vs, path_id[i]);
+            r.color(as[i]);
+            render_scanlines(ras, sl, r);
+        }
+    }
+
+
+
+
+
+
+    //=============================================render_scanlines_compound
+    template<class Rasterizer, 
+             class ScanlineAA, 
+             class ScanlineBin, 
+             class BaseRenderer, 
+             class SpanAllocator,
+             class StyleHandler>
+    void render_scanlines_compound(Rasterizer& ras, 
+                                   ScanlineAA& sl_aa,
+                                   ScanlineBin& sl_bin,
+                                   BaseRenderer& ren,
+                                   SpanAllocator& alloc,
+                                   StyleHandler& sh)
+    {
+        if(ras.rewind_scanlines())
+        {
+            int min_x = ras.min_x();
+            int len = ras.max_x() - min_x + 2;
+            sl_aa.reset(min_x, ras.max_x());
+            sl_bin.reset(min_x, ras.max_x());
+
+            typedef typename BaseRenderer::color_type color_type;
+            color_type* color_span = alloc.allocate(len * 2);
+            color_type* mix_buffer = color_span + len;
+            unsigned num_spans;
+
+            unsigned num_styles;
+            unsigned style;
+            bool     solid;
+            while((num_styles = ras.sweep_styles()) > 0)
+            {
+                typename ScanlineAA::const_iterator span_aa;
+                if(num_styles == 1)
+                {
+                    // Optimization for a single style. Happens often
+                    //-------------------------
+                    if(ras.sweep_scanline(sl_aa, 0))
+                    {
+                        style = ras.style(0);
+                        if(sh.is_solid(style))
+                        {
+                            // Just solid fill
+                            //-----------------------
+                            render_scanline_aa_solid(sl_aa, ren, sh.color(style));
+                        }
+                        else
+                        {
+                            // Arbitrary span generator
+                            //-----------------------
+                            span_aa   = sl_aa.begin();
+                            num_spans = sl_aa.num_spans();
+                            for(;;)
+                            {
+                                len = span_aa->len;
+                                sh.generate_span(color_span, 
+                                                 span_aa->x, 
+                                                 sl_aa.y(), 
+                                                 len, 
+                                                 style);
+
+                                ren.blend_color_hspan(span_aa->x, 
+                                                      sl_aa.y(), 
+                                                      span_aa->len,
+                                                      color_span,
+                                                      span_aa->covers);
+                                if(--num_spans == 0) break;
+                                ++span_aa;
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    if(ras.sweep_scanline(sl_bin, -1))
+                    {
+                        // Clear the spans of the mix_buffer
+                        //--------------------
+                        typename ScanlineBin::const_iterator span_bin = sl_bin.begin();
+                        num_spans = sl_bin.num_spans();
+                        for(;;)
+                        {
+                            memset(mix_buffer + span_bin->x - min_x, 
+                                   0, 
+                                   span_bin->len * sizeof(color_type));
+
+                            if(--num_spans == 0) break;
+                            ++span_bin;
+                        }
+
+                        unsigned i;
+                        for(i = 0; i < num_styles; i++)
+                        {
+                            style = ras.style(i);
+                            solid = sh.is_solid(style);
+
+                            if(ras.sweep_scanline(sl_aa, i))
+                            {
+                                color_type* colors;
+                                color_type* cspan;
+                                typename ScanlineAA::cover_type* covers;
+                                span_aa   = sl_aa.begin();
+                                num_spans = sl_aa.num_spans();
+                                if(solid)
+                                {
+                                    // Just solid fill
+                                    //-----------------------
+                                    for(;;)
+                                    {
+                                        color_type c = sh.color(style);
+                                        len    = span_aa->len;
+                                        colors = mix_buffer + span_aa->x - min_x;
+                                        covers = span_aa->covers;
+                                        do
+                                        {
+                                            if(*covers == cover_full) 
+                                            {
+                                                *colors = c;
+                                            }
+                                            else
+                                            {
+                                                colors->add(c, *covers);
+                                            }
+                                            ++colors;
+                                            ++covers;
+                                        }
+                                        while(--len);
+                                        if(--num_spans == 0) break;
+                                        ++span_aa;
+                                    }
+                                }
+                                else
+                                {
+                                    // Arbitrary span generator
+                                    //-----------------------
+                                    for(;;)
+                                    {
+                                        len = span_aa->len;
+                                        colors = mix_buffer + span_aa->x - min_x;
+                                        cspan  = color_span;
+                                        sh.generate_span(cspan, 
+                                                         span_aa->x, 
+                                                         sl_aa.y(), 
+                                                         len, 
+                                                         style);
+                                        covers = span_aa->covers;
+                                        do
+                                        {
+                                            if(*covers == cover_full) 
+                                            {
+                                                *colors = *cspan;
+                                            }
+                                            else
+                                            {
+                                                colors->add(*cspan, *covers);
+                                            }
+                                            ++cspan;
+                                            ++colors;
+                                            ++covers;
+                                        }
+                                        while(--len);
+                                        if(--num_spans == 0) break;
+                                        ++span_aa;
+                                    }
+                                }
+                            }
+                        }
+
+                        // Emit the blended result as a color hspan
+                        //-------------------------
+                        span_bin = sl_bin.begin();
+                        num_spans = sl_bin.num_spans();
+                        for(;;)
+                        {
+                            ren.blend_color_hspan(span_bin->x, 
+                                                  sl_bin.y(), 
+                                                  span_bin->len,
+                                                  mix_buffer + span_bin->x - min_x,
+                                                  0,
+                                                  cover_full);
+                            if(--num_spans == 0) break;
+                            ++span_bin;
+                        }
+                    } // if(ras.sweep_scanline(sl_bin, -1))
+                } // if(num_styles == 1) ... else
+            } // while((num_styles = ras.sweep_styles()) > 0)
+        } // if(ras.rewind_scanlines())
+    }
+
+    //=======================================render_scanlines_compound_layered
+    template<class Rasterizer, 
+             class ScanlineAA, 
+             class BaseRenderer, 
+             class SpanAllocator,
+             class StyleHandler>
+    void render_scanlines_compound_layered(Rasterizer& ras, 
+                                           ScanlineAA& sl_aa,
+                                           BaseRenderer& ren,
+                                           SpanAllocator& alloc,
+                                           StyleHandler& sh)
+    {
+        if(ras.rewind_scanlines())
+        {
+            int min_x = ras.min_x();
+            int len = ras.max_x() - min_x + 2;
+            sl_aa.reset(min_x, ras.max_x());
+
+            typedef typename BaseRenderer::color_type color_type;
+            color_type* color_span   = alloc.allocate(len * 2);
+            color_type* mix_buffer   = color_span + len;
+            cover_type* cover_buffer = ras.allocate_cover_buffer(len);
+            unsigned num_spans;
+
+            unsigned num_styles;
+            unsigned style;
+            bool     solid;
+            while((num_styles = ras.sweep_styles()) > 0)
+            {
+                typename ScanlineAA::const_iterator span_aa;
+                if(num_styles == 1)
+                {
+                    // Optimization for a single style. Happens often
+                    //-------------------------
+                    if(ras.sweep_scanline(sl_aa, 0))
+                    {
+                        style = ras.style(0);
+                        if(sh.is_solid(style))
+                        {
+                            // Just solid fill
+                            //-----------------------
+                            render_scanline_aa_solid(sl_aa, ren, sh.color(style));
+                        }
+                        else
+                        {
+                            // Arbitrary span generator
+                            //-----------------------
+                            span_aa   = sl_aa.begin();
+                            num_spans = sl_aa.num_spans();
+                            for(;;)
+                            {
+                                len = span_aa->len;
+                                sh.generate_span(color_span, 
+                                                 span_aa->x, 
+                                                 sl_aa.y(), 
+                                                 len, 
+                                                 style);
+
+                                ren.blend_color_hspan(span_aa->x, 
+                                                      sl_aa.y(), 
+                                                      span_aa->len,
+                                                      color_span,
+                                                      span_aa->covers);
+                                if(--num_spans == 0) break;
+                                ++span_aa;
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    int      sl_start = ras.scanline_start();
+                    unsigned sl_len   = ras.scanline_length();
+
+                    if(sl_len)
+                    {
+                        memset(mix_buffer + sl_start - min_x, 
+                               0, 
+                               sl_len * sizeof(color_type));
+
+                        memset(cover_buffer + sl_start - min_x, 
+                               0, 
+                               sl_len * sizeof(cover_type));
+
+                        int sl_y = 0x7FFFFFFF;
+                        unsigned i;
+                        for(i = 0; i < num_styles; i++)
+                        {
+                            style = ras.style(i);
+                            solid = sh.is_solid(style);
+
+                            if(ras.sweep_scanline(sl_aa, i))
+                            {
+                                unsigned    cover;
+                                color_type* colors;
+                                color_type* cspan;
+                                cover_type* src_covers;
+                                cover_type* dst_covers;
+                                span_aa   = sl_aa.begin();
+                                num_spans = sl_aa.num_spans();
+                                sl_y      = sl_aa.y();
+                                if(solid)
+                                {
+                                    // Just solid fill
+                                    //-----------------------
+                                    for(;;)
+                                    {
+                                        color_type c = sh.color(style);
+                                        len    = span_aa->len;
+                                        colors = mix_buffer + span_aa->x - min_x;
+                                        src_covers = span_aa->covers;
+                                        dst_covers = cover_buffer + span_aa->x - min_x;
+                                        do
+                                        {
+                                            cover = *src_covers;
+                                            if(*dst_covers + cover > cover_full)
+                                            {
+                                                cover = cover_full - *dst_covers;
+                                            }
+                                            if(cover)
+                                            {
+                                                colors->add(c, cover);
+                                                *dst_covers += cover;
+                                            }
+                                            ++colors;
+                                            ++src_covers;
+                                            ++dst_covers;
+                                        }
+                                        while(--len);
+                                        if(--num_spans == 0) break;
+                                        ++span_aa;
+                                    }
+                                }
+                                else
+                                {
+                                    // Arbitrary span generator
+                                    //-----------------------
+                                    for(;;)
+                                    {
+                                        len = span_aa->len;
+                                        colors = mix_buffer + span_aa->x - min_x;
+                                        cspan  = color_span;
+                                        sh.generate_span(cspan, 
+                                                         span_aa->x, 
+                                                         sl_aa.y(), 
+                                                         len, 
+                                                         style);
+                                        src_covers = span_aa->covers;
+                                        dst_covers = cover_buffer + span_aa->x - min_x;
+                                        do
+                                        {
+                                            cover = *src_covers;
+                                            if(*dst_covers + cover > cover_full)
+                                            {
+                                                cover = cover_full - *dst_covers;
+                                            }
+                                            if(cover)
+                                            {
+                                                colors->add(*cspan, cover);
+                                                *dst_covers += cover;
+                                            }
+                                            ++cspan;
+                                            ++colors;
+                                            ++src_covers;
+                                            ++dst_covers;
+                                        }
+                                        while(--len);
+                                        if(--num_spans == 0) break;
+                                        ++span_aa;
+                                    }
+                                }
+                            }
+                        }
+                        ren.blend_color_hspan(sl_start, 
+                                              sl_y, 
+                                              sl_len,
+                                              mix_buffer + sl_start - min_x,
+                                              0,
+                                              cover_full);
+                    } //if(sl_len)
+                } //if(num_styles == 1) ... else
+            } //while((num_styles = ras.sweep_styles()) > 0)
+        } //if(ras.rewind_scanlines())
+    }
+
+
+}
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_rendering_buffer.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_rendering_buffer.h
new file mode 100644
index 0000000000..191347f63e
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_rendering_buffer.h
@@ -0,0 +1,300 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// class rendering_buffer
+//
+//----------------------------------------------------------------------------
+
+#ifndef AGG_RENDERING_BUFFER_INCLUDED
+#define AGG_RENDERING_BUFFER_INCLUDED
+
+#include "agg_array.h"
+
+namespace agg
+{
+
+    //===========================================================row_accessor
+    template<class T> class row_accessor
+    {
+    public:
+        typedef const_row_info<T> row_data;
+
+        //-------------------------------------------------------------------
+        row_accessor() :
+            m_buf(0),
+            m_start(0),
+            m_width(0),
+            m_height(0),
+            m_stride(0)
+        {
+        }
+
+        //--------------------------------------------------------------------
+        row_accessor(T* buf, unsigned width, unsigned height, int stride) :
+            m_buf(0),
+            m_start(0),
+            m_width(0),
+            m_height(0),
+            m_stride(0)
+        {
+            attach(buf, width, height, stride);
+        }
+
+
+        //--------------------------------------------------------------------
+        void attach(T* buf, unsigned width, unsigned height, int stride)
+        {
+            m_buf = m_start = buf;
+            m_width = width;
+            m_height = height;
+            m_stride = stride;
+            if(stride < 0) 
+            { 
+                m_start = m_buf - (AGG_INT64)(height - 1) * stride;
+            }
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE       T* buf()          { return m_buf;    }
+        AGG_INLINE const T* buf()    const { return m_buf;    }
+        AGG_INLINE unsigned width()  const { return m_width;  }
+        AGG_INLINE unsigned height() const { return m_height; }
+        AGG_INLINE int      stride() const { return m_stride; }
+        AGG_INLINE unsigned stride_abs() const 
+        {
+            return (m_stride < 0) ? unsigned(-m_stride) : unsigned(m_stride); 
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE       T* row_ptr(int, int y, unsigned) 
+        { 
+            return m_start + y * (AGG_INT64)m_stride;
+        }
+        AGG_INLINE       T* row_ptr(int y)       { return m_start + y * (AGG_INT64)m_stride; }
+        AGG_INLINE const T* row_ptr(int y) const { return m_start + y * (AGG_INT64)m_stride; }
+        AGG_INLINE row_data row    (int y) const 
+        { 
+            return row_data(0, m_width-1, row_ptr(y)); 
+        }
+
+        //--------------------------------------------------------------------
+        template<class RenBuf>
+        void copy_from(const RenBuf& src)
+        {
+            unsigned h = height();
+            if(src.height() < h) h = src.height();
+        
+            unsigned l = stride_abs();
+            if(src.stride_abs() < l) l = src.stride_abs();
+        
+            l *= sizeof(T);
+
+            unsigned y;
+            unsigned w = width();
+            for (y = 0; y < h; y++)
+            {
+                memcpy(row_ptr(0, y, w), src.row_ptr(y), l);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void clear(T value)
+        {
+            unsigned y;
+            unsigned w = width();
+            unsigned stride = stride_abs();
+            for(y = 0; y < height(); y++)
+            {
+                T* p = row_ptr(0, y, w);
+                unsigned x;
+                for(x = 0; x < stride; x++)
+                {
+                    *p++ = value;
+                }
+            }
+        }
+
+    private:
+        //--------------------------------------------------------------------
+        T*            m_buf;    // Pointer to renrdering buffer
+        T*            m_start;  // Pointer to first pixel depending on stride 
+        unsigned      m_width;  // Width in pixels
+        unsigned      m_height; // Height in pixels
+        int           m_stride; // Number of bytes per row. Can be < 0
+    };
+
+
+
+
+    //==========================================================row_ptr_cache
+    template<class T> class row_ptr_cache
+    {
+    public:
+        typedef const_row_info<T> row_data;
+
+        //-------------------------------------------------------------------
+        row_ptr_cache() :
+            m_buf(0),
+            m_rows(),
+            m_width(0),
+            m_height(0),
+            m_stride(0)
+        {
+        }
+
+        //--------------------------------------------------------------------
+        row_ptr_cache(T* buf, unsigned width, unsigned height, int stride) :
+            m_buf(0),
+            m_rows(),
+            m_width(0),
+            m_height(0),
+            m_stride(0)
+        {
+            attach(buf, width, height, stride);
+        }
+
+        //--------------------------------------------------------------------
+        void attach(T* buf, unsigned width, unsigned height, int stride)
+        {
+            m_buf = buf;
+            m_width = width;
+            m_height = height;
+            m_stride = stride;
+            if(height > m_rows.size())
+            {
+                m_rows.resize(height);
+            }
+
+            T* row_ptr = m_buf;
+
+            if(stride < 0)
+            {
+                row_ptr = m_buf - (AGG_INT64)(height - 1) * stride;
+            }
+
+            T** rows = &m_rows[0];
+
+            while(height--)
+            {
+                *rows++ = row_ptr;
+                row_ptr += stride;
+            }
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE       T* buf()          { return m_buf;    }
+        AGG_INLINE const T* buf()    const { return m_buf;    }
+        AGG_INLINE unsigned width()  const { return m_width;  }
+        AGG_INLINE unsigned height() const { return m_height; }
+        AGG_INLINE int      stride() const { return m_stride; }
+        AGG_INLINE unsigned stride_abs() const 
+        {
+            return (m_stride < 0) ? unsigned(-m_stride) : unsigned(m_stride); 
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE       T* row_ptr(int, int y, unsigned) 
+        { 
+            return m_rows[y]; 
+        }
+        AGG_INLINE       T* row_ptr(int y)       { return m_rows[y]; }
+        AGG_INLINE const T* row_ptr(int y) const { return m_rows[y]; }
+        AGG_INLINE row_data row    (int y) const 
+        { 
+            return row_data(0, m_width-1, m_rows[y]); 
+        }
+
+        //--------------------------------------------------------------------
+        T const* const* rows() const { return &m_rows[0]; }
+
+        //--------------------------------------------------------------------
+        template<class RenBuf>
+        void copy_from(const RenBuf& src)
+        {
+            unsigned h = height();
+            if(src.height() < h) h = src.height();
+        
+            unsigned l = stride_abs();
+            if(src.stride_abs() < l) l = src.stride_abs();
+        
+            l *= sizeof(T);
+
+            unsigned y;
+            unsigned w = width();
+            for (y = 0; y < h; y++)
+            {
+                memcpy(row_ptr(0, y, w), src.row_ptr(y), l);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void clear(T value)
+        {
+            unsigned y;
+            unsigned w = width();
+            unsigned stride = stride_abs();
+            for(y = 0; y < height(); y++)
+            {
+                T* p = row_ptr(0, y, w);
+                unsigned x;
+                for(x = 0; x < stride; x++)
+                {
+                    *p++ = value;
+                }
+            }
+        }
+
+    private:
+        //--------------------------------------------------------------------
+        T*            m_buf;        // Pointer to renrdering buffer
+        pod_array<T*> m_rows;       // Pointers to each row of the buffer
+        unsigned      m_width;      // Width in pixels
+        unsigned      m_height;     // Height in pixels
+        int           m_stride;     // Number of bytes per row. Can be < 0
+    };
+
+
+
+
+    //========================================================rendering_buffer
+    // 
+    // The definition of the main type for accessing the rows in the frame 
+    // buffer. It provides functionality to navigate to the rows in a 
+    // rectangular matrix, from top to bottom or from bottom to top depending 
+    // on stride.
+    //
+    // row_accessor is cheap to create/destroy, but performs one multiplication
+    // when calling row_ptr().
+    // 
+    // row_ptr_cache creates an array of pointers to rows, so, the access 
+    // via row_ptr() may be faster. But it requires memory allocation 
+    // when creating. For example, on typical Intel Pentium hardware 
+    // row_ptr_cache speeds span_image_filter_rgb_nn up to 10%
+    //
+    // It's used only in short hand typedefs like pixfmt_rgba32 and can be 
+    // redefined in agg_config.h
+    // In real applications you can use both, depending on your needs
+    //------------------------------------------------------------------------
+#ifdef AGG_RENDERING_BUFFER
+    typedef AGG_RENDERING_BUFFER rendering_buffer;
+#else
+//  typedef row_ptr_cache<int8u> rendering_buffer;
+    typedef row_accessor<int8u> rendering_buffer;
+#endif
+
+}
+
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_scanline_bin.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_scanline_bin.h
new file mode 100644
index 0000000000..660292b613
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_scanline_bin.h
@@ -0,0 +1,264 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Class scanline_bin - binary scanline.
+//
+//----------------------------------------------------------------------------
+//
+// Adaptation for 32-bit screen coordinates (scanline32_bin) has been sponsored by 
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+// 
+//----------------------------------------------------------------------------
+
+#ifndef AGG_SCANLINE_BIN_INCLUDED
+#define AGG_SCANLINE_BIN_INCLUDED
+
+#include "agg_array.h"
+
+namespace agg
+{
+
+    //=============================================================scanline_bin
+    // 
+    // This is binary scaline container which supports the interface 
+    // used in the rasterizer::render(). See description of agg_scanline_u8 
+    // for details.
+    // 
+    //------------------------------------------------------------------------
+    class scanline_bin
+    {
+    public:
+        typedef int32 coord_type;
+
+        struct span
+        {
+            int16 x;
+            int16 len;
+        };
+
+        typedef const span* const_iterator;
+
+        //--------------------------------------------------------------------
+        scanline_bin() :
+            m_last_x(0x7FFFFFF0),
+            m_spans(),
+            m_cur_span(0)
+        {
+        }
+
+        //--------------------------------------------------------------------
+        void reset(int min_x, int max_x)
+        {
+            unsigned max_len = max_x - min_x + 3;
+            if(max_len > m_spans.size())
+            {
+                m_spans.resize(max_len);
+            }
+            m_last_x   = 0x7FFFFFF0;
+            m_cur_span = &m_spans[0];
+        }
+
+        //--------------------------------------------------------------------
+        void add_cell(int x, unsigned)
+        {
+            if(x == m_last_x+1)
+            {
+                m_cur_span->len++;
+            }
+            else
+            {
+                ++m_cur_span;
+                m_cur_span->x = (int16)x;
+                m_cur_span->len = 1;
+            }
+            m_last_x = x;
+        }
+
+        //--------------------------------------------------------------------
+        void add_span(int x, unsigned len, unsigned)
+        {
+            if(x == m_last_x+1)
+            {
+                m_cur_span->len = (int16)(m_cur_span->len + len);
+            }
+            else
+            {
+                ++m_cur_span;
+                m_cur_span->x = (int16)x;
+                m_cur_span->len = (int16)len;
+            }
+            m_last_x = x + len - 1;
+        }
+
+        //--------------------------------------------------------------------
+        void add_cells(int x, unsigned len, const void*)
+        {
+            add_span(x, len, 0);
+        }
+
+        //--------------------------------------------------------------------
+        void finalize(int y) 
+        { 
+            m_y = y; 
+        }
+
+        //--------------------------------------------------------------------
+        void reset_spans()
+        {
+            m_last_x    = 0x7FFFFFF0;
+            m_cur_span  = &m_spans[0];
+        }
+
+        //--------------------------------------------------------------------
+        int            y()         const { return m_y; }
+        unsigned       num_spans() const { return unsigned(m_cur_span - &m_spans[0]); }
+        const_iterator begin()     const { return &m_spans[1]; }
+
+    private:
+        scanline_bin(const scanline_bin&);
+        const scanline_bin operator = (const scanline_bin&);
+
+        int             m_last_x;
+        int             m_y;
+        pod_array<span> m_spans;
+        span*           m_cur_span;
+    };
+
+
+
+
+
+
+    //===========================================================scanline32_bin
+    class scanline32_bin
+    {
+    public:
+        typedef int32 coord_type;
+
+        //--------------------------------------------------------------------
+        struct span
+        {
+            span() {}
+            span(coord_type x_, coord_type len_) : x(x_), len(len_) {}
+
+            coord_type x;
+            coord_type len;
+        };
+        typedef pod_bvector<span, 4> span_array_type;
+
+
+        //--------------------------------------------------------------------
+        class const_iterator
+        {
+        public:
+            const_iterator(const span_array_type& spans) :
+                m_spans(spans),
+                m_span_idx(0)
+            {}
+
+            const span& operator*()  const { return m_spans[m_span_idx];  }
+            const span* operator->() const { return &m_spans[m_span_idx]; }
+
+            void operator ++ () { ++m_span_idx; }
+
+        private:
+            const span_array_type& m_spans;
+            unsigned               m_span_idx;
+        };
+
+
+        //--------------------------------------------------------------------
+        scanline32_bin() : m_max_len(0), m_last_x(0x7FFFFFF0) {}
+
+        //--------------------------------------------------------------------
+        void reset(int min_x, int max_x)
+        {
+            m_last_x = 0x7FFFFFF0;
+            m_spans.remove_all();
+        }
+
+        //--------------------------------------------------------------------
+        void add_cell(int x, unsigned)
+        {
+            if(x == m_last_x+1)
+            {
+                m_spans.last().len++;
+            }
+            else
+            {
+                m_spans.add(span(coord_type(x), 1));
+            }
+            m_last_x = x;
+        }
+
+        //--------------------------------------------------------------------
+        void add_span(int x, unsigned len, unsigned)
+        {
+            if(x == m_last_x+1)
+            {
+                m_spans.last().len += coord_type(len);
+            }
+            else
+            {
+                m_spans.add(span(coord_type(x), coord_type(len)));
+            }
+            m_last_x = x + len - 1;
+        }
+
+        //--------------------------------------------------------------------
+        void add_cells(int x, unsigned len, const void*)
+        {
+            add_span(x, len, 0);
+        }
+
+        //--------------------------------------------------------------------
+        void finalize(int y) 
+        { 
+            m_y = y; 
+        }
+
+        //--------------------------------------------------------------------
+        void reset_spans()
+        {
+            m_last_x = 0x7FFFFFF0;
+            m_spans.remove_all();
+        }
+
+        //--------------------------------------------------------------------
+        int            y()         const { return m_y; }
+        unsigned       num_spans() const { return m_spans.size(); }
+        const_iterator begin()     const { return const_iterator(m_spans); }
+
+    private:
+        scanline32_bin(const scanline32_bin&);
+        const scanline32_bin operator = (const scanline32_bin&);
+
+        unsigned        m_max_len;
+        int             m_last_x;
+        int             m_y;
+        span_array_type m_spans;
+    };
+
+
+
+
+
+}
+
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_scanline_p.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_scanline_p.h
new file mode 100644
index 0000000000..1d1cbe72f1
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_scanline_p.h
@@ -0,0 +1,329 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Class scanline_p - a general purpose scanline container with packed spans.
+//
+//----------------------------------------------------------------------------
+//
+// Adaptation for 32-bit screen coordinates (scanline32_p) has been sponsored by 
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+// 
+//----------------------------------------------------------------------------
+#ifndef AGG_SCANLINE_P_INCLUDED
+#define AGG_SCANLINE_P_INCLUDED
+
+#include "agg_array.h"
+
+namespace agg
+{
+
+    //=============================================================scanline_p8
+    // 
+    // This is a general purpose scaline container which supports the interface 
+    // used in the rasterizer::render(). See description of scanline_u8
+    // for details.
+    // 
+    //------------------------------------------------------------------------
+    class scanline_p8
+    {
+    public:
+        typedef scanline_p8 self_type;
+        typedef int8u       cover_type;
+        typedef int16       coord_type;
+
+        //--------------------------------------------------------------------
+        struct span
+        {
+            coord_type        x;
+            coord_type        len; // If negative, it's a solid span, covers is valid
+            const cover_type* covers;
+        };
+
+        typedef span* iterator;
+        typedef const span* const_iterator;
+
+        scanline_p8() :
+            m_last_x(0x7FFFFFF0),
+            m_covers(),
+            m_cover_ptr(0),
+            m_spans(),
+            m_cur_span(0)
+        {
+        }
+
+        //--------------------------------------------------------------------
+        void reset(int min_x, int max_x)
+        {
+            unsigned max_len = max_x - min_x + 3;
+            if(max_len > m_spans.size())
+            {
+                m_spans.resize(max_len);
+                m_covers.resize(max_len);
+            }
+            m_last_x    = 0x7FFFFFF0;
+            m_cover_ptr = &m_covers[0];
+            m_cur_span  = &m_spans[0];
+            m_cur_span->len = 0;
+        }
+
+        //--------------------------------------------------------------------
+        void add_cell(int x, unsigned cover)
+        {
+            *m_cover_ptr = (cover_type)cover;
+            if(x == m_last_x+1 && m_cur_span->len > 0)
+            {
+                m_cur_span->len++;
+            }
+            else
+            {
+                m_cur_span++;
+                m_cur_span->covers = m_cover_ptr;
+                m_cur_span->x = (int16)x;
+                m_cur_span->len = 1;
+            }
+            m_last_x = x;
+            m_cover_ptr++;
+        }
+
+        //--------------------------------------------------------------------
+        void add_cells(int x, unsigned len, const cover_type* covers)
+        {
+            memcpy(m_cover_ptr, covers, len * sizeof(cover_type));
+            if(x == m_last_x+1 && m_cur_span->len > 0)
+            {
+                m_cur_span->len += (int16)len;
+            }
+            else
+            {
+                m_cur_span++;
+                m_cur_span->covers = m_cover_ptr;
+                m_cur_span->x = (int16)x;
+                m_cur_span->len = (int16)len;
+            }
+            m_cover_ptr += len;
+            m_last_x = x + len - 1;
+        }
+
+        //--------------------------------------------------------------------
+        void add_span(int x, unsigned len, unsigned cover)
+        {
+            if(x == m_last_x+1 && 
+               m_cur_span->len < 0 && 
+               cover == *m_cur_span->covers)
+            {
+                m_cur_span->len -= (int16)len;
+            }
+            else
+            {
+                *m_cover_ptr = (cover_type)cover;
+                m_cur_span++;
+                m_cur_span->covers = m_cover_ptr++;
+                m_cur_span->x      = (int16)x;
+                m_cur_span->len    = (int16)(-int(len));
+            }
+            m_last_x = x + len - 1;
+        }
+
+        //--------------------------------------------------------------------
+        void finalize(int y) 
+        { 
+            m_y = y; 
+        }
+
+        //--------------------------------------------------------------------
+        void reset_spans()
+        {
+            m_last_x    = 0x7FFFFFF0;
+            m_cover_ptr = &m_covers[0];
+            m_cur_span  = &m_spans[0];
+            m_cur_span->len = 0;
+        }
+
+        //--------------------------------------------------------------------
+        int            y()         const { return m_y; }
+        unsigned       num_spans() const { return unsigned(m_cur_span - &m_spans[0]); }
+        const_iterator begin()     const { return &m_spans[1]; }
+
+    private:
+        scanline_p8(const self_type&);
+        const self_type& operator = (const self_type&);
+
+        int                   m_last_x;
+        int                   m_y;
+        pod_array<cover_type> m_covers;
+        cover_type*           m_cover_ptr;
+        pod_array<span>       m_spans;
+        span*                 m_cur_span;
+    };
+
+
+
+
+
+
+
+
+    //==========================================================scanline32_p8
+    class scanline32_p8
+    {
+    public:
+        typedef scanline32_p8 self_type;
+        typedef int8u         cover_type;
+        typedef int32         coord_type;
+
+        struct span
+        {
+            span() {}
+            span(coord_type x_, coord_type len_, const cover_type* covers_) :
+                x(x_), len(len_), covers(covers_) {}
+
+            coord_type x;
+            coord_type len; // If negative, it's a solid span, covers is valid
+            const cover_type* covers;
+        };
+        typedef pod_bvector<span, 4> span_array_type;
+
+
+        //--------------------------------------------------------------------
+        class const_iterator
+        {
+        public:
+            const_iterator(const span_array_type& spans) :
+                m_spans(spans),
+                m_span_idx(0)
+            {}
+
+            const span& operator*()  const { return m_spans[m_span_idx];  }
+            const span* operator->() const { return &m_spans[m_span_idx]; }
+
+            void operator ++ () { ++m_span_idx; }
+
+        private:
+            const span_array_type& m_spans;
+            unsigned               m_span_idx;
+        };
+
+        //--------------------------------------------------------------------
+        scanline32_p8() :
+            m_max_len(0),
+            m_last_x(0x7FFFFFF0),
+            m_covers(),
+            m_cover_ptr(0)
+        {
+        }
+
+        //--------------------------------------------------------------------
+        void reset(int min_x, int max_x)
+        {
+            unsigned max_len = max_x - min_x + 3;
+            if(max_len > m_covers.size())
+            {
+                m_covers.resize(max_len);
+            }
+            m_last_x    = 0x7FFFFFF0;
+            m_cover_ptr = &m_covers[0];
+            m_spans.remove_all();
+        }
+
+        //--------------------------------------------------------------------
+        void add_cell(int x, unsigned cover)
+        {
+            *m_cover_ptr = cover_type(cover);
+            if(x == m_last_x+1 && m_spans.size() && m_spans.last().len > 0)
+            {
+                m_spans.last().len++;
+            }
+            else
+            {
+                m_spans.add(span(coord_type(x), 1, m_cover_ptr));
+            }
+            m_last_x = x;
+            m_cover_ptr++;
+        }
+
+        //--------------------------------------------------------------------
+        void add_cells(int x, unsigned len, const cover_type* covers)
+        {
+            memcpy(m_cover_ptr, covers, len * sizeof(cover_type));
+            if(x == m_last_x+1 && m_spans.size() && m_spans.last().len > 0)
+            {
+                m_spans.last().len += coord_type(len);
+            }
+            else
+            {
+                m_spans.add(span(coord_type(x), coord_type(len), m_cover_ptr));
+            }
+            m_cover_ptr += len;
+            m_last_x = x + len - 1;
+        }
+
+        //--------------------------------------------------------------------
+        void add_span(int x, unsigned len, unsigned cover)
+        {
+            if(x == m_last_x+1 && 
+               m_spans.size() &&
+               m_spans.last().len < 0 && 
+               cover == *m_spans.last().covers)
+            {
+                m_spans.last().len -= coord_type(len);
+            }
+            else
+            {
+                *m_cover_ptr = cover_type(cover);
+                m_spans.add(span(coord_type(x), -coord_type(len), m_cover_ptr++));
+            }
+            m_last_x = x + len - 1;
+        }
+
+        //--------------------------------------------------------------------
+        void finalize(int y) 
+        { 
+            m_y = y; 
+        }
+
+        //--------------------------------------------------------------------
+        void reset_spans()
+        {
+            m_last_x    = 0x7FFFFFF0;
+            m_cover_ptr = &m_covers[0];
+            m_spans.remove_all();
+        }
+
+        //--------------------------------------------------------------------
+        int            y()         const { return m_y; }
+        unsigned       num_spans() const { return m_spans.size(); }
+        const_iterator begin()     const { return const_iterator(m_spans); }
+
+    private:
+        scanline32_p8(const self_type&);
+        const self_type& operator = (const self_type&);
+
+        unsigned              m_max_len;
+        int                   m_last_x;
+        int                   m_y;
+        pod_array<cover_type> m_covers;
+        cover_type*           m_cover_ptr;
+        span_array_type       m_spans;
+    };
+
+
+}
+
+
+#endif
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_scanline_storage_aa.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_scanline_storage_aa.h
new file mode 100644
index 0000000000..b3471fce76
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_scanline_storage_aa.h
@@ -0,0 +1,815 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Adaptation for 32-bit screen coordinates has been sponsored by 
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+// 
+//----------------------------------------------------------------------------
+
+#ifndef AGG_SCANLINE_STORAGE_AA_INCLUDED
+#define AGG_SCANLINE_STORAGE_AA_INCLUDED
+
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+#include "agg_array.h"
+
+
+namespace agg
+{
+
+    //----------------------------------------------scanline_cell_storage
+    template<class T> class scanline_cell_storage
+    {
+        struct extra_span
+        {
+            unsigned len;
+            T*       ptr;
+        };
+
+    public:
+        typedef T value_type;
+
+        //---------------------------------------------------------------
+        ~scanline_cell_storage()
+        {
+            remove_all();
+        }
+
+        //---------------------------------------------------------------
+        scanline_cell_storage() :
+            m_cells(128-2),
+            m_extra_storage()
+        {}
+
+
+        // Copying
+        //---------------------------------------------------------------
+        scanline_cell_storage(const scanline_cell_storage<T>& v) :
+            m_cells(v.m_cells),
+            m_extra_storage()
+        {
+            copy_extra_storage(v);
+        }
+
+        //---------------------------------------------------------------
+        const scanline_cell_storage<T>& 
+        operator = (const scanline_cell_storage<T>& v)
+        {
+            remove_all();
+            m_cells = v.m_cells;
+            copy_extra_storage(v);
+            return *this;
+        }
+
+        //---------------------------------------------------------------
+        void remove_all()
+        {
+            int i;
+            for(i = m_extra_storage.size()-1; i >= 0; --i)
+            {
+                pod_allocator<T>::deallocate(m_extra_storage[i].ptr,
+                                             m_extra_storage[i].len);
+            }
+            m_extra_storage.remove_all();
+            m_cells.remove_all();
+        }
+
+        //---------------------------------------------------------------
+        int add_cells(const T* cells, unsigned num_cells)
+        {
+            int idx = m_cells.allocate_continuous_block(num_cells);
+            if(idx >= 0)
+            {
+                T* ptr = &m_cells[idx];
+                memcpy(ptr, cells, sizeof(T) * num_cells);
+                return idx;
+            }
+            extra_span s;
+            s.len = num_cells;
+            s.ptr = pod_allocator<T>::allocate(num_cells);
+            memcpy(s.ptr, cells, sizeof(T) * num_cells);
+            m_extra_storage.add(s);
+            return -int(m_extra_storage.size());
+        }
+
+        //---------------------------------------------------------------
+        const T* operator [] (int idx) const
+        {
+            if(idx >= 0)
+            {
+                if((unsigned)idx >= m_cells.size()) return 0;
+                return &m_cells[(unsigned)idx];
+            }
+            unsigned i = unsigned(-idx - 1);
+            if(i >= m_extra_storage.size()) return 0;
+            return m_extra_storage[i].ptr;
+        }
+
+        //---------------------------------------------------------------
+        T* operator [] (int idx)
+        {
+            if(idx >= 0)
+            {
+                if((unsigned)idx >= m_cells.size()) return 0;
+                return &m_cells[(unsigned)idx];
+            }
+            unsigned i = unsigned(-idx - 1);
+            if(i >= m_extra_storage.size()) return 0;
+            return m_extra_storage[i].ptr;
+        }
+
+    private:
+        void copy_extra_storage(const scanline_cell_storage<T>& v)
+        {
+            unsigned i;
+            for(i = 0; i < v.m_extra_storage.size(); ++i)
+            {
+                const extra_span& src = v.m_extra_storage[i];
+                extra_span dst;
+                dst.len = src.len;
+                dst.ptr = pod_allocator<T>::allocate(dst.len);
+                memcpy(dst.ptr, src.ptr, dst.len * sizeof(T));
+                m_extra_storage.add(dst);
+            }
+        }
+
+        pod_bvector<T, 12>         m_cells;
+        pod_bvector<extra_span, 6> m_extra_storage;
+    };
+
+
+
+
+
+
+    //-----------------------------------------------scanline_storage_aa
+    template<class T> class scanline_storage_aa
+    {
+    public:
+        typedef T cover_type;
+
+        //---------------------------------------------------------------
+        struct span_data
+        {
+            int32 x;
+            int32 len;       // If negative, it's a solid span, covers is valid
+            int   covers_id; // The index of the cells in the scanline_cell_storage
+        };
+
+        //---------------------------------------------------------------
+        struct scanline_data
+        {
+            int      y;
+            unsigned num_spans;
+            unsigned start_span;
+        };
+
+
+        //---------------------------------------------------------------
+        class embedded_scanline
+        {
+        public:
+
+            //-----------------------------------------------------------
+            class const_iterator
+            {
+            public:
+                struct span
+                {
+                    int32    x;
+                    int32    len; // If negative, it's a solid span, covers is valid
+                    const T* covers;
+                };
+
+                const_iterator() : m_storage(0) {}
+                const_iterator(embedded_scanline& sl) :
+                    m_storage(sl.m_storage),
+                    m_span_idx(sl.m_scanline.start_span)
+                {
+                    init_span();
+                }
+
+                const span& operator*()  const { return m_span;  }
+                const span* operator->() const { return &m_span; }
+
+                void operator ++ ()
+                {
+                    ++m_span_idx;
+                    init_span();
+                }
+
+            private:
+                void init_span()
+                {
+                    const span_data& s = m_storage->span_by_index(m_span_idx);
+                    m_span.x      = s.x;
+                    m_span.len    = s.len;
+                    m_span.covers = m_storage->covers_by_index(s.covers_id);
+                }
+
+                scanline_storage_aa* m_storage;
+                unsigned                   m_span_idx;
+                span                       m_span;
+            };
+
+            friend class const_iterator;
+
+
+            //-----------------------------------------------------------
+            embedded_scanline(const scanline_storage_aa& storage) :
+                m_storage(&storage)
+            {
+                init(0);
+            }
+
+            //-----------------------------------------------------------
+            void     reset(int, int)     {}
+            unsigned num_spans()   const { return m_scanline.num_spans;  }
+            int      y()           const { return m_scanline.y;          }
+            const_iterator begin() const { return const_iterator(*this); }
+
+            //-----------------------------------------------------------
+            void init(unsigned scanline_idx)
+            {
+                m_scanline_idx = scanline_idx;
+                m_scanline = m_storage->scanline_by_index(m_scanline_idx);
+            }
+
+        private:
+            const scanline_storage_aa* m_storage;
+            scanline_data              m_scanline;
+            unsigned                   m_scanline_idx;
+        };
+
+
+        //---------------------------------------------------------------
+        scanline_storage_aa() :
+            m_covers(),
+            m_spans(256-2),         // Block increment size
+            m_scanlines(),
+            m_min_x( 0x7FFFFFFF),
+            m_min_y( 0x7FFFFFFF),
+            m_max_x(-0x7FFFFFFF),
+            m_max_y(-0x7FFFFFFF),
+            m_cur_scanline(0)
+        {
+            m_fake_scanline.y = 0;
+            m_fake_scanline.num_spans = 0;
+            m_fake_scanline.start_span = 0;
+            m_fake_span.x = 0;
+            m_fake_span.len = 0;
+            m_fake_span.covers_id = 0;
+        }
+
+        // Renderer Interface
+        //---------------------------------------------------------------
+        void prepare()
+        {
+            m_covers.remove_all();
+            m_scanlines.remove_all();
+            m_spans.remove_all();
+            m_min_x =  0x7FFFFFFF;
+            m_min_y =  0x7FFFFFFF;
+            m_max_x = -0x7FFFFFFF;
+            m_max_y = -0x7FFFFFFF;
+            m_cur_scanline = 0;
+        }
+
+        //---------------------------------------------------------------
+        template<class Scanline> void render(const Scanline& sl)
+        {
+            scanline_data sl_this;
+
+            int y = sl.y();
+            if(y < m_min_y) m_min_y = y;
+            if(y > m_max_y) m_max_y = y;
+
+            sl_this.y = y;
+            sl_this.num_spans = sl.num_spans();
+            sl_this.start_span = m_spans.size();
+            typename Scanline::const_iterator span_iterator = sl.begin();
+
+            unsigned num_spans = sl_this.num_spans;
+            for(;;)
+            {
+                span_data sp;
+
+                sp.x         = span_iterator->x;
+                sp.len       = span_iterator->len;
+                int len      = abs(int(sp.len));
+                sp.covers_id = 
+                    m_covers.add_cells(span_iterator->covers, 
+                                       unsigned(len));
+                m_spans.add(sp);
+                int x1 = sp.x;
+                int x2 = sp.x + len - 1;
+                if(x1 < m_min_x) m_min_x = x1;
+                if(x2 > m_max_x) m_max_x = x2;
+                if(--num_spans == 0) break;
+                ++span_iterator;
+            }
+            m_scanlines.add(sl_this);
+        }
+
+
+        //---------------------------------------------------------------
+        // Iterate scanlines interface
+        int min_x() const { return m_min_x; }
+        int min_y() const { return m_min_y; }
+        int max_x() const { return m_max_x; }
+        int max_y() const { return m_max_y; }
+
+        //---------------------------------------------------------------
+        bool rewind_scanlines()
+        {
+            m_cur_scanline = 0;
+            return m_scanlines.size() > 0;
+        }
+
+
+        //---------------------------------------------------------------
+        template<class Scanline> bool sweep_scanline(Scanline& sl)
+        {
+            sl.reset_spans();
+            for(;;)
+            {
+                if(m_cur_scanline >= m_scanlines.size()) return false;
+                const scanline_data& sl_this = m_scanlines[m_cur_scanline];
+
+                unsigned num_spans = sl_this.num_spans;
+                unsigned span_idx  = sl_this.start_span;
+                do
+                {
+                    const span_data& sp = m_spans[span_idx++];
+                    const T* covers = covers_by_index(sp.covers_id);
+                    if(sp.len < 0)
+                    {
+                        sl.add_span(sp.x, unsigned(-sp.len), *covers);
+                    }
+                    else
+                    {
+                        sl.add_cells(sp.x, sp.len, covers);
+                    }
+                }
+                while(--num_spans);
+                ++m_cur_scanline;
+                if(sl.num_spans())
+                {
+                    sl.finalize(sl_this.y);
+                    break;
+                }
+            }
+            return true;
+        }
+
+
+        //---------------------------------------------------------------
+        // Specialization for embedded_scanline
+        bool sweep_scanline(embedded_scanline& sl)
+        {
+            do
+            {
+                if(m_cur_scanline >= m_scanlines.size()) return false;
+                sl.init(m_cur_scanline);
+                ++m_cur_scanline;
+            }
+            while(sl.num_spans() == 0);
+            return true;
+        }
+
+        //---------------------------------------------------------------
+        unsigned byte_size() const
+        {
+            unsigned i;
+            unsigned size = sizeof(int32) * 4; // min_x, min_y, max_x, max_y
+
+            for(i = 0; i < m_scanlines.size(); ++i)
+            {
+                size += sizeof(int32) * 3; // scanline size in bytes, Y, num_spans
+
+                const scanline_data& sl_this = m_scanlines[i];
+
+                unsigned num_spans = sl_this.num_spans;
+                unsigned span_idx  = sl_this.start_span;
+                do
+                {
+                    const span_data& sp = m_spans[span_idx++];
+
+                    size += sizeof(int32) * 2;                // X, span_len
+                    if(sp.len < 0)
+                    {
+                        size += sizeof(T);                    // cover
+                    }
+                    else
+                    {
+                        size += sizeof(T) * unsigned(sp.len); // covers
+                    }
+                }
+                while(--num_spans);
+            }
+            return size;
+        }
+
+
+        //---------------------------------------------------------------
+        static void write_int32(int8u* dst, int32 val)
+        {
+            dst[0] = ((const int8u*)&val)[0];
+            dst[1] = ((const int8u*)&val)[1];
+            dst[2] = ((const int8u*)&val)[2];
+            dst[3] = ((const int8u*)&val)[3];
+        }
+
+
+        //---------------------------------------------------------------
+        void serialize(int8u* data) const
+        {
+            unsigned i;
+
+            write_int32(data, min_x()); // min_x
+            data += sizeof(int32);
+            write_int32(data, min_y()); // min_y
+            data += sizeof(int32);
+            write_int32(data, max_x()); // max_x
+            data += sizeof(int32);
+            write_int32(data, max_y()); // max_y
+            data += sizeof(int32);
+
+            for(i = 0; i < m_scanlines.size(); ++i)
+            {
+                const scanline_data& sl_this = m_scanlines[i];
+                
+                int8u* size_ptr = data;
+                data += sizeof(int32);  // Reserve space for scanline size in bytes
+
+                write_int32(data, sl_this.y);            // Y
+                data += sizeof(int32);
+
+                write_int32(data, sl_this.num_spans);    // num_spans
+                data += sizeof(int32);
+
+                unsigned num_spans = sl_this.num_spans;
+                unsigned span_idx  = sl_this.start_span;
+                do
+                {
+                    const span_data& sp = m_spans[span_idx++];
+                    const T* covers = covers_by_index(sp.covers_id);
+
+                    write_int32(data, sp.x);            // X
+                    data += sizeof(int32);
+
+                    write_int32(data, sp.len);          // span_len
+                    data += sizeof(int32);
+
+                    if(sp.len < 0)
+                    {
+                        memcpy(data, covers, sizeof(T));
+                        data += sizeof(T);
+                    }
+                    else
+                    {
+                        memcpy(data, covers, unsigned(sp.len) * sizeof(T));
+                        data += sizeof(T) * unsigned(sp.len);
+                    }
+                }
+                while(--num_spans);
+                write_int32(size_ptr, int32(unsigned(data - size_ptr)));
+            }
+        }
+
+
+        //---------------------------------------------------------------
+        const scanline_data& scanline_by_index(unsigned i) const
+        {
+            return (i < m_scanlines.size()) ? m_scanlines[i] : m_fake_scanline;
+        }
+
+        //---------------------------------------------------------------
+        const span_data& span_by_index(unsigned i) const
+        {
+            return (i < m_spans.size()) ? m_spans[i] : m_fake_span;
+        }
+
+        //---------------------------------------------------------------
+        const T* covers_by_index(int i) const
+        {
+            return m_covers[i];
+        }
+
+    private:
+        scanline_cell_storage<T>      m_covers;
+        pod_bvector<span_data, 10>    m_spans;
+        pod_bvector<scanline_data, 8> m_scanlines;
+        span_data     m_fake_span;
+        scanline_data m_fake_scanline;
+        int           m_min_x;
+        int           m_min_y;
+        int           m_max_x;
+        int           m_max_y;
+        unsigned      m_cur_scanline;
+    };
+
+
+    typedef scanline_storage_aa<int8u>  scanline_storage_aa8;  //--------scanline_storage_aa8
+    typedef scanline_storage_aa<int16u> scanline_storage_aa16; //--------scanline_storage_aa16
+    typedef scanline_storage_aa<int32u> scanline_storage_aa32; //--------scanline_storage_aa32
+
+
+
+
+    //------------------------------------------serialized_scanlines_adaptor_aa
+    template<class T> class serialized_scanlines_adaptor_aa
+    {
+    public:
+        typedef T cover_type;
+
+        //---------------------------------------------------------------------
+        class embedded_scanline
+        {
+        public:
+            typedef T cover_type;
+
+            //-----------------------------------------------------------------
+            class const_iterator
+            {
+            public:
+                struct span
+                {
+                    int32    x;
+                    int32    len; // If negative, it's a solid span, "covers" is valid
+                    const T* covers; 
+                };
+
+                const_iterator() : m_ptr(0) {}
+                const_iterator(const embedded_scanline* sl) :
+                    m_ptr(sl->m_ptr),
+                    m_dx(sl->m_dx)
+                {
+                    init_span();
+                }
+
+                const span& operator*()  const { return m_span;  }
+                const span* operator->() const { return &m_span; }
+
+                void operator ++ ()
+                {
+                    if(m_span.len < 0) 
+                    {
+                        m_ptr += sizeof(T);
+                    }
+                    else 
+                    {
+                        m_ptr += m_span.len * sizeof(T);
+                    }
+                    init_span();
+                }
+
+            private:
+                int read_int32()
+                {
+                    int32 val;
+                    ((int8u*)&val)[0] = *m_ptr++;
+                    ((int8u*)&val)[1] = *m_ptr++;
+                    ((int8u*)&val)[2] = *m_ptr++;
+                    ((int8u*)&val)[3] = *m_ptr++;
+                    return val;
+                }
+
+                void init_span()
+                {
+                    m_span.x      = read_int32() + m_dx;
+                    m_span.len    = read_int32();
+                    m_span.covers = m_ptr;
+                }
+
+                const int8u* m_ptr;
+                span         m_span;
+                int          m_dx;
+            };
+
+            friend class const_iterator;
+
+
+            //-----------------------------------------------------------------
+            embedded_scanline() : m_ptr(0), m_y(0), m_num_spans(0) {}
+
+            //-----------------------------------------------------------------
+            void     reset(int, int)     {}
+            unsigned num_spans()   const { return m_num_spans;  }
+            int      y()           const { return m_y;          }
+            const_iterator begin() const { return const_iterator(this); }
+
+
+        private:
+            //-----------------------------------------------------------------
+            int read_int32()
+            {
+                int32 val;
+                ((int8u*)&val)[0] = *m_ptr++;
+                ((int8u*)&val)[1] = *m_ptr++;
+                ((int8u*)&val)[2] = *m_ptr++;
+                ((int8u*)&val)[3] = *m_ptr++;
+                return val;
+            }
+
+        public:
+            //-----------------------------------------------------------------
+            void init(const int8u* ptr, int dx, int dy)
+            {
+                m_ptr       = ptr;
+                m_y         = read_int32() + dy;
+                m_num_spans = unsigned(read_int32());
+                m_dx        = dx;
+            }
+
+        private:
+            const int8u* m_ptr;
+            int          m_y;
+            unsigned     m_num_spans;
+            int          m_dx;
+        };
+
+
+
+    public:
+        //--------------------------------------------------------------------
+        serialized_scanlines_adaptor_aa() :
+            m_data(0),
+            m_end(0),
+            m_ptr(0),
+            m_dx(0),
+            m_dy(0),
+            m_min_x(0x7FFFFFFF),
+            m_min_y(0x7FFFFFFF),
+            m_max_x(-0x7FFFFFFF),
+            m_max_y(-0x7FFFFFFF)
+        {}
+
+        //--------------------------------------------------------------------
+        serialized_scanlines_adaptor_aa(const int8u* data, unsigned size,
+                                        double dx, double dy) :
+            m_data(data),
+            m_end(data + size),
+            m_ptr(data),
+            m_dx(iround(dx)),
+            m_dy(iround(dy)),
+            m_min_x(0x7FFFFFFF),
+            m_min_y(0x7FFFFFFF),
+            m_max_x(-0x7FFFFFFF),
+            m_max_y(-0x7FFFFFFF)
+        {}
+
+        //--------------------------------------------------------------------
+        void init(const int8u* data, unsigned size, double dx, double dy)
+        {
+            m_data  = data;
+            m_end   = data + size;
+            m_ptr   = data;
+            m_dx    = iround(dx);
+            m_dy    = iround(dy);
+            m_min_x = 0x7FFFFFFF;
+            m_min_y = 0x7FFFFFFF;
+            m_max_x = -0x7FFFFFFF;
+            m_max_y = -0x7FFFFFFF;
+        }
+
+    private:
+        //--------------------------------------------------------------------
+        int read_int32()
+        {
+            int32 val;
+            ((int8u*)&val)[0] = *m_ptr++;
+            ((int8u*)&val)[1] = *m_ptr++;
+            ((int8u*)&val)[2] = *m_ptr++;
+            ((int8u*)&val)[3] = *m_ptr++;
+            return val;
+        }
+
+        //--------------------------------------------------------------------
+        unsigned read_int32u()
+        {
+            int32u val;
+            ((int8u*)&val)[0] = *m_ptr++;
+            ((int8u*)&val)[1] = *m_ptr++;
+            ((int8u*)&val)[2] = *m_ptr++;
+            ((int8u*)&val)[3] = *m_ptr++;
+            return val;
+        }
+        
+    public:
+        // Iterate scanlines interface
+        //--------------------------------------------------------------------
+        bool rewind_scanlines()
+        {
+            m_ptr = m_data;
+            if(m_ptr < m_end)
+            {
+                m_min_x = read_int32u() + m_dx;
+                m_min_y = read_int32u() + m_dy;
+                m_max_x = read_int32u() + m_dx;
+                m_max_y = read_int32u() + m_dy;
+            }
+            return m_ptr < m_end;
+        }
+
+        //--------------------------------------------------------------------
+        int min_x() const { return m_min_x; }
+        int min_y() const { return m_min_y; }
+        int max_x() const { return m_max_x; }
+        int max_y() const { return m_max_y; }
+
+        //--------------------------------------------------------------------
+        template<class Scanline> bool sweep_scanline(Scanline& sl)
+        {
+            sl.reset_spans();
+            for(;;)
+            {
+                if(m_ptr >= m_end) return false;
+
+                read_int32();      // Skip scanline size in bytes
+                int y = read_int32() + m_dy;
+                unsigned num_spans = read_int32();
+
+                do
+                {
+                    int x = read_int32() + m_dx;
+                    int len = read_int32();
+
+                    if(len < 0)
+                    {
+                        sl.add_span(x, unsigned(-len), *m_ptr);
+                        m_ptr += sizeof(T);
+                    }
+                    else
+                    {
+                        sl.add_cells(x, len, m_ptr);
+                        m_ptr += len * sizeof(T);
+                    }
+                }
+                while(--num_spans);
+
+                if(sl.num_spans())
+                {
+                    sl.finalize(y);
+                    break;
+                }
+            }
+            return true;
+        }
+
+
+        //--------------------------------------------------------------------
+        // Specialization for embedded_scanline
+        bool sweep_scanline(embedded_scanline& sl)
+        {
+            do
+            {
+                if(m_ptr >= m_end) return false;
+
+                unsigned byte_size = read_int32u();
+                sl.init(m_ptr, m_dx, m_dy);
+                m_ptr += byte_size - sizeof(int32);
+            }
+            while(sl.num_spans() == 0);
+            return true;
+        }
+
+    private:
+        const int8u* m_data;
+        const int8u* m_end;
+        const int8u* m_ptr;
+        int          m_dx;
+        int          m_dy;
+        int          m_min_x;
+        int          m_min_y;
+        int          m_max_x;
+        int          m_max_y;
+    };
+
+
+
+    typedef serialized_scanlines_adaptor_aa<int8u>  serialized_scanlines_adaptor_aa8;  //----serialized_scanlines_adaptor_aa8
+    typedef serialized_scanlines_adaptor_aa<int16u> serialized_scanlines_adaptor_aa16; //----serialized_scanlines_adaptor_aa16
+    typedef serialized_scanlines_adaptor_aa<int32u> serialized_scanlines_adaptor_aa32; //----serialized_scanlines_adaptor_aa32
+
+}
+
+
+#endif
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_scanline_storage_bin.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_scanline_storage_bin.h
new file mode 100644
index 0000000000..3ab1adca51
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_scanline_storage_bin.h
@@ -0,0 +1,586 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Adaptation for 32-bit screen coordinates has been sponsored by 
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+// 
+//----------------------------------------------------------------------------
+
+
+#ifndef AGG_SCANLINE_STORAGE_BIN_INCLUDED
+#define AGG_SCANLINE_STORAGE_BIN_INCLUDED
+
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+#include "agg_array.h"
+
+
+namespace agg
+{
+
+    //-----------------------------------------------scanline_storage_bin
+    class scanline_storage_bin
+    {
+    public:
+        //---------------------------------------------------------------
+        struct span_data
+        {
+            int32 x;
+            int32 len;
+        };
+
+        //---------------------------------------------------------------
+        struct scanline_data
+        {
+            int      y;
+            unsigned num_spans;
+            unsigned start_span;
+        };
+
+
+        //---------------------------------------------------------------
+        class embedded_scanline
+        {
+        public:
+
+            //-----------------------------------------------------------
+            class const_iterator
+            {
+            public:
+                const_iterator() : m_storage(0) {}
+                const_iterator(const embedded_scanline* sl) :
+                    m_storage(sl->m_storage),
+                    m_span_idx(sl->m_scanline.start_span)
+                {
+                    m_span = m_storage->span_by_index(m_span_idx);
+                }
+
+                const span_data& operator*()  const { return m_span;  }
+                const span_data* operator->() const { return &m_span; }
+
+                void operator ++ ()
+                {
+                    ++m_span_idx;
+                    m_span = m_storage->span_by_index(m_span_idx);
+                }
+
+            private:
+                const scanline_storage_bin* m_storage;
+                unsigned                    m_span_idx;
+                span_data                   m_span;
+            };
+
+            friend class const_iterator;
+
+
+            //-----------------------------------------------------------
+            embedded_scanline(scanline_storage_bin& storage) :
+                m_storage(&storage)
+            {
+                setup(0);
+            }
+
+            //-----------------------------------------------------------
+            void     reset(int, int)     {}
+            unsigned num_spans()   const { return m_scanline.num_spans;  }
+            int      y()           const { return m_scanline.y;          }
+            const_iterator begin() const { return const_iterator(this); }
+
+            //-----------------------------------------------------------
+            void setup(unsigned scanline_idx)
+            {
+                m_scanline_idx = scanline_idx;
+                m_scanline = m_storage->scanline_by_index(m_scanline_idx);
+            }
+
+        private:
+            scanline_storage_bin*       m_storage;
+            scanline_data               m_scanline;
+            unsigned                    m_scanline_idx;
+        };
+
+
+        //---------------------------------------------------------------
+        scanline_storage_bin() :
+            m_spans(256-2),         // Block increment size
+            m_scanlines(),
+            m_min_x( 0x7FFFFFFF),
+            m_min_y( 0x7FFFFFFF),
+            m_max_x(-0x7FFFFFFF),
+            m_max_y(-0x7FFFFFFF),
+            m_cur_scanline(0)
+        {
+            m_fake_scanline.y = 0;
+            m_fake_scanline.num_spans = 0;
+            m_fake_scanline.start_span = 0;
+            m_fake_span.x = 0;
+            m_fake_span.len = 0;
+        }
+
+        // Renderer Interface
+        //---------------------------------------------------------------
+        void prepare()
+        {
+            m_scanlines.remove_all();
+            m_spans.remove_all();
+            m_min_x =  0x7FFFFFFF;
+            m_min_y =  0x7FFFFFFF;
+            m_max_x = -0x7FFFFFFF;
+            m_max_y = -0x7FFFFFFF;
+            m_cur_scanline = 0;
+        }
+
+        //---------------------------------------------------------------
+        template<class Scanline> void render(const Scanline& sl)
+        {
+            scanline_data sl_this;
+
+            int y = sl.y();
+            if(y < m_min_y) m_min_y = y;
+            if(y > m_max_y) m_max_y = y;
+
+            sl_this.y = y;
+            sl_this.num_spans = sl.num_spans();
+            sl_this.start_span = m_spans.size();
+            typename Scanline::const_iterator span_iterator = sl.begin();
+
+            unsigned num_spans = sl_this.num_spans;
+            for(;;)
+            {
+                span_data sp;
+                sp.x   = span_iterator->x;
+                sp.len = (int32)abs((int)(span_iterator->len));
+                m_spans.add(sp);
+                int x1 = sp.x;
+                int x2 = sp.x + sp.len - 1;
+                if(x1 < m_min_x) m_min_x = x1;
+                if(x2 > m_max_x) m_max_x = x2;
+                if(--num_spans == 0) break;
+                ++span_iterator;
+            }
+            m_scanlines.add(sl_this);
+        }
+
+
+        //---------------------------------------------------------------
+        // Iterate scanlines interface
+        int min_x() const { return m_min_x; }
+        int min_y() const { return m_min_y; }
+        int max_x() const { return m_max_x; }
+        int max_y() const { return m_max_y; }
+
+        //---------------------------------------------------------------
+        bool rewind_scanlines()
+        {
+            m_cur_scanline = 0;
+            return m_scanlines.size() > 0;
+        }
+
+
+        //---------------------------------------------------------------
+        template<class Scanline> bool sweep_scanline(Scanline& sl)
+        {
+            sl.reset_spans();
+            for(;;)
+            {
+                if(m_cur_scanline >= m_scanlines.size()) return false;
+                const scanline_data& sl_this = m_scanlines[m_cur_scanline];
+
+                unsigned num_spans = sl_this.num_spans;
+                unsigned span_idx  = sl_this.start_span;
+                do
+                {
+                    const span_data& sp = m_spans[span_idx++];
+                    sl.add_span(sp.x, sp.len, cover_full);
+                }
+                while(--num_spans);
+
+                ++m_cur_scanline;
+                if(sl.num_spans())
+                {
+                    sl.finalize(sl_this.y);
+                    break;
+                }
+            }
+            return true;
+        }
+
+
+        //---------------------------------------------------------------
+        // Specialization for embedded_scanline
+        bool sweep_scanline(embedded_scanline& sl)
+        {
+            do
+            {
+                if(m_cur_scanline >= m_scanlines.size()) return false;
+                sl.setup(m_cur_scanline);
+                ++m_cur_scanline;
+            }
+            while(sl.num_spans() == 0);
+            return true;
+        }
+
+
+        //---------------------------------------------------------------
+        unsigned byte_size() const
+        {
+            unsigned i;
+            unsigned size = sizeof(int32) * 4; // min_x, min_y, max_x, max_y
+
+            for(i = 0; i < m_scanlines.size(); ++i)
+            {
+                size += sizeof(int32) * 2 + // Y, num_spans
+                        unsigned(m_scanlines[i].num_spans) * sizeof(int32) * 2; // X, span_len
+            }
+            return size;
+        }
+
+
+        //---------------------------------------------------------------
+        static void write_int32(int8u* dst, int32 val)
+        {
+            dst[0] = ((const int8u*)&val)[0];
+            dst[1] = ((const int8u*)&val)[1];
+            dst[2] = ((const int8u*)&val)[2];
+            dst[3] = ((const int8u*)&val)[3];
+        }
+
+
+        //---------------------------------------------------------------
+        void serialize(int8u* data) const
+        {
+            unsigned i;
+
+            write_int32(data, min_x()); // min_x
+            data += sizeof(int32);
+            write_int32(data, min_y()); // min_y
+            data += sizeof(int32);
+            write_int32(data, max_x()); // max_x
+            data += sizeof(int32);
+            write_int32(data, max_y()); // max_y
+            data += sizeof(int32);
+
+            for(i = 0; i < m_scanlines.size(); ++i)
+            {
+                const scanline_data& sl_this = m_scanlines[i];
+
+                write_int32(data, sl_this.y);            // Y
+                data += sizeof(int32);
+
+                write_int32(data, sl_this.num_spans);    // num_spans
+                data += sizeof(int32);
+
+                unsigned num_spans = sl_this.num_spans;
+                unsigned span_idx  = sl_this.start_span;
+                do
+                {
+                    const span_data& sp = m_spans[span_idx++];
+
+                    write_int32(data, sp.x);             // X
+                    data += sizeof(int32);
+
+                    write_int32(data, sp.len);           // len
+                    data += sizeof(int32);
+                }
+                while(--num_spans);
+            }
+        }
+
+
+        //---------------------------------------------------------------
+        const scanline_data& scanline_by_index(unsigned i) const
+        {
+            return (i < m_scanlines.size()) ? m_scanlines[i] : m_fake_scanline;
+        }
+
+        //---------------------------------------------------------------
+        const span_data& span_by_index(unsigned i) const
+        {
+            return (i < m_spans.size()) ? m_spans[i] : m_fake_span;
+        }
+
+
+    private:
+        pod_bvector<span_data, 10>    m_spans;
+        pod_bvector<scanline_data, 8> m_scanlines;
+        span_data     m_fake_span;
+        scanline_data m_fake_scanline;
+        int           m_min_x;
+        int           m_min_y;
+        int           m_max_x;
+        int           m_max_y;
+        unsigned      m_cur_scanline;
+    };
+
+
+
+
+
+
+
+
+
+
+
+
+
+    //---------------------------------------serialized_scanlines_adaptor_bin
+    class serialized_scanlines_adaptor_bin
+    {
+    public:
+        typedef bool cover_type;
+
+        //--------------------------------------------------------------------
+        class embedded_scanline
+        {
+        public:
+
+            //----------------------------------------------------------------
+            class const_iterator
+            {
+            public:
+                struct span
+                {
+                    int32 x;
+                    int32 len;
+                };
+
+                const_iterator() : m_ptr(0) {}
+                const_iterator(const embedded_scanline* sl) :
+                    m_ptr(sl->m_ptr),
+                    m_dx(sl->m_dx)
+                {
+                    m_span.x   = read_int32() + m_dx;
+                    m_span.len = read_int32();
+                }
+
+                const span& operator*()  const { return m_span;  }
+                const span* operator->() const { return &m_span; }
+
+                void operator ++ ()
+                {
+                    m_span.x   = read_int32() + m_dx;
+                    m_span.len = read_int32();
+                }
+
+            private:
+                int read_int32()
+                {
+                    int32 val;
+                    ((int8u*)&val)[0] = *m_ptr++;
+                    ((int8u*)&val)[1] = *m_ptr++;
+                    ((int8u*)&val)[2] = *m_ptr++;
+                    ((int8u*)&val)[3] = *m_ptr++;
+                    return val;
+                }
+
+                const int8u* m_ptr;
+                span         m_span;
+                int          m_dx;
+            };
+
+            friend class const_iterator;
+
+
+            //----------------------------------------------------------------
+            embedded_scanline() : m_ptr(0), m_y(0), m_num_spans(0) {}
+
+            //----------------------------------------------------------------
+            void     reset(int, int)     {}
+            unsigned num_spans()   const { return m_num_spans;  }
+            int      y()           const { return m_y;          }
+            const_iterator begin() const { return const_iterator(this); }
+
+
+        private:
+            //----------------------------------------------------------------
+            int read_int32()
+            {
+                int32 val;
+                ((int8u*)&val)[0] = *m_ptr++;
+                ((int8u*)&val)[1] = *m_ptr++;
+                ((int8u*)&val)[2] = *m_ptr++;
+                ((int8u*)&val)[3] = *m_ptr++;
+                return val;
+            }
+
+        public:
+            //----------------------------------------------------------------
+            void init(const int8u* ptr, int dx, int dy)
+            {
+                m_ptr       = ptr;
+                m_y         = read_int32() + dy;
+                m_num_spans = unsigned(read_int32());
+                m_dx        = dx;
+            }
+
+        private:
+            const int8u* m_ptr;
+            int          m_y;
+            unsigned     m_num_spans;
+            int          m_dx;
+        };
+
+
+
+    public:
+        //--------------------------------------------------------------------
+        serialized_scanlines_adaptor_bin() :
+            m_data(0),
+            m_end(0),
+            m_ptr(0),
+            m_dx(0),
+            m_dy(0),
+            m_min_x(0x7FFFFFFF),
+            m_min_y(0x7FFFFFFF),
+            m_max_x(-0x7FFFFFFF),
+            m_max_y(-0x7FFFFFFF)
+        {}
+
+        //--------------------------------------------------------------------
+        serialized_scanlines_adaptor_bin(const int8u* data, unsigned size,
+                                         double dx, double dy) :
+            m_data(data),
+            m_end(data + size),
+            m_ptr(data),
+            m_dx(iround(dx)),
+            m_dy(iround(dy)),
+            m_min_x(0x7FFFFFFF),
+            m_min_y(0x7FFFFFFF),
+            m_max_x(-0x7FFFFFFF),
+            m_max_y(-0x7FFFFFFF)
+        {}
+
+        //--------------------------------------------------------------------
+        void init(const int8u* data, unsigned size, double dx, double dy)
+        {
+            m_data  = data;
+            m_end   = data + size;
+            m_ptr   = data;
+            m_dx    = iround(dx);
+            m_dy    = iround(dy);
+            m_min_x = 0x7FFFFFFF;
+            m_min_y = 0x7FFFFFFF;
+            m_max_x = -0x7FFFFFFF;
+            m_max_y = -0x7FFFFFFF;
+        }
+
+    private:
+        //--------------------------------------------------------------------
+        int read_int32()
+        {
+            int32 val;
+            ((int8u*)&val)[0] = *m_ptr++;
+            ((int8u*)&val)[1] = *m_ptr++;
+            ((int8u*)&val)[2] = *m_ptr++;
+            ((int8u*)&val)[3] = *m_ptr++;
+            return val;
+        }
+       
+    public:
+        // Iterate scanlines interface
+        //--------------------------------------------------------------------
+        bool rewind_scanlines()
+        {
+            m_ptr = m_data;
+            if(m_ptr < m_end)
+            {
+                m_min_x = read_int32() + m_dx; 
+                m_min_y = read_int32() + m_dy;
+                m_max_x = read_int32() + m_dx;
+                m_max_y = read_int32() + m_dy;
+            }
+            return m_ptr < m_end;
+        }
+
+        //--------------------------------------------------------------------
+        int min_x() const { return m_min_x; }
+        int min_y() const { return m_min_y; }
+        int max_x() const { return m_max_x; }
+        int max_y() const { return m_max_y; }
+
+        //--------------------------------------------------------------------
+        template<class Scanline> bool sweep_scanline(Scanline& sl)
+        {
+            sl.reset_spans();
+            for(;;)
+            {
+                if(m_ptr >= m_end) return false;
+
+                int y = read_int32() + m_dy;
+                unsigned num_spans = read_int32();
+
+                do
+                {
+                    int x = read_int32() + m_dx;
+                    int len = read_int32();
+
+                    if(len < 0) len = -len;
+                    sl.add_span(x, unsigned(len), cover_full);
+                }
+                while(--num_spans);
+
+                if(sl.num_spans())
+                {
+                    sl.finalize(y);
+                    break;
+                }
+            }
+            return true;
+        }
+
+
+        //--------------------------------------------------------------------
+        // Specialization for embedded_scanline
+        bool sweep_scanline(embedded_scanline& sl)
+        {
+            do
+            {
+                if(m_ptr >= m_end) return false;
+
+                sl.init(m_ptr, m_dx, m_dy);
+
+                // Jump to the next scanline
+                //--------------------------
+                read_int32();                    // Y
+                int num_spans = read_int32();    // num_spans
+                m_ptr += num_spans * sizeof(int32) * 2;
+            }
+            while(sl.num_spans() == 0);
+            return true;
+        }
+
+    private:
+        const int8u* m_data;
+        const int8u* m_end;
+        const int8u* m_ptr;
+        int          m_dx;
+        int          m_dy;
+        int          m_min_x;
+        int          m_min_y;
+        int          m_max_x;
+        int          m_max_y;
+    };
+
+
+
+}
+
+#endif
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_scanline_u.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_scanline_u.h
new file mode 100644
index 0000000000..2628f55f47
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_scanline_u.h
@@ -0,0 +1,499 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Adaptation for 32-bit screen coordinates (scanline32_u) has been sponsored by 
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+// 
+//----------------------------------------------------------------------------
+
+#ifndef AGG_SCANLINE_U_INCLUDED
+#define AGG_SCANLINE_U_INCLUDED
+
+#include "agg_array.h"
+
+namespace agg
+{
+    //=============================================================scanline_u8
+    //
+    // Unpacked scanline container class
+    //
+    // This class is used to transfer data from a scanline rasterizer 
+    // to the rendering buffer. It's organized very simple. The class stores 
+    // information of horizontal spans to render it into a pixel-map buffer. 
+    // Each span has staring X, length, and an array of bytes that determine the 
+    // cover-values for each pixel. 
+    // Before using this class you should know the minimal and maximal pixel 
+    // coordinates of your scanline. The protocol of using is:
+    // 1. reset(min_x, max_x)
+    // 2. add_cell() / add_span() - accumulate scanline. 
+    //    When forming one scanline the next X coordinate must be always greater
+    //    than the last stored one, i.e. it works only with ordered coordinates.
+    // 3. Call finalize(y) and render the scanline.
+    // 3. Call reset_spans() to prepare for the new scanline.
+    //    
+    // 4. Rendering:
+    // 
+    // Scanline provides an iterator class that allows you to extract
+    // the spans and the cover values for each pixel. Be aware that clipping
+    // has not been done yet, so you should perform it yourself.
+    // Use scanline_u8::iterator to render spans:
+    //-------------------------------------------------------------------------
+    //
+    // int y = sl.y();                    // Y-coordinate of the scanline
+    //
+    // ************************************
+    // ...Perform vertical clipping here...
+    // ************************************
+    //
+    // scanline_u8::const_iterator span = sl.begin();
+    // 
+    // unsigned char* row = m_rbuf->row(y); // The address of the beginning
+    //                                      // of the current row
+    // 
+    // unsigned num_spans = sl.num_spans(); // Number of spans. It's guaranteed that
+    //                                      // num_spans is always greater than 0.
+    //
+    // do
+    // {
+    //     const scanline_u8::cover_type* covers =
+    //         span->covers;                     // The array of the cover values
+    //
+    //     int num_pix = span->len;              // Number of pixels of the span.
+    //                                           // Always greater than 0, still it's
+    //                                           // better to use "int" instead of 
+    //                                           // "unsigned" because it's more
+    //                                           // convenient for clipping
+    //     int x = span->x;
+    //
+    //     **************************************
+    //     ...Perform horizontal clipping here...
+    //     ...you have x, covers, and pix_count..
+    //     **************************************
+    //
+    //     unsigned char* dst = row + x;  // Calculate the start address of the row.
+    //                                    // In this case we assume a simple 
+    //                                    // grayscale image 1-byte per pixel.
+    //     do
+    //     {
+    //         *dst++ = *covers++;        // Hypotetical rendering. 
+    //     }
+    //     while(--num_pix);
+    //
+    //     ++span;
+    // } 
+    // while(--num_spans);  // num_spans cannot be 0, so this loop is quite safe
+    //------------------------------------------------------------------------
+    //
+    // The question is: why should we accumulate the whole scanline when we
+    // could render just separate spans when they're ready?
+    // That's because using the scanline is generally faster. When is consists 
+    // of more than one span the conditions for the processor cash system
+    // are better, because switching between two different areas of memory 
+    // (that can be very large) occurs less frequently.
+    //------------------------------------------------------------------------
+    class scanline_u8
+    {
+    public:
+        typedef scanline_u8 self_type;
+        typedef int8u       cover_type;
+        typedef int16       coord_type;
+
+        //--------------------------------------------------------------------
+        struct span
+        {
+            coord_type  x;
+            coord_type  len;
+            cover_type* covers;
+        };
+
+        typedef span* iterator;
+        typedef const span* const_iterator;
+
+        //--------------------------------------------------------------------
+        scanline_u8() :
+            m_min_x(0),
+            m_last_x(0x7FFFFFF0),
+            m_cur_span(0)
+        {}
+
+        //--------------------------------------------------------------------
+        void reset(int min_x, int max_x)
+        {
+            unsigned max_len = max_x - min_x + 2;
+            if(max_len > m_spans.size())
+            {
+                m_spans.resize(max_len);
+                m_covers.resize(max_len);
+            }
+            m_last_x   = 0x7FFFFFF0;
+            m_min_x    = min_x;
+            m_cur_span = &m_spans[0];
+        }
+
+        //--------------------------------------------------------------------
+        void add_cell(int x, unsigned cover)
+        {
+            x -= m_min_x;
+            m_covers[x] = (cover_type)cover;
+            if(x == m_last_x+1)
+            {
+                m_cur_span->len++;
+            }
+            else
+            {
+                m_cur_span++;
+                m_cur_span->x      = (coord_type)(x + m_min_x);
+                m_cur_span->len    = 1;
+                m_cur_span->covers = &m_covers[x];
+            }
+            m_last_x = x;
+        }
+
+        //--------------------------------------------------------------------
+        void add_cells(int x, unsigned len, const cover_type* covers)
+        {
+            x -= m_min_x;
+            memcpy(&m_covers[x], covers, len * sizeof(cover_type));
+            if(x == m_last_x+1)
+            {
+                m_cur_span->len += (coord_type)len;
+            }
+            else
+            {
+                m_cur_span++;
+                m_cur_span->x      = (coord_type)(x + m_min_x);
+                m_cur_span->len    = (coord_type)len;
+                m_cur_span->covers = &m_covers[x];
+            }
+            m_last_x = x + len - 1;
+        }
+
+        //--------------------------------------------------------------------
+        void add_span(int x, unsigned len, unsigned cover)
+        {
+            x -= m_min_x;
+            memset(&m_covers[x], cover, len);
+            if(x == m_last_x+1)
+            {
+                m_cur_span->len += (coord_type)len;
+            }
+            else
+            {
+                m_cur_span++;
+                m_cur_span->x      = (coord_type)(x + m_min_x);
+                m_cur_span->len    = (coord_type)len;
+                m_cur_span->covers = &m_covers[x];
+            }
+            m_last_x = x + len - 1;
+        }
+
+        //--------------------------------------------------------------------
+        void finalize(int y) 
+        { 
+            m_y = y; 
+        }
+
+        //--------------------------------------------------------------------
+        void reset_spans()
+        {
+            m_last_x    = 0x7FFFFFF0;
+            m_cur_span  = &m_spans[0];
+        }
+
+        //--------------------------------------------------------------------
+        int      y()           const { return m_y; }
+        unsigned num_spans()   const { return unsigned(m_cur_span - &m_spans[0]); }
+        const_iterator begin() const { return &m_spans[1]; }
+        iterator       begin()       { return &m_spans[1]; }
+
+    private:
+        scanline_u8(const self_type&);
+        const self_type& operator = (const self_type&);
+
+    private:
+        int                   m_min_x;
+        int                   m_last_x;
+        int                   m_y;
+        pod_array<cover_type> m_covers;
+        pod_array<span>       m_spans;
+        span*                 m_cur_span;
+    };
+
+
+
+
+    //==========================================================scanline_u8_am
+    // 
+    // The scanline container with alpha-masking
+    // 
+    //------------------------------------------------------------------------
+    template<class AlphaMask> 
+    class scanline_u8_am : public scanline_u8
+    {
+    public:
+        typedef scanline_u8           base_type;
+        typedef AlphaMask             alpha_mask_type;
+        typedef base_type::cover_type cover_type;
+        typedef base_type::coord_type coord_type;
+
+        scanline_u8_am() : base_type(), m_alpha_mask(0) {}
+        scanline_u8_am(AlphaMask& am) : base_type(), m_alpha_mask(&am) {}
+
+        //--------------------------------------------------------------------
+        void finalize(int span_y)
+        {
+            base_type::finalize(span_y);
+            if(m_alpha_mask)
+            {
+                typename base_type::iterator span = base_type::begin();
+                unsigned count = base_type::num_spans();
+                do
+                {
+                    m_alpha_mask->combine_hspan(span->x, 
+                                                base_type::y(), 
+                                                span->covers, 
+                                                span->len);
+                    ++span;
+                }
+                while(--count);
+            }
+        }
+
+    private:
+        AlphaMask* m_alpha_mask;
+    };
+
+
+
+
+    //===========================================================scanline32_u8
+    class scanline32_u8
+    {
+    public:
+        typedef scanline32_u8 self_type;
+        typedef int8u         cover_type;
+        typedef int32         coord_type;
+
+        //--------------------------------------------------------------------
+        struct span
+        {
+            span() {}
+            span(coord_type x_, coord_type len_, cover_type* covers_) :
+                x(x_), len(len_), covers(covers_) {}
+
+            coord_type  x;
+            coord_type  len;
+            cover_type* covers;
+        };
+
+        typedef pod_bvector<span, 4> span_array_type;
+
+        //--------------------------------------------------------------------
+        class const_iterator
+        {
+        public:
+            const_iterator(const span_array_type& spans) :
+                m_spans(spans),
+                m_span_idx(0)
+            {}
+
+            const span& operator*()  const { return m_spans[m_span_idx];  }
+            const span* operator->() const { return &m_spans[m_span_idx]; }
+
+            void operator ++ () { ++m_span_idx; }
+
+        private:
+            const span_array_type& m_spans;
+            unsigned               m_span_idx;
+        };
+
+        //--------------------------------------------------------------------
+        class iterator
+        {
+        public:
+            iterator(span_array_type& spans) :
+                m_spans(spans),
+                m_span_idx(0)
+            {}
+
+            span& operator*()  { return m_spans[m_span_idx];  }
+            span* operator->() { return &m_spans[m_span_idx]; }
+
+            void operator ++ () { ++m_span_idx; }
+
+        private:
+            span_array_type& m_spans;
+            unsigned         m_span_idx;
+        };
+
+
+
+        //--------------------------------------------------------------------
+        scanline32_u8() :
+            m_min_x(0),
+            m_last_x(0x7FFFFFF0),
+            m_covers()
+        {}
+
+        //--------------------------------------------------------------------
+        void reset(int min_x, int max_x)
+        {
+            unsigned max_len = max_x - min_x + 2;
+            if(max_len > m_covers.size())
+            {
+                m_covers.resize(max_len);
+            }
+            m_last_x = 0x7FFFFFF0;
+            m_min_x  = min_x;
+            m_spans.remove_all();
+        }
+
+        //--------------------------------------------------------------------
+        void add_cell(int x, unsigned cover)
+        {
+            x -= m_min_x;
+            m_covers[x] = cover_type(cover);
+            if(x == m_last_x+1)
+            {
+                m_spans.last().len++;
+            }
+            else
+            {
+                m_spans.add(span(coord_type(x + m_min_x), 1, &m_covers[x]));
+            }
+            m_last_x = x;
+        }
+
+        //--------------------------------------------------------------------
+        void add_cells(int x, unsigned len, const cover_type* covers)
+        {
+            x -= m_min_x;
+            memcpy(&m_covers[x], covers, len * sizeof(cover_type));
+            if(x == m_last_x+1)
+            {
+                m_spans.last().len += coord_type(len);
+            }
+            else
+            {
+                m_spans.add(span(coord_type(x + m_min_x), 
+                                 coord_type(len), 
+                                 &m_covers[x]));
+            }
+            m_last_x = x + len - 1;
+        }
+
+        //--------------------------------------------------------------------
+        void add_span(int x, unsigned len, unsigned cover)
+        {
+            x -= m_min_x;
+            memset(&m_covers[x], cover, len);
+            if(x == m_last_x+1)
+            {
+                m_spans.last().len += coord_type(len);
+            }
+            else
+            {
+                m_spans.add(span(coord_type(x + m_min_x), 
+                                 coord_type(len), 
+                                 &m_covers[x]));
+            }
+            m_last_x = x + len - 1;
+        }
+
+        //--------------------------------------------------------------------
+        void finalize(int y) 
+        { 
+            m_y = y; 
+        }
+
+        //--------------------------------------------------------------------
+        void reset_spans()
+        {
+            m_last_x = 0x7FFFFFF0;
+            m_spans.remove_all();
+        }
+
+        //--------------------------------------------------------------------
+        int      y()           const { return m_y; }
+        unsigned num_spans()   const { return m_spans.size(); }
+        const_iterator begin() const { return const_iterator(m_spans); }
+        iterator       begin()       { return iterator(m_spans); }
+
+    private:
+        scanline32_u8(const self_type&);
+        const self_type& operator = (const self_type&);
+
+    private:
+        int                   m_min_x;
+        int                   m_last_x;
+        int                   m_y;
+        pod_array<cover_type> m_covers;
+        span_array_type       m_spans;
+    };
+
+
+
+
+    //========================================================scanline32_u8_am
+    // 
+    // The scanline container with alpha-masking
+    // 
+    //------------------------------------------------------------------------
+    template<class AlphaMask> 
+    class scanline32_u8_am : public scanline32_u8
+    {
+    public:
+        typedef scanline32_u8         base_type;
+        typedef AlphaMask             alpha_mask_type;
+        typedef base_type::cover_type cover_type;
+        typedef base_type::coord_type coord_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)
+        {
+            base_type::finalize(span_y);
+            if(m_alpha_mask)
+            {
+                typename base_type::iterator span = base_type::begin();
+                unsigned count = base_type::num_spans();
+                do
+                {
+                    m_alpha_mask->combine_hspan(span->x, 
+                                                base_type::y(), 
+                                                span->covers, 
+                                                span->len);
+                    ++span;
+                }
+                while(--count);
+            }
+        }
+
+    private:
+        AlphaMask* m_alpha_mask;
+    };
+
+
+
+}
+
+#endif
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_shorten_path.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_shorten_path.h
new file mode 100644
index 0000000000..dd9929ff97
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_shorten_path.h
@@ -0,0 +1,66 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_SHORTEN_PATH_INCLUDED
+#define AGG_SHORTEN_PATH_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_vertex_sequence.h"
+
+namespace agg
+{
+
+    //===========================================================shorten_path
+    template<class VertexSequence> 
+    void shorten_path(VertexSequence& vs, double s, unsigned closed = 0)
+    {
+        typedef typename VertexSequence::value_type vertex_type;
+
+        if(s > 0.0 && vs.size() > 1)
+        {
+            double d;
+            int n = int(vs.size() - 2);
+            while(n)
+            {
+                d = vs[n].dist;
+                if(d > s) break;
+                vs.remove_last();
+                s -= d;
+                --n;
+            }
+            if(vs.size() < 2)
+            {
+                vs.remove_all();
+            }
+            else
+            {
+                n = vs.size() - 1;
+                vertex_type& prev = vs[n-1];
+                vertex_type& last = vs[n];
+                d = (prev.dist - s) / prev.dist;
+                double x = prev.x + (last.x - prev.x) * d;
+                double y = prev.y + (last.y - prev.y) * d;
+                last.x = x;
+                last.y = y;
+                if(!prev(last)) vs.remove_last();
+                vs.close(closed != 0);
+            }
+        }
+    }
+
+
+}
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_allocator.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_allocator.h
new file mode 100644
index 0000000000..201b69bb01
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_allocator.h
@@ -0,0 +1,54 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_SPAN_ALLOCATOR_INCLUDED
+#define AGG_SPAN_ALLOCATOR_INCLUDED
+
+#include "agg_array.h"
+
+namespace agg
+{
+    //----------------------------------------------------------span_allocator
+    template<class ColorT> class span_allocator
+    {
+    public:
+        typedef ColorT color_type;
+
+        //--------------------------------------------------------------------
+        AGG_INLINE color_type* allocate(unsigned span_len)
+        {
+            if(span_len > m_span.size())
+            {
+                // To reduce the number of reallocs we align the 
+                // span_len to 256 color elements. 
+                // Well, I just like this number and it looks reasonable.
+                //-----------------------
+                m_span.resize(((span_len + 255) >> 8) << 8);
+            }
+            return &m_span[0];
+        }
+
+        AGG_INLINE color_type* span()               { return &m_span[0]; }
+        AGG_INLINE unsigned    max_span_len() const { return m_span.size(); }
+
+    private:
+        pod_array<color_type> m_span;
+    };
+}
+
+
+#endif
+
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_converter.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_converter.h
new file mode 100644
index 0000000000..91d0f87c25
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_converter.h
@@ -0,0 +1,56 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_SPAN_CONVERTER_INCLUDED
+#define AGG_SPAN_CONVERTER_INCLUDED
+
+#include "agg_basics.h"
+
+namespace agg
+{
+    //----------------------------------------------------------span_converter
+    template<class SpanGenerator, class SpanConverter> class span_converter
+    {
+    public:
+        typedef typename SpanGenerator::color_type color_type;
+
+        span_converter(SpanGenerator& span_gen, SpanConverter& span_cnv) : 
+            m_span_gen(&span_gen), m_span_cnv(&span_cnv) {}
+
+        void attach_generator(SpanGenerator& span_gen) { m_span_gen = &span_gen; }
+        void attach_converter(SpanConverter& span_cnv) { m_span_cnv = &span_cnv; }
+
+        //--------------------------------------------------------------------
+        void prepare() 
+        { 
+            m_span_gen->prepare(); 
+            m_span_cnv->prepare();
+        }
+
+        //--------------------------------------------------------------------
+        void generate(color_type* span, int x, int y, unsigned len)
+        {
+            m_span_gen->generate(span, x, y, len);
+            m_span_cnv->generate(span, x, y, len);
+        }
+
+    private:
+        SpanGenerator* m_span_gen;
+        SpanConverter* m_span_cnv;
+    };
+
+}
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_gouraud.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_gouraud.h
new file mode 100644
index 0000000000..2986c88fee
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_gouraud.h
@@ -0,0 +1,172 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_SPAN_GOURAUD_INCLUDED
+#define AGG_SPAN_GOURAUD_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_math.h"
+
+namespace agg
+{
+
+    //============================================================span_gouraud
+    template<class ColorT> class span_gouraud
+    {
+    public:
+        typedef ColorT color_type;
+
+        struct coord_type
+        {
+            double x;
+            double y;
+            color_type color;
+        };
+
+        //--------------------------------------------------------------------
+        span_gouraud() : 
+            m_vertex(0)
+        {
+            m_cmd[0] = path_cmd_stop;
+        }
+
+        //--------------------------------------------------------------------
+        span_gouraud(const color_type& c1,
+                     const color_type& c2,
+                     const color_type& c3,
+                     double x1, double y1,
+                     double x2, double y2,
+                     double x3, double y3,
+                     double d) : 
+            m_vertex(0)
+        {
+            colors(c1, c2, c3);
+            triangle(x1, y1, x2, y2, x3, y3, d);
+        }
+
+        //--------------------------------------------------------------------
+        void colors(ColorT c1, ColorT c2, ColorT c3)
+        {
+            m_coord[0].color = c1;
+            m_coord[1].color = c2;
+            m_coord[2].color = c3;
+        }
+
+        //--------------------------------------------------------------------
+        // Sets the triangle and dilates it if needed.
+        // The trick here is to calculate beveled joins in the vertices of the 
+        // triangle and render it as a 6-vertex polygon. 
+        // It's necessary to achieve numerical stability. 
+        // However, the coordinates to interpolate colors are calculated
+        // as miter joins (calc_intersection).
+        void triangle(double x1, double y1, 
+                      double x2, double y2,
+                      double x3, double y3,
+                      double d)
+        {
+            m_coord[0].x = m_x[0] = x1; 
+            m_coord[0].y = m_y[0] = y1;
+            m_coord[1].x = m_x[1] = x2; 
+            m_coord[1].y = m_y[1] = y2;
+            m_coord[2].x = m_x[2] = x3; 
+            m_coord[2].y = m_y[2] = y3;
+            m_cmd[0] = path_cmd_move_to;
+            m_cmd[1] = path_cmd_line_to;
+            m_cmd[2] = path_cmd_line_to;
+            m_cmd[3] = path_cmd_stop;
+
+            if(d != 0.0)
+            {   
+                dilate_triangle(m_coord[0].x, m_coord[0].y,
+                                m_coord[1].x, m_coord[1].y,
+                                m_coord[2].x, m_coord[2].y,
+                                m_x, m_y, d);
+
+                calc_intersection(m_x[4], m_y[4], m_x[5], m_y[5],
+                                  m_x[0], m_y[0], m_x[1], m_y[1],
+                                  &m_coord[0].x, &m_coord[0].y);
+
+                calc_intersection(m_x[0], m_y[0], m_x[1], m_y[1],
+                                  m_x[2], m_y[2], m_x[3], m_y[3],
+                                  &m_coord[1].x, &m_coord[1].y);
+
+                calc_intersection(m_x[2], m_y[2], m_x[3], m_y[3],
+                                  m_x[4], m_y[4], m_x[5], m_y[5],
+                                  &m_coord[2].x, &m_coord[2].y);
+                m_cmd[3] = path_cmd_line_to;
+                m_cmd[4] = path_cmd_line_to;
+                m_cmd[5] = path_cmd_line_to;
+                m_cmd[6] = path_cmd_stop;
+            }
+        }
+
+        //--------------------------------------------------------------------
+        // Vertex Source Interface to feed the coordinates to the rasterizer
+        void rewind(unsigned)
+        {
+            m_vertex = 0;
+        }
+
+        //--------------------------------------------------------------------
+        unsigned vertex(double* x, double* y)
+        {
+            *x = m_x[m_vertex];
+            *y = m_y[m_vertex];
+            return m_cmd[m_vertex++];
+        }
+
+    protected:
+        //--------------------------------------------------------------------
+        void arrange_vertices(coord_type* coord) const
+        {
+            coord[0] = m_coord[0];
+            coord[1] = m_coord[1];
+            coord[2] = m_coord[2];
+
+            if(m_coord[0].y > m_coord[2].y)
+            {
+                coord[0] = m_coord[2]; 
+                coord[2] = m_coord[0];
+            }
+
+            coord_type tmp;
+            if(coord[0].y > coord[1].y)
+            {
+                tmp      = coord[1];
+                coord[1] = coord[0];
+                coord[0] = tmp;
+            }
+
+            if(coord[1].y > coord[2].y)
+            {
+                tmp      = coord[2];
+                coord[2] = coord[1];
+                coord[1] = tmp;
+            }
+       }
+
+    private:
+        //--------------------------------------------------------------------
+        coord_type m_coord[3];
+        double m_x[8];
+        double m_y[8];
+        unsigned m_cmd[8];
+        unsigned m_vertex;
+    };
+
+}
+
+#endif
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_gouraud_rgba.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_gouraud_rgba.h
new file mode 100644
index 0000000000..1b28572029
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_gouraud_rgba.h
@@ -0,0 +1,277 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Adaptation for high precision colors has been sponsored by 
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+// 
+//----------------------------------------------------------------------------
+
+#ifndef AGG_SPAN_GOURAUD_RGBA_INCLUDED
+#define AGG_SPAN_GOURAUD_RGBA_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_color_rgba.h"
+#include "agg_dda_line.h"
+#include "agg_span_gouraud.h"
+
+namespace agg
+{
+
+    //=======================================================span_gouraud_rgba
+    template<class ColorT> class span_gouraud_rgba : public span_gouraud<ColorT>
+    {
+    public:
+        typedef ColorT color_type;
+        typedef typename ColorT::value_type value_type;
+        typedef span_gouraud<color_type> base_type;
+        typedef typename base_type::coord_type coord_type;
+        enum subpixel_scale_e
+        { 
+            subpixel_shift = 4, 
+            subpixel_scale = 1 << subpixel_shift
+        };
+
+    private:
+        //--------------------------------------------------------------------
+        struct rgba_calc
+        {
+            void init(const coord_type& c1, const coord_type& c2)
+            {
+                m_x1  = c1.x - 0.5; 
+                m_y1  = c1.y - 0.5;
+                m_dx  = c2.x - c1.x;
+                double dy = c2.y - c1.y;
+                m_1dy = (dy < 1e-5) ? 1e5 : 1.0 / dy;
+                m_r1  = c1.color.r;
+                m_g1  = c1.color.g;
+                m_b1  = c1.color.b;
+                m_a1  = c1.color.a;
+                m_dr  = c2.color.r - m_r1;
+                m_dg  = c2.color.g - m_g1;
+                m_db  = c2.color.b - m_b1;
+                m_da  = c2.color.a - m_a1;
+            }
+
+            void calc(double y)
+            {
+                double k = (y - m_y1) * m_1dy;
+                if(k < 0.0) k = 0.0;
+                if(k > 1.0) k = 1.0;
+                m_r = m_r1 + iround(m_dr * k);
+                m_g = m_g1 + iround(m_dg * k);
+                m_b = m_b1 + iround(m_db * k);
+                m_a = m_a1 + iround(m_da * k);
+                m_x = iround((m_x1 + m_dx * k) * subpixel_scale);
+            }
+
+            double m_x1;
+            double m_y1;
+            double m_dx;
+            double m_1dy;
+            int    m_r1;
+            int    m_g1;
+            int    m_b1;
+            int    m_a1;
+            int    m_dr;
+            int    m_dg;
+            int    m_db;
+            int    m_da;
+            int    m_r;
+            int    m_g;
+            int    m_b;
+            int    m_a;
+            int    m_x;
+        };
+
+    public:
+
+        //--------------------------------------------------------------------
+        span_gouraud_rgba() {}
+        span_gouraud_rgba(const color_type& c1, 
+                          const color_type& c2, 
+                          const color_type& c3,
+                          double x1, double y1, 
+                          double x2, double y2,
+                          double x3, double y3, 
+                          double d = 0) : 
+            base_type(c1, c2, c3, x1, y1, x2, y2, x3, y3, d)
+        {}
+
+        //--------------------------------------------------------------------
+        void prepare()
+        {
+            coord_type coord[3];
+            base_type::arrange_vertices(coord);
+
+            m_y2 = int(coord[1].y);
+
+            m_swap = cross_product(coord[0].x, coord[0].y, 
+                                   coord[2].x, coord[2].y,
+                                   coord[1].x, coord[1].y) < 0.0;
+
+            m_rgba1.init(coord[0], coord[2]);
+            m_rgba2.init(coord[0], coord[1]);
+            m_rgba3.init(coord[1], coord[2]);
+        }
+
+        //--------------------------------------------------------------------
+        void generate(color_type* span, int x, int y, unsigned len)
+        {
+            m_rgba1.calc(y);//(m_rgba1.m_1dy > 2) ? m_rgba1.m_y1 : y);
+            const rgba_calc* pc1 = &m_rgba1;
+            const rgba_calc* pc2 = &m_rgba2;
+
+            if(y <= m_y2)
+            {          
+                // Bottom part of the triangle (first subtriangle)
+                //-------------------------
+                m_rgba2.calc(y + m_rgba2.m_1dy);
+            }
+            else
+            {
+                // Upper part (second subtriangle)
+                m_rgba3.calc(y - m_rgba3.m_1dy);
+                //-------------------------
+                pc2 = &m_rgba3;
+            }
+
+            if(m_swap)
+            {
+                // It means that the triangle is oriented clockwise, 
+                // so that we need to swap the controlling structures
+                //-------------------------
+                const rgba_calc* t = pc2;
+                pc2 = pc1;
+                pc1 = t;
+            }
+
+            // Get the horizontal length with subpixel accuracy
+            // and protect it from division by zero
+            //-------------------------
+            int nlen = abs(pc2->m_x - pc1->m_x);
+            if(nlen <= 0) nlen = 1;
+
+            dda_line_interpolator<14> r(pc1->m_r, pc2->m_r, nlen);
+            dda_line_interpolator<14> g(pc1->m_g, pc2->m_g, nlen);
+            dda_line_interpolator<14> b(pc1->m_b, pc2->m_b, nlen);
+            dda_line_interpolator<14> a(pc1->m_a, pc2->m_a, nlen);
+
+            // Calculate the starting point of the gradient with subpixel 
+            // accuracy and correct (roll back) the interpolators.
+            // This operation will also clip the beginning of the span
+            // if necessary.
+            //-------------------------
+            int start = pc1->m_x - (x << subpixel_shift);
+            r    -= start; 
+            g    -= start; 
+            b    -= start; 
+            a    -= start;
+            nlen += start;
+
+            int vr, vg, vb, va;
+            enum lim_e { lim = color_type::base_mask };
+
+            // Beginning part of the span. Since we rolled back the 
+            // interpolators, the color values may have overflow.
+            // So that, we render the beginning part with checking 
+            // for overflow. It lasts until "start" is positive;
+            // typically it's 1-2 pixels, but may be more in some cases.
+            //-------------------------
+            while(len && start > 0)
+            {
+                vr = r.y();
+                vg = g.y();
+                vb = b.y();
+                va = a.y();
+                if(vr < 0) { vr = 0; }; if(vr > lim) { vr = lim; };
+                if(vg < 0) { vg = 0; }; if(vg > lim) { vg = lim; };
+                if(vb < 0) { vb = 0; }; if(vb > lim) { vb = lim; };
+                if(va < 0) { va = 0; }; if(va > lim) { va = lim; };
+                span->r = (value_type)vr;
+                span->g = (value_type)vg;
+                span->b = (value_type)vb;
+                span->a = (value_type)va;
+                r     += subpixel_scale; 
+                g     += subpixel_scale; 
+                b     += subpixel_scale; 
+                a     += subpixel_scale;
+                nlen  -= subpixel_scale;
+                start -= subpixel_scale;
+                ++span;
+                --len;
+            }
+
+            // Middle part, no checking for overflow.
+            // Actual spans can be longer than the calculated length
+            // because of anti-aliasing, thus, the interpolators can 
+            // overflow. But while "nlen" is positive we are safe.
+            //-------------------------
+            while(len && nlen > 0)
+            {
+                span->r = (value_type)r.y();
+                span->g = (value_type)g.y();
+                span->b = (value_type)b.y();
+                span->a = (value_type)a.y();
+                r    += subpixel_scale; 
+                g    += subpixel_scale; 
+                b    += subpixel_scale; 
+                a    += subpixel_scale;
+                nlen -= subpixel_scale;
+                ++span;
+                --len;
+            }
+
+            // Ending part; checking for overflow.
+            // Typically it's 1-2 pixels, but may be more in some cases.
+            //-------------------------
+            while(len)
+            {
+                vr = r.y();
+                vg = g.y();
+                vb = b.y();
+                va = a.y();
+                if(vr < 0) { vr = 0; }; if(vr > lim) { vr = lim; };
+                if(vg < 0) { vg = 0; }; if(vg > lim) { vg = lim; };
+                if(vb < 0) { vb = 0; }; if(vb > lim) { vb = lim; };
+                if(va < 0) { va = 0; }; if(va > lim) { va = lim; };
+                span->r = (value_type)vr;
+                span->g = (value_type)vg;
+                span->b = (value_type)vb;
+                span->a = (value_type)va;
+                r += subpixel_scale; 
+                g += subpixel_scale; 
+                b += subpixel_scale; 
+                a += subpixel_scale;
+                ++span;
+                --len;
+            }
+        }
+
+    private:
+        bool      m_swap;
+        int       m_y2;
+        rgba_calc m_rgba1;
+        rgba_calc m_rgba2;
+        rgba_calc m_rgba3;
+    };
+
+
+
+}
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_image_filter.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_image_filter.h
new file mode 100644
index 0000000000..2f613e5d86
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_image_filter.h
@@ -0,0 +1,246 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Image transformations with filtering. Span generator base class
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_SPAN_IMAGE_FILTER_INCLUDED
+#define AGG_SPAN_IMAGE_FILTER_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_image_filters.h"
+#include "agg_span_interpolator_linear.h"
+
+namespace agg
+{
+
+    //-------------------------------------------------------span_image_filter
+    template<class Source, class Interpolator> class span_image_filter
+    {
+    public:
+        typedef Source source_type;
+        typedef Interpolator interpolator_type;
+
+        //--------------------------------------------------------------------
+        span_image_filter() {}
+        span_image_filter(source_type& src, 
+                          interpolator_type& interpolator,
+                          image_filter_lut* filter) : 
+            m_src(&src),
+            m_interpolator(&interpolator),
+            m_filter(filter),
+            m_dx_dbl(0.5),
+            m_dy_dbl(0.5),
+            m_dx_int(image_subpixel_scale / 2),
+            m_dy_int(image_subpixel_scale / 2)
+        {}
+        void attach(source_type& v) { m_src = &v; }
+
+        //--------------------------------------------------------------------
+               source_type& source()            { return *m_src; }
+        const  source_type& source()      const { return *m_src; }
+        const  image_filter_lut& filter() const { return *m_filter; }
+        int    filter_dx_int()            const { return m_dx_int; }
+        int    filter_dy_int()            const { return m_dy_int; }
+        double filter_dx_dbl()            const { return m_dx_dbl; }
+        double filter_dy_dbl()            const { return m_dy_dbl; }
+
+        //--------------------------------------------------------------------
+        void interpolator(interpolator_type& v)  { m_interpolator = &v; }
+        void filter(image_filter_lut& v)         { m_filter = &v; }
+        void filter_offset(double dx, double dy)
+        {
+            m_dx_dbl = dx;
+            m_dy_dbl = dy;
+            m_dx_int = iround(dx * image_subpixel_scale);
+            m_dy_int = iround(dy * image_subpixel_scale);
+        }
+        void filter_offset(double d) { filter_offset(d, d); }
+
+        //--------------------------------------------------------------------
+        interpolator_type& interpolator() { return *m_interpolator; }
+
+        //--------------------------------------------------------------------
+        void prepare() {}
+
+        //--------------------------------------------------------------------
+    private:
+        source_type*            m_src;
+        interpolator_type*      m_interpolator;
+        image_filter_lut*       m_filter;
+        double   m_dx_dbl;
+        double   m_dy_dbl;
+        unsigned m_dx_int;
+        unsigned m_dy_int;
+    };
+
+
+
+
+    //==============================================span_image_resample_affine
+    template<class Source> 
+    class span_image_resample_affine : 
+    public span_image_filter<Source, span_interpolator_linear<trans_affine> >
+    {
+    public:
+        typedef Source source_type;
+        typedef span_interpolator_linear<trans_affine> interpolator_type;
+        typedef span_image_filter<source_type, interpolator_type> base_type;
+
+        //--------------------------------------------------------------------
+        span_image_resample_affine() : 
+            m_scale_limit(200.0),
+            m_blur_x(1.0),
+            m_blur_y(1.0)
+        {}
+
+        //--------------------------------------------------------------------
+        span_image_resample_affine(source_type& src, 
+                                   interpolator_type& inter,
+                                   image_filter_lut& filter) :
+            base_type(src, inter, &filter),
+            m_scale_limit(200.0),
+            m_blur_x(1.0),
+            m_blur_y(1.0)
+        {}
+
+
+        //--------------------------------------------------------------------
+        int  scale_limit() const { return uround(m_scale_limit); }
+        void scale_limit(int v)  { m_scale_limit = v; }
+
+        //--------------------------------------------------------------------
+        double blur_x() const { return m_blur_x; }
+        double blur_y() const { return m_blur_y; }
+        void blur_x(double v) { m_blur_x = v; }
+        void blur_y(double v) { m_blur_y = v; }
+        void blur(double v) { m_blur_x = m_blur_y = v; }
+
+        //--------------------------------------------------------------------
+        void prepare() 
+        {
+            double scale_x;
+            double scale_y;
+
+            base_type::interpolator().transformer().scaling_abs(&scale_x, &scale_y);
+
+            if(scale_x * scale_y > m_scale_limit)
+            {
+                scale_x = scale_x * m_scale_limit / (scale_x * scale_y);
+                scale_y = scale_y * m_scale_limit / (scale_x * scale_y);
+            }
+
+            if(scale_x < 1) scale_x = 1;
+            if(scale_y < 1) scale_y = 1;
+
+            if(scale_x > m_scale_limit) scale_x = m_scale_limit;
+            if(scale_y > m_scale_limit) scale_y = m_scale_limit;
+
+            scale_x *= m_blur_x;
+            scale_y *= m_blur_y;
+
+            if(scale_x < 1) scale_x = 1;
+            if(scale_y < 1) scale_y = 1;
+
+            m_rx     = uround(    scale_x * double(image_subpixel_scale));
+            m_rx_inv = uround(1.0/scale_x * double(image_subpixel_scale));
+
+            m_ry     = uround(    scale_y * double(image_subpixel_scale));
+            m_ry_inv = uround(1.0/scale_y * double(image_subpixel_scale));
+        }
+
+    protected:
+        int m_rx;
+        int m_ry;
+        int m_rx_inv;
+        int m_ry_inv;
+
+    private:
+        double m_scale_limit;
+        double m_blur_x;
+        double m_blur_y;
+    };
+
+
+
+    //=====================================================span_image_resample
+    template<class Source, class Interpolator> 
+    class span_image_resample : 
+    public span_image_filter<Source, Interpolator>
+    {
+    public:
+        typedef Source source_type;
+        typedef Interpolator interpolator_type;
+        typedef span_image_filter<source_type, interpolator_type> base_type;
+
+        //--------------------------------------------------------------------
+        span_image_resample() : 
+            m_scale_limit(20),
+            m_blur_x(image_subpixel_scale),
+            m_blur_y(image_subpixel_scale)
+        {}
+
+        //--------------------------------------------------------------------
+        span_image_resample(source_type& src, 
+                            interpolator_type& inter,
+                            image_filter_lut& filter) :
+            base_type(src, inter, &filter),
+            m_scale_limit(20),
+            m_blur_x(image_subpixel_scale),
+            m_blur_y(image_subpixel_scale)
+        {}
+
+        //--------------------------------------------------------------------
+        int  scale_limit() const { return m_scale_limit; }
+        void scale_limit(int v)  { m_scale_limit = v; }
+
+        //--------------------------------------------------------------------
+        double blur_x() const { return double(m_blur_x) / double(image_subpixel_scale); }
+        double blur_y() const { return double(m_blur_y) / double(image_subpixel_scale); }
+        void blur_x(double v) { m_blur_x = uround(v * double(image_subpixel_scale)); }
+        void blur_y(double v) { m_blur_y = uround(v * double(image_subpixel_scale)); }
+        void blur(double v)   { m_blur_x = 
+                                m_blur_y = uround(v * double(image_subpixel_scale)); }
+
+    protected:
+        AGG_INLINE void adjust_scale(int* rx, int* ry)
+        {
+            if(*rx < image_subpixel_scale) *rx = image_subpixel_scale;
+            if(*ry < image_subpixel_scale) *ry = image_subpixel_scale;
+            if(*rx > image_subpixel_scale * m_scale_limit) 
+            {
+                *rx = image_subpixel_scale * m_scale_limit;
+            }
+            if(*ry > image_subpixel_scale * m_scale_limit) 
+            {
+                *ry = image_subpixel_scale * m_scale_limit;
+            }
+            *rx = (*rx * m_blur_x) >> image_subpixel_shift;
+            *ry = (*ry * m_blur_y) >> image_subpixel_shift;
+            if(*rx < image_subpixel_scale) *rx = image_subpixel_scale;
+            if(*ry < image_subpixel_scale) *ry = image_subpixel_scale;
+        }
+
+        int m_scale_limit;
+        int m_blur_x;
+        int m_blur_y;
+    };
+
+
+
+
+}
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_image_filter_gray.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_image_filter_gray.h
new file mode 100644
index 0000000000..e2c688e004
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_image_filter_gray.h
@@ -0,0 +1,723 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Adaptation for high precision colors has been sponsored by 
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+// 
+//----------------------------------------------------------------------------
+#ifndef AGG_SPAN_IMAGE_FILTER_GRAY_INCLUDED
+#define AGG_SPAN_IMAGE_FILTER_GRAY_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_color_gray.h"
+#include "agg_span_image_filter.h"
+
+
+namespace agg
+{
+
+    //==============================================span_image_filter_gray_nn
+    template<class Source, class Interpolator> 
+    class span_image_filter_gray_nn : 
+    public span_image_filter<Source, Interpolator>
+    {
+    public:
+        typedef Source source_type;
+        typedef typename source_type::color_type color_type;
+        typedef Interpolator interpolator_type;
+        typedef span_image_filter<source_type, interpolator_type> base_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        //--------------------------------------------------------------------
+        span_image_filter_gray_nn() {}
+        span_image_filter_gray_nn(source_type& src, 
+                                  interpolator_type& inter) :
+            base_type(src, inter, 0) 
+        {}
+
+        //--------------------------------------------------------------------
+        void generate(color_type* span, int x, int y, unsigned len)
+        {
+            base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 
+                                            y + base_type::filter_dy_dbl(), len);
+            do
+            {
+                base_type::interpolator().coordinates(&x, &y);
+                span->v = *(const value_type*)
+                    base_type::source().span(x >> image_subpixel_shift, 
+                                             y >> image_subpixel_shift, 
+                                             1);
+                span->a = color_type::full_value();
+                ++span;
+                ++base_type::interpolator();
+            } while(--len);
+        }
+    };
+
+
+
+    //=========================================span_image_filter_gray_bilinear
+    template<class Source, class Interpolator> 
+    class span_image_filter_gray_bilinear : 
+    public span_image_filter<Source, Interpolator>
+    {
+    public:
+        typedef Source source_type;
+        typedef typename source_type::color_type color_type;
+        typedef Interpolator interpolator_type;
+        typedef span_image_filter<source_type, interpolator_type> base_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        //--------------------------------------------------------------------
+        span_image_filter_gray_bilinear() {}
+        span_image_filter_gray_bilinear(source_type& src, 
+                                        interpolator_type& inter) :
+            base_type(src, inter, 0) 
+        {}
+
+
+        //--------------------------------------------------------------------
+        void generate(color_type* span, int x, int y, unsigned len)
+        {
+            base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 
+                                            y + base_type::filter_dy_dbl(), len);
+            long_type fg;
+            const value_type *fg_ptr;
+            do
+            {
+                int x_hr;
+                int y_hr;
+
+                base_type::interpolator().coordinates(&x_hr, &y_hr);
+
+                x_hr -= base_type::filter_dx_int();
+                y_hr -= base_type::filter_dy_int();
+
+                int x_lr = x_hr >> image_subpixel_shift;
+                int y_lr = y_hr >> image_subpixel_shift;
+
+                fg = 0;
+
+                x_hr &= image_subpixel_mask;
+                y_hr &= image_subpixel_mask;
+
+                fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, 2);
+                fg    += *fg_ptr * (image_subpixel_scale - x_hr) * (image_subpixel_scale - y_hr);
+
+                fg_ptr = (const value_type*)base_type::source().next_x();
+                fg    += *fg_ptr * x_hr * (image_subpixel_scale - y_hr);
+
+                fg_ptr = (const value_type*)base_type::source().next_y();
+                fg    += *fg_ptr * (image_subpixel_scale - x_hr) * y_hr;
+
+                fg_ptr = (const value_type*)base_type::source().next_x();
+                fg    += *fg_ptr * x_hr * y_hr;
+
+                span->v = color_type::downshift(fg, image_subpixel_shift * 2);
+                span->a = color_type::full_value();
+                ++span;
+                ++base_type::interpolator();
+
+            } while(--len);
+        }
+    };
+
+
+    //====================================span_image_filter_gray_bilinear_clip
+    template<class Source, class Interpolator> 
+    class span_image_filter_gray_bilinear_clip : 
+    public span_image_filter<Source, Interpolator>
+    {
+    public:
+        typedef Source source_type;
+        typedef typename source_type::color_type color_type;
+        typedef Interpolator interpolator_type;
+        typedef span_image_filter<source_type, interpolator_type> base_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        //--------------------------------------------------------------------
+        span_image_filter_gray_bilinear_clip() {}
+        span_image_filter_gray_bilinear_clip(source_type& src, 
+                                             const color_type& back_color,
+                                             interpolator_type& inter) :
+            base_type(src, inter, 0), 
+            m_back_color(back_color)
+        {}
+        const color_type& background_color() const { return m_back_color; }
+        void background_color(const color_type& v)   { m_back_color = v; }
+
+        //--------------------------------------------------------------------
+        void generate(color_type* span, int x, int y, unsigned len)
+        {
+            base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 
+                                            y + base_type::filter_dy_dbl(), len);
+            long_type fg;
+            long_type src_alpha;
+            value_type back_v = m_back_color.v;
+            value_type back_a = m_back_color.a;
+
+            const value_type *fg_ptr;
+
+            int maxx = base_type::source().width() - 1;
+            int maxy = base_type::source().height() - 1;
+
+            do
+            {
+                int x_hr;
+                int y_hr;
+                
+                base_type::interpolator().coordinates(&x_hr, &y_hr);
+
+                x_hr -= base_type::filter_dx_int();
+                y_hr -= base_type::filter_dy_int();
+
+                int x_lr = x_hr >> image_subpixel_shift;
+                int y_lr = y_hr >> image_subpixel_shift;
+
+                if(x_lr >= 0    && y_lr >= 0 &&
+                   x_lr <  maxx && y_lr <  maxy) 
+                {
+                    fg = 0;
+
+                    x_hr &= image_subpixel_mask;
+                    y_hr &= image_subpixel_mask;
+                    fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + x_lr;
+
+                    fg += *fg_ptr++ * (image_subpixel_scale - x_hr) * (image_subpixel_scale - y_hr);
+                    fg += *fg_ptr++ * (image_subpixel_scale - y_hr) * x_hr;
+
+                    ++y_lr;
+                    fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + x_lr;
+
+                    fg += *fg_ptr++ * (image_subpixel_scale - x_hr) * y_hr;
+                    fg += *fg_ptr++ * x_hr * y_hr;
+
+                    fg = color_type::downshift(fg, image_subpixel_shift * 2);
+                    src_alpha = color_type::full_value();
+                }
+                else
+                {
+                    unsigned weight;
+                    if(x_lr < -1   || y_lr < -1 ||
+                       x_lr > maxx || y_lr > maxy)
+                    {
+                        fg        = back_v;
+                        src_alpha = back_a;
+                    }
+                    else
+                    {
+                        fg = src_alpha = 0;
+
+                        x_hr &= image_subpixel_mask;
+                        y_hr &= image_subpixel_mask;
+
+                        weight = (image_subpixel_scale - x_hr) * 
+                                 (image_subpixel_scale - y_hr);
+                        if(x_lr >= 0    && y_lr >= 0 &&
+                           x_lr <= maxx && y_lr <= maxy)
+                        {
+                            fg += weight * 
+                                *((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
+                            src_alpha += weight * color_type::full_value();
+                        }
+                        else
+                        {
+                            fg        += back_v * weight;
+                            src_alpha += back_a * weight;
+                        }
+
+                        x_lr++;
+
+                        weight = x_hr * (image_subpixel_scale - y_hr);
+                        if(x_lr >= 0    && y_lr >= 0 &&
+                           x_lr <= maxx && y_lr <= maxy)
+                        {
+                            fg += weight * 
+                                *((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
+                            src_alpha += weight * color_type::full_value();
+                        }
+                        else
+                        {
+                            fg        += back_v * weight;
+                            src_alpha += back_a * weight;
+                        }
+
+                        x_lr--;
+                        y_lr++;
+
+                        weight = (image_subpixel_scale - x_hr) * y_hr;
+                        if(x_lr >= 0    && y_lr >= 0 &&
+                           x_lr <= maxx && y_lr <= maxy)
+                        {
+                            fg += weight * 
+                                *((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
+                            src_alpha += weight * color_type::full_value();
+                        }
+                        else
+                        {
+                            fg        += back_v * weight;
+                            src_alpha += back_a * weight;
+                        }
+
+                        x_lr++;
+
+                        weight = x_hr * y_hr;
+                        if(x_lr >= 0    && y_lr >= 0 &&
+                           x_lr <= maxx && y_lr <= maxy)
+                        {
+                            fg += weight * 
+                                *((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
+                            src_alpha += weight * color_type::full_value();
+                        }
+                        else
+                        {
+                            fg        += back_v * weight;
+                            src_alpha += back_a * weight;
+                        }
+
+                        fg = color_type::downshift(fg, image_subpixel_shift * 2);
+                        src_alpha = color_type::downshift(src_alpha, image_subpixel_shift * 2);
+                    }
+                }
+
+                span->v = (value_type)fg;
+                span->a = (value_type)src_alpha;
+                ++span;
+                ++base_type::interpolator();
+
+            } while(--len);
+        }
+    private:
+        color_type m_back_color;
+    };
+
+
+
+    //==============================================span_image_filter_gray_2x2
+    template<class Source, class Interpolator> 
+    class span_image_filter_gray_2x2 : 
+    public span_image_filter<Source, Interpolator>
+    {
+    public:
+        typedef Source source_type;
+        typedef typename source_type::color_type color_type;
+        typedef Interpolator interpolator_type;
+        typedef span_image_filter<source_type, interpolator_type> base_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        //--------------------------------------------------------------------
+        span_image_filter_gray_2x2() {}
+        span_image_filter_gray_2x2(source_type& src, 
+                                   interpolator_type& inter,
+                                   image_filter_lut& filter) :
+            base_type(src, inter, &filter) 
+        {}
+
+
+        //--------------------------------------------------------------------
+        void generate(color_type* span, int x, int y, unsigned len)
+        {
+            base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 
+                                            y + base_type::filter_dy_dbl(), len);
+
+            long_type fg;
+
+            const value_type *fg_ptr;
+            const int16* weight_array = base_type::filter().weight_array() + 
+                                        ((base_type::filter().diameter()/2 - 1) << 
+                                          image_subpixel_shift);
+            do
+            {
+                int x_hr;
+                int y_hr;
+
+                base_type::interpolator().coordinates(&x_hr, &y_hr);
+
+                x_hr -= base_type::filter_dx_int();
+                y_hr -= base_type::filter_dy_int();
+
+                int x_lr = x_hr >> image_subpixel_shift;
+                int y_lr = y_hr >> image_subpixel_shift;
+
+                unsigned weight;
+                fg = 0;
+
+                x_hr &= image_subpixel_mask;
+                y_hr &= image_subpixel_mask;
+
+                fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, 2);
+                weight = (weight_array[x_hr + image_subpixel_scale] * 
+                          weight_array[y_hr + image_subpixel_scale] + 
+                          image_filter_scale / 2) >> 
+                          image_filter_shift;
+                fg += weight * *fg_ptr;
+
+                fg_ptr = (const value_type*)base_type::source().next_x();
+                weight = (weight_array[x_hr] * 
+                          weight_array[y_hr + image_subpixel_scale] + 
+                          image_filter_scale / 2) >> 
+                          image_filter_shift;
+                fg += weight * *fg_ptr;
+
+                fg_ptr = (const value_type*)base_type::source().next_y();
+                weight = (weight_array[x_hr + image_subpixel_scale] * 
+                          weight_array[y_hr] + 
+                          image_filter_scale / 2) >> 
+                          image_filter_shift;
+                fg += weight * *fg_ptr;
+
+                fg_ptr = (const value_type*)base_type::source().next_x();
+                weight = (weight_array[x_hr] * 
+                          weight_array[y_hr] + 
+                          image_filter_scale / 2) >> 
+                          image_filter_shift;
+                fg += weight * *fg_ptr;
+
+                fg >>= image_filter_shift;
+                if(fg > color_type::full_value()) fg = color_type::full_value();
+
+                span->v = (value_type)fg;
+                span->a = color_type::full_value();
+                ++span;
+                ++base_type::interpolator();
+            } while(--len);
+        }
+    };
+
+
+
+    //==================================================span_image_filter_gray
+    template<class Source, class Interpolator> 
+    class span_image_filter_gray : 
+    public span_image_filter<Source, Interpolator>
+    {
+    public:
+        typedef Source source_type;
+        typedef typename source_type::color_type color_type;
+        typedef Interpolator interpolator_type;
+        typedef span_image_filter<source_type, interpolator_type> base_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        //--------------------------------------------------------------------
+        span_image_filter_gray() {}
+        span_image_filter_gray(source_type& src, 
+                               interpolator_type& inter,
+                               image_filter_lut& filter) :
+            base_type(src, inter, &filter) 
+        {}
+
+        //--------------------------------------------------------------------
+        void generate(color_type* span, int x, int y, unsigned len)
+        {
+            base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 
+                                            y + base_type::filter_dy_dbl(), len);
+
+            long_type fg;
+            const value_type *fg_ptr;
+
+            unsigned     diameter     = base_type::filter().diameter();
+            int          start        = base_type::filter().start();
+            const int16* weight_array = base_type::filter().weight_array();
+
+            int x_count; 
+            int weight_y;
+
+            do
+            {
+                base_type::interpolator().coordinates(&x, &y);
+
+                x -= base_type::filter_dx_int();
+                y -= base_type::filter_dy_int();
+
+                int x_hr = x; 
+                int y_hr = y; 
+
+                int x_lr = x_hr >> image_subpixel_shift;
+                int y_lr = y_hr >> image_subpixel_shift;
+
+                fg = 0;
+
+                int x_fract = x_hr & image_subpixel_mask;
+                unsigned y_count = diameter;
+
+                y_hr = image_subpixel_mask - (y_hr & image_subpixel_mask);
+                fg_ptr = (const value_type*)base_type::source().span(x_lr + start, 
+                                                                     y_lr + start, 
+                                                                     diameter);
+                for(;;)
+                {
+                    x_count  = diameter;
+                    weight_y = weight_array[y_hr];
+                    x_hr = image_subpixel_mask - x_fract;
+                    for(;;)
+                    {
+                        fg += *fg_ptr * 
+                              ((weight_y * weight_array[x_hr] + 
+                                image_filter_scale / 2) >> 
+                                image_filter_shift);
+                        if(--x_count == 0) break;
+                        x_hr  += image_subpixel_scale;
+                        fg_ptr = (const value_type*)base_type::source().next_x();
+                    }
+
+                    if(--y_count == 0) break;
+                    y_hr  += image_subpixel_scale;
+                    fg_ptr = (const value_type*)base_type::source().next_y();
+                }
+
+                fg = color_type::downshift(fg, image_filter_shift);
+                if(fg < 0) fg = 0;
+                if(fg > color_type::full_value()) fg = color_type::full_value();
+                span->v = (value_type)fg;
+                span->a = color_type::full_value();
+
+                ++span;
+                ++base_type::interpolator();
+
+            } while(--len);
+        }
+    };
+
+
+
+    //=========================================span_image_resample_gray_affine
+    template<class Source> 
+    class span_image_resample_gray_affine : 
+    public span_image_resample_affine<Source>
+    {
+    public:
+        typedef Source source_type;
+        typedef typename source_type::color_type color_type;
+        typedef span_image_resample_affine<source_type> base_type;
+        typedef typename base_type::interpolator_type interpolator_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::long_type long_type;
+        enum base_scale_e
+        {
+            downscale_shift = image_filter_shift
+        };
+
+        //--------------------------------------------------------------------
+        span_image_resample_gray_affine() {}
+        span_image_resample_gray_affine(source_type& src, 
+                                        interpolator_type& inter,
+                                        image_filter_lut& filter) :
+            base_type(src, inter, filter) 
+        {}
+
+
+        //--------------------------------------------------------------------
+        void generate(color_type* span, int x, int y, unsigned len)
+        {
+            base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 
+                                            y + base_type::filter_dy_dbl(), len);
+
+            long_type fg;
+
+            int diameter     = base_type::filter().diameter();
+            int filter_scale = diameter << image_subpixel_shift;
+            int radius_x     = (diameter * base_type::m_rx) >> 1;
+            int radius_y     = (diameter * base_type::m_ry) >> 1;
+            int len_x_lr     = 
+                (diameter * base_type::m_rx + image_subpixel_mask) >> 
+                    image_subpixel_shift;
+
+            const int16* weight_array = base_type::filter().weight_array();
+
+            do
+            {
+                base_type::interpolator().coordinates(&x, &y);
+
+                x += base_type::filter_dx_int() - radius_x;
+                y += base_type::filter_dy_int() - radius_y;
+
+                fg = 0;
+
+                int y_lr = y >> image_subpixel_shift;
+                int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) * 
+                                base_type::m_ry_inv) >> 
+                                    image_subpixel_shift;
+                int total_weight = 0;
+                int x_lr = x >> image_subpixel_shift;
+                int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) * 
+                                base_type::m_rx_inv) >> 
+                                    image_subpixel_shift;
+
+                int x_hr2 = x_hr;
+                const value_type* fg_ptr = 
+                    (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
+                for(;;)
+                {
+                    int weight_y = weight_array[y_hr];
+                    x_hr = x_hr2;
+                    for(;;)
+                    {
+                        int weight = (weight_y * weight_array[x_hr] + 
+                                     image_filter_scale / 2) >> 
+                                     downscale_shift;
+
+                        fg += *fg_ptr * weight;
+                        total_weight += weight;
+                        x_hr  += base_type::m_rx_inv;
+                        if(x_hr >= filter_scale) break;
+                        fg_ptr = (const value_type*)base_type::source().next_x();
+                    }
+                    y_hr += base_type::m_ry_inv;
+                    if(y_hr >= filter_scale) break;
+                    fg_ptr = (const value_type*)base_type::source().next_y();
+                }
+
+                fg /= total_weight;
+                if(fg < 0) fg = 0;
+                if(fg > color_type::full_value()) fg = color_type::full_value();
+
+                span->v = (value_type)fg;
+                span->a = color_type::full_value();
+
+                ++span;
+                ++base_type::interpolator();
+            } while(--len);
+        }
+    };
+
+
+
+    //================================================span_image_resample_gray
+    template<class Source, class Interpolator>
+    class span_image_resample_gray : 
+    public span_image_resample<Source, Interpolator>
+    {
+    public:
+        typedef Source source_type;
+        typedef typename source_type::color_type color_type;
+        typedef Interpolator interpolator_type;
+        typedef span_image_resample<source_type, interpolator_type> base_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::long_type long_type;
+        enum base_scale_e
+        {
+            downscale_shift = image_filter_shift
+        };
+
+        //--------------------------------------------------------------------
+        span_image_resample_gray() {}
+        span_image_resample_gray(source_type& src, 
+                                 interpolator_type& inter,
+                                 image_filter_lut& filter) :
+            base_type(src, inter, filter)
+        {}
+
+        //--------------------------------------------------------------------
+        void generate(color_type* span, int x, int y, unsigned len)
+        {
+            base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 
+                                            y + base_type::filter_dy_dbl(), len);
+            long_type fg;
+
+            int diameter = base_type::filter().diameter();
+            int filter_scale = diameter << image_subpixel_shift;
+
+            const int16* weight_array = base_type::filter().weight_array();
+            do
+            {
+                int rx;
+                int ry;
+                int rx_inv = image_subpixel_scale;
+                int ry_inv = image_subpixel_scale;
+                base_type::interpolator().coordinates(&x,  &y);
+                base_type::interpolator().local_scale(&rx, &ry);
+                base_type::adjust_scale(&rx, &ry);
+
+                rx_inv = image_subpixel_scale * image_subpixel_scale / rx;
+                ry_inv = image_subpixel_scale * image_subpixel_scale / ry;
+
+                int radius_x = (diameter * rx) >> 1;
+                int radius_y = (diameter * ry) >> 1;
+                int len_x_lr = 
+                    (diameter * rx + image_subpixel_mask) >> 
+                        image_subpixel_shift;
+
+                x += base_type::filter_dx_int() - radius_x;
+                y += base_type::filter_dy_int() - radius_y;
+
+                fg = 0;
+
+                int y_lr = y >> image_subpixel_shift;
+                int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) * 
+                               ry_inv) >> 
+                                   image_subpixel_shift;
+                int total_weight = 0;
+                int x_lr = x >> image_subpixel_shift;
+                int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) * 
+                               rx_inv) >> 
+                                   image_subpixel_shift;
+                int x_hr2 = x_hr;
+                const value_type* fg_ptr = 
+                    (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
+
+                for(;;)
+                {
+                    int weight_y = weight_array[y_hr];
+                    x_hr = x_hr2;
+                    for(;;)
+                    {
+                        int weight = (weight_y * weight_array[x_hr] + 
+                                     image_filter_scale / 2) >> 
+                                     downscale_shift;
+                        fg += *fg_ptr * weight;
+                        total_weight += weight;
+                        x_hr  += rx_inv;
+                        if(x_hr >= filter_scale) break;
+                        fg_ptr = (const value_type*)base_type::source().next_x();
+                    }
+                    y_hr += ry_inv;
+                    if(y_hr >= filter_scale) break;
+                    fg_ptr = (const value_type*)base_type::source().next_y();
+                }
+
+                fg /= total_weight;
+                if(fg < 0) fg = 0;
+                if(fg > color_type::full_value()) fg = color_type::full_value();
+
+                span->v = (value_type)fg;
+                span->a = color_type::full_value();
+
+                ++span;
+                ++base_type::interpolator();
+            } while(--len);
+        }
+    };
+
+
+}
+
+
+#endif
+
+
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_image_filter_rgba.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_image_filter_rgba.h
new file mode 100644
index 0000000000..af7a1a2ef0
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_image_filter_rgba.h
@@ -0,0 +1,890 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Adaptation for high precision colors has been sponsored by 
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+// 
+//----------------------------------------------------------------------------
+#ifndef AGG_SPAN_IMAGE_FILTER_RGBA_INCLUDED
+#define AGG_SPAN_IMAGE_FILTER_RGBA_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_color_rgba.h"
+#include "agg_span_image_filter.h"
+
+
+namespace agg
+{
+
+    //==============================================span_image_filter_rgba_nn
+    template<class Source, class Interpolator> 
+    class span_image_filter_rgba_nn : 
+    public span_image_filter<Source, Interpolator>
+    {
+    public:
+        typedef Source source_type;
+        typedef typename source_type::color_type color_type;
+        typedef typename source_type::order_type order_type;
+        typedef Interpolator interpolator_type;
+        typedef span_image_filter<source_type, interpolator_type> base_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        //--------------------------------------------------------------------
+        span_image_filter_rgba_nn() {}
+        span_image_filter_rgba_nn(source_type& src, 
+                                  interpolator_type& inter) :
+            base_type(src, inter, 0) 
+        {}
+
+        //--------------------------------------------------------------------
+        void generate(color_type* span, int x, int y, unsigned len)
+        {
+            base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 
+                                            y + base_type::filter_dy_dbl(), len);
+            do
+            {
+                base_type::interpolator().coordinates(&x, &y);
+                const value_type* fg_ptr = (const value_type*)
+                    base_type::source().span(x >> image_subpixel_shift, 
+                                             y >> image_subpixel_shift, 
+                                             1);
+                span->r = fg_ptr[order_type::R];
+                span->g = fg_ptr[order_type::G];
+                span->b = fg_ptr[order_type::B];
+                span->a = fg_ptr[order_type::A];
+                ++span;
+                ++base_type::interpolator();
+
+            } while(--len);
+        }
+    };
+
+
+
+    //=========================================span_image_filter_rgba_bilinear
+    template<class Source, class Interpolator> 
+    class span_image_filter_rgba_bilinear : 
+        public span_image_filter<Source, Interpolator>
+    {
+    public:
+        typedef Source source_type;
+        typedef typename source_type::color_type color_type;
+        typedef typename source_type::order_type order_type;
+        typedef Interpolator interpolator_type;
+        typedef span_image_filter<source_type, interpolator_type> base_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        //--------------------------------------------------------------------
+        span_image_filter_rgba_bilinear() {}
+        span_image_filter_rgba_bilinear(source_type& src, 
+                                        interpolator_type& inter) :
+            base_type(src, inter, 0) 
+        {}
+
+
+        //--------------------------------------------------------------------
+        void generate(color_type* span, int x, int y, unsigned len)
+        {
+            base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 
+                                            y + base_type::filter_dy_dbl(), len);
+
+            long_type fg[4];
+            const value_type *fg_ptr;
+
+            do
+            {
+                int x_hr;
+                int y_hr;
+
+                base_type::interpolator().coordinates(&x_hr, &y_hr);
+
+                x_hr -= base_type::filter_dx_int();
+                y_hr -= base_type::filter_dy_int();
+
+                int x_lr = x_hr >> image_subpixel_shift;
+                int y_lr = y_hr >> image_subpixel_shift;
+
+                unsigned weight;
+
+                fg[0] = 
+                fg[1] = 
+                fg[2] = 
+                fg[3] = image_subpixel_scale * image_subpixel_scale / 2;
+
+                x_hr &= image_subpixel_mask;
+                y_hr &= image_subpixel_mask;
+
+                fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, 2);
+                weight = (image_subpixel_scale - x_hr) * 
+                         (image_subpixel_scale - y_hr);
+                fg[0] += weight * *fg_ptr++;
+                fg[1] += weight * *fg_ptr++;
+                fg[2] += weight * *fg_ptr++;
+                fg[3] += weight * *fg_ptr;
+
+                fg_ptr = (const value_type*)base_type::source().next_x();
+                weight = x_hr * (image_subpixel_scale - y_hr);
+                fg[0] += weight * *fg_ptr++;
+                fg[1] += weight * *fg_ptr++;
+                fg[2] += weight * *fg_ptr++;
+                fg[3] += weight * *fg_ptr;
+
+                fg_ptr = (const value_type*)base_type::source().next_y();
+                weight = (image_subpixel_scale - x_hr) * y_hr;
+                fg[0] += weight * *fg_ptr++;
+                fg[1] += weight * *fg_ptr++;
+                fg[2] += weight * *fg_ptr++;
+                fg[3] += weight * *fg_ptr;
+
+                fg_ptr = (const value_type*)base_type::source().next_x();
+                weight = x_hr * y_hr;
+                fg[0] += weight * *fg_ptr++;
+                fg[1] += weight * *fg_ptr++;
+                fg[2] += weight * *fg_ptr++;
+                fg[3] += weight * *fg_ptr;
+
+                span->r = value_type(color_type::downshift(fg[order_type::R], image_subpixel_shift * 2));
+                span->g = value_type(color_type::downshift(fg[order_type::G], image_subpixel_shift * 2));
+                span->b = value_type(color_type::downshift(fg[order_type::B], image_subpixel_shift * 2));
+                span->a = value_type(color_type::downshift(fg[order_type::A], image_subpixel_shift * 2));
+
+                ++span;
+                ++base_type::interpolator();
+
+            } while(--len);
+        }
+    };
+
+
+    //====================================span_image_filter_rgba_bilinear_clip
+    template<class Source, class Interpolator> 
+    class span_image_filter_rgba_bilinear_clip : 
+    public span_image_filter<Source, Interpolator>
+    {
+    public:
+        typedef Source source_type;
+        typedef typename source_type::color_type color_type;
+        typedef typename source_type::order_type order_type;
+        typedef Interpolator interpolator_type;
+        typedef span_image_filter<source_type, interpolator_type> base_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        //--------------------------------------------------------------------
+        span_image_filter_rgba_bilinear_clip() {}
+        span_image_filter_rgba_bilinear_clip(source_type& src, 
+                                             const color_type& back_color,
+                                             interpolator_type& inter) :
+            base_type(src, inter, 0),
+            m_back_color(back_color)
+        {}
+        const color_type& background_color() const { return m_back_color; }
+        void background_color(const color_type& v)   { m_back_color = v; }
+
+
+        //--------------------------------------------------------------------
+        void generate(color_type* span, int x, int y, unsigned len)
+        {
+            base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 
+                                            y + base_type::filter_dy_dbl(), len);
+
+            long_type fg[4];
+            value_type back_r = m_back_color.r;
+            value_type back_g = m_back_color.g;
+            value_type back_b = m_back_color.b;
+            value_type back_a = m_back_color.a;
+
+            const value_type *fg_ptr;
+            int maxx = base_type::source().width() - 1;
+            int maxy = base_type::source().height() - 1;
+
+            do
+            {
+                int x_hr;
+                int y_hr;
+
+                base_type::interpolator().coordinates(&x_hr, &y_hr);
+
+                x_hr -= base_type::filter_dx_int();
+                y_hr -= base_type::filter_dy_int();
+
+                int x_lr = x_hr >> image_subpixel_shift;
+                int y_lr = y_hr >> image_subpixel_shift;
+
+                unsigned weight;
+
+                if(x_lr >= 0    && y_lr >= 0 &&
+                   x_lr <  maxx && y_lr <  maxy) 
+                {
+                    fg[0] = fg[1] = fg[2] = fg[3] = 0;
+
+                    x_hr &= image_subpixel_mask;
+                    y_hr &= image_subpixel_mask;
+
+                    fg_ptr = (const value_type*)
+                        base_type::source().row_ptr(y_lr) + (x_lr << 2);
+
+                    weight = (image_subpixel_scale - x_hr) * 
+                             (image_subpixel_scale - y_hr);
+                    fg[0] += weight * *fg_ptr++;
+                    fg[1] += weight * *fg_ptr++;
+                    fg[2] += weight * *fg_ptr++;
+                    fg[3] += weight * *fg_ptr++;
+
+                    weight = x_hr * (image_subpixel_scale - y_hr);
+                    fg[0] += weight * *fg_ptr++;
+                    fg[1] += weight * *fg_ptr++;
+                    fg[2] += weight * *fg_ptr++;
+                    fg[3] += weight * *fg_ptr++;
+
+                    ++y_lr;
+                    fg_ptr = (const value_type*)
+                        base_type::source().row_ptr(y_lr) + (x_lr << 2);
+
+                    weight = (image_subpixel_scale - x_hr) * y_hr;
+                    fg[0] += weight * *fg_ptr++;
+                    fg[1] += weight * *fg_ptr++;
+                    fg[2] += weight * *fg_ptr++;
+                    fg[3] += weight * *fg_ptr++;
+
+                    weight = x_hr * y_hr;
+                    fg[0] += weight * *fg_ptr++;
+                    fg[1] += weight * *fg_ptr++;
+                    fg[2] += weight * *fg_ptr++;
+                    fg[3] += weight * *fg_ptr++;
+
+                    fg[0] = color_type::downshift(fg[0], image_subpixel_shift * 2);
+                    fg[1] = color_type::downshift(fg[1], image_subpixel_shift * 2);
+                    fg[2] = color_type::downshift(fg[2], image_subpixel_shift * 2);
+                    fg[3] = color_type::downshift(fg[3], image_subpixel_shift * 2);
+                }
+                else
+                {
+                    if(x_lr < -1   || y_lr < -1 ||
+                       x_lr > maxx || y_lr > maxy)
+                    {
+                        fg[order_type::R] = back_r;
+                        fg[order_type::G] = back_g;
+                        fg[order_type::B] = back_b;
+                        fg[order_type::A] = back_a;
+                    }
+                    else
+                    {
+                        fg[0] = fg[1] = fg[2] = fg[3] = 0;
+
+                        x_hr &= image_subpixel_mask;
+                        y_hr &= image_subpixel_mask;
+
+                        weight = (image_subpixel_scale - x_hr) * 
+                                 (image_subpixel_scale - y_hr);
+                        if(x_lr >= 0    && y_lr >= 0 &&
+                           x_lr <= maxx && y_lr <= maxy)
+                        {
+                            fg_ptr = (const value_type*)
+                                base_type::source().row_ptr(y_lr) + (x_lr << 2);
+
+                            fg[0] += weight * *fg_ptr++;
+                            fg[1] += weight * *fg_ptr++;
+                            fg[2] += weight * *fg_ptr++;
+                            fg[3] += weight * *fg_ptr++;
+                        }
+                        else
+                        {
+                            fg[order_type::R] += back_r * weight;
+                            fg[order_type::G] += back_g * weight;
+                            fg[order_type::B] += back_b * weight;
+                            fg[order_type::A] += back_a * weight;
+                        }
+
+                        x_lr++;
+
+                        weight = x_hr * (image_subpixel_scale - y_hr);
+                        if(x_lr >= 0    && y_lr >= 0 &&
+                           x_lr <= maxx && y_lr <= maxy)
+                        {
+                            fg_ptr = (const value_type*)
+                                base_type::source().row_ptr(y_lr) + (x_lr << 2);
+
+                            fg[0] += weight * *fg_ptr++;
+                            fg[1] += weight * *fg_ptr++;
+                            fg[2] += weight * *fg_ptr++;
+                            fg[3] += weight * *fg_ptr++;
+                        }
+                        else
+                        {
+                            fg[order_type::R] += back_r * weight;
+                            fg[order_type::G] += back_g * weight;
+                            fg[order_type::B] += back_b * weight;
+                            fg[order_type::A] += back_a * weight;
+                        }
+
+                        x_lr--;
+                        y_lr++;
+
+                        weight = (image_subpixel_scale - x_hr) * y_hr;
+                        if(x_lr >= 0    && y_lr >= 0 &&
+                           x_lr <= maxx && y_lr <= maxy)
+                        {
+                            fg_ptr = (const value_type*)
+                                base_type::source().row_ptr(y_lr) + (x_lr << 2);
+
+                            fg[0] += weight * *fg_ptr++;
+                            fg[1] += weight * *fg_ptr++;
+                            fg[2] += weight * *fg_ptr++;
+                            fg[3] += weight * *fg_ptr++;
+                        }
+                        else
+                        {
+                            fg[order_type::R] += back_r * weight;
+                            fg[order_type::G] += back_g * weight;
+                            fg[order_type::B] += back_b * weight;
+                            fg[order_type::A] += back_a * weight;
+                        }
+
+                        x_lr++;
+
+                        weight = x_hr * y_hr;
+                        if(x_lr >= 0    && y_lr >= 0 &&
+                           x_lr <= maxx && y_lr <= maxy)
+                        {
+                            fg_ptr = (const value_type*)
+                                base_type::source().row_ptr(y_lr) + (x_lr << 2);
+
+                            fg[0] += weight * *fg_ptr++;
+                            fg[1] += weight * *fg_ptr++;
+                            fg[2] += weight * *fg_ptr++;
+                            fg[3] += weight * *fg_ptr++;
+                        }
+                        else
+                        {
+                            fg[order_type::R] += back_r * weight;
+                            fg[order_type::G] += back_g * weight;
+                            fg[order_type::B] += back_b * weight;
+                            fg[order_type::A] += back_a * weight;
+                        }
+
+                        fg[0] = color_type::downshift(fg[0], image_subpixel_shift * 2);
+                        fg[1] = color_type::downshift(fg[1], image_subpixel_shift * 2);
+                        fg[2] = color_type::downshift(fg[2], image_subpixel_shift * 2);
+                        fg[3] = color_type::downshift(fg[3], image_subpixel_shift * 2);
+                    }
+                }
+
+                span->r = (value_type)fg[order_type::R];
+                span->g = (value_type)fg[order_type::G];
+                span->b = (value_type)fg[order_type::B];
+                span->a = (value_type)fg[order_type::A];
+                ++span;
+                ++base_type::interpolator();
+
+            } while(--len);
+        }
+    private:
+        color_type m_back_color;
+    };
+
+
+    //==============================================span_image_filter_rgba_2x2
+    template<class Source, class Interpolator> 
+    class span_image_filter_rgba_2x2 : 
+    public span_image_filter<Source, Interpolator>
+    {
+    public:
+        typedef Source source_type;
+        typedef typename source_type::color_type color_type;
+        typedef typename source_type::order_type order_type;
+        typedef Interpolator interpolator_type;
+        typedef span_image_filter<source_type, interpolator_type> base_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        //--------------------------------------------------------------------
+        span_image_filter_rgba_2x2() {}
+        span_image_filter_rgba_2x2(source_type& src, 
+                                   interpolator_type& inter,
+                                   image_filter_lut& filter) :
+            base_type(src, inter, &filter) 
+        {}
+
+
+        //--------------------------------------------------------------------
+        void generate(color_type* span, int x, int y, unsigned len)
+        {
+            base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 
+                                            y + base_type::filter_dy_dbl(), len);
+
+            long_type fg[4];
+
+            const value_type *fg_ptr;
+            const int16* weight_array = base_type::filter().weight_array() + 
+                                        ((base_type::filter().diameter()/2 - 1) << 
+                                          image_subpixel_shift);
+
+            do
+            {
+                int x_hr;
+                int y_hr;
+
+                base_type::interpolator().coordinates(&x_hr, &y_hr);
+
+                x_hr -= base_type::filter_dx_int();
+                y_hr -= base_type::filter_dy_int();
+
+                int x_lr = x_hr >> image_subpixel_shift;
+                int y_lr = y_hr >> image_subpixel_shift;
+
+                unsigned weight;
+                fg[0] = fg[1] = fg[2] = fg[3] = 0;
+
+                x_hr &= image_subpixel_mask;
+                y_hr &= image_subpixel_mask;
+
+                fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, 2);
+                weight = (weight_array[x_hr + image_subpixel_scale] * 
+                          weight_array[y_hr + image_subpixel_scale] + 
+                          image_filter_scale / 2) >> 
+                          image_filter_shift;
+                fg[0] += weight * *fg_ptr++;
+                fg[1] += weight * *fg_ptr++;
+                fg[2] += weight * *fg_ptr++;
+                fg[3] += weight * *fg_ptr;
+
+                fg_ptr = (const value_type*)base_type::source().next_x();
+                weight = (weight_array[x_hr] * 
+                          weight_array[y_hr + image_subpixel_scale] + 
+                          image_filter_scale / 2) >> 
+                          image_filter_shift;
+                fg[0] += weight * *fg_ptr++;
+                fg[1] += weight * *fg_ptr++;
+                fg[2] += weight * *fg_ptr++;
+                fg[3] += weight * *fg_ptr;
+
+                fg_ptr = (const value_type*)base_type::source().next_y();
+                weight = (weight_array[x_hr + image_subpixel_scale] * 
+                          weight_array[y_hr] + 
+                          image_filter_scale / 2) >> 
+                          image_filter_shift;
+                fg[0] += weight * *fg_ptr++;
+                fg[1] += weight * *fg_ptr++;
+                fg[2] += weight * *fg_ptr++;
+                fg[3] += weight * *fg_ptr;
+
+                fg_ptr = (const value_type*)base_type::source().next_x();
+                weight = (weight_array[x_hr] * 
+                          weight_array[y_hr] + 
+                          image_filter_scale / 2) >> 
+                          image_filter_shift;
+                fg[0] += weight * *fg_ptr++;
+                fg[1] += weight * *fg_ptr++;
+                fg[2] += weight * *fg_ptr++;
+                fg[3] += weight * *fg_ptr;
+
+                fg[0] = color_type::downshift(fg[0], image_filter_shift);
+                fg[1] = color_type::downshift(fg[1], image_filter_shift);
+                fg[2] = color_type::downshift(fg[2], image_filter_shift);
+                fg[3] = color_type::downshift(fg[3], image_filter_shift);
+
+                if(fg[order_type::A] > color_type::full_value()) fg[order_type::A] = color_type::full_value();
+                if(fg[order_type::R] > fg[order_type::A]) fg[order_type::R] = fg[order_type::A];
+                if(fg[order_type::G] > fg[order_type::A]) fg[order_type::G] = fg[order_type::A];
+                if(fg[order_type::B] > fg[order_type::A]) fg[order_type::B] = fg[order_type::A];
+
+                span->r = (value_type)fg[order_type::R];
+                span->g = (value_type)fg[order_type::G];
+                span->b = (value_type)fg[order_type::B];
+                span->a = (value_type)fg[order_type::A];
+                ++span;
+                ++base_type::interpolator();
+
+            } while(--len);
+        }
+    };
+
+
+
+    //==================================================span_image_filter_rgba
+    template<class Source, class Interpolator> 
+    class span_image_filter_rgba : 
+    public span_image_filter<Source, Interpolator>
+    {
+    public:
+        typedef Source source_type;
+        typedef typename source_type::color_type color_type;
+        typedef typename source_type::order_type order_type;
+        typedef Interpolator interpolator_type;
+        typedef span_image_filter<source_type, interpolator_type> base_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        //--------------------------------------------------------------------
+        span_image_filter_rgba() {}
+        span_image_filter_rgba(source_type& src, 
+                               interpolator_type& inter,
+                               image_filter_lut& filter) :
+            base_type(src, inter, &filter) 
+        {}
+
+        //--------------------------------------------------------------------
+        void generate(color_type* span, int x, int y, unsigned len)
+        {
+            base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 
+                                            y + base_type::filter_dy_dbl(), len);
+
+            long_type fg[4];
+            const value_type *fg_ptr;
+
+            unsigned     diameter     = base_type::filter().diameter();
+            int          start        = base_type::filter().start();
+            const int16* weight_array = base_type::filter().weight_array();
+
+            int x_count; 
+            int weight_y;
+
+            do
+            {
+                base_type::interpolator().coordinates(&x, &y);
+
+                x -= base_type::filter_dx_int();
+                y -= base_type::filter_dy_int();
+
+                int x_hr = x; 
+                int y_hr = y; 
+
+                int x_lr = x_hr >> image_subpixel_shift;
+                int y_lr = y_hr >> image_subpixel_shift;
+
+                fg[0] = fg[1] = fg[2] = fg[3] = 0;
+
+                int x_fract = x_hr & image_subpixel_mask;
+                unsigned y_count = diameter;
+
+                y_hr = image_subpixel_mask - (y_hr & image_subpixel_mask);
+                fg_ptr = (const value_type*)base_type::source().span(x_lr + start, 
+                                                                     y_lr + start, 
+                                                                     diameter);
+                for(;;)
+                {
+                    x_count  = diameter;
+                    weight_y = weight_array[y_hr];
+                    x_hr = image_subpixel_mask - x_fract;
+                    for(;;)
+                    {
+                        int weight = (weight_y * weight_array[x_hr] + 
+                                     image_filter_scale / 2) >> 
+                                     image_filter_shift;
+
+                        fg[0] += weight * *fg_ptr++;
+                        fg[1] += weight * *fg_ptr++;
+                        fg[2] += weight * *fg_ptr++;
+                        fg[3] += weight * *fg_ptr;
+
+                        if(--x_count == 0) break;
+                        x_hr  += image_subpixel_scale;
+                        fg_ptr = (const value_type*)base_type::source().next_x();
+                    }
+
+                    if(--y_count == 0) break;
+                    y_hr  += image_subpixel_scale;
+                    fg_ptr = (const value_type*)base_type::source().next_y();
+                }
+
+                fg[0] = color_type::downshift(fg[0], image_filter_shift);
+                fg[1] = color_type::downshift(fg[1], image_filter_shift);
+                fg[2] = color_type::downshift(fg[2], image_filter_shift);
+                fg[3] = color_type::downshift(fg[3], image_filter_shift);
+
+                if(fg[0] < 0) fg[0] = 0;
+                if(fg[1] < 0) fg[1] = 0;
+                if(fg[2] < 0) fg[2] = 0;
+                if(fg[3] < 0) fg[3] = 0;
+
+                if(fg[order_type::A] > color_type::full_value()) fg[order_type::A] = color_type::full_value();
+                if(fg[order_type::R] > fg[order_type::A]) fg[order_type::R] = fg[order_type::A];
+                if(fg[order_type::G] > fg[order_type::A]) fg[order_type::G] = fg[order_type::A];
+                if(fg[order_type::B] > fg[order_type::A]) fg[order_type::B] = fg[order_type::A];
+
+                span->r = (value_type)fg[order_type::R];
+                span->g = (value_type)fg[order_type::G];
+                span->b = (value_type)fg[order_type::B];
+                span->a = (value_type)fg[order_type::A];
+                ++span;
+                ++base_type::interpolator();
+
+            } while(--len);
+        }
+    };
+
+
+
+    //========================================span_image_resample_rgba_affine
+    template<class Source> 
+    class span_image_resample_rgba_affine : 
+    public span_image_resample_affine<Source>
+    {
+    public:
+        typedef Source source_type;
+        typedef typename source_type::color_type color_type;
+        typedef typename source_type::order_type order_type;
+        typedef span_image_resample_affine<source_type> base_type;
+        typedef typename base_type::interpolator_type interpolator_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::long_type long_type;
+        enum base_scale_e
+        {
+            downscale_shift = image_filter_shift
+        };
+
+        //--------------------------------------------------------------------
+        span_image_resample_rgba_affine() {}
+        span_image_resample_rgba_affine(source_type& src, 
+                                        interpolator_type& inter,
+                                        image_filter_lut& filter) :
+            base_type(src, inter, filter) 
+        {}
+
+
+        //--------------------------------------------------------------------
+        void generate(color_type* span, int x, int y, unsigned len)
+        {
+            base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 
+                                            y + base_type::filter_dy_dbl(), len);
+
+            long_type fg[4];
+
+            int diameter     = base_type::filter().diameter();
+            int filter_scale = diameter << image_subpixel_shift;
+            int radius_x     = (diameter * base_type::m_rx) >> 1;
+            int radius_y     = (diameter * base_type::m_ry) >> 1;
+            int len_x_lr     = 
+                (diameter * base_type::m_rx + image_subpixel_mask) >> 
+                    image_subpixel_shift;
+
+            const int16* weight_array = base_type::filter().weight_array();
+
+            do
+            {
+                base_type::interpolator().coordinates(&x, &y);
+
+                x += base_type::filter_dx_int() - radius_x;
+                y += base_type::filter_dy_int() - radius_y;
+
+                fg[0] = fg[1] = fg[2] = fg[3] = 0;
+
+                int y_lr = y >> image_subpixel_shift;
+                int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) * 
+                                base_type::m_ry_inv) >> 
+                                    image_subpixel_shift;
+                int total_weight = 0;
+                int x_lr = x >> image_subpixel_shift;
+                int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) * 
+                                base_type::m_rx_inv) >> 
+                                    image_subpixel_shift;
+
+                int x_hr2 = x_hr;
+                const value_type* fg_ptr = 
+                    (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
+                for(;;)
+                {
+                    int weight_y = weight_array[y_hr];
+                    x_hr = x_hr2;
+                    for(;;)
+                    {
+                        int weight = (weight_y * weight_array[x_hr] + 
+                                     image_filter_scale / 2) >> 
+                                     downscale_shift;
+
+                        fg[0] += *fg_ptr++ * weight;
+                        fg[1] += *fg_ptr++ * weight;
+                        fg[2] += *fg_ptr++ * weight;
+                        fg[3] += *fg_ptr++ * weight;
+                        total_weight += weight;
+                        x_hr  += base_type::m_rx_inv;
+                        if(x_hr >= filter_scale) break;
+                        fg_ptr = (const value_type*)base_type::source().next_x();
+                    }
+                    y_hr += base_type::m_ry_inv;
+                    if(y_hr >= filter_scale) break;
+                    fg_ptr = (const value_type*)base_type::source().next_y();
+                }
+
+                fg[0] /= total_weight;
+                fg[1] /= total_weight;
+                fg[2] /= total_weight;
+                fg[3] /= total_weight;
+
+                if(fg[0] < 0) fg[0] = 0;
+                if(fg[1] < 0) fg[1] = 0;
+                if(fg[2] < 0) fg[2] = 0;
+                if(fg[3] < 0) fg[3] = 0;
+
+                if(fg[order_type::A] > color_type::full_value()) fg[order_type::A] = color_type::full_value();
+                if(fg[order_type::R] > fg[order_type::A]) fg[order_type::R] = fg[order_type::A];
+                if(fg[order_type::G] > fg[order_type::A]) fg[order_type::G] = fg[order_type::A];
+                if(fg[order_type::B] > fg[order_type::A]) fg[order_type::B] = fg[order_type::A];
+
+                span->r = (value_type)fg[order_type::R];
+                span->g = (value_type)fg[order_type::G];
+                span->b = (value_type)fg[order_type::B];
+                span->a = (value_type)fg[order_type::A];
+
+                ++span;
+                ++base_type::interpolator();
+            } while(--len);
+        }
+    };
+
+
+
+    //==============================================span_image_resample_rgba
+    template<class Source, class Interpolator>
+    class span_image_resample_rgba : 
+    public span_image_resample<Source, Interpolator>
+    {
+    public:
+        typedef Source source_type;
+        typedef typename source_type::color_type color_type;
+        typedef typename source_type::order_type order_type;
+        typedef Interpolator interpolator_type;
+        typedef span_image_resample<source_type, interpolator_type> base_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::long_type long_type;
+        enum base_scale_e
+        {
+            downscale_shift = image_filter_shift
+        };
+
+        //--------------------------------------------------------------------
+        span_image_resample_rgba() {}
+        span_image_resample_rgba(source_type& src, 
+                                 interpolator_type& inter,
+                                 image_filter_lut& filter) :
+            base_type(src, inter, filter)
+        {}
+
+        //--------------------------------------------------------------------
+        void generate(color_type* span, int x, int y, unsigned len)
+        {
+            base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 
+                                            y + base_type::filter_dy_dbl(), len);
+            long_type fg[4];
+
+            int diameter = base_type::filter().diameter();
+            int filter_scale = diameter << image_subpixel_shift;
+
+            const int16* weight_array = base_type::filter().weight_array();
+            do
+            {
+                int rx;
+                int ry;
+                int rx_inv = image_subpixel_scale;
+                int ry_inv = image_subpixel_scale;
+                base_type::interpolator().coordinates(&x,  &y);
+                base_type::interpolator().local_scale(&rx, &ry);
+                base_type::adjust_scale(&rx, &ry);
+
+                rx_inv = image_subpixel_scale * image_subpixel_scale / rx;
+                ry_inv = image_subpixel_scale * image_subpixel_scale / ry;
+
+                int radius_x = (diameter * rx) >> 1;
+                int radius_y = (diameter * ry) >> 1;
+                int len_x_lr = 
+                    (diameter * rx + image_subpixel_mask) >> 
+                        image_subpixel_shift;
+
+                x += base_type::filter_dx_int() - radius_x;
+                y += base_type::filter_dy_int() - radius_y;
+
+                fg[0] = fg[1] = fg[2] = fg[3] = 0;
+
+                int y_lr = y >> image_subpixel_shift;
+                int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) * 
+                               ry_inv) >> 
+                                   image_subpixel_shift;
+                int total_weight = 0;
+                int x_lr = x >> image_subpixel_shift;
+                int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) * 
+                               rx_inv) >> 
+                                   image_subpixel_shift;
+                int x_hr2 = x_hr;
+                const value_type* fg_ptr = 
+                    (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
+
+                for(;;)
+                {
+                    int weight_y = weight_array[y_hr];
+                    x_hr = x_hr2;
+                    for(;;)
+                    {
+                        int weight = (weight_y * weight_array[x_hr] + 
+                                     image_filter_scale / 2) >> 
+                                     downscale_shift;
+                        fg[0] += *fg_ptr++ * weight;
+                        fg[1] += *fg_ptr++ * weight;
+                        fg[2] += *fg_ptr++ * weight;
+                        fg[3] += *fg_ptr++ * weight;
+                        total_weight += weight;
+                        x_hr  += rx_inv;
+                        if(x_hr >= filter_scale) break;
+                        fg_ptr = (const value_type*)base_type::source().next_x();
+                    }
+                    y_hr += ry_inv;
+                    if(y_hr >= filter_scale) break;
+                    fg_ptr = (const value_type*)base_type::source().next_y();
+                }
+
+                fg[0] /= total_weight;
+                fg[1] /= total_weight;
+                fg[2] /= total_weight;
+                fg[3] /= total_weight;
+
+                if(fg[0] < 0) fg[0] = 0;
+                if(fg[1] < 0) fg[1] = 0;
+                if(fg[2] < 0) fg[2] = 0;
+                if(fg[3] < 0) fg[3] = 0;
+
+                if(fg[order_type::A] > color_type::full_value()) fg[order_type::A] = color_type::full_value();
+                if(fg[order_type::R] > fg[order_type::R]) fg[order_type::R] = fg[order_type::R];
+                if(fg[order_type::G] > fg[order_type::G]) fg[order_type::G] = fg[order_type::G];
+                if(fg[order_type::B] > fg[order_type::B]) fg[order_type::B] = fg[order_type::B];
+
+                span->r = (value_type)fg[order_type::R];
+                span->g = (value_type)fg[order_type::G];
+                span->b = (value_type)fg[order_type::B];
+                span->a = (value_type)fg[order_type::A];
+
+                ++span;
+                ++base_type::interpolator();
+            } while(--len);
+        }
+    };
+
+
+}
+
+
+#endif
+
+
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_interpolator_adaptor.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_interpolator_adaptor.h
new file mode 100644
index 0000000000..0fdfa77479
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_interpolator_adaptor.h
@@ -0,0 +1,77 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_SPAN_INTERPOLATOR_ADAPTOR_INCLUDED
+#define AGG_SPAN_INTERPOLATOR_ADAPTOR_INCLUDED
+
+#include "agg_basics.h"
+
+namespace agg
+{
+
+    //===============================================span_interpolator_adaptor
+    template<class Interpolator, class Distortion>
+    class span_interpolator_adaptor : public Interpolator
+    {
+    public:
+        typedef Interpolator base_type;
+        typedef typename base_type::trans_type trans_type;
+        typedef Distortion distortion_type;
+
+        //--------------------------------------------------------------------
+        span_interpolator_adaptor() {}
+        span_interpolator_adaptor(trans_type& trans, 
+                                  distortion_type& dist) :
+            base_type(trans),
+            m_distortion(&dist)
+        {   
+        }
+
+        //--------------------------------------------------------------------
+        span_interpolator_adaptor(trans_type& trans,
+                                  distortion_type& dist,
+                                  double x, double y, unsigned len) :
+            base_type(trans, x, y, len),
+            m_distortion(&dist)
+        {
+        }
+
+        //--------------------------------------------------------------------
+        distortion_type& distortion() const
+        {
+            return *m_distortion;
+        }
+
+        //--------------------------------------------------------------------
+        void distortion(distortion_type& dist)
+        {
+            m_distortion = dist;
+        }
+
+        //--------------------------------------------------------------------
+        void coordinates(int* x, int* y) const
+        {
+            base_type::coordinates(x, y);
+            m_distortion->calculate(x, y);
+        }
+
+    private:
+        //--------------------------------------------------------------------
+        distortion_type* m_distortion;
+    };
+}
+
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_interpolator_linear.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_interpolator_linear.h
new file mode 100644
index 0000000000..ef10505ce1
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_interpolator_linear.h
@@ -0,0 +1,232 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_SPAN_INTERPOLATOR_LINEAR_INCLUDED
+#define AGG_SPAN_INTERPOLATOR_LINEAR_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_dda_line.h"
+#include "agg_trans_affine.h"
+
+namespace agg
+{
+
+    //================================================span_interpolator_linear
+    template<class Transformer = trans_affine, unsigned SubpixelShift = 8> 
+    class span_interpolator_linear
+    {
+    public:
+        typedef Transformer trans_type;
+
+        enum subpixel_scale_e
+        {
+            subpixel_shift = SubpixelShift,
+            subpixel_scale  = 1 << subpixel_shift
+        };
+
+        //--------------------------------------------------------------------
+        span_interpolator_linear() {}
+        span_interpolator_linear(trans_type& trans) : m_trans(&trans) {}
+        span_interpolator_linear(trans_type& trans,
+                                 double x, double y, unsigned len) :
+            m_trans(&trans)
+        {
+            begin(x, y, len);
+        }
+
+        //----------------------------------------------------------------
+        const trans_type& transformer() const { return *m_trans; }
+        void transformer(trans_type& trans) { m_trans = &trans; }
+
+        //----------------------------------------------------------------
+        void begin(double x, double y, unsigned len)
+        {
+            double tx;
+            double ty;
+
+            tx = x;
+            ty = y;
+            m_trans->transform(&tx, &ty);
+            int x1 = iround(tx * subpixel_scale);
+            int y1 = iround(ty * subpixel_scale);
+
+            tx = x + len;
+            ty = y;
+            m_trans->transform(&tx, &ty);
+            int x2 = iround(tx * subpixel_scale);
+            int y2 = iround(ty * subpixel_scale);
+
+            m_li_x = dda2_line_interpolator(x1, x2, len);
+            m_li_y = dda2_line_interpolator(y1, y2, len);
+        }
+
+        //----------------------------------------------------------------
+        void resynchronize(double xe, double ye, unsigned len)
+        {
+            m_trans->transform(&xe, &ye);
+            m_li_x = dda2_line_interpolator(m_li_x.y(), iround(xe * subpixel_scale), len);
+            m_li_y = dda2_line_interpolator(m_li_y.y(), iround(ye * subpixel_scale), len);
+        }
+    
+        //----------------------------------------------------------------
+        void operator++()
+        {
+            ++m_li_x;
+            ++m_li_y;
+        }
+
+        //----------------------------------------------------------------
+        void coordinates(int* x, int* y) const
+        {
+            *x = m_li_x.y();
+            *y = m_li_y.y();
+        }
+
+    private:
+        trans_type* m_trans;
+        dda2_line_interpolator m_li_x;
+        dda2_line_interpolator m_li_y;
+    };
+
+
+
+
+
+
+    //=====================================span_interpolator_linear_subdiv
+    template<class Transformer = trans_affine, unsigned SubpixelShift = 8> 
+    class span_interpolator_linear_subdiv
+    {
+    public:
+        typedef Transformer trans_type;
+
+        enum subpixel_scale_e
+        {
+            subpixel_shift = SubpixelShift,
+            subpixel_scale = 1 << subpixel_shift
+        };
+
+
+        //----------------------------------------------------------------
+        span_interpolator_linear_subdiv() :
+            m_subdiv_shift(4),
+            m_subdiv_size(1 << m_subdiv_shift),
+            m_subdiv_mask(m_subdiv_size - 1) {}
+
+        span_interpolator_linear_subdiv(trans_type& trans, 
+                                        unsigned subdiv_shift = 4) : 
+            m_subdiv_shift(subdiv_shift),
+            m_subdiv_size(1 << m_subdiv_shift),
+            m_subdiv_mask(m_subdiv_size - 1),
+            m_trans(&trans) {}
+
+        span_interpolator_linear_subdiv(trans_type& trans,
+                                        double x, double y, unsigned len,
+                                        unsigned subdiv_shift = 4) :
+            m_subdiv_shift(subdiv_shift),
+            m_subdiv_size(1 << m_subdiv_shift),
+            m_subdiv_mask(m_subdiv_size - 1),
+            m_trans(&trans)
+        {
+            begin(x, y, len);
+        }
+
+        //----------------------------------------------------------------
+        const trans_type& transformer() const { return *m_trans; }
+        void transformer(const trans_type& trans) { m_trans = &trans; }
+
+        //----------------------------------------------------------------
+        unsigned subdiv_shift() const { return m_subdiv_shift; }
+        void subdiv_shift(unsigned shift) 
+        {
+            m_subdiv_shift = shift;
+            m_subdiv_size = 1 << m_subdiv_shift;
+            m_subdiv_mask = m_subdiv_size - 1;
+        }
+
+        //----------------------------------------------------------------
+        void begin(double x, double y, unsigned len)
+        {
+            double tx;
+            double ty;
+            m_pos   = 1;
+            m_src_x = iround(x * subpixel_scale) + subpixel_scale;
+            m_src_y = y;
+            m_len   = len;
+
+            if(len > m_subdiv_size) len = m_subdiv_size;
+            tx = x;
+            ty = y;
+            m_trans->transform(&tx, &ty);
+            int x1 = iround(tx * subpixel_scale);
+            int y1 = iround(ty * subpixel_scale);
+
+            tx = x + len;
+            ty = y;
+            m_trans->transform(&tx, &ty);
+
+            m_li_x = dda2_line_interpolator(x1, iround(tx * subpixel_scale), len);
+            m_li_y = dda2_line_interpolator(y1, iround(ty * subpixel_scale), len);
+        }
+
+        //----------------------------------------------------------------
+        void operator++()
+        {
+            ++m_li_x;
+            ++m_li_y;
+            if(m_pos >= m_subdiv_size)
+            {
+                unsigned len = m_len;
+                if(len > m_subdiv_size) len = m_subdiv_size;
+                double tx = double(m_src_x) / double(subpixel_scale) + len;
+                double ty = m_src_y;
+                m_trans->transform(&tx, &ty);
+                m_li_x = dda2_line_interpolator(m_li_x.y(), iround(tx * subpixel_scale), len);
+                m_li_y = dda2_line_interpolator(m_li_y.y(), iround(ty * subpixel_scale), len);
+                m_pos = 0;
+            }
+            m_src_x += subpixel_scale;
+            ++m_pos;
+            --m_len;
+        }
+
+        //----------------------------------------------------------------
+        void coordinates(int* x, int* y) const
+        {
+            *x = m_li_x.y();
+            *y = m_li_y.y();
+        }
+
+    private:
+        unsigned m_subdiv_shift;
+        unsigned m_subdiv_size;
+        unsigned m_subdiv_mask;
+        trans_type* m_trans;
+        dda2_line_interpolator m_li_x;
+        dda2_line_interpolator m_li_y;
+        int      m_src_x;
+        double   m_src_y;
+        unsigned m_pos;
+        unsigned m_len;
+    };
+
+
+}
+
+
+
+#endif
+
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_pattern_rgba.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_pattern_rgba.h
new file mode 100644
index 0000000000..d47d2a6c02
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_span_pattern_rgba.h
@@ -0,0 +1,94 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Adaptation for high precision colors has been sponsored by 
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+// 
+//----------------------------------------------------------------------------
+
+
+#ifndef AGG_SPAN_PATTERN_RGBA_INCLUDED
+#define AGG_SPAN_PATTERN_RGBA_INCLUDED
+
+#include "agg_basics.h"
+
+namespace agg
+{
+
+    //======================================================span_pattern_rgba
+    template<class Source> class span_pattern_rgba
+    {
+    public:
+        typedef Source source_type;
+        typedef typename source_type::color_type color_type;
+        typedef typename source_type::order_type order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+
+        //--------------------------------------------------------------------
+        span_pattern_rgba() {}
+        span_pattern_rgba(source_type& src, 
+                          unsigned offset_x, unsigned offset_y) :
+            m_src(&src),
+            m_offset_x(offset_x),
+            m_offset_y(offset_y)
+        {}
+
+        //--------------------------------------------------------------------
+        void   attach(source_type& v)      { m_src = &v; }
+               source_type& source()       { return *m_src; }
+        const  source_type& source() const { return *m_src; }
+
+        //--------------------------------------------------------------------
+        void       offset_x(unsigned v) { m_offset_x = v; }
+        void       offset_y(unsigned v) { m_offset_y = v; }
+        unsigned   offset_x() const { return m_offset_x; }
+        unsigned   offset_y() const { return m_offset_y; }
+        void       alpha(value_type) {}
+        value_type alpha() const { return 0; }
+
+        //--------------------------------------------------------------------
+        void prepare() {}
+        void generate(color_type* span, int x, int y, unsigned len)
+        {   
+            x += m_offset_x;
+            y += m_offset_y;
+            const value_type* p = (const value_type*)m_src->span(x, y, len);
+            do
+            {
+                span->r = p[order_type::R];
+                span->g = p[order_type::G];
+                span->b = p[order_type::B];
+                span->a = p[order_type::A];
+                p = (const value_type*)m_src->next_x();
+                ++span;
+            }
+            while(--len);
+        }
+
+    private:
+        source_type* m_src;
+        unsigned     m_offset_x;
+        unsigned     m_offset_y;
+
+    };
+
+}
+
+#endif
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_trans_affine.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_trans_affine.h
new file mode 100644
index 0000000000..1a61163883
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_trans_affine.h
@@ -0,0 +1,518 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Affine transformation classes.
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_TRANS_AFFINE_INCLUDED
+#define AGG_TRANS_AFFINE_INCLUDED
+
+#include <math.h>
+#include "agg_basics.h"
+
+namespace agg
+{
+    const double affine_epsilon = 1e-14; 
+
+    //============================================================trans_affine
+    //
+    // See Implementation agg_trans_affine.cpp
+    //
+    // Affine transformation are linear transformations in Cartesian coordinates
+    // (strictly speaking not only in Cartesian, but for the beginning we will 
+    // think so). They are rotation, scaling, translation and skewing.  
+    // After any affine transformation a line segment remains a line segment 
+    // and it will never become a curve. 
+    //
+    // There will be no math about matrix calculations, since it has been 
+    // described many times. Ask yourself a very simple question:
+    // "why do we need to understand and use some matrix stuff instead of just 
+    // rotating, scaling and so on". The answers are:
+    //
+    // 1. Any combination of transformations can be done by only 4 multiplications
+    //    and 4 additions in floating point.
+    // 2. One matrix transformation is equivalent to the number of consecutive
+    //    discrete transformations, i.e. the matrix "accumulates" all transformations 
+    //    in the order of their settings. Suppose we have 4 transformations: 
+    //       * rotate by 30 degrees,
+    //       * scale X to 2.0, 
+    //       * scale Y to 1.5, 
+    //       * move to (100, 100). 
+    //    The result will depend on the order of these transformations, 
+    //    and the advantage of matrix is that the sequence of discret calls:
+    //    rotate(30), scaleX(2.0), scaleY(1.5), move(100,100) 
+    //    will have exactly the same result as the following matrix transformations:
+    //   
+    //    affine_matrix m;
+    //    m *= rotate_matrix(30); 
+    //    m *= scaleX_matrix(2.0);
+    //    m *= scaleY_matrix(1.5);
+    //    m *= move_matrix(100,100);
+    //
+    //    m.transform_my_point_at_last(x, y);
+    //
+    // What is the good of it? In real life we will set-up the matrix only once
+    // and then transform many points, let alone the convenience to set any 
+    // combination of transformations.
+    //
+    // So, how to use it? Very easy - literally as it's shown above. Not quite,
+    // let us write a correct example:
+    //
+    // agg::trans_affine m;
+    // m *= agg::trans_affine_rotation(30.0 * 3.1415926 / 180.0);
+    // m *= agg::trans_affine_scaling(2.0, 1.5);
+    // m *= agg::trans_affine_translation(100.0, 100.0);
+    // m.transform(&x, &y);
+    //
+    // The affine matrix is all you need to perform any linear transformation,
+    // but all transformations have origin point (0,0). It means that we need to 
+    // use 2 translations if we want to rotate someting around (100,100):
+    // 
+    // m *= agg::trans_affine_translation(-100.0, -100.0);         // move to (0,0)
+    // m *= agg::trans_affine_rotation(30.0 * 3.1415926 / 180.0);  // rotate
+    // m *= agg::trans_affine_translation(100.0, 100.0);           // move back to (100,100)
+    //----------------------------------------------------------------------
+    struct trans_affine
+    {
+        double sx, shy, shx, sy, tx, ty;
+
+        //------------------------------------------ Construction
+        // Identity matrix
+        trans_affine() :
+            sx(1.0), shy(0.0), shx(0.0), sy(1.0), tx(0.0), ty(0.0)
+        {}
+
+        // Custom matrix. Usually used in derived classes
+        trans_affine(double v0, double v1, double v2, 
+                     double v3, double v4, double v5) :
+            sx(v0), shy(v1), shx(v2), sy(v3), tx(v4), ty(v5)
+        {}
+
+        // Custom matrix from m[6]
+        explicit trans_affine(const double* m) :
+            sx(m[0]), shy(m[1]), shx(m[2]), sy(m[3]), tx(m[4]), ty(m[5])
+        {}
+
+        // Rectangle to a parallelogram.
+        trans_affine(double x1, double y1, double x2, double y2, 
+                     const double* parl)
+        {
+            rect_to_parl(x1, y1, x2, y2, parl);
+        }
+
+        // Parallelogram to a rectangle.
+        trans_affine(const double* parl, 
+                     double x1, double y1, double x2, double y2)
+        {
+            parl_to_rect(parl, x1, y1, x2, y2);
+        }
+
+        // Arbitrary parallelogram transformation.
+        trans_affine(const double* src, const double* dst)
+        {
+            parl_to_parl(src, dst);
+        }
+
+        //---------------------------------- Parellelogram transformations
+        // transform a parallelogram to another one. Src and dst are 
+        // pointers to arrays of three points (double[6], x1,y1,...) that 
+        // identify three corners of the parallelograms assuming implicit 
+        // fourth point. The arguments are arrays of double[6] mapped 
+        // to x1,y1, x2,y2, x3,y3  where the coordinates are:
+        //        *-----------------*
+        //       /          (x3,y3)/
+        //      /                 /
+        //     /(x1,y1)   (x2,y2)/
+        //    *-----------------*
+        const trans_affine& parl_to_parl(const double* src, 
+                                         const double* dst);
+
+        const trans_affine& rect_to_parl(double x1, double y1, 
+                                         double x2, double y2, 
+                                         const double* parl);
+
+        const trans_affine& parl_to_rect(const double* parl, 
+                                         double x1, double y1, 
+                                         double x2, double y2);
+
+
+        //------------------------------------------ Operations
+        // Reset - load an identity matrix
+        const trans_affine& reset();
+
+        // Direct transformations operations
+        const trans_affine& translate(double x, double y);
+        const trans_affine& rotate(double a);
+        const trans_affine& scale(double s);
+        const trans_affine& scale(double x, double y);
+
+        // Multiply matrix to another one
+        const trans_affine& multiply(const trans_affine& m);
+
+        // Multiply "m" to "this" and assign the result to "this"
+        const trans_affine& premultiply(const trans_affine& m);
+
+        // Multiply matrix to inverse of another one
+        const trans_affine& multiply_inv(const trans_affine& m);
+
+        // Multiply inverse of "m" to "this" and assign the result to "this"
+        const trans_affine& premultiply_inv(const trans_affine& m);
+
+        // Invert matrix. Do not try to invert degenerate matrices, 
+        // there's no check for validity. If you set scale to 0 and 
+        // then try to invert matrix, expect unpredictable result.
+        const trans_affine& invert();
+
+        // Mirroring around X
+        const trans_affine& flip_x();
+
+        // Mirroring around Y
+        const trans_affine& flip_y();
+
+        //------------------------------------------- Load/Store
+        // Store matrix to an array [6] of double
+        void store_to(double* m) const
+        {
+            *m++ = sx; *m++ = shy; *m++ = shx; *m++ = sy; *m++ = tx; *m++ = ty;
+        }
+
+        // Load matrix from an array [6] of double
+        const trans_affine& load_from(const double* m)
+        {
+            sx = *m++; shy = *m++; shx = *m++; sy = *m++; tx = *m++;  ty = *m++;
+            return *this;
+        }
+
+        //------------------------------------------- Operators
+        
+        // Multiply the matrix by another one
+        const trans_affine& operator *= (const trans_affine& m)
+        {
+            return multiply(m);
+        }
+
+        // Multiply the matrix by inverse of another one
+        const trans_affine& operator /= (const trans_affine& m)
+        {
+            return multiply_inv(m);
+        }
+
+        // Multiply the matrix by another one and return
+        // the result in a separete matrix.
+        trans_affine operator * (const trans_affine& m) const
+        {
+            return trans_affine(*this).multiply(m);
+        }
+
+        // Multiply the matrix by inverse of another one 
+        // and return the result in a separete matrix.
+        trans_affine operator / (const trans_affine& m) const
+        {
+            return trans_affine(*this).multiply_inv(m);
+        }
+
+        // Calculate and return the inverse matrix
+        trans_affine operator ~ () const
+        {
+            trans_affine ret = *this;
+            return ret.invert();
+        }
+
+        // Equal operator with default epsilon
+        bool operator == (const trans_affine& m) const
+        {
+            return is_equal(m, affine_epsilon);
+        }
+
+        // Not Equal operator with default epsilon
+        bool operator != (const trans_affine& m) const
+        {
+            return !is_equal(m, affine_epsilon);
+        }
+
+        //-------------------------------------------- Transformations
+        // Direct transformation of x and y
+        void transform(double* x, double* y) const;
+
+        // Direct transformation of x and y, 2x2 matrix only, no translation
+        void transform_2x2(double* x, double* y) const;
+
+        // Inverse transformation of x and y. It works slower than the 
+        // direct transformation. For massive operations it's better to 
+        // invert() the matrix and then use direct transformations. 
+        void inverse_transform(double* x, double* y) const;
+
+        //-------------------------------------------- Auxiliary
+        // Calculate the determinant of matrix
+        double determinant() const
+        {
+            return sx * sy - shy * shx;
+        }
+
+        // Calculate the reciprocal of the determinant
+        double determinant_reciprocal() const
+        {
+            return 1.0 / (sx * sy - shy * shx);
+        }
+
+        // Get the average scale (by X and Y). 
+        // Basically used to calculate the approximation_scale when
+        // decomposinting curves into line segments.
+        double scale() const;
+
+        // Check to see if the matrix is not degenerate
+        bool is_valid(double epsilon = affine_epsilon) const;
+
+        // Check to see if it's an identity matrix
+        bool is_identity(double epsilon = affine_epsilon) const;
+
+        // Check to see if two matrices are equal
+        bool is_equal(const trans_affine& m, double epsilon = affine_epsilon) const;
+
+        // Determine the major parameters. Use with caution considering 
+        // possible degenerate cases.
+        double rotation() const;
+        void   translation(double* dx, double* dy) const;
+        void   scaling(double* x, double* y) const;
+        void   scaling_abs(double* x, double* y) const;
+    };
+
+    //------------------------------------------------------------------------
+    inline void trans_affine::transform(double* x, double* y) const
+    {
+        double tmp = *x;
+        *x = tmp * sx  + *y * shx + tx;
+        *y = tmp * shy + *y * sy  + ty;
+    }
+
+    //------------------------------------------------------------------------
+    inline void trans_affine::transform_2x2(double* x, double* y) const
+    {
+        double tmp = *x;
+        *x = tmp * sx  + *y * shx;
+        *y = tmp * shy + *y * sy;
+    }
+
+    //------------------------------------------------------------------------
+    inline void trans_affine::inverse_transform(double* x, double* y) const
+    {
+        double d = determinant_reciprocal();
+        double a = (*x - tx) * d;
+        double b = (*y - ty) * d;
+        *x = a * sy - b * shx;
+        *y = b * sx - a * shy;
+    }
+
+    //------------------------------------------------------------------------
+    inline double trans_affine::scale() const
+    {
+        double x = 0.707106781 * sx  + 0.707106781 * shx;
+        double y = 0.707106781 * shy + 0.707106781 * sy;
+        return sqrt(x*x + y*y);
+    }
+
+    //------------------------------------------------------------------------
+    inline const trans_affine& trans_affine::translate(double x, double y) 
+    { 
+        tx += x;
+        ty += y; 
+        return *this;
+    }
+
+    //------------------------------------------------------------------------
+    inline const trans_affine& trans_affine::rotate(double a) 
+    {
+        double ca = cos(a); 
+        double sa = sin(a);
+        double t0 = sx  * ca - shy * sa;
+        double t2 = shx * ca - sy * sa;
+        double t4 = tx  * ca - ty * sa;
+        shy = sx  * sa + shy * ca;
+        sy  = shx * sa + sy * ca; 
+        ty  = tx  * sa + ty * ca;
+        sx  = t0;
+        shx = t2;
+        tx  = t4;
+        return *this;
+    }
+
+    //------------------------------------------------------------------------
+    inline const trans_affine& trans_affine::scale(double x, double y) 
+    {
+        double mm0 = x; // Possible hint for the optimizer
+        double mm3 = y; 
+        sx  *= mm0;
+        shx *= mm0;
+        tx  *= mm0;
+        shy *= mm3;
+        sy  *= mm3;
+        ty  *= mm3;
+        return *this;
+    }
+
+    //------------------------------------------------------------------------
+    inline const trans_affine& trans_affine::scale(double s) 
+    {
+        double m = s; // Possible hint for the optimizer
+        sx  *= m;
+        shx *= m;
+        tx  *= m;
+        shy *= m;
+        sy  *= m;
+        ty  *= m;
+        return *this;
+    }
+
+    //------------------------------------------------------------------------
+    inline const trans_affine& trans_affine::premultiply(const trans_affine& m)
+    {
+        trans_affine t = m;
+        return *this = t.multiply(*this);
+    }
+
+    //------------------------------------------------------------------------
+    inline const trans_affine& trans_affine::multiply_inv(const trans_affine& m)
+    {
+        trans_affine t = m;
+        t.invert();
+        return multiply(t);
+    }
+
+    //------------------------------------------------------------------------
+    inline const trans_affine& trans_affine::premultiply_inv(const trans_affine& m)
+    {
+        trans_affine t = m;
+        t.invert();
+        return *this = t.multiply(*this);
+    }
+
+    //------------------------------------------------------------------------
+    inline void trans_affine::scaling_abs(double* x, double* y) const
+    {
+        // Used to calculate scaling coefficients in image resampling. 
+        // When there is considerable shear this method gives us much
+        // better estimation than just sx, sy.
+        *x = sqrt(sx  * sx  + shx * shx);
+        *y = sqrt(shy * shy + sy  * sy);
+    }
+
+    //====================================================trans_affine_rotation
+    // Rotation matrix. sin() and cos() are calculated twice for the same angle.
+    // There's no harm because the performance of sin()/cos() is very good on all
+    // modern processors. Besides, this operation is not going to be invoked too 
+    // often.
+    class trans_affine_rotation : public trans_affine
+    {
+    public:
+        trans_affine_rotation(double a) : 
+          trans_affine(cos(a), sin(a), -sin(a), cos(a), 0.0, 0.0)
+        {}
+    };
+
+    //====================================================trans_affine_scaling
+    // Scaling matrix. x, y - scale coefficients by X and Y respectively
+    class trans_affine_scaling : public trans_affine
+    {
+    public:
+        trans_affine_scaling(double x, double y) : 
+          trans_affine(x, 0.0, 0.0, y, 0.0, 0.0)
+        {}
+
+        trans_affine_scaling(double s) : 
+          trans_affine(s, 0.0, 0.0, s, 0.0, 0.0)
+        {}
+    };
+
+    //================================================trans_affine_translation
+    // Translation matrix
+    class trans_affine_translation : public trans_affine
+    {
+    public:
+        trans_affine_translation(double x, double y) : 
+          trans_affine(1.0, 0.0, 0.0, 1.0, x, y)
+        {}
+    };
+
+    //====================================================trans_affine_skewing
+    // Sckewing (shear) matrix
+    class trans_affine_skewing : public trans_affine
+    {
+    public:
+        trans_affine_skewing(double x, double y) : 
+          trans_affine(1.0, tan(y), tan(x), 1.0, 0.0, 0.0)
+        {}
+    };
+
+
+    //===============================================trans_affine_line_segment
+    // Rotate, Scale and Translate, associating 0...dist with line segment 
+    // x1,y1,x2,y2
+    class trans_affine_line_segment : public trans_affine
+    {
+    public:
+        trans_affine_line_segment(double x1, double y1, double x2, double y2, 
+                                  double dist)
+        {
+            double dx = x2 - x1;
+            double dy = y2 - y1;
+            if(dist > 0.0)
+            {
+                multiply(trans_affine_scaling(sqrt(dx * dx + dy * dy) / dist));
+            }
+            multiply(trans_affine_rotation(atan2(dy, dx)));
+            multiply(trans_affine_translation(x1, y1));
+        }
+    };
+
+
+    //============================================trans_affine_reflection_unit
+    // Reflection matrix. Reflect coordinates across the line through 
+    // the origin containing the unit vector (ux, uy).
+    // Contributed by John Horigan
+    class trans_affine_reflection_unit : public trans_affine
+    {
+    public:
+        trans_affine_reflection_unit(double ux, double uy) :
+          trans_affine(2.0 * ux * ux - 1.0, 
+                       2.0 * ux * uy, 
+                       2.0 * ux * uy, 
+                       2.0 * uy * uy - 1.0, 
+                       0.0, 0.0)
+        {}
+    };
+
+
+    //=================================================trans_affine_reflection
+    // Reflection matrix. Reflect coordinates across the line through 
+    // the origin at the angle a or containing the non-unit vector (x, y).
+    // Contributed by John Horigan
+    class trans_affine_reflection : public trans_affine_reflection_unit
+    {
+    public:
+        trans_affine_reflection(double a) :
+          trans_affine_reflection_unit(cos(a), sin(a))
+        {}
+
+
+        trans_affine_reflection(double x, double y) :
+          trans_affine_reflection_unit(x / sqrt(x * x + y * y), y / sqrt(x * x + y * y))
+        {}
+    };
+
+}
+
+
+#endif
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_vcgen_contour.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_vcgen_contour.h
new file mode 100644
index 0000000000..8c25da13f5
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_vcgen_contour.h
@@ -0,0 +1,94 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_VCGEN_CONTOUR_INCLUDED
+#define AGG_VCGEN_CONTOUR_INCLUDED
+
+#include "agg_math_stroke.h"
+
+namespace agg
+{
+
+    //----------------------------------------------------------vcgen_contour
+    //
+    // See Implementation agg_vcgen_contour.cpp
+    //
+    class vcgen_contour
+    {
+        enum status_e
+        {
+            initial,
+            ready,
+            outline,
+            out_vertices,
+            end_poly,
+            stop
+        };
+
+    public:
+        typedef vertex_sequence<vertex_dist, 6> vertex_storage;
+        typedef pod_bvector<point_d, 6>         coord_storage;
+
+        vcgen_contour();
+
+        void line_cap(line_cap_e lc)     { m_stroker.line_cap(lc); }
+        void line_join(line_join_e lj)   { m_stroker.line_join(lj); }
+        void inner_join(inner_join_e ij) { m_stroker.inner_join(ij); }
+
+        line_cap_e   line_cap()   const { return m_stroker.line_cap(); }
+        line_join_e  line_join()  const { return m_stroker.line_join(); }
+        inner_join_e inner_join() const { return m_stroker.inner_join(); }
+
+        void width(double w) { m_stroker.width(m_width = w); }
+        void miter_limit(double ml) { m_stroker.miter_limit(ml); }
+        void miter_limit_theta(double t) { m_stroker.miter_limit_theta(t); }
+        void inner_miter_limit(double ml) { m_stroker.inner_miter_limit(ml); }
+        void approximation_scale(double as) { m_stroker.approximation_scale(as); }
+
+        double width() const { return m_width; }
+        double miter_limit() const { return m_stroker.miter_limit(); }
+        double inner_miter_limit() const { return m_stroker.inner_miter_limit(); }
+        double approximation_scale() const { return m_stroker.approximation_scale(); }
+
+        void auto_detect_orientation(bool v) { m_auto_detect = v; }
+        bool auto_detect_orientation() const { return m_auto_detect; }
+
+        // Generator interface
+        void remove_all();
+        void add_vertex(double x, double y, unsigned cmd);
+
+        // Vertex Source Interface
+        void     rewind(unsigned path_id);
+        unsigned vertex(double* x, double* y);
+
+    private:
+        vcgen_contour(const vcgen_contour&);
+        const vcgen_contour& operator = (const vcgen_contour&);
+
+        math_stroke<coord_storage> m_stroker;
+        double                     m_width;
+        vertex_storage             m_src_vertices;
+        coord_storage              m_out_vertices;
+        status_e                   m_status;
+        unsigned                   m_src_vertex;
+        unsigned                   m_out_vertex;
+        unsigned                   m_closed;
+        unsigned                   m_orientation;
+        bool                       m_auto_detect;
+    };
+
+}
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_vcgen_dash.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_vcgen_dash.h
new file mode 100644
index 0000000000..c87dce4c81
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_vcgen_dash.h
@@ -0,0 +1,93 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Line dash generator
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_VCGEN_DASH_INCLUDED
+#define AGG_VCGEN_DASH_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_vertex_sequence.h"
+
+namespace agg
+{
+
+    //---------------------------------------------------------------vcgen_dash
+    //
+    // See Implementation agg_vcgen_dash.cpp
+    //
+    class vcgen_dash
+    {
+        enum max_dashes_e
+        {
+            max_dashes = 32
+        };
+
+        enum status_e
+        {
+            initial,
+            ready,
+            polyline,
+            stop
+        };
+
+    public:
+        typedef vertex_sequence<vertex_dist, 6> vertex_storage;
+
+        vcgen_dash();
+
+        void remove_all_dashes();
+        void add_dash(double dash_len, double gap_len);
+        void dash_start(double ds);
+
+        void shorten(double s) { m_shorten = s; }
+        double shorten() const { return m_shorten; }
+
+        // Vertex Generator Interface
+        void remove_all();
+        void add_vertex(double x, double y, unsigned cmd);
+
+        // Vertex Source Interface
+        void     rewind(unsigned path_id);
+        unsigned vertex(double* x, double* y);
+
+    private:
+        vcgen_dash(const vcgen_dash&);
+        const vcgen_dash& operator = (const vcgen_dash&);
+
+        void calc_dash_start(double ds);
+
+        double             m_dashes[max_dashes];
+        double             m_total_dash_len;
+        unsigned           m_num_dashes;
+        double             m_dash_start;
+        double             m_shorten;
+        double             m_curr_dash_start;
+        unsigned           m_curr_dash;
+        double             m_curr_rest;
+        const vertex_dist* m_v1;
+        const vertex_dist* m_v2;
+
+        vertex_storage m_src_vertices;
+        unsigned       m_closed;
+        status_e       m_status;
+        unsigned       m_src_vertex;
+    };
+
+
+}
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_vcgen_stroke.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_vcgen_stroke.h
new file mode 100644
index 0000000000..778223fe40
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_vcgen_stroke.h
@@ -0,0 +1,102 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_VCGEN_STROKE_INCLUDED
+#define AGG_VCGEN_STROKE_INCLUDED
+
+#include "agg_math_stroke.h"
+
+
+namespace agg
+{
+
+    //============================================================vcgen_stroke
+    //
+    // See Implementation agg_vcgen_stroke.cpp
+    // Stroke generator
+    //
+    //------------------------------------------------------------------------
+    class vcgen_stroke
+    {
+        enum status_e
+        {
+            initial,
+            ready,
+            cap1,
+            cap2,
+            outline1,
+            close_first,
+            outline2,
+            out_vertices,
+            end_poly1,
+            end_poly2,
+            stop
+        };
+
+    public:
+        typedef vertex_sequence<vertex_dist, 6> vertex_storage;
+        typedef pod_bvector<point_d, 6>         coord_storage;
+
+        vcgen_stroke();
+
+        void line_cap(line_cap_e lc)     { m_stroker.line_cap(lc); }
+        void line_join(line_join_e lj)   { m_stroker.line_join(lj); }
+        void inner_join(inner_join_e ij) { m_stroker.inner_join(ij); }
+
+        line_cap_e   line_cap()   const { return m_stroker.line_cap(); }
+        line_join_e  line_join()  const { return m_stroker.line_join(); }
+        inner_join_e inner_join() const { return m_stroker.inner_join(); }
+
+        void width(double w) { m_stroker.width(w); }
+        void miter_limit(double ml) { m_stroker.miter_limit(ml); }
+        void miter_limit_theta(double t) { m_stroker.miter_limit_theta(t); }
+        void inner_miter_limit(double ml) { m_stroker.inner_miter_limit(ml); }
+        void approximation_scale(double as) { m_stroker.approximation_scale(as); }
+
+        double width() const { return m_stroker.width(); }
+        double miter_limit() const { return m_stroker.miter_limit(); }
+        double inner_miter_limit() const { return m_stroker.inner_miter_limit(); }
+        double approximation_scale() const { return m_stroker.approximation_scale(); }
+
+        void shorten(double s) { m_shorten = s; }
+        double shorten() const { return m_shorten; }
+
+        // Vertex Generator Interface
+        void remove_all();
+        void add_vertex(double x, double y, unsigned cmd);
+
+        // Vertex Source Interface
+        void     rewind(unsigned path_id);
+        unsigned vertex(double* x, double* y);
+
+    private:
+        vcgen_stroke(const vcgen_stroke&);
+        const vcgen_stroke& operator = (const vcgen_stroke&);
+
+        math_stroke<coord_storage> m_stroker;
+        vertex_storage             m_src_vertices;
+        coord_storage              m_out_vertices;
+        double                     m_shorten;
+        unsigned                   m_closed;
+        status_e                   m_status;
+        status_e                   m_prev_status;
+        unsigned                   m_src_vertex;
+        unsigned                   m_out_vertex;
+    };
+
+
+}
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_vertex_sequence.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_vertex_sequence.h
new file mode 100644
index 0000000000..2ad0701b37
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_vertex_sequence.h
@@ -0,0 +1,172 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// vertex_sequence container and vertex_dist struct
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_VERTEX_SEQUENCE_INCLUDED
+#define AGG_VERTEX_SEQUENCE_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_array.h"
+#include "agg_math.h"
+
+namespace agg
+{
+
+    //----------------------------------------------------------vertex_sequence
+    // Modified agg::pod_bvector. The data is interpreted as a sequence 
+    // of vertices. It means that the type T must expose:
+    //
+    // bool T::operator() (const T& val)
+    // 
+    // that is called every time new vertex is being added. The main purpose
+    // of this operator is the possibility to calculate some values during 
+    // adding and to return true if the vertex fits some criteria or false if
+    // it doesn't. In the last case the new vertex is not added. 
+    // 
+    // The simple example is filtering coinciding vertices with calculation 
+    // of the distance between the current and previous ones:
+    //
+    //    struct vertex_dist
+    //    {
+    //        double   x;
+    //        double   y;
+    //        double   dist;
+    //
+    //        vertex_dist() {}
+    //        vertex_dist(double x_, double y_) :
+    //            x(x_),
+    //            y(y_),
+    //            dist(0.0)
+    //        {
+    //        }
+    //
+    //        bool operator () (const vertex_dist& val)
+    //        {
+    //            return (dist = calc_distance(x, y, val.x, val.y)) > EPSILON;
+    //        }
+    //    };
+    //
+    // Function close() calls this operator and removes the last vertex if 
+    // necessary.
+    //------------------------------------------------------------------------
+    template<class T, unsigned S=6> 
+    class vertex_sequence : public pod_bvector<T, S>
+    {
+    public:
+        typedef pod_bvector<T, S> base_type;
+
+        void add(const T& val);
+        void modify_last(const T& val);
+        void close(bool remove_flag);
+    };
+
+
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S> 
+    void vertex_sequence<T, S>::add(const T& val)
+    {
+        if(base_type::size() > 1)
+        {
+            if(!(*this)[base_type::size() - 2]((*this)[base_type::size() - 1])) 
+            {
+                base_type::remove_last();
+            }
+        }
+        base_type::add(val);
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S> 
+    void vertex_sequence<T, S>::modify_last(const T& val)
+    {
+        base_type::remove_last();
+        add(val);
+    }
+
+
+
+    //------------------------------------------------------------------------
+    template<class T, unsigned S> 
+    void vertex_sequence<T, S>::close(bool closed)
+    {
+        while(base_type::size() > 1)
+        {
+            if((*this)[base_type::size() - 2]((*this)[base_type::size() - 1])) break;
+            T t = (*this)[base_type::size() - 1];
+            base_type::remove_last();
+            modify_last(t);
+        }
+
+        if(closed)
+        {
+            while(base_type::size() > 1)
+            {
+                if((*this)[base_type::size() - 1]((*this)[0])) break;
+                base_type::remove_last();
+            }
+        }
+    }
+
+
+    //-------------------------------------------------------------vertex_dist
+    // Vertex (x, y) with the distance to the next one. The last vertex has 
+    // distance between the last and the first points if the polygon is closed
+    // and 0.0 if it's a polyline.
+    struct vertex_dist
+    {
+        double   x;
+        double   y;
+        double   dist;
+
+        vertex_dist() {}
+        vertex_dist(double x_, double y_) :
+            x(x_),
+            y(y_),
+            dist(0.0)
+        {
+        }
+
+        bool operator () (const vertex_dist& val)
+        {
+            bool ret = (dist = calc_distance(x, y, val.x, val.y)) > vertex_dist_epsilon;
+            if(!ret) dist = 1.0 / vertex_dist_epsilon;
+            return ret;
+        }
+    };
+
+
+
+    //--------------------------------------------------------vertex_dist_cmd
+    // Save as the above but with additional "command" value
+    struct vertex_dist_cmd : public vertex_dist
+    {
+        unsigned cmd;
+
+        vertex_dist_cmd() {}
+        vertex_dist_cmd(double x_, double y_, unsigned cmd_) :
+            vertex_dist(x_, y_),
+            cmd(cmd_)
+        {
+        }
+    };
+
+
+}
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_vpgen_segmentator.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_vpgen_segmentator.h
new file mode 100644
index 0000000000..29b3c9fa6f
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/agg_vpgen_segmentator.h
@@ -0,0 +1,61 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_VPGEN_SEGMENTATOR_INCLUDED
+#define AGG_VPGEN_SEGMENTATOR_INCLUDED
+
+#include <math.h>
+#include "agg_basics.h"
+
+namespace agg
+{
+
+    //=======================================================vpgen_segmentator
+    // 
+    // See Implementation agg_vpgen_segmentator.cpp
+    //
+    class vpgen_segmentator
+    {
+    public:
+        vpgen_segmentator() : m_approximation_scale(1.0) {}
+
+        void approximation_scale(double s) { m_approximation_scale = s;     }
+        double approximation_scale() const { return m_approximation_scale;  }
+
+        static bool auto_close()   { return false; }
+        static bool auto_unclose() { return false; }
+
+        void reset() { m_cmd = path_cmd_stop; }
+        void move_to(double x, double y);
+        void line_to(double x, double y);
+        unsigned vertex(double* x, double* y);
+
+    private:
+        double   m_approximation_scale;
+        double   m_x1;
+        double   m_y1;
+        double   m_dx;
+        double   m_dy;
+        double   m_dl;
+        double   m_ddl;
+        unsigned m_cmd;
+    };
+
+
+
+}
+
+#endif
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/util/agg_color_conv.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/util/agg_color_conv.h
new file mode 100644
index 0000000000..8b8a0a55d2
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/util/agg_color_conv.h
@@ -0,0 +1,128 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Conversion from one colorspace/pixel format to another
+//
+//----------------------------------------------------------------------------
+
+#ifndef AGG_COLOR_CONV_INCLUDED
+#define AGG_COLOR_CONV_INCLUDED
+
+#include <string.h>
+#include "agg_basics.h"
+#include "agg_rendering_buffer.h"
+
+
+
+
+namespace agg
+{
+
+    //--------------------------------------------------------------color_conv
+    template<class RenBuf, class CopyRow> 
+    void color_conv(RenBuf* dst, const RenBuf* src, CopyRow copy_row_functor)
+    {
+        unsigned width = src->width();
+        unsigned height = src->height();
+
+        if(dst->width()  < width)  width  = dst->width();
+        if(dst->height() < height) height = dst->height();
+
+        if(width)
+        {
+            unsigned y;
+            for(y = 0; y < height; y++)
+            {
+                copy_row_functor(dst->row_ptr(0, y, width), 
+                                 src->row_ptr(y), 
+                                 width);
+            }
+        }
+    }
+
+
+    //---------------------------------------------------------color_conv_row
+    template<class CopyRow> 
+    void color_conv_row(int8u* dst, 
+                        const int8u* src,
+                        unsigned width,
+                        CopyRow copy_row_functor)
+    {
+        copy_row_functor(dst, src, width);
+    }
+
+
+    //---------------------------------------------------------color_conv_same
+    template<int BPP> class color_conv_same
+    {
+    public:
+        void operator () (int8u* dst, 
+                          const int8u* src,
+                          unsigned width) const
+        {
+            memmove(dst, src, width*BPP);
+        }
+    };
+
+
+    // Generic pixel converter.
+    template<class DstFormat, class SrcFormat>
+    struct conv_pixel
+    {
+        void operator()(void* dst, const void* src) const
+        {
+            // Read a pixel from the source format and write it to the destination format.
+            DstFormat::write_plain_color(dst, SrcFormat::read_plain_color(src));
+        }
+    };
+
+    // Generic row converter. Uses conv_pixel to convert individual pixels.
+    template<class DstFormat, class SrcFormat>
+    struct conv_row
+    {
+        void operator()(void* dst, const void* src, unsigned width) const
+        {
+            conv_pixel<DstFormat, SrcFormat> conv;
+            do
+            {
+                conv(dst, src);
+                dst = (int8u*)dst + DstFormat::pix_width;
+                src = (int8u*)src + SrcFormat::pix_width;
+            }
+            while (--width);
+        }
+    };
+
+    // Specialization for case where source and destination formats are identical.
+    template<class Format>
+    struct conv_row<Format, Format>
+    {
+        void operator()(void* dst, const void* src, unsigned width) const
+        {
+            memmove(dst, src, width * Format::pix_width);
+        }
+    };
+
+    // Top-level conversion function, converts one pixel format to any other.
+    template<class DstFormat, class SrcFormat, class RenBuf>
+    void convert(RenBuf* dst, const RenBuf* src)
+    {
+        color_conv(dst, src, conv_row<DstFormat, SrcFormat>());
+    }
+}
+
+
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/include/util/agg_color_conv_rgb8.h b/contrib/python/matplotlib/py2/extern/agg24-svn/include/util/agg_color_conv_rgb8.h
new file mode 100644
index 0000000000..609460dba4
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/include/util/agg_color_conv_rgb8.h
@@ -0,0 +1,476 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// A set of functors used with color_conv(). See file agg_color_conv.h
+// These functors can convert images with up to 8 bits per component.
+// Use convertors in the following way:
+//
+// agg::color_conv(dst, src, agg::color_conv_XXXX_to_YYYY());
+// whare XXXX and YYYY can be any of:
+//  rgb24
+//  bgr24
+//  rgba32
+//  abgr32
+//  argb32
+//  bgra32
+//  rgb555
+//  rgb565
+//----------------------------------------------------------------------------
+
+#ifndef AGG_COLOR_CONV_RGB8_INCLUDED
+#define AGG_COLOR_CONV_RGB8_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_color_conv.h"
+
+namespace agg
+{
+
+    //-----------------------------------------------------color_conv_rgb24
+    class color_conv_rgb24
+    {
+    public:
+        void operator () (int8u* dst, 
+                          const int8u* src,
+                          unsigned width) const
+        {
+            do
+            {
+                int8u tmp[3];
+                tmp[0] = *src++;
+                tmp[1] = *src++;
+                tmp[2] = *src++;
+                *dst++ = tmp[2];
+                *dst++ = tmp[1];
+                *dst++ = tmp[0];
+            }
+            while(--width);
+        }
+    };
+
+    typedef color_conv_rgb24 color_conv_rgb24_to_bgr24;
+    typedef color_conv_rgb24 color_conv_bgr24_to_rgb24;
+
+    typedef color_conv_same<3> color_conv_bgr24_to_bgr24;
+    typedef color_conv_same<3> color_conv_rgb24_to_rgb24;
+
+
+
+    //------------------------------------------------------color_conv_rgba32
+    template<int I1, int I2, int I3, int I4> class color_conv_rgba32
+    {
+    public:
+        void operator () (int8u* dst, 
+                          const int8u* src,
+                          unsigned width) const
+        {
+            do
+            {
+                int8u tmp[4];
+                tmp[0] = *src++;
+                tmp[1] = *src++;
+                tmp[2] = *src++;
+                tmp[3] = *src++;
+                *dst++ = tmp[I1];
+                *dst++ = tmp[I2];
+                *dst++ = tmp[I3];
+                *dst++ = tmp[I4]; 
+            }
+            while(--width);
+        }
+    };
+
+
+    //------------------------------------------------------------------------
+    typedef color_conv_rgba32<0,3,2,1> color_conv_argb32_to_abgr32; //----color_conv_argb32_to_abgr32
+    typedef color_conv_rgba32<3,2,1,0> color_conv_argb32_to_bgra32; //----color_conv_argb32_to_bgra32
+    typedef color_conv_rgba32<1,2,3,0> color_conv_argb32_to_rgba32; //----color_conv_argb32_to_rgba32
+    typedef color_conv_rgba32<3,0,1,2> color_conv_bgra32_to_abgr32; //----color_conv_bgra32_to_abgr32
+    typedef color_conv_rgba32<3,2,1,0> color_conv_bgra32_to_argb32; //----color_conv_bgra32_to_argb32
+    typedef color_conv_rgba32<2,1,0,3> color_conv_bgra32_to_rgba32; //----color_conv_bgra32_to_rgba32
+    typedef color_conv_rgba32<3,2,1,0> color_conv_rgba32_to_abgr32; //----color_conv_rgba32_to_abgr32
+    typedef color_conv_rgba32<3,0,1,2> color_conv_rgba32_to_argb32; //----color_conv_rgba32_to_argb32
+    typedef color_conv_rgba32<2,1,0,3> color_conv_rgba32_to_bgra32; //----color_conv_rgba32_to_bgra32
+    typedef color_conv_rgba32<0,3,2,1> color_conv_abgr32_to_argb32; //----color_conv_abgr32_to_argb32
+    typedef color_conv_rgba32<1,2,3,0> color_conv_abgr32_to_bgra32; //----color_conv_abgr32_to_bgra32
+    typedef color_conv_rgba32<3,2,1,0> color_conv_abgr32_to_rgba32; //----color_conv_abgr32_to_rgba32
+
+    //------------------------------------------------------------------------
+    typedef color_conv_same<4> color_conv_rgba32_to_rgba32; //----color_conv_rgba32_to_rgba32
+    typedef color_conv_same<4> color_conv_argb32_to_argb32; //----color_conv_argb32_to_argb32
+    typedef color_conv_same<4> color_conv_bgra32_to_bgra32; //----color_conv_bgra32_to_bgra32
+    typedef color_conv_same<4> color_conv_abgr32_to_abgr32; //----color_conv_abgr32_to_abgr32
+
+
+    //--------------------------------------------color_conv_rgb24_rgba32
+    template<int I1, int I2, int I3, int A> class color_conv_rgb24_rgba32
+    {
+    public:
+        void operator () (int8u* dst, 
+                          const int8u* src,
+                          unsigned width) const
+        {
+            do
+            {
+                dst[I1] = *src++;
+                dst[I2] = *src++;
+                dst[I3] = *src++;
+                dst[A]  = 255; 
+                dst += 4;
+            }
+            while(--width);
+        }
+    };
+
+
+    //------------------------------------------------------------------------
+    typedef color_conv_rgb24_rgba32<1,2,3,0> color_conv_rgb24_to_argb32; //----color_conv_rgb24_to_argb32
+    typedef color_conv_rgb24_rgba32<3,2,1,0> color_conv_rgb24_to_abgr32; //----color_conv_rgb24_to_abgr32
+    typedef color_conv_rgb24_rgba32<2,1,0,3> color_conv_rgb24_to_bgra32; //----color_conv_rgb24_to_bgra32
+    typedef color_conv_rgb24_rgba32<0,1,2,3> color_conv_rgb24_to_rgba32; //----color_conv_rgb24_to_rgba32
+    typedef color_conv_rgb24_rgba32<3,2,1,0> color_conv_bgr24_to_argb32; //----color_conv_bgr24_to_argb32
+    typedef color_conv_rgb24_rgba32<1,2,3,0> color_conv_bgr24_to_abgr32; //----color_conv_bgr24_to_abgr32
+    typedef color_conv_rgb24_rgba32<0,1,2,3> color_conv_bgr24_to_bgra32; //----color_conv_bgr24_to_bgra32
+    typedef color_conv_rgb24_rgba32<2,1,0,3> color_conv_bgr24_to_rgba32; //----color_conv_bgr24_to_rgba32
+
+    
+
+    //-------------------------------------------------color_conv_rgba32_rgb24
+    template<int I1, int I2, int I3> class color_conv_rgba32_rgb24
+    {
+    public:
+        void operator () (int8u* dst, 
+                          const int8u* src,
+                          unsigned width) const
+        {
+            do
+            {
+                *dst++ = src[I1];
+                *dst++ = src[I2];
+                *dst++ = src[I3];
+                src += 4;
+            }
+            while(--width);
+        }
+    };
+
+
+
+    //------------------------------------------------------------------------
+    typedef color_conv_rgba32_rgb24<1,2,3> color_conv_argb32_to_rgb24; //----color_conv_argb32_to_rgb24
+    typedef color_conv_rgba32_rgb24<3,2,1> color_conv_abgr32_to_rgb24; //----color_conv_abgr32_to_rgb24
+    typedef color_conv_rgba32_rgb24<2,1,0> color_conv_bgra32_to_rgb24; //----color_conv_bgra32_to_rgb24
+    typedef color_conv_rgba32_rgb24<0,1,2> color_conv_rgba32_to_rgb24; //----color_conv_rgba32_to_rgb24
+    typedef color_conv_rgba32_rgb24<3,2,1> color_conv_argb32_to_bgr24; //----color_conv_argb32_to_bgr24
+    typedef color_conv_rgba32_rgb24<1,2,3> color_conv_abgr32_to_bgr24; //----color_conv_abgr32_to_bgr24
+    typedef color_conv_rgba32_rgb24<0,1,2> color_conv_bgra32_to_bgr24; //----color_conv_bgra32_to_bgr24
+    typedef color_conv_rgba32_rgb24<2,1,0> color_conv_rgba32_to_bgr24; //----color_conv_rgba32_to_bgr24
+
+
+    //------------------------------------------------color_conv_rgb555_rgb24
+    template<int R, int B> class color_conv_rgb555_rgb24
+    {
+    public:
+        void operator () (int8u* dst, 
+                          const int8u* src,
+                          unsigned width) const
+        {
+            do
+            {
+                unsigned rgb = *(int16u*)src;
+                dst[R] = (int8u)((rgb >> 7) & 0xF8);
+                dst[1] = (int8u)((rgb >> 2) & 0xF8);
+                dst[B] = (int8u)((rgb << 3) & 0xF8);
+                src += 2;
+                dst += 3;
+            }
+            while(--width);
+        }
+    };
+
+
+    //------------------------------------------------------------------------
+    typedef color_conv_rgb555_rgb24<2,0> color_conv_rgb555_to_bgr24; //----color_conv_rgb555_to_bgr24
+    typedef color_conv_rgb555_rgb24<0,2> color_conv_rgb555_to_rgb24; //----color_conv_rgb555_to_rgb24
+
+
+    //-------------------------------------------------color_conv_rgb24_rgb555
+    template<int R, int B> class color_conv_rgb24_rgb555
+    {
+    public:
+        void operator () (int8u* dst, 
+                          const int8u* src,
+                          unsigned width) const
+        {
+            do
+            {
+                *(int16u*)dst = (int16u)(((unsigned(src[R]) << 7) & 0x7C00) | 
+                                         ((unsigned(src[1]) << 2) & 0x3E0)  |
+                                         ((unsigned(src[B]) >> 3)));
+                src += 3;
+                dst += 2;
+            }
+            while(--width);
+        }
+    };
+
+
+    //------------------------------------------------------------------------
+    typedef color_conv_rgb24_rgb555<2,0> color_conv_bgr24_to_rgb555; //----color_conv_bgr24_to_rgb555
+    typedef color_conv_rgb24_rgb555<0,2> color_conv_rgb24_to_rgb555; //----color_conv_rgb24_to_rgb555
+
+
+    //-------------------------------------------------color_conv_rgb565_rgb24
+    template<int R, int B> class color_conv_rgb565_rgb24
+    {
+    public:
+        void operator () (int8u* dst, 
+                          const int8u* src,
+                          unsigned width) const
+        {
+            do
+            {
+                unsigned rgb = *(int16u*)src;
+                dst[R] = (rgb >> 8) & 0xF8;
+                dst[1] = (rgb >> 3) & 0xFC;
+                dst[B] = (rgb << 3) & 0xF8;
+                src += 2;
+                dst += 3;
+            }
+            while(--width);
+        }
+    };
+
+
+    //------------------------------------------------------------------------
+    typedef color_conv_rgb565_rgb24<2,0> color_conv_rgb565_to_bgr24; //----color_conv_rgb565_to_bgr24
+    typedef color_conv_rgb565_rgb24<0,2> color_conv_rgb565_to_rgb24; //----color_conv_rgb565_to_rgb24
+
+
+    //-------------------------------------------------color_conv_rgb24_rgb565
+    template<int R, int B> class color_conv_rgb24_rgb565
+    {
+    public:
+        void operator () (int8u* dst, 
+                          const int8u* src,
+                          unsigned width) const
+        {
+            do
+            {
+                *(int16u*)dst = (int16u)(((unsigned(src[R]) << 8) & 0xF800) | 
+                                         ((unsigned(src[1]) << 3) & 0x7E0)  |
+                                         ((unsigned(src[B]) >> 3)));
+                src += 3;
+                dst += 2;
+            }
+            while(--width);
+        }
+    };
+
+
+    //------------------------------------------------------------------------
+    typedef color_conv_rgb24_rgb565<2,0> color_conv_bgr24_to_rgb565; //----color_conv_bgr24_to_rgb565
+    typedef color_conv_rgb24_rgb565<0,2> color_conv_rgb24_to_rgb565; //----color_conv_rgb24_to_rgb565
+
+
+
+    //-------------------------------------------------color_conv_rgb555_rgba32
+    template<int R, int G, int B, int A> class color_conv_rgb555_rgba32
+    {
+    public:
+        void operator () (int8u* dst, 
+                          const int8u* src,
+                          unsigned width) const
+        {
+            do
+            {
+                int rgb = *(int16*)src;
+                dst[R] = (int8u)((rgb >> 7) & 0xF8);
+                dst[G] = (int8u)((rgb >> 2) & 0xF8);
+                dst[B] = (int8u)((rgb << 3) & 0xF8);
+                dst[A] = (int8u)(rgb >> 15);
+                src += 2;
+                dst += 4;
+            }
+            while(--width);
+        }
+    };
+
+
+    //------------------------------------------------------------------------
+    typedef color_conv_rgb555_rgba32<1,2,3,0> color_conv_rgb555_to_argb32; //----color_conv_rgb555_to_argb32
+    typedef color_conv_rgb555_rgba32<3,2,1,0> color_conv_rgb555_to_abgr32; //----color_conv_rgb555_to_abgr32
+    typedef color_conv_rgb555_rgba32<2,1,0,3> color_conv_rgb555_to_bgra32; //----color_conv_rgb555_to_bgra32
+    typedef color_conv_rgb555_rgba32<0,1,2,3> color_conv_rgb555_to_rgba32; //----color_conv_rgb555_to_rgba32
+
+
+    //------------------------------------------------color_conv_rgba32_rgb555
+    template<int R, int G, int B, int A> class color_conv_rgba32_rgb555
+    {
+    public:
+        void operator () (int8u* dst, 
+                          const int8u* src,
+                          unsigned width) const
+        {
+            do
+            {
+                *(int16u*)dst = (int16u)(((unsigned(src[R]) << 7) & 0x7C00) | 
+                                         ((unsigned(src[G]) << 2) & 0x3E0)  |
+                                         ((unsigned(src[B]) >> 3)) |
+                                         ((unsigned(src[A]) << 8) & 0x8000));
+                src += 4;
+                dst += 2;
+            }
+            while(--width);
+        }
+    };
+
+
+    //------------------------------------------------------------------------
+    typedef color_conv_rgba32_rgb555<1,2,3,0> color_conv_argb32_to_rgb555; //----color_conv_argb32_to_rgb555
+    typedef color_conv_rgba32_rgb555<3,2,1,0> color_conv_abgr32_to_rgb555; //----color_conv_abgr32_to_rgb555
+    typedef color_conv_rgba32_rgb555<2,1,0,3> color_conv_bgra32_to_rgb555; //----color_conv_bgra32_to_rgb555
+    typedef color_conv_rgba32_rgb555<0,1,2,3> color_conv_rgba32_to_rgb555; //----color_conv_rgba32_to_rgb555
+
+
+
+    //------------------------------------------------color_conv_rgb565_rgba32
+    template<int R, int G, int B, int A> class color_conv_rgb565_rgba32
+    {
+    public:
+        void operator () (int8u* dst, 
+                          const int8u* src,
+                          unsigned width) const
+        {
+            do
+            {
+                int rgb = *(int16*)src;
+                dst[R] = (rgb >> 8) & 0xF8;
+                dst[G] = (rgb >> 3) & 0xFC;
+                dst[B] = (rgb << 3) & 0xF8;
+                dst[A] = 255;
+                src += 2;
+                dst += 4;
+            }
+            while(--width);
+        }
+    };
+
+
+    //------------------------------------------------------------------------
+    typedef color_conv_rgb565_rgba32<1,2,3,0> color_conv_rgb565_to_argb32; //----color_conv_rgb565_to_argb32
+    typedef color_conv_rgb565_rgba32<3,2,1,0> color_conv_rgb565_to_abgr32; //----color_conv_rgb565_to_abgr32
+    typedef color_conv_rgb565_rgba32<2,1,0,3> color_conv_rgb565_to_bgra32; //----color_conv_rgb565_to_bgra32
+    typedef color_conv_rgb565_rgba32<0,1,2,3> color_conv_rgb565_to_rgba32; //----color_conv_rgb565_to_rgba32
+
+
+    //------------------------------------------------color_conv_rgba32_rgb565
+    template<int R, int G, int B> class color_conv_rgba32_rgb565
+    {
+    public:
+        void operator () (int8u* dst, 
+                          const int8u* src,
+                          unsigned width) const
+        {
+            do
+            {
+                *(int16u*)dst = (int16u)(((unsigned(src[R]) << 8) & 0xF800) | 
+                                         ((unsigned(src[G]) << 3) & 0x7E0)  |
+                                         ((unsigned(src[B]) >> 3)));
+                src += 4;
+                dst += 2;
+            }
+            while(--width);
+        }
+    };
+
+
+    //------------------------------------------------------------------------
+    typedef color_conv_rgba32_rgb565<1,2,3> color_conv_argb32_to_rgb565; //----color_conv_argb32_to_rgb565
+    typedef color_conv_rgba32_rgb565<3,2,1> color_conv_abgr32_to_rgb565; //----color_conv_abgr32_to_rgb565
+    typedef color_conv_rgba32_rgb565<2,1,0> color_conv_bgra32_to_rgb565; //----color_conv_bgra32_to_rgb565
+    typedef color_conv_rgba32_rgb565<0,1,2> color_conv_rgba32_to_rgb565; //----color_conv_rgba32_to_rgb565
+
+
+    //---------------------------------------------color_conv_rgb555_to_rgb565
+    class color_conv_rgb555_to_rgb565
+    {
+    public:
+        void operator () (int8u* dst, 
+                          const int8u* src,
+                          unsigned width) const
+        {
+            do
+            {
+                unsigned rgb = *(int16u*)src;
+                *(int16u*)dst = (int16u)(((rgb << 1) & 0xFFC0) | (rgb & 0x1F));
+                src += 2;
+                dst += 2;
+            }
+            while(--width);
+        }
+    };
+
+
+    //----------------------------------------------color_conv_rgb565_to_rgb555
+    class color_conv_rgb565_to_rgb555
+    {
+    public:
+        void operator () (int8u* dst, 
+                          const int8u* src,
+                          unsigned width) const
+        {
+            do
+            {
+                unsigned rgb = *(int16u*)src;
+                *(int16u*)dst = (int16u)(((rgb >> 1) & 0x7FE0) | (rgb & 0x1F));
+                src += 2;
+                dst += 2;
+            }
+            while(--width);
+        }
+    };
+
+
+    //------------------------------------------------------------------------
+    typedef color_conv_same<2> color_conv_rgb555_to_rgb555; //----color_conv_rgb555_to_rgb555
+    typedef color_conv_same<2> color_conv_rgb565_to_rgb565; //----color_conv_rgb565_to_rgb565
+
+    
+    template<int R, int B> class color_conv_rgb24_gray8
+    {
+    public:
+        void operator () (int8u* dst, 
+                          const int8u* src,
+                          unsigned width) const
+        {
+            do
+            {
+                *dst++ = (src[R]*77 + src[1]*150 + src[B]*29) >> 8;
+                src += 3;
+            }
+            while(--width);
+        }
+    };
+
+    typedef color_conv_rgb24_gray8<0,2> color_conv_rgb24_to_gray8; //----color_conv_rgb24_to_gray8
+    typedef color_conv_rgb24_gray8<2,0> color_conv_bgr24_to_gray8; //----color_conv_bgr24_to_gray8
+
+
+}
+
+
+
+#endif
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/src/ChangeLog b/contrib/python/matplotlib/py2/extern/agg24-svn/src/ChangeLog
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/src/ChangeLog
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_bezier_arc.cpp b/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_bezier_arc.cpp
new file mode 100644
index 0000000000..844d300c09
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_bezier_arc.cpp
@@ -0,0 +1,258 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Arc generator. Produces at most 4 consecutive cubic bezier curves, i.e., 
+// 4, 7, 10, or 13 vertices.
+//
+//----------------------------------------------------------------------------
+
+
+#include <math.h>
+#include "agg_bezier_arc.h"
+
+
+namespace agg
+{
+
+    // This epsilon is used to prevent us from adding degenerate curves 
+    // (converging to a single point).
+    // The value isn't very critical. Function arc_to_bezier() has a limit 
+    // of the sweep_angle. If fabs(sweep_angle) exceeds pi/2 the curve 
+    // becomes inaccurate. But slight exceeding is quite appropriate.
+    //-------------------------------------------------bezier_arc_angle_epsilon
+    const double bezier_arc_angle_epsilon = 0.01;
+
+    //------------------------------------------------------------arc_to_bezier
+    void arc_to_bezier(double cx, double cy, double rx, double ry, 
+                       double start_angle, double sweep_angle,
+                       double* curve)
+    {
+        double x0 = cos(sweep_angle / 2.0);
+        double y0 = sin(sweep_angle / 2.0);
+        double tx = (1.0 - x0) * 4.0 / 3.0;
+        double ty = y0 - tx * x0 / y0;
+        double px[4];
+        double py[4];
+        px[0] =  x0;
+        py[0] = -y0;
+        px[1] =  x0 + tx;
+        py[1] = -ty;
+        px[2] =  x0 + tx;
+        py[2] =  ty;
+        px[3] =  x0;
+        py[3] =  y0;
+
+        double sn = sin(start_angle + sweep_angle / 2.0);
+        double cs = cos(start_angle + sweep_angle / 2.0);
+
+        unsigned i;
+        for(i = 0; i < 4; i++)
+        {
+            curve[i * 2]     = cx + rx * (px[i] * cs - py[i] * sn);
+            curve[i * 2 + 1] = cy + ry * (px[i] * sn + py[i] * cs);
+        }
+    }
+
+
+
+    //------------------------------------------------------------------------
+    void bezier_arc::init(double x,  double y, 
+                          double rx, double ry, 
+                          double start_angle, 
+                          double sweep_angle)
+    {
+        start_angle = fmod(start_angle, 2.0 * pi);
+        if(sweep_angle >=  2.0 * pi) sweep_angle =  2.0 * pi;
+        if(sweep_angle <= -2.0 * pi) sweep_angle = -2.0 * pi;
+
+        if(fabs(sweep_angle) < 1e-10)
+        {
+            m_num_vertices = 4;
+            m_cmd = path_cmd_line_to;
+            m_vertices[0] = x + rx * cos(start_angle);
+            m_vertices[1] = y + ry * sin(start_angle);
+            m_vertices[2] = x + rx * cos(start_angle + sweep_angle);
+            m_vertices[3] = y + ry * sin(start_angle + sweep_angle);
+            return;
+        }
+
+        double total_sweep = 0.0;
+        double local_sweep = 0.0;
+        double prev_sweep;
+        m_num_vertices = 2;
+        m_cmd = path_cmd_curve4;
+        bool done = false;
+        do
+        {
+            if(sweep_angle < 0.0)
+            {
+                prev_sweep  = total_sweep;
+                local_sweep = -pi * 0.5;
+                total_sweep -= pi * 0.5;
+                if(total_sweep <= sweep_angle + bezier_arc_angle_epsilon)
+                {
+                    local_sweep = sweep_angle - prev_sweep;
+                    done = true;
+                }
+            }
+            else
+            {
+                prev_sweep  = total_sweep;
+                local_sweep =  pi * 0.5;
+                total_sweep += pi * 0.5;
+                if(total_sweep >= sweep_angle - bezier_arc_angle_epsilon)
+                {
+                    local_sweep = sweep_angle - prev_sweep;
+                    done = true;
+                }
+            }
+
+            arc_to_bezier(x, y, rx, ry, 
+                          start_angle, 
+                          local_sweep, 
+                          m_vertices + m_num_vertices - 2);
+
+            m_num_vertices += 6;
+            start_angle += local_sweep;
+        }
+        while(!done && m_num_vertices < 26);
+    }
+
+
+
+
+    //--------------------------------------------------------------------
+    void bezier_arc_svg::init(double x0, double y0, 
+                              double rx, double ry, 
+                              double angle,
+                              bool large_arc_flag,
+                              bool sweep_flag,
+                              double x2, double y2)
+    {
+        m_radii_ok = true;
+
+        if(rx < 0.0) rx = -rx;
+        if(ry < 0.0) ry = -rx;
+
+        // Calculate the middle point between 
+        // the current and the final points
+        //------------------------
+        double dx2 = (x0 - x2) / 2.0;
+        double dy2 = (y0 - y2) / 2.0;
+
+        double cos_a = cos(angle);
+        double sin_a = sin(angle);
+
+        // Calculate (x1, y1)
+        //------------------------
+        double x1 =  cos_a * dx2 + sin_a * dy2;
+        double y1 = -sin_a * dx2 + cos_a * dy2;
+
+        // Ensure radii are large enough
+        //------------------------
+        double prx = rx * rx;
+        double pry = ry * ry;
+        double px1 = x1 * x1;
+        double py1 = y1 * y1;
+
+        // Check that radii are large enough
+        //------------------------
+        double radii_check = px1/prx + py1/pry;
+        if(radii_check > 1.0) 
+        {
+            rx = sqrt(radii_check) * rx;
+            ry = sqrt(radii_check) * ry;
+            prx = rx * rx;
+            pry = ry * ry;
+            if(radii_check > 10.0) m_radii_ok = false;
+        }
+
+        // Calculate (cx1, cy1)
+        //------------------------
+        double sign = (large_arc_flag == sweep_flag) ? -1.0 : 1.0;
+        double sq   = (prx*pry - prx*py1 - pry*px1) / (prx*py1 + pry*px1);
+        double coef = sign * sqrt((sq < 0) ? 0 : sq);
+        double cx1  = coef *  ((rx * y1) / ry);
+        double cy1  = coef * -((ry * x1) / rx);
+
+        //
+        // Calculate (cx, cy) from (cx1, cy1)
+        //------------------------
+        double sx2 = (x0 + x2) / 2.0;
+        double sy2 = (y0 + y2) / 2.0;
+        double cx = sx2 + (cos_a * cx1 - sin_a * cy1);
+        double cy = sy2 + (sin_a * cx1 + cos_a * cy1);
+
+        // Calculate the start_angle (angle1) and the sweep_angle (dangle)
+        //------------------------
+        double ux =  (x1 - cx1) / rx;
+        double uy =  (y1 - cy1) / ry;
+        double vx = (-x1 - cx1) / rx;
+        double vy = (-y1 - cy1) / ry;
+        double p, n;
+
+        // Calculate the angle start
+        //------------------------
+        n = sqrt(ux*ux + uy*uy);
+        p = ux; // (1 * ux) + (0 * uy)
+        sign = (uy < 0) ? -1.0 : 1.0;
+        double v = p / n;
+        if(v < -1.0) v = -1.0;
+        if(v >  1.0) v =  1.0;
+        double start_angle = sign * acos(v);
+
+        // Calculate the sweep angle
+        //------------------------
+        n = sqrt((ux*ux + uy*uy) * (vx*vx + vy*vy));
+        p = ux * vx + uy * vy;
+        sign = (ux * vy - uy * vx < 0) ? -1.0 : 1.0;
+        v = p / n;
+        if(v < -1.0) v = -1.0;
+        if(v >  1.0) v =  1.0;
+        double sweep_angle = sign * acos(v);
+        if(!sweep_flag && sweep_angle > 0) 
+        {
+            sweep_angle -= pi * 2.0;
+        } 
+        else 
+        if (sweep_flag && sweep_angle < 0) 
+        {
+            sweep_angle += pi * 2.0;
+        }
+
+        // We can now build and transform the resulting arc
+        //------------------------
+        m_arc.init(0.0, 0.0, rx, ry, start_angle, sweep_angle);
+        trans_affine mtx = trans_affine_rotation(angle);
+        mtx *= trans_affine_translation(cx, cy);
+        
+        for(unsigned i = 2; i < m_arc.num_vertices()-2; i += 2)
+        {
+            mtx.transform(m_arc.vertices() + i, m_arc.vertices() + i + 1);
+        }
+
+        // We must make sure that the starting and ending points
+        // exactly coincide with the initial (x0,y0) and (x2,y2)
+        m_arc.vertices()[0] = x0;
+        m_arc.vertices()[1] = y0;
+        if(m_arc.num_vertices() > 2)
+        {
+            m_arc.vertices()[m_arc.num_vertices() - 2] = x2;
+            m_arc.vertices()[m_arc.num_vertices() - 1] = y2;
+        }
+    }
+
+
+}
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_curves.cpp b/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_curves.cpp
new file mode 100644
index 0000000000..4701734718
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_curves.cpp
@@ -0,0 +1,613 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#include <math.h>
+#include "agg_curves.h"
+#include "agg_math.h"
+
+namespace agg
+{
+
+    //------------------------------------------------------------------------
+    const double curve_distance_epsilon                  = 1e-30;
+    const double curve_collinearity_epsilon              = 1e-30;
+    const double curve_angle_tolerance_epsilon           = 0.01;
+    enum curve_recursion_limit_e { curve_recursion_limit = 32 };
+
+
+
+    //------------------------------------------------------------------------
+    void curve3_inc::approximation_scale(double s) 
+    { 
+        m_scale = s;
+    }
+
+    //------------------------------------------------------------------------
+    double curve3_inc::approximation_scale() const 
+    { 
+        return m_scale;
+    }
+
+    //------------------------------------------------------------------------
+    void curve3_inc::init(double x1, double y1, 
+                          double x2, double y2, 
+                          double x3, double y3)
+    {
+        m_start_x = x1;
+        m_start_y = y1;
+        m_end_x   = x3;
+        m_end_y   = y3;
+
+        double dx1 = x2 - x1;
+        double dy1 = y2 - y1;
+        double dx2 = x3 - x2;
+        double dy2 = y3 - y2;
+
+        double len = sqrt(dx1 * dx1 + dy1 * dy1) + sqrt(dx2 * dx2 + dy2 * dy2); 
+
+        m_num_steps = uround(len * 0.25 * m_scale);
+
+        if(m_num_steps < 4)
+        {
+            m_num_steps = 4;   
+        }
+
+        double subdivide_step  = 1.0 / m_num_steps;
+        double subdivide_step2 = subdivide_step * subdivide_step;
+
+        double tmpx = (x1 - x2 * 2.0 + x3) * subdivide_step2;
+        double tmpy = (y1 - y2 * 2.0 + y3) * subdivide_step2;
+
+        m_saved_fx = m_fx = x1;
+        m_saved_fy = m_fy = y1;
+        
+        m_saved_dfx = m_dfx = tmpx + (x2 - x1) * (2.0 * subdivide_step);
+        m_saved_dfy = m_dfy = tmpy + (y2 - y1) * (2.0 * subdivide_step);
+
+        m_ddfx = tmpx * 2.0;
+        m_ddfy = tmpy * 2.0;
+
+        m_step = m_num_steps;
+    }
+
+    //------------------------------------------------------------------------
+    void curve3_inc::rewind(unsigned)
+    {
+        if(m_num_steps == 0)
+        {
+            m_step = -1;
+            return;
+        }
+        m_step = m_num_steps;
+        m_fx   = m_saved_fx;
+        m_fy   = m_saved_fy;
+        m_dfx  = m_saved_dfx;
+        m_dfy  = m_saved_dfy;
+    }
+
+    //------------------------------------------------------------------------
+    unsigned curve3_inc::vertex(double* x, double* y)
+    {
+        if(m_step < 0) return path_cmd_stop;
+        if(m_step == m_num_steps)
+        {
+            *x = m_start_x;
+            *y = m_start_y;
+            --m_step;
+            return path_cmd_move_to;
+        }
+        if(m_step == 0)
+        {
+            *x = m_end_x;
+            *y = m_end_y;
+            --m_step;
+            return path_cmd_line_to;
+        }
+        m_fx  += m_dfx; 
+        m_fy  += m_dfy;
+        m_dfx += m_ddfx; 
+        m_dfy += m_ddfy; 
+        *x = m_fx;
+        *y = m_fy;
+        --m_step;
+        return path_cmd_line_to;
+    }
+
+    //------------------------------------------------------------------------
+    void curve3_div::init(double x1, double y1, 
+                          double x2, double y2, 
+                          double x3, double y3)
+    {
+        m_points.remove_all();
+        m_distance_tolerance_square = 0.5 / m_approximation_scale;
+        m_distance_tolerance_square *= m_distance_tolerance_square;
+        bezier(x1, y1, x2, y2, x3, y3);
+        m_count = 0;
+    }
+
+    //------------------------------------------------------------------------
+    void curve3_div::recursive_bezier(double x1, double y1, 
+                                      double x2, double y2, 
+                                      double x3, double y3,
+                                      unsigned level)
+    {
+        if(level > curve_recursion_limit) 
+        {
+            return;
+        }
+
+        // Calculate all the mid-points of the line segments
+        //----------------------
+        double x12   = (x1 + x2) / 2;                
+        double y12   = (y1 + y2) / 2;
+        double x23   = (x2 + x3) / 2;
+        double y23   = (y2 + y3) / 2;
+        double x123  = (x12 + x23) / 2;
+        double y123  = (y12 + y23) / 2;
+
+        double dx = x3-x1;
+        double dy = y3-y1;
+        double d = fabs(((x2 - x3) * dy - (y2 - y3) * dx));
+        double da;
+
+        if(d > curve_collinearity_epsilon)
+        { 
+            // Regular case
+            //-----------------
+            if(d * d <= m_distance_tolerance_square * (dx*dx + dy*dy))
+            {
+                // If the curvature doesn't exceed the distance_tolerance value
+                // we tend to finish subdivisions.
+                //----------------------
+                if(m_angle_tolerance < curve_angle_tolerance_epsilon)
+                {
+                    m_points.add(point_d(x123, y123));
+                    return;
+                }
+
+                // Angle & Cusp Condition
+                //----------------------
+                da = fabs(atan2(y3 - y2, x3 - x2) - atan2(y2 - y1, x2 - x1));
+                if(da >= pi) da = 2*pi - da;
+
+                if(da < m_angle_tolerance)
+                {
+                    // Finally we can stop the recursion
+                    //----------------------
+                    m_points.add(point_d(x123, y123));
+                    return;                 
+                }
+            }
+        }
+        else
+        {
+            // Collinear case
+            //------------------
+            da = dx*dx + dy*dy;
+            if(da == 0)
+            {
+                d = calc_sq_distance(x1, y1, x2, y2);
+            }
+            else
+            {
+                d = ((x2 - x1)*dx + (y2 - y1)*dy) / da;
+                if(d > 0 && d < 1)
+                {
+                    // Simple collinear case, 1---2---3
+                    // We can leave just two endpoints
+                    return;
+                }
+                     if(d <= 0) d = calc_sq_distance(x2, y2, x1, y1);
+                else if(d >= 1) d = calc_sq_distance(x2, y2, x3, y3);
+                else            d = calc_sq_distance(x2, y2, x1 + d*dx, y1 + d*dy);
+            }
+            if(d < m_distance_tolerance_square)
+            {
+                m_points.add(point_d(x2, y2));
+                return;
+            }
+        }
+
+        // Continue subdivision
+        //----------------------
+        recursive_bezier(x1, y1, x12, y12, x123, y123, level + 1); 
+        recursive_bezier(x123, y123, x23, y23, x3, y3, level + 1); 
+    }
+
+    //------------------------------------------------------------------------
+    void curve3_div::bezier(double x1, double y1, 
+                            double x2, double y2, 
+                            double x3, double y3)
+    {
+        m_points.add(point_d(x1, y1));
+        recursive_bezier(x1, y1, x2, y2, x3, y3, 0);
+        m_points.add(point_d(x3, y3));
+    }
+
+
+
+
+
+    //------------------------------------------------------------------------
+    void curve4_inc::approximation_scale(double s) 
+    { 
+        m_scale = s;
+    }
+
+    //------------------------------------------------------------------------
+    double curve4_inc::approximation_scale() const 
+    { 
+        return m_scale;
+    }
+
+#if defined(_MSC_VER) && _MSC_VER <= 1200
+    //------------------------------------------------------------------------
+    static double MSC60_fix_ICE(double v) { return v; }
+#endif
+
+    //------------------------------------------------------------------------
+    void curve4_inc::init(double x1, double y1, 
+                          double x2, double y2, 
+                          double x3, double y3,
+                          double x4, double y4)
+    {
+        m_start_x = x1;
+        m_start_y = y1;
+        m_end_x   = x4;
+        m_end_y   = y4;
+
+        double dx1 = x2 - x1;
+        double dy1 = y2 - y1;
+        double dx2 = x3 - x2;
+        double dy2 = y3 - y2;
+        double dx3 = x4 - x3;
+        double dy3 = y4 - y3;
+
+        double len = (sqrt(dx1 * dx1 + dy1 * dy1) + 
+                      sqrt(dx2 * dx2 + dy2 * dy2) + 
+                      sqrt(dx3 * dx3 + dy3 * dy3)) * 0.25 * m_scale;
+
+#if defined(_MSC_VER) && _MSC_VER <= 1200
+        m_num_steps = uround(MSC60_fix_ICE(len));
+#else
+        m_num_steps = uround(len);
+#endif
+
+        if(m_num_steps < 4)
+        {
+            m_num_steps = 4;   
+        }
+
+        double subdivide_step  = 1.0 / m_num_steps;
+        double subdivide_step2 = subdivide_step * subdivide_step;
+        double subdivide_step3 = subdivide_step * subdivide_step * subdivide_step;
+
+        double pre1 = 3.0 * subdivide_step;
+        double pre2 = 3.0 * subdivide_step2;
+        double pre4 = 6.0 * subdivide_step2;
+        double pre5 = 6.0 * subdivide_step3;
+	
+        double tmp1x = x1 - x2 * 2.0 + x3;
+        double tmp1y = y1 - y2 * 2.0 + y3;
+
+        double tmp2x = (x2 - x3) * 3.0 - x1 + x4;
+        double tmp2y = (y2 - y3) * 3.0 - y1 + y4;
+
+        m_saved_fx = m_fx = x1;
+        m_saved_fy = m_fy = y1;
+
+        m_saved_dfx = m_dfx = (x2 - x1) * pre1 + tmp1x * pre2 + tmp2x * subdivide_step3;
+        m_saved_dfy = m_dfy = (y2 - y1) * pre1 + tmp1y * pre2 + tmp2y * subdivide_step3;
+
+        m_saved_ddfx = m_ddfx = tmp1x * pre4 + tmp2x * pre5;
+        m_saved_ddfy = m_ddfy = tmp1y * pre4 + tmp2y * pre5;
+
+        m_dddfx = tmp2x * pre5;
+        m_dddfy = tmp2y * pre5;
+
+        m_step = m_num_steps;
+    }
+
+    //------------------------------------------------------------------------
+    void curve4_inc::rewind(unsigned)
+    {
+        if(m_num_steps == 0)
+        {
+            m_step = -1;
+            return;
+        }
+        m_step = m_num_steps;
+        m_fx   = m_saved_fx;
+        m_fy   = m_saved_fy;
+        m_dfx  = m_saved_dfx;
+        m_dfy  = m_saved_dfy;
+        m_ddfx = m_saved_ddfx;
+        m_ddfy = m_saved_ddfy;
+    }
+
+    //------------------------------------------------------------------------
+    unsigned curve4_inc::vertex(double* x, double* y)
+    {
+        if(m_step < 0) return path_cmd_stop;
+        if(m_step == m_num_steps)
+        {
+            *x = m_start_x;
+            *y = m_start_y;
+            --m_step;
+            return path_cmd_move_to;
+        }
+
+        if(m_step == 0)
+        {
+            *x = m_end_x;
+            *y = m_end_y;
+            --m_step;
+            return path_cmd_line_to;
+        }
+
+        m_fx   += m_dfx;
+        m_fy   += m_dfy;
+        m_dfx  += m_ddfx; 
+        m_dfy  += m_ddfy; 
+        m_ddfx += m_dddfx; 
+        m_ddfy += m_dddfy; 
+
+        *x = m_fx;
+        *y = m_fy;
+        --m_step;
+        return path_cmd_line_to;
+    }
+
+
+
+
+    //------------------------------------------------------------------------
+    void curve4_div::init(double x1, double y1, 
+                          double x2, double y2, 
+                          double x3, double y3,
+                          double x4, double y4)
+    {
+        m_points.remove_all();
+        m_distance_tolerance_square = 0.5 / m_approximation_scale;
+        m_distance_tolerance_square *= m_distance_tolerance_square;
+        bezier(x1, y1, x2, y2, x3, y3, x4, y4);
+        m_count = 0;
+    }
+
+    //------------------------------------------------------------------------
+    void curve4_div::recursive_bezier(double x1, double y1, 
+                                      double x2, double y2, 
+                                      double x3, double y3, 
+                                      double x4, double y4,
+                                      unsigned level)
+    {
+        if(level > curve_recursion_limit) 
+        {
+            return;
+        }
+
+        // Calculate all the mid-points of the line segments
+        //----------------------
+        double x12   = (x1 + x2) / 2;
+        double y12   = (y1 + y2) / 2;
+        double x23   = (x2 + x3) / 2;
+        double y23   = (y2 + y3) / 2;
+        double x34   = (x3 + x4) / 2;
+        double y34   = (y3 + y4) / 2;
+        double x123  = (x12 + x23) / 2;
+        double y123  = (y12 + y23) / 2;
+        double x234  = (x23 + x34) / 2;
+        double y234  = (y23 + y34) / 2;
+        double x1234 = (x123 + x234) / 2;
+        double y1234 = (y123 + y234) / 2;
+
+
+        // Try to approximate the full cubic curve by a single straight line
+        //------------------
+        double dx = x4-x1;
+        double dy = y4-y1;
+
+        double d2 = fabs(((x2 - x4) * dy - (y2 - y4) * dx));
+        double d3 = fabs(((x3 - x4) * dy - (y3 - y4) * dx));
+        double da1, da2, k;
+
+        switch((int(d2 > curve_collinearity_epsilon) << 1) +
+                int(d3 > curve_collinearity_epsilon))
+        {
+        case 0:
+            // All collinear OR p1==p4
+            //----------------------
+            k = dx*dx + dy*dy;
+            if(k == 0)
+            {
+                d2 = calc_sq_distance(x1, y1, x2, y2);
+                d3 = calc_sq_distance(x4, y4, x3, y3);
+            }
+            else
+            {
+                k   = 1 / k;
+                da1 = x2 - x1;
+                da2 = y2 - y1;
+                d2  = k * (da1*dx + da2*dy);
+                da1 = x3 - x1;
+                da2 = y3 - y1;
+                d3  = k * (da1*dx + da2*dy);
+                if(d2 > 0 && d2 < 1 && d3 > 0 && d3 < 1)
+                {
+                    // Simple collinear case, 1---2---3---4
+                    // We can leave just two endpoints
+                    return;
+                }
+                     if(d2 <= 0) d2 = calc_sq_distance(x2, y2, x1, y1);
+                else if(d2 >= 1) d2 = calc_sq_distance(x2, y2, x4, y4);
+                else             d2 = calc_sq_distance(x2, y2, x1 + d2*dx, y1 + d2*dy);
+
+                     if(d3 <= 0) d3 = calc_sq_distance(x3, y3, x1, y1);
+                else if(d3 >= 1) d3 = calc_sq_distance(x3, y3, x4, y4);
+                else             d3 = calc_sq_distance(x3, y3, x1 + d3*dx, y1 + d3*dy);
+            }
+            if(d2 > d3)
+            {
+                if(d2 < m_distance_tolerance_square)
+                {
+                    m_points.add(point_d(x2, y2));
+                    return;
+                }
+            }
+            else
+            {
+                if(d3 < m_distance_tolerance_square)
+                {
+                    m_points.add(point_d(x3, y3));
+                    return;
+                }
+            }
+            break;
+
+        case 1:
+            // p1,p2,p4 are collinear, p3 is significant
+            //----------------------
+            if(d3 * d3 <= m_distance_tolerance_square * (dx*dx + dy*dy))
+            {
+                if(m_angle_tolerance < curve_angle_tolerance_epsilon)
+                {
+                    m_points.add(point_d(x23, y23));
+                    return;
+                }
+
+                // Angle Condition
+                //----------------------
+                da1 = fabs(atan2(y4 - y3, x4 - x3) - atan2(y3 - y2, x3 - x2));
+                if(da1 >= pi) da1 = 2*pi - da1;
+
+                if(da1 < m_angle_tolerance)
+                {
+                    m_points.add(point_d(x2, y2));
+                    m_points.add(point_d(x3, y3));
+                    return;
+                }
+
+                if(m_cusp_limit != 0.0)
+                {
+                    if(da1 > m_cusp_limit)
+                    {
+                        m_points.add(point_d(x3, y3));
+                        return;
+                    }
+                }
+            }
+            break;
+
+        case 2:
+            // p1,p3,p4 are collinear, p2 is significant
+            //----------------------
+            if(d2 * d2 <= m_distance_tolerance_square * (dx*dx + dy*dy))
+            {
+                if(m_angle_tolerance < curve_angle_tolerance_epsilon)
+                {
+                    m_points.add(point_d(x23, y23));
+                    return;
+                }
+
+                // Angle Condition
+                //----------------------
+                da1 = fabs(atan2(y3 - y2, x3 - x2) - atan2(y2 - y1, x2 - x1));
+                if(da1 >= pi) da1 = 2*pi - da1;
+
+                if(da1 < m_angle_tolerance)
+                {
+                    m_points.add(point_d(x2, y2));
+                    m_points.add(point_d(x3, y3));
+                    return;
+                }
+
+                if(m_cusp_limit != 0.0)
+                {
+                    if(da1 > m_cusp_limit)
+                    {
+                        m_points.add(point_d(x2, y2));
+                        return;
+                    }
+                }
+            }
+            break;
+
+        case 3: 
+            // Regular case
+            //-----------------
+            if((d2 + d3)*(d2 + d3) <= m_distance_tolerance_square * (dx*dx + dy*dy))
+            {
+                // If the curvature doesn't exceed the distance_tolerance value
+                // we tend to finish subdivisions.
+                //----------------------
+                if(m_angle_tolerance < curve_angle_tolerance_epsilon)
+                {
+                    m_points.add(point_d(x23, y23));
+                    return;
+                }
+
+                // Angle & Cusp Condition
+                //----------------------
+                k   = atan2(y3 - y2, x3 - x2);
+                da1 = fabs(k - atan2(y2 - y1, x2 - x1));
+                da2 = fabs(atan2(y4 - y3, x4 - x3) - k);
+                if(da1 >= pi) da1 = 2*pi - da1;
+                if(da2 >= pi) da2 = 2*pi - da2;
+
+                if(da1 + da2 < m_angle_tolerance)
+                {
+                    // Finally we can stop the recursion
+                    //----------------------
+                    m_points.add(point_d(x23, y23));
+                    return;
+                }
+
+                if(m_cusp_limit != 0.0)
+                {
+                    if(da1 > m_cusp_limit)
+                    {
+                        m_points.add(point_d(x2, y2));
+                        return;
+                    }
+
+                    if(da2 > m_cusp_limit)
+                    {
+                        m_points.add(point_d(x3, y3));
+                        return;
+                    }
+                }
+            }
+            break;
+        }
+
+        // Continue subdivision
+        //----------------------
+        recursive_bezier(x1, y1, x12, y12, x123, y123, x1234, y1234, level + 1); 
+        recursive_bezier(x1234, y1234, x234, y234, x34, y34, x4, y4, level + 1); 
+    }
+
+    //------------------------------------------------------------------------
+    void curve4_div::bezier(double x1, double y1, 
+                            double x2, double y2, 
+                            double x3, double y3, 
+                            double x4, double y4)
+    {
+        m_points.add(point_d(x1, y1));
+        recursive_bezier(x1, y1, x2, y2, x3, y3, x4, y4, 0);
+        m_points.add(point_d(x4, y4));
+    }
+
+}
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_image_filters.cpp b/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_image_filters.cpp
new file mode 100644
index 0000000000..549d9adbf5
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_image_filters.cpp
@@ -0,0 +1,103 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Filtering class image_filter_lut implemantation
+//
+//----------------------------------------------------------------------------
+
+
+#include "agg_image_filters.h"
+
+
+namespace agg
+{
+    //--------------------------------------------------------------------
+    void image_filter_lut::realloc_lut(double radius)
+    {
+        m_radius = radius;
+        m_diameter = uceil(radius) * 2;
+        m_start = -int(m_diameter / 2 - 1);
+        unsigned size = m_diameter << image_subpixel_shift;
+        if(size > m_weight_array.size())
+        {
+            m_weight_array.resize(size);
+        }
+    }
+
+
+
+    //--------------------------------------------------------------------
+    // This function normalizes integer values and corrects the rounding 
+    // errors. It doesn't do anything with the source floating point values
+    // (m_weight_array_dbl), it corrects only integers according to the rule 
+    // of 1.0 which means that any sum of pixel weights must be equal to 1.0.
+    // So, the filter function must produce a graph of the proper shape.
+    //--------------------------------------------------------------------
+    void image_filter_lut::normalize()
+    {
+        unsigned i;
+        int flip = 1;
+
+        for(i = 0; i < image_subpixel_scale; i++)
+        {
+            for(;;)
+            {
+                int sum = 0;
+                unsigned j;
+                for(j = 0; j < m_diameter; j++)
+                {
+                    sum += m_weight_array[j * image_subpixel_scale + i];
+                }
+
+                if(sum == image_filter_scale) break;
+
+                double k = double(image_filter_scale) / double(sum);
+                sum = 0;
+                for(j = 0; j < m_diameter; j++)
+                {
+                    sum +=     m_weight_array[j * image_subpixel_scale + i] = 
+                        iround(m_weight_array[j * image_subpixel_scale + i] * k);
+                }
+
+                sum -= image_filter_scale;
+                int inc = (sum > 0) ? -1 : 1;
+
+                for(j = 0; j < m_diameter && sum; j++)
+                {
+                    flip ^= 1;
+                    unsigned idx = flip ? m_diameter/2 + j/2 : m_diameter/2 - j/2;
+                    int v = m_weight_array[idx * image_subpixel_scale + i];
+                    if(v < image_filter_scale)
+                    {
+                        m_weight_array[idx * image_subpixel_scale + i] += inc;
+                        sum += inc;
+                    }
+                }
+            }
+        }
+
+        unsigned pivot = m_diameter << (image_subpixel_shift - 1);
+
+        for(i = 0; i < pivot; i++)
+        {
+            m_weight_array[pivot + i] = m_weight_array[pivot - i];
+        }
+        unsigned end = (diameter() << image_subpixel_shift) - 1;
+        m_weight_array[0] = m_weight_array[end];
+    }
+
+
+}
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_trans_affine.cpp b/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_trans_affine.cpp
new file mode 100644
index 0000000000..99febc953a
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_trans_affine.cpp
@@ -0,0 +1,194 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Affine transformations
+//
+//----------------------------------------------------------------------------
+#include "agg_trans_affine.h"
+
+
+
+namespace agg
+{
+
+    //------------------------------------------------------------------------
+    const trans_affine& trans_affine::parl_to_parl(const double* src, 
+                                                   const double* dst)
+    {
+        sx  = src[2] - src[0];
+        shy = src[3] - src[1];
+        shx = src[4] - src[0];
+        sy  = src[5] - src[1];
+        tx  = src[0];
+        ty  = src[1];
+        invert();
+        multiply(trans_affine(dst[2] - dst[0], dst[3] - dst[1], 
+                              dst[4] - dst[0], dst[5] - dst[1],
+                              dst[0], dst[1]));
+        return *this;
+    }
+
+    //------------------------------------------------------------------------
+    const trans_affine& trans_affine::rect_to_parl(double x1, double y1, 
+                                                   double x2, double y2, 
+                                                   const double* parl)
+    {
+        double src[6];
+        src[0] = x1; src[1] = y1;
+        src[2] = x2; src[3] = y1;
+        src[4] = x2; src[5] = y2;
+        parl_to_parl(src, parl);
+        return *this;
+    }
+
+    //------------------------------------------------------------------------
+    const trans_affine& trans_affine::parl_to_rect(const double* parl, 
+                                                   double x1, double y1, 
+                                                   double x2, double y2)
+    {
+        double dst[6];
+        dst[0] = x1; dst[1] = y1;
+        dst[2] = x2; dst[3] = y1;
+        dst[4] = x2; dst[5] = y2;
+        parl_to_parl(parl, dst);
+        return *this;
+    }
+
+    //------------------------------------------------------------------------
+    const trans_affine& trans_affine::multiply(const trans_affine& m)
+    {
+        double t0 = sx  * m.sx + shy * m.shx;
+        double t2 = shx * m.sx + sy  * m.shx;
+        double t4 = tx  * m.sx + ty  * m.shx + m.tx;
+        shy = sx  * m.shy + shy * m.sy;
+        sy  = shx * m.shy + sy  * m.sy;
+        ty  = tx  * m.shy + ty  * m.sy + m.ty;
+        sx  = t0;
+        shx = t2;
+        tx  = t4;
+        return *this;
+    }
+
+
+    //------------------------------------------------------------------------
+    const trans_affine& trans_affine::invert()
+    {
+        double d  = determinant_reciprocal();
+
+        double t0  =  sy  * d;
+               sy  =  sx  * d;
+               shy = -shy * d;
+               shx = -shx * d;
+
+        double t4 = -tx * t0  - ty * shx;
+               ty = -tx * shy - ty * sy;
+
+        sx = t0;
+        tx = t4;
+        return *this;
+    }
+
+
+   //------------------------------------------------------------------------
+    const trans_affine& trans_affine::flip_x()
+    {
+        sx  = -sx;
+        shy = -shy;
+        tx  = -tx;
+        return *this;
+    }
+
+    //------------------------------------------------------------------------
+    const trans_affine& trans_affine::flip_y()
+    {
+        shx = -shx;
+        sy  = -sy;
+        ty  = -ty;
+        return *this;
+    }
+
+    //------------------------------------------------------------------------
+    const trans_affine& trans_affine::reset()
+    {
+        sx  = sy  = 1.0; 
+        shy = shx = tx = ty = 0.0;
+        return *this;
+    }
+
+    //------------------------------------------------------------------------
+    bool trans_affine::is_identity(double epsilon) const
+    {
+        return is_equal_eps(sx,  1.0, epsilon) &&
+               is_equal_eps(shy, 0.0, epsilon) &&
+               is_equal_eps(shx, 0.0, epsilon) && 
+               is_equal_eps(sy,  1.0, epsilon) &&
+               is_equal_eps(tx,  0.0, epsilon) &&
+               is_equal_eps(ty,  0.0, epsilon);
+    }
+
+    //------------------------------------------------------------------------
+    bool trans_affine::is_valid(double epsilon) const
+    {
+        return fabs(sx) > epsilon && fabs(sy) > epsilon;
+    }
+
+    //------------------------------------------------------------------------
+    bool trans_affine::is_equal(const trans_affine& m, double epsilon) const
+    {
+        return is_equal_eps(sx,  m.sx,  epsilon) &&
+               is_equal_eps(shy, m.shy, epsilon) &&
+               is_equal_eps(shx, m.shx, epsilon) && 
+               is_equal_eps(sy,  m.sy,  epsilon) &&
+               is_equal_eps(tx,  m.tx,  epsilon) &&
+               is_equal_eps(ty,  m.ty,  epsilon);
+    }
+
+    //------------------------------------------------------------------------
+    double trans_affine::rotation() const
+    {
+        double x1 = 0.0;
+        double y1 = 0.0;
+        double x2 = 1.0;
+        double y2 = 0.0;
+        transform(&x1, &y1);
+        transform(&x2, &y2);
+        return atan2(y2-y1, x2-x1);
+    }
+
+    //------------------------------------------------------------------------
+    void trans_affine::translation(double* dx, double* dy) const
+    {
+        *dx = tx;
+        *dy = ty;
+    }
+
+    //------------------------------------------------------------------------
+    void trans_affine::scaling(double* x, double* y) const
+    {
+        double x1 = 0.0;
+        double y1 = 0.0;
+        double x2 = 1.0;
+        double y2 = 1.0;
+        trans_affine t(*this);
+        t *= trans_affine_rotation(-rotation());
+        t.transform(&x1, &y1);
+        t.transform(&x2, &y2);
+        *x = x2 - x1;
+        *y = y2 - y1;
+    }
+
+
+}
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_vcgen_contour.cpp b/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_vcgen_contour.cpp
new file mode 100644
index 0000000000..a6a99405ad
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_vcgen_contour.cpp
@@ -0,0 +1,165 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Contour generator
+//
+//----------------------------------------------------------------------------
+
+#include <math.h>
+#include "agg_vcgen_contour.h"
+
+namespace agg
+{
+
+    //------------------------------------------------------------------------
+    vcgen_contour::vcgen_contour() :
+        m_stroker(),
+        m_width(1),
+        m_src_vertices(),
+        m_out_vertices(),
+        m_status(initial),
+        m_src_vertex(0),
+        m_closed(0),
+        m_orientation(0),
+        m_auto_detect(false)
+    {
+    }
+
+    //------------------------------------------------------------------------
+    void vcgen_contour::remove_all()
+    {
+        m_src_vertices.remove_all();
+        m_closed = 0;
+        m_orientation = 0;
+        m_status = initial;
+    }
+
+    //------------------------------------------------------------------------
+    void vcgen_contour::add_vertex(double x, double y, unsigned cmd)
+    {
+        m_status = initial;
+        if(is_move_to(cmd))
+        {
+            m_src_vertices.modify_last(vertex_dist(x, y));
+        }
+        else
+        {
+            if(is_vertex(cmd))
+            {
+                m_src_vertices.add(vertex_dist(x, y));
+            }
+            else
+            {
+                if(is_end_poly(cmd))
+                {
+                    m_closed = get_close_flag(cmd);
+                    if(m_orientation == path_flags_none) 
+                    {
+                        m_orientation = get_orientation(cmd);
+                    }
+                }
+            }
+        }
+    }
+
+    //------------------------------------------------------------------------
+    void vcgen_contour::rewind(unsigned)
+    {
+        if(m_status == initial)
+        {
+            m_src_vertices.close(true);
+            if(m_auto_detect)
+            {
+                if(!is_oriented(m_orientation))
+                {
+                    m_orientation = (calc_polygon_area(m_src_vertices) > 0.0) ? 
+                                    path_flags_ccw : 
+                                    path_flags_cw;
+                }
+            }
+            if(is_oriented(m_orientation))
+            {
+                m_stroker.width(is_ccw(m_orientation) ? m_width : -m_width);
+            }
+        }
+        m_status = ready;
+        m_src_vertex = 0;
+    }
+
+    //------------------------------------------------------------------------
+    unsigned vcgen_contour::vertex(double* x, double* y)
+    {
+        unsigned cmd = path_cmd_line_to;
+        while(!is_stop(cmd))
+        {
+            switch(m_status)
+            {
+            case initial:
+                rewind(0);
+
+            case ready:
+                if(m_src_vertices.size() < 2 + unsigned(m_closed != 0))
+                {
+                    cmd = path_cmd_stop;
+                    break;
+                }
+                m_status = outline;
+                cmd = path_cmd_move_to;
+                m_src_vertex = 0;
+                m_out_vertex = 0;
+
+            case outline:
+                if(m_src_vertex >= m_src_vertices.size())
+                {
+                    m_status = end_poly;
+                    break;
+                }
+                m_stroker.calc_join(m_out_vertices, 
+                                    m_src_vertices.prev(m_src_vertex), 
+                                    m_src_vertices.curr(m_src_vertex), 
+                                    m_src_vertices.next(m_src_vertex), 
+                                    m_src_vertices.prev(m_src_vertex).dist,
+                                    m_src_vertices.curr(m_src_vertex).dist);
+                ++m_src_vertex;
+                m_status = out_vertices;
+                m_out_vertex = 0;
+
+            case out_vertices:
+                if(m_out_vertex >= m_out_vertices.size())
+                {
+                    m_status = outline;
+                }
+                else
+                {
+                    const point_d& c = m_out_vertices[m_out_vertex++];
+                    *x = c.x;
+                    *y = c.y;
+                    return cmd;
+                }
+                break;
+
+            case end_poly:
+                if(!m_closed) return path_cmd_stop;
+                m_status = stop;
+                return path_cmd_end_poly | path_flags_close | path_flags_ccw;
+
+            case stop:
+                return path_cmd_stop;
+            }
+        }
+        return cmd;
+    }
+
+}
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_vcgen_dash.cpp b/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_vcgen_dash.cpp
new file mode 100644
index 0000000000..129505786c
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_vcgen_dash.cpp
@@ -0,0 +1,235 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Line dash generator
+//
+//----------------------------------------------------------------------------
+
+#include <math.h>
+#include "agg_vcgen_dash.h"
+#include "agg_shorten_path.h"
+
+namespace agg
+{
+
+    //------------------------------------------------------------------------
+    vcgen_dash::vcgen_dash() :
+        m_total_dash_len(0.0),
+        m_num_dashes(0),
+        m_dash_start(0.0),
+        m_shorten(0.0),
+        m_curr_dash_start(0.0),
+        m_curr_dash(0),
+        m_src_vertices(),
+        m_closed(0),
+        m_status(initial),
+        m_src_vertex(0)
+    {
+    }
+
+
+
+    //------------------------------------------------------------------------
+    void vcgen_dash::remove_all_dashes()
+    {
+        m_total_dash_len = 0.0;
+        m_num_dashes = 0;
+        m_curr_dash_start = 0.0;
+        m_curr_dash = 0;
+    }
+
+
+    //------------------------------------------------------------------------
+    void vcgen_dash::add_dash(double dash_len, double gap_len)
+    {
+        if(m_num_dashes < max_dashes)
+        {
+            m_total_dash_len += dash_len + gap_len;
+            m_dashes[m_num_dashes++] = dash_len;
+            m_dashes[m_num_dashes++] = gap_len;
+        }
+    }
+
+
+    //------------------------------------------------------------------------
+    void vcgen_dash::dash_start(double ds)
+    {
+        m_dash_start = ds;
+        calc_dash_start(fabs(ds));
+    }
+
+
+    //------------------------------------------------------------------------
+    void vcgen_dash::calc_dash_start(double ds)
+    {
+        m_curr_dash = 0;
+        m_curr_dash_start = 0.0;
+        while(ds > 0.0)
+        {
+            if(ds > m_dashes[m_curr_dash])
+            {
+                ds -= m_dashes[m_curr_dash];
+                ++m_curr_dash;
+                m_curr_dash_start = 0.0;
+                if(m_curr_dash >= m_num_dashes) m_curr_dash = 0;
+            }
+            else
+            {
+                m_curr_dash_start = ds;
+                ds = 0.0;
+            }
+        }
+    }
+
+
+    //------------------------------------------------------------------------
+    void vcgen_dash::remove_all()
+    {
+        m_status = initial;
+        m_src_vertices.remove_all();
+        m_closed = 0;
+    }
+
+
+    //------------------------------------------------------------------------
+    void vcgen_dash::add_vertex(double x, double y, unsigned cmd)
+    {
+        m_status = initial;
+        if(is_move_to(cmd))
+        {
+            m_src_vertices.modify_last(vertex_dist(x, y));
+        }
+        else
+        {
+            if(is_vertex(cmd))
+            {
+                m_src_vertices.add(vertex_dist(x, y));
+            }
+            else
+            {
+                m_closed = get_close_flag(cmd);
+            }
+        }
+    }
+
+
+    //------------------------------------------------------------------------
+    void vcgen_dash::rewind(unsigned)
+    {
+        if(m_status == initial)
+        {
+            m_src_vertices.close(m_closed != 0);
+            shorten_path(m_src_vertices, m_shorten, m_closed);
+        }
+        m_status = ready;
+        m_src_vertex = 0;
+    }
+
+
+    //------------------------------------------------------------------------
+    unsigned vcgen_dash::vertex(double* x, double* y)
+    {
+        unsigned cmd = path_cmd_move_to;
+        while(!is_stop(cmd))
+        {
+            switch(m_status)
+            {
+            case initial:
+                rewind(0);
+
+            case ready:
+                if(m_num_dashes < 2 || m_src_vertices.size() < 2)
+                {
+                    cmd = path_cmd_stop;
+                    break;
+                }
+                m_status = polyline;
+                m_src_vertex = 1;
+                m_v1 = &m_src_vertices[0];
+                m_v2 = &m_src_vertices[1];
+                m_curr_rest = m_v1->dist;
+                *x = m_v1->x;
+                *y = m_v1->y;
+                if(m_dash_start >= 0.0) calc_dash_start(m_dash_start);
+                return path_cmd_move_to;
+
+            case polyline:
+                {
+                    double dash_rest = m_dashes[m_curr_dash] - m_curr_dash_start;
+
+                    unsigned cmd = (m_curr_dash & 1) ? 
+                                   path_cmd_move_to : 
+                                   path_cmd_line_to;
+
+                    if(m_curr_rest > dash_rest)
+                    {
+                        m_curr_rest -= dash_rest;
+                        ++m_curr_dash;
+                        if(m_curr_dash >= m_num_dashes) m_curr_dash = 0;
+                        m_curr_dash_start = 0.0;
+                        *x = m_v2->x - (m_v2->x - m_v1->x) * m_curr_rest / m_v1->dist;
+                        *y = m_v2->y - (m_v2->y - m_v1->y) * m_curr_rest / m_v1->dist;
+                    }
+                    else
+                    {
+                        m_curr_dash_start += m_curr_rest;
+                        *x = m_v2->x;
+                        *y = m_v2->y;
+                        ++m_src_vertex;
+                        m_v1 = m_v2;
+                        m_curr_rest = m_v1->dist;
+                        if(m_closed)
+                        {
+                            if(m_src_vertex > m_src_vertices.size())
+                            {
+                                m_status = stop;
+                            }
+                            else
+                            {
+                                m_v2 = &m_src_vertices
+                                [
+                                    (m_src_vertex >= m_src_vertices.size()) ? 0 : 
+                                    m_src_vertex
+                                ];
+                            }
+                        }
+                        else
+                        {
+                            if(m_src_vertex >= m_src_vertices.size())
+                            {
+                                m_status = stop;
+                            }
+                            else
+                            {
+                                m_v2 = &m_src_vertices[m_src_vertex];
+                            }
+                        }
+                    }
+                    return cmd;
+                }
+                break;
+
+            case stop:
+                cmd = path_cmd_stop;
+                break;
+            }
+
+        }
+        return path_cmd_stop;
+    }
+
+
+}
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_vcgen_stroke.cpp b/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_vcgen_stroke.cpp
new file mode 100644
index 0000000000..2dae3e122b
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_vcgen_stroke.cpp
@@ -0,0 +1,213 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Stroke generator
+//
+//----------------------------------------------------------------------------
+#include <math.h>
+#include "agg_vcgen_stroke.h"
+#include "agg_shorten_path.h"
+
+namespace agg
+{
+
+    //------------------------------------------------------------------------
+    vcgen_stroke::vcgen_stroke() :
+        m_stroker(),
+        m_src_vertices(),
+        m_out_vertices(),
+        m_shorten(0.0),
+        m_closed(0),
+        m_status(initial),
+        m_src_vertex(0),
+        m_out_vertex(0)
+    {
+    }
+
+    //------------------------------------------------------------------------
+    void vcgen_stroke::remove_all()
+    {
+        m_src_vertices.remove_all();
+        m_closed = 0;
+        m_status = initial;
+    }
+
+
+    //------------------------------------------------------------------------
+    void vcgen_stroke::add_vertex(double x, double y, unsigned cmd)
+    {
+        m_status = initial;
+        if(is_move_to(cmd))
+        {
+            m_src_vertices.modify_last(vertex_dist(x, y));
+        }
+        else
+        {
+            if(is_vertex(cmd))
+            {
+                m_src_vertices.add(vertex_dist(x, y));
+            }
+            else
+            {
+                m_closed = get_close_flag(cmd);
+            }
+        }
+    }
+
+    //------------------------------------------------------------------------
+    void vcgen_stroke::rewind(unsigned)
+    {
+        if(m_status == initial)
+        {
+            m_src_vertices.close(m_closed != 0);
+            shorten_path(m_src_vertices, m_shorten, m_closed);
+            if(m_src_vertices.size() < 3) m_closed = 0;
+        }
+        m_status = ready;
+        m_src_vertex = 0;
+        m_out_vertex = 0;
+    }
+
+
+    //------------------------------------------------------------------------
+    unsigned vcgen_stroke::vertex(double* x, double* y)
+    {
+        unsigned cmd = path_cmd_line_to;
+        while(!is_stop(cmd))
+        {
+            switch(m_status)
+            {
+            case initial:
+                rewind(0);
+
+            case ready:
+                if(m_src_vertices.size() < 2 + unsigned(m_closed != 0))
+                {
+                    cmd = path_cmd_stop;
+                    break;
+                }
+                m_status = m_closed ? outline1 : cap1;
+                cmd = path_cmd_move_to;
+                m_src_vertex = 0;
+                m_out_vertex = 0;
+                break;
+
+            case cap1:
+                m_stroker.calc_cap(m_out_vertices,
+                                   m_src_vertices[0], 
+                                   m_src_vertices[1], 
+                                   m_src_vertices[0].dist);
+                m_src_vertex = 1;
+                m_prev_status = outline1;
+                m_status = out_vertices;
+                m_out_vertex = 0;
+                break;
+
+            case cap2:
+                m_stroker.calc_cap(m_out_vertices,
+                                   m_src_vertices[m_src_vertices.size() - 1], 
+                                   m_src_vertices[m_src_vertices.size() - 2], 
+                                   m_src_vertices[m_src_vertices.size() - 2].dist);
+                m_prev_status = outline2;
+                m_status = out_vertices;
+                m_out_vertex = 0;
+                break;
+
+            case outline1:
+                if(m_closed)
+                {
+                    if(m_src_vertex >= m_src_vertices.size())
+                    {
+                        m_prev_status = close_first;
+                        m_status = end_poly1;
+                        break;
+                    }
+                }
+                else
+                {
+                    if(m_src_vertex >= m_src_vertices.size() - 1)
+                    {
+                        m_status = cap2;
+                        break;
+                    }
+                }
+                m_stroker.calc_join(m_out_vertices, 
+                                    m_src_vertices.prev(m_src_vertex), 
+                                    m_src_vertices.curr(m_src_vertex), 
+                                    m_src_vertices.next(m_src_vertex), 
+                                    m_src_vertices.prev(m_src_vertex).dist,
+                                    m_src_vertices.curr(m_src_vertex).dist);
+                ++m_src_vertex;
+                m_prev_status = m_status;
+                m_status = out_vertices;
+                m_out_vertex = 0;
+                break;
+
+            case close_first:
+                m_status = outline2;
+                cmd = path_cmd_move_to;
+
+            case outline2:
+                if(m_src_vertex <= unsigned(m_closed == 0))
+                {
+                    m_status = end_poly2;
+                    m_prev_status = stop;
+                    break;
+                }
+
+                --m_src_vertex;
+                m_stroker.calc_join(m_out_vertices,
+                                    m_src_vertices.next(m_src_vertex), 
+                                    m_src_vertices.curr(m_src_vertex), 
+                                    m_src_vertices.prev(m_src_vertex), 
+                                    m_src_vertices.curr(m_src_vertex).dist, 
+                                    m_src_vertices.prev(m_src_vertex).dist);
+
+                m_prev_status = m_status;
+                m_status = out_vertices;
+                m_out_vertex = 0;
+                break;
+
+            case out_vertices:
+                if(m_out_vertex >= m_out_vertices.size())
+                {
+                    m_status = m_prev_status;
+                }
+                else
+                {
+                    const point_d& c = m_out_vertices[m_out_vertex++];
+                    *x = c.x;
+                    *y = c.y;
+                    return cmd;
+                }
+                break;
+
+            case end_poly1:
+                m_status = m_prev_status;
+                return path_cmd_end_poly | path_flags_close | path_flags_ccw;
+
+            case end_poly2:
+                m_status = m_prev_status;
+                return path_cmd_end_poly | path_flags_close | path_flags_cw;
+
+            case stop:
+                cmd = path_cmd_stop;
+                break;
+            }
+        }
+        return cmd;
+    }
+
+}
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_vpgen_segmentator.cpp b/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_vpgen_segmentator.cpp
new file mode 100644
index 0000000000..49a45b6b13
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/src/agg_vpgen_segmentator.cpp
@@ -0,0 +1,67 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#include <math.h>
+#include "agg_vpgen_segmentator.h"
+
+namespace agg
+{
+
+    void vpgen_segmentator::move_to(double x, double y)
+    {
+        m_x1 = x;
+        m_y1 = y;
+        m_dx = 0.0;
+        m_dy = 0.0;
+        m_dl = 2.0;
+        m_ddl = 2.0;
+        m_cmd = path_cmd_move_to;
+    }
+
+    void vpgen_segmentator::line_to(double x, double y)
+    {
+        m_x1 += m_dx;
+        m_y1 += m_dy;
+        m_dx  = x - m_x1;
+        m_dy  = y - m_y1;
+        double len = sqrt(m_dx * m_dx + m_dy * m_dy) * m_approximation_scale;
+        if(len < 1e-30) len = 1e-30;
+        m_ddl = 1.0 / len;
+        m_dl  = (m_cmd == path_cmd_move_to) ? 0.0 : m_ddl;
+        if(m_cmd == path_cmd_stop) m_cmd = path_cmd_line_to;
+    }
+
+    unsigned vpgen_segmentator::vertex(double* x, double* y)
+    {
+        if(m_cmd == path_cmd_stop) return path_cmd_stop;
+
+        unsigned cmd = m_cmd;
+        m_cmd = path_cmd_line_to;
+        if(m_dl >= 1.0 - m_ddl)
+        {
+            m_dl = 1.0;
+            m_cmd = path_cmd_stop;
+            *x = m_x1 + m_dx;
+            *y = m_y1 + m_dy;
+            return cmd;
+        }
+        *x = m_x1 + m_dx * m_dl;
+        *y = m_y1 + m_dy * m_dl;
+        m_dl += m_ddl;
+        return cmd;
+    }
+
+}
+
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/src/authors b/contrib/python/matplotlib/py2/extern/agg24-svn/src/authors
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/src/authors
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/src/copying b/contrib/python/matplotlib/py2/extern/agg24-svn/src/copying
new file mode 100644
index 0000000000..a08de15faa
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/src/copying
@@ -0,0 +1,11 @@
+The Anti-Grain Geometry Project
+A high quality rendering engine for C++
+http://antigrain.com
+
+Anti-Grain Geometry - Version 2.4 
+Copyright (C) 2002-2005 Maxim Shemanarev (McSeem) 
+
+Permission to copy, use, modify, sell and distribute this software 
+is granted provided this copyright notice appears in all copies. 
+This software is provided "as is" without express or implied
+warranty, and with no claim as to its suitability for any purpose.
diff --git a/contrib/python/matplotlib/py2/extern/agg24-svn/ya.make b/contrib/python/matplotlib/py2/extern/agg24-svn/ya.make
new file mode 100644
index 0000000000..b8e286b07c
--- /dev/null
+++ b/contrib/python/matplotlib/py2/extern/agg24-svn/ya.make
@@ -0,0 +1,22 @@
+LIBRARY()
+
+LICENSE(PSF-2.0)
+
+ADDINCL(
+    contrib/python/matplotlib/py2/extern/agg24-svn/include
+)
+
+NO_COMPILER_WARNINGS()
+
+SRCS(
+    src/agg_bezier_arc.cpp
+    src/agg_curves.cpp
+    src/agg_image_filters.cpp
+    src/agg_trans_affine.cpp
+    src/agg_vcgen_contour.cpp
+    src/agg_vcgen_dash.cpp
+    src/agg_vcgen_stroke.cpp
+    src/agg_vpgen_segmentator.cpp
+)
+
+END()