precommit

.pre-commit-config.yaml

@@ -0,0 +1,16 @@
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+repos:
+    - repo: https://github.com/pre-commit/pre-commit-hooks
+      rev: v4.3.0
+      hooks:
+          - id: trailing-whitespace
+            files: ^.*\.cmake|CMakeLists\.txt$
+          - id: end-of-file-fixer
+            files: ^.*\.cmake|CMakeLists\.txt$
+            
+    - repo: https://github.com/pre-commit/mirrors-clang-format
+      rev: v14.0.6
+      hooks:
+          - id: clang-format
+            types_or: [c++, c]

deps/agg/include/agg_alpha_mask_u8.h

@@ -23,23 +23,18 @@
 #include "agg_basics.h"
 #include "agg_rendering_buffer.h"
 
-namespace agg
+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) 
+    static unsigned calculate(const int8u* p) { return (p[R] * 77 + p[G] * 150 + p[B] * 29) >> 8; }
-        { 
-            return (p[R]*77 + p[G]*150 + p[B]*29) >> 8; 
-        }
 };
 
 //==========================================================alpha_mask_u8
@@ -49,31 +44,26 @@ namespace agg
   public:
     typedef int8u cover_type;
     typedef alpha_mask_u8<Step, Offset, MaskF> self_type;
-        enum cover_scale_e
+    enum cover_scale_e { cover_shift = 8, cover_none = 0, cover_full = 255 };
-        { 
-            cover_shift = 8,
-            cover_none  = 0,
-            cover_full  = 255
-        };
 
-        alpha_mask_u8() : m_rbuf(0) {}
+    alpha_mask_u8()
-        explicit alpha_mask_u8(rendering_buffer& rbuf) : m_rbuf(&rbuf) {}
+        : 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 && 
+        if (x >= 0 && y >= 0 && x < (int)m_rbuf->width() && y < (int)m_rbuf->height())
-               x < (int)m_rbuf->width() && 
-               y < (int)m_rbuf->height())
         {
-                return (cover_type)m_mask_function.calculate(
+            return (cover_type)m_mask_function.calculate(m_rbuf->row_ptr(y) + x * Step + Offset);
-                                        m_rbuf->row_ptr(y) + x * Step + Offset);
         }
         return 0;
     }
@@ -81,19 +71,15 @@ namespace agg
     //--------------------------------------------------------------------
     cover_type combine_pixel(int x, int y, cover_type val) const
     {
-            if(x >= 0 && y >= 0 && 
+        if (x >= 0 && y >= 0 && x < (int)m_rbuf->width() && y < (int)m_rbuf->height())
-               x < (int)m_rbuf->width() && 
-               y < (int)m_rbuf->height())
         {
-                return (cover_type)((cover_full + val * 
+            return (
-                                     m_mask_function.calculate(
+              cover_type)((cover_full + val * m_mask_function.calculate(m_rbuf->row_ptr(y) + x * Step + Offset)) >>
-                                        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
     {
@@ -139,10 +125,8 @@ namespace agg
         {
             *covers++ = (cover_type)m_mask_function.calculate(mask);
             mask += Step;
+        } while (--count);
     }
-            while(--count);
-        }
-
 
     //--------------------------------------------------------------------
     void combine_hspan(int x, int y, cover_type* dst, int num_pix) const
@@ -187,13 +171,10 @@ namespace agg
         const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
         do
         {
-                *covers = (cover_type)((cover_full + (*covers) * 
+            *covers = (cover_type)((cover_full + (*covers) * m_mask_function.calculate(mask)) >> cover_shift);
-                                       m_mask_function.calculate(mask)) >> 
-                                       cover_shift);
             ++covers;
             mask += Step;
-            }
+        } while (--count);
-            while(--count);
     }
 
     //--------------------------------------------------------------------
@@ -241,8 +222,7 @@ namespace agg
         {
             *covers++ = (cover_type)m_mask_function.calculate(mask);
             mask += m_rbuf->stride();
-            }
+        } while (--count);
-            while(--count);
     }
 
     //--------------------------------------------------------------------
@@ -288,15 +268,11 @@ namespace agg
         const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
         do
         {
-                *covers = (cover_type)((cover_full + (*covers) * 
+            *covers = (cover_type)((cover_full + (*covers) * m_mask_function.calculate(mask)) >> cover_shift);
-                                       m_mask_function.calculate(mask)) >> 
-                                       cover_shift);
             ++covers;
             mask += m_rbuf->stride();
+        } while (--count);
     }
-            while(--count);
-        }
-
 
   private:
     alpha_mask_u8(const self_type&);
@@ -306,7 +282,6 @@ namespace agg
     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
@@ -344,8 +319,6 @@ namespace agg
 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
@@ -353,40 +326,33 @@ namespace agg
   public:
     typedef int8u cover_type;
     typedef amask_no_clip_u8<Step, Offset, MaskF> self_type;
-        enum cover_scale_e
+    enum cover_scale_e { cover_shift = 8, cover_none = 0, cover_full = 255 };
-        { 
-            cover_shift = 8,
-            cover_none  = 0,
-            cover_full  = 255
-        };
 
-        amask_no_clip_u8() : m_rbuf(0) {}
+    amask_no_clip_u8()
-        explicit amask_no_clip_u8(rendering_buffer& rbuf) : m_rbuf(&rbuf) {}
+        : 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(
+        return (cover_type)m_mask_function.calculate(m_rbuf->row_ptr(y) + x * Step + Offset);
-                                   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 * 
+        return (cover_type)((cover_full + val * m_mask_function.calculate(m_rbuf->row_ptr(y) + x * Step + Offset)) >>
-                                 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
     {
@@ -395,11 +361,8 @@ namespace agg
         {
             *dst++ = (cover_type)m_mask_function.calculate(mask);
             mask += Step;
+        } while (--num_pix);
     }
-            while(--num_pix);
-        }
-
-
 
     //--------------------------------------------------------------------
     void combine_hspan(int x, int y, cover_type* dst, int num_pix) const
@@ -407,15 +370,11 @@ namespace agg
         const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
         do
         {
-                *dst = (cover_type)((cover_full + (*dst) * 
+            *dst = (cover_type)((cover_full + (*dst) * m_mask_function.calculate(mask)) >> cover_shift);
-                                    m_mask_function.calculate(mask)) >> 
-                                    cover_shift);
             ++dst;
             mask += Step;
+        } while (--num_pix);
     }
-            while(--num_pix);
-        }
-
 
     //--------------------------------------------------------------------
     void fill_vspan(int x, int y, cover_type* dst, int num_pix) const
@@ -425,10 +384,8 @@ namespace agg
         {
             *dst++ = (cover_type)m_mask_function.calculate(mask);
             mask += m_rbuf->stride();
+        } while (--num_pix);
     }
-            while(--num_pix);
-        }
-
 
     //--------------------------------------------------------------------
     void combine_vspan(int x, int y, cover_type* dst, int num_pix) const
@@ -436,13 +393,10 @@ namespace agg
         const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
         do
         {
-                *dst = (cover_type)((cover_full + (*dst) * 
+            *dst = (cover_type)((cover_full + (*dst) * m_mask_function.calculate(mask)) >> cover_shift);
-                                    m_mask_function.calculate(mask)) >> 
-                                    cover_shift);
             ++dst;
             mask += m_rbuf->stride();
-            }
+        } while (--num_pix);
-            while(--num_pix);
     }
 
   private:
@@ -453,7 +407,6 @@ namespace agg
     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
@@ -491,9 +444,6 @@ namespace agg
 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
 
-
+} // namespace agg
-}
-
-
 
 #endif

deps/agg/include/agg_arc.h

@@ -23,8 +23,7 @@
 #include <cmath>
 #include "agg_basics.h"
 
-namespace agg
+namespace agg {
-{
 
 //=====================================================================arc
 //
@@ -33,16 +32,13 @@ namespace agg
 class arc
 {
   public:
-        arc() : m_scale(1.0), m_initialized(false) {}
+    arc()
-        arc(double x,  double y, 
+        : m_scale(1.0)
-            double rx, double ry, 
+        , m_initialized(false)
-            double a1, double a2, 
+    {}
-            bool ccw=true);
+    arc(double x, double y, double rx, double ry, double a1, double a2, bool ccw = true);
 
-        void init(double x,  double y, 
+    void init(double x, double y, double rx, double ry, double a1, double a2, bool ccw = true);
-                  double rx, double ry, 
-                  double a1, double a2, 
-                  bool ccw=true);
 
     void approximation_scale(double s);
     double approximation_scale() const { return m_scale; }
@@ -67,8 +63,6 @@ namespace agg
     unsigned m_path_cmd;
 };
 
-
+} // namespace agg
-}
-
 
 #endif

deps/agg/include/agg_array.h

@@ -19,16 +19,18 @@
 #include <cstring>
 #include "agg_basics.h"
 
-namespace agg
+namespace agg {
-{
 
 //-------------------------------------------------------pod_array_adaptor
-    template<class T> class pod_array_adaptor
+template<class T>
+class pod_array_adaptor
 {
   public:
     typedef T value_type;
-        pod_array_adaptor(T* array, unsigned _size) : 
+    pod_array_adaptor(T* array, unsigned _size)
-            m_array(array), m_size(_size) {}
+        : m_array(array)
+        , m_size(_size)
+    {}
 
     unsigned size() const { return m_size; }
     const T& operator[](unsigned i) const { return m_array[i]; }
@@ -42,19 +44,16 @@ namespace agg
     unsigned m_size;
 };
 
-
 //---------------------------------------------------------pod_auto_array
-    template<class T, unsigned Size> class 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)
+    explicit pod_auto_array(const T* c) { memcpy(m_array, c, sizeof(T) * Size); }
-        {
-            memcpy(m_array, c, sizeof(T) * Size);
-        }
 
     const self_type& operator=(const T* c)
     {
@@ -73,15 +72,17 @@ namespace agg
     T m_array[Size];
 };
 
-
 //--------------------------------------------------------pod_auto_vector
-    template<class T, unsigned Size> class 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) {}
+    pod_auto_vector()
+        : m_size(0)
+    {}
 
     void remove_all() { m_size = 0; }
     void clear() { m_size = 0; }
@@ -101,32 +102,35 @@ namespace agg
     unsigned m_size;
 };
 
-
 //---------------------------------------------------------------pod_array
-    template<class T> class 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()
-
+        : m_array(0)
-        pod_array(unsigned _size) : 
+        , m_size(0)
-            m_array(pod_allocator<T>::allocate(_size)), 
-            m_size(_size) 
     {}
 
-        pod_array(const self_type& v) : 
+    pod_array(unsigned _size)
-            m_array(pod_allocator<T>::allocate(v.m_size)), 
+        : m_array(pod_allocator<T>::allocate(_size))
-            m_size(v.m_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);
     }
 
-        pod_array(self_type && rhs) :
+    pod_array(self_type&& rhs)
-            m_array(rhs.m_array),
+        : m_array(rhs.m_array)
-            m_size(rhs.m_size)
+        , m_size(rhs.m_size)
     {
         rhs.m_array = nullptr;
         rhs.m_size = 0;
@@ -156,24 +160,28 @@ namespace agg
 
     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
+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()
+        : m_size(0)
+        , m_capacity(0)
+        , m_array(0)
+    {}
     pod_vector(unsigned cap, unsigned extra_tail = 0);
 
     // Copying
@@ -193,10 +201,7 @@ namespace agg
     // Resize keeping the content.
     void resize(unsigned new_size);
 
-        void zero()
+    void zero() { memset(m_array, 0, sizeof(T) * m_size); }
-        {
-            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; }
@@ -217,7 +222,11 @@ namespace agg
 
     void remove_all() { m_size = 0; }
     void clear() { m_size = 0; }
-        void cut_at(unsigned num) { if(num < m_size) m_size = num; }
+    void cut_at(unsigned num)
+    {
+        if (num < m_size)
+            m_size = num;
+    }
 
   private:
     unsigned m_size;
@@ -246,7 +255,6 @@ namespace agg
     m_size = _size;
 }
 
-
 //------------------------------------------------------------------------
 template<class T>
 void pod_vector<T>::resize(unsigned new_size)
@@ -268,25 +276,29 @@ namespace agg
 }
 
 //------------------------------------------------------------------------
-    template<class T> pod_vector<T>::pod_vector(unsigned cap, unsigned extra_tail) :
+template<class T>
-        m_size(0), 
+pod_vector<T>::pod_vector(unsigned cap, unsigned extra_tail)
-        m_capacity(cap + extra_tail), 
+    : m_size(0)
-        m_array(pod_allocator<T>::allocate(m_capacity)) {}
+    , 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) :
+template<class T>
-        m_size(v.m_size),
+pod_vector<T>::pod_vector(const pod_vector<T>& v)
-        m_capacity(v.m_capacity),
+    : m_size(v.m_size)
-        m_array(v.m_capacity ? pod_allocator<T>::allocate(v.m_capacity) : 0)
+    , 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> pod_vector<T>::pod_vector(pod_vector<T> && rhs) :
+template<class T>
-        m_size(rhs.m_size),
+pod_vector<T>::pod_vector(pod_vector<T>&& rhs)
-        m_capacity(rhs.m_capacity),
+    : m_size(rhs.m_size)
-        m_array(rhs.m_array)
+    , m_capacity(rhs.m_capacity)
+    , m_array(rhs.m_array)
 {
     rhs.m_size = 0;
     rhs.m_capacity = 0;
@@ -294,18 +306,21 @@ namespace agg
 }
 
 //------------------------------------------------------------------------
-    template<class T> const pod_vector<T>& 
+template<class T>
-    pod_vector<T>::operator = (const pod_vector<T>&v)
+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);
+    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
+template<class T>
+void pod_vector<T>::serialize(int8u* ptr) const
 {
-        if(m_size) memcpy(ptr, m_array, m_size * sizeof(T)); 
+    if (m_size)
+        memcpy(ptr, m_array, m_size * sizeof(T));
 }
 
 //------------------------------------------------------------------------
@@ -314,7 +329,8 @@ namespace agg
 {
     _byte_size /= sizeof(T);
     allocate(_byte_size);
-        if(_byte_size) memcpy(m_array, _data, _byte_size * sizeof(T));
+    if (_byte_size)
+        memcpy(m_array, _data, _byte_size * sizeof(T));
 }
 
 //------------------------------------------------------------------------
@@ -344,15 +360,11 @@ namespace agg
 // 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
+template<class T, unsigned S = 6>
+class pod_bvector
 {
   public:
-        enum block_scale_e
+    enum block_scale_e { block_shift = S, block_size = 1 << block_shift, block_mask = block_size - 1 };
-        {   
-            block_shift = S,
-            block_size  = 1 << block_shift,
-            block_mask  = block_size - 1
-        };
 
     typedef T value_type;
 
@@ -383,7 +395,8 @@ namespace agg
         }
     }
 
-        template<class DataAccessor> void add_data(DataAccessor& data)
+    template<class DataAccessor>
+    void add_data(DataAccessor& data)
     {
         while (data.size())
         {
@@ -394,81 +407,42 @@ namespace agg
 
     void cut_at(unsigned _size)
     {
-            if(_size < m_size) m_size = _size;
+        if (_size < m_size)
+            m_size = _size;
     }
 
     unsigned size() const { return m_size; }
 
-        const T& operator [] (unsigned i) const
+    const T& operator[](unsigned i) const { return m_blocks[i >> block_shift][i & block_mask]; }
-        {
-            return m_blocks[i >> block_shift][i & block_mask];
-        }
 
-        T& operator [] (unsigned i)
+    T& operator[](unsigned i) { return m_blocks[i >> block_shift][i & block_mask]; }
-        {
-            return m_blocks[i >> block_shift][i & block_mask];
-        }
 
-        const T& at(unsigned i) const
+    const T& at(unsigned i) const { return m_blocks[i >> block_shift][i & block_mask]; }
-        { 
-            return m_blocks[i >> block_shift][i & block_mask];
-        }
 
-        T& at(unsigned i) 
+    T& at(unsigned i) { return m_blocks[i >> block_shift][i & block_mask]; }
-        { 
-            return m_blocks[i >> block_shift][i & block_mask];
-        }
 
-        T value_at(unsigned i) const
+    T value_at(unsigned i) const { return m_blocks[i >> block_shift][i & block_mask]; }
-        { 
-            return m_blocks[i >> block_shift][i & block_mask];
-        }
 
-        const T& curr(unsigned idx) const
+    const T& curr(unsigned idx) const { return (*this)[idx]; }
-        {
-            return (*this)[idx];
-        }
 
-        T& curr(unsigned idx)
+    T& curr(unsigned idx) { return (*this)[idx]; }
-        {
-            return (*this)[idx];
-        }
 
-        const T& prev(unsigned idx) const
+    const T& prev(unsigned idx) const { return (*this)[(idx + m_size - 1) % m_size]; }
-        {
-            return (*this)[(idx + m_size - 1) % m_size];
-        }
 
-        T& prev(unsigned idx)
+    T& prev(unsigned idx) { return (*this)[(idx + m_size - 1) % m_size]; }
-        {
-            return (*this)[(idx + m_size - 1) % m_size];
-        }
 
-        const T& next(unsigned idx) const
+    const T& next(unsigned idx) const { return (*this)[(idx + 1) % m_size]; }
-        {
-            return (*this)[(idx + 1) % m_size];
-        }
 
-        T& next(unsigned idx)
+    T& next(unsigned idx) { return (*this)[(idx + 1) % m_size]; }
-        {
-            return (*this)[(idx + 1) % m_size];
-        }
 
-        const T& last() const
+    const T& last() const { return (*this)[m_size - 1]; }
-        {
-            return (*this)[m_size - 1];
-        }
 
-        T& last()
+    T& last() { return (*this)[m_size - 1]; }
-        {
-            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, 
+    void deserialize(unsigned start, const T& empty_val, const int8u* data, unsigned byte_size);
-                         const int8u* data, unsigned byte_size);
 
     template<class ByteAccessor>
     void deserialize(ByteAccessor data)
@@ -530,9 +504,9 @@ namespace agg
     unsigned m_block_ptr_inc;
 };
 
-
 //------------------------------------------------------------------------
-    template<class T, unsigned S> pod_bvector<T, S>::~pod_bvector()
+template<class T, unsigned S>
+pod_bvector<T, S>::~pod_bvector()
 {
     if (m_num_blocks)
     {
@@ -547,7 +521,6 @@ namespace agg
     pod_allocator<T*>::deallocate(m_blocks, m_max_blocks);
 }
 
-
 //------------------------------------------------------------------------
 template<class T, unsigned S>
 void pod_bvector<T, S>::free_tail(unsigned _size)
@@ -569,40 +542,34 @@ namespace agg
     }
 }
 
-
 //------------------------------------------------------------------------
-    template<class T, unsigned S> pod_bvector<T, S>::pod_bvector() :
+template<class T, unsigned S>
-        m_size(0),
+pod_bvector<T, S>::pod_bvector()
-        m_num_blocks(0),
+    : m_size(0)
-        m_max_blocks(0),
+    , m_num_blocks(0)
-        m_blocks(0),
+    , m_max_blocks(0)
-        m_block_ptr_inc(block_size)
+    , m_blocks(0)
-    {
+    , m_block_ptr_inc(block_size)
-    }
+{}
-
 
 //------------------------------------------------------------------------
 template<class T, unsigned S>
-    pod_bvector<T, S>::pod_bvector(unsigned block_ptr_inc) :
+pod_bvector<T, S>::pod_bvector(unsigned block_ptr_inc)
-        m_size(0),
+    : m_size(0)
-        m_num_blocks(0),
+    , m_num_blocks(0)
-        m_max_blocks(0),
+    , m_max_blocks(0)
-        m_blocks(0),
+    , m_blocks(0)
-        m_block_ptr_inc(block_ptr_inc)
+    , m_block_ptr_inc(block_ptr_inc)
-    {
+{}
-    }
-
 
 //------------------------------------------------------------------------
 template<class T, unsigned S>
-    pod_bvector<T, S>::pod_bvector(const pod_bvector<T, S>& v) :
+pod_bvector<T, S>::pod_bvector(const pod_bvector<T, S>& v)
-        m_size(v.m_size),
+    : m_size(v.m_size)
-        m_num_blocks(v.m_num_blocks),
+    , m_num_blocks(v.m_num_blocks)
-        m_max_blocks(v.m_max_blocks),
+    , m_max_blocks(v.m_max_blocks)
-        m_blocks(v.m_max_blocks ? 
+    , m_blocks(v.m_max_blocks ? pod_allocator<T*>::allocate(v.m_max_blocks) : 0)
-                 pod_allocator<T*>::allocate(v.m_max_blocks) : 
+    , m_block_ptr_inc(v.m_block_ptr_inc)
-                 0),
-        m_block_ptr_inc(v.m_block_ptr_inc)
 {
     unsigned i;
     for (i = 0; i < v.m_num_blocks; ++i)
@@ -612,11 +579,9 @@ namespace agg
     }
 }
 
-
 //------------------------------------------------------------------------
 template<class T, unsigned S>
-    const pod_bvector<T, S>& 
+const pod_bvector<T, S>& pod_bvector<T, S>::operator=(const pod_bvector<T, S>& v)
-    pod_bvector<T, S>::operator = (const pod_bvector<T, S>& v)
 {
     unsigned i;
     for (i = m_num_blocks; i < v.m_num_blocks; ++i)
@@ -631,7 +596,6 @@ namespace agg
     return *this;
 }
 
-
 //------------------------------------------------------------------------
 template<class T, unsigned S>
 void pod_bvector<T, S>::allocate_block(unsigned nb)
@@ -642,9 +606,7 @@ namespace agg
 
         if (m_blocks)
         {
-                memcpy(new_blocks, 
+            memcpy(new_blocks, m_blocks, m_num_blocks * sizeof(T*));
-                       m_blocks, 
-                       m_num_blocks * sizeof(T*));
 
             pod_allocator<T*>::deallocate(m_blocks, m_max_blocks);
         }
@@ -655,8 +617,6 @@ namespace agg
     m_num_blocks++;
 }
 
-
-
 //------------------------------------------------------------------------
 template<class T, unsigned S>
 inline T* pod_bvector<T, S>::data_ptr()
@@ -669,8 +629,6 @@ namespace agg
     return m_blocks[nb] + (m_size & block_mask);
 }
 
-
-
 //------------------------------------------------------------------------
 template<class T, unsigned S>
 inline void pod_bvector<T, S>::add(const T& val)
@@ -679,15 +637,14 @@ namespace agg
     ++m_size;
 }
 
-
 //------------------------------------------------------------------------
 template<class T, unsigned S>
 inline void pod_bvector<T, S>::remove_last()
 {
-        if(m_size) --m_size;
+    if (m_size)
+        --m_size;
 }
 
-
 //------------------------------------------------------------------------
 template<class T, unsigned S>
 void pod_bvector<T, S>::modify_last(const T& val)
@@ -696,7 +653,6 @@ namespace agg
     add(val);
 }
 
-
 //------------------------------------------------------------------------
 template<class T, unsigned S>
 int pod_bvector<T, S>::allocate_continuous_block(unsigned num_elements)
@@ -726,7 +682,6 @@ namespace agg
     return -1; // Impossible to allocate
 }
 
-
 //------------------------------------------------------------------------
 template<class T, unsigned S>
 unsigned pod_bvector<T, S>::byte_size() const
@@ -734,7 +689,6 @@ namespace agg
     return m_size * sizeof(T);
 }
 
-
 //------------------------------------------------------------------------
 template<class T, unsigned S>
 void pod_bvector<T, S>::serialize(int8u* ptr) const
@@ -762,12 +716,10 @@ namespace agg
     }
 }
 
-
 // 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, 
+void pod_bvector<T, S>::deserialize(unsigned start, const T& empty_val, const int8u* _data, unsigned _byte_size)
-                                        const int8u* _data, unsigned _byte_size)
 {
     while (m_size < start)
     {
@@ -791,7 +743,6 @@ namespace agg
     }
 }
 
-
 //---------------------------------------------------------block_allocator
 // Allocator for arbitrary POD data. Most usable in different cache
 // systems for efficient memory allocations.
@@ -828,33 +779,28 @@ namespace agg
         m_rest = 0;
     }
 
-        ~block_allocator()
+    ~block_allocator() { remove_all(); }
-        {
-            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)
-        {
-        }
 
+    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 == 0)
+            return 0;
         if (size <= m_rest)
         {
             int8u* ptr = m_buf_ptr;
             if (alignment > 1)
             {
-                    unsigned align = 
+                unsigned align = (alignment - unsigned((size_t)ptr) % alignment) % alignment;
-                        (alignment - unsigned((size_t)ptr) % alignment) % alignment;
 
                 size += align;
                 ptr += align;
@@ -875,21 +821,18 @@ namespace agg
         return allocate(size, alignment);
     }
 
-
   private:
     void allocate_block(unsigned size)
     {
-            if(size < m_block_size) size = m_block_size;
+        if (size < m_block_size)
+            size = m_block_size;
         if (m_num_blocks >= m_max_blocks)
         {
-                block_type* new_blocks = 
+            block_type* new_blocks = pod_allocator<block_type>::allocate(m_max_blocks + m_block_ptr_inc);
-                    pod_allocator<block_type>::allocate(m_max_blocks + m_block_ptr_inc);
 
             if (m_blocks)
             {
-                    memcpy(new_blocks, 
+                memcpy(new_blocks, m_blocks, m_num_blocks * sizeof(block_type));
-                           m_blocks, 
-                           m_num_blocks * sizeof(block_type));
                 pod_allocator<block_type>::deallocate(m_blocks, m_max_blocks);
             }
             m_blocks = new_blocks;
@@ -897,9 +840,7 @@ namespace agg
         }
 
         m_blocks[m_num_blocks].size = size;
-            m_blocks[m_num_blocks].data = 
+        m_blocks[m_num_blocks].data = m_buf_ptr = pod_allocator<int8u>::allocate(size);
-                m_buf_ptr =
-                pod_allocator<int8u>::allocate(size);
 
         m_num_blocks++;
         m_rest = size;
@@ -914,34 +855,24 @@ namespace agg
     unsigned m_rest;
 };
 
-
-
-
-
-
-
-
 //------------------------------------------------------------------------
-    enum quick_sort_threshold_e
+enum quick_sort_threshold_e { quick_sort_threshold = 9 };
-    {
-        quick_sort_threshold = 9
-    };
-
 
 //-----------------------------------------------------------swap_elements
-    template<class T> inline void swap_elements(T& a, T& b)
+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;
+    if (arr.size() < 2)
+        return;
 
     typename Array::value_type* e1;
     typename Array::value_type* e2;
@@ -971,20 +902,27 @@ namespace agg
             // now ensure that *i <= *base <= *j
             e1 = &(arr[j]);
             e2 = &(arr[i]);
-                if(less(*e1, *e2)) swap_elements(*e1, *e2);
+            if (less(*e1, *e2))
+                swap_elements(*e1, *e2);
 
             e1 = &(arr[base]);
             e2 = &(arr[i]);
-                if(less(*e1, *e2)) swap_elements(*e1, *e2);
+            if (less(*e1, *e2))
+                swap_elements(*e1, *e2);
 
             e1 = &(arr[j]);
             e2 = &(arr[base]);
-                if(less(*e1, *e2)) swap_elements(*e1, *e2);
+            if (less(*e1, *e2))
+                swap_elements(*e1, *e2);
 
             for (;;)
             {
-                    do i++; while( less(arr[i], arr[base]) );
+                do
-                    do j--; while( less(arr[base], arr[j]) );
+                    i++;
+                while (less(arr[i], arr[base]));
+                do
+                    j--;
+                while (less(arr[base], arr[j]));
 
                 if (i > j)
                 {
@@ -1042,9 +980,6 @@ namespace agg
     }
 }
 
-
-
-
 //------------------------------------------------------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.
@@ -1052,7 +987,8 @@ namespace agg
 template<class Array, class Equal>
 unsigned remove_duplicates(Array& arr, Equal equal)
 {
-        if(arr.size() < 2) return arr.size();
+    if (arr.size() < 2)
+        return arr.size();
 
     unsigned i, j;
     for (i = 1, j = 1; i < arr.size(); i++)
@@ -1067,7 +1003,8 @@ namespace agg
 }
 
 //--------------------------------------------------------invert_container
-    template<class Array> void invert_container(Array& arr)
+template<class Array>
+void invert_container(Array& arr)
 {
     int i = 0;
     int j = arr.size() - 1;
@@ -1081,19 +1018,24 @@ namespace agg
 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;
+    if (arr.size() == 0)
+        return 0;
 
     unsigned beg = 0;
     unsigned end = arr.size() - 1;
 
-        if(less(val, arr[0])) return 0;
+    if (less(val, arr[0]))
-        if(less(arr[end], val)) return end + 1;
+        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; 
+        if (less(val, arr[mid]))
-            else                    beg = mid;
+            end = mid;
+        else
+            beg = mid;
     }
 
     // if(beg <= 0 && less(val, arr[0])) return 0;
@@ -1103,13 +1045,16 @@ namespace agg
 }
 
 //----------------------------------------------------------range_adaptor
-    template<class Array> class range_adaptor
+template<class Array>
+class range_adaptor
 {
   public:
     typedef typename Array::value_type value_type;
 
-        range_adaptor(Array& array, unsigned start, unsigned _size) :
+    range_adaptor(Array& array, unsigned start, unsigned _size)
-            m_array(array), m_start(start), m_size(_size)
+        : m_array(array)
+        , m_start(start)
+        , m_size(_size)
     {}
 
     unsigned size() const { return m_size; }
@@ -1126,16 +1071,28 @@ namespace agg
 };
 
 //---------------------------------------------------------------int_less
-    inline bool int_less(int a, int b) { return a < b; }
+inline bool int_less(int a, int b)
-
+{
-    //------------------------------------------------------------int_greater
+    return a < b;
-    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; }
 }
 
+//------------------------------------------------------------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;
+}
+} // namespace agg
+
 #endif

deps/agg/include/agg_arrowhead.h

@@ -21,8 +21,7 @@
 
 #include "agg_basics.h"
 
-namespace agg
+namespace agg {
-{
 
 //===============================================================arrowhead
 //
@@ -77,6 +76,6 @@ namespace agg
     unsigned m_curr_coord;
 };
 
-}
+} // namespace agg
 
 #endif

deps/agg/include/agg_basics.h

@@ -23,8 +23,7 @@
 #ifdef AGG_CUSTOM_ALLOCATOR
 #include "agg_allocator.h"
 #else
-namespace agg
+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
@@ -33,7 +32,8 @@ namespace agg
 // 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
+template<class T>
+struct pod_allocator
 {
     // static T*   allocate(unsigned num)       { return static_cast<T*>(::operator new(sizeof(T)*num));}
     // static void deallocate(T* ptr, unsigned) { ::operator delete(ptr) ;}
@@ -49,15 +49,15 @@ namespace agg
 // 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
+template<class T>
+struct obj_allocator
 {
     static T* allocate() { return new T; }
     static void deallocate(T* ptr) { delete ptr; }
 };
-}
+} // namespace agg
 #endif
 
-
 //-------------------------------------------------------- Default basic types
 //
 // If the compiler has different capacity of the basic types you can redefine
@@ -107,8 +107,7 @@ namespace agg
 #define AGG_INLINE inline
 #endif
 
-namespace agg
+namespace agg {
-{
 //-------------------------------------------------------------------------
 typedef AGG_INT8 int8;     //----int8
 typedef AGG_INT8U int8u;   //----int8u
@@ -137,18 +136,22 @@ namespace agg
 }
 
 //---------------------------------------------------------------saturation
-    template<int Limit> struct saturation
+template<int Limit>
+struct saturation
 {
     AGG_INLINE static int iround(double v)
     {
-            if(v < double(-Limit)) return -Limit;
+        if (v < double(-Limit))
-            if(v > double( Limit)) return  Limit;
+            return -Limit;
+        if (v > double(Limit))
+            return Limit;
         return agg::iround(v);
     }
 };
 
 //------------------------------------------------------------------mul_one
-    template<unsigned Shift> struct mul_one
+template<unsigned Shift>
+struct mul_one
 {
     AGG_INLINE static unsigned mul(unsigned a, unsigned b)
     {
@@ -159,8 +162,7 @@ namespace agg
 
 //-------------------------------------------------------------------------
 typedef unsigned char cover_type; //----cover_type
-    enum cover_scale_e
+enum cover_scale_e {
-    {
     cover_shift = 8,               //----cover_shift
     cover_size = 1 << cover_shift, //----cover_size
     cover_mask = cover_size - 1,   //----cover_mask
@@ -174,19 +176,14 @@ namespace agg
 // 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
+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
+enum filling_rule_e { fill_non_zero, fill_even_odd };
-    {
-        fill_non_zero,
-        fill_even_odd
-    };
 
 //-----------------------------------------------------------------------pi
 const double pi = 3.14159265358979323846;
@@ -204,47 +201,63 @@ namespace agg
 }
 
 //----------------------------------------------------------------rect_base
-    template<class T> struct 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_) :
+    rect_base(T x1_, T y1_, T x2_, T y2_)
-            x1(x1_), y1(y1_), x2(x2_), y2(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_;
+        x1 = x1_;
+        y1 = y1_;
+        x2 = x2_;
+        y2 = y2_;
     }
 
     const self_type& normalize()
     {
         T t;
-            if(x1 > x2) { t = x1; x1 = x2; x2 = t; }
+        if (x1 > x2)
-            if(y1 > y2) { t = y1; y1 = y2; y2 = t; }
+        {
+            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 (x2 > r.x2)
-            if(y2 > r.y2) y2 = r.y2;
+            x2 = r.x2;
-            if(x1 < r.x1) x1 = r.x1;
+        if (y2 > r.y2)
-            if(y1 < r.y1) y1 = r.y1;
+            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
+    bool is_valid() const { return x1 <= x2 && y1 <= y2; }
-        {
-            return x1 <= x2 && y1 <= y2;
-        }
 
-        bool hit_test(T x, T y) const
+    bool hit_test(T x, T y) const { return (x >= x1 && x <= x2 && y >= y1 && y <= y2); }
-        {
-            return (x >= x1 && x <= x2 && y >= y1 && y <= y2);
-        }
 };
 
 //-----------------------------------------------------intersect_rectangles
@@ -258,23 +271,30 @@ namespace agg
     // 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.x2 > r2.x2)
-        if(r.y2 > r2.y2) r.y2 = r2.y2;
+        r.x2 = r2.x2;
-        if(r.x1 < r2.x1) r.x1 = r2.x1;
+    if (r.y2 > r2.y2)
-        if(r.y1 < r2.y1) r.y1 = r2.y1;
+        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.x2 < r2.x2)
-        if(r.y2 < r2.y2) r.y2 = r2.y2;
+        r.x2 = r2.x2;
-        if(r.x1 > r2.x1) r.x1 = r2.x1;
+    if (r.y2 < r2.y2)
-        if(r.y1 > r2.y1) r.y1 = r2.y1;
+        r.y2 = r2.y2;
+    if (r.x1 > r2.x1)
+        r.x1 = r2.x1;
+    if (r.y1 > r2.y1)
+        r.y1 = r2.y1;
     return r;
 }
 
@@ -283,8 +303,7 @@ namespace agg
 typedef rect_base<double> rect_d; //----rect_d
 
 //---------------------------------------------------------path_commands_e
-    enum 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
@@ -298,8 +317,7 @@ namespace agg
 };
 
 //------------------------------------------------------------path_flags_e
-    enum 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
@@ -364,8 +382,7 @@ namespace agg
 //----------------------------------------------------------------is_close
 inline bool is_close(unsigned c)
 {
-        return (c & ~(path_flags_cw | path_flags_ccw)) ==
+    return (c & ~(path_flags_cw | path_flags_ccw)) == (path_cmd_end_poly | path_flags_close);
-               (path_cmd_end_poly | path_flags_close);
 }
 
 //------------------------------------------------------------is_next_poly
@@ -423,56 +440,74 @@ namespace agg
 }
 
 //--------------------------------------------------------------point_base
-    template<class T> struct 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_) {}
+    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
+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_) {}
+    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
+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_) {}
+    row_info(int x1_, int x2_, T* ptr_)
+        : x1(x1_)
+        , x2(x2_)
+        , ptr(ptr_)
+    {}
 };
 
 //----------------------------------------------------------const_row_info
-    template<class T> struct 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_) :
+    const_row_info(int x1_, int x2_, const T* ptr_)
-            x1(x1_), x2(x2_), ptr(ptr_) {}
+        : x1(x1_)
+        , x2(x2_)
+        , ptr(ptr_)
+    {}
 };
 
 //------------------------------------------------------------is_equal_eps
-    template<class T> inline bool is_equal_eps(T v1, T v2, T epsilon)
+template<class T>
+inline bool is_equal_eps(T v1, T v2, T epsilon)
 {
     return std::fabs(v1 - v2) <= double(epsilon);
 }
 
-}
+} // namespace agg
-
 
 #endif

deps/agg/include/agg_bezier_arc.h

@@ -23,14 +23,10 @@
 
 #include "agg_conv_transform.h"
 
-namespace agg
+namespace agg {
-{
 
 //-----------------------------------------------------------------------
-    void arc_to_bezier(double cx, double cy, double rx, double ry, 
+void arc_to_bezier(double cx, double cy, double rx, double ry, double start_angle, double sweep_angle, double* curve);
-                       double start_angle, double sweep_angle,
-                       double* curve);
-
 
 //==============================================================bezier_arc
 //
@@ -40,31 +36,27 @@ namespace agg
 {
   public:
     //--------------------------------------------------------------------
-        bezier_arc() : m_vertex(26), m_num_vertices(0), m_cmd(path_cmd_line_to) {}
+    bezier_arc()
-        bezier_arc(double x,  double y, 
+        : m_vertex(26)
-                   double rx, double ry, 
+        , m_num_vertices(0)
-                   double start_angle, 
+        , m_cmd(path_cmd_line_to)
-                   double sweep_angle)
+    {}
+    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, 
+    void init(double x, double y, double rx, double ry, double start_angle, double sweep_angle);
-                  double rx, double ry, 
-                  double start_angle, 
-                  double sweep_angle);
 
     //--------------------------------------------------------------------
-        void rewind(unsigned)
+    void rewind(unsigned) { m_vertex = 0; }
-        {
-            m_vertex = 0;
-        }
 
     //--------------------------------------------------------------------
     unsigned vertex(double* x, double* y)
     {
-            if(m_vertex >= m_num_vertices) return path_cmd_stop;
+        if (m_vertex >= m_num_vertices)
+            return path_cmd_stop;
         *x = m_vertices[m_vertex];
         *y = m_vertices[m_vertex + 1];
         m_vertex += 2;
@@ -85,8 +77,6 @@ namespace agg
     unsigned m_cmd;
 };
 
-
-
 //==========================================================bezier_arc_svg
 // Compute an SVG-style bezier arc.
 //
@@ -102,41 +92,45 @@ namespace agg
 {
   public:
     //--------------------------------------------------------------------
-        bezier_arc_svg() : m_arc(), m_radii_ok(false) {}
+    bezier_arc_svg()
+        : m_arc()
+        , m_radii_ok(false)
+    {}
 
-        bezier_arc_svg(double x1, double y1, 
+    bezier_arc_svg(double x1,
-                       double rx, double ry, 
+                   double y1,
+                   double rx,
+                   double ry,
                    double angle,
                    bool large_arc_flag,
                    bool sweep_flag,
-                       double x2, double y2) : 
+                   double x2,
-            m_arc(), m_radii_ok(false)
+                   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, 
+    void init(double x1,
-                  double rx, double ry, 
+              double y1,
+              double rx,
+              double ry,
               double angle,
               bool large_arc_flag,
               bool sweep_flag,
-                  double x2, double y2);
+              double x2,
+              double y2);
 
     //--------------------------------------------------------------------
     bool radii_ok() const { return m_radii_ok; }
 
     //--------------------------------------------------------------------
-        void rewind(unsigned)
+    void rewind(unsigned) { m_arc.rewind(0); }
-        {
-            m_arc.rewind(0);
-        }
 
     //--------------------------------------------------------------------
-        unsigned vertex(double* x, double* y)
+    unsigned vertex(double* x, double* y) { return m_arc.vertex(x, 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.
@@ -150,10 +144,6 @@ namespace agg
     bool m_radii_ok;
 };
 
-
+} // namespace agg
-
-
-}
-
 
 #endif

deps/agg/include/agg_bitset_iterator.h

@@ -18,15 +18,14 @@
 
 #include "agg_basics.h"
 
-namespace agg
+namespace agg {
-{
 
 class bitset_iterator
 {
   public:
-        bitset_iterator(const int8u* bits, unsigned offset = 0) :
+    bitset_iterator(const int8u* bits, unsigned offset = 0)
-            m_bits(bits + (offset >> 3)),
+        : m_bits(bits + (offset >> 3))
-            m_mask(0x80 >> (offset & 7))
+        , m_mask(0x80 >> (offset & 7))
     {}
 
     void operator++()
@@ -39,16 +38,13 @@ namespace agg
         }
     }
 
-        unsigned bit() const
+    unsigned bit() const { return (*m_bits) & m_mask; }
-        {
-            return (*m_bits) & m_mask;
-        }
 
   private:
     const int8u* m_bits;
     int8u m_mask;
 };
 
-}
+} // namespace agg
 
 #endif

deps/agg/include/agg_blur.h

@@ -30,10 +30,10 @@
 #include "agg_array.h"
 #include "agg_pixfmt_transposer.h"
 
-namespace agg
+namespace agg {
-{
 
-    template<class T> struct stack_blur_tables
+template<class T>
+struct stack_blur_tables
 {
     static int16u const g_stack_blur8_mul[255];
     static int8u const g_stack_blur8_shr[255];
@@ -41,61 +41,47 @@ namespace agg
 
 //------------------------------------------------------------------------
 template<class T>
-    int16u const stack_blur_tables<T>::g_stack_blur8_mul[255] = 
+int16u const stack_blur_tables<T>::g_stack_blur8_mul[255] = {
-    {
+  512, 512, 456, 512, 328, 456, 335, 512, 405, 328, 271, 456, 388, 335, 292, 512, 454, 405, 364, 328, 298, 271,
-        512,512,456,512,328,456,335,512,405,328,271,456,388,335,292,512,
+  496, 456, 420, 388, 360, 335, 312, 292, 273, 512, 482, 454, 428, 405, 383, 364, 345, 328, 312, 298, 284, 271,
-        454,405,364,328,298,271,496,456,420,388,360,335,312,292,273,512,
+  259, 496, 475, 456, 437, 420, 404, 388, 374, 360, 347, 335, 323, 312, 302, 292, 282, 273, 265, 512, 497, 482,
-        482,454,428,405,383,364,345,328,312,298,284,271,259,496,475,456,
+  468, 454, 441, 428, 417, 405, 394, 383, 373, 364, 354, 345, 337, 328, 320, 312, 305, 298, 291, 284, 278, 271,
-        437,420,404,388,374,360,347,335,323,312,302,292,282,273,265,512,
+  265, 259, 507, 496, 485, 475, 465, 456, 446, 437, 428, 420, 412, 404, 396, 388, 381, 374, 367, 360, 354, 347,
-        497,482,468,454,441,428,417,405,394,383,373,364,354,345,337,328,
+  341, 335, 329, 323, 318, 312, 307, 302, 297, 292, 287, 282, 278, 273, 269, 265, 261, 512, 505, 497, 489, 482,
-        320,312,305,298,291,284,278,271,265,259,507,496,485,475,465,456,
+  475, 468, 461, 454, 447, 441, 435, 428, 422, 417, 411, 405, 399, 394, 389, 383, 378, 373, 368, 364, 359, 354,
-        446,437,428,420,412,404,396,388,381,374,367,360,354,347,341,335,
+  350, 345, 341, 337, 332, 328, 324, 320, 316, 312, 309, 305, 301, 298, 294, 291, 287, 284, 281, 278, 274, 271,
-        329,323,318,312,307,302,297,292,287,282,278,273,269,265,261,512,
+  268, 265, 262, 259, 257, 507, 501, 496, 491, 485, 480, 475, 470, 465, 460, 456, 451, 446, 442, 437, 433, 428,
-        505,497,489,482,475,468,461,454,447,441,435,428,422,417,411,405,
+  424, 420, 416, 412, 408, 404, 400, 396, 392, 388, 385, 381, 377, 374, 370, 367, 363, 360, 357, 354, 350, 347,
-        399,394,389,383,378,373,368,364,359,354,350,345,341,337,332,328,
+  344, 341, 338, 335, 332, 329, 326, 323, 320, 318, 315, 312, 310, 307, 304, 302, 299, 297, 294, 292, 289, 287,
-        324,320,316,312,309,305,301,298,294,291,287,284,281,278,274,271,
+  285, 282, 280, 278, 275, 273, 271, 269, 267, 265, 263, 261, 259};
-        268,265,262,259,257,507,501,496,491,485,480,475,470,465,460,456,
-        451,446,442,437,433,428,424,420,416,412,408,404,400,396,392,388,
-        385,381,377,374,370,367,363,360,357,354,350,347,344,341,338,335,
-        332,329,326,323,320,318,315,312,310,307,304,302,299,297,294,292,
-        289,287,285,282,280,278,275,273,271,269,267,265,263,261,259
-    };
 
 //------------------------------------------------------------------------
 template<class T>
-    int8u const stack_blur_tables<T>::g_stack_blur8_shr[255] = 
+int8u const stack_blur_tables<T>::g_stack_blur8_shr[255] = {
-    {
+  9,  11, 12, 13, 13, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18,
-          9, 11, 12, 13, 13, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17, 
+  18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
-         17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 18, 19, 
+  20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-         19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20,
+  21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-         20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21,
+  22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-         21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+  23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-         21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 
+  23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-         22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-         22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 
+  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24};
-         23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-         23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-         23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 
-         23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
-         24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-         24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-         24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-         24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24
-    };
-
-
 
 //==============================================================stack_blur
-    template<class ColorT, class CalculatorT> class stack_blur
+template<class ColorT, class CalculatorT>
+class stack_blur
 {
   public:
     typedef ColorT color_type;
     typedef CalculatorT calculator_type;
 
     //--------------------------------------------------------------------
-        template<class Img> void blur_x(Img& img, unsigned radius)
+    template<class Img>
+    void blur_x(Img& img, unsigned radius)
     {
-            if(radius < 1) return;
+        if (radius < 1)
+            return;
 
         unsigned x, y, xp, i;
         unsigned stack_ptr;
@@ -150,19 +136,23 @@ namespace agg
             stack_ptr = radius;
             for (x = 0; x < w; x++)
             {
-                    if(mul_sum) sum.calc_pix(m_buf[x], mul_sum, shr_sum);
+                if (mul_sum)
-                    else        sum.calc_pix(m_buf[x], div_sum);
+                    sum.calc_pix(m_buf[x], mul_sum, shr_sum);
+                else
+                    sum.calc_pix(m_buf[x], div_sum);
 
                 sum.sub(sum_out);
 
                 stack_start = stack_ptr + div - radius;
-                    if(stack_start >= div) stack_start -= div;
+                if (stack_start >= div)
+                    stack_start -= div;
                 stack_pix = &m_stack[stack_start];
 
                 sum_out.sub(*stack_pix);
 
                 xp = x + radius + 1;
-                    if(xp > wm) xp = wm;
+                if (xp > wm)
+                    xp = wm;
                 pix = img.pixel(xp, y);
 
                 *stack_pix = pix;
@@ -171,7 +161,8 @@ namespace agg
                 sum.add(sum_in);
 
                 ++stack_ptr;
-                    if(stack_ptr >= div) stack_ptr = 0;
+                if (stack_ptr >= div)
+                    stack_ptr = 0;
                 stack_pix = &m_stack[stack_ptr];
 
                 sum_out.add(*stack_pix);
@@ -182,14 +173,16 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        template<class Img> void blur_y(Img& img, unsigned radius)
+    template<class Img>
+    void blur_y(Img& img, unsigned radius)
     {
         pixfmt_transposer<Img> img2(img);
         blur_x(img2, radius);
     }
 
     //--------------------------------------------------------------------
-        template<class Img> void blur(Img& img, unsigned radius)
+    template<class Img>
+    void blur(Img& img, unsigned radius)
     {
         blur_x(img, radius);
         pixfmt_transposer<Img> img2(img);
@@ -202,17 +195,16 @@ namespace agg
 };
 
 //====================================================stack_blur_calc_rgba
-    template<class T=unsigned> struct stack_blur_calc_rgba
+template<class T = unsigned>
+struct stack_blur_calc_rgba
 {
     typedef T value_type;
     value_type r, g, b, a;
 
-        AGG_INLINE void clear() 
+    AGG_INLINE void clear() { r = g = b = a = 0; }
-        { 
-            r = g = b = a = 0; 
-        }
 
-        template<class ArgT> AGG_INLINE void add(const ArgT& v)
+    template<class ArgT>
+    AGG_INLINE void add(const ArgT& v)
     {
         r += v.r;
         g += v.g;
@@ -220,7 +212,8 @@ namespace agg
         a += v.a;
     }
 
-        template<class ArgT> AGG_INLINE void add(const ArgT& v, unsigned k)
+    template<class ArgT>
+    AGG_INLINE void add(const ArgT& v, unsigned k)
     {
         r += v.r * k;
         g += v.g * k;
@@ -228,7 +221,8 @@ namespace agg
         a += v.a * k;
     }
 
-        template<class ArgT> AGG_INLINE void sub(const ArgT& v)
+    template<class ArgT>
+    AGG_INLINE void sub(const ArgT& v)
     {
         r -= v.r;
         g -= v.g;
@@ -236,7 +230,8 @@ namespace agg
         a -= v.a;
     }
 
-        template<class ArgT> AGG_INLINE void calc_pix(ArgT& v, unsigned div)
+    template<class ArgT>
+    AGG_INLINE void calc_pix(ArgT& v, unsigned div)
     {
         typedef typename ArgT::value_type value_type;
         v.r = value_type(r / div);
@@ -256,40 +251,41 @@ namespace agg
     }
 };
 
-
 //=====================================================stack_blur_calc_rgb
-    template<class T=unsigned> struct stack_blur_calc_rgb
+template<class T = unsigned>
+struct stack_blur_calc_rgb
 {
     typedef T value_type;
     value_type r, g, b;
 
-        AGG_INLINE void clear() 
+    AGG_INLINE void clear() { r = g = b = 0; }
-        { 
-            r = g = b = 0; 
-        }
 
-        template<class ArgT> AGG_INLINE void add(const ArgT& v)
+    template<class ArgT>
+    AGG_INLINE void add(const ArgT& v)
     {
         r += v.r;
         g += v.g;
         b += v.b;
     }
 
-        template<class ArgT> AGG_INLINE void add(const ArgT& v, unsigned k)
+    template<class ArgT>
+    AGG_INLINE void add(const ArgT& v, unsigned k)
     {
         r += v.r * k;
         g += v.g * k;
         b += v.b * k;
     }
 
-        template<class ArgT> AGG_INLINE void sub(const ArgT& v)
+    template<class ArgT>
+    AGG_INLINE void sub(const ArgT& v)
     {
         r -= v.r;
         g -= v.g;
         b -= v.b;
     }
 
-        template<class ArgT> AGG_INLINE void calc_pix(ArgT& v, unsigned div)
+    template<class ArgT>
+    AGG_INLINE void calc_pix(ArgT& v, unsigned div)
     {
         typedef typename ArgT::value_type value_type;
         v.r = value_type(r / div);
@@ -307,34 +303,35 @@ namespace agg
     }
 };
 
-
 //====================================================stack_blur_calc_gray
-    template<class T=unsigned> struct stack_blur_calc_gray
+template<class T = unsigned>
+struct stack_blur_calc_gray
 {
     typedef T value_type;
     value_type v;
 
-        AGG_INLINE void clear() 
+    AGG_INLINE void clear() { v = 0; }
-        { 
-            v = 0; 
-        }
 
-        template<class ArgT> AGG_INLINE void add(const ArgT& a)
+    template<class ArgT>
+    AGG_INLINE void add(const ArgT& a)
     {
         v += a.v;
     }
 
-        template<class ArgT> AGG_INLINE void add(const ArgT& a, unsigned k)
+    template<class ArgT>
+    AGG_INLINE void add(const ArgT& a, unsigned k)
     {
         v += a.v * k;
     }
 
-        template<class ArgT> AGG_INLINE void sub(const ArgT& a)
+    template<class ArgT>
+    AGG_INLINE void sub(const ArgT& a)
     {
         v -= a.v;
     }
 
-        template<class ArgT> AGG_INLINE void calc_pix(ArgT& a, unsigned div)
+    template<class ArgT>
+    AGG_INLINE void calc_pix(ArgT& a, unsigned div)
     {
         typedef typename ArgT::value_type value_type;
         a.v = value_type(v / div);
@@ -348,8 +345,6 @@ namespace agg
     }
 };
 
-
-
 //========================================================stack_blur_gray8
 template<class Img>
 void stack_blur_gray8(Img& img, unsigned rx, unsigned ry)
@@ -379,7 +374,8 @@ namespace agg
 
     if (rx > 0)
     {
-            if(rx > 254) rx = 254;
+        if (rx > 254)
+            rx = 254;
         div = rx * 2 + 1;
         mul_sum = stack_blur_tables<int>::g_stack_blur8_mul[rx];
         shr_sum = stack_blur_tables<int>::g_stack_blur8_shr[rx];
@@ -399,7 +395,8 @@ namespace agg
             }
             for (i = 1; i <= rx; i++)
             {
-                    if(i <= wm) src_pix_ptr += Img::pix_step; 
+                if (i <= wm)
+                    src_pix_ptr += Img::pix_step;
                 pix = *src_pix_ptr;
                 stack[i + rx] = pix;
                 sum += pix * (rx + 1 - i);
@@ -408,7 +405,8 @@ namespace agg
 
             stack_ptr = rx;
             xp = rx;
-                if(xp > wm) xp = wm;
+            if (xp > wm)
+                xp = wm;
             src_pix_ptr = img.pix_ptr(xp, y);
             dst_pix_ptr = img.pix_ptr(0, y);
             for (x = 0; x < w; x++)
@@ -419,7 +417,8 @@ namespace agg
                 sum -= sum_out;
 
                 stack_start = stack_ptr + div - rx;
-                    if(stack_start >= div) stack_start -= div;
+                if (stack_start >= div)
+                    stack_start -= div;
                 sum_out -= stack[stack_start];
 
                 if (xp < wm)
@@ -435,7 +434,8 @@ namespace agg
                 sum += sum_in;
 
                 ++stack_ptr;
-                    if(stack_ptr >= div) stack_ptr = 0;
+                if (stack_ptr >= div)
+                    stack_ptr = 0;
                 stack_pix = stack[stack_ptr];
 
                 sum_out += stack_pix;
@@ -446,7 +446,8 @@ namespace agg
 
     if (ry > 0)
     {
-            if(ry > 254) ry = 254;
+        if (ry > 254)
+            ry = 254;
         div = ry * 2 + 1;
         mul_sum = stack_blur_tables<int>::g_stack_blur8_mul[ry];
         shr_sum = stack_blur_tables<int>::g_stack_blur8_shr[ry];
@@ -467,7 +468,8 @@ namespace agg
             }
             for (i = 1; i <= ry; i++)
             {
-                    if(i <= hm) src_pix_ptr += stride; 
+                if (i <= hm)
+                    src_pix_ptr += stride;
                 pix = *src_pix_ptr;
                 stack[i + ry] = pix;
                 sum += pix * (ry + 1 - i);
@@ -476,7 +478,8 @@ namespace agg
 
             stack_ptr = ry;
             yp = ry;
-                if(yp > hm) yp = hm;
+            if (yp > hm)
+                yp = hm;
             src_pix_ptr = img.pix_ptr(x, yp);
             dst_pix_ptr = img.pix_ptr(x, 0);
             for (y = 0; y < h; y++)
@@ -487,7 +490,8 @@ namespace agg
                 sum -= sum_out;
 
                 stack_start = stack_ptr + div - ry;
-                    if(stack_start >= div) stack_start -= div;
+                if (stack_start >= div)
+                    stack_start -= div;
                 sum_out -= stack[stack_start];
 
                 if (yp < hm)
@@ -503,7 +507,8 @@ namespace agg
                 sum += sum_in;
 
                 ++stack_ptr;
-                    if(stack_ptr >= div) stack_ptr = 0;
+                if (stack_ptr >= div)
+                    stack_ptr = 0;
                 stack_pix = stack[stack_ptr];
 
                 sum_out += stack_pix;
@@ -513,20 +518,13 @@ namespace agg
     }
 }
 
-
-
 //========================================================stack_blur_rgb24
 template<class Img>
 void stack_blur_rgb24(Img& img, unsigned rx, unsigned ry)
 {
     typedef typename Img::color_type color_type;
     typedef typename Img::order_type order_type;
-        enum order_e 
+    enum order_e { R = order_type::R, G = order_type::G, B = order_type::B };
-        { 
-            R = order_type::R, 
-            G = order_type::G, 
-            B = order_type::B 
-        };
 
     unsigned x, y, xp, yp, i;
     unsigned stack_ptr;
@@ -559,7 +557,8 @@ namespace agg
 
     if (rx > 0)
     {
-            if(rx > 254) rx = 254;
+        if (rx > 254)
+            rx = 254;
         div = rx * 2 + 1;
         mul_sum = stack_blur_tables<int>::g_stack_blur8_mul[rx];
         shr_sum = stack_blur_tables<int>::g_stack_blur8_shr[rx];
@@ -567,15 +566,7 @@ namespace agg
 
         for (y = 0; y < h; y++)
         {
-                sum_r = 
+            sum_r = sum_g = sum_b = sum_in_r = sum_in_g = sum_in_b = sum_out_r = sum_out_g = sum_out_b = 0;
-                sum_g = 
-                sum_b = 
-                sum_in_r = 
-                sum_in_g = 
-                sum_in_b = 
-                sum_out_r = 
-                sum_out_g = 
-                sum_out_b = 0;
 
             src_pix_ptr = img.pix_ptr(0, y);
             for (i = 0; i <= rx; i++)
@@ -593,7 +584,8 @@ namespace agg
             }
             for (i = 1; i <= rx; i++)
             {
-                    if(i <= wm) src_pix_ptr += Img::pix_width; 
+                if (i <= wm)
+                    src_pix_ptr += Img::pix_width;
                 stack_pix_ptr = &stack[i + rx];
                 stack_pix_ptr->r = src_pix_ptr[R];
                 stack_pix_ptr->g = src_pix_ptr[G];
@@ -608,7 +600,8 @@ namespace agg
 
             stack_ptr = rx;
             xp = rx;
-                if(xp > wm) xp = wm;
+            if (xp > wm)
+                xp = wm;
             src_pix_ptr = img.pix_ptr(xp, y);
             dst_pix_ptr = img.pix_ptr(0, y);
             for (x = 0; x < w; x++)
@@ -623,7 +616,8 @@ namespace agg
                 sum_b -= sum_out_b;
 
                 stack_start = stack_ptr + div - rx;
-                    if(stack_start >= div) stack_start -= div;
+                if (stack_start >= div)
+                    stack_start -= div;
                 stack_pix_ptr = &stack[stack_start];
 
                 sum_out_r -= stack_pix_ptr->r;
@@ -648,7 +642,8 @@ namespace agg
                 sum_b += sum_in_b;
 
                 ++stack_ptr;
-                    if(stack_ptr >= div) stack_ptr = 0;
+                if (stack_ptr >= div)
+                    stack_ptr = 0;
                 stack_pix_ptr = &stack[stack_ptr];
 
                 sum_out_r += stack_pix_ptr->r;
@@ -663,7 +658,8 @@ namespace agg
 
     if (ry > 0)
     {
-            if(ry > 254) ry = 254;
+        if (ry > 254)
+            ry = 254;
         div = ry * 2 + 1;
         mul_sum = stack_blur_tables<int>::g_stack_blur8_mul[ry];
         shr_sum = stack_blur_tables<int>::g_stack_blur8_shr[ry];
@@ -672,15 +668,7 @@ namespace agg
         int stride = img.stride();
         for (x = 0; x < w; x++)
         {
-                sum_r = 
+            sum_r = sum_g = sum_b = sum_in_r = sum_in_g = sum_in_b = sum_out_r = sum_out_g = sum_out_b = 0;
-                sum_g = 
-                sum_b = 
-                sum_in_r = 
-                sum_in_g = 
-                sum_in_b = 
-                sum_out_r = 
-                sum_out_g = 
-                sum_out_b = 0;
 
             src_pix_ptr = img.pix_ptr(x, 0);
             for (i = 0; i <= ry; i++)
@@ -698,7 +686,8 @@ namespace agg
             }
             for (i = 1; i <= ry; i++)
             {
-                    if(i <= hm) src_pix_ptr += stride; 
+                if (i <= hm)
+                    src_pix_ptr += stride;
                 stack_pix_ptr = &stack[i + ry];
                 stack_pix_ptr->r = src_pix_ptr[R];
                 stack_pix_ptr->g = src_pix_ptr[G];
@@ -713,7 +702,8 @@ namespace agg
 
             stack_ptr = ry;
             yp = ry;
-                if(yp > hm) yp = hm;
+            if (yp > hm)
+                yp = hm;
             src_pix_ptr = img.pix_ptr(x, yp);
             dst_pix_ptr = img.pix_ptr(x, 0);
             for (y = 0; y < h; y++)
@@ -728,7 +718,8 @@ namespace agg
                 sum_b -= sum_out_b;
 
                 stack_start = stack_ptr + div - ry;
-                    if(stack_start >= div) stack_start -= div;
+                if (stack_start >= div)
+                    stack_start -= div;
 
                 stack_pix_ptr = &stack[stack_start];
                 sum_out_r -= stack_pix_ptr->r;
@@ -753,7 +744,8 @@ namespace agg
                 sum_b += sum_in_b;
 
                 ++stack_ptr;
-                    if(stack_ptr >= div) stack_ptr = 0;
+                if (stack_ptr >= div)
+                    stack_ptr = 0;
                 stack_pix_ptr = &stack[stack_ptr];
 
                 sum_out_r += stack_pix_ptr->r;
@@ -767,21 +759,13 @@ namespace agg
     }
 }
 
-
-
 //=======================================================stack_blur_rgba32
 template<class Img>
 void stack_blur_rgba32(Img& img, unsigned rx, unsigned ry)
 {
     typedef typename Img::color_type color_type;
     typedef typename Img::order_type order_type;
-        enum order_e 
+    enum order_e { R = order_type::R, G = order_type::G, B = order_type::B, A = order_type::A };
-        { 
-            R = order_type::R, 
-            G = order_type::G, 
-            B = order_type::B,
-            A = order_type::A 
-        };
 
     unsigned x, y, xp, yp, i;
     unsigned stack_ptr;
@@ -817,7 +801,8 @@ namespace agg
 
     if (rx > 0)
     {
-            if(rx > 254) rx = 254;
+        if (rx > 254)
+            rx = 254;
         div = rx * 2 + 1;
         mul_sum = stack_blur_tables<int>::g_stack_blur8_mul[rx];
         shr_sum = stack_blur_tables<int>::g_stack_blur8_shr[rx];
@@ -825,18 +810,8 @@ namespace agg
 
         for (y = 0; y < h; y++)
         {
-                sum_r = 
+            sum_r = sum_g = sum_b = sum_a = sum_in_r = sum_in_g = sum_in_b = sum_in_a = sum_out_r = sum_out_g =
-                sum_g = 
+              sum_out_b = sum_out_a = 0;
-                sum_b = 
-                sum_a = 
-                sum_in_r = 
-                sum_in_g = 
-                sum_in_b = 
-                sum_in_a = 
-                sum_out_r = 
-                sum_out_g = 
-                sum_out_b = 
-                sum_out_a = 0;
 
             src_pix_ptr = img.pix_ptr(0, y);
             for (i = 0; i <= rx; i++)
@@ -857,7 +832,8 @@ namespace agg
             }
             for (i = 1; i <= rx; i++)
             {
-                    if(i <= wm) src_pix_ptr += Img::pix_width; 
+                if (i <= wm)
+                    src_pix_ptr += Img::pix_width;
                 stack_pix_ptr = &stack[i + rx];
                 stack_pix_ptr->r = src_pix_ptr[R];
                 stack_pix_ptr->g = src_pix_ptr[G];
@@ -875,7 +851,8 @@ namespace agg
 
             stack_ptr = rx;
             xp = rx;
-                if(xp > wm) xp = wm;
+            if (xp > wm)
+                xp = wm;
             src_pix_ptr = img.pix_ptr(xp, y);
             dst_pix_ptr = img.pix_ptr(0, y);
             for (x = 0; x < w; x++)
@@ -892,7 +869,8 @@ namespace agg
                 sum_a -= sum_out_a;
 
                 stack_start = stack_ptr + div - rx;
-                    if(stack_start >= div) stack_start -= div;
+                if (stack_start >= div)
+                    stack_start -= div;
                 stack_pix_ptr = &stack[stack_start];
 
                 sum_out_r -= stack_pix_ptr->r;
@@ -921,7 +899,8 @@ namespace agg
                 sum_a += sum_in_a;
 
                 ++stack_ptr;
-                    if(stack_ptr >= div) stack_ptr = 0;
+                if (stack_ptr >= div)
+                    stack_ptr = 0;
                 stack_pix_ptr = &stack[stack_ptr];
 
                 sum_out_r += stack_pix_ptr->r;
@@ -938,7 +917,8 @@ namespace agg
 
     if (ry > 0)
     {
-            if(ry > 254) ry = 254;
+        if (ry > 254)
+            ry = 254;
         div = ry * 2 + 1;
         mul_sum = stack_blur_tables<int>::g_stack_blur8_mul[ry];
         shr_sum = stack_blur_tables<int>::g_stack_blur8_shr[ry];
@@ -947,18 +927,8 @@ namespace agg
         int stride = img.stride();
         for (x = 0; x < w; x++)
         {
-                sum_r = 
+            sum_r = sum_g = sum_b = sum_a = sum_in_r = sum_in_g = sum_in_b = sum_in_a = sum_out_r = sum_out_g =
-                sum_g = 
+              sum_out_b = sum_out_a = 0;
-                sum_b = 
-                sum_a = 
-                sum_in_r = 
-                sum_in_g = 
-                sum_in_b = 
-                sum_in_a = 
-                sum_out_r = 
-                sum_out_g = 
-                sum_out_b = 
-                sum_out_a = 0;
 
             src_pix_ptr = img.pix_ptr(x, 0);
             for (i = 0; i <= ry; i++)
@@ -979,7 +949,8 @@ namespace agg
             }
             for (i = 1; i <= ry; i++)
             {
-                    if(i <= hm) src_pix_ptr += stride; 
+                if (i <= hm)
+                    src_pix_ptr += stride;
                 stack_pix_ptr = &stack[i + ry];
                 stack_pix_ptr->r = src_pix_ptr[R];
                 stack_pix_ptr->g = src_pix_ptr[G];
@@ -997,7 +968,8 @@ namespace agg
 
             stack_ptr = ry;
             yp = ry;
-                if(yp > hm) yp = hm;
+            if (yp > hm)
+                yp = hm;
             src_pix_ptr = img.pix_ptr(x, yp);
             dst_pix_ptr = img.pix_ptr(x, 0);
             for (y = 0; y < h; y++)
@@ -1014,7 +986,8 @@ namespace agg
                 sum_a -= sum_out_a;
 
                 stack_start = stack_ptr + div - ry;
-                    if(stack_start >= div) stack_start -= div;
+                if (stack_start >= div)
+                    stack_start -= div;
 
                 stack_pix_ptr = &stack[stack_start];
                 sum_out_r -= stack_pix_ptr->r;
@@ -1043,7 +1016,8 @@ namespace agg
                 sum_a += sum_in_a;
 
                 ++stack_ptr;
-                    if(stack_ptr >= div) stack_ptr = 0;
+                if (stack_ptr >= div)
+                    stack_ptr = 0;
                 stack_pix_ptr = &stack[stack_ptr];
 
                 sum_out_r += stack_pix_ptr->r;
@@ -1059,10 +1033,9 @@ namespace agg
     }
 }
 
-
-
 //===========================================================recursive_blur
-    template<class ColorT, class CalculatorT> class recursive_blur
+template<class ColorT, class CalculatorT>
+class recursive_blur
 {
   public:
     typedef ColorT color_type;
@@ -1071,30 +1044,25 @@ namespace agg
     typedef typename calculator_type::value_type calc_type;
 
     //--------------------------------------------------------------------
-        template<class Img> void blur_x(Img& img, double radius)
+    template<class Img>
+    void blur_x(Img& img, double radius)
     {
-            if(radius < 0.62) return;
+        if (radius < 0.62)
-            if(img.width() < 3) return;
+            return;
+        if (img.width() < 3)
+            return;
 
         calc_type s = calc_type(radius * 0.5);
-            calc_type q = calc_type((s < 2.5) ?
+        calc_type q = calc_type((s < 2.5) ? 3.97156 - 4.14554 * sqrt(1 - 0.26891 * s) : 0.98711 * s - 0.96330);
-                                    3.97156 - 4.14554 * sqrt(1 - 0.26891 * s) :
-                                    0.98711 * s - 0.96330);
 
         calc_type q2 = calc_type(q * q);
         calc_type q3 = calc_type(q2 * q);
 
-            calc_type b0 = calc_type(1.0 / (1.578250 + 
+        calc_type b0 = calc_type(1.0 / (1.578250 + 2.444130 * q + 1.428100 * q2 + 0.422205 * q3));
-                                            2.444130 * q + 
-                                            1.428100 * q2 + 
-                                            0.422205 * q3));
 
-            calc_type b1 = calc_type( 2.44413 * q + 
+        calc_type b1 = calc_type(2.44413 * q + 2.85619 * q2 + 1.26661 * q3);
-                                      2.85619 * q2 + 
-                                      1.26661 * q3);
 
-            calc_type b2 = calc_type(-1.42810 * q2 + 
+        calc_type b2 = calc_type(-1.42810 * q2 + -1.26661 * q3);
-                                     -1.26661 * q3);
 
         calc_type b3 = calc_type(0.422205 * q3);
 
@@ -1146,14 +1114,16 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        template<class Img> void blur_y(Img& img, double radius)
+    template<class Img>
+    void blur_y(Img& img, double radius)
     {
         pixfmt_transposer<Img> img2(img);
         blur_x(img2, radius);
     }
 
     //--------------------------------------------------------------------
-        template<class Img> void blur(Img& img, double radius)
+    template<class Img>
+    void blur(Img& img, double radius)
     {
         blur_x(img, radius);
         pixfmt_transposer<Img> img2(img);
@@ -1166,9 +1136,9 @@ namespace agg
     agg::pod_vector<color_type> m_buf;
 };
 
-
 //=================================================recursive_blur_calc_rgba
-    template<class T=double> struct recursive_blur_calc_rgba
+template<class T = double>
+struct recursive_blur_calc_rgba
 {
     typedef T value_type;
     typedef recursive_blur_calc_rgba<T> self_type;
@@ -1210,9 +1180,9 @@ namespace agg
     }
 };
 
-
 //=================================================recursive_blur_calc_rgb
-    template<class T=double> struct recursive_blur_calc_rgb
+template<class T = double>
+struct recursive_blur_calc_rgb
 {
     typedef T value_type;
     typedef recursive_blur_calc_rgb<T> self_type;
@@ -1251,9 +1221,9 @@ namespace agg
     }
 };
 
-
 //================================================recursive_blur_calc_gray
-    template<class T=double> struct recursive_blur_calc_gray
+template<class T = double>
+struct recursive_blur_calc_gray
 {
     typedef T value_type;
     typedef recursive_blur_calc_gray<T> self_type;
@@ -1286,9 +1256,6 @@ namespace agg
     }
 };
 
-}
+} // namespace agg
-
-
-
 
 #endif

deps/agg/include/agg_bounding_rect.h

@@ -21,14 +21,18 @@
 
 #include "agg_basics.h"
 
-namespace agg
+namespace agg {
-{
 
 //-----------------------------------------------------------bounding_rect
 template<class VertexSource, class GetId, class CoordT>
-    bool bounding_rect(VertexSource& vs, GetId& gi, 
+bool bounding_rect(VertexSource& vs,
-                       unsigned start, unsigned num, 
+                   GetId& gi,
-                       CoordT* x1, CoordT* y1, CoordT* x2, CoordT* y2)
+                   unsigned start,
+                   unsigned num,
+                   CoordT* x1,
+                   CoordT* y1,
+                   CoordT* x2,
+                   CoordT* y2)
 {
     unsigned i;
     double x;
@@ -58,10 +62,14 @@ namespace agg
                 }
                 else
                 {
-                        if(CoordT(x) < *x1) *x1 = CoordT(x);
+                    if (CoordT(x) < *x1)
-                        if(CoordT(y) < *y1) *y1 = CoordT(y);
+                        *x1 = CoordT(x);
-                        if(CoordT(x) > *x2) *x2 = CoordT(x);
+                    if (CoordT(y) < *y1)
-                        if(CoordT(y) > *y2) *y2 = CoordT(y);
+                        *y1 = CoordT(y);
+                    if (CoordT(x) > *x2)
+                        *x2 = CoordT(x);
+                    if (CoordT(y) > *y2)
+                        *y2 = CoordT(y);
                 }
             }
         }
@@ -69,11 +77,9 @@ namespace agg
     return *x1 <= *x2 && *y1 <= *y2;
 }
 
-
 //-----------------------------------------------------bounding_rect_single
 template<class VertexSource, class CoordT>
-    bool bounding_rect_single(VertexSource& vs, unsigned path_id,
+bool bounding_rect_single(VertexSource& vs, unsigned path_id, CoordT* x1, CoordT* y1, CoordT* x2, CoordT* y2)
-                              CoordT* x1, CoordT* y1, CoordT* x2, CoordT* y2)
 {
     double x;
     double y;
@@ -100,17 +106,20 @@ namespace agg
             }
             else
             {
-                    if(CoordT(x) < *x1) *x1 = CoordT(x);
+                if (CoordT(x) < *x1)
-                    if(CoordT(y) < *y1) *y1 = CoordT(y);
+                    *x1 = CoordT(x);
-                    if(CoordT(x) > *x2) *x2 = CoordT(x);
+                if (CoordT(y) < *y1)
-                    if(CoordT(y) > *y2) *y2 = CoordT(y);
+                    *y1 = CoordT(y);
+                if (CoordT(x) > *x2)
+                    *x2 = CoordT(x);
+                if (CoordT(y) > *y2)
+                    *y2 = CoordT(y);
             }
         }
     }
     return *x1 <= *x2 && *y1 <= *y2;
 }
 
-
+} // namespace agg
-}
 
 #endif

deps/agg/include/agg_bspline.h

@@ -22,8 +22,7 @@
 
 #include "agg_array.h"
 
-namespace agg
+namespace agg {
-{
 //----------------------------------------------------------------bspline
 // A very simple class of Bi-cubic Spline interpolation.
 // First call init(num, x[], y[]) where num - number of source points,
@@ -70,7 +69,6 @@ namespace agg
     mutable int m_last_idx;
 };
 
-
+} // namespace agg
-}
 
 #endif

deps/agg/include/agg_clip_liang_barsky.h

@@ -21,12 +21,10 @@
 
 #include "agg_basics.h"
 
-namespace agg
+namespace agg {
-{
 
 //------------------------------------------------------------------------
-    enum clipping_flags_e
+enum clipping_flags_e {
-    {
     clipping_flags_x1_clipped = 4,
     clipping_flags_x2_clipped = 1,
     clipping_flags_y1_clipped = 8,
@@ -56,10 +54,7 @@ namespace agg
 template<class T>
 inline unsigned clipping_flags(T x, T y, const rect_base<T>& clip_box)
 {
-        return  (x > clip_box.x2) |
+    return (x > clip_box.x2) | ((y > clip_box.y2) << 1) | ((x < clip_box.x1) << 2) | ((y < clip_box.y1) << 3);
-               ((y > clip_box.y2) << 1) |
-               ((x < clip_box.x1) << 2) |
-               ((y < clip_box.y1) << 3);
 }
 
 //--------------------------------------------------------clipping_flags_x
@@ -69,7 +64,6 @@ namespace agg
     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)
@@ -77,12 +71,9 @@ namespace agg
     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,
+inline unsigned clip_liang_barsky(T x1, T y1, T x2, T y2, const rect_base<T>& clip_box, T* x, T* y)
-                                      const rect_base<T>& clip_box,
-                                      T* x, T* y)
 {
     const double nearzero = 1e-30;
 
@@ -228,12 +219,9 @@ namespace agg
     return np;
 }
 
-
 //----------------------------------------------------------------------------
 template<class T>
-    bool clip_move_point(T x1, T y1, T x2, T y2,
+bool clip_move_point(T x1, T y1, T x2, T y2, const rect_base<T>& clip_box, T* x, T* y, unsigned flags)
-                         const rect_base<T>& clip_box,
-                         T* x, T* y, unsigned flags)
 {
     T bound;
 
@@ -268,8 +256,7 @@ namespace agg
 //          (ret & 2) != 0  - Second point has been moved
 //
 template<class T>
-    unsigned clip_line_segment(T* x1, T* y1, T* x2, T* y2,
+unsigned clip_line_segment(T* x1, T* y1, T* x2, T* y2, const rect_base<T>& clip_box)
-                               const rect_base<T>& clip_box)
 {
     unsigned f1 = clipping_flags(*x1, *y1, clip_box);
     unsigned f2 = clipping_flags(*x2, *y2, clip_box);
@@ -281,15 +268,13 @@ namespace agg
         return 0;
     }
 
-        if((f1 & clipping_flags_x_clipped) != 0 &&
+    if ((f1 & clipping_flags_x_clipped) != 0 && (f1 & clipping_flags_x_clipped) == (f2 & clipping_flags_x_clipped))
-           (f1 & clipping_flags_x_clipped) == (f2 & clipping_flags_x_clipped))
     {
         // Fully clipped
         return 4;
     }
 
-        if((f1 & clipping_flags_y_clipped) != 0 &&
+    if ((f1 & clipping_flags_y_clipped) != 0 && (f1 & clipping_flags_y_clipped) == (f2 & clipping_flags_y_clipped))
-           (f1 & clipping_flags_y_clipped) == (f2 & clipping_flags_y_clipped))
     {
         // Fully clipped
         return 4;
@@ -326,8 +311,6 @@ namespace agg
     return ret;
 }
 
-
+} // namespace agg
-}
-
 
 #endif

deps/agg/include/agg_color_gray.h

@@ -31,8 +31,7 @@
 #include "agg_basics.h"
 #include "agg_color_rgba.h"
 
-namespace agg
+namespace agg {
-{
 
 //===================================================================gray8
 template<class Colorspace>
@@ -41,8 +40,7 @@ struct gray8T
     typedef int8u value_type;
     typedef int32u calc_type;
     typedef int32 long_type;
-    enum base_scale_e
+    enum base_scale_e {
-    {
         base_shift = 8,
         base_scale = 1 << base_shift,
         base_mask = base_scale - 1,
@@ -105,17 +103,22 @@ struct gray8T
     gray8T() {}
 
     //--------------------------------------------------------------------
-    gray8T(unsigned v_, unsigned a_=base_mask) :
+    gray8T(unsigned v_, unsigned a_ = base_mask)
-        v(int8u(v_)), a(int8u(a_)) {}
+        : v(int8u(v_))
+        , a(int8u(a_))
+    {}
 
     //--------------------------------------------------------------------
-    gray8T(const self_type& c, unsigned a_) :
+    gray8T(const self_type& c, unsigned a_)
-        v(c.v), a(value_type(a_)) {}
+        : v(c.v)
+        , a(value_type(a_))
+    {}
 
     //--------------------------------------------------------------------
-    gray8T(const rgba& c) :
+    gray8T(const rgba& c)
-        v(luminance(c)),
+        : v(luminance(c))
-        a(value_type(uround(c.a * base_mask))) {}
+        , a(value_type(uround(c.a * base_mask)))
+    {}
 
     //--------------------------------------------------------------------
     template<class T>
@@ -147,36 +150,18 @@ struct gray8T
     }
 
     //--------------------------------------------------------------------
-    rgba8 make_rgba8(const linear&) const
+    rgba8 make_rgba8(const linear&) const { return rgba8(v, v, v, a); }
-    {
-        return rgba8(v, v, v, a);
-    }
 
-    rgba8 make_rgba8(const sRGB&) const
+    rgba8 make_rgba8(const sRGB&) const { return convert_from_sRGB<srgba8>(); }
-    {
-        return convert_from_sRGB<srgba8>();
-    }
 
-    operator rgba8() const
+    operator rgba8() const { return make_rgba8(Colorspace()); }
-    {
-        return make_rgba8(Colorspace());
-    }
 
     //--------------------------------------------------------------------
-    srgba8 make_srgba8(const linear&) const
+    srgba8 make_srgba8(const linear&) const { return convert_to_sRGB<rgba8>(); }
-    {
-        return convert_to_sRGB<rgba8>();
-    }
 
-    srgba8 make_srgba8(const sRGB&) const
+    srgba8 make_srgba8(const sRGB&) const { return srgba8(v, v, v, a); }
-    {
-        return srgba8(v, v, v, a);
-    }
 
-    operator srgba8() const
+    operator srgba8() const { return make_rgba8(Colorspace()); }
-    {
-        return make_rgba8(Colorspace());
-    }
 
     //--------------------------------------------------------------------
     rgba16 make_rgba16(const linear&) const
@@ -185,15 +170,9 @@ struct gray8T
         return rgba16(rgb, rgb, rgb, (a << 8) | a);
     }
 
-    rgba16 make_rgba16(const sRGB&) const
+    rgba16 make_rgba16(const sRGB&) const { return convert_from_sRGB<rgba16>(); }
-    {
-        return convert_from_sRGB<rgba16>();
-    }
 
-    operator rgba16() const
+    operator rgba16() const { return make_rgba16(Colorspace()); }
-    {
-        return make_rgba16(Colorspace());
-    }
 
     //--------------------------------------------------------------------
     rgba32 make_rgba32(const linear&) const
@@ -202,51 +181,27 @@ struct gray8T
         return rgba32(v32, v32, v32, a / 255.0);
     }
 
-    rgba32 make_rgba32(const sRGB&) const
+    rgba32 make_rgba32(const sRGB&) const { return convert_from_sRGB<rgba32>(); }
-    {
-        return convert_from_sRGB<rgba32>();
-    }
 
-    operator rgba32() const
+    operator rgba32() const { return make_rgba32(Colorspace()); }
-    {
-        return make_rgba32(Colorspace());
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE double to_double(value_type a)
+    static AGG_INLINE double to_double(value_type a) { return double(a) / base_mask; }
-    {
-        return double(a) / base_mask;
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type from_double(double a)
+    static AGG_INLINE value_type from_double(double a) { return value_type(uround(a * base_mask)); }
-    {
-        return value_type(uround(a * base_mask));
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type empty_value()
+    static AGG_INLINE value_type empty_value() { return 0; }
-    {
-        return 0;
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type full_value()
+    static AGG_INLINE value_type full_value() { return base_mask; }
-    {
-        return base_mask;
-    }
 
     //--------------------------------------------------------------------
-    AGG_INLINE bool is_transparent() const
+    AGG_INLINE bool is_transparent() const { return a == 0; }
-    {
-        return a == 0;
-    }
 
     //--------------------------------------------------------------------
-    AGG_INLINE bool is_opaque() const
+    AGG_INLINE bool is_opaque() const { return a == base_mask; }
-    {
-        return a == base_mask;
-    }
 
     //--------------------------------------------------------------------
     // Fixed-point multiply, exact over int8u.
@@ -267,7 +222,8 @@ struct gray8T
         {
             return base_mask;
         }
-        else return value_type((a * base_mask + (b >> 1)) / b);
+        else
+            return value_type((a * base_mask + (b >> 1)) / b);
     }
 
     //--------------------------------------------------------------------
@@ -287,23 +243,14 @@ struct gray8T
     //--------------------------------------------------------------------
     // 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)
+    static AGG_INLINE value_type mult_cover(value_type a, value_type b) { return multiply(a, b); }
-    {
-        return multiply(a, b);
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
+    static AGG_INLINE cover_type scale_cover(cover_type a, value_type b) { return multiply(b, a); }
-    {
-        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)
+    static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a) { return p + q - multiply(p, a); }
-    {
-        return p + q - multiply(p, a);
-    }
 
     //--------------------------------------------------------------------
     // Interpolate p to q by a.
@@ -330,25 +277,27 @@ struct gray8T
     //--------------------------------------------------------------------
     self_type& opacity(double a_)
     {
-        if (a_ < 0) a = 0;
+        if (a_ < 0)
-        else if (a_ > 1) a = 1;
+            a = 0;
-        else a = (value_type)uround(a_ * double(base_mask));
+        else if (a_ > 1)
+            a = 1;
+        else
+            a = (value_type)uround(a_ * double(base_mask));
         return *this;
     }
 
     //--------------------------------------------------------------------
-    double opacity() const
+    double opacity() const { return double(a) / double(base_mask); }
-    {
-        return double(a) / double(base_mask);
-    }
 
     //--------------------------------------------------------------------
     self_type& premultiply()
     {
         if (a < base_mask)
         {
-            if (a == 0) v = 0;
+            if (a == 0)
-            else v = multiply(v, a);
+                v = 0;
+            else
+                v = multiply(v, a);
         }
         return *this;
     }
@@ -414,15 +363,13 @@ struct gray8T
 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
+    enum base_scale_e {
-    {
         base_shift = 16,
         base_scale = 1 << base_shift,
         base_mask = base_scale - 1,
@@ -445,67 +392,65 @@ struct gray16
         return value_type((13933u * c.r + 46872u * c.g + 4732u * c.b) >> 16);
     }
 
-    static value_type luminance(const rgba8& c)
+    static value_type luminance(const rgba8& c) { return luminance(rgba16(c)); }
-    {
-        return luminance(rgba16(c));
-    }
 
-    static value_type luminance(const srgba8& c)
+    static value_type luminance(const srgba8& c) { return luminance(rgba16(c)); }
-    {
-        return luminance(rgba16(c));
-    }
 
-    static value_type luminance(const rgba32& c)
+    static value_type luminance(const rgba32& c) { return luminance(rgba(c)); }
-    {
-        return luminance(rgba(c));
-    }
 
     //--------------------------------------------------------------------
     gray16() {}
 
     //--------------------------------------------------------------------
-    gray16(unsigned v_, unsigned a_ = base_mask) :
+    gray16(unsigned v_, unsigned a_ = base_mask)
-        v(int16u(v_)), a(int16u(a_)) {}
+        : v(int16u(v_))
+        , a(int16u(a_))
+    {}
 
     //--------------------------------------------------------------------
-    gray16(const self_type& c, unsigned a_) :
+    gray16(const self_type& c, unsigned a_)
-        v(c.v), a(value_type(a_)) {}
+        : v(c.v)
+        , a(value_type(a_))
+    {}
 
     //--------------------------------------------------------------------
-    gray16(const rgba& c) :
+    gray16(const rgba& c)
-        v(luminance(c)),
+        : v(luminance(c))
-        a((value_type)uround(c.a * double(base_mask))) {}
+        , a((value_type)uround(c.a * double(base_mask)))
+    {}
 
     //--------------------------------------------------------------------
-    gray16(const rgba8& c) :
+    gray16(const rgba8& c)
-        v(luminance(c)),
+        : v(luminance(c))
-        a((value_type(c.a) << 8) | c.a) {}
+        , a((value_type(c.a) << 8) | c.a)
+    {}
 
     //--------------------------------------------------------------------
-    gray16(const srgba8& c) :
+    gray16(const srgba8& c)
-        v(luminance(c)),
+        : v(luminance(c))
-        a((value_type(c.a) << 8) | c.a) {}
+        , a((value_type(c.a) << 8) | c.a)
+    {}
 
     //--------------------------------------------------------------------
-    gray16(const rgba16& c) :
+    gray16(const rgba16& c)
-        v(luminance(c)),
+        : v(luminance(c))
-        a(c.a) {}
+        , a(c.a)
+    {}
 
     //--------------------------------------------------------------------
-    gray16(const gray8& c) :
+    gray16(const gray8& c)
-        v((value_type(c.v) << 8) | c.v),
+        : v((value_type(c.v) << 8) | c.v)
-        a((value_type(c.a) << 8) | c.a) {}
+        , a((value_type(c.a) << 8) | c.a)
+    {}
 
     //--------------------------------------------------------------------
-    gray16(const sgray8& c) :
+    gray16(const sgray8& c)
-        v(sRGB_conv<value_type>::rgb_from_sRGB(c.v)),
+        : v(sRGB_conv<value_type>::rgb_from_sRGB(c.v))
-        a(sRGB_conv<value_type>::alpha_from_sRGB(c.a)) {}
+        , a(sRGB_conv<value_type>::alpha_from_sRGB(c.a))
+    {}
 
     //--------------------------------------------------------------------
-    operator rgba8() const
+    operator rgba8() const { return rgba8(v >> 8, v >> 8, v >> 8, a >> 8); }
-    {
-        return rgba8(v >> 8, v >> 8, v >> 8, a >> 8);
-    }
 
     //--------------------------------------------------------------------
     operator srgba8() const
@@ -515,60 +460,34 @@ struct gray16
     }
 
     //--------------------------------------------------------------------
-    operator rgba16() const
+    operator rgba16() const { return rgba16(v, v, v, a); }
-    {
-        return rgba16(v, v, v, a);
-    }
 
     //--------------------------------------------------------------------
-    operator gray8() const
+    operator gray8() const { return gray8(v >> 8, a >> 8); }
-    {
-        return gray8(v >> 8, a >> 8);
-    }
 
     //--------------------------------------------------------------------
     operator sgray8() const
     {
-        return sgray8(
+        return sgray8(sRGB_conv<value_type>::rgb_to_sRGB(v), sRGB_conv<value_type>::alpha_to_sRGB(a));
-            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)
+    static AGG_INLINE double to_double(value_type a) { return double(a) / base_mask; }
-    {
-        return double(a) / base_mask;
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type from_double(double a)
+    static AGG_INLINE value_type from_double(double a) { return value_type(uround(a * base_mask)); }
-    {
-        return value_type(uround(a * base_mask));
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type empty_value()
+    static AGG_INLINE value_type empty_value() { return 0; }
-    {
-        return 0;
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type full_value()
+    static AGG_INLINE value_type full_value() { return base_mask; }
-    {
-        return base_mask;
-    }
 
     //--------------------------------------------------------------------
-    AGG_INLINE bool is_transparent() const
+    AGG_INLINE bool is_transparent() const { return a == 0; }
-    {
-        return a == 0;
-    }
 
     //--------------------------------------------------------------------
-    AGG_INLINE bool is_opaque() const
+    AGG_INLINE bool is_opaque() const { return a == base_mask; }
-    {
-        return a == base_mask;
-    }
 
     //--------------------------------------------------------------------
     // Fixed-point multiply, exact over int16u.
@@ -589,7 +508,8 @@ struct gray16
         {
             return base_mask;
         }
-        else return value_type((a * base_mask + (b >> 1)) / b);
+        else
+            return value_type((a * base_mask + (b >> 1)) / b);
     }
 
     //--------------------------------------------------------------------
@@ -609,23 +529,14 @@ struct gray16
     //--------------------------------------------------------------------
     // 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)
+    static AGG_INLINE value_type mult_cover(value_type a, cover_type b) { return multiply(a, b << 8 | b); }
-    {
-        return multiply(a, b << 8 | b);
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
+    static AGG_INLINE cover_type scale_cover(cover_type a, value_type b) { return mult_cover(b, a) >> 8; }
-    {
-        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)
+    static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a) { return p + q - multiply(p, a); }
-    {
-        return p + q - multiply(p, a);
-    }
 
     //--------------------------------------------------------------------
     // Interpolate p to q by a.
@@ -652,26 +563,27 @@ struct gray16
     //--------------------------------------------------------------------
     self_type& opacity(double a_)
     {
-        if (a_ < 0) a = 0;
+        if (a_ < 0)
-        else if(a_ > 1) a = 1;
+            a = 0;
-        else a = (value_type)uround(a_ * double(base_mask));
+        else if (a_ > 1)
+            a = 1;
+        else
+            a = (value_type)uround(a_ * double(base_mask));
         return *this;
     }
 
     //--------------------------------------------------------------------
-    double opacity() const
+    double opacity() const { return double(a) / double(base_mask); }
-    {
-        return double(a) / double(base_mask);
-    }
-
 
     //--------------------------------------------------------------------
     self_type& premultiply()
     {
         if (a < base_mask)
         {
-            if(a == 0) v = 0;
+            if (a == 0)
-            else v = multiply(v, a);
+                v = 0;
+            else
+                v = multiply(v, a);
         }
         return *this;
     }
@@ -734,7 +646,6 @@ struct gray16
     static self_type no_color() { return self_type(0, 0); }
 };
 
-
 //===================================================================gray32
 struct gray32
 {
@@ -746,8 +657,7 @@ struct gray32
     value_type v;
     value_type a;
 
-    enum base_scale_e
+    enum base_scale_e {
-    {
         base_shift = 8,
         base_scale = 1 << base_shift,
         base_mask = base_scale - 1,
@@ -759,103 +669,92 @@ struct gray32
         return value_type(0.2126 * r + 0.7152 * g + 0.0722 * b);
     }
 
-    static value_type luminance(const rgba& c)
+    static value_type luminance(const rgba& c) { return luminance(c.r, c.g, c.b); }
-    {
-        return luminance(c.r, c.g, c.b);
-    }
 
-    static value_type luminance(const rgba32& c)
+    static value_type luminance(const rgba32& c) { return luminance(c.r, c.g, c.b); }
-    {
-        return luminance(c.r, c.g, c.b);
-    }
 
-    static value_type luminance(const rgba8& c)
+    static value_type luminance(const rgba8& c) { return luminance(c.r / 255.0, c.g / 255.0, c.g / 255.0); }
-    {
-        return luminance(c.r / 255.0, c.g / 255.0, c.g / 255.0);
-    }
 
-    static value_type luminance(const rgba16& c)
+    static value_type luminance(const rgba16& c) { return luminance(c.r / 65535.0, c.g / 65535.0, c.g / 65535.0); }
-    {
-        return luminance(c.r / 65535.0, c.g / 65535.0, c.g / 65535.0);
-    }
 
     //--------------------------------------------------------------------
     gray32() {}
 
     //--------------------------------------------------------------------
-    gray32(value_type v_, value_type a_ = 1) :
+    gray32(value_type v_, value_type a_ = 1)
-        v(v_), a(a_) {}
+        : v(v_)
+        , a(a_)
+    {}
 
     //--------------------------------------------------------------------
-    gray32(const self_type& c, value_type a_) :
+    gray32(const self_type& c, value_type a_)
-        v(c.v), a(a_) {}
+        : v(c.v)
+        , a(a_)
+    {}
 
     //--------------------------------------------------------------------
-    gray32(const rgba& c) :
+    gray32(const rgba& c)
-        v(luminance(c)),
+        : v(luminance(c))
-        a(value_type(c.a)) {}
+        , a(value_type(c.a))
+    {}
 
     //--------------------------------------------------------------------
-    gray32(const rgba8& c) :
+    gray32(const rgba8& c)
-        v(luminance(c)),
+        : v(luminance(c))
-        a(value_type(c.a / 255.0)) {}
+        , a(value_type(c.a / 255.0))
+    {}
 
     //--------------------------------------------------------------------
-    gray32(const srgba8& c) :
+    gray32(const srgba8& c)
-        v(luminance(rgba32(c))),
+        : v(luminance(rgba32(c)))
-        a(value_type(c.a / 255.0)) {}
+        , a(value_type(c.a / 255.0))
+    {}
 
     //--------------------------------------------------------------------
-    gray32(const rgba16& c) :
+    gray32(const rgba16& c)
-        v(luminance(c)),
+        : v(luminance(c))
-        a(value_type(c.a / 65535.0)) {}
+        , a(value_type(c.a / 65535.0))
+    {}
 
     //--------------------------------------------------------------------
-    gray32(const rgba32& c) :
+    gray32(const rgba32& c)
-        v(luminance(c)),
+        : v(luminance(c))
-        a(value_type(c.a)) {}
+        , a(value_type(c.a))
+    {}
 
     //--------------------------------------------------------------------
-    gray32(const gray8& c) :
+    gray32(const gray8& c)
-        v(value_type(c.v / 255.0)),
+        : v(value_type(c.v / 255.0))
-        a(value_type(c.a / 255.0)) {}
+        , a(value_type(c.a / 255.0))
+    {}
 
     //--------------------------------------------------------------------
-    gray32(const sgray8& c) :
+    gray32(const sgray8& c)
-        v(sRGB_conv<value_type>::rgb_from_sRGB(c.v)),
+        : v(sRGB_conv<value_type>::rgb_from_sRGB(c.v))
-        a(sRGB_conv<value_type>::alpha_from_sRGB(c.a)) {}
+        , a(sRGB_conv<value_type>::alpha_from_sRGB(c.a))
+    {}
 
     //--------------------------------------------------------------------
-    gray32(const gray16& c) :
+    gray32(const gray16& c)
-        v(value_type(c.v / 65535.0)),
+        : v(value_type(c.v / 65535.0))
-        a(value_type(c.a / 65535.0)) {}
+        , a(value_type(c.a / 65535.0))
+    {}
 
     //--------------------------------------------------------------------
-    operator rgba() const
+    operator rgba() const { return rgba(v, v, v, a); }
-    {
-        return rgba(v, v, v, a);
-    }
 
     //--------------------------------------------------------------------
-    operator gray8() const
+    operator gray8() const { return gray8(uround(v * 255.0), uround(a * 255.0)); }
-    {
-        return gray8(uround(v * 255.0), uround(a * 255.0));
-    }
 
     //--------------------------------------------------------------------
     operator sgray8() const
     {
         // Return (non-premultiplied) sRGB values.
-        return sgray8(
+        return sgray8(sRGB_conv<value_type>::rgb_to_sRGB(v), sRGB_conv<value_type>::alpha_to_sRGB(a));
-            sRGB_conv<value_type>::rgb_to_sRGB(v),
-            sRGB_conv<value_type>::alpha_to_sRGB(a));
     }
 
     //--------------------------------------------------------------------
-    operator gray16() const
+    operator gray16() const { return gray16(uround(v * 65535.0), uround(a * 65535.0)); }
-    {
-        return gray16(uround(v * 65535.0), uround(a * 65535.0));
-    }
 
     //--------------------------------------------------------------------
     operator rgba8() const
@@ -879,58 +778,31 @@ struct gray32
     }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE double to_double(value_type a)
+    static AGG_INLINE double to_double(value_type a) { return a; }
-    {
-        return a;
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type from_double(double a)
+    static AGG_INLINE value_type from_double(double a) { return value_type(a); }
-    {
-        return value_type(a);
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type empty_value()
+    static AGG_INLINE value_type empty_value() { return 0; }
-    {
-        return 0;
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type full_value()
+    static AGG_INLINE value_type full_value() { return 1; }
-    {
-        return 1;
-    }
 
     //--------------------------------------------------------------------
-    AGG_INLINE bool is_transparent() const
+    AGG_INLINE bool is_transparent() const { return a <= 0; }
-    {
-        return a <= 0;
-    }
 
     //--------------------------------------------------------------------
-    AGG_INLINE bool is_opaque() const
+    AGG_INLINE bool is_opaque() const { return a >= 1; }
-    {
-        return a >= 1;
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type invert(value_type x)
+    static AGG_INLINE value_type invert(value_type x) { return 1 - x; }
-    {
-        return 1 - x;
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type multiply(value_type a, value_type b)
+    static AGG_INLINE value_type multiply(value_type a, value_type b) { return value_type(a * b); }
-    {
-        return value_type(a * b);
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type demultiply(value_type a, value_type b)
+    static AGG_INLINE value_type demultiply(value_type a, value_type b) { return (b == 0) ? 0 : value_type(a / b); }
-    {
-        return (b == 0) ? 0 : value_type(a / b);
-    }
 
     //--------------------------------------------------------------------
     template<typename T>
@@ -947,16 +819,10 @@ struct gray32
     }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type mult_cover(value_type a, cover_type b)
+    static AGG_INLINE value_type mult_cover(value_type a, cover_type b) { return value_type(a * b / cover_mask); }
-    {
-        return value_type(a * b / cover_mask);
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
+    static AGG_INLINE cover_type scale_cover(cover_type a, value_type b) { return cover_type(uround(a * b)); }
-    {
-        return cover_type(uround(a * b));
-    }
 
     //--------------------------------------------------------------------
     // Interpolate p to q by a, assuming q is premultiplied by a.
@@ -993,49 +859,47 @@ struct gray32
     //--------------------------------------------------------------------
     self_type& opacity(double a_)
     {
-        if (a_ < 0) a = 0;
+        if (a_ < 0)
-        else if (a_ > 1) a = 1;
+            a = 0;
-        else a = value_type(a_);
+        else if (a_ > 1)
+            a = 1;
+        else
+            a = value_type(a_);
         return *this;
     }
 
     //--------------------------------------------------------------------
-    double opacity() const
+    double opacity() const { return a; }
-    {
-        return a;
-    }
-
 
     //--------------------------------------------------------------------
     self_type& premultiply()
     {
-        if (a < 0) v = 0;
+        if (a < 0)
-        else if(a < 1) v *= a;
+            v = 0;
+        else if (a < 1)
+            v *= a;
         return *this;
     }
 
     //--------------------------------------------------------------------
     self_type& demultiply()
     {
-        if (a < 0) v = 0;
+        if (a < 0)
-        else if (a < 1) v /= a;
+            v = 0;
+        else if (a < 1)
+            v /= a;
         return *this;
     }
 
     //--------------------------------------------------------------------
     self_type gradient(self_type c, double k) const
     {
-        return self_type(
+        return self_type(value_type(v + (c.v - v) * k), value_type(a + (c.a - a) * k));
-            value_type(v + (c.v - v) * k),
-            value_type(a + (c.a - a) * k));
     }
 
     //--------------------------------------------------------------------
     static self_type no_color() { return self_type(0, 0); }
 };
-}
+} // namespace agg
-
-
-
 
 #endif

deps/agg/include/agg_color_rgba.h

@@ -28,20 +28,39 @@
 #include "agg_basics.h"
 #include "agg_gamma_lut.h"
 
-namespace agg
+namespace agg {
-{
 // Supported byte orders for RGB and RGBA pixel formats
 //=======================================================================
-struct order_rgb  { enum rgb_e  { R=0, G=1, B=2, rgb_tag, hasAlpha=false }; };       //----order_rgb
+struct order_rgb
-struct order_bgr  { enum bgr_e  { B=0, G=1, R=2, rgb_tag, hasAlpha=false }; };       //----order_bgr
+{
-struct order_rgba { enum rgba_e { R=0, G=1, B=2, A=3, rgba_tag, hasAlpha=true }; }; //----order_rgba
+    enum rgb_e { R = 0, G = 1, B = 2, rgb_tag, hasAlpha = false };
-struct order_argb { enum argb_e { A=0, R=1, G=2, B=3, rgba_tag, hasAlpha=true }; }; //----order_argb
+}; //----order_rgb
-struct order_abgr { enum abgr_e { A=0, B=1, G=2, R=3, rgba_tag, hasAlpha=true }; }; //----order_abgr
+struct order_bgr
-struct order_bgra { enum bgra_e { B=0, G=1, R=2, A=3, rgba_tag, hasAlpha=true }; }; //----order_bgra
+{
+    enum bgr_e { B = 0, G = 1, R = 2, rgb_tag, hasAlpha = false };
+}; //----order_bgr
+struct order_rgba
+{
+    enum rgba_e { R = 0, G = 1, B = 2, A = 3, rgba_tag, hasAlpha = true };
+}; //----order_rgba
+struct order_argb
+{
+    enum argb_e { A = 0, R = 1, G = 2, B = 3, rgba_tag, hasAlpha = true };
+}; //----order_argb
+struct order_abgr
+{
+    enum abgr_e { A = 0, B = 1, G = 2, R = 3, rgba_tag, hasAlpha = true };
+}; //----order_abgr
+struct order_bgra
+{
+    enum bgra_e { B = 0, G = 1, R = 2, A = 3, rgba_tag, hasAlpha = true };
+}; //----order_bgra
 
 // Colorspace tag types.
-struct linear {};
+struct linear
-struct sRGB {};
+{};
+struct sRGB
+{};
 
 //====================================================================rgba
 struct rgba
@@ -57,11 +76,20 @@ struct rgba
     rgba() {}
 
     //--------------------------------------------------------------------
-    rgba(double r_, double g_, double b_, double a_=1.0) :
+    rgba(double r_, double g_, double b_, double a_ = 1.0)
-        r(r_), g(g_), b(b_), a(a_) {}
+        : 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(const rgba& c, double a_)
+        : r(c.r)
+        , g(c.g)
+        , b(c.b)
+        , a(a_)
+    {}
 
     //--------------------------------------------------------------------
     rgba& clear()
@@ -80,17 +108,17 @@ struct rgba
     //--------------------------------------------------------------------
     rgba& opacity(double a_)
     {
-        if (a_ < 0) a = 0;
+        if (a_ < 0)
-        else if (a_ > 1) a = 1;
+            a = 0;
-        else a = a_;
+        else if (a_ > 1)
+            a = 1;
+        else
+            a = a_;
         return *this;
     }
 
     //--------------------------------------------------------------------
-    double opacity() const
+    double opacity() const { return a; }
-    {
-        return a;
-    }
 
     //--------------------------------------------------------------------
     rgba& premultiply()
@@ -136,7 +164,6 @@ struct rgba
         return *this;
     }
 
-
     //--------------------------------------------------------------------
     rgba gradient(rgba c, double k) const
     {
@@ -173,11 +200,7 @@ struct rgba
     static rgba from_wavelength(double wl, double gamma = 1.0);
 
     //--------------------------------------------------------------------
-    explicit rgba(double wavelen, double gamma=1.0)
+    explicit rgba(double wavelen, double gamma = 1.0) { *this = from_wavelength(wavelen, gamma); }
-    {
-        *this = from_wavelength(wavelen, gamma);
-    }
-
 };
 
 inline rgba operator+(const rgba& a, const rgba& b)
@@ -226,8 +249,10 @@ inline rgba rgba::from_wavelength(double wl, double gamma)
     }
 
     double s = 1.0;
-    if (wl > 700.0)       s = 0.3 + 0.7 * (780.0 - wl) / (780.0 - 700.0);
+    if (wl > 700.0)
-    else if (wl <  420.0) s = 0.3 + 0.7 * (wl - 380.0) / (420.0 - 380.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);
@@ -240,7 +265,6 @@ 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
@@ -248,8 +272,7 @@ struct rgba8T
     typedef int8u value_type;
     typedef int32u calc_type;
     typedef int32 long_type;
-    enum base_scale_e
+    enum base_scale_e {
-    {
         base_shift = 8,
         base_scale = 1 << base_shift,
         base_mask = base_scale - 1,
@@ -257,7 +280,6 @@ struct rgba8T
     };
     typedef rgba8T self_type;
 
-
     value_type r;
     value_type g;
     value_type b;
@@ -317,21 +339,23 @@ struct rgba8T
     rgba8T() {}
 
     //--------------------------------------------------------------------
-    rgba8T(unsigned r_, unsigned g_, unsigned b_, unsigned a_ = base_mask) :
+    rgba8T(unsigned r_, unsigned g_, unsigned b_, unsigned a_ = base_mask)
-        r(value_type(r_)),
+        : r(value_type(r_))
-        g(value_type(g_)),
+        , g(value_type(g_))
-        b(value_type(b_)),
+        , b(value_type(b_))
-        a(value_type(a_)) {}
+        , a(value_type(a_))
+    {}
 
     //--------------------------------------------------------------------
-    rgba8T(const rgba& c)
+    rgba8T(const rgba& c) { convert(*this, c); }
-    {
-        convert(*this, c);
-    }
 
     //--------------------------------------------------------------------
-    rgba8T(const self_type& c, unsigned a_) :
+    rgba8T(const self_type& c, unsigned a_)
-        r(c.r), g(c.g), b(c.b), a(value_type(a_)) {}
+        : r(c.r)
+        , g(c.g)
+        , b(c.b)
+        , a(value_type(a_))
+    {}
 
     //--------------------------------------------------------------------
     template<class T>
@@ -349,46 +373,25 @@ struct rgba8T
     }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE double to_double(value_type a)
+    static AGG_INLINE double to_double(value_type a) { return double(a) / base_mask; }
-    {
-        return double(a) / base_mask;
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type from_double(double a)
+    static AGG_INLINE value_type from_double(double a) { return value_type(uround(a * base_mask)); }
-    {
-        return value_type(uround(a * base_mask));
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type empty_value()
+    static AGG_INLINE value_type empty_value() { return 0; }
-    {
-        return 0;
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type full_value()
+    static AGG_INLINE value_type full_value() { return base_mask; }
-    {
-        return base_mask;
-    }
 
     //--------------------------------------------------------------------
-    AGG_INLINE bool is_transparent() const
+    AGG_INLINE bool is_transparent() const { return a == 0; }
-    {
-        return a == 0;
-    }
 
     //--------------------------------------------------------------------
-    AGG_INLINE bool is_opaque() const
+    AGG_INLINE bool is_opaque() const { return a == base_mask; }
-    {
-        return a == base_mask;
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type invert(value_type x)
+    static AGG_INLINE value_type invert(value_type x) { return base_mask - x; }
-    {
-        return base_mask - x;
-    }
 
     //--------------------------------------------------------------------
     // Fixed-point multiply, exact over int8u.
@@ -409,7 +412,8 @@ struct rgba8T
         {
             return base_mask;
         }
-        else return value_type((a * base_mask + (b >> 1)) / b);
+        else
+            return value_type((a * base_mask + (b >> 1)) / b);
     }
 
     //--------------------------------------------------------------------
@@ -429,23 +433,14 @@ struct rgba8T
     //--------------------------------------------------------------------
     // 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)
+    static AGG_INLINE value_type mult_cover(value_type a, cover_type b) { return multiply(a, b); }
-    {
-        return multiply(a, b);
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
+    static AGG_INLINE cover_type scale_cover(cover_type a, value_type b) { return multiply(b, a); }
-    {
-        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)
+    static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a) { return p + q - multiply(p, a); }
-    {
-        return p + q - multiply(p, a);
-    }
 
     //--------------------------------------------------------------------
     // Interpolate p to q by a.
@@ -472,17 +467,17 @@ struct rgba8T
     //--------------------------------------------------------------------
     self_type& opacity(double a_)
     {
-        if (a_ < 0) a = 0;
+        if (a_ < 0)
-        else if (a_ > 1) a = 1;
+            a = 0;
-        else a = (value_type)uround(a_ * double(base_mask));
+        else if (a_ > 1)
+            a = 1;
+        else
+            a = (value_type)uround(a_ * double(base_mask));
         return *this;
     }
 
     //--------------------------------------------------------------------
-    double opacity() const
+    double opacity() const { return double(a) / double(base_mask); }
-    {
-        return double(a) / double(base_mask);
-    }
 
     //--------------------------------------------------------------------
     AGG_INLINE self_type& premultiply()
@@ -617,8 +612,7 @@ typedef rgba8T<linear> rgba8;
 typedef rgba8T<sRGB> srgba8;
 
 //-------------------------------------------------------------rgba8_pre
-inline rgba8 rgba8_pre(unsigned r, unsigned g, unsigned b,
+inline rgba8 rgba8_pre(unsigned r, unsigned g, unsigned b, unsigned a = rgba8::base_mask)
-                       unsigned a = rgba8::base_mask)
 {
     return rgba8(r, g, b, a).premultiply();
 }
@@ -639,9 +633,6 @@ inline rgba8 rgba8_pre(const rgba& c, double a)
     return rgba8(c, a).premultiply();
 }
 
-
-
-
 //-------------------------------------------------------------rgb8_packed
 inline rgba8 rgb8_packed(unsigned v)
 {
@@ -674,16 +665,13 @@ 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
+    enum base_scale_e {
-    {
         base_shift = 16,
         base_scale = 1 << base_shift,
         base_mask = base_scale - 1,
@@ -700,105 +688,81 @@ struct rgba16
     rgba16() {}
 
     //--------------------------------------------------------------------
-    rgba16(unsigned r_, unsigned g_, unsigned b_, unsigned a_=base_mask) :
+    rgba16(unsigned r_, unsigned g_, unsigned b_, unsigned a_ = base_mask)
-        r(value_type(r_)),
+        : r(value_type(r_))
-        g(value_type(g_)),
+        , g(value_type(g_))
-        b(value_type(b_)),
+        , b(value_type(b_))
-        a(value_type(a_)) {}
+        , a(value_type(a_))
+    {}
 
     //--------------------------------------------------------------------
-    rgba16(const self_type& c, unsigned a_) :
+    rgba16(const self_type& c, unsigned a_)
-        r(c.r), g(c.g), b(c.b), a(value_type(a_)) {}
+        : r(c.r)
+        , g(c.g)
+        , b(c.b)
+        , a(value_type(a_))
+    {}
 
     //--------------------------------------------------------------------
-    rgba16(const rgba& c) :
+    rgba16(const rgba& c)
-        r((value_type)uround(c.r * double(base_mask))),
+        : r((value_type)uround(c.r * double(base_mask)))
-        g((value_type)uround(c.g * double(base_mask))),
+        , g((value_type)uround(c.g * double(base_mask)))
-        b((value_type)uround(c.b * double(base_mask))),
+        , b((value_type)uround(c.b * double(base_mask)))
-        a((value_type)uround(c.a * double(base_mask))) {}
+        , a((value_type)uround(c.a * double(base_mask)))
+    {}
 
     //--------------------------------------------------------------------
-    rgba16(const rgba8& c) :
+    rgba16(const rgba8& c)
-        r(value_type((value_type(c.r) << 8) | c.r)),
+        : r(value_type((value_type(c.r) << 8) | c.r))
-        g(value_type((value_type(c.g) << 8) | c.g)),
+        , g(value_type((value_type(c.g) << 8) | c.g))
-        b(value_type((value_type(c.b) << 8) | c.b)),
+        , b(value_type((value_type(c.b) << 8) | c.b))
-        a(value_type((value_type(c.a) << 8) | c.a)) {}
+        , a(value_type((value_type(c.a) << 8) | c.a))
+    {}
 
     //--------------------------------------------------------------------
-    rgba16(const srgba8& c) :
+    rgba16(const srgba8& c)
-        r(sRGB_conv<value_type>::rgb_from_sRGB(c.r)),
+        : r(sRGB_conv<value_type>::rgb_from_sRGB(c.r))
-        g(sRGB_conv<value_type>::rgb_from_sRGB(c.g)),
+        , g(sRGB_conv<value_type>::rgb_from_sRGB(c.g))
-        b(sRGB_conv<value_type>::rgb_from_sRGB(c.b)),
+        , b(sRGB_conv<value_type>::rgb_from_sRGB(c.b))
-        a(sRGB_conv<value_type>::alpha_from_sRGB(c.a)) {}
+        , a(sRGB_conv<value_type>::alpha_from_sRGB(c.a))
+    {}
 
     //--------------------------------------------------------------------
-    operator rgba() const
+    operator rgba() const { return rgba(r / 65535.0, g / 65535.0, b / 65535.0, a / 65535.0); }
-    {
-        return rgba(
-            r / 65535.0,
-            g / 65535.0,
-            b / 65535.0,
-            a / 65535.0);
-    }
 
     //--------------------------------------------------------------------
-    operator rgba8() const
+    operator rgba8() const { return rgba8(r >> 8, g >> 8, b >> 8, a >> 8); }
-    {
-        return rgba8(r >> 8, g >> 8, b >> 8, a >> 8);
-    }
 
     //--------------------------------------------------------------------
     operator srgba8() const
     {
         // Return (non-premultiplied) sRGB values.
-        return srgba8(
+        return srgba8(sRGB_conv<value_type>::rgb_to_sRGB(r),
-            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)
+    static AGG_INLINE double to_double(value_type a) { return double(a) / base_mask; }
-    {
-        return double(a) / base_mask;
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type from_double(double a)
+    static AGG_INLINE value_type from_double(double a) { return value_type(uround(a * base_mask)); }
-    {
-        return value_type(uround(a * base_mask));
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type empty_value()
+    static AGG_INLINE value_type empty_value() { return 0; }
-    {
-        return 0;
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type full_value()
+    static AGG_INLINE value_type full_value() { return base_mask; }
-    {
-        return base_mask;
-    }
 
     //--------------------------------------------------------------------
-    AGG_INLINE bool is_transparent() const
+    AGG_INLINE bool is_transparent() const { return a == 0; }
-    {
-        return a == 0;
-    }
 
     //--------------------------------------------------------------------
-    AGG_INLINE bool is_opaque() const
+    AGG_INLINE bool is_opaque() const { return a == base_mask; }
-    {
-        return a == base_mask;
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type invert(value_type x)
+    static AGG_INLINE value_type invert(value_type x) { return base_mask - x; }
-    {
-        return base_mask - x;
-    }
 
     //--------------------------------------------------------------------
     // Fixed-point multiply, exact over int16u.
@@ -819,7 +783,8 @@ struct rgba16
         {
             return base_mask;
         }
-        else return value_type((a * base_mask + (b >> 1)) / b);
+        else
+            return value_type((a * base_mask + (b >> 1)) / b);
     }
 
     //--------------------------------------------------------------------
@@ -839,23 +804,14 @@ struct rgba16
     //--------------------------------------------------------------------
     // 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)
+    static AGG_INLINE value_type mult_cover(value_type a, cover_type b) { return multiply(a, (b << 8) | b); }
-    {
-        return multiply(a, (b << 8) | b);
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
+    static AGG_INLINE cover_type scale_cover(cover_type a, value_type b) { return multiply((a << 8) | a, b) >> 8; }
-    {
-        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)
+    static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a) { return p + q - multiply(p, a); }
-    {
-        return p + q - multiply(p, a);
-    }
 
     //--------------------------------------------------------------------
     // Interpolate p to q by a.
@@ -882,17 +838,16 @@ struct rgba16
     //--------------------------------------------------------------------
     AGG_INLINE self_type& opacity(double a_)
     {
-        if (a_ < 0) a = 0;
+        if (a_ < 0)
-        if (a_ > 1) a = 1;
+            a = 0;
+        if (a_ > 1)
+            a = 1;
         a = value_type(uround(a_ * double(base_mask)));
         return *this;
     }
 
     //--------------------------------------------------------------------
-    double opacity() const
+    double opacity() const { return double(a) / double(base_mask); }
-    {
-        return double(a) / double(base_mask);
-    }
 
     //--------------------------------------------------------------------
     AGG_INLINE self_type& premultiply()
@@ -1023,7 +978,6 @@ struct rgba16
     }
 };
 
-
 //------------------------------------------------------rgba16_gamma_dir
 template<class GammaLUT>
 rgba16 rgba16_gamma_dir(rgba16 c, const GammaLUT& gamma)
@@ -1055,59 +1009,63 @@ struct rgba32
     rgba32() {}
 
     //--------------------------------------------------------------------
-    rgba32(value_type r_, value_type g_, value_type b_, value_type a_= 1) :
+    rgba32(value_type r_, value_type g_, value_type b_, value_type a_ = 1)
-        r(r_), g(g_), b(b_), a(a_) {}
+        : r(r_)
+        , g(g_)
+        , b(b_)
+        , a(a_)
+    {}
 
     //--------------------------------------------------------------------
-    rgba32(const self_type& c, float a_) :
+    rgba32(const self_type& c, float a_)
-        r(c.r), g(c.g), b(c.b), a(a_) {}
+        : r(c.r)
+        , g(c.g)
+        , b(c.b)
+        , a(a_)
+    {}
 
     //--------------------------------------------------------------------
-    rgba32(const rgba& c) :
+    rgba32(const rgba& c)
-        r(value_type(c.r)), g(value_type(c.g)), b(value_type(c.b)), a(value_type(c.a)) {}
+        : r(value_type(c.r))
+        , g(value_type(c.g))
+        , b(value_type(c.b))
+        , a(value_type(c.a))
+    {}
 
     //--------------------------------------------------------------------
-    rgba32(const rgba8& c) :
+    rgba32(const rgba8& c)
-        r(value_type(c.r / 255.0)),
+        : r(value_type(c.r / 255.0))
-        g(value_type(c.g / 255.0)),
+        , g(value_type(c.g / 255.0))
-        b(value_type(c.b / 255.0)),
+        , b(value_type(c.b / 255.0))
-        a(value_type(c.a / 255.0)) {}
+        , a(value_type(c.a / 255.0))
+    {}
 
     //--------------------------------------------------------------------
-    rgba32(const srgba8& c) :
+    rgba32(const srgba8& c)
-        r(sRGB_conv<value_type>::rgb_from_sRGB(c.r)),
+        : r(sRGB_conv<value_type>::rgb_from_sRGB(c.r))
-        g(sRGB_conv<value_type>::rgb_from_sRGB(c.g)),
+        , g(sRGB_conv<value_type>::rgb_from_sRGB(c.g))
-        b(sRGB_conv<value_type>::rgb_from_sRGB(c.b)),
+        , b(sRGB_conv<value_type>::rgb_from_sRGB(c.b))
-        a(sRGB_conv<value_type>::alpha_from_sRGB(c.a)) {}
+        , a(sRGB_conv<value_type>::alpha_from_sRGB(c.a))
+    {}
 
     //--------------------------------------------------------------------
-    rgba32(const rgba16& c) :
+    rgba32(const rgba16& c)
-        r(value_type(c.r / 65535.0)),
+        : r(value_type(c.r / 65535.0))
-        g(value_type(c.g / 65535.0)),
+        , g(value_type(c.g / 65535.0))
-        b(value_type(c.b / 65535.0)),
+        , b(value_type(c.b / 65535.0))
-        a(value_type(c.a / 65535.0)) {}
+        , a(value_type(c.a / 65535.0))
+    {}
 
     //--------------------------------------------------------------------
-    operator rgba() const
+    operator rgba() const { return rgba(r, g, b, a); }
-    {
-        return rgba(r, g, b, a);
-    }
 
     //--------------------------------------------------------------------
-    operator rgba8() const
+    operator rgba8() const { return rgba8(uround(r * 255.0), uround(g * 255.0), uround(b * 255.0), uround(a * 255.0)); }
-    {
-        return rgba8(
-            uround(r * 255.0),
-            uround(g * 255.0),
-            uround(b * 255.0),
-            uround(a * 255.0));
-    }
 
     //--------------------------------------------------------------------
     operator srgba8() const
     {
-        return srgba8(
+        return srgba8(sRGB_conv<value_type>::rgb_to_sRGB(r),
-            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));
@@ -1116,66 +1074,35 @@ struct rgba32
     //--------------------------------------------------------------------
     operator rgba16() const
     {
-        return rgba8(
+        return rgba8(uround(r * 65535.0), uround(g * 65535.0), uround(b * 65535.0), uround(a * 65535.0));
-            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)
+    static AGG_INLINE double to_double(value_type a) { return a; }
-    {
-        return a;
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type from_double(double a)
+    static AGG_INLINE value_type from_double(double a) { return value_type(a); }
-    {
-        return value_type(a);
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type empty_value()
+    static AGG_INLINE value_type empty_value() { return 0; }
-    {
-        return 0;
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type full_value()
+    static AGG_INLINE value_type full_value() { return 1; }
-    {
-        return 1;
-    }
 
     //--------------------------------------------------------------------
-    AGG_INLINE bool is_transparent() const
+    AGG_INLINE bool is_transparent() const { return a <= 0; }
-    {
-        return a <= 0;
-    }
 
     //--------------------------------------------------------------------
-    AGG_INLINE bool is_opaque() const
+    AGG_INLINE bool is_opaque() const { return a >= 1; }
-    {
-        return a >= 1;
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type invert(value_type x)
+    static AGG_INLINE value_type invert(value_type x) { return 1 - x; }
-    {
-        return 1 - x;
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type multiply(value_type a, value_type b)
+    static AGG_INLINE value_type multiply(value_type a, value_type b) { return value_type(a * b); }
-    {
-        return value_type(a * b);
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type demultiply(value_type a, value_type b)
+    static AGG_INLINE value_type demultiply(value_type a, value_type b) { return (b == 0) ? 0 : value_type(a / b); }
-    {
-        return (b == 0) ? 0 : value_type(a / b);
-    }
 
     //--------------------------------------------------------------------
     template<typename T>
@@ -1192,16 +1119,10 @@ struct rgba32
     }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE value_type mult_cover(value_type a, cover_type b)
+    static AGG_INLINE value_type mult_cover(value_type a, cover_type b) { return value_type(a * b / cover_mask); }
-    {
-        return value_type(a * b / cover_mask);
-    }
 
     //--------------------------------------------------------------------
-    static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
+    static AGG_INLINE cover_type scale_cover(cover_type a, value_type b) { return cover_type(uround(a * b)); }
-    {
-        return cover_type(uround(a * b));
-    }
 
     //--------------------------------------------------------------------
     // Interpolate p to q by a, assuming q is premultiplied by a.
@@ -1238,17 +1159,17 @@ struct rgba32
     //--------------------------------------------------------------------
     AGG_INLINE self_type& opacity(double a_)
     {
-        if (a_ < 0) a = 0;
+        if (a_ < 0)
-        else if (a_ > 1) a = 1;
+            a = 0;
-        else a = value_type(a_);
+        else if (a_ > 1)
+            a = 1;
+        else
+            a = value_type(a_);
         return *this;
     }
 
     //--------------------------------------------------------------------
-    double opacity() const
+    double opacity() const { return a; }
-    {
-        return a;
-    }
 
     //--------------------------------------------------------------------
     AGG_INLINE self_type& premultiply()
@@ -1324,10 +1245,14 @@ struct rgba32
             b += mult_cover(c.b, cover);
             a += mult_cover(c.a, cover);
         }
-        if (a > 1) a = 1;
+        if (a > 1)
-        if (r > a) r = a;
+            a = 1;
-        if (g > a) g = a;
+        if (r > a)
-        if (b > a) b = a;
+            r = a;
+        if (g > a)
+            g = a;
+        if (b > a)
+            b = a;
     }
 
     //--------------------------------------------------------------------
@@ -1357,8 +1282,6 @@ struct rgba32
         return self_type(rgba::from_wavelength(wl, gamma));
     }
 };
-}
+} // namespace agg
-
-
 
 #endif

deps/agg/include/agg_config.h

@@ -26,7 +26,6 @@
 // but it won't result any crash and the rest of the library will remain
 // fully functional.
 
-
 //---------------------------------------
 // 2. Default rendering_buffer type. Can be:
 //

deps/agg/include/agg_conv_adaptor_vcgen.h

@@ -18,8 +18,7 @@
 
 #include "agg_basics.h"
 
-namespace agg
+namespace agg {
-{
 //------------------------------------------------------------null_markers
 struct null_markers
 {
@@ -32,23 +31,16 @@ namespace agg
     unsigned type() const { return 0; }
 };
 
-
 //------------------------------------------------------conv_adaptor_vcgen
-    template<class VertexSource, 
+template<class VertexSource, class Generator, class Markers = null_markers>
-             class Generator, 
+class conv_adaptor_vcgen
-             class Markers=null_markers> class conv_adaptor_vcgen
 {
-        enum status
+    enum status { initial, accumulate, generate };
-        {
-            initial,
-            accumulate,
-            generate
-        };
 
   public:
-        explicit conv_adaptor_vcgen(VertexSource& source) :
+    explicit conv_adaptor_vcgen(VertexSource& source)
-            m_source(&source), 
+        : m_source(&source)
-            m_status(initial)
+        , m_status(initial)
     {}
 
     conv_adaptor_vcgen(conv_adaptor_vcgen<VertexSource, Generator, Markers>&&) = default;
@@ -85,10 +77,6 @@ namespace agg
     double m_start_y;
 };
 
-
-
-
-
 //------------------------------------------------------------------------
 template<class VertexSource, class Generator, class Markers>
 unsigned conv_adaptor_vcgen<VertexSource, Generator, Markers>::vertex(double* x, double* y)
@@ -105,7 +93,8 @@ namespace agg
                 m_status = accumulate;
 
             case accumulate:
-                if(is_stop(m_last_cmd)) return path_cmd_stop;
+                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);
@@ -157,6 +146,6 @@ namespace agg
     return cmd;
 }
 
-}
+} // namespace agg
 
 #endif

deps/agg/include/agg_conv_adaptor_vpgen.h

@@ -18,14 +18,16 @@
 
 #include "agg_basics.h"
 
-namespace agg
+namespace agg {
-{
 
 //======================================================conv_adaptor_vpgen
-    template<class VertexSource, class VPGen> class conv_adaptor_vpgen
+template<class VertexSource, class VPGen>
+class conv_adaptor_vpgen
 {
   public:
-        explicit conv_adaptor_vpgen(VertexSource& source) : m_source(&source) {}
+    explicit conv_adaptor_vpgen(VertexSource& source)
+        : m_source(&source)
+    {}
     void attach(VertexSource& source) { m_source = &source; }
 
     VPGen& vpgen() { return m_vpgen; }
@@ -37,8 +39,7 @@ namespace agg
 
   private:
     conv_adaptor_vpgen(const conv_adaptor_vpgen<VertexSource, VPGen>&);
-        const conv_adaptor_vpgen<VertexSource, VPGen>& 
+    const conv_adaptor_vpgen<VertexSource, VPGen>& operator=(const conv_adaptor_vpgen<VertexSource, VPGen>&);
-            operator = (const conv_adaptor_vpgen<VertexSource, VPGen>&);
 
     VertexSource* m_source;
     VPGen m_vpgen;
@@ -48,8 +49,6 @@ namespace agg
     int m_vertices;
 };
 
-
-
 //------------------------------------------------------------------------
 template<class VertexSource, class VPGen>
 void conv_adaptor_vpgen<VertexSource, VPGen>::rewind(unsigned path_id)
@@ -62,7 +61,6 @@ namespace agg
     m_vertices = 0;
 }
 
-
 //------------------------------------------------------------------------
 template<class VertexSource, class VPGen>
 unsigned conv_adaptor_vpgen<VertexSource, VPGen>::vertex(double* x, double* y)
@@ -71,7 +69,8 @@ namespace agg
     for (;;)
     {
         cmd = m_vpgen.vertex(x, y);
-            if(!is_stop(cmd)) break;
+        if (!is_stop(cmd))
+            break;
 
         if (m_poly_flags && !m_vpgen.auto_unclose())
         {
@@ -127,7 +126,8 @@ namespace agg
                 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_vpgen.auto_close())
+                        m_poly_flags |= path_flags_close;
                     if (m_vertices > 2)
                     {
                         m_vpgen.line_to(m_start_x, m_start_y);
@@ -152,9 +152,6 @@ namespace agg
     return cmd;
 }
 
-
+} // namespace agg
-}
-
 
 #endif
-

deps/agg/include/agg_conv_bspline.h

@@ -19,9 +19,7 @@
 #include "agg_vcgen_bspline.h"
 #include "agg_conv_adaptor_vcgen.h"
 
-
+namespace agg {
-namespace agg
-{
 
 //---------------------------------------------------------conv_bspline
 template<class VertexSource>
@@ -29,20 +27,18 @@ namespace agg
 {
     typedef conv_adaptor_vcgen<VertexSource, vcgen_bspline> base_type;
 
-        conv_bspline(VertexSource& vs) : 
+    conv_bspline(VertexSource& vs)
-            conv_adaptor_vcgen<VertexSource, vcgen_bspline>(vs) {}
+        : conv_adaptor_vcgen<VertexSource, vcgen_bspline>(vs)
+    {}
 
     void interpolation_step(double v) { base_type::generator().interpolation_step(v); }
     double interpolation_step() const { return base_type::generator().interpolation_step(); }
 
   private:
     conv_bspline(const conv_bspline<VertexSource>&);
-        const conv_bspline<VertexSource>& 
+    const conv_bspline<VertexSource>& operator=(const conv_bspline<VertexSource>&);
-            operator = (const conv_bspline<VertexSource>&);
 };
 
-}
+} // namespace agg
-
 
 #endif
-

deps/agg/include/agg_conv_clip_polygon.h

@@ -30,8 +30,7 @@
 #include "agg_conv_adaptor_vpgen.h"
 #include "agg_vpgen_clip_polygon.h"
 
-namespace agg
+namespace agg {
-{
 
 //=======================================================conv_clip_polygon
 template<class VertexSource>
@@ -39,13 +38,11 @@ namespace agg
 {
     typedef conv_adaptor_vpgen<VertexSource, vpgen_clip_polygon> base_type;
 
-        conv_clip_polygon(VertexSource& vs) : 
+    conv_clip_polygon(VertexSource& vs)
-            conv_adaptor_vpgen<VertexSource, vpgen_clip_polygon>(vs) {}
+        : conv_adaptor_vpgen<VertexSource, vpgen_clip_polygon>(vs)
+    {}
 
-        void clip_box(double _x1, double _y1, double _x2, double _y2)
+    void clip_box(double _x1, double _y1, double _x2, double _y2) { base_type::vpgen().clip_box(_x1, _y1, _x2, _y2); }
-        {
-            base_type::vpgen().clip_box(_x1, _y1, _x2, _y2);
-        }
 
     double x1() const { return base_type::vpgen().x1(); }
     double y1() const { return base_type::vpgen().y1(); }
@@ -55,10 +52,9 @@ namespace agg
 
   private:
     conv_clip_polygon(const conv_clip_polygon<VertexSource>&);
-        const conv_clip_polygon<VertexSource>& 
+    const conv_clip_polygon<VertexSource>& operator=(const conv_clip_polygon<VertexSource>&);
-            operator = (const conv_clip_polygon<VertexSource>&);
 };
 
-}
+} // namespace agg
 
 #endif

deps/agg/include/agg_conv_clip_polyline.h

@@ -30,8 +30,7 @@
 #include "agg_conv_adaptor_vpgen.h"
 #include "agg_vpgen_clip_polyline.h"
 
-namespace agg
+namespace agg {
-{
 
 //=======================================================conv_clip_polyline
 template<class VertexSource>
@@ -39,13 +38,11 @@ namespace agg
 {
     typedef conv_adaptor_vpgen<VertexSource, vpgen_clip_polyline> base_type;
 
-        conv_clip_polyline(VertexSource& vs) : 
+    conv_clip_polyline(VertexSource& vs)
-            conv_adaptor_vpgen<VertexSource, vpgen_clip_polyline>(vs) {}
+        : conv_adaptor_vpgen<VertexSource, vpgen_clip_polyline>(vs)
+    {}
 
-        void clip_box(double _x1, double _y1, double _x2, double _y2)
+    void clip_box(double _x1, double _y1, double _x2, double _y2) { base_type::vpgen().clip_box(_x1, _y1, _x2, _y2); }
-        {
-            base_type::vpgen().clip_box(_x1, _y1, _x2, _y2);
-        }
 
     double x1() const { return base_type::vpgen().x1(); }
     double y1() const { return base_type::vpgen().y1(); }
@@ -55,10 +52,9 @@ namespace agg
 
   private:
     conv_clip_polyline(const conv_clip_polyline<VertexSource>&);
-        const conv_clip_polyline<VertexSource>& 
+    const conv_clip_polyline<VertexSource>& operator=(const conv_clip_polyline<VertexSource>&);
-            operator = (const conv_clip_polyline<VertexSource>&);
 };
 
-}
+} // namespace agg
 
 #endif

deps/agg/include/agg_conv_close_polygon.h

@@ -18,14 +18,16 @@
 
 #include "agg_basics.h"
 
-namespace agg
+namespace agg {
-{
 
 //======================================================conv_close_polygon
-    template<class VertexSource> class conv_close_polygon
+template<class VertexSource>
+class conv_close_polygon
 {
   public:
-        explicit conv_close_polygon(VertexSource& vs) : m_source(&vs) {}
+    explicit conv_close_polygon(VertexSource& vs)
+        : m_source(&vs)
+    {}
     void attach(VertexSource& source) { m_source = &source; }
 
     void rewind(unsigned path_id);
@@ -33,8 +35,7 @@ namespace agg
 
   private:
     conv_close_polygon(const conv_close_polygon<VertexSource>&);
-        const conv_close_polygon<VertexSource>& 
+    const conv_close_polygon<VertexSource>& operator=(const conv_close_polygon<VertexSource>&);
-            operator = (const conv_close_polygon<VertexSource>&);
 
     VertexSource* m_source;
     unsigned m_cmd[2];
@@ -44,8 +45,6 @@ namespace agg
     bool m_line_to;
 };
 
-
-
 //------------------------------------------------------------------------
 template<class VertexSource>
 void conv_close_polygon<VertexSource>::rewind(unsigned path_id)
@@ -55,8 +54,6 @@ namespace agg
     m_line_to = false;
 }
 
-
-    
 //------------------------------------------------------------------------
 template<class VertexSource>
 unsigned conv_close_polygon<VertexSource>::vertex(double* x, double* y)
@@ -120,6 +117,6 @@ namespace agg
     return cmd;
 }
 
-}
+} // namespace agg
 
 #endif

deps/agg/include/agg_conv_concat.h

@@ -18,20 +18,22 @@
 
 #include "agg_basics.h"
 
-namespace agg
+namespace agg {
-{
 //=============================================================conv_concat
 // Concatenation of two paths. Usually used to combine lines or curves
 // with markers such as arrowheads
-    template<class VS1, class VS2> class conv_concat
+template<class VS1, class VS2>
+class conv_concat
 {
   public:
-        conv_concat(VS1& source1, VS2& source2) :
+    conv_concat(VS1& source1, VS2& source2)
-            m_source1(&source1), m_source2(&source2), m_status(2) {}
+        : m_source1(&source1)
+        , m_source2(&source2)
+        , m_status(2)
+    {}
     void attach1(VS1& source) { m_source1 = &source; }
     void attach2(VS2& source) { m_source2 = &source; }
 
-
     void rewind(unsigned path_id)
     {
         m_source1->rewind(path_id);
@@ -45,13 +47,15 @@ namespace agg
         if (m_status == 0)
         {
             cmd = m_source1->vertex(x, y);
-                if(!is_stop(cmd)) return cmd;
+            if (!is_stop(cmd))
+                return cmd;
             m_status = 1;
         }
         if (m_status == 1)
         {
             cmd = m_source2->vertex(x, y);
-                if(!is_stop(cmd)) return cmd;
+            if (!is_stop(cmd))
+                return cmd;
             m_status = 2;
         }
         return path_cmd_stop;
@@ -59,15 +63,12 @@ namespace agg
 
   private:
     conv_concat(const conv_concat<VS1, VS2>&);
-        const conv_concat<VS1, VS2>& 
+    const conv_concat<VS1, VS2>& operator=(const conv_concat<VS1, VS2>&);
-            operator = (const conv_concat<VS1, VS2>&);
 
     VS1* m_source1;
     VS2* m_source2;
     int m_status;
-
 };
-}
+} // namespace agg
-
 
 #endif

deps/agg/include/agg_conv_contour.h

@@ -23,8 +23,7 @@
 #include "agg_vcgen_contour.h"
 #include "agg_conv_adaptor_vcgen.h"
 
-namespace agg
+namespace agg {
-{
 
 //-----------------------------------------------------------conv_contour
 template<class VertexSource>
@@ -32,10 +31,9 @@ namespace agg
 {
     typedef conv_adaptor_vcgen<VertexSource, vcgen_contour> base_type;
 
-        conv_contour(VertexSource& vs) : 
+    conv_contour(VertexSource& vs)
-            conv_adaptor_vcgen<VertexSource, vcgen_contour>(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); }
@@ -56,10 +54,9 @@ namespace agg
 
   private:
     conv_contour(const conv_contour<VertexSource>&);
-        const conv_contour<VertexSource>& 
+    const conv_contour<VertexSource>& operator=(const conv_contour<VertexSource>&);
-            operator = (const conv_contour<VertexSource>&);
 };
 
-}
+} // namespace agg
 
 #endif

deps/agg/include/agg_conv_curve.h

@@ -23,9 +23,7 @@
 #include "agg_basics.h"
 #include "agg_curves.h"
 
-namespace agg
+namespace agg {
-{
-
 
 //---------------------------------------------------------------conv_curve
 // Curve converter class. Any path storage can have Bezier curves defined
@@ -51,17 +49,19 @@ namespace agg
 // 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, 
+template<class VertexSource, class Curve3 = curve3, class Curve4 = curve4>
-             class Curve3=curve3, 
+class conv_curve
-             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) :
+    explicit conv_curve(VertexSource& source)
-          m_source(&source), m_last_x(0.0), m_last_y(0.0) {}
+        : m_source(&source)
+        , m_last_x(0.0)
+        , m_last_y(0.0)
+    {}
 
     conv_curve(self_type&&) = default;
 
@@ -73,10 +73,7 @@ namespace agg
         m_curve4.approximation_method(v);
     }
 
-        curve_approximation_method_e approximation_method() const 
+    curve_approximation_method_e approximation_method() const { return m_curve4.approximation_method(); }
-        { 
-            return m_curve4.approximation_method();
-        }
 
     void approximation_scale(double s)
     {
@@ -84,10 +81,7 @@ namespace agg
         m_curve4.approximation_scale(s);
     }
 
-        double approximation_scale() const 
+    double approximation_scale() const { return m_curve4.approximation_scale(); }
-        { 
-            return m_curve4.approximation_scale();  
-        }
 
     void angle_tolerance(double v)
     {
@@ -95,10 +89,7 @@ namespace agg
         m_curve4.angle_tolerance(v);
     }
 
-        double angle_tolerance() const 
+    double angle_tolerance() const { return m_curve4.angle_tolerance(); }
-        { 
-            return m_curve4.angle_tolerance();  
-        }
 
     void cusp_limit(double v)
     {
@@ -106,10 +97,7 @@ namespace agg
         m_curve4.cusp_limit(v);
     }
 
-        double cusp_limit() const 
+    double cusp_limit() const { return m_curve4.cusp_limit(); }
-        { 
-            return m_curve4.cusp_limit();  
-        }
 
     void rewind(unsigned path_id);
     unsigned vertex(double* x, double* y);
@@ -125,8 +113,6 @@ namespace agg
     curve4_type m_curve4;
 };
 
-
-
 //------------------------------------------------------------------------
 template<class VertexSource, class Curve3, class Curve4>
 void conv_curve<VertexSource, Curve3, Curve4>::rewind(unsigned path_id)
@@ -138,7 +124,6 @@ namespace agg
     m_curve4.reset();
 }
 
-
 //------------------------------------------------------------------------
 template<class VertexSource, class Curve3, class Curve4>
 unsigned conv_curve<VertexSource, Curve3, Curve4>::vertex(double* x, double* y)
@@ -168,9 +153,7 @@ namespace agg
         case path_cmd_curve3:
             m_source->vertex(&end_x, &end_y);
 
-            m_curve3.init(m_last_x, m_last_y, 
+            m_curve3.init(m_last_x, m_last_y, *x, *y, end_x, end_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
@@ -181,10 +164,7 @@ namespace agg
             m_source->vertex(&ct2_x, &ct2_y);
             m_source->vertex(&end_x, &end_y);
 
-            m_curve4.init(m_last_x, m_last_y, 
+            m_curve4.init(m_last_x, m_last_y, *x, *y, ct2_x, ct2_y, end_x, end_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
@@ -196,9 +176,6 @@ namespace agg
     return cmd;
 }
 
-
+} // namespace agg
-}
-
-
 
 #endif

deps/agg/include/agg_conv_dash.h

@@ -23,8 +23,7 @@
 #include "agg_vcgen_dash.h"
 #include "agg_conv_adaptor_vcgen.h"
 
-namespace agg
+namespace agg {
-{
 
 //---------------------------------------------------------------conv_dash
 template<class VertexSource, class Markers = null_markers>
@@ -33,36 +32,24 @@ namespace agg
     typedef Markers marker_type;
     typedef conv_adaptor_vcgen<VertexSource, vcgen_dash, Markers> base_type;
 
-        conv_dash(VertexSource& vs) : 
+    conv_dash(VertexSource& vs)
-            conv_adaptor_vcgen<VertexSource, vcgen_dash, Markers>(vs)
+        : conv_adaptor_vcgen<VertexSource, vcgen_dash, Markers>(vs)
-        {
+    {}
-        }
 
-        void remove_all_dashes() 
+    void remove_all_dashes() { base_type::generator().remove_all_dashes(); }
-        { 
-            base_type::generator().remove_all_dashes(); 
-        }
 
-        void add_dash(double dash_len, double gap_len) 
+    void add_dash(double dash_len, double gap_len) { base_type::generator().add_dash(dash_len, gap_len); }
-        { 
-            base_type::generator().add_dash(dash_len, gap_len); 
-        }
 
-        void dash_start(double ds) 
+    void dash_start(double ds) { base_type::generator().dash_start(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>& 
+    const conv_dash<VertexSource, Markers>& operator=(const conv_dash<VertexSource, Markers>&);
-            operator = (const conv_dash<VertexSource, Markers>&);
 };
 
-
+} // namespace agg
-}
 
 #endif

deps/agg/include/agg_conv_gpc.h

@@ -33,27 +33,14 @@ extern "C"
 #include "gpc.h"
 }
 
-namespace agg
+namespace agg {
-{
+enum gpc_op_e { gpc_or, gpc_and, gpc_xor, gpc_a_minus_b, gpc_b_minus_a };
-    enum gpc_op_e
-    {
-        gpc_or,
-        gpc_and,
-        gpc_xor,
-        gpc_a_minus_b,
-        gpc_b_minus_a
-    };
-
 
 //================================================================conv_gpc
-    template<class VSA, class VSB> class conv_gpc
+template<class VSA, class VSB>
+class conv_gpc
 {
-        enum status
+    enum status { status_move_to, status_line_to, status_stop };
-        {
-            status_move_to,
-            status_line_to,
-            status_stop
-        };
 
     struct contour_header_type
     {
@@ -65,24 +52,20 @@ namespace agg
     typedef pod_bvector<gpc_vertex, 8> vertex_array_type;
     typedef pod_bvector<contour_header_type, 6> contour_header_array_type;
 
-
   public:
     typedef VSA source_a_type;
     typedef VSB source_b_type;
     typedef conv_gpc<source_a_type, source_b_type> self_type;
 
-        ~conv_gpc()
+    ~conv_gpc() { free_gpc_data(); }
-        {
-            free_gpc_data();
-        }
 
-        conv_gpc(source_a_type& a, source_b_type& b, gpc_op_e op = gpc_or) :
+    conv_gpc(source_a_type& a, source_b_type& b, gpc_op_e op = gpc_or)
-            m_src_a(&a),
+        : m_src_a(&a)
-            m_src_b(&b),
+        , m_src_b(&b)
-            m_status(status_move_to),
+        , m_status(status_move_to)
-            m_vertex(-1),
+        , m_vertex(-1)
-            m_contour(-1),
+        , m_contour(-1)
-            m_operation(op)
+        , m_operation(op)
     {
         memset(&m_poly_a, 0, sizeof(m_poly_a));
         memset(&m_poly_b, 0, sizeof(m_poly_b));
@@ -114,9 +97,9 @@ namespace agg
     bool next_contour();
     bool next_vertex(double* x, double* y);
 
-
     //--------------------------------------------------------------------
-        template<class VS> void add(VS& src, gpc_polygon& p)
+    template<class VS>
+    void add(VS& src, gpc_polygon& p)
     {
         unsigned cmd;
         double x, y;
@@ -164,7 +147,6 @@ namespace agg
         make_polygon(p);
     }
 
-
   private:
     //--------------------------------------------------------------------
     source_a_type* m_src_a;
@@ -180,10 +162,6 @@ namespace agg
     gpc_polygon m_result;
 };
 
-
-
-
-
 //------------------------------------------------------------------------
 template<class VSA, class VSB>
 void conv_gpc<VSA, VSB>::free_polygon(gpc_polygon& p)
@@ -191,14 +169,12 @@ namespace agg
     int i;
     for (i = 0; i < p.num_contours; i++)
     {
-            pod_allocator<gpc_vertex>::deallocate(p.contour[i].vertex, 
+        pod_allocator<gpc_vertex>::deallocate(p.contour[i].vertex, p.contour[i].num_vertices);
-                                                  p.contour[i].num_vertices);
     }
     pod_allocator<gpc_vertex_list>::deallocate(p.contour, p.num_contours);
     memset(&p, 0, sizeof(gpc_polygon));
 }
 
-
 //------------------------------------------------------------------------
 template<class VSA, class VSB>
 void conv_gpc<VSA, VSB>::free_result()
@@ -210,7 +186,6 @@ namespace agg
     memset(&m_result, 0, sizeof(m_result));
 }
 
-
 //------------------------------------------------------------------------
 template<class VSA, class VSB>
 void conv_gpc<VSA, VSB>::free_gpc_data()
@@ -220,7 +195,6 @@ namespace agg
     free_result();
 }
 
-
 //------------------------------------------------------------------------
 template<class VSA, class VSB>
 void conv_gpc<VSA, VSB>::start_contour()
@@ -231,7 +205,6 @@ namespace agg
     m_vertex_accumulator.remove_all();
 }
 
-
 //------------------------------------------------------------------------
 template<class VSA, class VSB>
 inline void conv_gpc<VSA, VSB>::add_vertex(double x, double y)
@@ -242,7 +215,6 @@ namespace agg
     m_vertex_accumulator.add(v);
 }
 
-
 //------------------------------------------------------------------------
 template<class VSA, class VSB>
 void conv_gpc<VSA, VSB>::end_contour(unsigned orientation)
@@ -251,8 +223,7 @@ namespace agg
     {
         if (m_vertex_accumulator.size() > 2)
         {
-                contour_header_type& h = 
+            contour_header_type& h = m_contour_accumulator[m_contour_accumulator.size() - 1];
-                    m_contour_accumulator[m_contour_accumulator.size() - 1];
 
             h.num_vertices = m_vertex_accumulator.size();
             h.hole_flag = 0;
@@ -278,7 +249,6 @@ namespace agg
     }
 }
 
-
 //------------------------------------------------------------------------
 template<class VSA, class VSB>
 void conv_gpc<VSA, VSB>::make_polygon(gpc_polygon& p)
@@ -303,7 +273,6 @@ namespace agg
     }
 }
 
-
 //------------------------------------------------------------------------
 template<class VSA, class VSB>
 void conv_gpc<VSA, VSB>::start_extracting()
@@ -313,7 +282,6 @@ namespace agg
     m_vertex = -1;
 }
 
-
 //------------------------------------------------------------------------
 template<class VSA, class VSB>
 bool conv_gpc<VSA, VSB>::next_contour()
@@ -326,7 +294,6 @@ namespace agg
     return false;
 }
 
-
 //------------------------------------------------------------------------
 template<class VSA, class VSB>
 inline bool conv_gpc<VSA, VSB>::next_vertex(double* x, double* y)
@@ -342,7 +309,6 @@ namespace agg
     return false;
 }
 
-
 //------------------------------------------------------------------------
 template<class VSA, class VSB>
 void conv_gpc<VSA, VSB>::rewind(unsigned path_id)
@@ -355,44 +321,28 @@ namespace agg
     switch (m_operation)
     {
         case gpc_or:
-                gpc_polygon_clip(GPC_UNION,
+            gpc_polygon_clip(GPC_UNION, &m_poly_a, &m_poly_b, &m_result);
-                                 &m_poly_a,
-                                 &m_poly_b,
-                                 &m_result);
             break;
 
         case gpc_and:
-                gpc_polygon_clip(GPC_INT,
+            gpc_polygon_clip(GPC_INT, &m_poly_a, &m_poly_b, &m_result);
-                                 &m_poly_a,
-                                 &m_poly_b,
-                                 &m_result);
             break;
 
         case gpc_xor:
-                gpc_polygon_clip(GPC_XOR,
+            gpc_polygon_clip(GPC_XOR, &m_poly_a, &m_poly_b, &m_result);
-                                 &m_poly_a,
-                                 &m_poly_b,
-                                 &m_result);
             break;
 
         case gpc_a_minus_b:
-                gpc_polygon_clip(GPC_DIFF,
+            gpc_polygon_clip(GPC_DIFF, &m_poly_a, &m_poly_b, &m_result);
-                                 &m_poly_a,
-                                 &m_poly_b,
-                                 &m_result);
             break;
 
         case gpc_b_minus_a:
-                gpc_polygon_clip(GPC_DIFF,
+            gpc_polygon_clip(GPC_DIFF, &m_poly_b, &m_poly_a, &m_result);
-                                 &m_poly_b,
-                                 &m_poly_a,
-                                 &m_result);
             break;
     }
     start_extracting();
 }
 
-
 //------------------------------------------------------------------------
 template<class VSA, class VSB>
 unsigned conv_gpc<VSA, VSB>::vertex(double* x, double* y)
@@ -425,8 +375,6 @@ namespace agg
     return path_cmd_stop;
 }
 
-   
+} // namespace agg
-}
-
 
 #endif

deps/agg/include/agg_conv_marker.h

@@ -22,8 +22,7 @@
 #include "agg_basics.h"
 #include "agg_trans_affine.h"
 
-namespace agg
+namespace agg {
-{
 //-------------------------------------------------------------conv_marker
 template<class MarkerLocator, class MarkerShapes>
 class conv_marker
@@ -39,16 +38,9 @@ namespace agg
 
   private:
     conv_marker(const conv_marker<MarkerLocator, MarkerShapes>&);
-        const conv_marker<MarkerLocator, MarkerShapes>& 
+    const conv_marker<MarkerLocator, MarkerShapes>& operator=(const conv_marker<MarkerLocator, MarkerShapes>&);
-            operator = (const conv_marker<MarkerLocator, MarkerShapes>&);
 
-        enum status_e 
+    enum status_e { initial, markers, polygon, stop };
-        {
-            initial,
-            markers,
-            polygon,
-            stop
-        };
 
     MarkerLocator* m_marker_locator;
     MarkerShapes* m_marker_shapes;
@@ -59,18 +51,15 @@ namespace agg
     unsigned m_num_markers;
 };
 
-
 //------------------------------------------------------------------------
 template<class MarkerLocator, class MarkerShapes>
-    conv_marker<MarkerLocator, MarkerShapes>::conv_marker(MarkerLocator& ml, MarkerShapes& ms) :
+conv_marker<MarkerLocator, MarkerShapes>::conv_marker(MarkerLocator& ml, MarkerShapes& ms)
-        m_marker_locator(&ml),
+    : m_marker_locator(&ml)
-        m_marker_shapes(&ms),
+    , m_marker_shapes(&ms)
-        m_status(initial),
+    , m_status(initial)
-        m_marker(0),
+    , m_marker(0)
-        m_num_markers(1)
+    , m_num_markers(1)
-    {
+{}
-    }
-
 
 //------------------------------------------------------------------------
 template<class MarkerLocator, class MarkerShapes>
@@ -81,7 +70,6 @@ namespace agg
     m_num_markers = 1;
 }
 
-
 //------------------------------------------------------------------------
 template<class MarkerLocator, class MarkerShapes>
 unsigned conv_marker<MarkerLocator, MarkerShapes>::vertex(double* x, double* y)
@@ -141,8 +129,6 @@ namespace agg
     return cmd;
 }
 
-}
+} // namespace agg
-
 
 #endif
-

deps/agg/include/agg_conv_marker_adaptor.h

@@ -20,32 +20,27 @@
 #include "agg_conv_adaptor_vcgen.h"
 #include "agg_vcgen_vertex_sequence.h"
 
-namespace agg
+namespace agg {
-{
 
 //=====================================================conv_marker_adaptor
 template<class VertexSource, class Markers = null_markers>
-    struct conv_marker_adaptor : 
+struct conv_marker_adaptor : public conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence, Markers>
-    public conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence, Markers>
 {
     typedef Markers marker_type;
     typedef conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence, Markers> base_type;
 
-        conv_marker_adaptor(VertexSource& vs) : 
+    conv_marker_adaptor(VertexSource& vs)
-            conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence, Markers>(vs)
+        : conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence, Markers>(vs)
-        {
+    {}
-        }
 
     void shorten(double s) { base_type::generator().shorten(s); }
     double shorten() const { return base_type::generator().shorten(); }
 
   private:
     conv_marker_adaptor(const conv_marker_adaptor<VertexSource, Markers>&);
-        const conv_marker_adaptor<VertexSource, Markers>& 
+    const conv_marker_adaptor<VertexSource, Markers>& operator=(const conv_marker_adaptor<VertexSource, Markers>&);
-            operator = (const conv_marker_adaptor<VertexSource, Markers>&);
 };
 
-
+} // namespace agg
-}
 
 #endif

deps/agg/include/agg_conv_offset.h

@@ -22,10 +22,10 @@
 #include "agg_array.h"
 #include "clipper.hpp"
 
-namespace agg
+namespace agg {
-{
 
-template<class VSA> class conv_offset
+template<class VSA>
+class conv_offset
 {
     enum status { status_move_to, status_line_to, status_stop };
     typedef VSA source_a_type;
@@ -45,36 +45,30 @@ private:
 
     int Round(double val)
     {
-        if ((val < 0)) return (int)(val - 0.5); else return (int)(val + 0.5);
+        if ((val < 0))
+            return (int)(val - 0.5);
+        else
+            return (int)(val + 0.5);
     }
 
   public:
-    conv_offset(source_a_type &a, double offset = 0.0,
+    conv_offset(source_a_type& a, double offset = 0.0, int scaling_factor = 0)
-                int scaling_factor = 0)
+        : m_src_a(&a)
-        : m_src_a(&a),
+        , m_offset(offset)
-          m_offset(offset),
+        , m_status(status_move_to)
-          m_status(status_move_to),
+        , m_vertex(-1)
-          m_vertex(-1),
+        , m_contour(-1)
-          m_contour(-1)
     {
         m_scaling_factor = std::max(std::min(scaling_factor, 6), 0);
         m_scaling_factor = Round(std::pow((double)10, m_scaling_factor));
     }
 
-    ~conv_offset()
+    ~conv_offset() {}
-    {
-    }
 
     void set_offset(double offset) { m_offset = offset; }
-    unsigned type() const
+    unsigned type() const { return static_cast<unsigned>(m_src_a->type()); }
-    {
-        return static_cast<unsigned>(m_src_a->type());
-    }
 
-    double get_offset() const
+    double get_offset() const { return m_offset; }
-    {
-        return m_offset;
-    }
 
     void rewind(unsigned path_id);
     unsigned vertex(double* x, double* y);
@@ -85,10 +79,14 @@ public:
     void add_vertex_(double& x, double& y);
     void end_contour(ClipperLib::Paths& p);
 
-    template<class VS> void add(VS &src, ClipperLib::Paths &p)
+    template<class VS>
+    void add(VS& src, ClipperLib::Paths& p)
     {
         unsigned cmd;
-        double x; double y; double start_x; double start_y;
+        double x;
+        double y;
+        double start_x;
+        double start_y;
         bool starting_first_line;
 
         start_x = 0.0;
@@ -103,7 +101,8 @@ public:
             {
                 if (is_move_to(cmd))
                 {
-                    if(!starting_first_line ) end_contour(p);
+                    if (!starting_first_line)
+                        end_contour(p);
                     start_x = x;
                     start_y = y;
                 }
@@ -153,7 +152,8 @@ void conv_offset<VSA>::end_contour( ClipperLib::Paths &p)
 {
     unsigned i, len;
 
-    if( m_vertex_accumulator.size() < 3 ) return;
+    if (m_vertex_accumulator.size() < 3)
+        return;
     len = p.size();
     p.resize(len + 1);
     p[len].resize(m_vertex_accumulator.size());
@@ -178,7 +178,8 @@ template<class VSA>
 bool conv_offset<VSA>::next_contour()
 {
     m_contour++;
-    if(m_contour >= (int)m_result.size()) return false;
+    if (m_contour >= (int)m_result.size())
+        return false;
     m_vertex = -1;
     return true;
 }
@@ -188,7 +189,8 @@ template<class VSA>
 bool conv_offset<VSA>::next_vertex(double* x, double* y)
 {
     m_vertex++;
-    if(m_vertex >= (int)m_result[m_contour].size()) return false;
+    if (m_vertex >= (int)m_result[m_contour].size())
+        return false;
     *x = (double)m_result[m_contour][m_vertex].X / m_scaling_factor;
     *y = (double)m_result[m_contour][m_vertex].Y / m_scaling_factor;
     return true;
@@ -231,6 +233,5 @@ unsigned conv_offset<VSA>::vertex(double *x, double *y)
 }
 //------------------------------------------------------------------------------
 
-
 } // namespace agg
 #endif // AGG_CONV_OFFSET_INCLUDED

deps/agg/include/agg_conv_segmentator.h

@@ -20,8 +20,7 @@
 #include "agg_conv_adaptor_vpgen.h"
 #include "agg_vpgen_segmentator.h"
 
-namespace agg
+namespace agg {
-{
 
 //========================================================conv_segmentator
 template<class VertexSource>
@@ -29,20 +28,18 @@ namespace agg
 {
     typedef conv_adaptor_vpgen<VertexSource, vpgen_segmentator> base_type;
 
-        conv_segmentator(VertexSource& vs) : 
+    conv_segmentator(VertexSource& vs)
-            conv_adaptor_vpgen<VertexSource, vpgen_segmentator>(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>& 
+    const conv_segmentator<VertexSource>& operator=(const conv_segmentator<VertexSource>&);
-            operator = (const conv_segmentator<VertexSource>&);
 };
 
-
+} // namespace agg
-}
 
 #endif
-

deps/agg/include/agg_conv_shorten_path.h

@@ -20,31 +20,27 @@
 #include "agg_conv_adaptor_vcgen.h"
 #include "agg_vcgen_vertex_sequence.h"
 
-namespace agg
+namespace agg {
-{
 
 //=======================================================conv_shorten_path
-    template<class VertexSource>  class conv_shorten_path : 
+template<class VertexSource>
-    public conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence>
+class conv_shorten_path : public conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence>
 {
   public:
     typedef conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence> base_type;
 
-        conv_shorten_path(VertexSource& vs) : 
+    conv_shorten_path(VertexSource& vs)
-            conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence>(vs)
+        : conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence>(vs)
-        {
+    {}
-        }
 
     void shorten(double s) { base_type::generator().shorten(s); }
     double shorten() const { return base_type::generator().shorten(); }
 
   private:
     conv_shorten_path(const conv_shorten_path<VertexSource>&);
-        const conv_shorten_path<VertexSource>& 
+    const conv_shorten_path<VertexSource>& operator=(const conv_shorten_path<VertexSource>&);
-            operator = (const conv_shorten_path<VertexSource>&);
 };
 
-
+} // namespace agg
-}
 
 #endif

deps/agg/include/agg_conv_smooth_poly1.h

@@ -24,21 +24,17 @@
 #include "agg_conv_adaptor_vcgen.h"
 #include "agg_conv_curve.h"
 
-
+namespace agg {
-namespace agg
-{
 
 //-------------------------------------------------------conv_smooth
 template<class VertexSource, class VertexGenerator>
-    struct conv_smooth :
+struct conv_smooth : public conv_adaptor_vcgen<VertexSource, VertexGenerator>
-    public conv_adaptor_vcgen<VertexSource, VertexGenerator>
 {
     typedef conv_adaptor_vcgen<VertexSource, VertexGenerator> base_type;
 
-        conv_smooth(VertexSource& vs) :
+    conv_smooth(VertexSource& vs)
-            conv_adaptor_vcgen<VertexSource, VertexGenerator>(vs)
+        : conv_adaptor_vcgen<VertexSource, VertexGenerator>(vs)
-        {
+    {}
-        }
 
     conv_smooth(conv_smooth<VertexSource, VertexGenerator>&&) = default;
 
@@ -56,18 +52,16 @@ namespace agg
 
 //-------------------------------------------------conv_smooth_curve
 template<class VertexSource, class VertexGenerator>
-    struct conv_smooth_curve :
+struct conv_smooth_curve : public conv_curve<conv_smooth<VertexSource, VertexGenerator>>
-    public conv_curve<conv_smooth<VertexSource, VertexGenerator>>
 {
-        conv_smooth_curve(VertexSource& vs) :
+    conv_smooth_curve(VertexSource& vs)
-            conv_curve<conv_smooth<VertexSource, VertexGenerator>>(m_smooth),
+        : conv_curve<conv_smooth<VertexSource, VertexGenerator>>(m_smooth)
-            m_smooth(vs)
+        , m_smooth(vs)
-        {
+    {}
-        }
 
-        conv_smooth_curve(conv_smooth_curve<VertexSource, VertexGenerator> && rhs) :
+    conv_smooth_curve(conv_smooth_curve<VertexSource, VertexGenerator>&& rhs)
-            conv_curve<conv_smooth<VertexSource, VertexGenerator>>(std::move(rhs)),
+        : conv_curve<conv_smooth<VertexSource, VertexGenerator>>(std::move(rhs))
-            m_smooth(std::move(rhs.m_smooth))
+        , m_smooth(std::move(rhs.m_smooth))
     {
         this->attach(m_smooth);
     }
@@ -86,8 +80,6 @@ namespace agg
 
 template<class VertexSource>
 using conv_smooth_poly1_curve = conv_smooth_curve<VertexSource, vcgen_smooth_poly1>;
-}
+} // namespace agg
-
 
 #endif
-

deps/agg/include/agg_conv_stroke.h

@@ -23,21 +23,18 @@
 #include "agg_vcgen_stroke.h"
 #include "agg_conv_adaptor_vcgen.h"
 
-namespace agg
+namespace agg {
-{
 
 //-------------------------------------------------------------conv_stroke
 template<class VertexSource, class Markers = null_markers>
-    struct conv_stroke : 
+struct conv_stroke : public conv_adaptor_vcgen<VertexSource, vcgen_stroke, Markers>
-    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_stroke(VertexSource& vs)
-            conv_adaptor_vcgen<VertexSource, vcgen_stroke, Markers>(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); }
@@ -63,11 +60,9 @@ namespace agg
 
   private:
     conv_stroke(const conv_stroke<VertexSource, Markers>&);
-       const conv_stroke<VertexSource, Markers>& 
+    const conv_stroke<VertexSource, Markers>& operator=(const conv_stroke<VertexSource, Markers>&);
-           operator = (const conv_stroke<VertexSource, Markers>&);
-
 };
 
-}
+} // namespace agg
 
 #endif

deps/agg/include/agg_conv_transform.h

@@ -22,22 +22,21 @@
 #include "agg_basics.h"
 #include "agg_trans_affine.h"
 
-namespace agg
+namespace agg {
-{
 
 //----------------------------------------------------------conv_transform
-    template<class VertexSource, class Transformer=trans_affine> class conv_transform
+template<class VertexSource, class Transformer = trans_affine>
+class conv_transform
 {
   public:
-        conv_transform(VertexSource& source, Transformer& tr) :
+    conv_transform(VertexSource& source, Transformer& tr)
-            m_source(&source), m_trans(&tr) {}
+        : m_source(&source)
+        , m_trans(&tr)
+    {}
 
     void attach(VertexSource& source) { m_source = &source; }
 
-        void rewind(unsigned path_id) 
+    void rewind(unsigned path_id) { m_source->rewind(path_id); }
-        { 
-            m_source->rewind(path_id); 
-        }
 
     unsigned vertex(double* x, double* y)
     {
@@ -49,23 +48,18 @@ namespace agg
         return cmd;
     }
 
-        void transformer(Transformer& tr)
+    void transformer(Transformer& tr) { m_trans = &tr; }
-        {
-            m_trans = &tr;
-        }
 
     unsigned type() const { return m_source->type(); }
 
   private:
     conv_transform(const conv_transform<VertexSource>&);
-        const conv_transform<VertexSource>& 
+    const conv_transform<VertexSource>& operator=(const conv_transform<VertexSource>&);
-            operator = (const conv_transform<VertexSource>&);
 
     VertexSource* m_source;
     const Transformer* m_trans;
 };
 
-
+} // namespace agg
-}
 
 #endif

deps/agg/include/agg_conv_unclose_polygon.h

@@ -18,35 +18,34 @@
 
 #include "agg_basics.h"
 
-namespace agg
+namespace agg {
-{
 //====================================================conv_unclose_polygon
-    template<class VertexSource> class conv_unclose_polygon
+template<class VertexSource>
+class conv_unclose_polygon
 {
   public:
-        explicit conv_unclose_polygon(VertexSource& vs) : m_source(&vs) {}
+    explicit conv_unclose_polygon(VertexSource& vs)
+        : m_source(&vs)
+    {}
     void attach(VertexSource& source) { m_source = &source; }
 
-        void rewind(unsigned path_id)
+    void rewind(unsigned path_id) { m_source->rewind(path_id); }
-        {
-            m_source->rewind(path_id);
-        }
 
     unsigned vertex(double* x, double* y)
     {
         unsigned cmd = m_source->vertex(x, y);
-            if(is_end_poly(cmd)) cmd &= ~path_flags_close;
+        if (is_end_poly(cmd))
+            cmd &= ~path_flags_close;
         return cmd;
     }
 
   private:
     conv_unclose_polygon(const conv_unclose_polygon<VertexSource>&);
-        const conv_unclose_polygon<VertexSource>& 
+    const conv_unclose_polygon<VertexSource>& operator=(const conv_unclose_polygon<VertexSource>&);
-            operator = (const conv_unclose_polygon<VertexSource>&);
 
     VertexSource* m_source;
 };
 
-}
+} // namespace agg
 
 #endif

deps/agg/include/agg_curves.h

@@ -21,37 +21,37 @@
 
 #include <mapnik/config.hpp>
 
-namespace agg
+namespace agg {
-{
 
 // See Implementation agg_curves.cpp
 
 //--------------------------------------------curve_approximation_method_e
-    enum curve_approximation_method_e
+enum curve_approximation_method_e { curve_inc, curve_div };
-    {
-        curve_inc,
-        curve_div
-    };
 
 //--------------------------------------------------------------curve3_inc
 class MAPNIK_DECL curve3_inc
 {
   public:
-        curve3_inc() :
+    curve3_inc()
-          m_num_steps(0), m_step(0), m_scale(1.0) { }
+        : m_num_steps(0)
+        , m_step(0)
+        , m_scale(1.0)
+    {}
 
-        curve3_inc(double x1, double y1, 
+    curve3_inc(double x1, double y1, double x2, double y2, double x3, double y3)
-                   double x2, double y2, 
+        : m_num_steps(0)
-                   double x3, double y3) :
+        , m_step(0)
-            m_num_steps(0), m_step(0), m_scale(1.0) 
+        , m_scale(1.0)
     {
         init(x1, y1, x2, y2, x3, y3);
     }
 
-        void reset() { m_num_steps = 0; m_step = -1; }
+    void reset()
-        void init(double x1, double y1, 
+    {
-                  double x2, double y2, 
+        m_num_steps = 0;
-                  double x3, double y3);
+        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; }
@@ -88,34 +88,30 @@ namespace agg
     double m_saved_dfy;
 };
 
-
-
-
-
 //-------------------------------------------------------------curve3_div
 class MAPNIK_DECL curve3_div
 {
   public:
-        curve3_div() : 
+    curve3_div()
-            m_approximation_scale(1.0),
+        : m_approximation_scale(1.0)
-            m_angle_tolerance(0.0),
+        , m_angle_tolerance(0.0)
-            m_count(0)
+        , m_count(0)
     {}
 
-        curve3_div(double x1, double y1, 
+    curve3_div(double x1, double y1, double x2, double y2, double x3, double y3)
-                   double x2, double y2, 
+        : m_approximation_scale(1.0)
-                   double x3, double y3) :
+        , m_angle_tolerance(0.0)
-            m_approximation_scale(1.0),
+        , m_count(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 reset()
-        void init(double x1, double y1, 
+    {
-                  double x2, double y2, 
+        m_points.remove_all();
-                  double x3, double y3);
+        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; }
@@ -129,14 +125,12 @@ namespace agg
     void cusp_limit(double) {}
     double cusp_limit() const { return 0.0; }
 
-        void rewind(unsigned)
+    void rewind(unsigned) { m_count = 0; }
-        {
-            m_count = 0;
-        }
 
     unsigned vertex(double* x, double* y)
     {
-            if(m_count >= m_points.size()) return path_cmd_stop;
+        if (m_count >= m_points.size())
+            return path_cmd_stop;
         const point_d& p = m_points[m_count++];
         *x = p.x;
         *y = p.y;
@@ -144,13 +138,8 @@ namespace agg
     }
 
   private:
-        void bezier(double x1, double y1, 
+    void bezier(double x1, double y1, double x2, double y2, double x3, double y3);
-                    double x2, double y2, 
+    void recursive_bezier(double x1, double y1, double x2, double y2, double x3, double y3, unsigned level);
-                    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;
@@ -159,71 +148,71 @@ namespace agg
     pod_bvector<point_d> m_points;
 };
 
-
-
-
-
-
-
 //-------------------------------------------------------------curve4_points
 struct MAPNIK_DECL curve4_points
 {
     double cp[8];
     curve4_points() {}
-        curve4_points(double x1, double y1,
+    curve4_points(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
-                      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[0] = x1;
-            cp[4] = x3; cp[5] = y3; cp[6] = x4; cp[7] = y4;
+        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,
+    void init(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
-                  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[0] = x1;
-            cp[4] = x3; cp[5] = y3; cp[6] = x4; cp[7] = y4;
+        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 MAPNIK_DECL curve4_inc
 {
   public:
-        curve4_inc() :
+    curve4_inc()
-            m_num_steps(0), m_step(0), m_scale(1.0) { }
+        : m_num_steps(0)
+        , m_step(0)
+        , m_scale(1.0)
+    {}
 
-        curve4_inc(double x1, double y1, 
+    curve4_inc(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
-                   double x2, double y2, 
+        : m_num_steps(0)
-                   double x3, double y3,
+        , m_step(0)
-                   double x4, double y4) :
+        , m_scale(1.0)
-            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) :
+    curve4_inc(const curve4_points& cp)
-            m_num_steps(0), m_step(0), m_scale(1.0) 
+        : 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 reset()
-        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]);
+        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; }
@@ -264,13 +253,9 @@ namespace agg
     double m_saved_ddfy;
 };
 
-
-
 //-------------------------------------------------------catrom_to_bezier
-    inline curve4_points catrom_to_bezier(double x1, double y1, 
+inline curve4_points
-                                          double x2, double y2, 
+  catrom_to_bezier(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
-                                          double x3, double y3,
-                                          double x4, double y4)
 {
     // Trans. matrix Catmull-Rom to Bezier
     //
@@ -279,8 +264,7 @@ namespace agg
     //  0       1/6     1       -1/6
     //  0       0       1       0
     //
-        return curve4_points(
+    return curve4_points(x2,
-            x2,
                          y2,
                          (-x1 + 6 * x2 + x3) / 6,
                          (-y1 + 6 * y2 + y3) / 6,
@@ -290,22 +274,15 @@ namespace agg
                          y3);
 }
 
-
 //-----------------------------------------------------------------------
-    inline curve4_points
+inline curve4_points catrom_to_bezier(const curve4_points& cp)
-    catrom_to_bezier(const curve4_points& cp)
 {
-        return catrom_to_bezier(cp[0], cp[1], cp[2], cp[3], 
+    return catrom_to_bezier(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
-                                cp[4], cp[5], cp[6], cp[7]);
 }
 
-
-
 //-----------------------------------------------------ubspline_to_bezier
-    inline curve4_points ubspline_to_bezier(double x1, double y1, 
+inline curve4_points
-                                            double x2, double y2, 
+  ubspline_to_bezier(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
-                                            double x3, double y3,
-                                            double x4, double y4)
 {
     // Trans. matrix Uniform BSpline to Bezier
     //
@@ -314,8 +291,7 @@ namespace agg
     //  0       2/6     4/6     0
     //  0       1/6     4/6     1/6
     //
-        return curve4_points(
+    return curve4_points((x1 + 4 * x2 + x3) / 6,
-            (x1 + 4*x2 + x3) / 6,
                          (y1 + 4 * y2 + y3) / 6,
                          (4 * x2 + 2 * x3) / 6,
                          (4 * y2 + 2 * y3) / 6,
@@ -325,23 +301,15 @@ namespace agg
                          (y2 + 4 * y3 + y4) / 6);
 }
 
-
 //-----------------------------------------------------------------------
-    inline curve4_points 
+inline curve4_points ubspline_to_bezier(const curve4_points& cp)
-    ubspline_to_bezier(const curve4_points& cp)
 {
-        return ubspline_to_bezier(cp[0], cp[1], cp[2], cp[3], 
+    return ubspline_to_bezier(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
-                                  cp[4], cp[5], cp[6], cp[7]);
 }
 
-
-
-
 //------------------------------------------------------hermite_to_bezier
-    inline curve4_points hermite_to_bezier(double x1, double y1, 
+inline curve4_points
-                                           double x2, double y2, 
+  hermite_to_bezier(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
-                                           double x3, double y3,
-                                           double x4, double y4)
 {
     // Trans. matrix Hermite to Bezier
     //
@@ -350,76 +318,55 @@ namespace agg
     //  0       1       0       -1/3
     //  0       1       0       0
     //
-        return curve4_points(
+    return curve4_points(x1, y1, (3 * x1 + x3) / 3, (3 * y1 + y3) / 3, (3 * x2 - x4) / 3, (3 * y2 - y4) / 3, x2, y2);
-            x1,
-            y1,
-            (3*x1 + x3) / 3,
-            (3*y1 + y3) / 3,
-            (3*x2 - x4) / 3,
-            (3*y2 - y4) / 3,
-            x2,
-            y2);
 }
 
-
-
 //-----------------------------------------------------------------------
-    inline curve4_points 
+inline curve4_points hermite_to_bezier(const curve4_points& cp)
-    hermite_to_bezier(const curve4_points& cp)
 {
-        return hermite_to_bezier(cp[0], cp[1], cp[2], cp[3], 
+    return hermite_to_bezier(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
-                                 cp[4], cp[5], cp[6], cp[7]);
 }
 
-
 //-------------------------------------------------------------curve4_div
 class MAPNIK_DECL curve4_div
 {
   public:
-        curve4_div() : 
+    curve4_div()
-            m_approximation_scale(1.0),
+        : m_approximation_scale(1.0)
-            m_angle_tolerance(0.0),
+        , m_angle_tolerance(0.0)
-            m_cusp_limit(0.0),
+        , m_cusp_limit(0.0)
-            m_count(0)
+        , m_count(0)
     {}
 
-        curve4_div(double x1, double y1, 
+    curve4_div(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
-                   double x2, double y2, 
+        : m_approximation_scale(1.0)
-                   double x3, double y3,
+        , m_angle_tolerance(0.0)
-                   double x4, double y4) :
+        , m_cusp_limit(0.0)
-            m_approximation_scale(1.0),
+        , m_count(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) :
+    curve4_div(const curve4_points& cp)
-            m_approximation_scale(1.0),
+        : m_approximation_scale(1.0)
-            m_angle_tolerance(0.0),
+        , m_angle_tolerance(0.0)
-            m_count(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 reset()
-        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]);
+        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 
+    curve_approximation_method_e approximation_method() const { return curve_div; }
-        { 
-            return curve_div; 
-        }
 
     void approximation_scale(double s) { m_approximation_scale = s; }
     double approximation_scale() const { return m_approximation_scale; }
@@ -427,24 +374,16 @@ namespace agg
     void angle_tolerance(double a) { m_angle_tolerance = a; }
     double angle_tolerance() const { return m_angle_tolerance; }
 
-        void cusp_limit(double v) 
+    void cusp_limit(double v) { m_cusp_limit = (v == 0.0) ? 0.0 : pi - v; }
-        { 
-            m_cusp_limit = (v == 0.0) ? 0.0 : pi - v; 
-        }
 
-        double cusp_limit() const 
+    double cusp_limit() const { return (m_cusp_limit == 0.0) ? 0.0 : pi - m_cusp_limit; }
-        { 
-            return (m_cusp_limit == 0.0) ? 0.0 : pi - m_cusp_limit; 
-        }
 
-        void rewind(unsigned)
+    void rewind(unsigned) { m_count = 0; }
-        {
-            m_count = 0;
-        }
 
     unsigned vertex(double* x, double* y)
     {
-            if(m_count >= m_points.size()) return path_cmd_stop;
+        if (m_count >= m_points.size())
+            return path_cmd_stop;
         const point_d& p = m_points[m_count++];
         *x = p.x;
         *y = p.y;
@@ -452,15 +391,16 @@ namespace agg
     }
 
   private:
-        void bezier(double x1, double y1, 
+    void bezier(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4);
-                    double x2, double y2, 
-                    double x3, double y3, 
-                    double x4, double y4);
 
-        void recursive_bezier(double x1, double y1, 
+    void recursive_bezier(double x1,
-                              double x2, double y2, 
+                          double y1,
-                              double x3, double y3, 
+                          double x2,
-                              double x4, double y4,
+                          double y2,
+                          double x3,
+                          double y3,
+                          double x4,
+                          double y4,
                           unsigned level);
 
     double m_approximation_scale;
@@ -471,16 +411,15 @@ namespace agg
     pod_bvector<point_d> m_points;
 };
 
-
 //-----------------------------------------------------------------curve3
 class MAPNIK_DECL curve3
 {
   public:
-        curve3() : m_approximation_method(curve_div) {}
+    curve3()
-        curve3(double x1, double y1, 
+        : m_approximation_method(curve_div)
-               double x2, double y2, 
+    {}
-               double x3, double y3) :
+    curve3(double x1, double y1, double x2, double y2, double x3, double y3)
-            m_approximation_method(curve_div)
+        : m_approximation_method(curve_div)
     {
         init(x1, y1, x2, y2, x3, y3);
     }
@@ -491,9 +430,7 @@ namespace agg
         m_curve_div.reset();
     }
 
-        void init(double x1, double y1, 
+    void init(double x1, double y1, double x2, double y2, double x3, double y3)
-                  double x2, double y2, 
-                  double x3, double y3)
     {
         if (m_approximation_method == curve_inc)
         {
@@ -505,15 +442,9 @@ namespace agg
         }
     }
 
-        void approximation_method(curve_approximation_method_e v) 
+    void approximation_method(curve_approximation_method_e v) { m_approximation_method = v; }
-        { 
-            m_approximation_method = v; 
-        }
 
-        curve_approximation_method_e approximation_method() const 
+    curve_approximation_method_e approximation_method() const { return m_approximation_method; }
-        { 
-            return m_approximation_method; 
-        }
 
     void approximation_scale(double s)
     {
@@ -521,30 +452,15 @@ namespace agg
         m_curve_div.approximation_scale(s);
     }
 
-        double approximation_scale() const 
+    double approximation_scale() const { return m_curve_inc.approximation_scale(); }
-        { 
-            return m_curve_inc.approximation_scale(); 
-        }
 
-        void angle_tolerance(double a) 
+    void angle_tolerance(double a) { m_curve_div.angle_tolerance(a); }
-        { 
-            m_curve_div.angle_tolerance(a); 
-        }
 
-        double angle_tolerance() const 
+    double angle_tolerance() const { return m_curve_div.angle_tolerance(); }
-        { 
-            return m_curve_div.angle_tolerance(); 
-        }
 
-        void cusp_limit(double v) 
+    void cusp_limit(double v) { m_curve_div.cusp_limit(v); }
-        { 
-            m_curve_div.cusp_limit(v); 
-        }
 
-        double cusp_limit() const 
+    double cusp_limit() const { return m_curve_div.cusp_limit(); }
-        { 
-            return m_curve_div.cusp_limit();  
-        }
 
     void rewind(unsigned path_id)
     {
@@ -573,26 +489,21 @@ namespace agg
     curve_approximation_method_e m_approximation_method;
 };
 
-
-
-
-
 //-----------------------------------------------------------------curve4
 class MAPNIK_DECL curve4
 {
   public:
-        curve4() : m_approximation_method(curve_div) {}
+    curve4()
-        curve4(double x1, double y1, 
+        : m_approximation_method(curve_div)
-               double x2, double y2, 
+    {}
-               double x3, double y3,
+    curve4(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
-               double x4, double y4) : 
+        : m_approximation_method(curve_div)
-            m_approximation_method(curve_div)
     {
         init(x1, y1, x2, y2, x3, y3, x4, y4);
     }
 
-        curve4(const curve4_points& cp) :
+    curve4(const curve4_points& cp)
-            m_approximation_method(curve_div)
+        : m_approximation_method(curve_div)
     {
         init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
     }
@@ -603,10 +514,7 @@ namespace agg
         m_curve_div.reset();
     }
 
-        void init(double x1, double y1, 
+    void init(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
-                  double x2, double y2, 
-                  double x3, double y3,
-                  double x4, double y4)
     {
         if (m_approximation_method == curve_inc)
         {
@@ -618,20 +526,11 @@ namespace agg
         }
     }
 
-        void init(const curve4_points& cp)
+    void init(const curve4_points& cp) { init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]); }
-        {
-            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) 
+    void approximation_method(curve_approximation_method_e v) { m_approximation_method = v; }
-        { 
-            m_approximation_method = v; 
-        }
 
-        curve_approximation_method_e approximation_method() const 
+    curve_approximation_method_e approximation_method() const { return m_approximation_method; }
-        { 
-            return m_approximation_method; 
-        }
 
     void approximation_scale(double s)
     {
@@ -640,25 +539,13 @@ namespace agg
     }
     double approximation_scale() const { return m_curve_inc.approximation_scale(); }
 
-        void angle_tolerance(double v) 
+    void angle_tolerance(double v) { m_curve_div.angle_tolerance(v); }
-        { 
-            m_curve_div.angle_tolerance(v); 
-        }
 
-        double angle_tolerance() const 
+    double angle_tolerance() const { return m_curve_div.angle_tolerance(); }
-        { 
-            return m_curve_div.angle_tolerance();  
-        }
 
-        void cusp_limit(double v) 
+    void cusp_limit(double v) { m_curve_div.cusp_limit(v); }
-        { 
-            m_curve_div.cusp_limit(v); 
-        }
 
-        double cusp_limit() const 
+    double cusp_limit() const { return m_curve_div.cusp_limit(); }
-        { 
-            return m_curve_div.cusp_limit();  
-        }
 
     void rewind(unsigned path_id)
     {
@@ -687,9 +574,6 @@ namespace agg
     curve_approximation_method_e m_approximation_method;
 };
 
-
+} // namespace agg
-
-
-}
 
 #endif

deps/agg/include/agg_dda_line.h

@@ -23,49 +23,36 @@
 #include <cstdlib>
 #include "agg_basics.h"
 
-namespace agg
+namespace agg {
-{
 
 //===================================================dda_line_interpolator
-    template<int FractionShift, int YShift = 0> class dda_line_interpolator
+template<int FractionShift, int YShift = 0>
+class dda_line_interpolator
 {
     static constexpr int factor = 2 << (FractionShift - 1);
+
   public:
     //--------------------------------------------------------------------
     dda_line_interpolator() {}
 
     //--------------------------------------------------------------------
-        dda_line_interpolator(int y1, int y2, unsigned count) :
+    dda_line_interpolator(int y1, int y2, unsigned count)
-            m_y(y1),
+        : m_y(y1)
-            m_inc(((y2 - y1) * factor) / static_cast<int>(count)),
+        , m_inc(((y2 - y1) * factor) / static_cast<int>(count))
-            m_dy(0)
+        , m_dy(0)
-        {
+    {}
-        }
 
     //--------------------------------------------------------------------
-        void operator ++ ()
+    void operator++() { m_dy += m_inc; }
-        {
-            m_dy += m_inc;
-        }
 
     //--------------------------------------------------------------------
-        void operator -- ()
+    void operator--() { m_dy -= m_inc; }
-        {
-            m_dy -= m_inc;
-        }
 
     //--------------------------------------------------------------------
-        void operator += (unsigned n)
+    void operator+=(unsigned n) { m_dy += m_inc * n; }
-        {
-            m_dy += m_inc * n;
-        }
 
     //--------------------------------------------------------------------
-        void operator -= (unsigned n)
+    void operator-=(unsigned n) { m_dy -= m_inc * n; }
-        {
-            m_dy -= m_inc * n;
-        }
-
 
     //--------------------------------------------------------------------
     int y() const { return m_y + (m_dy >> (FractionShift - YShift)); }
@@ -77,10 +64,6 @@ namespace agg
     int m_dy;
 };
 
-
-
-
-
 //=================================================dda2_line_interpolator
 class dda2_line_interpolator
 {
@@ -92,12 +75,12 @@ namespace agg
     dda2_line_interpolator() {}
 
     //-------------------------------------------- Forward-adjusted line
-        dda2_line_interpolator(int y1, int y2, int count) :
+    dda2_line_interpolator(int y1, int y2, int count)
-            m_cnt(count <= 0 ? 1 : count),
+        : m_cnt(count <= 0 ? 1 : count)
-            m_lft((y2 - y1) / m_cnt),
+        , m_lft((y2 - y1) / m_cnt)
-            m_rem((y2 - y1) % m_cnt),
+        , m_rem((y2 - y1) % m_cnt)
-            m_mod(m_rem),
+        , m_mod(m_rem)
-            m_y(y1)
+        , m_y(y1)
     {
         if (m_mod <= 0)
         {
@@ -109,12 +92,12 @@ namespace agg
     }
 
     //-------------------------------------------- Backward-adjusted line
-        dda2_line_interpolator(int y1, int y2, int count, int) :
+    dda2_line_interpolator(int y1, int y2, int count, int)
-            m_cnt(count <= 0 ? 1 : count),
+        : m_cnt(count <= 0 ? 1 : count)
-            m_lft((y2 - y1) / m_cnt),
+        , m_lft((y2 - y1) / m_cnt)
-            m_rem((y2 - y1) % m_cnt),
+        , m_rem((y2 - y1) % m_cnt)
-            m_mod(m_rem),
+        , m_mod(m_rem)
-            m_y(y1)
+        , m_y(y1)
     {
         if (m_mod <= 0)
         {
@@ -125,12 +108,12 @@ namespace agg
     }
 
     //-------------------------------------------- Backward-adjusted line
-        dda2_line_interpolator(int y, int count) :
+    dda2_line_interpolator(int y, int count)
-            m_cnt(count <= 0 ? 1 : count),
+        : m_cnt(count <= 0 ? 1 : count)
-            m_lft(y / m_cnt),
+        , m_lft(y / m_cnt)
-            m_rem(y % m_cnt),
+        , m_rem(y % m_cnt)
-            m_mod(m_rem),
+        , m_mod(m_rem)
-            m_y(0)
+        , m_y(0)
     {
         if (m_mod <= 0)
         {
@@ -140,7 +123,6 @@ namespace agg
         }
     }
 
-
     //--------------------------------------------------------------------
     void save(save_data_type* data) const
     {
@@ -180,16 +162,10 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        void adjust_forward()
+    void adjust_forward() { m_mod -= m_cnt; }
-        {
-            m_mod -= m_cnt;
-        }
 
     //--------------------------------------------------------------------
-        void adjust_backward()
+    void adjust_backward() { m_mod += m_cnt; }
-        {
-            m_mod += m_cnt;
-        }
 
     //--------------------------------------------------------------------
     int mod() const { return m_mod; }
@@ -207,18 +183,11 @@ namespace agg
     int m_y;
 };
 
-
-
-
-
-
-
 //---------------------------------------------line_bresenham_interpolator
 class line_bresenham_interpolator
 {
   public:
-        enum subpixel_scale_e
+    enum subpixel_scale_e {
-        {
         subpixel_shift = 8,
         subpixel_scale = 1 << subpixel_shift,
         subpixel_mask = subpixel_scale - 1
@@ -228,20 +197,16 @@ namespace agg
     static int line_lr(int v) { return v >> subpixel_shift; }
 
     //--------------------------------------------------------------------
-        line_bresenham_interpolator(int x1, int y1, int x2, int y2) :
+    line_bresenham_interpolator(int x1, int y1, int x2, int y2)
-            m_x1_lr(line_lr(x1)),
+        : m_x1_lr(line_lr(x1))
-            m_y1_lr(line_lr(y1)),
+        , m_y1_lr(line_lr(y1))
-            m_x2_lr(line_lr(x2)),
+        , m_x2_lr(line_lr(x2))
-            m_y2_lr(line_lr(y2)),
+        , m_y2_lr(line_lr(y2))
-            m_ver(std::abs(m_x2_lr - m_x1_lr) < std::abs(m_y2_lr - m_y1_lr)),
+        , m_ver(std::abs(m_x2_lr - m_x1_lr) < std::abs(m_y2_lr - m_y1_lr))
-            m_len(m_ver ? std::abs(m_y2_lr - m_y1_lr) :
+        , m_len(m_ver ? std::abs(m_y2_lr - m_y1_lr) : std::abs(m_x2_lr - m_x1_lr))
-                          std::abs(m_x2_lr - m_x1_lr)),
+        , m_inc(m_ver ? ((y2 > y1) ? 1 : -1) : ((x2 > x1) ? 1 : -1))
-            m_inc(m_ver ? ((y2 > y1) ? 1 : -1) : ((x2 > x1) ? 1 : -1)),
+        , m_interpolator(m_ver ? x1 : y1, m_ver ? x2 : y2, m_len)
-            m_interpolator(m_ver ? x1 : y1,
+    {}
-                           m_ver ? x2 : y2,
-                           m_len)
-        {
-        }
 
     //--------------------------------------------------------------------
     bool is_ver() const { return m_ver; }
@@ -279,12 +244,8 @@ namespace agg
     unsigned m_len;
     int m_inc;
     dda2_line_interpolator m_interpolator;
-
 };
 
-
+} // namespace agg
-}
-
-
 
 #endif

deps/agg/include/agg_ellipse.h

@@ -23,27 +23,38 @@
 #include "agg_basics.h"
 #include <cmath>
 
-namespace agg
+namespace agg {
-{
 
 //----------------------------------------------------------------ellipse
 class ellipse
 {
   public:
-        ellipse() : 
+    ellipse()
-            m_x(0.0), m_y(0.0), m_rx(1.0), m_ry(1.0), m_scale(1.0), 
+        : m_x(0.0)
-            m_num(4), m_step(0), m_cw(false) {}
+        , m_y(0.0)
+        , m_rx(1.0)
+        , m_ry(1.0)
+        , m_scale(1.0)
+        , m_num(4)
+        , m_step(0)
+        , m_cw(false)
+    {}
 
-        ellipse(double x, double y, double rx, double ry, 
+    ellipse(double x, double y, double rx, double ry, unsigned num_steps = 0, bool cw = false)
-                unsigned num_steps=0, bool cw=false) :
+        : m_x(x)
-            m_x(x), m_y(y), m_rx(rx), m_ry(ry), m_scale(1.0), 
+        , m_y(y)
-            m_num(num_steps), m_step(0), m_cw(cw) 
+        , m_rx(rx)
+        , m_ry(ry)
+        , m_scale(1.0)
+        , m_num(num_steps)
+        , m_step(0)
+        , m_cw(cw)
     {
-            if(m_num == 0) calc_num_steps();
+        if (m_num == 0)
+            calc_num_steps();
     }
 
-        void init(double x, double y, double rx, double ry, 
+    void init(double x, double y, double rx, double ry, unsigned num_steps = 0, bool cw = false);
-                  unsigned num_steps=0, bool cw=false);
 
     void approximation_scale(double scale);
     void rewind(unsigned path_id);
@@ -64,8 +75,7 @@ namespace agg
 };
 
 //------------------------------------------------------------------------
-    inline void ellipse::init(double x, double y, double rx, double ry, 
+inline void ellipse::init(double x, double y, double rx, double ry, unsigned num_steps, bool cw)
-                              unsigned num_steps, bool cw)
 {
     m_x = x;
     m_y = y;
@@ -74,7 +84,8 @@ namespace agg
     m_num = num_steps;
     m_step = 0;
     m_cw = cw;
-        if(m_num == 0) calc_num_steps();
+    if (m_num == 0)
+        calc_num_steps();
 }
 
 //------------------------------------------------------------------------
@@ -106,19 +117,17 @@ namespace agg
         ++m_step;
         return path_cmd_end_poly | path_flags_close | path_flags_ccw;
     }
-        if(m_step > m_num) return path_cmd_stop;
+    if (m_step > m_num)
+        return path_cmd_stop;
     double angle = double(m_step) / double(m_num) * 2.0 * pi;
-        if(m_cw) angle = 2.0 * pi - angle;
+    if (m_cw)
+        angle = 2.0 * pi - angle;
     *x = m_x + std::cos(angle) * m_rx;
     *y = m_y + std::sin(angle) * m_ry;
     m_step++;
     return ((m_step == 1) ? path_cmd_move_to : path_cmd_line_to);
 }
 
-}
+} // namespace agg
-
-
 
 #endif
-
-

deps/agg/include/agg_ellipse_bresenham.h

@@ -20,27 +20,24 @@
 #ifndef AGG_ELLIPSE_BRESENHAM_INCLUDED
 #define AGG_ELLIPSE_BRESENHAM_INCLUDED
 
-
 #include "agg_basics.h"
 
-
+namespace agg {
-namespace agg
-{
 
 //------------------------------------------ellipse_bresenham_interpolator
 class ellipse_bresenham_interpolator
 {
   public:
-        ellipse_bresenham_interpolator(int rx, int ry) :
+    ellipse_bresenham_interpolator(int rx, int ry)
-            m_rx2(rx * rx),
+        : m_rx2(rx * rx)
-            m_ry2(ry * ry),
+        , m_ry2(ry * ry)
-            m_two_rx2(m_rx2 << 1),
+        , m_two_rx2(m_rx2 << 1)
-            m_two_ry2(m_ry2 << 1),
+        , m_two_ry2(m_ry2 << 1)
-            m_dx(0),
+        , m_dx(0)
-            m_dy(0),
+        , m_dy(0)
-            m_inc_x(0),
+        , m_inc_x(0)
-            m_inc_y(-ry * m_two_rx2),
+        , m_inc_y(-ry * m_two_rx2)
-            m_cur_f(0)
+        , m_cur_f(0)
     {}
 
     int dx() const { return m_dx; }
@@ -52,13 +49,16 @@ namespace agg
         int fx, fy, fxy;
 
         mx = fx = m_cur_f + m_inc_x + m_ry2;
-            if(mx < 0) mx = -mx;
+        if (mx < 0)
+            mx = -mx;
 
         my = fy = m_cur_f + m_inc_y + m_rx2;
-            if(my < 0) my = -my;
+        if (my < 0)
+            my = -my;
 
         mxy = fxy = m_cur_f + m_inc_x + m_ry2 + m_inc_y + m_rx2;
-            if(mxy < 0) mxy = -mxy;
+        if (mxy < 0)
+            mxy = -mxy;
 
         min_m = mx;
         bool flag = true;
@@ -104,10 +104,8 @@ namespace agg
     int m_inc_x;
     int m_inc_y;
     int m_cur_f;
-
 };
 
-}
+} // namespace agg
 
 #endif
-

deps/agg/include/agg_embedded_raster_fonts.h

@@ -18,8 +18,7 @@
 
 #include "agg_basics.h"
 
-namespace agg
+namespace agg {
-{
 extern const int8u gse4x6[];
 extern const int8u gse4x8[];
 extern const int8u gse5x7[];
@@ -54,6 +53,6 @@ namespace agg
 extern const int8u verdana17_bold[];
 extern const int8u verdana18[];
 extern const int8u verdana18_bold[];
-}
+} // namespace agg
 
 #endif

deps/agg/include/agg_font_cache_manager.h

@@ -19,18 +19,10 @@
 #include <cstring>
 #include "agg_array.h"
 
-namespace agg
+namespace agg {
-{
 
 //---------------------------------------------------------glyph_data_type
-    enum glyph_data_type
+enum glyph_data_type { glyph_data_invalid = 0, glyph_data_mono = 1, glyph_data_gray8 = 2, glyph_data_outline = 3 };
-    {
-        glyph_data_invalid = 0,
-        glyph_data_mono    = 1,
-        glyph_data_gray8   = 2,
-        glyph_data_outline = 3
-    };
-
 
 //-------------------------------------------------------------glyph_cache
 struct glyph_cache
@@ -44,7 +36,6 @@ namespace agg
     double advance_y;
 };
 
-
 //--------------------------------------------------------------font_cache
 class font_cache
 {
@@ -52,9 +43,9 @@ namespace agg
     enum block_size_e { block_size = 16384 - 16 };
 
     //--------------------------------------------------------------------
-        font_cache() : 
+    font_cache()
-            m_allocator(block_size),
+        : m_allocator(block_size)
-            m_font_signature(0)
+        , m_font_signature(0)
     {}
 
     //--------------------------------------------------------------------
@@ -66,10 +57,7 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        bool font_is(const char* font_signature) const
+    bool font_is(const char* font_signature) const { return strcmp(font_signature, m_font_signature) == 0; }
-        {
-            return strcmp(font_signature, m_font_signature) == 0;
-        }
 
     //--------------------------------------------------------------------
     const glyph_cache* find_glyph(unsigned glyph_code) const
@@ -94,18 +82,15 @@ namespace agg
         unsigned msb = (glyph_code >> 8) & 0xFF;
         if (m_glyphs[msb] == 0)
         {
-                m_glyphs[msb] = 
+            m_glyphs[msb] = (glyph_cache**)m_allocator.allocate(sizeof(glyph_cache*) * 256, sizeof(glyph_cache*));
-                    (glyph_cache**)m_allocator.allocate(sizeof(glyph_cache*) * 256, 
-                                                        sizeof(glyph_cache*));
             memset(m_glyphs[msb], 0, sizeof(glyph_cache*) * 256);
         }
 
         unsigned lsb = glyph_code & 0xFF;
-            if(m_glyphs[msb][lsb]) return 0; // Already exists, do not overwrite
+        if (m_glyphs[msb][lsb])
+            return 0; // Already exists, do not overwrite
 
-            glyph_cache* glyph = 
+        glyph_cache* glyph = (glyph_cache*)m_allocator.allocate(sizeof(glyph_cache), sizeof(double));
-                (glyph_cache*)m_allocator.allocate(sizeof(glyph_cache),
-                                                   sizeof(double));
 
         glyph->glyph_index = glyph_index;
         glyph->data = m_allocator.allocate(data_size);
@@ -123,12 +108,6 @@ namespace agg
     char* m_font_signature;
 };
 
-
-
-
-
-
-    
 //---------------------------------------------------------font_cache_pool
 class font_cache_pool
 {
@@ -145,14 +124,13 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        font_cache_pool(unsigned max_fonts=32) : 
+    font_cache_pool(unsigned max_fonts = 32)
-            m_fonts(pod_allocator<font_cache*>::allocate(max_fonts)),
+        : m_fonts(pod_allocator<font_cache*>::allocate(max_fonts))
-            m_max_fonts(max_fonts),
+        , m_max_fonts(max_fonts)
-            m_num_fonts(0),
+        , m_num_fonts(0)
-            m_cur_font(0)
+        , m_cur_font(0)
     {}
 
-
     //--------------------------------------------------------------------
     void font(const char* font_signature, bool reset_cache = false)
     {
@@ -172,9 +150,7 @@ namespace agg
             if (m_num_fonts >= m_max_fonts)
             {
                 obj_allocator<font_cache>::deallocate(m_fonts[0]);
-                    memcpy(m_fonts, 
+                memcpy(m_fonts, m_fonts + 1, (m_max_fonts - 1) * sizeof(font_cache*));
-                           m_fonts + 1, 
-                           (m_max_fonts - 1) * sizeof(font_cache*));
                 m_num_fonts = m_max_fonts - 1;
             }
             m_fonts[m_num_fonts] = obj_allocator<font_cache>::allocate();
@@ -185,15 +161,13 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        const font_cache* font() const
+    const font_cache* font() const { return m_cur_font; }
-        {
-            return m_cur_font;
-        }
 
     //--------------------------------------------------------------------
     const glyph_cache* find_glyph(unsigned glyph_code) const
     {
-            if(m_cur_font) return m_cur_font->find_glyph(glyph_code);
+        if (m_cur_font)
+            return m_cur_font->find_glyph(glyph_code);
         return 0;
     }
 
@@ -208,25 +182,19 @@ namespace agg
     {
         if (m_cur_font)
         {
-                return m_cur_font->cache_glyph(glyph_code,
+            return m_cur_font->cache_glyph(glyph_code, glyph_index, data_size, data_type, bounds, advance_x, advance_y);
-                                               glyph_index,
-                                               data_size,
-                                               data_type,
-                                               bounds,
-                                               advance_x,
-                                               advance_y);
         }
         return 0;
     }
 
-
     //--------------------------------------------------------------------
     int find_font(const char* font_signature)
     {
         unsigned i;
         for (i = 0; i < m_num_fonts; i++)
         {
-                if(m_fonts[i]->font_is(font_signature)) return int(i);
+            if (m_fonts[i]->font_is(font_signature))
+                return int(i);
         }
         return -1;
     }
@@ -238,12 +206,8 @@ namespace agg
     font_cache* m_cur_font;
 };
 
-
-
-
 //------------------------------------------------------------------------
-    enum glyph_rendering
+enum glyph_rendering {
-    {
     glyph_ren_native_mono,
     glyph_ren_native_gray8,
     glyph_ren_outline,
@@ -251,11 +215,9 @@ namespace agg
     glyph_ren_agg_gray8
 };
 
-
-
-
 //------------------------------------------------------font_cache_manager
-    template<class FontEngine> class font_cache_manager
+template<class FontEngine>
+class font_cache_manager
 {
   public:
     typedef FontEngine font_engine_type;
@@ -267,19 +229,16 @@ namespace agg
     typedef typename mono_adaptor_type::embedded_scanline mono_scanline_type;
 
     //--------------------------------------------------------------------
-        font_cache_manager(font_engine_type& engine, unsigned max_fonts=32) :
+    font_cache_manager(font_engine_type& engine, unsigned max_fonts = 32)
-            m_fonts(max_fonts),
+        : m_fonts(max_fonts)
-            m_engine(engine),
+        , m_engine(engine)
-            m_change_stamp(-1),
+        , m_change_stamp(-1)
-            m_prev_glyph(0),
+        , m_prev_glyph(0)
-            m_last_glyph(0)
+        , m_last_glyph(0)
     {}
 
     //--------------------------------------------------------------------
-        void reset_last_glyph()
+    void reset_last_glyph() { m_prev_glyph = m_last_glyph = 0; }
-        {
-            m_prev_glyph = m_last_glyph = 0;
-        }
 
     //--------------------------------------------------------------------
     const glyph_cache* glyph(unsigned glyph_code)
@@ -311,15 +270,14 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        void init_embedded_adaptors(const glyph_cache* gl, 
+    void init_embedded_adaptors(const glyph_cache* gl, double x, double y, double scale = 1.0)
-                                    double x, double y, 
-                                    double scale=1.0)
     {
         if (gl)
         {
             switch (gl->data_type)
             {
-                default: return;
+                default:
+                    return;
                 case glyph_data_mono:
                     m_mono_adaptor.init(gl->data, gl->data_size, x, y);
                     break;
@@ -335,7 +293,6 @@ namespace agg
         }
     }
 
-
     //--------------------------------------------------------------------
     path_adaptor_type& path_adaptor() { return m_path_adaptor; }
     gray8_adaptor_type& gray8_adaptor() { return m_gray8_adaptor; }
@@ -352,9 +309,7 @@ namespace agg
     {
         if (m_prev_glyph && m_last_glyph)
         {
-                return m_engine.add_kerning(m_prev_glyph->glyph_index, 
+            return m_engine.add_kerning(m_prev_glyph->glyph_index, m_last_glyph->glyph_index, x, y);
-                                            m_last_glyph->glyph_index,
-                                            x, y);
         }
         return false;
     }
@@ -362,7 +317,8 @@ namespace agg
     //--------------------------------------------------------------------
     void precache(unsigned from, unsigned to)
     {
-            for(; from <= to; ++from) glyph(from);
+        for (; from <= to; ++from)
+            glyph(from);
     }
 
     //--------------------------------------------------------------------
@@ -403,7 +359,6 @@ namespace agg
     mono_scanline_type m_mono_scanline;
 };
 
-}
+} // namespace agg
 
 #endif
-

deps/agg/include/agg_gamma_functions.h

@@ -19,28 +19,31 @@
 #include <cmath>
 #include "agg_basics.h"
 
-namespace agg
+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()
-        gamma_power(double g) : m_gamma(g) {}
+        : 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
     {
-            if (x == 0.0) return 0.0;
+        if (x == 0.0)
+            return 0.0;
         return pow(x, m_gamma);
     }
 
@@ -48,35 +51,44 @@ namespace agg
     double m_gamma;
 };
 
-
 //==========================================================gamma_threshold
 class gamma_threshold
 {
   public:
-        gamma_threshold() : m_threshold(0.5) {}
+    gamma_threshold()
-        gamma_threshold(double t) : m_threshold(t) {}
+        : 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
+    double operator()(double x) const { return (x < m_threshold) ? 0.0 : 1.0; }
-        {
-            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()
-        gamma_linear(double s, double e) : m_start(s), m_end(e) {}
+        : 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 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; }
@@ -84,12 +96,15 @@ namespace agg
 
     double operator()(double x) const
     {
-            if(x < m_start) return 0.0;
+        if (x < m_start)
-            if(x > m_end) return 1.0;
+            return 0.0;
+        if (x > m_end)
+            return 1.0;
         double delta = m_end - m_start;
         // avoid nan from potential zero division
         // https://github.com/mapnik/mapnik/issues/761
-            if (delta <= 0.0) return 0.0;
+        if (delta <= 0.0)
+            return 0.0;
         return (x - m_start) / delta;
     }
 
@@ -98,13 +113,16 @@ namespace agg
     double m_end;
 };
 
-
 //==========================================================gamma_multiply
 class gamma_multiply
 {
   public:
-        gamma_multiply() : m_mul(1.0) {}
+    gamma_multiply()
-        gamma_multiply(double v) : m_mul(v) {}
+        : m_mul(1.0)
+    {}
+    gamma_multiply(double v)
+        : m_mul(v)
+    {}
 
     void value(double v) { m_mul = v; }
     double value() const { return m_mul; }
@@ -112,7 +130,8 @@ namespace agg
     double operator()(double x) const
     {
         double y = x * m_mul;
-            if(y > 1.0) y = 1.0;
+        if (y > 1.0)
+            y = 1.0;
         return y;
     }
 
@@ -129,6 +148,6 @@ namespace agg
 {
     return (x <= 0.0031308) ? (x * 12.92) : (1.055 * pow(x, 1 / 2.4) - 0.055);
 }
-}
+} // namespace agg
 
 #endif

deps/agg/include/agg_gamma_lut.h

@@ -20,29 +20,16 @@
 #include "agg_basics.h"
 #include "agg_gamma_functions.h"
 
-namespace agg
+namespace agg {
-{
+template<class LoResT = int8u, class HiResT = int8u, unsigned GammaShift = 8, unsigned HiResShift = 8>
-    template<class LoResT=int8u,
+class gamma_lut
-             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
+    enum gamma_scale_e { gamma_shift = GammaShift, gamma_size = 1 << gamma_shift, gamma_mask = gamma_size - 1 };
-        {
-            gamma_shift = GammaShift,
-            gamma_size  = 1 << gamma_shift,
-            gamma_mask  = gamma_size - 1
-        };
 
-        enum hi_res_scale_e
+    enum hi_res_scale_e { hi_res_shift = HiResShift, hi_res_size = 1 << hi_res_shift, hi_res_mask = hi_res_size - 1 };
-        {
-            hi_res_shift = HiResShift,
-            hi_res_size  = 1 << hi_res_shift,
-            hi_res_mask  = hi_res_size - 1
-        };
 
     ~gamma_lut()
     {
@@ -50,10 +37,10 @@ namespace agg
         pod_allocator<HiResT>::deallocate(m_dir_gamma, gamma_size);
     }
 
-        gamma_lut() :
+    gamma_lut()
-            m_gamma(1.0),
+        : m_gamma(1.0)
-            m_dir_gamma(pod_allocator<HiResT>::allocate(gamma_size)),
+        , m_dir_gamma(pod_allocator<HiResT>::allocate(gamma_size))
-            m_inv_gamma(pod_allocator<LoResT>::allocate(hi_res_size))
+        , m_inv_gamma(pod_allocator<LoResT>::allocate(hi_res_size))
     {
         unsigned i;
         for (i = 0; i < gamma_size; i++)
@@ -67,10 +54,10 @@ namespace agg
         }
     }
 
-        gamma_lut(double g) :
+    gamma_lut(double g)
-            m_gamma(1.0),
+        : m_gamma(1.0)
-            m_dir_gamma(pod_allocator<HiResT>::allocate(gamma_size)),
+        , m_dir_gamma(pod_allocator<HiResT>::allocate(gamma_size))
-            m_inv_gamma(pod_allocator<LoResT>::allocate(hi_res_size))
+        , m_inv_gamma(pod_allocator<LoResT>::allocate(hi_res_size))
     {
         gamma(g);
     }
@@ -82,32 +69,21 @@ namespace agg
         unsigned i;
         for (i = 0; i < gamma_size; i++)
         {
-                m_dir_gamma[i] = (HiResT)
+            m_dir_gamma[i] = (HiResT)uround(pow(i / double(gamma_mask), m_gamma) * double(hi_res_mask));
-                    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)
+            m_inv_gamma[i] = (LoResT)uround(pow(i / double(hi_res_mask), inv_g) * double(gamma_mask));
-                    uround(pow(i / double(hi_res_mask), inv_g) * double(gamma_mask));
         }
     }
 
-        double gamma() const
+    double gamma() const { return m_gamma; }
-        {
-            return m_gamma;
-        }
 
-        HiResT dir(LoResT v) const
+    HiResT dir(LoResT v) const { return m_dir_gamma[unsigned(v)]; }
-        {
-            return m_dir_gamma[unsigned(v)];
-        }
 
-        LoResT inv(HiResT v) const
+    LoResT inv(HiResT v) const { return m_inv_gamma[unsigned(v)]; }
-        {
-            return m_inv_gamma[unsigned(v)];
-        }
 
   private:
     gamma_lut(const self_type&);
@@ -129,23 +105,28 @@ namespace agg
 class sRGB_lut_base
 {
   public:
-        LinearType dir(int8u v) const
+    LinearType dir(int8u v) const { return m_dir_table[v]; }
-        {
-            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[128])
-            if (v > m_inv_table[x + 64]) x += 64;
+            x = 128;
-            if (v > m_inv_table[x + 32]) x += 32;
+        if (v > m_inv_table[x + 64])
-            if (v > m_inv_table[x + 16]) x += 16;
+            x += 64;
-            if (v > m_inv_table[x + 8]) x += 8;
+        if (v > m_inv_table[x + 32])
-            if (v > m_inv_table[x + 4]) x += 4;
+            x += 32;
-            if (v > m_inv_table[x + 2]) x += 2;
+        if (v > m_inv_table[x + 16])
-            if (v > m_inv_table[x + 1]) x += 1;
+            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;
     }
 
@@ -154,9 +135,7 @@ namespace agg
     LinearType m_inv_table[256];
 
     // Only derived classes may instantiate.
-        sRGB_lut_base()
+    sRGB_lut_base() {}
-        {
-        }
 };
 
 // sRGB_lut - implements sRGB conversion for the various types.
@@ -230,15 +209,9 @@ namespace agg
 class sRGB_conv_base
 {
   public:
-        static T rgb_from_sRGB(int8u x)
+    static T rgb_from_sRGB(int8u x) { return lut.dir(x); }
-        {
-            return lut.dir(x);
-        }
 
-        static int8u rgb_to_sRGB(T x)
+    static int8u rgb_to_sRGB(T x) { return lut.inv(x); }
-        {
-            return lut.inv(x);
-        }
 
   private:
     static sRGB_lut<T> lut;
@@ -258,16 +231,16 @@ namespace agg
 class sRGB_conv<float> : public sRGB_conv_base<float>
 {
   public:
-        static float alpha_from_sRGB(int8u x)
+    static float alpha_from_sRGB(int8u x) { return float(x / 255.0); }
-        {
-            return float(x / 255.0);
-        }
 
     static int8u alpha_to_sRGB(float x)
     {
-            if (x <= 0) return 0;
+        if (x <= 0)
-            else if (x >= 1) return 255;
+            return 0;
-            else return int8u(0.5 + x * 255);
+        else if (x >= 1)
+            return 255;
+        else
+            return int8u(0.5 + x * 255);
     }
 };
 
@@ -275,31 +248,19 @@ namespace agg
 class sRGB_conv<int16u> : public sRGB_conv_base<int16u>
 {
   public:
-        static int16u alpha_from_sRGB(int8u x)
+    static int16u alpha_from_sRGB(int8u x) { return (x << 8) | x; }
-        {
-            return (x << 8) | x;
-        }
 
-        static int8u alpha_to_sRGB(int16u x)
+    static int8u alpha_to_sRGB(int16u x) { return x >> 8; }
-        {
-            return x >> 8;
-        }
 };
 
 template<>
 class sRGB_conv<int8u> : public sRGB_conv_base<int8u>
 {
   public:
-        static int8u alpha_from_sRGB(int8u x)
+    static int8u alpha_from_sRGB(int8u x) { return x; }
-        {
-            return x;
-        }
 
-        static int8u alpha_to_sRGB(int8u x)
+    static int8u alpha_to_sRGB(int8u x) { return x; }
-        {
-            return x;
-        }
 };
-}
+} // namespace agg
 
 #endif

deps/agg/include/agg_glyph_raster_bin.h

@@ -19,11 +19,11 @@
 #include <cstring>
 #include "agg_basics.h"
 
-namespace agg
+namespace agg {
-{
 
 //========================================================glyph_raster_bin
-    template<class ColorT> class glyph_raster_bin
+template<class ColorT>
+class glyph_raster_bin
 {
   public:
     typedef ColorT color_type;
@@ -36,12 +36,13 @@ namespace agg
     };
 
     //--------------------------------------------------------------------
-        glyph_raster_bin(const int8u* font) :
+    glyph_raster_bin(const int8u* font)
-            m_font(font),
+        : m_font(font)
-            m_big_endian(false)
+        , m_big_endian(false)
     {
         int t = 1;
-            if(*(char*)&t == 0) m_big_endian = true;
+        if (*(char*)&t == 0)
+            m_big_endian = true;
         memset(m_span, 0, sizeof(m_span));
     }
 
@@ -64,8 +65,7 @@ namespace agg
         while (*str)
         {
             unsigned glyph = *str;
-                const int8u* bits = m_font + 4 + num_chars * 2 + 
+            const int8u* bits = m_font + 4 + num_chars * 2 + value(m_font + 4 + (glyph - start_char) * 2);
-                                    value(m_font + 4 + (glyph - start_char) * 2);
             w += *bits;
             ++str;
         }
@@ -78,8 +78,7 @@ namespace agg
         unsigned start_char = m_font[2];
         unsigned num_chars = m_font[3];
 
-            m_bits = m_font + 4 + num_chars * 2 + 
+        m_bits = m_font + 4 + num_chars * 2 + value(m_font + 4 + (glyph - start_char) * 2);
-                     value(m_font + 4 + (glyph - start_char) * 2);
 
         m_glyph_width = *m_bits++;
         m_glyph_byte_width = (m_glyph_width + 7) >> 3;
@@ -139,7 +138,6 @@ namespace agg
         return v;
     }
 
-
     //--------------------------------------------------------------------
     const int8u* m_font;
     bool m_big_endian;
@@ -149,7 +147,6 @@ namespace agg
     unsigned m_glyph_byte_width;
 };
 
-
+} // namespace agg
-}
 
 #endif

deps/agg/include/agg_gradient_lut.h

@@ -21,33 +21,25 @@
 #include "agg_color_rgba.h"
 #include "agg_color_gray.h"
 
-namespace agg
+namespace agg {
-{
 
 //======================================================color_interpolator
-    template<class ColorT> struct color_interpolator
+template<class ColorT>
+struct color_interpolator
 {
   public:
     typedef ColorT color_type;
 
-        color_interpolator(const color_type& c1, 
+    color_interpolator(const color_type& c1, const color_type& c2, unsigned len)
-                           const color_type& c2, 
+        : m_c1(c1)
-                           unsigned len) :
+        , m_c2(c2)
-            m_c1(c1),
+        , m_len(len)
-            m_c2(c2),
+        , m_count(0)
-            m_len(len),
-            m_count(0)
     {}
 
-        void operator ++ ()
+    void operator++() { ++m_count; }
-        {
-            ++m_count;
-        }
 
-        color_type color() const
+    color_type color() const { return m_c1.gradient(m_c2, double(m_count) / m_len); }
-        {
-            return m_c1.gradient(m_c2, double(m_count) / m_len);
-        }
 
   private:
     color_type m_c1;
@@ -58,29 +50,28 @@ namespace agg
 
 //========================================================================
 // Fast specialization for rgba8
-    template<> struct color_interpolator<rgba8>
+template<>
+struct color_interpolator<rgba8>
 {
   public:
     typedef rgba8 color_type;
 
-        color_interpolator(const color_type& c1, 
+    color_interpolator(const color_type& c1, const color_type& c2, unsigned len)
-                           const color_type& c2, 
+        : r(c1.r, c2.r, len)
-                           unsigned len) :
+        , g(c1.g, c2.g, len)
-            r(c1.r, c2.r, len),
+        , b(c1.b, c2.b, len)
-            g(c1.g, c2.g, len),
+        , a(c1.a, c2.a, len)
-            b(c1.b, c2.b, len),
-            a(c1.a, c2.a, len)
     {}
 
     void operator++()
     {
-            ++r; ++g; ++b; ++a;
+        ++r;
+        ++g;
+        ++b;
+        ++a;
     }
 
-        color_type color() const
+    color_type color() const { return color_type(r.y(), g.y(), b.y(), a.y()); }
-        {
-            return color_type(r.y(), g.y(), b.y(), a.y());
-        }
 
   private:
     agg::dda_line_interpolator<14> r, g, b, a;
@@ -88,35 +79,32 @@ namespace agg
 
 //========================================================================
 // Fast specialization for gray8
-    template<> struct color_interpolator<gray8>
+template<>
+struct color_interpolator<gray8>
 {
   public:
     typedef gray8 color_type;
 
-        color_interpolator(const color_type& c1, 
+    color_interpolator(const color_type& c1, const color_type& c2, unsigned len)
-                           const color_type& c2, 
+        : v(c1.v, c2.v, len)
-                           unsigned len) :
+        , a(c1.a, c2.a, len)
-            v(c1.v, c2.v, len),
-            a(c1.a, c2.a, len)
     {}
 
     void operator++()
     {
-            ++v; ++a;
+        ++v;
+        ++a;
     }
 
-        color_type color() const
+    color_type color() const { return color_type(v.y(), a.y()); }
-        {
-            return color_type(v.y(), a.y());
-        }
 
   private:
     agg::dda_line_interpolator<14> v, a;
 };
 
 //============================================================gradient_lut
-    template<class ColorInterpolator, 
+template<class ColorInterpolator, unsigned ColorLutSize = 256>
-             unsigned ColorLutSize=256> class gradient_lut
+class gradient_lut
 {
   public:
     typedef ColorInterpolator interpolator_type;
@@ -124,7 +112,9 @@ namespace agg
     enum { color_lut_size = ColorLutSize };
 
     //--------------------------------------------------------------------
-        gradient_lut() : m_color_lut(color_lut_size) {}
+    gradient_lut()
+        : m_color_lut(color_lut_size)
+    {}
 
     // Build Gradient Lut
     // First, call remove_all(), then add_color() at least twice,
@@ -143,14 +133,8 @@ namespace agg
     // ColorF in span_gradient. All it needs is two access methods
     // size() and operator [].
     //--------------------------------------------------------------------
-        static unsigned size() 
+    static unsigned size() { return color_lut_size; }
-        { 
+    const color_type& operator[](unsigned i) const { return m_color_lut[i]; }
-            return color_lut_size; 
-        }
-        const color_type& operator [] (unsigned i) const 
-        { 
-            return m_color_lut[i]; 
-        }
 
   private:
     //--------------------------------------------------------------------
@@ -160,32 +144,27 @@ namespace agg
         color_type color;
 
         color_point() {}
-            color_point(double off, const color_type& c) : 
+        color_point(double off, const color_type& c)
-                offset(off), color(c)
+            : offset(off)
+            , color(c)
         {
-                if(offset < 0.0) offset = 0.0;
+            if (offset < 0.0)
-                if(offset > 1.0) offset = 1.0;
+                offset = 0.0;
+            if (offset > 1.0)
+                offset = 1.0;
         }
     };
     typedef agg::pod_bvector<color_point, 4> color_profile_type;
     typedef agg::pod_array<color_type> color_lut_type;
 
-        static bool offset_less(const color_point& a, const color_point& b)
+    static bool offset_less(const color_point& a, const color_point& b) { return a.offset < b.offset; }
-        {
+    static bool offset_equal(const color_point& a, const color_point& b) { return a.offset == b.offset; }
-            return a.offset < b.offset;
-        }
-        static bool offset_equal(const color_point& a, const color_point& b)
-        {
-            return a.offset == b.offset;
-        }
 
     //--------------------------------------------------------------------
     color_profile_type m_color_profile;
     color_lut_type m_color_lut;
 };
 
-
-
 //------------------------------------------------------------------------
 template<class T, unsigned S>
 void gradient_lut<T, S>::remove_all()
@@ -219,9 +198,7 @@ namespace agg
         for (i = 1; i < m_color_profile.size(); i++)
         {
             end = uround(m_color_profile[i].offset * color_lut_size);
-                interpolator_type ci(m_color_profile[i-1].color, 
+            interpolator_type ci(m_color_profile[i - 1].color, m_color_profile[i].color, end - start + 1);
-                                     m_color_profile[i  ].color, 
-                                     end - start + 1);
             while (start < end)
             {
                 m_color_lut[start] = ci.color();
@@ -238,9 +215,6 @@ namespace agg
     }
     return false;
 }
-}
+} // namespace agg
-
-
-
 
 #endif

deps/agg/include/agg_gsv_text.h

@@ -24,9 +24,7 @@
 #include "agg_conv_stroke.h"
 #include "agg_conv_transform.h"
 
-namespace agg
+namespace agg {
-{
-
 
 //---------------------------------------------------------------gsv_text
 //
@@ -34,13 +32,7 @@ namespace agg
 //
 class gsv_text
 {
-        enum status
+    enum status { initial, next_char, start_glyph, glyph };
-        {
-            initial,
-            next_char,
-            start_glyph,
-            glyph
-        };
 
   public:
     gsv_text();
@@ -105,28 +97,19 @@ namespace agg
     double m_h;
 };
 
-
-
-
 //--------------------------------------------------------gsv_text_outline
-    template<class Transformer = trans_affine> class gsv_text_outline
+template<class Transformer = trans_affine>
+class gsv_text_outline
 {
   public:
-        gsv_text_outline(gsv_text& text, const Transformer& trans) :
+    gsv_text_outline(gsv_text& text, const Transformer& trans)
-          m_polyline(text),
+        : m_polyline(text)
-          m_trans(m_polyline, trans)
+        , m_trans(m_polyline, trans)
-        {
+    {}
-        }
 
-        void width(double w) 
+    void width(double w) { m_polyline.width(w); }
-        { 
-            m_polyline.width(w); 
-        }
 
-        void transformer(const Transformer* trans) 
+    void transformer(const Transformer* trans) { m_trans->transformer(trans); }
-        {
-            m_trans->transformer(trans);
-        }
 
     void rewind(unsigned path_id)
     {
@@ -135,19 +118,13 @@ namespace agg
         m_polyline.line_cap(round_cap);
     }
 
-        unsigned vertex(double* x, double* y)
+    unsigned vertex(double* x, double* y) { return m_trans.vertex(x, y); }
-        {
-            return m_trans.vertex(x, y);
-        }
 
   private:
     conv_stroke<gsv_text> m_polyline;
     conv_transform<conv_stroke<gsv_text>, Transformer> m_trans;
 };
 
-
+} // namespace agg
-
-}
-
 
 #endif

deps/agg/include/agg_image_accessors.h

@@ -18,11 +18,11 @@
 
 #include "agg_basics.h"
 
-namespace agg
+namespace agg {
-{
 
 //-----------------------------------------------------image_accessor_clip
-    template<class PixFmt> class image_accessor_clip
+template<class PixFmt>
+class image_accessor_clip
 {
   public:
     typedef PixFmt pixfmt_type;
@@ -32,28 +32,20 @@ namespace agg
     enum pix_width_e { pix_width = pixfmt_type::pix_width };
 
     image_accessor_clip() {}
-        explicit image_accessor_clip(const pixfmt_type& pixf,
+    explicit image_accessor_clip(const pixfmt_type& pixf, const color_type& bk)
-                                     const color_type& bk) :
+        : m_pixf(&pixf)
-            m_pixf(&pixf)
     {
         pixfmt_type::make_pix(m_bk_buf, bk);
     }
 
-        void attach(const pixfmt_type& pixf)
+    void attach(const pixfmt_type& pixf) { m_pixf = &pixf; }
-        {
-            m_pixf = &pixf;
-        }
 
-        void background_color(const color_type& bk)
+    void background_color(const color_type& bk) { pixfmt_type::make_pix(m_bk_buf, 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() &&
+        if (m_y >= 0 && m_y < (int)m_pixf->height() && m_x >= 0 && m_x < (int)m_pixf->width())
-               m_x >= 0 && m_x < (int)m_pixf->width())
         {
             return m_pixf->pix_ptr(m_x, m_y);
         }
@@ -65,8 +57,7 @@ namespace agg
     {
         m_x = m_x0 = x;
         m_y = y;
-            if(y >= 0 && y < (int)m_pixf->height() &&
+        if (y >= 0 && y < (int)m_pixf->height() && x >= 0 && x + (int)len <= (int)m_pixf->width())
-               x >= 0 && x+(int)len <= (int)m_pixf->width())
         {
             return m_pix_ptr = m_pixf->pix_ptr(x, y);
         }
@@ -76,7 +67,8 @@ namespace agg
 
     AGG_INLINE const int8u* next_x()
     {
-            if(m_pix_ptr) return m_pix_ptr += pix_width;
+        if (m_pix_ptr)
+            return m_pix_ptr += pix_width;
         ++m_x;
         return pixel();
     }
@@ -85,8 +77,7 @@ namespace agg
     {
         ++m_y;
         m_x = m_x0;
-            if(m_pix_ptr &&
+        if (m_pix_ptr && m_y >= 0 && m_y < (int)m_pixf->height())
-               m_y >= 0 && m_y < (int)m_pixf->height())
         {
             return m_pix_ptr = m_pixf->pix_ptr(m_x, m_y);
         }
@@ -101,11 +92,9 @@ namespace agg
     const int8u* m_pix_ptr;
 };
 
-
-
-
 //--------------------------------------------------image_accessor_no_clip
-    template<class PixFmt> class image_accessor_no_clip
+template<class PixFmt>
+class image_accessor_no_clip
 {
   public:
     typedef PixFmt pixfmt_type;
@@ -115,14 +104,11 @@ namespace agg
     enum pix_width_e { pix_width = pixfmt_type::pix_width };
 
     image_accessor_no_clip() {}
-        explicit image_accessor_no_clip(const pixfmt_type& pixf) :
+    explicit image_accessor_no_clip(const pixfmt_type& pixf)
-            m_pixf(&pixf)
+        : m_pixf(&pixf)
     {}
 
-        void attach(const pixfmt_type& pixf)
+    void attach(const pixfmt_type& pixf) { m_pixf = &pixf; }
-        {
-            m_pixf = &pixf;
-        }
 
     AGG_INLINE const int8u* span(int x, int y, unsigned)
     {
@@ -131,10 +117,7 @@ namespace agg
         return m_pix_ptr = m_pixf->pix_ptr(x, y);
     }
 
-        AGG_INLINE const int8u* next_x()
+    AGG_INLINE const int8u* next_x() { return m_pix_ptr += pix_width; }
-        {
-            return m_pix_ptr += pix_width;
-        }
 
     AGG_INLINE const int8u* next_y()
     {
@@ -148,11 +131,9 @@ namespace agg
     const int8u* m_pix_ptr;
 };
 
-
-
-
 //----------------------------------------------------image_accessor_clone
-    template<class PixFmt> class image_accessor_clone
+template<class PixFmt>
+class image_accessor_clone
 {
   public:
     typedef PixFmt pixfmt_type;
@@ -162,24 +143,25 @@ namespace agg
     enum pix_width_e { pix_width = pixfmt_type::pix_width };
 
     image_accessor_clone() {}
-        explicit image_accessor_clone(const pixfmt_type& pixf) :
+    explicit image_accessor_clone(const pixfmt_type& pixf)
-            m_pixf(&pixf)
+        : m_pixf(&pixf)
     {}
 
-        void attach(const pixfmt_type& pixf)
+    void attach(const pixfmt_type& pixf) { m_pixf = &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 (x < 0)
-            if(y < 0) y = 0;
+            x = 0;
-            if(x >= (int)m_pixf->width())  x = m_pixf->width() - 1;
+        if (y < 0)
-            if(y >= (int)m_pixf->height()) y = m_pixf->height() - 1;
+            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);
     }
 
@@ -188,8 +170,7 @@ namespace agg
     {
         m_x = m_x0 = x;
         m_y = y;
-            if(y >= 0 && y < (int)m_pixf->height() &&
+        if (y >= 0 && y < (int)m_pixf->height() && x >= 0 && x + (int)len <= (int)m_pixf->width())
-               x >= 0 && x+(int)len <= (int)m_pixf->width())
         {
             return m_pix_ptr = m_pixf->pix_ptr(x, y);
         }
@@ -199,7 +180,8 @@ namespace agg
 
     AGG_INLINE const int8u* next_x()
     {
-            if(m_pix_ptr) return m_pix_ptr += pix_width;
+        if (m_pix_ptr)
+            return m_pix_ptr += pix_width;
         ++m_x;
         return pixel();
     }
@@ -208,8 +190,7 @@ namespace agg
     {
         ++m_y;
         m_x = m_x0;
-            if(m_pix_ptr &&
+        if (m_pix_ptr && m_y >= 0 && m_y < (int)m_pixf->height())
-               m_y >= 0 && m_y < (int)m_pixf->height())
         {
             return m_pix_ptr = m_pixf->pix_ptr(m_x, m_y);
         }
@@ -223,12 +204,9 @@ namespace agg
     const int8u* m_pix_ptr;
 };
 
-
-
-
-
 //-----------------------------------------------------image_accessor_wrap
-    template<class PixFmt, class WrapX, class WrapY> class image_accessor_wrap
+template<class PixFmt, class WrapX, class WrapY>
+class image_accessor_wrap
 {
   public:
     typedef PixFmt pixfmt_type;
@@ -238,16 +216,13 @@ namespace agg
     enum pix_width_e { pix_width = pixfmt_type::pix_width };
 
     image_accessor_wrap() {}
-        explicit image_accessor_wrap(const pixfmt_type& pixf) :
+    explicit image_accessor_wrap(const pixfmt_type& pixf)
-            m_pixf(&pixf),
+        : m_pixf(&pixf)
-            m_wrap_x(pixf.width()),
+        , m_wrap_x(pixf.width())
-            m_wrap_y(pixf.height())
+        , m_wrap_y(pixf.height())
     {}
 
-        void attach(const pixfmt_type& pixf)
+    void attach(const pixfmt_type& pixf) { m_pixf = &pixf; }
-        {
-            m_pixf = &pixf;
-        }
 
     AGG_INLINE const int8u* span(int x, int y, unsigned)
     {
@@ -276,86 +251,83 @@ namespace agg
     WrapY m_wrap_y;
 };
 
-
-
-
 //--------------------------------------------------------wrap_mode_repeat
 class wrap_mode_repeat
 {
   public:
     wrap_mode_repeat() {}
-        wrap_mode_repeat(unsigned size) :
+    wrap_mode_repeat(unsigned size)
-            m_size(size),
+        : m_size(size)
-            m_add(size * (0x3FFFFFFF / size)),
+        , m_add(size * (0x3FFFFFFF / size))
-            m_value(0)
+        , m_value(0)
     {}
 
-        AGG_INLINE unsigned operator() (int v)
+    AGG_INLINE unsigned operator()(int v) { return m_value = (unsigned(v) + m_add) % m_size; }
-        {
-            return m_value = (unsigned(v) + m_add) % m_size;
-        }
 
     AGG_INLINE unsigned operator++()
     {
         ++m_value;
-            if(m_value >= m_size) m_value = 0;
+        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)
+    wrap_mode_repeat_pow2(unsigned size)
+        : m_value(0)
     {
         m_mask = 1;
-            while(m_mask < size) m_mask = (m_mask << 1) | 1;
+        while (m_mask < size)
+            m_mask = (m_mask << 1) | 1;
         m_mask >>= 1;
     }
-        AGG_INLINE unsigned operator() (int v)
+    AGG_INLINE unsigned operator()(int v) { return m_value = unsigned(v) & m_mask; }
-        {
-            return m_value = unsigned(v) & m_mask;
-        }
     AGG_INLINE unsigned operator++()
     {
         ++m_value;
-            if(m_value > m_mask) m_value = 0;
+        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) :
+    wrap_mode_repeat_auto_pow2(unsigned size)
-            m_size(size),
+        : m_size(size)
-            m_add(size * (0x3FFFFFFF / size)),
+        , m_add(size * (0x3FFFFFFF / size))
-            m_mask((m_size & (m_size-1)) ? 0 : m_size-1),
+        , m_mask((m_size & (m_size - 1)) ? 0 : m_size - 1)
-            m_value(0)
+        , m_value(0)
     {}
 
     AGG_INLINE unsigned operator()(int v)
     {
-            if(m_mask) return m_value = unsigned(v) & m_mask;
+        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;
+        if (m_value >= m_size)
+            m_value = 0;
         return m_value;
     }
 
@@ -366,33 +338,36 @@ namespace agg
     unsigned m_value;
 };
 
-
 //-------------------------------------------------------wrap_mode_reflect
 class wrap_mode_reflect
 {
   public:
     wrap_mode_reflect() {}
-        wrap_mode_reflect(unsigned size) :
+    wrap_mode_reflect(unsigned size)
-            m_size(size),
+        : m_size(size)
-            m_size2(size * 2),
+        , m_size2(size * 2)
-            m_add(m_size2 * (0x3FFFFFFF / m_size2)),
+        , m_add(m_size2 * (0x3FFFFFFF / m_size2))
-            m_value(0)
+        , 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;
+        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_size2)
-            if(m_value >= m_size) return m_size2 - m_value - 1;
+            m_value = 0;
+        if (m_value >= m_size)
+            return m_size2 - m_value - 1;
         return m_value;
     }
+
   private:
     unsigned m_size;
     unsigned m_size2;
@@ -400,14 +375,13 @@ namespace agg
     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)
+    wrap_mode_reflect_pow2(unsigned size)
+        : m_value(0)
     {
         m_mask = 1;
         m_size = 1;
@@ -420,49 +394,52 @@ namespace agg
     AGG_INLINE unsigned operator()(int v)
     {
         m_value = unsigned(v) & m_mask;
-            if(m_value >= m_size) return m_mask - m_value;
+        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;
+        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) :
+    wrap_mode_reflect_auto_pow2(unsigned size)
-            m_size(size),
+        : m_size(size)
-            m_size2(size * 2),
+        , m_size2(size * 2)
-            m_add(m_size2 * (0x3FFFFFFF / m_size2)),
+        , m_add(m_size2 * (0x3FFFFFFF / m_size2))
-            m_mask((m_size2 & (m_size2-1)) ? 0 : m_size2-1),
+        , m_mask((m_size2 & (m_size2 - 1)) ? 0 : m_size2 - 1)
-            m_value(0)
+        , m_value(0)
     {}
 
     AGG_INLINE unsigned operator()(int v)
     {
-            m_value = m_mask ? unsigned(v) & m_mask :
+        m_value = m_mask ? unsigned(v) & m_mask : (unsigned(v) + m_add) % m_size2;
-                              (unsigned(v) + m_add) % m_size2;
+        if (m_value >= m_size)
-            if(m_value >= m_size) return m_size2 - m_value - 1;
+            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_size2)
-            if(m_value >= m_size) return m_size2 - m_value - 1;
+            m_value = 0;
+        if (m_value >= m_size)
+            return m_size2 - m_value - 1;
         return m_value;
     }
 
@@ -474,8 +451,6 @@ namespace agg
     unsigned m_value;
 };
 
-
+} // namespace agg
-}
-
 
 #endif

deps/agg/include/agg_image_filters.h

@@ -23,32 +23,28 @@
 #include "agg_array.h"
 #include "agg_math.h"
 
-namespace agg
+namespace agg {
-{
 
 // See Implementation agg_image_filters.cpp
 
-    enum image_filter_scale_e
+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
+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,
+    template<class FilterF>
-                                               bool normalization=true)
+    void calculate(const FilterF& filter, bool normalization = true)
     {
         double r = filter.radius();
         realloc_lut(r);
@@ -58,8 +54,7 @@ namespace agg
         {
             double x = double(i) / double(image_subpixel_scale);
             double y = filter.calc_weight(x);
-                m_weight_array[pivot + i] = 
+            m_weight_array[pivot + i] = m_weight_array[pivot - i] = (int16)iround(y * image_filter_scale);
-                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];
@@ -69,10 +64,14 @@ namespace agg
         }
     }
 
-        image_filter_lut() : m_radius(0), m_diameter(0), m_start(0) {}
+    image_filter_lut()
+        : m_radius(0)
+        , m_diameter(0)
+        , m_start(0)
+    {}
 
-        template<class FilterF> image_filter_lut(const FilterF& filter, 
+    template<class FilterF>
-                                                 bool normalization=true)
+    image_filter_lut(const FilterF& filter, bool normalization = true)
     {
         calculate(filter, normalization);
     }
@@ -94,61 +93,43 @@ namespace agg
     pod_array<int16> m_weight_array;
 };
 
-
-
 //--------------------------------------------------------image_filter
-    template<class FilterF> class image_filter : public image_filter_lut
+template<class FilterF>
+class image_filter : public image_filter_lut
 {
   public:
-        image_filter()
+    image_filter() { calculate(m_filter_function); }
-        {
+
-            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)
+    static double calc_weight(double x) { return 1.0 - x; }
-        {
-            return 1.0 - x;
-        }
 };
 
-
 //-----------------------------------------------image_filter_hanning
 struct image_filter_hanning
 {
     static double radius() { return 1.0; }
-        static double calc_weight(double x)
+    static double calc_weight(double x) { return 0.5 + 0.5 * std::cos(pi * x); }
-        {
-            return 0.5 + 0.5 * std::cos(pi * x);
-        }
 };
 
-
 //-----------------------------------------------image_filter_hamming
 struct image_filter_hamming
 {
     static double radius() { return 1.0; }
-        static double calc_weight(double x)
+    static double calc_weight(double x) { return 0.54 + 0.46 * std::cos(pi * x); }
-        {
-            return 0.54 + 0.46 * std::cos(pi * x);
-        }
 };
 
 //-----------------------------------------------image_filter_hermite
 struct image_filter_hermite
 {
     static double radius() { return 1.0; }
-        static double calc_weight(double x)
+    static double calc_weight(double x) { return (2.0 * x - 3.0) * x * x + 1.0; }
-        {
-            return (2.0 * x - 3.0) * x * x + 1.0;
-        }
 };
 
 //------------------------------------------------image_filter_quadric
@@ -158,8 +139,13 @@ namespace agg
     static double calc_weight(double x)
     {
         double t;
-            if(x <  0.5) return 0.75 - x * x;
+        if (x < 0.5)
-            if(x <  1.5) {t = x - 1.5; return 0.5 * t * t;}
+            return 0.75 - x * x;
+        if (x < 1.5)
+        {
+            t = x - 1.5;
+            return 0.5 * t * t;
+        }
         return 0.0;
     }
 };
@@ -167,18 +153,13 @@ namespace agg
 //------------------------------------------------image_filter_bicubic
 class image_filter_bicubic
 {
-        static double pow3(double x)
+    static double pow3(double x) { return (x <= 0.0) ? 0.0 : x * x * x; }
-        {
-            return (x <= 0.0) ? 0.0 : x * x * x;
-        }
 
   public:
     static double radius() { return 2.0; }
     static double calc_weight(double x)
     {
-            return
+        return (1.0 / 6.0) * (pow3(x + 2) - 4 * pow3(x + 1) + 6 * pow3(x) - 4 * pow3(x - 1));
-                (1.0/6.0) * 
-                (pow3(x + 2) - 4 * pow3(x + 1) + 6 * pow3(x) - 4 * pow3(x - 1));
     }
 };
 
@@ -190,17 +171,15 @@ namespace agg
     double epsilon;
 
   public:
-        image_filter_kaiser(double b = 6.33) :
+    image_filter_kaiser(double b = 6.33)
-            a(b), epsilon(1e-12)
+        : a(b)
+        , epsilon(1e-12)
     {
         i0a = 1.0 / bessel_i0(b);
     }
 
     static double radius() { return 1.0; }
-        double calc_weight(double x) const
+    double calc_weight(double x) const { return bessel_i0(a * sqrt(1. - x * x)) * i0a; }
-        {
-            return bessel_i0(a * sqrt(1. - x * x)) * i0a;
-        }
 
   private:
     double bessel_i0(double x) const
@@ -227,8 +206,10 @@ namespace agg
     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 < 1.0)
-            if(x <  2.0) return 0.5 * (4.0 + x * (-8.0 + x * (5.0 - x)));
+            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.;
     }
 };
@@ -240,26 +221,27 @@ namespace agg
     double q0, q1, q2, q3;
 
   public:
-        image_filter_mitchell(double b = 1.0/3.0, double c = 1.0/3.0) :
+    image_filter_mitchell(double b = 1.0 / 3.0, double c = 1.0 / 3.0)
-            p0((6.0 - 2.0 * b) / 6.0),
+        : p0((6.0 - 2.0 * b) / 6.0)
-            p2((-18.0 + 12.0 * b + 6.0 * c) / 6.0),
+        , p2((-18.0 + 12.0 * b + 6.0 * c) / 6.0)
-            p3((12.0 - 9.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),
+        , q0((8.0 * b + 24.0 * c) / 6.0)
-            q1((-12.0 * b - 48.0 * c) / 6.0),
+        , q1((-12.0 * b - 48.0 * c) / 6.0)
-            q2((6.0 * b + 30.0 * c) / 6.0),
+        , q2((6.0 * b + 30.0 * c) / 6.0)
-            q3((-b - 6.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 < 1.0)
-            if(x < 2.0) return q0 + x * (q1 + x * (q2 + x * q3));
+            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
 {
@@ -274,7 +256,6 @@ namespace agg
     }
 };
 
-
 //---------------------------------------------image_filter_spline36
 struct image_filter_spline36
 {
@@ -293,156 +274,248 @@ namespace agg
     }
 };
 
-
 //----------------------------------------------image_filter_gaussian
 struct image_filter_gaussian
 {
     static double radius() { return 2.0; }
-        static double calc_weight(double x) 
+    static double calc_weight(double x) { return exp(-2.0 * x * x) * sqrt(2.0 / pi); }
-        {
-            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)
+    static double calc_weight(double x) { return (x == 0.0) ? pi / 4.0 : besj(pi * x, 1) / (2.0 * 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) {}
+    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;
+        if (x == 0.0)
+            return 1.0;
         x *= pi;
         return std::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) {}
+    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 == 0.0)
-           if(x > m_radius) return 0.0;
+            return 1.0;
+        if (x > m_radius)
+            return 0.0;
         x *= pi;
         double xr = x / m_radius;
         return (std::sin(x) / x) * (std::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) {}
+    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 == 0.0)
-           if(x > m_radius) return 0.0;
+            return 1.0;
+        if (x > m_radius)
+            return 0.0;
         x *= pi;
         double xr = x / m_radius;
         return (std::sin(x) / x) * (0.42 + 0.5 * std::cos(xr) + 0.08 * std::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){} };
+{
+  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){} };
+{
+  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){} };
+{
+  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){} };
+{
+  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){} };
+{
+  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){} };
+{
+  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){} };
+{
+  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){} };
+{
+  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){} };
+{
+  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){} };
+{
+  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){} };
+{
+  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){} };
+{
+  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){} };
+{
+  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){} };
+{
+  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){} };
+{
+  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){} };
+{
+  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){} };
+{
+  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){} };
+{
+  public:
+    image_filter_blackman256()
+        : image_filter_blackman(8.0)
+    {}
+};
 
-
+} // namespace agg
-}
 
 #endif

deps/agg/include/agg_line_aa_basics.h

@@ -18,14 +18,12 @@
 #include <cstdlib>
 #include "agg_basics.h"
 
-namespace agg
+namespace agg {
-{
 
 // See Implementation agg_line_aa_basics.cpp
 
 //-------------------------------------------------------------------------
-    enum line_subpixel_scale_e
+enum line_subpixel_scale_e {
-    {
     line_subpixel_shift = 8,                          //----line_subpixel_shift
     line_subpixel_scale = 1 << line_subpixel_shift,   //----line_subpixel_scale
     line_subpixel_mask = line_subpixel_scale - 1,     //----line_subpixel_mask
@@ -34,8 +32,7 @@ namespace agg
 };
 
 //-------------------------------------------------------------------------
-    enum line_mr_subpixel_scale_e
+enum line_mr_subpixel_scale_e {
-    {
     line_mr_subpixel_shift = 4,                           //----line_mr_subpixel_shift
     line_mr_subpixel_scale = 1 << line_mr_subpixel_shift, //----line_mr_subpixel_scale
     line_mr_subpixel_mask = line_mr_subpixel_scale - 1    //----line_mr_subpixel_mask
@@ -62,19 +59,13 @@ namespace agg
 //---------------------------------------------------------------line_coord
 struct line_coord
 {
-        AGG_INLINE static int conv(double x)
+    AGG_INLINE static int conv(double x) { return iround(x * line_subpixel_scale); }
-        {
-            return iround(x * line_subpixel_scale);
-        }
 };
 
 //-----------------------------------------------------------line_coord_sat
 struct line_coord_sat
 {
-        AGG_INLINE static int conv(double x)
+    AGG_INLINE static int conv(double x) { return saturation<line_max_coord>::iround(x * line_subpixel_scale); }
-        {
-            return saturation<line_max_coord>::iround(x * line_subpixel_scale);
-        }
 };
 
 //==========================================================line_parameters
@@ -82,18 +73,20 @@ namespace agg
 {
     //---------------------------------------------------------------------
     line_parameters() {}
-        line_parameters(int x1_, int y1_, int x2_, int y2_, int len_) :
+    line_parameters(int x1_, int y1_, int x2_, int y2_, int len_)
-            x1(x1_), y1(y1_), x2(x2_), y2(y2_),
+        : x1(x1_)
-            dx(std::abs(x2_ - x1_)),
+        , y1(y1_)
-            dy(std::abs(y2_ - y1_)),
+        , x2(x2_)
-            sx((x2_ > x1_) ? 1 : -1),
+        , y2(y2_)
-            sy((y2_ > y1_) ? 1 : -1),
+        , dx(std::abs(x2_ - x1_))
-            vertical(dy >= dx),
+        , dy(std::abs(y2_ - y1_))
-            inc(vertical ? sy : sx),
+        , sx((x2_ > x1_) ? 1 : -1)
-            len(len_),
+        , sy((y2_ > y1_) ? 1 : -1)
-            octant((sy & 4) | (sx & 2) | int(vertical))
+        , vertical(dy >= dx)
-        {
+        , inc(vertical ? sy : sx)
-        }
+        , len(len_)
+        , octant((sy & 4) | (sx & 2) | int(vertical))
+    {}
 
     //---------------------------------------------------------------------
     unsigned orthogonal_quadrant() const { return s_orthogonal_quadrant[octant]; }
@@ -146,22 +139,15 @@ namespace agg
     static const int8u s_diagonal_quadrant[8];
 };
 
-
-
 // See Implementation agg_line_aa_basics.cpp
 
 //----------------------------------------------------------------bisectrix
-    void bisectrix(const line_parameters& l1,
+void bisectrix(const line_parameters& l1, const line_parameters& l2, int* x, int* y);
-                   const line_parameters& l2,
-                   int* x, int* y);
-
 
 //-------------------------------------------fix_degenerate_bisectrix_start
-    void inline fix_degenerate_bisectrix_start(const line_parameters& lp,
+void inline fix_degenerate_bisectrix_start(const line_parameters& lp, int* x, int* y)
-                                               int* x, int* y)
 {
-        int d = iround((double(*x - lp.x2) * double(lp.y2 - lp.y1) -
+    int d = iround((double(*x - lp.x2) * double(lp.y2 - lp.y1) - double(*y - lp.y2) * double(lp.x2 - lp.x1)) / lp.len);
-                        double(*y - lp.y2) * double(lp.x2 - lp.x1)) / lp.len);
     if (d < line_subpixel_scale / 2)
     {
         *x = lp.x1 + (lp.y2 - lp.y1);
@@ -169,13 +155,10 @@ namespace agg
     }
 }
 
-
 //---------------------------------------------fix_degenerate_bisectrix_end
-    void inline fix_degenerate_bisectrix_end(const line_parameters& lp,
+void inline fix_degenerate_bisectrix_end(const line_parameters& lp, int* x, int* y)
-                                             int* x, int* y)
 {
-        int d = iround((double(*x - lp.x2) * double(lp.y2 - lp.y1) -
+    int d = iround((double(*x - lp.x2) * double(lp.y2 - lp.y1) - double(*y - lp.y2) * double(lp.x2 - lp.x1)) / lp.len);
-                        double(*y - lp.y2) * double(lp.x2 - lp.x1)) / lp.len);
     if (d < line_subpixel_scale / 2)
     {
         *x = lp.x2 + (lp.y2 - lp.y1);
@@ -183,7 +166,6 @@ namespace agg
     }
 }
 
-
+} // namespace agg
-}
 
 #endif

deps/agg/include/agg_math.h

@@ -22,8 +22,7 @@
 #include <cmath>
 #include "agg_basics.h"
 
-namespace agg
+namespace agg {
-{
 
 //------------------------------------------------------vertex_dist_epsilon
 // Coinciding points maximal distance (Epsilon)
@@ -34,18 +33,13 @@ namespace agg
 const double intersection_epsilon = 1.0e-30;
 
 //------------------------------------------------------------cross_product
-    AGG_INLINE double cross_product(double x1, double y1, 
+AGG_INLINE double cross_product(double x1, double y1, double x2, double y2, double x, double y)
-                                    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, 
+AGG_INLINE bool point_in_triangle(double x1, double y1, double x2, double y2, double x3, double y3, double x, double y)
-                                      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;
@@ -70,9 +64,7 @@ namespace agg
 }
 
 //------------------------------------------------calc_line_point_distance
-    AGG_INLINE double calc_line_point_distance(double x1, double y1, 
+AGG_INLINE double calc_line_point_distance(double x1, double y1, double x2, double y2, double x, double y)
-                                               double x2, double y2, 
-                                               double x,  double y)
 {
     double dx = x2 - x1;
     double dy = y2 - y1;
@@ -85,9 +77,7 @@ namespace agg
 }
 
 //-------------------------------------------------------calc_line_point_u
-    AGG_INLINE double calc_segment_point_u(double x1, double y1, 
+AGG_INLINE double calc_segment_point_u(double x1, double y1, double x2, double y2, double x, double y)
-                                           double x2, double y2, 
-                                           double x,  double y)
 {
     double dx = x2 - x1;
     double dy = y2 - y1;
@@ -104,17 +94,14 @@ namespace agg
 }
 
 //---------------------------------------------calc_line_point_sq_distance
-    AGG_INLINE double calc_segment_point_sq_distance(double x1, double y1, 
+AGG_INLINE double
-                                                     double x2, double y2, 
+  calc_segment_point_sq_distance(double x1, double y1, double x2, double y2, double x, double y, double u)
-                                                     double x,  double y,
-                                                     double u)
 {
     if (u <= 0)
     {
         return calc_sq_distance(x, y, x1, y1);
     }
-        else 
+    else if (u >= 1)
-        if(u >= 1)
     {
         return calc_sq_distance(x, y, x2, y2);
     }
@@ -122,24 +109,27 @@ namespace agg
 }
 
 //---------------------------------------------calc_line_point_sq_distance
-    AGG_INLINE double calc_segment_point_sq_distance(double x1, double y1, 
+AGG_INLINE double calc_segment_point_sq_distance(double x1, double y1, double x2, double y2, double x, double y)
-                                                     double x2, double y2, 
-                                                     double x,  double y)
 {
-        return 
+    return calc_segment_point_sq_distance(x1, y1, x2, y2, x, y, calc_segment_point_u(x1, y1, x2, y2, x, y));
-            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,
+AGG_INLINE bool calc_intersection(double ax,
-                                      double cx, double cy, double dx, double dy,
+                                  double ay,
-                                      double* x, double* y)
+                                  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(std::fabs(den) < intersection_epsilon) return false;
+    if (std::fabs(den) < intersection_epsilon)
+        return false;
     double r = num / den;
     *x = ax + r * (bx - ax);
     *y = ay + r * (by - ay);
@@ -147,8 +137,8 @@ namespace agg
 }
 
 //-----------------------------------------------------intersection_exists
-    AGG_INLINE bool intersection_exists(double x1, double y1, double x2, double y2,
+AGG_INLINE bool
-                                        double x3, double y3, double x4, double y4)
+  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
@@ -156,10 +146,8 @@ namespace agg
     double dy1 = y2 - y1;
     double dx2 = x4 - x3;
     double dy2 = y4 - y3;
-        return ((x3 - x2) * dy1 - (y3 - y2) * dx1 < 0.0) != 
+    return ((x3 - x2) * dy1 - (y3 - y2) * dx1 < 0.0) != ((x4 - x2) * dy1 - (y4 - 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);
-               ((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.
@@ -174,10 +162,7 @@ namespace agg
 }
 
 //--------------------------------------------------------calc_orthogonal
-    AGG_INLINE void calc_orthogonal(double thickness,
+AGG_INLINE void calc_orthogonal(double thickness, double x1, double y1, double x2, double y2, double* x, double* y)
-                                    double x1, double y1,
-                                    double x2, double y2,
-                                    double* x, double* y)
 {
     double dx = x2 - x1;
     double dy = y2 - y1;
@@ -187,11 +172,8 @@ namespace agg
 }
 
 //--------------------------------------------------------dilate_triangle
-    AGG_INLINE void dilate_triangle(double x1, double y1,
+AGG_INLINE void
-                                    double x2, double y2,
+  dilate_triangle(double x1, double y1, double x2, double y2, double x3, double y3, double* x, double* y, double d)
-                                    double x3, double y3,
-                                    double *x, double* y,
-                                    double d)
 {
     double dx1 = 0.0;
     double dy1 = 0.0;
@@ -210,24 +192,29 @@ namespace agg
         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++ = x1 + dx1;
-        *x++ = x2 + dx1;  *y++ = y2 + dy1;
+    *y++ = y1 + dy1;
-        *x++ = x2 + dx2;  *y++ = y2 + dy2;
+    *x++ = x2 + dx1;
-        *x++ = x3 + dx2;  *y++ = y3 + dy2;
+    *y++ = y2 + dy1;
-        *x++ = x3 + dx3;  *y++ = y3 + dy3;
+    *x++ = x2 + dx2;
-        *x++ = x1 + dx3;  *y++ = y1 + dy3;
+    *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,
+AGG_INLINE double calc_triangle_area(double x1, double y1, double x2, double y2, double x3, double y3)
-                                         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)
+template<class Storage>
+double calc_polygon_area(const Storage& st)
 {
     unsigned i;
     double sum = 0.0;
@@ -251,7 +238,6 @@ namespace agg
 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)
@@ -265,8 +251,7 @@ namespace agg
     // 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
+    __asm {
-        {
             mov ebx, val
             mov edx, 11
             bsr ecx, ebx
@@ -337,9 +322,6 @@ namespace agg
 #pragma warning(pop)
 #endif
 
-
-
-
 //--------------------------------------------------------------------besj
 // Function BESJ calculates Bessel function of first kind of order n
 // Arguments:
@@ -372,7 +354,8 @@ namespace agg
     double b = 0;
     if (std::fabs(x) <= d)
     {
-            if(n != 0) return 0;
+        if (n != 0)
+            return 0;
         return 1;
     }
     double b1 = 0; // b1 is the value from the previous iteration
@@ -431,7 +414,6 @@ namespace agg
     }
 }
 
-}
+} // namespace agg
-
 
 #endif

deps/agg/include/agg_math_stroke.h

@@ -23,38 +23,19 @@
 #include "agg_math.h"
 #include "agg_vertex_sequence.h"
 
-namespace agg
+namespace agg {
-{
 //-------------------------------------------------------------line_cap_e
-    enum line_cap_e
+enum line_cap_e { butt_cap, square_cap, round_cap };
-    {
-        butt_cap,
-        square_cap,
-        round_cap
-    };
 
 //------------------------------------------------------------line_join_e
-    enum line_join_e
+enum line_join_e { miter_join = 0, miter_join_revert = 1, round_join = 2, bevel_join = 3, miter_join_round = 4 };
-    {
-        miter_join         = 0,
-        miter_join_revert  = 1,
-        round_join         = 2,
-        bevel_join         = 3,
-        miter_join_round   = 4
-    };
-
 
 //-----------------------------------------------------------inner_join_e
-    enum inner_join_e
+enum inner_join_e { inner_bevel, inner_miter, inner_jag, inner_round };
-    {
-        inner_bevel,
-        inner_miter,
-        inner_jag,
-        inner_round
-    };
 
 //------------------------------------------------------------math_stroke
-    template<class VertexConsumer> class math_stroke
+template<class VertexConsumer>
+class math_stroke
 {
   public:
     typedef typename VertexConsumer::value_type coord_type;
@@ -80,10 +61,7 @@ namespace agg
     double inner_miter_limit() const { return m_inner_miter_limit; }
     double approximation_scale() const { return m_approx_scale; }
 
-        void calc_cap(VertexConsumer& vc,
+    void calc_cap(VertexConsumer& vc, const vertex_dist& v0, const vertex_dist& v1, double len);
-                      const vertex_dist& v0,
-                      const vertex_dist& v1,
-                      double len);
 
     void calc_join(VertexConsumer& vc,
                    const vertex_dist& v0,
@@ -93,22 +71,18 @@ namespace agg
                    double len2);
 
   private:
-        AGG_INLINE void add_vertex(VertexConsumer& vc, double x, double y)
+    AGG_INLINE void add_vertex(VertexConsumer& vc, double x, double y) { vc.add(coord_type(x, y)); }
-        {
-            vc.add(coord_type(x, y));
-        }
 
-        void calc_arc(VertexConsumer& vc,
+    void calc_arc(VertexConsumer& vc, double x, double y, double dx1, double dy1, double dx2, double dy2);
-                      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 dx1,
-                        double dx2, double dy2,
+                    double dy1,
+                    double dx2,
+                    double dy2,
                     line_join_e lj,
                     double mlimit,
                     double dbevel);
@@ -126,22 +100,23 @@ namespace agg
 };
 
 //-----------------------------------------------------------------------
-    template<class VC> math_stroke<VC>::math_stroke() :
+template<class VC>
-        m_width(0.5),
+math_stroke<VC>::math_stroke()
-        m_width_abs(0.5),
+    : m_width(0.5)
-        m_width_eps(0.5/1024.0),
+    , m_width_abs(0.5)
-        m_width_sign(1),
+    , m_width_eps(0.5 / 1024.0)
-        m_miter_limit(4.0),
+    , m_width_sign(1)
-        m_inner_miter_limit(1.01),
+    , m_miter_limit(4.0)
-        m_approx_scale(1.0),
+    , m_inner_miter_limit(1.01)
-        m_line_cap(butt_cap),
+    , m_approx_scale(1.0)
-        m_line_join(miter_join),
+    , m_line_cap(butt_cap)
-        m_inner_join(inner_miter)
+    , m_line_join(miter_join)
-    {
+    , m_inner_join(inner_miter)
-    }
+{}
 
 //-----------------------------------------------------------------------
-    template<class VC> void math_stroke<VC>::width(double w)
+template<class VC>
+void math_stroke<VC>::width(double w)
 {
     m_width = w * 0.5;
     if (m_width < 0)
@@ -158,17 +133,15 @@ namespace agg
 }
 
 //-----------------------------------------------------------------------
-    template<class VC> void math_stroke<VC>::miter_limit_theta(double t)
+template<class VC>
+void math_stroke<VC>::miter_limit_theta(double t)
 {
     m_miter_limit = 1.0 / std::sin(t * 0.5);
 }
 
 //-----------------------------------------------------------------------
 template<class VC>
-    void math_stroke<VC>::calc_arc(VC& vc,
+void math_stroke<VC>::calc_arc(VC& vc, double x, double y, double dx1, double dy1, double dx2, double dy2)
-                                   double x,   double y,
-                                   double dx1, double dy1,
-                                   double dx2, double dy2)
 {
     double a1 = std::atan2(dy1 * m_width_sign, dx1 * m_width_sign);
     double a2 = std::atan2(dy2 * m_width_sign, dx2 * m_width_sign);
@@ -180,7 +153,8 @@ namespace agg
     add_vertex(vc, x + dx1, y + dy1);
     if (m_width_sign > 0)
     {
-            if(a1 > a2) a2 += 2 * pi;
+        if (a1 > a2)
+            a2 += 2 * pi;
         n = int((a2 - a1) / da);
         da = (a2 - a1) / (n + 1);
         a1 += da;
@@ -192,7 +166,8 @@ namespace agg
     }
     else
     {
-            if(a1 < a2) a2 -= 2 * pi;
+        if (a1 < a2)
+            a2 -= 2 * pi;
         n = int((a1 - a2) / da);
         da = (a1 - a2) / (n + 1);
         a1 -= da;
@@ -211,8 +186,10 @@ namespace agg
                                  const vertex_dist& v0,
                                  const vertex_dist& v1,
                                  const vertex_dist& v2,
-                                     double dx1, double dy1,
+                                 double dx1,
-                                     double dx2, double dy2,
+                                 double dy1,
+                                 double dx2,
+                                 double dy2,
                                  line_join_e lj,
                                  double mlimit,
                                  double dbevel)
@@ -224,11 +201,16 @@ namespace agg
     bool miter_limit_exceeded = true; // Assume the worst
     bool intersection_failed = true;  // Assume the worst
 
-        if(calc_intersection(v0.x + dx1, v0.y - dy1,
+    if (calc_intersection(v0.x + dx1,
-                             v1.x + dx1, v1.y - dy1,
+                          v0.y - dy1,
-                             v1.x + dx2, v1.y - dy2,
+                          v1.x + dx1,
-                             v2.x + dx2, v2.y - dy2,
+                          v1.y - dy1,
-                             &xi, &yi))
+                          v1.x + dx2,
+                          v1.y - dy2,
+                          v2.x + dx2,
+                          v2.y - dy2,
+                          &xi,
+                          &yi))
     {
         // Calculation of the intersection succeeded
         //---------------------
@@ -290,10 +272,8 @@ namespace agg
                 if (intersection_failed)
                 {
                     mlimit *= m_width_sign;
-                    add_vertex(vc, v1.x + dx1 + dy1 * mlimit,
+                    add_vertex(vc, v1.x + dx1 + dy1 * mlimit, v1.y - dy1 + dx1 * mlimit);
-                                   v1.y - dy1 + dx1 * mlimit);
+                    add_vertex(vc, v1.x + dx2 - dy2 * mlimit, v1.y - dy2 - dx2 * mlimit);
-                    add_vertex(vc, v1.x + dx2 - dy2 * mlimit,
-                                   v1.y - dy2 - dx2 * mlimit);
                 }
                 else
                 {
@@ -302,10 +282,8 @@ namespace agg
                     double x2 = v1.x + dx2;
                     double y2 = v1.y - dy2;
                     di = (lim - dbevel) / (di - dbevel);
-                    add_vertex(vc, x1 + (xi - x1) * di,
+                    add_vertex(vc, x1 + (xi - x1) * di, y1 + (yi - y1) * di);
-                                   y1 + (yi - y1) * di);
+                    add_vertex(vc, x2 + (xi - x2) * di, y2 + (yi - y2) * di);
-                    add_vertex(vc, x2 + (xi - x2) * di,
-                                   y2 + (yi - y2) * di);
                 }
                 break;
         }
@@ -314,10 +292,7 @@ namespace agg
 
 //--------------------------------------------------------stroke_calc_cap
 template<class VC>
-    void math_stroke<VC>::calc_cap(VC& vc,
+void math_stroke<VC>::calc_cap(VC& vc, const vertex_dist& v0, const vertex_dist& v1, double len)
-                                   const vertex_dist& v0,
-                                   const vertex_dist& v1,
-                                   double len)
 {
     vc.remove_all();
 
@@ -354,8 +329,7 @@ namespace agg
             a1 += da;
             for (i = 0; i < n; i++)
             {
-                    add_vertex(vc, v0.x + std::cos(a1) * m_width,
+                add_vertex(vc, v0.x + std::cos(a1) * m_width, v0.y + std::sin(a1) * m_width);
-                                   v0.y + std::sin(a1) * m_width);
                 a1 += da;
             }
         }
@@ -365,8 +339,7 @@ namespace agg
             a1 -= da;
             for (i = 0; i < n; i++)
             {
-                    add_vertex(vc, v0.x + std::cos(a1) * m_width,
+                add_vertex(vc, v0.x + std::cos(a1) * m_width, v0.y + std::sin(a1) * m_width);
-                                   v0.y + std::sin(a1) * m_width);
                 a1 -= da;
             }
         }
@@ -409,10 +382,7 @@ namespace agg
                 break;
 
             case inner_miter:
-                calc_miter(vc,
+                calc_miter(vc, v0, v1, v2, dx1, dy1, dx2, dy2, miter_join_revert, limit, 0);
-                           v0, v1, v2, dx1, dy1, dx2, dy2,
-                           miter_join_revert,
-                           limit, 0);
                 break;
 
             case inner_jag:
@@ -420,10 +390,7 @@ namespace agg
                 cp = (dx1 - dx2) * (dx1 - dx2) + (dy1 - dy2) * (dy1 - dy2);
                 if (cp < len1 * len1 && cp < len2 * len2)
                 {
-                    calc_miter(vc,
+                    calc_miter(vc, v0, v1, v2, dx1, dy1, dx2, dy2, miter_join_revert, limit, 0);
-                               v0, v1, v2, dx1, dy1, dx2, dy2,
-                               miter_join_revert,
-                               limit, 0);
                 }
                 else
                 {
@@ -478,11 +445,16 @@ namespace agg
             //-------------------
             if (m_approx_scale * (m_width_abs - dbevel) < m_width_eps)
             {
-                    if(calc_intersection(v0.x + dx1, v0.y - dy1,
+                if (calc_intersection(v0.x + dx1,
-                                         v1.x + dx1, v1.y - dy1,
+                                      v0.y - dy1,
-                                         v1.x + dx2, v1.y - dy2,
+                                      v1.x + dx1,
-                                         v2.x + dx2, v2.y - dy2,
+                                      v1.y - dy1,
-                                         &dx, &dy))
+                                      v1.x + dx2,
+                                      v1.y - dy2,
+                                      v2.x + dx2,
+                                      v2.y - dy2,
+                                      &dx,
+                                      &dy))
                 {
                     add_vertex(vc, dx, dy);
                 }
@@ -499,11 +471,7 @@ namespace agg
             case miter_join:
             case miter_join_revert:
             case miter_join_round:
-                calc_miter(vc,
+                calc_miter(vc, v0, v1, v2, dx1, dy1, dx2, dy2, m_line_join, m_miter_limit, dbevel);
-                           v0, v1, v2, dx1, dy1, dx2, dy2,
-                           m_line_join,
-                           m_miter_limit,
-                           dbevel);
                 break;
 
             case round_join:
@@ -518,9 +486,6 @@ namespace agg
     }
 }
 
-
+} // namespace agg
-
-
-}
 
 #endif

deps/agg/include/agg_path_length.h

@@ -17,8 +17,7 @@
 
 #include "agg_math.h"
 
-namespace agg
+namespace agg {
-{
 template<class VertexSource>
 double path_length(VertexSource& vs, unsigned path_id = 0)
 {
@@ -60,6 +59,6 @@ namespace agg
     }
     return len;
 }
-}
+} // namespace agg
 
 #endif

deps/agg/include/agg_path_storage.h

@@ -22,9 +22,7 @@
 #include "agg_array.h"
 #include "agg_bezier_arc.h"
 
-namespace agg
+namespace agg {
-{
-
 
 //----------------------------------------------------vertex_block_storage
 template<class T, unsigned BlockShift = 8, unsigned BlockPool = 256>
@@ -32,8 +30,7 @@ namespace agg
 {
   public:
     // Allocation parameters
-        enum block_scale_e
+    enum block_scale_e {
-        {
         block_shift = BlockShift,
         block_size = 1 << block_shift,
         block_mask = block_size - 1,
@@ -80,7 +77,6 @@ namespace agg
     int8u** m_cmd_blocks;
 };
 
-
 //------------------------------------------------------------------------
 template<class T, unsigned S, unsigned P>
 void vertex_block_storage<T, S, P>::free_all()
@@ -90,10 +86,7 @@ namespace agg
         T** coord_blk = m_coord_blocks + m_total_blocks - 1;
         while (m_total_blocks--)
         {
-                pod_allocator<T>::deallocate(
+            pod_allocator<T>::deallocate(*coord_blk, block_size * 2 + block_size / (sizeof(T) / sizeof(unsigned char)));
-                    *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);
@@ -114,31 +107,29 @@ namespace agg
 
 //------------------------------------------------------------------------
 template<class T, unsigned S, unsigned P>
-    vertex_block_storage<T,S,P>::vertex_block_storage() :
+vertex_block_storage<T, S, P>::vertex_block_storage()
-        m_total_vertices(0),
+    : m_total_vertices(0)
-        m_total_blocks(0),
+    , m_total_blocks(0)
-        m_max_blocks(0),
+    , m_max_blocks(0)
-        m_coord_blocks(0),
+    , m_coord_blocks(0)
-        m_cmd_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) :
+vertex_block_storage<T, S, P>::vertex_block_storage(const vertex_block_storage<T, S, P>& v)
-        m_total_vertices(0),
+    : m_total_vertices(0)
-        m_total_blocks(0),
+    , m_total_blocks(0)
-        m_max_blocks(0),
+    , m_max_blocks(0)
-        m_coord_blocks(0),
+    , m_coord_blocks(0)
-        m_cmd_blocks(0)
+    , m_cmd_blocks(0)
 {
     *this = v;
 }
 
 //------------------------------------------------------------------------
 template<class T, unsigned S, unsigned P>
-    const vertex_block_storage<T,S,P>& 
+const vertex_block_storage<T, S, P>& vertex_block_storage<T, S, P>::operator=(const vertex_block_storage<T, S, P>& v)
-    vertex_block_storage<T,S,P>::operator = (const vertex_block_storage<T,S,P>& v)
 {
     remove_all();
     unsigned i;
@@ -160,8 +151,7 @@ namespace agg
 
 //------------------------------------------------------------------------
 template<class T, unsigned S, unsigned P>
-    inline void vertex_block_storage<T,S,P>::add_vertex(double x, double y, 
+inline void vertex_block_storage<T, S, P>::add_vertex(double x, double y, unsigned cmd)
-                                                        unsigned cmd)
 {
     T* coord_ptr = 0;
     *storage_ptrs(&coord_ptr) = (int8u)cmd;
@@ -172,8 +162,7 @@ namespace agg
 
 //------------------------------------------------------------------------
 template<class T, unsigned S, unsigned P>
-    inline void vertex_block_storage<T,S,P>::modify_vertex(unsigned idx, 
+inline void vertex_block_storage<T, S, P>::modify_vertex(unsigned idx, double x, double y)
-                                                           double x, double y)
 {
     T* pv = m_coord_blocks[idx >> block_shift] + ((idx & block_mask) << 1);
     pv[0] = T(x);
@@ -182,9 +171,7 @@ namespace agg
 
 //------------------------------------------------------------------------
 template<class T, unsigned S, unsigned P>
-    inline void vertex_block_storage<T,S,P>::modify_vertex(unsigned idx, 
+inline void vertex_block_storage<T, S, P>::modify_vertex(unsigned idx, double x, double y, unsigned cmd)
-                                                           double x, double y, 
-                                                           unsigned cmd)
 {
     unsigned block = idx >> block_shift;
     unsigned offset = idx & block_mask;
@@ -196,8 +183,7 @@ namespace agg
 
 //------------------------------------------------------------------------
 template<class T, unsigned S, unsigned P>
-    inline void vertex_block_storage<T,S,P>::modify_command(unsigned idx, 
+inline void vertex_block_storage<T, S, P>::modify_command(unsigned idx, unsigned cmd)
-                                                            unsigned cmd)
 {
     m_cmd_blocks[idx >> block_shift][idx & block_mask] = (int8u)cmd;
 }
@@ -213,8 +199,12 @@ namespace agg
     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[0];
-        val = pv1[1]; pv1[1] = pv2[1]; pv2[1] = val;
+    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;
@@ -224,7 +214,8 @@ namespace agg
 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);
+    if (m_total_vertices)
+        return command(m_total_vertices - 1);
     return path_cmd_stop;
 }
 
@@ -232,7 +223,8 @@ namespace agg
 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);
+    if (m_total_vertices)
+        return vertex(m_total_vertices - 1, x, y);
     return path_cmd_stop;
 }
 
@@ -240,7 +232,8 @@ namespace agg
 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);
+    if (m_total_vertices > 1)
+        return vertex(m_total_vertices - 2, x, y);
     return path_cmd_stop;
 }
 
@@ -277,8 +270,7 @@ namespace agg
 
 //------------------------------------------------------------------------
 template<class T, unsigned S, unsigned P>
-    inline unsigned vertex_block_storage<T,S,P>::vertex(unsigned idx, 
+inline unsigned vertex_block_storage<T, S, P>::vertex(unsigned idx, double* x, double* y) const
-                                                        double* x, double* y) const
 {
     unsigned nb = idx >> block_shift;
     const T* pv = m_coord_blocks[nb] + ((idx & block_mask) << 1);
@@ -300,21 +292,15 @@ namespace agg
 {
     if (nb >= m_max_blocks)
     {
-            T** new_coords = 
+        T** new_coords = pod_allocator<T*>::allocate((m_max_blocks + block_pool) * 2);
-                pod_allocator<T*>::allocate((m_max_blocks + block_pool) * 2);
 
-            unsigned char** new_cmds = 
+        unsigned char** new_cmds = (unsigned char**)(new_coords + m_max_blocks + block_pool);
-                (unsigned char**)(new_coords + m_max_blocks + block_pool);
 
         if (m_coord_blocks)
         {
-                memcpy(new_coords, 
+            memcpy(new_coords, m_coord_blocks, m_max_blocks * sizeof(T*));
-                       m_coord_blocks, 
-                       m_max_blocks * sizeof(T*));
 
-                memcpy(new_cmds, 
+            memcpy(new_cmds, m_cmd_blocks, m_max_blocks * sizeof(unsigned char*));
-                       m_cmd_blocks, 
-                       m_max_blocks * sizeof(unsigned char*));
 
             pod_allocator<T*>::deallocate(m_coord_blocks, m_max_blocks * 2);
         }
@@ -322,12 +308,9 @@ namespace agg
         m_cmd_blocks = new_cmds;
         m_max_blocks += block_pool;
     }
-        m_coord_blocks[nb] = 
+    m_coord_blocks[nb] = pod_allocator<T>::allocate(block_size * 2 + block_size / (sizeof(T) / sizeof(unsigned char)));
-            pod_allocator<T>::allocate(block_size * 2 + 
-                   block_size / (sizeof(T) / sizeof(unsigned char)));
 
-        m_cmd_blocks[nb]  = 
+    m_cmd_blocks[nb] = (unsigned char*)(m_coord_blocks[nb] + block_size * 2);
-            (unsigned char*)(m_coord_blocks[nb] + block_size * 2);
 
     m_total_blocks++;
 }
@@ -345,29 +328,27 @@ namespace agg
     return m_cmd_blocks[nb] + (m_total_vertices & block_mask);
 }
 
-
-
-
 //-----------------------------------------------------poly_plain_adaptor
-    template<class T> class poly_plain_adaptor
+template<class T>
+class poly_plain_adaptor
 {
   public:
     typedef T value_type;
 
-        poly_plain_adaptor() : 
+    poly_plain_adaptor()
-            m_data(0), 
+        : m_data(0)
-            m_ptr(0),
+        , m_ptr(0)
-            m_end(0),
+        , m_end(0)
-            m_closed(false),
+        , m_closed(false)
-            m_stop(false)
+        , m_stop(false)
     {}
 
-        poly_plain_adaptor(const T* data, unsigned num_points, bool closed) :
+    poly_plain_adaptor(const T* data, unsigned num_points, bool closed)
-            m_data(data), 
+        : m_data(data)
-            m_ptr(data),
+        , m_ptr(data)
-            m_end(data + num_points * 2),
+        , m_end(data + num_points * 2)
-            m_closed(closed),
+        , m_closed(closed)
-            m_stop(false)
+        , m_stop(false)
     {}
 
     void init(const T* data, unsigned num_points, bool closed)
@@ -411,28 +392,25 @@ namespace agg
     bool m_stop;
 };
 
-
-
-
-
 //-------------------------------------------------poly_container_adaptor
-    template<class Container> class poly_container_adaptor
+template<class Container>
+class poly_container_adaptor
 {
   public:
     typedef typename Container::value_type vertex_type;
 
-        poly_container_adaptor() : 
+    poly_container_adaptor()
-            m_container(0), 
+        : m_container(0)
-            m_index(0),
+        , m_index(0)
-            m_closed(false),
+        , m_closed(false)
-            m_stop(false)
+        , m_stop(false)
     {}
 
-        poly_container_adaptor(const Container& data, bool closed) :
+    poly_container_adaptor(const Container& data, bool closed)
-            m_container(&data), 
+        : m_container(&data)
-            m_index(0),
+        , m_index(0)
-            m_closed(closed),
+        , m_closed(closed)
-            m_stop(false)
+        , m_stop(false)
     {}
 
     void init(const Container& data, bool closed)
@@ -475,26 +453,25 @@ namespace agg
     bool m_stop;
 };
 
-
-
 //-----------------------------------------poly_container_reverse_adaptor
-    template<class Container> class poly_container_reverse_adaptor
+template<class Container>
+class poly_container_reverse_adaptor
 {
   public:
     typedef typename Container::value_type vertex_type;
 
-        poly_container_reverse_adaptor() : 
+    poly_container_reverse_adaptor()
-            m_container(0), 
+        : m_container(0)
-            m_index(-1),
+        , m_index(-1)
-            m_closed(false),
+        , m_closed(false)
-            m_stop(false)
+        , m_stop(false)
     {}
 
-        poly_container_reverse_adaptor(const Container& data, bool closed) :
+    poly_container_reverse_adaptor(const Container& data, bool closed)
-            m_container(&data), 
+        : m_container(&data)
-            m_index(-1),
+        , m_index(-1)
-            m_closed(closed),
+        , m_closed(closed)
-            m_stop(false)
+        , m_stop(false)
     {}
 
     void init(const Container& data, bool closed)
@@ -537,19 +514,17 @@ namespace agg
     bool m_stop;
 };
 
-
-
-
-
 //--------------------------------------------------------line_adaptor
 class line_adaptor
 {
   public:
     typedef double value_type;
 
-        line_adaptor() : m_line(m_coord, 2, false) {}
+    line_adaptor()
-        line_adaptor(double x1, double y1, double x2, double y2) :
+        : m_line(m_coord, 2, false)
-            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;
@@ -566,33 +541,15 @@ namespace agg
         m_line.rewind(0);
     }
 
-        void rewind(unsigned)
+    void rewind(unsigned) { m_line.rewind(0); }
-        {
-            m_line.rewind(0);
-        }
 
-        unsigned vertex(double* x, double* y)
+    unsigned vertex(double* x, double* y) { return m_line.vertex(x, 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"
@@ -605,16 +562,28 @@ namespace agg
 //
 // See also: vertex_source concept
 //------------------------------------------------------------------------
-    template<class VertexContainer> class path_base
+template<class VertexContainer>
+class path_base
 {
   public:
     typedef VertexContainer container_type;
     typedef path_base<VertexContainer> self_type;
 
     //--------------------------------------------------------------------
-        path_base() : m_vertices(), m_iterator(0) {}
+    path_base()
-        void remove_all() { m_vertices.remove_all(); m_iterator = 0; }
+        : m_vertices()
-        void free_all()   { m_vertices.free_all();   m_iterator = 0; }
+        , 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
     //--------------------------------------------------------------------
@@ -632,42 +601,25 @@ namespace agg
     void vline_to(double y);
     void vline_rel(double dy);
 
-        void arc_to(double rx, double ry,
+    void arc_to(double rx, double ry, double angle, bool large_arc_flag, bool sweep_flag, double x, double y);
-                    double angle,
-                    bool large_arc_flag,
-                    bool sweep_flag,
-                    double x, double y);
 
-        void arc_rel(double rx, double ry,
+    void arc_rel(double rx, double ry, double angle, bool large_arc_flag, bool sweep_flag, double dx, double dy);
-                     double angle,
-                     bool large_arc_flag,
-                     bool sweep_flag,
-                     double dx, double dy);
 
-        void curve3(double x_ctrl, double y_ctrl, 
+    void curve3(double x_ctrl, double y_ctrl, double x_to, double y_to);
-                    double x_to,   double y_to);
 
-        void curve3_rel(double dx_ctrl, double dy_ctrl, 
+    void curve3_rel(double dx_ctrl, double dy_ctrl, double dx_to, double dy_to);
-                        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, 
+    void curve4(double x_ctrl1, double y_ctrl1, double x_ctrl2, double y_ctrl2, double x_to, double y_to);
-                    double x_ctrl2, double y_ctrl2, 
-                    double x_to,    double y_to);
 
-        void curve4_rel(double dx_ctrl1, double dy_ctrl1, 
+    void curve4_rel(double dx_ctrl1, double dy_ctrl1, double dx_ctrl2, double dy_ctrl2, double dx_to, double dy_to);
-                        double dx_ctrl2, double dy_ctrl2, 
-                        double dx_to,    double dy_to);
 
-        void curve4(double x_ctrl2, double y_ctrl2, 
+    void curve4(double x_ctrl2, double y_ctrl2, double x_to, double y_to);
-                    double x_to,    double y_to);
-
-        void curve4_rel(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);
@@ -750,7 +702,8 @@ namespace agg
                 {
                     if (calc_distance(x, y, x0, y0) > vertex_dist_epsilon)
                     {
-                            if(is_move_to(cmd)) cmd = path_cmd_line_to;
+                        if (is_move_to(cmd))
+                            cmd = path_cmd_line_to;
                         m_vertices.add_vertex(x, y, cmd);
                     }
                 }
@@ -762,25 +715,23 @@ namespace agg
                     }
                     else
                     {
-                            if(is_move_to(cmd)) cmd = path_cmd_line_to;
+                        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) ? 
+                m_vertices.add_vertex(x, y, is_move_to(cmd) ? unsigned(path_cmd_line_to) : cmd);
-                                                    unsigned(path_cmd_line_to) : 
-                                                    cmd);
             }
         }
     }
 
     // Concatenate polygon/polyline.
     //--------------------------------------------------------------------
-        template<class T> void concat_poly(const T* data, 
+    template<class T>
-                                           unsigned num_points,
+    void concat_poly(const T* data, unsigned num_points, bool closed)
-                                           bool closed)
     {
         poly_plain_adaptor<T> poly(data, num_points, closed);
         concat_path(poly);
@@ -788,9 +739,8 @@ namespace agg
 
     // Join polygon/polyline continuously.
     //--------------------------------------------------------------------
-        template<class T> void join_poly(const T* data, 
+    template<class T>
-                                         unsigned num_points,
+    void join_poly(const T* data, unsigned num_points, bool closed)
-                                         bool closed)
     {
         poly_plain_adaptor<T> poly(data, num_points, closed);
         join_path(poly);
@@ -809,7 +759,8 @@ namespace agg
         {
             double x, y;
             unsigned cmd = m_vertices.vertex(path_id, &x, &y);
-                if(is_stop(cmd)) break;
+            if (is_stop(cmd))
+                break;
             if (is_vertex(cmd))
             {
                 trans.transform(&x, &y);
@@ -835,8 +786,6 @@ namespace agg
         }
     }
 
-
-
   private:
     unsigned perceive_polygon_orientation(unsigned start, unsigned end);
     void invert_polygon(unsigned start, unsigned end);
@@ -856,7 +805,6 @@ namespace agg
     return m_vertices.total_vertices();
 }
 
-
 //------------------------------------------------------------------------
 template<class VC>
 inline void path_base<VC>::rel_to_abs(double* x, double* y) const
@@ -870,8 +818,7 @@ namespace agg
             *x += x2;
             *y += y2;
         }
-            else if (!is_stop(m_vertices.last_command()) && 
+        else if (!is_stop(m_vertices.last_command()) && is_vertex(m_vertices.prev_vertex(&x2, &y2)))
-                     is_vertex(m_vertices.prev_vertex(&x2, &y2)))
         {
             *x += x2;
             *y += y2;
@@ -943,11 +890,7 @@ namespace agg
 
 //------------------------------------------------------------------------
 template<class VC>
-    void path_base<VC>::arc_to(double rx, double ry,
+void path_base<VC>::arc_to(double rx, double ry, double angle, bool large_arc_flag, bool sweep_flag, double x, double y)
-                               double angle,
-                               bool large_arc_flag,
-                               bool sweep_flag,
-                               double x, double y)
 {
     if (m_vertices.total_vertices() && is_vertex(m_vertices.last_command()))
     {
@@ -991,11 +934,13 @@ namespace agg
 
 //------------------------------------------------------------------------
 template<class VC>
-    void path_base<VC>::arc_rel(double rx, double ry,
+void path_base<VC>::arc_rel(double rx,
+                            double ry,
                             double angle,
                             bool large_arc_flag,
                             bool sweep_flag,
-                                double dx, double dy)
+                            double dx,
+                            double dy)
 {
     rel_to_abs(&dx, &dy);
     arc_to(rx, ry, angle, large_arc_flag, sweep_flag, dx, dy);
@@ -1003,8 +948,7 @@ namespace agg
 
 //------------------------------------------------------------------------
 template<class VC>
-    void path_base<VC>::curve3(double x_ctrl, double y_ctrl, 
+void path_base<VC>::curve3(double x_ctrl, double y_ctrl, double x_to, double y_to)
-                               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);
@@ -1012,8 +956,7 @@ namespace agg
 
 //------------------------------------------------------------------------
 template<class VC>
-    void path_base<VC>::curve3_rel(double dx_ctrl, double dy_ctrl, 
+void path_base<VC>::curve3_rel(double dx_ctrl, double dy_ctrl, double dx_to, double dy_to)
-                                   double dx_to,   double dy_to)
 {
     rel_to_abs(&dx_ctrl, &dy_ctrl);
     rel_to_abs(&dx_to, &dy_to);
@@ -1056,9 +999,7 @@ namespace agg
 
 //------------------------------------------------------------------------
 template<class VC>
-    void path_base<VC>::curve4(double x_ctrl1, double y_ctrl1, 
+void path_base<VC>::curve4(double x_ctrl1, double y_ctrl1, double x_ctrl2, double y_ctrl2, double x_to, double y_to)
-                               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);
@@ -1067,9 +1008,12 @@ namespace agg
 
 //------------------------------------------------------------------------
 template<class VC>
-    void path_base<VC>::curve4_rel(double dx_ctrl1, double dy_ctrl1, 
+void path_base<VC>::curve4_rel(double dx_ctrl1,
-                                   double dx_ctrl2, double dy_ctrl2, 
+                               double dy_ctrl1,
-                                   double dx_to,    double dy_to)
+                               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);
@@ -1081,8 +1025,7 @@ namespace agg
 
 //------------------------------------------------------------------------
 template<class VC>
-    void path_base<VC>::curve4(double x_ctrl2, double y_ctrl2, 
+void path_base<VC>::curve4(double x_ctrl2, double y_ctrl2, double x_to, double y_to)
-                               double x_to,    double y_to)
 {
     double x0;
     double y0;
@@ -1107,8 +1050,7 @@ namespace agg
 
 //------------------------------------------------------------------------
 template<class VC>
-    void path_base<VC>::curve4_rel(double dx_ctrl2, double dy_ctrl2, 
+void path_base<VC>::curve4_rel(double dx_ctrl2, double dy_ctrl2, double dx_to, double dy_to)
-                                   double dx_to,    double dy_to)
 {
     rel_to_abs(&dx_ctrl2, &dy_ctrl2);
     rel_to_abs(&dx_to, &dy_to);
@@ -1213,14 +1155,14 @@ namespace agg
 template<class VC>
 inline unsigned path_base<VC>::vertex(double* x, double* y)
 {
-        if(m_iterator >= m_vertices.total_vertices()) return path_cmd_stop;
+    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 path_base<VC>::perceive_polygon_orientation(unsigned start, unsigned end)
-                                                         unsigned end)
 {
     // Calculate signed area (double area to be exact)
     //---------------------
@@ -1267,42 +1209,42 @@ namespace agg
 void path_base<VC>::invert_polygon(unsigned start)
 {
     // Skip all non-vertices at the beginning
-        while(start < m_vertices.total_vertices() && 
+    while (start < m_vertices.total_vertices() && !is_vertex(m_vertices.command(start)))
-              !is_vertex(m_vertices.command(start))) ++start;
+        ++start;
 
     // Skip all insignificant move_to
-        while(start+1 < m_vertices.total_vertices() && 
+    while (start + 1 < m_vertices.total_vertices() && is_move_to(m_vertices.command(start)) &&
-              is_move_to(m_vertices.command(start)) &&
+           is_move_to(m_vertices.command(start + 1)))
-              is_move_to(m_vertices.command(start+1))) ++start;
+        ++start;
 
     // Find the last vertex
     unsigned end = start + 1;
-        while(end < m_vertices.total_vertices() && 
+    while (end < m_vertices.total_vertices() && !is_next_poly(m_vertices.command(end)))
-              !is_next_poly(m_vertices.command(end))) ++end;
+        ++end;
 
     invert_polygon(start, end);
 }
 
 //------------------------------------------------------------------------
 template<class VC>
-    unsigned path_base<VC>::arrange_polygon_orientation(unsigned start, 
+unsigned path_base<VC>::arrange_polygon_orientation(unsigned start, path_flags_e orientation)
-                                                        path_flags_e orientation)
 {
-        if(orientation == path_flags_none) return start;
+    if (orientation == path_flags_none)
+        return start;
 
     // Skip all non-vertices at the beginning
-        while(start < m_vertices.total_vertices() && 
+    while (start < m_vertices.total_vertices() && !is_vertex(m_vertices.command(start)))
-              !is_vertex(m_vertices.command(start))) ++start;
+        ++start;
 
     // Skip all insignificant move_to
-        while(start+1 < m_vertices.total_vertices() && 
+    while (start + 1 < m_vertices.total_vertices() && is_move_to(m_vertices.command(start)) &&
-              is_move_to(m_vertices.command(start)) &&
+           is_move_to(m_vertices.command(start + 1)))
-              is_move_to(m_vertices.command(start+1))) ++start;
+        ++start;
 
     // Find the last vertex
     unsigned end = start + 1;
-        while(end < m_vertices.total_vertices() && 
+    while (end < m_vertices.total_vertices() && !is_next_poly(m_vertices.command(end)))
-              !is_next_poly(m_vertices.command(end))) ++end;
+        ++end;
 
     if (end - start > 2)
     {
@@ -1311,8 +1253,7 @@ namespace agg
             // Invert polygon, set orientation flag, and skip all end_poly
             invert_polygon(start, end);
             unsigned cmd;
-                while(end < m_vertices.total_vertices() && 
+            while (end < m_vertices.total_vertices() && is_end_poly(cmd = m_vertices.command(end)))
-                      is_end_poly(cmd = m_vertices.command(end)))
             {
                 m_vertices.modify_command(end++, set_orientation(cmd, orientation));
             }
@@ -1323,8 +1264,7 @@ namespace agg
 
 //------------------------------------------------------------------------
 template<class VC>
-    unsigned path_base<VC>::arrange_orientations(unsigned start, 
+unsigned path_base<VC>::arrange_orientations(unsigned start, path_flags_e orientation)
-                                                 path_flags_e orientation)
 {
     if (orientation != path_flags_none)
     {
@@ -1396,7 +1336,8 @@ namespace agg
     {
         double x, y;
         unsigned cmd = m_vertices.vertex(path_id, &x, &y);
-            if(is_stop(cmd)) break;
+        if (is_stop(cmd))
+            break;
         if (is_vertex(cmd))
         {
             x += dx;
@@ -1426,10 +1367,9 @@ namespace agg
 
 ////////////////////////////////////////////////////////////////////////////////
 
-
-
 //-----------------------------------------------------vertex_stl_storage
-    template<class Container> class vertex_stl_storage
+template<class Container>
+class vertex_stl_storage
 {
   public:
     typedef typename Container::value_type vertex_type;
@@ -1440,9 +1380,7 @@ namespace agg
 
     void add_vertex(double x, double y, unsigned cmd)
     {
-            m_vertices.push_back(vertex_type(value_type(x), 
+        m_vertices.push_back(vertex_type(value_type(x), value_type(y), int8u(cmd)));
-                                             value_type(y), 
-                                             int8u(cmd)));
     }
 
     void modify_vertex(unsigned idx, double x, double y)
@@ -1460,10 +1398,7 @@ namespace agg
         v.cmd = int8u(cmd);
     }
 
-        void modify_command(unsigned idx, unsigned cmd)
+    void modify_command(unsigned idx, unsigned cmd) { m_vertices[idx].cmd = int8u(cmd); }
-        {
-            m_vertices[idx].cmd = int8u(cmd);
-        }
 
     void swap_vertices(unsigned v1, unsigned v2)
     {
@@ -1472,12 +1407,7 @@ namespace agg
         m_vertices[v2] = t;
     }
 
-        unsigned last_command() const
+    unsigned last_command() const { return m_vertices.size() ? m_vertices[m_vertices.size() - 1].cmd : path_cmd_stop; }
-        {
-            return m_vertices.size() ? 
-                m_vertices[m_vertices.size() - 1].cmd : 
-                path_cmd_stop;
-        }
 
     unsigned last_vertex(double* x, double* y) const
     {
@@ -1499,20 +1429,11 @@ namespace agg
         return vertex(m_vertices.size() - 2, x, y);
     }
 
-        double last_x() const
+    double last_x() const { return m_vertices.size() ? m_vertices[m_vertices.size() - 1].x : 0.0; }
-        {
-            return m_vertices.size() ? m_vertices[m_vertices.size() - 1].x : 0.0;
-        }
 
-        double last_y() const
+    double last_y() const { return m_vertices.size() ? m_vertices[m_vertices.size() - 1].y : 0.0; }
-        {
-            return m_vertices.size() ? m_vertices[m_vertices.size() - 1].y : 0.0;
-        }
 
-        unsigned total_vertices() const
+    unsigned total_vertices() const { return m_vertices.size(); }
-        {
-            return m_vertices.size();
-        }
 
     unsigned vertex(unsigned idx, double* x, double* y) const
     {
@@ -1522,10 +1443,7 @@ namespace agg
         return v.cmd;
     }
 
-        unsigned command(unsigned idx) const
+    unsigned command(unsigned idx) const { return m_vertices[idx].cmd; }
-        {
-            return m_vertices[idx].cmd;
-        }
 
   private:
     Container m_vertices;
@@ -1538,9 +1456,7 @@ namespace agg
 //-----------------------------------------------------------------------
 // typedef path_base<vertex_stl_storage<pod_bvector<vertex_d> > > path_storage;
 
-}
+} // namespace agg
-
-
 
 // Example of declarations path_storage with std::vector as a container
 //---------------------------------------------------------------------------
@@ -1551,5 +1467,4 @@ namespace agg
 //    typedef path_base<vertex_stl_storage<std::vector<vertex_d> > > path_storage;
 //}
 
-
 #endif

deps/agg/include/agg_path_storage_integer.h

@@ -19,86 +19,74 @@
 #include <cstring>
 #include "agg_array.h"
 
-namespace agg
+namespace agg {
-{
 //---------------------------------------------------------vertex_integer
-    template<class T, unsigned CoordShift=6> struct vertex_integer
+template<class T, unsigned CoordShift = 6>
+struct vertex_integer
 {
-        enum path_cmd
+    enum path_cmd { cmd_move_to = 0, cmd_line_to = 1, cmd_curve3 = 2, cmd_curve4 = 3 };
-        {
-            cmd_move_to = 0,
-            cmd_line_to = 1,
-            cmd_curve3  = 2,
-            cmd_curve4  = 3
-        };
 
-        enum coord_scale_e
+    enum coord_scale_e { coord_shift = CoordShift, coord_scale = 1 << coord_shift };
-        {
-            coord_shift = CoordShift,
-            coord_scale  = 1 << coord_shift
-        };
 
     T x, y;
     vertex_integer() {}
-        vertex_integer(T x_, T y_, unsigned flag) :
+    vertex_integer(T x_, T y_, unsigned flag)
-            x(((x_ << 1) & ~1) | (flag &  1)),
+        : x(((x_ << 1) & ~1) | (flag & 1))
-            y(((y_ << 1) & ~1) | (flag >> 1)) {}
+        , y(((y_ << 1) & ~1) | (flag >> 1))
+    {}
 
-        unsigned vertex(double* x_, double* y_, 
+    unsigned vertex(double* x_, double* y_, double dx = 0, double dy = 0, double scale = 1.0) const
-                        double dx=0, double dy=0,
-                        double scale=1.0) const
     {
         *x_ = dx + (double(x >> 1) / coord_scale) * scale;
         *y_ = dy + (double(y >> 1) / coord_scale) * scale;
         switch (((y & 1) << 1) | (x & 1))
         {
-                case cmd_move_to: return path_cmd_move_to;
+            case cmd_move_to:
-                case cmd_line_to: return path_cmd_line_to;
+                return path_cmd_move_to;
-                case cmd_curve3:  return path_cmd_curve3;
+            case cmd_line_to:
-                case cmd_curve4:  return path_cmd_curve4;
+                return path_cmd_line_to;
+            case cmd_curve3:
+                return path_cmd_curve3;
+            case cmd_curve4:
+                return path_cmd_curve4;
         }
         return path_cmd_stop;
     }
 };
 
-
 //---------------------------------------------------path_storage_integer
-    template<class T, unsigned CoordShift=6> class path_storage_integer
+template<class T, unsigned CoordShift = 6>
+class path_storage_integer
 {
   public:
     typedef T value_type;
     typedef vertex_integer<T, CoordShift> vertex_integer_type;
 
     //--------------------------------------------------------------------
-        path_storage_integer() : m_storage(), m_vertex_idx(0), m_closed(true) {}
+    path_storage_integer()
+        : m_storage()
+        , m_vertex_idx(0)
+        , m_closed(true)
+    {}
 
     //--------------------------------------------------------------------
     void remove_all() { m_storage.remove_all(); }
 
     //--------------------------------------------------------------------
-        void move_to(T x, T y)
+    void move_to(T x, T y) { m_storage.add(vertex_integer_type(x, y, vertex_integer_type::cmd_move_to)); }
-        {
-            m_storage.add(vertex_integer_type(x, y, vertex_integer_type::cmd_move_to));
-        }
 
     //--------------------------------------------------------------------
-        void line_to(T x, T y)
+    void line_to(T x, T y) { m_storage.add(vertex_integer_type(x, y, vertex_integer_type::cmd_line_to)); }
-        {
-            m_storage.add(vertex_integer_type(x, y, vertex_integer_type::cmd_line_to));
-        }
 
     //--------------------------------------------------------------------
-        void curve3(T x_ctrl,  T y_ctrl, 
+    void curve3(T x_ctrl, T y_ctrl, T x_to, T y_to)
-                    T x_to,    T y_to)
     {
         m_storage.add(vertex_integer_type(x_ctrl, y_ctrl, vertex_integer_type::cmd_curve3));
         m_storage.add(vertex_integer_type(x_to, y_to, vertex_integer_type::cmd_curve3));
     }
 
     //--------------------------------------------------------------------
-        void curve4(T x_ctrl1, T y_ctrl1, 
+    void curve4(T x_ctrl1, T y_ctrl1, T x_ctrl2, T y_ctrl2, T x_to, T y_to)
-                    T x_ctrl2, T y_ctrl2, 
-                    T x_to,    T y_to)
     {
         m_storage.add(vertex_integer_type(x_ctrl1, y_ctrl1, vertex_integer_type::cmd_curve4));
         m_storage.add(vertex_integer_type(x_ctrl2, y_ctrl2, vertex_integer_type::cmd_curve4));
@@ -110,10 +98,7 @@ namespace agg
 
     //--------------------------------------------------------------------
     unsigned size() const { return m_storage.size(); }
-        unsigned vertex(unsigned idx, double* x, double* y) const
+    unsigned vertex(unsigned idx, double* x, double* y) const { return m_storage[idx].vertex(x, y); }
-        {
-            return m_storage[idx].vertex(x, y);
-        }
 
     //--------------------------------------------------------------------
     unsigned byte_size() const { return m_storage.size() * sizeof(vertex_integer_type); }
@@ -178,10 +163,14 @@ namespace agg
             {
                 double x, y;
                 m_storage[i].vertex(&x, &y);
-                    if(x < bounds.x1) bounds.x1 = x;
+                if (x < bounds.x1)
-                    if(y < bounds.y1) bounds.y1 = y;
+                    bounds.x1 = x;
-                    if(x > bounds.x2) bounds.x2 = x;
+                if (y < bounds.y1)
-                    if(y > bounds.y2) bounds.y2 = y;
+                    bounds.y1 = y;
+                if (x > bounds.x2)
+                    bounds.x2 = x;
+                if (y > bounds.y2)
+                    bounds.y2 = y;
             }
         }
         return bounds;
@@ -193,40 +182,36 @@ namespace agg
     bool m_closed;
 };
 
-
-
-
 //-----------------------------------------serialized_integer_path_adaptor
-    template<class T, unsigned CoordShift=6> class serialized_integer_path_adaptor
+template<class T, unsigned CoordShift = 6>
+class serialized_integer_path_adaptor
 {
   public:
     typedef vertex_integer<T, CoordShift> vertex_integer_type;
 
     //--------------------------------------------------------------------
-        serialized_integer_path_adaptor() :
+    serialized_integer_path_adaptor()
-            m_data(0),
+        : m_data(0)
-            m_end(0),
+        , m_end(0)
-            m_ptr(0),
+        , m_ptr(0)
-            m_dx(0.0),
+        , m_dx(0.0)
-            m_dy(0.0),
+        , m_dy(0.0)
-            m_scale(1.0),
+        , m_scale(1.0)
-            m_vertices(0)
+        , m_vertices(0)
     {}
 
     //--------------------------------------------------------------------
-        serialized_integer_path_adaptor(const int8u* data, unsigned size,
+    serialized_integer_path_adaptor(const int8u* data, unsigned size, double dx, double dy)
-                                        double dx, double dy) :
+        : m_data(data)
-            m_data(data),
+        , m_end(data + size)
-            m_end(data + size),
+        , m_ptr(data)
-            m_ptr(data),
+        , m_dx(dx)
-            m_dx(dx),
+        , m_dy(dy)
-            m_dy(dy),
+        , m_vertices(0)
-            m_vertices(0)
     {}
 
     //--------------------------------------------------------------------
-        void init(const int8u* data, unsigned size, 
+    void init(const int8u* data, unsigned size, double dx, double dy, double scale = 1.0)
-                  double dx, double dy, double scale=1.0)
     {
         m_data = data;
         m_end = data + size;
@@ -237,7 +222,6 @@ namespace agg
         m_vertices = 0;
     }
 
-
     //--------------------------------------------------------------------
     void rewind(unsigned)
     {
@@ -288,8 +272,6 @@ namespace agg
     unsigned m_vertices;
 };
 
-}
+} // namespace agg
-
 
 #endif
-

deps/agg/include/agg_pattern_filters_rgba.h

@@ -19,52 +19,39 @@
 #include "agg_line_aa_basics.h"
 #include "agg_color_rgba.h"
 
-
+namespace agg {
-namespace agg
-{
 
 //=======================================================pattern_filter_nn
-    template<class ColorT> struct pattern_filter_nn
+template<class ColorT>
+struct pattern_filter_nn
 {
     typedef ColorT color_type;
     static unsigned dilation() { return 0; }
 
-        static void AGG_INLINE pixel_low_res(color_type const* const* buf, 
+    static void AGG_INLINE pixel_low_res(color_type const* const* buf, color_type* p, int x, int y) { *p = buf[y][x]; }
-                                             color_type* p, int x, int y)
-        {
-            *p = buf[y][x];
-        }
 
-        static void AGG_INLINE pixel_high_res(color_type const* const* buf, 
+    static void AGG_INLINE pixel_high_res(color_type const* const* buf, color_type* p, int x, int y)
-                                              color_type* p, int x, int y)
     {
-            *p = buf[y >> line_subpixel_shift]
+        *p = buf[y >> line_subpixel_shift][x >> line_subpixel_shift];
-                    [x >> line_subpixel_shift];
     }
 };
 
 typedef pattern_filter_nn<rgba8> pattern_filter_nn_rgba8;
 typedef pattern_filter_nn<rgba16> pattern_filter_nn_rgba16;
 
-
 //===========================================pattern_filter_bilinear_rgba
-    template<class ColorT> struct pattern_filter_bilinear_rgba
+template<class ColorT>
+struct pattern_filter_bilinear_rgba
 {
     typedef ColorT color_type;
     typedef typename color_type::value_type value_type;
     typedef typename color_type::calc_type calc_type;
 
-
     static unsigned dilation() { return 1; }
 
-        static AGG_INLINE void pixel_low_res(color_type const* const* buf, 
+    static AGG_INLINE void pixel_low_res(color_type const* const* buf, color_type* p, int x, int y) { *p = buf[y][x]; }
-                                             color_type* p, int x, int y)
-        {
-            *p = buf[y][x];
-        }
 
-        static AGG_INLINE void pixel_high_res(color_type const* const* buf, 
+    static AGG_INLINE void pixel_high_res(color_type const* const* buf, color_type* p, int x, int y)
-                                              color_type* p, int x, int y)
     {
         calc_type r, g, b, a;
         r = g = b = a = line_subpixel_scale * line_subpixel_scale / 2;
@@ -77,8 +64,7 @@ namespace agg
         y &= line_subpixel_mask;
         const color_type* ptr = buf[y_lr] + x_lr;
 
-            weight = (line_subpixel_scale - x) * 
+        weight = (line_subpixel_scale - x) * (line_subpixel_scale - y);
-                     (line_subpixel_scale - y);
         r += weight * ptr->r;
         g += weight * ptr->g;
         b += weight * ptr->b;
@@ -117,6 +103,6 @@ namespace agg
 
 typedef pattern_filter_bilinear_rgba<rgba8> pattern_filter_bilinear_rgba8;
 typedef pattern_filter_bilinear_rgba<rgba16> pattern_filter_bilinear_rgba16;
-}
+} // namespace agg
 
 #endif

deps/agg/include/agg_pixfmt_amask_adaptor.h

@@ -16,16 +16,14 @@
 #ifndef AGG_PIXFMT_AMASK_ADAPTOR_INCLUDED
 #define AGG_PIXFMT_AMASK_ADAPTOR_INCLUDED
 
-
 #include <cstring>
 #include "agg_array.h"
 #include "agg_rendering_buffer.h"
 
-
+namespace agg {
-namespace agg
-{
 //==================================================pixfmt_amask_adaptor
-    template<class PixFmt, class AlphaMask> class pixfmt_amask_adaptor
+template<class PixFmt, class AlphaMask>
+class pixfmt_amask_adaptor
 {
   public:
     typedef PixFmt pixfmt_type;
@@ -57,10 +55,11 @@ namespace agg
         memcpy(&m_span[0], covers, len * sizeof(cover_type));
     }
 
-
   public:
-        pixfmt_amask_adaptor(pixfmt_type& pixf, const amask_type& mask) :
+    pixfmt_amask_adaptor(pixfmt_type& pixf, const amask_type& mask)
-            m_pixf(&pixf), m_mask(&mask), m_span()
+        : m_pixf(&pixf)
+        , m_mask(&mask)
+        , m_span()
     {}
 
     void attach_pixfmt(pixfmt_type& pixf) { m_pixf = &pixf; }
@@ -78,16 +77,10 @@ namespace agg
     unsigned height() const { return m_pixf->height(); }
 
     //--------------------------------------------------------------------
-        color_type pixel(int x, int y)
+    color_type pixel(int x, int y) { return m_pixf->pixel(x, y); }
-        {
-            return m_pixf->pixel(x, y);
-        }
 
     //--------------------------------------------------------------------
-        void copy_pixel(int x, int y, const color_type& c)
+    void copy_pixel(int x, int y, const color_type& c) { m_pixf->blend_pixel(x, y, c, m_mask->pixel(x, y)); }
-        {
-            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)
@@ -96,9 +89,7 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        void copy_hline(int x, int y, 
+    void copy_hline(int x, int y, unsigned len, const color_type& c)
-                        unsigned len, 
-                        const color_type& c)
     {
         realloc_span(len);
         m_mask->fill_hspan(x, y, &m_span[0], len);
@@ -106,10 +97,7 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        void blend_hline(int x, int y,
+    void blend_hline(int x, int y, unsigned len, const color_type& c, cover_type cover)
-                         unsigned len, 
-                         const color_type& c,
-                         cover_type cover)
     {
         init_span(len);
         m_mask->combine_hspan(x, y, &m_span[0], len);
@@ -117,9 +105,7 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        void copy_vline(int x, int y,
+    void copy_vline(int x, int y, unsigned len, const color_type& c)
-                        unsigned len, 
-                        const color_type& c)
     {
         realloc_span(len);
         m_mask->fill_vspan(x, y, &m_span[0], len);
@@ -127,10 +113,7 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        void blend_vline(int x, int y,
+    void blend_vline(int x, int y, unsigned len, const color_type& c, cover_type cover)
-                         unsigned len, 
-                         const color_type& c,
-                         cover_type cover)
     {
         init_span(len);
         m_mask->combine_vspan(x, y, &m_span[0], len);
@@ -138,39 +121,27 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        void copy_from(const rendering_buffer& from, 
+    void copy_from(const rendering_buffer& from, int xdst, int ydst, int xsrc, int ysrc, unsigned len)
-                       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,
+    void blend_solid_hspan(int x, int y, unsigned len, const color_type& c, const cover_type* covers)
-                               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,
+    void blend_solid_vspan(int x, int y, unsigned len, const color_type& c, const cover_type* covers)
-                               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)
     {
@@ -188,7 +159,8 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        void blend_color_hspan(int x, int y,
+    void blend_color_hspan(int x,
+                           int y,
                            unsigned len,
                            const color_type* colors,
                            const cover_type* covers,
@@ -207,9 +179,9 @@ namespace agg
         m_pixf->blend_color_hspan(x, y, len, colors, &m_span[0], cover);
     }
 
-
     //--------------------------------------------------------------------
-        void blend_color_vspan(int x, int y,
+    void blend_color_vspan(int x,
+                           int y,
                            unsigned len,
                            const color_type* colors,
                            const cover_type* covers,
@@ -234,7 +206,6 @@ namespace agg
     pod_array<cover_type> m_span;
 };
 
-}
+} // namespace agg
 
 #endif
-

deps/agg/include/agg_pixfmt_base.h

@@ -20,19 +20,15 @@
 #include "agg_color_gray.h"
 #include "agg_color_rgba.h"
 
-namespace agg
+namespace agg {
-{
 struct pixfmt_gray_tag
-    {
+{};
-    };
 
 struct pixfmt_rgb_tag
-    {
+{};
-    };
 
 struct pixfmt_rgba_tag
-    {
+{};
-    };
 
 //--------------------------------------------------------------blender_base
 template<class ColorT, class Order = void>
@@ -46,8 +42,7 @@ namespace agg
     {
         if (cover > cover_none)
         {
-                rgba c(
+            rgba c(color_type::to_double(r),
-                    color_type::to_double(r), 
                    color_type::to_double(g),
                    color_type::to_double(b),
                    color_type::to_double(a));
@@ -63,17 +58,13 @@ namespace agg
 
             return c;
         }
-            else return rgba::no_color();
+        else
+            return rgba::no_color();
     }
 
     static rgba get(const value_type* p, cover_type cover = cover_full)
     {
-            return get(
+        return get(p[order_type::R], p[order_type::G], p[order_type::B], p[order_type::A], cover);
-                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)
@@ -92,6 +83,6 @@ namespace agg
         p[order_type::A] = color_type::from_double(c.a);
     }
 };
-}
+} // namespace agg
 
 #endif

deps/agg/include/agg_pixfmt_gray.h

@@ -28,11 +28,11 @@
 #include "agg_pixfmt_base.h"
 #include "agg_rendering_buffer.h"
 
-namespace agg
+namespace agg {
-{
 
 //============================================================blender_gray
-    template<class ColorT> struct blender_gray
+template<class ColorT>
+struct blender_gray
 {
     typedef ColorT color_type;
     typedef typename color_type::value_type value_type;
@@ -43,22 +43,20 @@ namespace agg
     // 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,
+    static AGG_INLINE void blend_pix(value_type* p, value_type cv, value_type alpha, cover_type cover)
-            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,
+    static AGG_INLINE void blend_pix(value_type* p, value_type cv, value_type alpha)
-            value_type cv, value_type alpha)
     {
         *p = color_type::lerp(*p, cv, alpha);
     }
 };
 
-
 //======================================================blender_gray_pre
-    template<class ColorT> struct blender_gray_pre
+template<class ColorT>
+struct blender_gray_pre
 {
     typedef ColorT color_type;
     typedef typename color_type::value_type value_type;
@@ -68,59 +66,51 @@ namespace agg
     // Blend pixels using the premultiplied form of Alvy-Ray Smith's
     // compositing function.
 
-        static AGG_INLINE void blend_pix(value_type* p,
+    static AGG_INLINE void blend_pix(value_type* p, value_type cv, value_type alpha, cover_type cover)
-            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,
+    static AGG_INLINE void blend_pix(value_type* p, value_type cv, value_type alpha)
-            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
+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) {}
+    apply_gamma_dir_gray(const GammaLut& gamma)
+        : m_gamma(gamma)
+    {}
 
-        AGG_INLINE void operator () (value_type* p)
+    AGG_INLINE void operator()(value_type* p) { *p = m_gamma.dir(*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
+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) {}
+    apply_gamma_inv_gray(const GammaLut& gamma)
+        : m_gamma(gamma)
+    {}
 
-        AGG_INLINE void operator () (value_type* p)
+    AGG_INLINE void operator()(value_type* p) { *p = m_gamma.inv(*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
@@ -134,8 +124,7 @@ namespace agg
     typedef int order_type; // A fake one
     typedef typename color_type::value_type value_type;
     typedef typename color_type::calc_type calc_type;
-        enum
+    enum {
-        {
         num_components = 1,
         pix_width = sizeof(value_type) * Step,
         pix_step = Step,
@@ -145,61 +134,32 @@ namespace agg
     {
         value_type c[num_components];
 
-            void set(value_type v)
+        void set(value_type v) { c[0] = v; }
-            {
-                c[0] = v;
-            }
 
-            void set(const color_type& color)
+        void set(const color_type& color) { set(color.v); }
-            {
-                set(color.v);
-            }
 
-            void get(value_type& v) const
+        void get(value_type& v) const { v = c[0]; }
-            {
-                v = c[0];
-            }
 
-            color_type get() const
+        color_type get() const { return color_type(c[0]); }
-            {
-                return color_type(c[0]);
-            }
 
-            pixel_type* next()
+        pixel_type* next() { return (pixel_type*)(c + pix_step); }
-            {
-                return (pixel_type*)(c + pix_step);
-            }
 
-            const pixel_type* next() const
+        const pixel_type* next() const { return (const pixel_type*)(c + pix_step); }
-            {
-                return (const pixel_type*)(c + pix_step);
-            }
 
-            pixel_type* advance(int n)
+        pixel_type* advance(int n) { return (pixel_type*)(c + n * pix_step); }
-            {
-                return (pixel_type*)(c + n * pix_step);
-            }
 
-            const pixel_type* advance(int n) const
+        const pixel_type* advance(int n) const { return (const pixel_type*)(c + n * pix_step); }
-            {
-                return (const pixel_type*)(c + n * pix_step);
-            }
     };
 
   private:
     //--------------------------------------------------------------------
-        AGG_INLINE void blend_pix(pixel_type* p,
+    AGG_INLINE void blend_pix(pixel_type* p, value_type v, value_type a, unsigned cover)
-            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)
+    AGG_INLINE void blend_pix(pixel_type* p, value_type v, value_type a) { blender_type::blend_pix(p->c, v, a); }
-        {
-            blender_type::blend_pix(p->c, v, a);
-        }
 
     //--------------------------------------------------------------------
     AGG_INLINE void blend_pix(pixel_type* p, const color_type& c, unsigned cover)
@@ -208,10 +168,7 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        AGG_INLINE void blend_pix(pixel_type* p, const color_type& c)
+    AGG_INLINE void blend_pix(pixel_type* p, const color_type& c) { blender_type::blend_pix(p->c, c.v, c.a); }
-        {
-            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)
@@ -247,8 +204,8 @@ namespace agg
 
   public:
     //--------------------------------------------------------------------
-        explicit pixfmt_alpha_blend_gray(rbuf_type& rb) :
+    explicit pixfmt_alpha_blend_gray(rbuf_type& rb)
-            m_rbuf(&rb)
+        : m_rbuf(&rb)
     {}
     void attach(rbuf_type& rb) { m_rbuf = &rb; }
     //--------------------------------------------------------------------
@@ -260,10 +217,7 @@ namespace agg
         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),
+            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);
-                               (r.x2 - r.x1) + 1,
-                               (r.y2 - r.y1) + 1,
-                               stride);
             return true;
         }
         return false;
@@ -304,10 +258,7 @@ namespace agg
     }
 
     // Get pixel pointer from raw buffer pointer.
-        AGG_INLINE static pixel_type* pix_value_ptr(void* p)
+    AGG_INLINE static pixel_type* pix_value_ptr(void* p) { return (pixel_type*)((value_type*)p + pix_offset); }
-        {
-            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)
@@ -324,16 +275,10 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        AGG_INLINE static color_type read_plain_color(const void* p)
+    AGG_INLINE static color_type read_plain_color(const void* p) { return pix_value_ptr(p)->get(); }
-        {
-            return pix_value_ptr(p)->get();
-        }
 
     //--------------------------------------------------------------------
-        AGG_INLINE static void make_pix(int8u* p, const color_type& c)
+    AGG_INLINE static void make_pix(int8u* p, const color_type& c) { ((pixel_type*)p)->set(c); }
-        {
-            ((pixel_type*)p)->set(c);
-        }
 
     //--------------------------------------------------------------------
     AGG_INLINE color_type pixel(int x, int y) const
@@ -346,10 +291,7 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        AGG_INLINE void copy_pixel(int x, int y, const color_type& c)
+    AGG_INLINE void copy_pixel(int x, int y, const color_type& c) { pix_value_ptr(x, y, 1)->set(c); }
-        {
-            pix_value_ptr(x, y, 1)->set(c);
-        }
 
     //--------------------------------------------------------------------
     AGG_INLINE void blend_pixel(int x, int y, const color_type& c, int8u cover)
@@ -358,38 +300,27 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        AGG_INLINE void copy_hline(int x, int y,
+    AGG_INLINE void copy_hline(int x, int y, unsigned len, const color_type& c)
-                                   unsigned len,
-                                   const color_type& c)
     {
         pixel_type* p = pix_value_ptr(x, y, len);
         do
         {
             p->set(c);
             p = p->next();
+        } while (--len);
     }
-            while(--len);
-        }
-
 
     //--------------------------------------------------------------------
-        AGG_INLINE void copy_vline(int x, int y,
+    AGG_INLINE void copy_vline(int x, int y, unsigned len, const color_type& c)
-                                   unsigned len,
-                                   const color_type& c)
     {
         do
         {
             pix_value_ptr(x, y++, 1)->set(c);
+        } while (--len);
     }
-            while (--len);
-        }
-
 
     //--------------------------------------------------------------------
-        void blend_hline(int x, int y,
+    void blend_hline(int x, int y, unsigned len, const color_type& c, int8u cover)
-                         unsigned len,
-                         const color_type& c,
-                         int8u cover)
     {
         if (!c.is_transparent())
         {
@@ -401,8 +332,7 @@ namespace agg
                 {
                     p->set(c);
                     p = p->next();
-                    }
+                } while (--len);
-                    while (--len);
             }
             else
             {
@@ -410,18 +340,13 @@ namespace agg
                 {
                     blend_pix(p, c, cover);
                     p = p->next();
-                    }
+                } while (--len);
-                    while (--len);
             }
         }
     }
 
-
     //--------------------------------------------------------------------
-        void blend_vline(int x, int y,
+    void blend_vline(int x, int y, unsigned len, const color_type& c, int8u cover)
-                         unsigned len,
-                         const color_type& c,
-                         int8u cover)
     {
         if (!c.is_transparent())
         {
@@ -430,26 +355,20 @@ namespace agg
                 do
                 {
                     pix_value_ptr(x, y++, 1)->set(c);
-                    }
+                } while (--len);
-                    while (--len);
             }
             else
             {
                 do
                 {
                     blend_pix(pix_value_ptr(x, y++, 1), c, cover);
-                    }
+                } while (--len);
-                    while (--len);
             }
         }
     }
 
-
     //--------------------------------------------------------------------
-        void blend_solid_hspan(int x, int y,
+    void blend_solid_hspan(int x, int y, unsigned len, const color_type& c, const int8u* covers)
-                               unsigned len,
-                               const color_type& c,
-                               const int8u* covers)
     {
         if (!c.is_transparent())
         {
@@ -467,17 +386,12 @@ namespace agg
                 }
                 p = p->next();
                 ++covers;
-                }
+            } while (--len);
-                while (--len);
         }
     }
 
-
     //--------------------------------------------------------------------
-        void blend_solid_vspan(int x, int y,
+    void blend_solid_vspan(int x, int y, unsigned len, const color_type& c, const int8u* covers)
-                               unsigned len,
-                               const color_type& c,
-                               const int8u* covers)
     {
         if (!c.is_transparent())
         {
@@ -494,16 +408,12 @@ namespace agg
                     blend_pix(p, c, *covers);
                 }
                 ++covers;
-                }
+            } while (--len);
-                while (--len);
         }
     }
 
-
     //--------------------------------------------------------------------
-        void copy_color_hspan(int x, int y,
+    void copy_color_hspan(int x, int y, unsigned len, const color_type* colors)
-                              unsigned len,
-                              const color_type* colors)
     {
         pixel_type* p = pix_value_ptr(x, y, len);
 
@@ -511,30 +421,20 @@ namespace agg
         {
             p->set(*colors++);
             p = p->next();
+        } while (--len);
     }
-            while (--len);
-        }
-
 
     //--------------------------------------------------------------------
-        void copy_color_vspan(int x, int y,
+    void copy_color_vspan(int x, int y, unsigned len, const color_type* colors)
-                              unsigned len,
-                              const color_type* colors)
     {
         do
         {
             pix_value_ptr(x, y++, 1)->set(*colors++);
+        } while (--len);
     }
-            while (--len);
-        }
-
 
     //--------------------------------------------------------------------
-        void blend_color_hspan(int x, int y,
+    void blend_color_hspan(int x, int y, unsigned len, const color_type* colors, const int8u* covers, int8u cover)
-                               unsigned len,
-                               const color_type* colors,
-                               const int8u* covers,
-                               int8u cover)
     {
         pixel_type* p = pix_value_ptr(x, y, len);
 
@@ -544,8 +444,7 @@ namespace agg
             {
                 copy_or_blend_pix(p, *colors++, *covers++);
                 p = p->next();
-                }
+            } while (--len);
-                while (--len);
         }
         else
         {
@@ -555,8 +454,7 @@ namespace agg
                 {
                     copy_or_blend_pix(p, *colors++);
                     p = p->next();
-                    }
+                } while (--len);
-                    while (--len);
             }
             else
             {
@@ -564,27 +462,20 @@ namespace agg
                 {
                     copy_or_blend_pix(p, *colors++, cover);
                     p = p->next();
-                    }
+                } while (--len);
-                    while (--len);
             }
         }
     }
 
-
     //--------------------------------------------------------------------
-        void blend_color_vspan(int x, int y,
+    void blend_color_vspan(int x, int y, unsigned len, const color_type* colors, const int8u* covers, int8u cover)
-                               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);
-                while (--len);
         }
         else
         {
@@ -593,22 +484,21 @@ namespace agg
                 do
                 {
                     copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++);
-                    }
+                } while (--len);
-                    while (--len);
             }
             else
             {
                 do
                 {
                     copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++, cover);
-                    }
+                } while (--len);
-                    while (--len);
             }
         }
     }
 
     //--------------------------------------------------------------------
-        template<class Function> void for_each_pixel(Function f)
+    template<class Function>
+    void for_each_pixel(Function f)
     {
         unsigned y;
         for (y = 0; y < height(); ++y)
@@ -622,36 +512,32 @@ namespace agg
                 {
                     f(p->c);
                     p = p->next();
-                    }
+                } while (--len);
-                    while (--len);
             }
         }
     }
 
     //--------------------------------------------------------------------
-        template<class GammaLut> void apply_gamma_dir(const GammaLut& g)
+    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)
+    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,
+    void copy_from(const RenBuf2& from, int xdst, int ydst, int xsrc, int ysrc, unsigned len)
-                       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,
+            memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width, p + xsrc * pix_width, len * pix_width);
-                        p + xsrc * pix_width,
-                        len * pix_width);
         }
     }
 
@@ -660,8 +546,10 @@ namespace agg
     template<class SrcPixelFormatRenderer>
     void blend_from_color(const SrcPixelFormatRenderer& from,
                           const color_type& color,
-                              int xdst, int ydst,
+                          int xdst,
-                              int xsrc, int ysrc,
+                          int ydst,
+                          int xsrc,
+                          int ysrc,
                           unsigned len,
                           int8u cover)
     {
@@ -677,8 +565,7 @@ namespace agg
                 copy_or_blend_pix(pdst, color, src_color_type::scale_cover(cover, psrc->c[0]));
                 psrc = psrc->next();
                 pdst = pdst->next();
-                }
+            } while (--len);
-                while (--len);
         }
     }
 
@@ -688,8 +575,10 @@ namespace agg
     template<class SrcPixelFormatRenderer>
     void blend_from_lut(const SrcPixelFormatRenderer& from,
                         const color_type* color_lut,
-                            int xdst, int ydst,
+                        int xdst,
-                            int xsrc, int ysrc,
+                        int ydst,
+                        int xsrc,
+                        int ysrc,
                         unsigned len,
                         int8u cover)
     {
@@ -704,8 +593,7 @@ namespace agg
                 copy_or_blend_pix(pdst, color_lut[psrc->c[0]], cover);
                 psrc = psrc->next();
                 pdst = pdst->next();
-                }
+            } while (--len);
-                while (--len);
         }
     }
 
@@ -732,6 +620,6 @@ namespace agg
 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;
-}
+} // namespace agg
 
 #endif

deps/agg/include/agg_pixfmt_rgb.h

@@ -29,16 +29,18 @@
 #include "agg_color_rgba.h"
 #include "agg_rendering_buffer.h"
 
-namespace agg
+namespace agg {
-{
 
 //=====================================================apply_gamma_dir_rgb
-    template<class ColorT, class Order, class GammaLut> class 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) {}
+    apply_gamma_dir_rgb(const GammaLut& gamma)
+        : m_gamma(gamma)
+    {}
 
     AGG_INLINE void operator()(value_type* p)
     {
@@ -51,15 +53,16 @@ namespace agg
     const GammaLut& m_gamma;
 };
 
-
-
 //=====================================================apply_gamma_inv_rgb
-    template<class ColorT, class Order, class GammaLut> class 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) {}
+    apply_gamma_inv_rgb(const GammaLut& gamma)
+        : m_gamma(gamma)
+    {}
 
     AGG_INLINE void operator()(value_type* p)
     {
@@ -72,9 +75,9 @@ namespace agg
     const GammaLut& m_gamma;
 };
 
-
 //=========================================================blender_rgb
-    template<class ColorT, class Order> struct blender_rgb
+template<class ColorT, class Order>
+struct blender_rgb
 {
     typedef ColorT color_type;
     typedef Order order_type;
@@ -83,10 +86,8 @@ namespace agg
     enum base_scale_e { base_shift = color_type::base_shift };
 
     //--------------------------------------------------------------------
-        static AGG_INLINE void blend_pix(value_type* p, 
+    static AGG_INLINE void
-                                         unsigned cr, unsigned cg, unsigned cb, 
+      blend_pix(value_type* p, unsigned cr, unsigned cg, unsigned cb, unsigned alpha, unsigned cover = 0)
-                                         unsigned alpha, 
-                                         unsigned cover=0)
     {
         p[Order::R] += (value_type)(((cr - p[Order::R]) * alpha) >> base_shift);
         p[Order::G] += (value_type)(((cg - p[Order::G]) * alpha) >> base_shift);
@@ -94,9 +95,9 @@ namespace agg
     }
 };
 
-
 //======================================================blender_rgb_pre
-    template<class ColorT, class Order> struct blender_rgb_pre
+template<class ColorT, class Order>
+struct blender_rgb_pre
 {
     typedef ColorT color_type;
     typedef Order order_type;
@@ -105,10 +106,8 @@ namespace agg
     enum base_scale_e { base_shift = color_type::base_shift };
 
     //--------------------------------------------------------------------
-        static AGG_INLINE void blend_pix(value_type* p, 
+    static AGG_INLINE void
-                                         unsigned cr, unsigned cg, unsigned cb,
+      blend_pix(value_type* p, unsigned cr, unsigned cg, unsigned cb, unsigned alpha, unsigned cover)
-                                         unsigned alpha,
-                                         unsigned cover)
     {
         alpha = color_type::base_mask - alpha;
         cover = (cover + 1) << (base_shift - 8);
@@ -118,22 +117,18 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        static AGG_INLINE void blend_pix(value_type* p, 
+    static AGG_INLINE void blend_pix(value_type* p, unsigned cr, unsigned cg, unsigned cb, unsigned alpha)
-                                         unsigned cr, unsigned cg, unsigned cb,
-                                         unsigned alpha)
     {
         alpha = color_type::base_mask - alpha;
         p[Order::R] = (value_type)(((p[Order::R] * alpha) >> base_shift) + cr);
         p[Order::G] = (value_type)(((p[Order::G] * alpha) >> base_shift) + cg);
         p[Order::B] = (value_type)(((p[Order::B] * alpha) >> base_shift) + cb);
     }
-
 };
 
-
-
 //===================================================blender_rgb_gamma
-    template<class ColorT, class Order, class Gamma> class blender_rgb_gamma
+template<class ColorT, class Order, class Gamma>
+class blender_rgb_gamma
 {
   public:
     typedef ColorT color_type;
@@ -144,14 +139,13 @@ namespace agg
     enum base_scale_e { base_shift = color_type::base_shift };
 
     //--------------------------------------------------------------------
-        blender_rgb_gamma() : m_gamma(0) {}
+    blender_rgb_gamma()
+        : m_gamma(0)
+    {}
     void gamma(const gamma_type& g) { m_gamma = &g; }
 
     //--------------------------------------------------------------------
-        AGG_INLINE void blend_pix(value_type* p, 
+    AGG_INLINE void blend_pix(value_type* p, unsigned cr, unsigned cg, unsigned cb, unsigned alpha, unsigned cover = 0)
-                                  unsigned cr, unsigned cg, unsigned cb,
-                                  unsigned alpha, 
-                                  unsigned cover=0)
     {
         calc_type r = m_gamma->dir(p[Order::R]);
         calc_type g = m_gamma->dir(p[Order::G]);
@@ -165,11 +159,9 @@ namespace agg
     const gamma_type* m_gamma;
 };
 
-
-
-    
 //==================================================pixfmt_alpha_blend_rgb
-    template<class Blender, class RenBuf> class pixfmt_alpha_blend_rgb
+template<class Blender, class RenBuf>
+class pixfmt_alpha_blend_rgb
 {
   public:
     typedef RenBuf rbuf_type;
@@ -179,8 +171,7 @@ namespace agg
     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 base_scale_e 
+    enum base_scale_e {
-        {
         base_shift = color_type::base_shift,
         base_scale = color_type::base_scale,
         base_mask = color_type::base_mask,
@@ -189,9 +180,7 @@ namespace agg
 
   private:
     //--------------------------------------------------------------------
-        AGG_INLINE void copy_or_blend_pix(value_type* p, 
+    AGG_INLINE void copy_or_blend_pix(value_type* p, const color_type& c, unsigned cover)
-                                          const color_type& c, 
-                                          unsigned cover)
     {
         if (c.a)
         {
@@ -210,8 +199,7 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        AGG_INLINE void copy_or_blend_pix(value_type* p, 
+    AGG_INLINE void copy_or_blend_pix(value_type* p, const color_type& c)
-                                          const color_type& c)
     {
         if (c.a)
         {
@@ -228,11 +216,10 @@ namespace agg
         }
     }
 
-
   public:
     //--------------------------------------------------------------------
-        explicit pixfmt_alpha_blend_rgb(rbuf_type& rb) :
+    explicit pixfmt_alpha_blend_rgb(rbuf_type& rb)
-            m_rbuf(&rb)
+        : m_rbuf(&rb)
     {}
     void attach(rbuf_type& rb) { m_rbuf = &rb; }
 
@@ -244,10 +231,7 @@ namespace agg
         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), 
+            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);
-                               (r.x2 - r.x1) + 1,
-                               (r.y2 - r.y1) + 1,
-                               stride);
             return true;
         }
         return false;
@@ -267,15 +251,9 @@ namespace agg
     AGG_INLINE row_data row(int y) const { return m_rbuf->row(y); }
 
     //--------------------------------------------------------------------
-        AGG_INLINE int8u* pix_ptr(int x, int y) 
+    AGG_INLINE int8u* pix_ptr(int x, int y) { return m_rbuf->row_ptr(y) + x * pix_width; }
-        { 
-            return m_rbuf->row_ptr(y) + x * pix_width; 
-        }
 
-        AGG_INLINE const int8u* pix_ptr(int x, int y) const 
+    AGG_INLINE const int8u* pix_ptr(int x, int y) const { return m_rbuf->row_ptr(y) + x * pix_width; }
-        { 
-            return m_rbuf->row_ptr(y) + x * pix_width; 
-        }
 
     //--------------------------------------------------------------------
     AGG_INLINE static void make_pix(int8u* p, const color_type& c)
@@ -289,9 +267,7 @@ namespace agg
     AGG_INLINE color_type pixel(int x, int y) const
     {
         value_type* p = (value_type*)m_rbuf->row_ptr(y) + x + x + x;
-            return color_type(p[order_type::R], 
+        return color_type(p[order_type::R], p[order_type::G], p[order_type::B]);
-                              p[order_type::G], 
-                              p[order_type::B]);
     }
 
     //--------------------------------------------------------------------
@@ -309,11 +285,8 @@ namespace agg
         copy_or_blend_pix((value_type*)m_rbuf->row_ptr(x, y, 1) + x + x + x, c, cover);
     }
 
-
     //--------------------------------------------------------------------
-        AGG_INLINE void copy_hline(int x, int y, 
+    AGG_INLINE void copy_hline(int x, int y, unsigned len, const color_type& c)
-                                   unsigned len, 
-                                   const color_type& c)
     {
         value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + x + x + x;
         do
@@ -322,38 +295,27 @@ namespace agg
             p[order_type::G] = c.g;
             p[order_type::B] = c.b;
             p += 3;
+        } while (--len);
     }
-            while(--len);
-        }
-
 
     //--------------------------------------------------------------------
-        AGG_INLINE void copy_vline(int x, int y,
+    AGG_INLINE void copy_vline(int x, int y, unsigned len, const color_type& c)
-                                   unsigned len, 
-                                   const color_type& c)
     {
         do
         {
-                value_type* p = (value_type*)
+            value_type* p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + x + x + x;
-                    m_rbuf->row_ptr(x, y++, 1) + x + x + x;
             p[order_type::R] = c.r;
             p[order_type::G] = c.g;
             p[order_type::B] = c.b;
+        } while (--len);
     }
-            while(--len);
-        }
-
 
     //--------------------------------------------------------------------
-        void blend_hline(int x, int y,
+    void blend_hline(int x, int y, unsigned len, const color_type& c, int8u cover)
-                         unsigned len, 
-                         const color_type& c,
-                         int8u cover)
     {
         if (c.a)
         {
-                value_type* p = (value_type*)
+            value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + x + x + x;
-                    m_rbuf->row_ptr(x, y, len) + x + x + x;
 
             calc_type alpha = (calc_type(c.a) * (calc_type(cover) + 1)) >> 8;
             if (alpha == base_mask)
@@ -364,8 +326,7 @@ namespace agg
                     p[order_type::G] = c.g;
                     p[order_type::B] = c.b;
                     p += 3;
-                    }
+                } while (--len);
-                    while(--len);
             }
             else
             {
@@ -373,18 +334,13 @@ namespace agg
                 {
                     m_blender.blend_pix(p, c.r, c.g, c.b, alpha, cover);
                     p += 3;
-                    }
+                } while (--len);
-                    while(--len);
             }
         }
     }
 
-
     //--------------------------------------------------------------------
-        void blend_vline(int x, int y,
+    void blend_vline(int x, int y, unsigned len, const color_type& c, int8u cover)
-                         unsigned len, 
-                         const color_type& c,
-                         int8u cover)
     {
         if (c.a)
         {
@@ -394,40 +350,31 @@ namespace agg
             {
                 do
                 {
-                        p = (value_type*)
+                    p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + x + x + x;
-                            m_rbuf->row_ptr(x, y++, 1) + x + x + x;
 
                     p[order_type::R] = c.r;
                     p[order_type::G] = c.g;
                     p[order_type::B] = c.b;
-                    }
+                } while (--len);
-                    while(--len);
             }
             else
             {
                 do
                 {
-                        p = (value_type*)
+                    p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + x + x + x;
-                            m_rbuf->row_ptr(x, y++, 1) + x + x + x;
 
                     m_blender.blend_pix(p, c.r, c.g, c.b, alpha, cover);
-                    }
+                } while (--len);
-                    while(--len);
             }
         }
     }
 
-
     //--------------------------------------------------------------------
-        void blend_solid_hspan(int x, int y,
+    void blend_solid_hspan(int x, int y, unsigned len, const color_type& c, const int8u* covers)
-                               unsigned len, 
-                               const color_type& c,
-                               const int8u* covers)
     {
         if (c.a)
         {
-                value_type* p = (value_type*)
+            value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + x + x + x;
-                    m_rbuf->row_ptr(x, y, len) + x + x + x;
 
             do
             {
@@ -444,24 +391,18 @@ namespace agg
                 }
                 p += 3;
                 ++covers;
-                }
+            } while (--len);
-                while(--len);
         }
     }
 
-
     //--------------------------------------------------------------------
-        void blend_solid_vspan(int x, int y,
+    void blend_solid_vspan(int x, int y, unsigned len, const color_type& c, const int8u* covers)
-                               unsigned len, 
-                               const color_type& c,
-                               const int8u* covers)
     {
         if (c.a)
         {
             do
             {
-                    value_type* p = (value_type*)
+                value_type* p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + x + x + x;
-                        m_rbuf->row_ptr(x, y++, 1) + x + x + x;
 
                 calc_type alpha = (calc_type(c.a) * (calc_type(*covers) + 1)) >> 8;
                 if (alpha == base_mask)
@@ -475,19 +416,14 @@ namespace agg
                     m_blender.blend_pix(p, c.r, c.g, c.b, alpha, *covers);
                 }
                 ++covers;
-                }
+            } while (--len);
-                while(--len);
         }
     }
 
-
     //--------------------------------------------------------------------
-        void copy_color_hspan(int x, int y,
+    void copy_color_hspan(int x, int y, unsigned len, const color_type* colors)
-                              unsigned len, 
-                              const color_type* colors)
     {
-            value_type* p = (value_type*)
+        value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + x + x + x;
-                m_rbuf->row_ptr(x, y, len) + x + x + x;
 
         do
         {
@@ -496,38 +432,26 @@ namespace agg
             p[order_type::B] = colors->b;
             ++colors;
             p += 3;
+        } while (--len);
     }
-            while(--len);
-        }
-
 
     //--------------------------------------------------------------------
-        void copy_color_vspan(int x, int y,
+    void copy_color_vspan(int x, int y, unsigned len, const color_type* colors)
-                              unsigned len, 
-                              const color_type* colors)
     {
         do
         {
-                value_type* p = (value_type*)
+            value_type* p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + x + x + x;
-                    m_rbuf->row_ptr(x, y++, 1) + x + x + x;
             p[order_type::R] = colors->r;
             p[order_type::G] = colors->g;
             p[order_type::B] = colors->b;
             ++colors;
+        } while (--len);
     }
-            while(--len);
-        }
-
 
     //--------------------------------------------------------------------
-        void blend_color_hspan(int x, int y,
+    void blend_color_hspan(int x, int y, unsigned len, const color_type* colors, const int8u* covers, int8u cover)
-                               unsigned len, 
-                               const color_type* colors,
-                               const int8u* covers,
-                               int8u cover)
     {
-            value_type* p = (value_type*)
+        value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + x + x + x;
-                m_rbuf->row_ptr(x, y, len) + x + x + x;
 
         if (covers)
         {
@@ -535,8 +459,7 @@ namespace agg
             {
                 copy_or_blend_pix(p, *colors++, *covers++);
                 p += 3;
-                }
+            } while (--len);
-                while(--len);
         }
         else
         {
@@ -546,8 +469,7 @@ namespace agg
                 {
                     copy_or_blend_pix(p, *colors++);
                     p += 3;
-                    }
+                } while (--len);
-                    while(--len);
             }
             else
             {
@@ -555,32 +477,23 @@ namespace agg
                 {
                     copy_or_blend_pix(p, *colors++, cover);
                     p += 3;
-                    }
+                } while (--len);
-                    while(--len);
             }
         }
     }
 
-
-
     //--------------------------------------------------------------------
-        void blend_color_vspan(int x, int y,
+    void blend_color_vspan(int x, int y, unsigned len, const color_type* colors, const int8u* covers, int8u cover)
-                               unsigned len, 
-                               const color_type* colors,
-                               const int8u* covers,
-                               int8u cover)
     {
         value_type* p;
         if (covers)
         {
             do
             {
-                    p = (value_type*)
+                p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + x + x + x;
-                        m_rbuf->row_ptr(x, y++, 1) + x + x + x;
 
                 copy_or_blend_pix(p, *colors++, *covers++);
-                }
+            } while (--len);
-                while(--len);
         }
         else
         {
@@ -588,29 +501,26 @@ namespace agg
             {
                 do
                 {
-                        p = (value_type*)
+                    p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + x + x + x;
-                            m_rbuf->row_ptr(x, y++, 1) + x + x + x;
 
                     copy_or_blend_pix(p, *colors++);
-                    }
+                } while (--len);
-                    while(--len);
             }
             else
             {
                 do
                 {
-                        p = (value_type*)
+                    p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + x + x + x;
-                            m_rbuf->row_ptr(x, y++, 1) + x + x + x;
 
                     copy_or_blend_pix(p, *colors++, cover);
-                    }
+                } while (--len);
-                    while(--len);
             }
         }
     }
 
     //--------------------------------------------------------------------
-        template<class Function> void for_each_pixel(Function f)
+    template<class Function>
+    void for_each_pixel(Function f)
     {
         unsigned y;
         for (y = 0; y < height(); ++y)
@@ -619,54 +529,45 @@ namespace agg
             if (r.ptr)
             {
                 unsigned len = r.x2 - r.x1 + 1;
-                    value_type* p = (value_type*)
+                value_type* p = (value_type*)m_rbuf->row_ptr(r.x1, y, len) + r.x1 * 3;
-                        m_rbuf->row_ptr(r.x1, y, len) + r.x1 * 3;
                 do
                 {
                     f(p);
                     p += 3;
-                    }
+                } while (--len);
-                    while(--len);
             }
         }
     }
 
     //--------------------------------------------------------------------
-        template<class GammaLut> void apply_gamma_dir(const GammaLut& g)
+    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)
+    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, 
+    void copy_from(const RenBuf2& from, int xdst, int ydst, int xsrc, int ysrc, unsigned len)
-                       int xdst, int ydst,
-                       int xsrc, int ysrc,
-                       unsigned len)
     {
         const int8u* p = from.row_ptr(ysrc);
         if (p)
         {
-                memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width, 
+            memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width, p + xsrc * pix_width, len * pix_width);
-                        p + xsrc * pix_width, 
-                        len * pix_width);
         }
     }
 
-
     //--------------------------------------------------------------------
     template<class SrcPixelFormatRenderer>
-        void blend_from(const SrcPixelFormatRenderer& from, 
+    void
-                        int xdst, int ydst,
+      blend_from(const SrcPixelFormatRenderer& from, int xdst, int ydst, int xsrc, int ysrc, unsigned len, int8u cover)
-                        int xsrc, int ysrc,
-                        unsigned len,
-                        int8u cover)
     {
         typedef typename SrcPixelFormatRenderer::order_type src_order;
 
@@ -674,8 +575,7 @@ namespace agg
         if (psrc)
         {
             psrc += xsrc * 4;
-                value_type* pdst = 
+            value_type* pdst = (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;
-                    (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;   
 
             if (cover == 255)
             {
@@ -701,8 +601,7 @@ namespace agg
                     }
                     psrc += 4;
                     pdst += 3;
-                    }
+                } while (--len);
-                    while(--len);
             }
             else
             {
@@ -716,8 +615,7 @@ namespace agg
                     copy_or_blend_pix(pdst, color, cover);
                     psrc += 4;
                     pdst += 3;
-                    }
+                } while (--len);
-                    while(--len);
             }
         }
     }
@@ -726,8 +624,10 @@ namespace agg
     template<class SrcPixelFormatRenderer>
     void blend_from_color(const SrcPixelFormatRenderer& from,
                           const color_type& color,
-                              int xdst, int ydst,
+                          int xdst,
-                              int xsrc, int ysrc,
+                          int ydst,
+                          int xsrc,
+                          int ysrc,
                           unsigned len,
                           int8u cover)
     {
@@ -735,17 +635,13 @@ namespace agg
         const src_value_type* psrc = (src_value_type*)from.row_ptr(ysrc);
         if (psrc)
         {
-                value_type* pdst = 
+            value_type* pdst = (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;
-                    (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;
             do
             {
-                    copy_or_blend_pix(pdst, 
+                copy_or_blend_pix(pdst, color, (*psrc * cover + base_mask) >> base_shift);
-                                      color, 
-                                      (*psrc * cover + base_mask) >> base_shift);
                 ++psrc;
                 pdst += 3;
-                }
+            } while (--len);
-                while(--len);
         }
     }
 
@@ -753,8 +649,10 @@ namespace agg
     template<class SrcPixelFormatRenderer>
     void blend_from_lut(const SrcPixelFormatRenderer& from,
                         const color_type* color_lut,
-                            int xdst, int ydst,
+                        int xdst,
-                            int xsrc, int ysrc,
+                        int ydst,
+                        int xsrc,
+                        int ysrc,
                         unsigned len,
                         int8u cover)
     {
@@ -762,20 +660,17 @@ namespace agg
         const src_value_type* psrc = (src_value_type*)from.row_ptr(ysrc);
         if (psrc)
         {
-                value_type* pdst = 
+            value_type* pdst = (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;
-                    (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;
 
             if (cover == 255)
             {
                 do
                 {
                     const color_type& color = color_lut[*psrc];
-                        m_blender.blend_pix(pdst, 
+                    m_blender.blend_pix(pdst, color.r, color.g, color.b, color.a);
-                                            color.r, color.g, color.b, color.a);
                     ++psrc;
                     pdst += 3;
-                    }
+                } while (--len);
-                    while(--len);
             }
             else
             {
@@ -784,8 +679,7 @@ namespace agg
                     copy_or_blend_pix(pdst, color_lut[*psrc], cover);
                     ++psrc;
                     pdst += 3;
-                    }
+                } while (--len);
-                    while(--len);
             }
         }
     }
@@ -800,61 +694,63 @@ namespace agg
 typedef pixfmt_alpha_blend_rgb<blender_rgb<rgba16, order_rgb>, rendering_buffer> pixfmt_rgb48; //----pixfmt_rgb48
 typedef pixfmt_alpha_blend_rgb<blender_rgb<rgba16, order_bgr>, rendering_buffer> pixfmt_bgr48; //----pixfmt_bgr48
 
-    typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba8,  order_rgb>, rendering_buffer> pixfmt_rgb24_pre; //----pixfmt_rgb24_pre
+typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba8, order_rgb>, rendering_buffer>
-    typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba8,  order_bgr>, rendering_buffer> pixfmt_bgr24_pre; //----pixfmt_bgr24_pre
+  pixfmt_rgb24_pre; //----pixfmt_rgb24_pre
-    typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba16, order_rgb>, rendering_buffer> pixfmt_rgb48_pre; //----pixfmt_rgb48_pre
+typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba8, order_bgr>, rendering_buffer>
-    typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba16, order_bgr>, rendering_buffer> pixfmt_bgr48_pre; //----pixfmt_bgr48_pre
+  pixfmt_bgr24_pre; //----pixfmt_bgr24_pre
+typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba16, order_rgb>, rendering_buffer>
+  pixfmt_rgb48_pre; //----pixfmt_rgb48_pre
+typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba16, order_bgr>, rendering_buffer>
+  pixfmt_bgr48_pre; //----pixfmt_bgr48_pre
 
 //-----------------------------------------------------pixfmt_rgb24_gamma
-    template<class Gamma> class pixfmt_rgb24_gamma : 
+template<class Gamma>
-    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_rgb, Gamma>, rendering_buffer>
+class pixfmt_rgb24_gamma : public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_rgb, Gamma>, rendering_buffer>
 {
   public:
-        pixfmt_rgb24_gamma(rendering_buffer& rb, const Gamma& g) :
+    pixfmt_rgb24_gamma(rendering_buffer& rb, const Gamma& g)
-            pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_rgb, Gamma>, rendering_buffer>(rb) 
+        : pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_rgb, Gamma>, rendering_buffer>(rb)
     {
         this->blender().gamma(g);
     }
 };
 
 //-----------------------------------------------------pixfmt_bgr24_gamma
-    template<class Gamma> class pixfmt_bgr24_gamma : 
+template<class Gamma>
-    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_bgr, Gamma>, rendering_buffer>
+class pixfmt_bgr24_gamma : public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_bgr, Gamma>, rendering_buffer>
 {
   public:
-        pixfmt_bgr24_gamma(rendering_buffer& rb, const Gamma& g) :
+    pixfmt_bgr24_gamma(rendering_buffer& rb, const Gamma& g)
-            pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_bgr, Gamma>, rendering_buffer>(rb) 
+        : pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_bgr, Gamma>, rendering_buffer>(rb)
     {
         this->blender().gamma(g);
     }
 };
 
 //-----------------------------------------------------pixfmt_rgb48_gamma
-    template<class Gamma> class pixfmt_rgb48_gamma : 
+template<class Gamma>
-    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_rgb, Gamma>, rendering_buffer>
+class pixfmt_rgb48_gamma : public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_rgb, Gamma>, rendering_buffer>
 {
   public:
-        pixfmt_rgb48_gamma(rendering_buffer& rb, const Gamma& g) :
+    pixfmt_rgb48_gamma(rendering_buffer& rb, const Gamma& g)
-            pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_rgb, Gamma>, rendering_buffer>(rb) 
+        : pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_rgb, Gamma>, rendering_buffer>(rb)
     {
         this->blender().gamma(g);
     }
 };
 
 //-----------------------------------------------------pixfmt_bgr48_gamma
-    template<class Gamma> class pixfmt_bgr48_gamma : 
+template<class Gamma>
-    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_bgr, Gamma>, rendering_buffer>
+class pixfmt_bgr48_gamma : public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_bgr, Gamma>, rendering_buffer>
 {
   public:
-        pixfmt_bgr48_gamma(rendering_buffer& rb, const Gamma& g) :
+    pixfmt_bgr48_gamma(rendering_buffer& rb, const Gamma& g)
-            pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_bgr, Gamma>, rendering_buffer>(rb) 
+        : pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_bgr, Gamma>, rendering_buffer>(rb)
     {
         this->blender().gamma(g);
     }
 };
 
-
+} // namespace agg
-}
 
 #endif
-

deps/agg/include/agg_pixfmt_transposer.h

@@ -18,10 +18,10 @@
 
 #include "agg_basics.h"
 
-namespace agg
+namespace agg {
-{
 //=======================================================pixfmt_transposer
-    template<class PixFmt> class pixfmt_transposer
+template<class PixFmt>
+class pixfmt_transposer
 {
   public:
     typedef PixFmt pixfmt_type;
@@ -31,8 +31,12 @@ namespace agg
     typedef typename color_type::calc_type calc_type;
 
     //--------------------------------------------------------------------
-        pixfmt_transposer() : m_pixf(0) {}
+    pixfmt_transposer()
-        explicit pixfmt_transposer(pixfmt_type& pixf) : m_pixf(&pixf) {}
+        : m_pixf(0)
+    {}
+    explicit pixfmt_transposer(pixfmt_type& pixf)
+        : m_pixf(&pixf)
+    {}
     void attach(pixfmt_type& pixf) { m_pixf = &pixf; }
 
     //--------------------------------------------------------------------
@@ -40,109 +44,66 @@ namespace agg
     AGG_INLINE unsigned height() const { return m_pixf->width(); }
 
     //--------------------------------------------------------------------
-        AGG_INLINE color_type pixel(int x, int y) const
+    AGG_INLINE color_type pixel(int x, int y) const { return m_pixf->pixel(y, x); }
-        {
-            return m_pixf->pixel(y, x);
-        }
 
     //--------------------------------------------------------------------
-        AGG_INLINE void copy_pixel(int x, int y, const color_type& c)
+    AGG_INLINE void copy_pixel(int x, int y, const color_type& c) { m_pixf->copy_pixel(y, x, c); }
-        {
-            m_pixf->copy_pixel(y, x, c);
-        }
 
     //--------------------------------------------------------------------
-        AGG_INLINE void blend_pixel(int x, int y, 
+    AGG_INLINE void blend_pixel(int x, int y, const color_type& c, int8u cover) { m_pixf->blend_pixel(y, x, c, cover); }
-                                    const color_type& c, 
-                                    int8u cover)
-        {
-            m_pixf->blend_pixel(y, x, c, cover);
-        }
 
     //--------------------------------------------------------------------
-        AGG_INLINE void copy_hline(int x, int y, 
+    AGG_INLINE void copy_hline(int x, int y, unsigned len, const color_type& c) { m_pixf->copy_vline(y, x, len, c); }
-                                   unsigned len, 
-                                   const color_type& c)
-        {
-            m_pixf->copy_vline(y, x, len, c);
-        }
 
     //--------------------------------------------------------------------
-        AGG_INLINE void copy_vline(int x, int y,
+    AGG_INLINE void copy_vline(int x, int y, unsigned len, const color_type& c) { m_pixf->copy_hline(y, x, len, c); }
-                                   unsigned len, 
-                                   const color_type& c)
-        {
-            m_pixf->copy_hline(y, x, len, c);
-        }
 
     //--------------------------------------------------------------------
-        AGG_INLINE void blend_hline(int x, int y,
+    AGG_INLINE void blend_hline(int x, int y, unsigned len, const color_type& c, int8u cover)
-                                    unsigned len, 
-                                    const color_type& c,
-                                    int8u cover)
     {
         m_pixf->blend_vline(y, x, len, c, cover);
     }
 
     //--------------------------------------------------------------------
-        AGG_INLINE void blend_vline(int x, int y,
+    AGG_INLINE void blend_vline(int x, int y, unsigned len, const color_type& c, int8u cover)
-                                    unsigned len, 
-                                    const color_type& c,
-                                    int8u cover)
     {
         m_pixf->blend_hline(y, x, len, c, cover);
     }
 
     //--------------------------------------------------------------------
-        AGG_INLINE void blend_solid_hspan(int x, int y,
+    AGG_INLINE void blend_solid_hspan(int x, int y, unsigned len, const color_type& c, const int8u* covers)
-                                          unsigned len, 
-                                          const color_type& c,
-                                          const int8u* covers)
     {
         m_pixf->blend_solid_vspan(y, x, len, c, covers);
     }
 
     //--------------------------------------------------------------------
-        AGG_INLINE void blend_solid_vspan(int x, int y,
+    AGG_INLINE void blend_solid_vspan(int x, int y, unsigned len, const color_type& c, const int8u* covers)
-                                          unsigned len, 
-                                          const color_type& c,
-                                          const int8u* covers)
     {
         m_pixf->blend_solid_hspan(y, x, len, c, covers);
     }
 
     //--------------------------------------------------------------------
-        AGG_INLINE void copy_color_hspan(int x, int y,
+    AGG_INLINE void copy_color_hspan(int x, int y, unsigned len, const color_type* colors)
-                                         unsigned len, 
-                                         const color_type* colors)
     {
         m_pixf->copy_color_vspan(y, x, len, colors);
     }
 
     //--------------------------------------------------------------------
-        AGG_INLINE void copy_color_vspan(int x, int y,
+    AGG_INLINE void copy_color_vspan(int x, int y, unsigned len, const color_type* colors)
-                                         unsigned len, 
-                                         const color_type* colors)
     {
         m_pixf->copy_color_hspan(y, x, len, colors);
     }
 
     //--------------------------------------------------------------------
-        AGG_INLINE void blend_color_hspan(int x, int y,
+    AGG_INLINE void
-                                          unsigned len, 
+      blend_color_hspan(int x, int y, unsigned len, const color_type* colors, const int8u* covers, int8u cover)
-                                          const color_type* colors,
-                                          const int8u* covers,
-                                          int8u cover)
     {
         m_pixf->blend_color_vspan(y, x, len, colors, covers, cover);
     }
 
     //--------------------------------------------------------------------
-        AGG_INLINE void blend_color_vspan(int x, int y,
+    AGG_INLINE void
-                               unsigned len, 
+      blend_color_vspan(int x, int y, unsigned len, const color_type* colors, const int8u* covers, int8u cover)
-                               const color_type* colors,
-                               const int8u* covers,
-                               int8u cover)
     {
         m_pixf->blend_color_hspan(y, x, len, colors, covers, cover);
     }
@@ -150,8 +111,6 @@ namespace agg
   private:
     pixfmt_type* m_pixf;
 };
-}
+} // namespace agg
 
 #endif
-
-

deps/agg/include/agg_rasterizer_cells_aa.h

@@ -35,17 +35,15 @@
 #include "agg_math.h"
 #include "agg_array.h"
 
-
+namespace agg {
-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
+template<class Cell>
-    {
+class rasterizer_cells_aa
-        enum cell_block_scale_e
 {
+    enum cell_block_scale_e {
         cell_block_shift = 12,
         cell_block_size = 1 << cell_block_shift,
         cell_block_mask = cell_block_size - 1,
@@ -77,15 +75,9 @@ namespace agg
 
     void sort_cells();
 
-        unsigned total_cells() const 
+    unsigned total_cells() const { return m_num_cells; }
-        {
-            return m_num_cells;
-        }
 
-        unsigned scanline_num_cells(unsigned y) const 
+    unsigned scanline_num_cells(unsigned y) const { return m_sorted_y[y - m_min_y].num; }
-        { 
-            return m_sorted_y[y - m_min_y].num; 
-        }
 
     const cell_type* const* scanline_cells(unsigned y) const
     {
@@ -121,9 +113,6 @@ namespace agg
     bool m_sorted;
 };
 
-
-
-
 //------------------------------------------------------------------------
 template<class Cell>
 rasterizer_cells_aa<Cell>::~rasterizer_cells_aa()
@@ -143,20 +132,20 @@ namespace agg
 
 //------------------------------------------------------------------------
 template<class Cell>
-    rasterizer_cells_aa<Cell>::rasterizer_cells_aa() :
+rasterizer_cells_aa<Cell>::rasterizer_cells_aa()
-        m_num_blocks(0),
+    : m_num_blocks(0)
-        m_max_blocks(0),
+    , m_max_blocks(0)
-        m_curr_block(0),
+    , m_curr_block(0)
-        m_num_cells(0),
+    , m_num_cells(0)
-        m_cells(0),
+    , m_cells(0)
-        m_curr_cell_ptr(0),
+    , m_curr_cell_ptr(0)
-        m_sorted_cells(),
+    , m_sorted_cells()
-        m_sorted_y(),
+    , m_sorted_y()
-        m_min_x(0x7FFFFFFF),
+    , m_min_x(0x7FFFFFFF)
-        m_min_y(0x7FFFFFFF),
+    , m_min_y(0x7FFFFFFF)
-        m_max_x(-0x7FFFFFFF),
+    , m_max_x(-0x7FFFFFFF)
-        m_max_y(-0x7FFFFFFF),
+    , m_max_y(-0x7FFFFFFF)
-        m_sorted(false)
+    , m_sorted(false)
 {
     m_style_cell.initial();
     m_curr_cell.initial();
@@ -185,7 +174,8 @@ namespace agg
     {
         if ((m_num_cells & cell_block_mask) == 0)
         {
-                if(m_num_blocks >= cell_block_limit) return;
+            if (m_num_blocks >= cell_block_limit)
+                return;
             allocate_block();
         }
         *m_curr_cell_ptr++ = m_curr_cell;
@@ -210,9 +200,7 @@ namespace agg
 
 //------------------------------------------------------------------------
 template<class Cell>
-    AGG_INLINE void rasterizer_cells_aa<Cell>::render_hline(int ey, 
+AGG_INLINE void rasterizer_cells_aa<Cell>::render_hline(int ey, int x1, int y1, int x2, int y2)
-                                                            int x1, int y1, 
-                                                            int x2, int y2)
 {
     int ex1 = x1 >> poly_subpixel_shift;
     int ex2 = x2 >> poly_subpixel_shift;
@@ -327,8 +315,10 @@ namespace agg
         int cy = (y1 + y2) >> 1;
 
         // Bail if values are so large they are likely to wrap
-            if ((std::abs(x1) >= std::numeric_limits<int>::max()/2) || (std::abs(y1) >= std::numeric_limits<int>::max()/2) ||
+        if ((std::abs(x1) >= std::numeric_limits<int>::max() / 2) ||
-                (std::abs(x2) >= std::numeric_limits<int>::max()/2) || (std::abs(y2) >= std::numeric_limits<int>::max()/2))
+            (std::abs(y1) >= std::numeric_limits<int>::max() / 2) ||
+            (std::abs(x2) >= std::numeric_limits<int>::max() / 2) ||
+            (std::abs(y2) >= std::numeric_limits<int>::max() / 2))
             return;
 
         line(x1, y1, cx, cy);
@@ -346,14 +336,22 @@ namespace agg
     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_min_x)
-        if(ex1 > m_max_x) m_max_x = ex1;
+        m_min_x = ex1;
-        if(ey1 < m_min_y) m_min_y = ey1;
+    if (ex1 > m_max_x)
-        if(ey1 > m_max_y) m_max_y = ey1;
+        m_max_x = ex1;
-        if(ex2 < m_min_x) m_min_x = ex2;
+    if (ey1 < m_min_y)
-        if(ex2 > m_max_x) m_max_x = ex2;
+        m_min_y = ey1;
-        if(ey2 < m_min_y) m_min_y = ey2;
+    if (ey1 > m_max_y)
-        if(ey2 > m_max_y) m_max_y = ey2;
+        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);
 
@@ -478,9 +476,7 @@ namespace agg
     {
         if (m_num_blocks >= m_max_blocks)
         {
-                cell_type** new_cells = 
+            cell_type** new_cells = pod_allocator<cell_type*>::allocate(m_max_blocks + cell_block_pool);
-                    pod_allocator<cell_type*>::allocate(m_max_blocks + 
-                                                        cell_block_pool);
 
             if (m_cells)
             {
@@ -491,30 +487,22 @@ namespace agg
             m_max_blocks += cell_block_pool;
         }
 
-            m_cells[m_num_blocks++] = 
+        m_cells[m_num_blocks++] = pod_allocator<cell_type>::allocate(cell_block_size);
-                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)
+template<class T>
+static AGG_INLINE void swap_cells(T* a, T* b)
 {
     T temp = *a;
     *a = *b;
     *b = temp;
 }
 
-
 //------------------------------------------------------------------------
-    enum
+enum { qsort_threshold = 9 };
-    {
-        qsort_threshold = 9
-    };
-
 
 //------------------------------------------------------------------------
 template<class Cell>
@@ -565,8 +553,12 @@ namespace agg
             for (;;)
             {
                 int x = (*base)->x;
-                    do i++; while( (*i)->x < x );
+                do
-                    do j--; while( x < (*j)->x );
+                    i++;
+                while ((*i)->x < x);
+                do
+                    j--;
+                while (x < (*j)->x);
 
                 if (i > j)
                 {
@@ -625,12 +617,12 @@ namespace agg
     }
 }
 
-
 //------------------------------------------------------------------------
 template<class Cell>
 void rasterizer_cells_aa<Cell>::sort_cells()
 {
-        if(m_sorted) return; //Perform sort only the first time.
+    if (m_sorted)
+        return; // Perform sort only the first time.
 
     add_curr_cell();
     m_curr_cell.x = 0x7FFFFFFF;
@@ -638,7 +630,8 @@ namespace agg
     m_curr_cell.cover = 0;
     m_curr_cell.area = 0;
 
-        if(m_num_cells == 0) return;
+    if (m_num_cells == 0)
+        return;
 
     // DBG: Check to see if min/max works well.
     // for(unsigned nc = 0; nc < m_num_cells; nc++)
@@ -736,23 +729,26 @@ namespace agg
     m_sorted = true;
 }
 
-
-
 //------------------------------------------------------scanline_hit_test
 class scanline_hit_test
 {
   public:
-        scanline_hit_test(int x) : m_x(x), m_hit(false) {}
+    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;
+        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;
+        if (m_x >= x && m_x < x + len)
+            m_hit = true;
     }
     unsigned num_spans() const { return 1; }
     bool hit() const { return m_hit; }
@@ -762,7 +758,6 @@ namespace agg
     bool m_hit;
 };
 
-
+} // namespace agg
-}
 
 #endif

deps/agg/include/agg_rasterizer_compound_aa.h

@@ -32,8 +32,7 @@
 #include "agg_rasterizer_cells_aa.h"
 #include "agg_rasterizer_sl_clip.h"
 
-namespace agg
+namespace agg {
-{
 
 //-----------------------------------------------------------cell_style_aa
 // A pixel cell. There're no constructors defined and it was done
@@ -69,18 +68,16 @@ namespace agg
     }
 };
 
-
 //===========================================================layer_order_e
-    enum layer_order_e
+enum layer_order_e {
-    {
     layer_unsorted, //------layer_unsorted
     layer_direct,   //------layer_direct
     layer_inverse   //------layer_inverse
 };
 
-
 //==================================================rasterizer_compound_aa
-    template<class Clip=rasterizer_sl_clip_int> class rasterizer_compound_aa
+template<class Clip = rasterizer_sl_clip_int>
+class rasterizer_compound_aa
 {
     struct style_info
     {
@@ -99,8 +96,7 @@ namespace agg
     typedef typename Clip::conv_type conv_type;
     typedef typename Clip::coord_type coord_type;
 
-        enum aa_scale_e
+    enum aa_scale_e {
-        {
         aa_shift = 8,
         aa_scale = 1 << aa_shift,
         aa_mask = aa_scale - 1,
@@ -109,24 +105,27 @@ namespace agg
     };
 
     //--------------------------------------------------------------------
-        rasterizer_compound_aa() : 
+    rasterizer_compound_aa()
-            m_outline(),
+        : m_outline()
-            m_clipper(),
+        , m_clipper()
-            m_filling_rule(fill_non_zero),
+        , m_filling_rule(fill_non_zero)
-            m_layer_order(layer_direct),
+        , m_layer_order(layer_direct)
-            m_styles(),  // Active Styles
+        , m_styles()
-            m_ast(),     // Active Style Table (unique values)
+        , // Active Styles
-            m_asm(),     // Active Style Mask 
+        m_ast()
-            m_cells(),
+        , // Active Style Table (unique values)
-            m_cover_buf(),
+        m_asm()
-            m_master_alpha(),
+        , // Active Style Mask
-            m_min_style(0x7FFFFFFF),
+        m_cells()
-            m_max_style(-0x7FFFFFFF),
+        , m_cover_buf()
-            m_start_x(0),
+        , m_master_alpha()
-            m_start_y(0),
+        , m_min_style(0x7FFFFFFF)
-            m_scan_y(0x7FFFFFFF),
+        , m_max_style(-0x7FFFFFFF)
-            m_sl_start(0),
+        , m_start_x(0)
-            m_sl_len(0)
+        , m_start_y(0)
+        , m_scan_y(0x7FFFFFFF)
+        , m_sl_start(0)
+        , m_sl_len(0)
     {}
 
     //--------------------------------------------------------------------
@@ -157,14 +156,14 @@ namespace agg
 
         unsigned cmd;
         vs.rewind(path_id);
-            if(m_outline.sorted()) reset();
+        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(); }
@@ -191,7 +190,8 @@ namespace agg
     AGG_INLINE unsigned calculate_alpha(int area, unsigned master_alpha) const
     {
         int cover = area >> (poly_subpixel_shift * 2 + 1 - aa_shift);
-            if(cover < 0) cover = -cover;
+        if (cover < 0)
+            cover = -cover;
         if (m_filling_rule == fill_even_odd)
         {
             cover &= aa_mask2;
@@ -200,17 +200,20 @@ namespace agg
                 cover = aa_scale2 - cover;
             }
         }
-            if(cover > aa_mask) cover = aa_mask;
+        if (cover > aa_mask)
+            cover = aa_mask;
         return (cover * master_alpha + aa_mask) >> aa_shift;
     }
 
     //--------------------------------------------------------------------
     // Sweeps one scanline with one style index. The style ID can be
     // determined by calling style().
-        template<class Scanline> bool sweep_scanline(Scanline& sl, int style_idx)
+    template<class Scanline>
+    bool sweep_scanline(Scanline& sl, int style_idx)
     {
         int scan_y = m_scan_y - 1;
-            if(scan_y > m_outline.max_y()) return false;
+        if (scan_y > m_outline.max_y())
+            return false;
 
         sl.reset_spans();
 
@@ -244,16 +247,14 @@ namespace agg
 
             if (area)
             {
-                    alpha = calculate_alpha((cover << (poly_subpixel_shift + 1)) - area,
+                alpha = calculate_alpha((cover << (poly_subpixel_shift + 1)) - area, master_alpha);
-                                            master_alpha);
                 sl.add_cell(x, alpha);
                 x++;
             }
 
             if (num_cells && cell->x > x)
             {
-                    alpha = calculate_alpha(cover << (poly_subpixel_shift + 1),
+                alpha = calculate_alpha(cover << (poly_subpixel_shift + 1), master_alpha);
-                                            master_alpha);
                 if (alpha)
                 {
                     sl.add_span(x, cell->x - x, alpha);
@@ -261,7 +262,8 @@ namespace agg
             }
         }
 
-            if(sl.num_spans() == 0) return false;
+        if (sl.num_spans() == 0)
+            return false;
         sl.finalize(scan_y);
         return true;
     }
@@ -273,8 +275,7 @@ namespace agg
     //--------------------------------------------------------------------
     // Disable copying
     rasterizer_compound_aa(const rasterizer_compound_aa<Clip>&);
-        const rasterizer_compound_aa<Clip>& 
+    const rasterizer_compound_aa<Clip>& operator=(const rasterizer_compound_aa<Clip>&);
-        operator = (const rasterizer_compound_aa<Clip>&);
 
   private:
     rasterizer_cells_aa<cell_style_aa> m_outline;
@@ -297,15 +298,6 @@ namespace agg
     unsigned m_sl_len;
 };
 
-
-
-
-
-
-
-
-
-
 //------------------------------------------------------------------------
 template<class Clip>
 void rasterizer_compound_aa<Clip>::reset()
@@ -334,12 +326,10 @@ namespace agg
 
 //------------------------------------------------------------------------
 template<class Clip>
-    void rasterizer_compound_aa<Clip>::clip_box(double x1, double y1, 
+void rasterizer_compound_aa<Clip>::clip_box(double x1, double y1, double x2, double y2)
-                                                double x2, double y2)
 {
     reset();
-        m_clipper.clip_box(conv_type::upscale(x1), conv_type::upscale(y1), 
+    m_clipper.clip_box(conv_type::upscale(x1), conv_type::upscale(y1), conv_type::upscale(x2), conv_type::upscale(y2));
-                           conv_type::upscale(x2), conv_type::upscale(y2));
 }
 
 //------------------------------------------------------------------------
@@ -359,46 +349,46 @@ namespace agg
     cell.left = (int16)left;
     cell.right = (int16)right;
     m_outline.style(cell);
-        if(left  >= 0 && left  < m_min_style) m_min_style = left;
+    if (left >= 0 && left < m_min_style)
-        if(left  >= 0 && left  > m_max_style) m_max_style = left;
+        m_min_style = left;
-        if(right >= 0 && right < m_min_style) m_min_style = right;
+    if (left >= 0 && left > m_max_style)
-        if(right >= 0 && right > m_max_style) m_max_style = right;
+        m_max_style = left;
+    if (right >= 0 && right < m_min_style)
+        m_min_style = right;
+    if (right >= 0 && right > m_max_style)
+        m_max_style = right;
 }
 
 //------------------------------------------------------------------------
 template<class Clip>
 void rasterizer_compound_aa<Clip>::move_to(int x, int y)
 {
-        if(m_outline.sorted()) reset();
+    if (m_outline.sorted())
-        m_clipper.move_to(m_start_x = conv_type::downscale(x), 
+        reset();
-                          m_start_y = conv_type::downscale(y));
+    m_clipper.move_to(m_start_x = conv_type::downscale(x), m_start_y = conv_type::downscale(y));
 }
 
 //------------------------------------------------------------------------
 template<class Clip>
 void rasterizer_compound_aa<Clip>::line_to(int x, int y)
 {
-        m_clipper.line_to(m_outline, 
+    m_clipper.line_to(m_outline, conv_type::downscale(x), conv_type::downscale(y));
-                          conv_type::downscale(x), 
-                          conv_type::downscale(y));
 }
 
 //------------------------------------------------------------------------
 template<class Clip>
 void rasterizer_compound_aa<Clip>::move_to_d(double x, double y)
 {
-        if(m_outline.sorted()) reset();
+    if (m_outline.sorted())
-        m_clipper.move_to(m_start_x = conv_type::upscale(x), 
+        reset();
-                          m_start_y = conv_type::upscale(y)); 
+    m_clipper.move_to(m_start_x = conv_type::upscale(x), m_start_y = conv_type::upscale(y));
 }
 
 //------------------------------------------------------------------------
 template<class Clip>
 void rasterizer_compound_aa<Clip>::line_to_d(double x, double y)
 {
-        m_clipper.line_to(m_outline, 
+    m_clipper.line_to(m_outline, conv_type::upscale(x), conv_type::upscale(y));
-                          conv_type::upscale(x), 
-                          conv_type::upscale(y)); 
 }
 
 //------------------------------------------------------------------------
@@ -409,13 +399,11 @@ namespace agg
     {
         move_to_d(x, y);
     }
-        else 
+    else if (is_vertex(cmd))
-        if(is_vertex(cmd))
     {
         line_to_d(x, y);
     }
-        else
+    else if (is_close(cmd))
-        if(is_close(cmd))
     {
         m_clipper.line_to(m_outline, m_start_x, m_start_y);
     }
@@ -425,23 +413,20 @@ namespace agg
 template<class Clip>
 void rasterizer_compound_aa<Clip>::edge(int x1, int y1, int x2, int y2)
 {
-        if(m_outline.sorted()) reset();
+    if (m_outline.sorted())
+        reset();
     m_clipper.move_to(conv_type::downscale(x1), conv_type::downscale(y1));
-        m_clipper.line_to(m_outline, 
+    m_clipper.line_to(m_outline, conv_type::downscale(x2), conv_type::downscale(y2));
-                          conv_type::downscale(x2), 
-                          conv_type::downscale(y2));
 }
 
 //------------------------------------------------------------------------
 template<class Clip>
-    void rasterizer_compound_aa<Clip>::edge_d(double x1, double y1, 
+void rasterizer_compound_aa<Clip>::edge_d(double x1, double y1, double x2, double y2)
-                                              double x2, double y2)
 {
-        if(m_outline.sorted()) reset();
+    if (m_outline.sorted())
+        reset();
     m_clipper.move_to(conv_type::upscale(x1), conv_type::upscale(y1));
-        m_clipper.line_to(m_outline, 
+    m_clipper.line_to(m_outline, conv_type::upscale(x2), conv_type::upscale(y2));
-                          conv_type::upscale(x2), 
-                          conv_type::upscale(y2)); 
 }
 
 //------------------------------------------------------------------------
@@ -474,8 +459,10 @@ namespace agg
 template<class Clip>
 AGG_INLINE void rasterizer_compound_aa<Clip>::add_style(int style_id)
 {
-        if(style_id < 0) style_id  = 0;
+    if (style_id < 0)
-        else             style_id -= m_min_style - 1;
+        style_id = 0;
+    else
+        style_id -= m_min_style - 1;
 
     unsigned nbyte = style_id >> 3;
     unsigned mask = 1 << (style_id & 7);
@@ -499,7 +486,8 @@ namespace agg
 {
     for (;;)
     {
-            if(m_scan_y > m_outline.max_y()) return 0;
+        if (m_scan_y > m_outline.max_y())
+            return 0;
         unsigned num_cells = m_outline.scanline_num_cells(m_scan_y);
         const cell_style_aa* const* cells = m_outline.scanline_cells(m_scan_y);
         unsigned num_styles = m_max_style - m_min_style + 2;
@@ -550,8 +538,7 @@ namespace agg
             while (num_cells--)
             {
                 curr_cell = *cells++;
-                    style_id = (curr_cell->left < 0) ? 0 : 
+                style_id = (curr_cell->left < 0) ? 0 : curr_cell->left - m_min_style + 1;
-                                curr_cell->left - m_min_style + 1;
 
                 style = &m_styles[style_id];
                 if (curr_cell->x == style->last_x)
@@ -570,8 +557,7 @@ namespace agg
                     style->num_cells++;
                 }
 
-                    style_id = (curr_cell->right < 0) ? 0 : 
+                style_id = (curr_cell->right < 0) ? 0 : curr_cell->right - m_min_style + 1;
-                                curr_cell->right - m_min_style + 1;
 
                 style = &m_styles[style_id];
                 if (curr_cell->x == style->last_x)
@@ -591,7 +577,8 @@ namespace agg
                 }
             }
         }
-            if(m_ast.size() > 1) break;
+        if (m_ast.size() > 1)
+            break;
         ++m_scan_y;
     }
     ++m_scan_y;
@@ -599,8 +586,10 @@ namespace agg
     if (m_layer_order != layer_unsorted)
     {
         range_adaptor<pod_vector<unsigned>> ra(m_ast, 1, m_ast.size() - 1);
-            if(m_layer_order == layer_direct) quick_sort(ra, unsigned_greater);
+        if (m_layer_order == layer_direct)
-            else                              quick_sort(ra, unsigned_less);
+            quick_sort(ra, unsigned_greater);
+        else
+            quick_sort(ra, unsigned_less);
     }
 
     return m_ast.size() - 1;
@@ -609,8 +598,7 @@ namespace agg
 //------------------------------------------------------------------------
 // Returns style ID depending of the existing style index
 template<class Clip>
-    AGG_INLINE 
+AGG_INLINE unsigned rasterizer_compound_aa<Clip>::style(unsigned style_idx) const
-    unsigned rasterizer_compound_aa<Clip>::style(unsigned style_idx) const
 {
     return m_ast[style_idx + 1] + m_min_style - 1;
 }
@@ -690,9 +678,6 @@ namespace agg
     }
 }
 
-}
+} // namespace agg
-
-
 
 #endif
-

deps/agg/include/agg_rasterizer_outline.h

@@ -17,21 +17,20 @@
 
 #include "agg_basics.h"
 
-namespace agg
+namespace agg {
-{
 //======================================================rasterizer_outline
-    template<class Renderer> class rasterizer_outline
+template<class Renderer>
+class rasterizer_outline
 {
   public:
-        explicit rasterizer_outline(Renderer& ren) : 
+    explicit rasterizer_outline(Renderer& ren)
-            m_ren(&ren), 
+        : m_ren(&ren)
-            m_start_x(0), 
+        , m_start_x(0)
-            m_start_y(0), 
+        , m_start_y(0)
-            m_vertices(0)
+        , m_vertices(0)
     {}
     void attach(Renderer& ren) { m_ren = &ren; }
 
-
     //--------------------------------------------------------------------
     void move_to(int x, int y)
     {
@@ -47,16 +46,10 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        void move_to_d(double x, double y)
+    void move_to_d(double x, double y) { move_to(m_ren->coord(x), m_ren->coord(y)); }
-        {
-            move_to(m_ren->coord(x), m_ren->coord(y));
-        }
 
     //--------------------------------------------------------------------
-        void line_to_d(double x, double y)
+    void line_to_d(double x, double y) { line_to(m_ren->coord(x), m_ren->coord(y)); }
-        {
-            line_to(m_ren->coord(x), m_ren->coord(y));
-        }
 
     //--------------------------------------------------------------------
     void close()
@@ -79,7 +72,8 @@ namespace agg
         {
             if (is_end_poly(cmd))
             {
-                    if(is_closed(cmd)) close();
+                if (is_closed(cmd))
+                    close();
             }
             else
             {
@@ -88,7 +82,6 @@ namespace agg
         }
     }
 
-
     //--------------------------------------------------------------------
     template<class VertexSource>
     void add_path(VertexSource& vs, unsigned path_id = 0)
@@ -104,13 +97,9 @@ namespace agg
         }
     }
 
-
     //--------------------------------------------------------------------
     template<class VertexSource, class ColorStorage, class PathId>
-        void render_all_paths(VertexSource& vs, 
+    void render_all_paths(VertexSource& vs, const ColorStorage& colors, const PathId& path_id, unsigned num_paths)
-                              const ColorStorage& colors, 
-                              const PathId& path_id,
-                              unsigned num_paths)
     {
         for (unsigned i = 0; i < num_paths; i++)
         {
@@ -119,9 +108,9 @@ namespace agg
         }
     }
 
-
     //--------------------------------------------------------------------
-        template<class Ctrl> void render_ctrl(Ctrl& c)
+    template<class Ctrl>
+    void render_ctrl(Ctrl& c)
     {
         unsigned i;
         for (i = 0; i < c.num_paths(); i++)
@@ -131,7 +120,6 @@ namespace agg
         }
     }
 
-
   private:
     Renderer* m_ren;
     int m_start_x;
@@ -139,9 +127,6 @@ namespace agg
     unsigned m_vertices;
 };
 
-
+} // namespace agg
-}
-
 
 #endif
-

deps/agg/include/agg_rasterizer_outline_aa.h

@@ -19,14 +19,17 @@
 #include "agg_line_aa_basics.h"
 #include "agg_vertex_sequence.h"
 
-namespace agg
+namespace agg {
-{
 
 //-------------------------------------------------------------------------
-    inline bool cmp_dist_start(int d) { return d > 0;  }
+inline bool cmp_dist_start(int d)
-    inline bool cmp_dist_end(int d)   { return d <= 0; }
+{
-
+    return d > 0;
-
+}
+inline bool cmp_dist_end(int d)
+{
+    return d <= 0;
+}
 
 //-----------------------------------------------------------line_aa_vertex
 // Vertex (x, y) with the distance to the next one. The last vertex has
@@ -38,26 +41,22 @@ namespace agg
     int len;
 
     line_aa_vertex() {}
-        line_aa_vertex(int x_, int y_) :
+    line_aa_vertex(int x_, int y_)
-            x(x_),
+        : x(x_)
-            y(y_),
+        , y(y_)
-            len(0)
+        , len(0)
-        {
+    {}
-        }
 
     bool operator()(const line_aa_vertex& val)
     {
         double dx = val.x - x;
         double dy = val.y - y;
-            return (len = uround(sqrt(dx * dx + dy * dy))) > 
+        return (len = uround(sqrt(dx * dx + dy * dy))) > (line_subpixel_scale + line_subpixel_scale / 2);
-                   (line_subpixel_scale + line_subpixel_scale / 2);
     }
 };
 
-
 //----------------------------------------------------------outline_aa_join_e
-    enum outline_aa_join_e
+enum outline_aa_join_e {
-    {
     outline_no_join,            //-----outline_no_join
     outline_miter_join,         //-----outline_miter_join
     outline_round_join,         //-----outline_round_join
@@ -65,7 +64,8 @@ namespace agg
 };
 
 //=======================================================rasterizer_outline_aa
-    template<class Renderer, class Coord=line_coord> class rasterizer_outline_aa
+template<class Renderer, class Coord = line_coord>
+class rasterizer_outline_aa
 {
   private:
     //------------------------------------------------------------------------
@@ -85,23 +85,19 @@ namespace agg
     typedef line_aa_vertex vertex_type;
     typedef vertex_sequence<vertex_type, 6> vertex_storage_type;
 
-        explicit rasterizer_outline_aa(Renderer& ren) : 
+    explicit rasterizer_outline_aa(Renderer& ren)
-            m_ren(&ren), 
+        : m_ren(&ren)
-            m_line_join(ren.accurate_join_only() ? 
+        , m_line_join(ren.accurate_join_only() ? outline_miter_accurate_join : outline_round_join)
-                            outline_miter_accurate_join : 
+        , m_round_cap(false)
-                            outline_round_join),
+        , m_start_x(0)
-            m_round_cap(false),
+        , m_start_y(0)
-            m_start_x(0),
-            m_start_y(0)
     {}
     void attach(Renderer& ren) { m_ren = &ren; }
 
     //------------------------------------------------------------------------
     void line_join(outline_aa_join_e join)
     {
-            m_line_join = m_ren->accurate_join_only() ? 
+        m_line_join = m_ren->accurate_join_only() ? outline_miter_accurate_join : join;
-                outline_miter_accurate_join : 
-                join; 
     }
     bool line_join() const { return m_line_join; }
 
@@ -110,28 +106,16 @@ namespace agg
     bool round_cap() const { return m_round_cap; }
 
     //------------------------------------------------------------------------
-        void move_to(int x, int y)
+    void move_to(int x, int y) { m_src_vertices.modify_last(vertex_type(m_start_x = x, m_start_y = y)); }
-        {
-            m_src_vertices.modify_last(vertex_type(m_start_x = x, m_start_y = y));
-        }
 
     //------------------------------------------------------------------------
-        void line_to(int x, int y)
+    void line_to(int x, int y) { m_src_vertices.add(vertex_type(x, y)); }
-        {
-            m_src_vertices.add(vertex_type(x, y));
-        }
 
     //------------------------------------------------------------------------
-        void move_to_d(double x, double y)
+    void move_to_d(double x, double y) { move_to(Coord::conv(x), Coord::conv(y)); }
-        {
-            move_to(Coord::conv(x), Coord::conv(y));
-        }
 
     //------------------------------------------------------------------------
-        void line_to_d(double x, double y)
+    void line_to_d(double x, double y) { line_to(Coord::conv(x), Coord::conv(y)); }
-        {
-            line_to(Coord::conv(x), Coord::conv(y));
-        }
 
     //------------------------------------------------------------------------
     void render(bool close_polygon);
@@ -177,13 +161,9 @@ namespace agg
         render(false);
     }
 
-
     //------------------------------------------------------------------------
     template<class VertexSource, class ColorStorage, class PathId>
-        void render_all_paths(VertexSource& vs, 
+    void render_all_paths(VertexSource& vs, const ColorStorage& colors, const PathId& path_id, unsigned num_paths)
-                              const ColorStorage& colors, 
-                              const PathId& path_id,
-                              unsigned num_paths)
     {
         for (unsigned i = 0; i < num_paths; i++)
         {
@@ -192,9 +172,9 @@ namespace agg
         }
     }
 
-
     //------------------------------------------------------------------------
-        template<class Ctrl> void render_ctrl(Ctrl& c)
+    template<class Ctrl>
+    void render_ctrl(Ctrl& c)
     {
         unsigned i;
         for (i = 0; i < c.num_paths(); i++)
@@ -206,8 +186,7 @@ namespace agg
 
   private:
     rasterizer_outline_aa(const rasterizer_outline_aa<Renderer, Coord>&);
-        const rasterizer_outline_aa<Renderer, Coord>& operator = 
+    const rasterizer_outline_aa<Renderer, Coord>& operator=(const rasterizer_outline_aa<Renderer, Coord>&);
-            (const rasterizer_outline_aa<Renderer, Coord>&);
 
     Renderer* m_ren;
     vertex_storage_type m_src_vertices;
@@ -217,18 +196,9 @@ namespace agg
     int m_start_y;
 };
 
-
-
-
-
-
-
-
 //----------------------------------------------------------------------------
 template<class Renderer, class Coord>
-    void rasterizer_outline_aa<Renderer, Coord>::draw(draw_vars& dv, 
+void rasterizer_outline_aa<Renderer, Coord>::draw(draw_vars& dv, unsigned start, unsigned end)
-                                                      unsigned start, 
-                                                      unsigned end)
 {
     unsigned i;
     const vertex_storage_type::value_type* v;
@@ -245,15 +215,24 @@ namespace agg
 
         switch (dv.flags)
         {
-            case 0: m_ren->line3(dv.curr, dv.xb1, dv.yb1, dv.xb2, dv.yb2); break;
+            case 0:
-            case 1: m_ren->line2(dv.curr, dv.xb2, dv.yb2); break;
+                m_ren->line3(dv.curr, dv.xb1, dv.yb1, dv.xb2, dv.yb2);
-            case 2: m_ren->line1(dv.curr, dv.xb1, dv.yb1); break;
+                break;
-            case 3: m_ren->line0(dv.curr); break;
+            case 1:
+                m_ren->line2(dv.curr, dv.xb2, dv.yb2);
+                break;
+            case 2:
+                m_ren->line1(dv.curr, dv.xb1, dv.yb1);
+                break;
+            case 3:
+                m_ren->line0(dv.curr);
+                break;
         }
 
         if (m_line_join == outline_round_join && (dv.flags & 2) == 0)
         {
-                m_ren->pie(dv.curr.x2, dv.curr.y2, 
+            m_ren->pie(dv.curr.x2,
+                       dv.curr.y2,
                        dv.curr.x2 + (dv.curr.y2 - dv.curr.y1),
                        dv.curr.y2 - (dv.curr.x2 - dv.curr.x1),
                        dv.curr.x2 + (dv.next.y2 - dv.next.y1),
@@ -266,7 +245,8 @@ namespace agg
         dv.lnext = m_src_vertices[dv.idx].len;
 
         ++dv.idx;
-            if(dv.idx >= m_src_vertices.size()) dv.idx = 0; 
+        if (dv.idx >= m_src_vertices.size())
+            dv.idx = 0;
 
         v = &m_src_vertices[dv.idx];
         dv.x2 = v->x;
@@ -285,8 +265,7 @@ namespace agg
 
             case outline_miter_join:
                 dv.flags >>= 1;
-                dv.flags |= ((dv.curr.diagonal_quadrant() == 
+                dv.flags |= ((dv.curr.diagonal_quadrant() == dv.next.diagonal_quadrant()) << 1);
-                              dv.next.diagonal_quadrant()) << 1);
                 if ((dv.flags & 2) == 0)
                 {
                     bisectrix(dv.curr, dv.next, &dv.xb2, &dv.yb2);
@@ -295,8 +274,7 @@ namespace agg
 
             case outline_round_join:
                 dv.flags >>= 1;
-                dv.flags |= ((dv.curr.diagonal_quadrant() == 
+                dv.flags |= ((dv.curr.diagonal_quadrant() == dv.next.diagonal_quadrant()) << 1);
-                              dv.next.diagonal_quadrant()) << 1);
                 break;
 
             case outline_miter_accurate_join:
@@ -307,9 +285,6 @@ namespace agg
     }
 }
 
-
-
-
 //----------------------------------------------------------------------------
 template<class Renderer, class Coord>
 void rasterizer_outline_aa<Renderer, Coord>::render(bool close_polygon)
@@ -362,8 +337,7 @@ namespace agg
 
             case outline_miter_join:
             case outline_round_join:
-                dv.flags = 
+                dv.flags = (prev.diagonal_quadrant() == dv.curr.diagonal_quadrant()) |
-                        (prev.diagonal_quadrant() == dv.curr.diagonal_quadrant()) |
                            ((dv.curr.diagonal_quadrant() == dv.next.diagonal_quadrant()) << 1);
                 break;
 
@@ -391,8 +365,7 @@ namespace agg
             case 1:
                 break;
 
-                case 2:
+            case 2: {
-                {
                 v = &m_src_vertices[0];
                 x1 = v->x;
                 y1 = v->y;
@@ -405,11 +378,7 @@ namespace agg
                 {
                     m_ren->semidot(cmp_dist_start, x1, y1, x1 + (y2 - y1), y1 - (x2 - x1));
                 }
-                    m_ren->line3(lp, 
+                m_ren->line3(lp, x1 + (y2 - y1), y1 - (x2 - x1), x2 + (y2 - y1), y2 - (x2 - x1));
-                                 x1 + (y2 - y1), 
-                                 y1 - (x2 - x1),
-                                 x2 + (y2 - y1), 
-                                 y2 - (x2 - x1));
                 if (m_round_cap)
                 {
                     m_ren->semidot(cmp_dist_end, x2, y2, x2 + (y2 - y1), y2 - (x2 - x1));
@@ -417,8 +386,7 @@ namespace agg
             }
             break;
 
-                case 3:
+            case 3: {
-                {
                 int x3, y3;
                 int lnext;
                 v = &m_src_vertices[0];
@@ -442,23 +410,18 @@ namespace agg
 
                 if (m_line_join == outline_round_join)
                 {
-                        m_ren->line3(lp1, x1 + (y2 - y1), y1 - (x2 - x1), 
+                    m_ren->line3(lp1, x1 + (y2 - y1), y1 - (x2 - x1), x2 + (y2 - y1), y2 - (x2 - x1));
-                                          x2 + (y2 - y1), y2 - (x2 - x1));
 
-                        m_ren->pie(x2, y2, x2 + (y2 - y1), y2 - (x2 - x1),
+                    m_ren->pie(x2, y2, x2 + (y2 - y1), y2 - (x2 - x1), x2 + (y3 - y2), y2 - (x3 - x2));
-                                           x2 + (y3 - y2), y2 - (x3 - x2));
 
-                        m_ren->line3(lp2, x2 + (y3 - y2), y2 - (x3 - x2),
+                    m_ren->line3(lp2, x2 + (y3 - y2), y2 - (x3 - x2), x3 + (y3 - y2), y3 - (x3 - x2));
-                                          x3 + (y3 - y2), y3 - (x3 - x2));
                 }
                 else
                 {
                     bisectrix(lp1, lp2, &dv.xb1, &dv.yb1);
-                        m_ren->line3(lp1, x1 + (y2 - y1), y1 - (x2 - x1),
+                    m_ren->line3(lp1, x1 + (y2 - y1), y1 - (x2 - x1), dv.xb1, dv.yb1);
-                                          dv.xb1,         dv.yb1);
 
-                        m_ren->line3(lp2, dv.xb1,         dv.yb1,
+                    m_ren->line3(lp2, dv.xb1, dv.yb1, x3 + (y3 - y2), y3 - (x3 - x2));
-                                          x3 + (y3 - y2), y3 - (x3 - x2));
                 }
                 if (m_round_cap)
                 {
@@ -467,8 +430,7 @@ namespace agg
             }
             break;
 
-                default:
+            default: {
-                {
                 dv.idx = 3;
 
                 v = &m_src_vertices[0];
@@ -506,8 +468,7 @@ namespace agg
 
                     case outline_miter_join:
                     case outline_round_join:
-                        dv.flags = 
+                        dv.flags = (prev.diagonal_quadrant() == dv.curr.diagonal_quadrant()) |
-                                (prev.diagonal_quadrant() == dv.curr.diagonal_quadrant()) |
                                    ((dv.curr.diagonal_quadrant() == dv.next.diagonal_quadrant()) << 1);
                         break;
 
@@ -524,25 +485,23 @@ namespace agg
                 {
                     if (m_line_join == outline_round_join)
                     {
-                            m_ren->line3(prev, x1 + (y2 - y1), y1 - (x2 - x1),
+                        m_ren->line3(prev, x1 + (y2 - y1), y1 - (x2 - x1), x2 + (y2 - y1), y2 - (x2 - x1));
-                                               x2 + (y2 - y1), y2 - (x2 - x1));
+                        m_ren->pie(prev.x2,
-                            m_ren->pie(prev.x2, prev.y2, 
+                                   prev.y2,
-                                       x2 + (y2 - y1), y2 - (x2 - x1),
+                                   x2 + (y2 - y1),
+                                   y2 - (x2 - x1),
                                    dv.curr.x1 + (dv.curr.y2 - dv.curr.y1),
                                    dv.curr.y1 - (dv.curr.x2 - dv.curr.x1));
                     }
                     else
                     {
                         bisectrix(prev, dv.curr, &dv.xb1, &dv.yb1);
-                            m_ren->line3(prev, x1 + (y2 - y1), y1 - (x2 - x1),
+                        m_ren->line3(prev, x1 + (y2 - y1), y1 - (x2 - x1), dv.xb1, dv.yb1);
-                                               dv.xb1,         dv.yb1);
                     }
                 }
                 else
                 {
-                        m_ren->line1(prev, 
+                    m_ren->line1(prev, x1 + (y2 - y1), y1 - (x2 - x1));
-                                     x1 + (y2 - y1), 
-                                     y1 - (x2 - x1));
                 }
                 if ((dv.flags & 2) == 0 && m_line_join != outline_round_join)
                 {
@@ -563,7 +522,9 @@ namespace agg
                     }
                     else
                     {
-                            m_ren->line3(dv.curr, dv.xb1, dv.yb1,
+                        m_ren->line3(dv.curr,
+                                     dv.xb1,
+                                     dv.yb1,
                                      dv.curr.x2 + (dv.curr.y2 - dv.curr.y1),
                                      dv.curr.y2 - (dv.curr.x2 - dv.curr.x1));
                     }
@@ -576,11 +537,12 @@ namespace agg
                 }
                 if (m_round_cap)
                 {
-                        m_ren->semidot(cmp_dist_end, dv.curr.x2, dv.curr.y2,
+                    m_ren->semidot(cmp_dist_end,
+                                   dv.curr.x2,
+                                   dv.curr.y2,
                                    dv.curr.x2 + (dv.curr.y2 - dv.curr.y1),
                                    dv.curr.y2 - (dv.curr.x2 - dv.curr.x1));
                 }
-
             }
             break;
         }
@@ -588,9 +550,6 @@ namespace agg
     m_src_vertices.remove_all();
 }
 
-
+} // namespace agg
-}
-
 
 #endif
-

deps/agg/include/agg_rasterizer_scanline_aa.h

@@ -33,10 +33,7 @@
 #include "agg_rasterizer_sl_clip.h"
 #include "agg_gamma_functions.h"
 
-
+namespace agg {
-namespace agg
-{
-
 
 //-----------------------------------------------------------------cell_aa
 // A pixel cell. There're no constructors defined and it was done
@@ -59,13 +56,9 @@ namespace agg
 
     void style(const cell_aa&) {}
 
-        int not_equal(int ex, int ey, const cell_aa&) const
+    int not_equal(int ex, int ey, const cell_aa&) const { return (ex - x) | (ey - y); }
-        {
-            return (ex - x) | (ey - y);
-        }
 };
 
-
 //==================================================rasterizer_scanline_aa
 // Polygon rasterizer that is used to render filled polygons with
 // high-quality Anti-Aliasing. Internally, by default, the class uses
@@ -97,23 +90,17 @@ namespace agg
 //
 // filling_rule() and gamma() can be called anytime before "sweeping".
 //------------------------------------------------------------------------
-    template<class Clip=rasterizer_sl_clip_int> class rasterizer_scanline_aa
+template<class Clip = rasterizer_sl_clip_int>
+class rasterizer_scanline_aa
 {
-        enum status
+    enum status { status_initial, status_move_to, status_line_to, status_closed };
-        {
-            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
+    enum aa_scale_e {
-        {
         aa_shift = 8,
         aa_scale = 1 << aa_shift,
         aa_mask = aa_scale - 1,
@@ -122,29 +109,30 @@ namespace agg
     };
 
     //--------------------------------------------------------------------
-        rasterizer_scanline_aa() :
+    rasterizer_scanline_aa()
-            m_outline(),
+        : m_outline()
-            m_clipper(),
+        , m_clipper()
-            m_filling_rule(fill_non_zero),
+        , m_filling_rule(fill_non_zero)
-            m_auto_close(true),
+        , m_auto_close(true)
-            m_start_x(0),
+        , m_start_x(0)
-            m_start_y(0),
+        , m_start_y(0)
-            m_status(status_initial)
+        , m_status(status_initial)
     {
         int i;
-            for(i = 0; i < aa_scale; i++) m_gamma[i] = i;
+        for (i = 0; i < aa_scale; i++)
+            m_gamma[i] = i;
     }
 
     //--------------------------------------------------------------------
     template<class GammaF>
-        rasterizer_scanline_aa(const GammaF& gamma_function) :
+    rasterizer_scanline_aa(const GammaF& gamma_function)
-            m_outline(),
+        : m_outline()
-            m_clipper(m_outline),
+        , m_clipper(m_outline)
-            m_filling_rule(fill_non_zero),
+        , m_filling_rule(fill_non_zero)
-            m_auto_close(true),
+        , m_auto_close(true)
-            m_start_x(0),
+        , m_start_x(0)
-            m_start_y(0),
+        , m_start_y(0)
-            m_status(status_initial)
+        , m_status(status_initial)
     {
         gamma(gamma_function);
     }
@@ -157,7 +145,8 @@ namespace agg
     void auto_close(bool flag) { m_auto_close = flag; }
 
     //--------------------------------------------------------------------
-        template<class GammaF> void gamma(const GammaF& gamma_function)
+    template<class GammaF>
+    void gamma(const GammaF& gamma_function)
     {
         int i;
         for (i = 0; i < aa_scale; i++)
@@ -167,10 +156,7 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        unsigned apply_gamma(unsigned cover) const
+    unsigned apply_gamma(unsigned cover) const { return m_gamma[cover]; }
-        {
-            return m_gamma[cover];
-        }
 
     //--------------------------------------------------------------------
     void move_to(int x, int y);
@@ -192,7 +178,8 @@ namespace agg
 
         unsigned cmd;
         vs.rewind(path_id);
-            if(m_outline.sorted()) reset();
+        if (m_outline.sorted())
+            reset();
         while (!is_stop(cmd = vs.vertex(&x, &y)))
         {
             add_vertex(x, y, cmd);
@@ -215,7 +202,8 @@ namespace agg
     {
         int cover = area >> (poly_subpixel_shift * 2 + 1 - aa_shift);
 
-            if(cover < 0) cover = -cover;
+        if (cover < 0)
+            cover = -cover;
         if (m_filling_rule == fill_even_odd)
         {
             cover &= aa_mask2;
@@ -224,16 +212,19 @@ namespace agg
                 cover = aa_scale2 - cover;
             }
         }
-            if(cover > aa_mask) cover = aa_mask;
+        if (cover > aa_mask)
+            cover = aa_mask;
         return m_gamma[cover];
     }
 
     //--------------------------------------------------------------------
-        template<class Scanline> bool sweep_scanline(Scanline& sl)
+    template<class Scanline>
+    bool sweep_scanline(Scanline& sl)
     {
         for (;;)
         {
-                if(m_scan_y > m_outline.max_y()) return false;
+            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);
@@ -252,7 +243,8 @@ namespace agg
                 while (--num_cells)
                 {
                     cur_cell = *++cells;
-                        if(cur_cell->x != x) break;
+                    if (cur_cell->x != x)
+                        break;
                     area += cur_cell->area;
                     cover += cur_cell->cover;
                 }
@@ -277,7 +269,8 @@ namespace agg
                 }
             }
 
-                if(sl.num_spans()) break;
+            if (sl.num_spans())
+                break;
             ++m_scan_y;
         }
 
@@ -289,13 +282,11 @@ namespace agg
     //--------------------------------------------------------------------
     bool hit_test(int tx, int ty);
 
-
   private:
     //--------------------------------------------------------------------
     // Disable copying
     rasterizer_scanline_aa(const rasterizer_scanline_aa<Clip>&);
-        const rasterizer_scanline_aa<Clip>&
+    const rasterizer_scanline_aa<Clip>& operator=(const rasterizer_scanline_aa<Clip>&);
-        operator = (const rasterizer_scanline_aa<Clip>&);
 
   private:
     rasterizer_cells_aa<cell_aa> m_outline;
@@ -309,17 +300,6 @@ namespace agg
     int m_scan_y;
 };
 
-
-
-
-
-
-
-
-
-
-
-
 //------------------------------------------------------------------------
 template<class Clip>
 void rasterizer_scanline_aa<Clip>::reset()
@@ -337,12 +317,10 @@ namespace agg
 
 //------------------------------------------------------------------------
 template<class Clip>
-    void rasterizer_scanline_aa<Clip>::clip_box(double x1, double y1,
+void rasterizer_scanline_aa<Clip>::clip_box(double x1, double y1, double x2, double y2)
-                                                double x2, double y2)
 {
     reset();
-        m_clipper.clip_box(conv_type::upscale(x1), conv_type::upscale(y1),
+    m_clipper.clip_box(conv_type::upscale(x1), conv_type::upscale(y1), conv_type::upscale(x2), conv_type::upscale(y2));
-                           conv_type::upscale(x2), conv_type::upscale(y2));
 }
 
 //------------------------------------------------------------------------
@@ -368,10 +346,11 @@ namespace agg
 template<class Clip>
 void rasterizer_scanline_aa<Clip>::move_to(int x, int y)
 {
-        if(m_outline.sorted()) reset();
+    if (m_outline.sorted())
-        if(m_auto_close) close_polygon();
+        reset();
-        m_clipper.move_to(m_start_x = conv_type::downscale(x),
+    if (m_auto_close)
-                          m_start_y = conv_type::downscale(y));
+        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;
 }
 
@@ -379,9 +358,7 @@ namespace agg
 template<class Clip>
 void rasterizer_scanline_aa<Clip>::line_to(int x, int y)
 {
-        m_clipper.line_to(m_outline,
+    m_clipper.line_to(m_outline, conv_type::downscale(x), conv_type::downscale(y));
-                          conv_type::downscale(x),
-                          conv_type::downscale(y));
     m_status = status_line_to;
 }
 
@@ -389,10 +366,11 @@ namespace agg
 template<class Clip>
 void rasterizer_scanline_aa<Clip>::move_to_d(double x, double y)
 {
-        if(m_outline.sorted()) reset();
+    if (m_outline.sorted())
-        if(m_auto_close) close_polygon();
+        reset();
-        m_clipper.move_to(m_start_x = conv_type::upscale(x),
+    if (m_auto_close)
-                          m_start_y = conv_type::upscale(y));
+        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;
 }
 
@@ -400,9 +378,7 @@ namespace agg
 template<class Clip>
 void rasterizer_scanline_aa<Clip>::line_to_d(double x, double y)
 {
-        m_clipper.line_to(m_outline,
+    m_clipper.line_to(m_outline, conv_type::upscale(x), conv_type::upscale(y));
-                          conv_type::upscale(x),
-                          conv_type::upscale(y));
     m_status = status_line_to;
 }
 
@@ -414,13 +390,11 @@ namespace agg
     {
         move_to_d(x, y);
     }
-        else
+    else if (is_vertex(cmd))
-        if(is_vertex(cmd))
     {
         line_to_d(x, y);
     }
-        else
+    else if (is_close(cmd))
-        if(is_close(cmd))
     {
         close_polygon();
     }
@@ -430,24 +404,21 @@ namespace agg
 template<class Clip>
 void rasterizer_scanline_aa<Clip>::edge(int x1, int y1, int x2, int y2)
 {
-        if(m_outline.sorted()) reset();
+    if (m_outline.sorted())
+        reset();
     m_clipper.move_to(conv_type::downscale(x1), conv_type::downscale(y1));
-        m_clipper.line_to(m_outline,
+    m_clipper.line_to(m_outline, conv_type::downscale(x2), conv_type::downscale(y2));
-                          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,
+void rasterizer_scanline_aa<Clip>::edge_d(double x1, double y1, double x2, double y2)
-                                              double x2, double y2)
 {
-        if(m_outline.sorted()) reset();
+    if (m_outline.sorted())
+        reset();
     m_clipper.move_to(conv_type::upscale(x1), conv_type::upscale(y1));
-        m_clipper.line_to(m_outline,
+    m_clipper.line_to(m_outline, conv_type::upscale(x2), conv_type::upscale(y2));
-                          conv_type::upscale(x2),
-                          conv_type::upscale(y2));
     m_status = status_move_to;
 }
 
@@ -455,7 +426,8 @@ namespace agg
 template<class Clip>
 void rasterizer_scanline_aa<Clip>::sort()
 {
-        if(m_auto_close) close_polygon();
+    if (m_auto_close)
+        close_polygon();
     m_outline.sort_cells();
 }
 
@@ -463,7 +435,8 @@ namespace agg
 template<class Clip>
 AGG_INLINE bool rasterizer_scanline_aa<Clip>::rewind_scanlines()
 {
-        if(m_auto_close) close_polygon();
+    if (m_auto_close)
+        close_polygon();
     m_outline.sort_cells();
     if (m_outline.total_cells() == 0)
     {
@@ -473,16 +446,14 @@ namespace agg
     return true;
 }
 
-
 //------------------------------------------------------------------------
 template<class Clip>
 AGG_INLINE bool rasterizer_scanline_aa<Clip>::navigate_scanline(int y)
 {
-        if(m_auto_close) close_polygon();
+    if (m_auto_close)
+        close_polygon();
     m_outline.sort_cells();
-        if(m_outline.total_cells() == 0 ||
+    if (m_outline.total_cells() == 0 || y < m_outline.min_y() || y > m_outline.max_y())
-           y < m_outline.min_y() ||
-           y > m_outline.max_y())
     {
         return false;
     }
@@ -494,16 +465,13 @@ namespace agg
 template<class Clip>
 bool rasterizer_scanline_aa<Clip>::hit_test(int tx, int ty)
 {
-        if(!navigate_scanline(ty)) return false;
+    if (!navigate_scanline(ty))
+        return false;
     scanline_hit_test sl(tx);
     sweep_scanline(sl);
     return sl.hit();
 }
 
-
+} // namespace agg
-
-}
-
-
 
 #endif

deps/agg/include/agg_rasterizer_sl_clip.h

@@ -17,11 +17,9 @@
 
 #include "agg_clip_liang_barsky.h"
 
-namespace agg
+namespace agg {
-{
 //--------------------------------------------------------poly_max_coord_e
-    enum poly_max_coord_e
+enum poly_max_coord_e {
-    {
     poly_max_coord = (1 << 30) - 1 //----poly_max_coord
 };
 
@@ -29,10 +27,7 @@ namespace agg
 struct ras_conv_int
 {
     typedef int coord_type;
-        static AGG_INLINE int mul_div(double a, double b, double c)
+    static AGG_INLINE int mul_div(double a, double b, double c) { return iround(a * b / 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); }
@@ -49,10 +44,7 @@ namespace agg
     }
     static int xi(int v) { return v; }
     static int yi(int v) { return v; }
-        static int upscale(double v) 
+    static int upscale(double v) { return saturation<poly_max_coord>::iround(v * poly_subpixel_scale); }
-        { 
-            return saturation<poly_max_coord>::iround(v * poly_subpixel_scale); 
-        }
     static int downscale(int v) { return v; }
 };
 
@@ -60,10 +52,7 @@ namespace agg
 struct ras_conv_int_3x
 {
     typedef int coord_type;
-        static AGG_INLINE int mul_div(double a, double b, double c)
+    static AGG_INLINE int mul_div(double a, double b, double c) { return iround(a * b / 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); }
@@ -74,10 +63,7 @@ namespace agg
 struct ras_conv_dbl
 {
     typedef double coord_type;
-        static AGG_INLINE double mul_div(double a, double b, double c)
+    static AGG_INLINE double mul_div(double a, double b, double c) { return a * b / 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; }
@@ -88,22 +74,16 @@ namespace agg
 struct ras_conv_dbl_3x
 {
     typedef double coord_type;
-        static AGG_INLINE double mul_div(double a, double b, double c)
+    static AGG_INLINE double mul_div(double a, double b, double c) { return a * b / 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
+template<class Conv>
+class rasterizer_sl_clip
 {
   public:
     typedef Conv conv_type;
@@ -111,19 +91,16 @@ namespace agg
     typedef rect_base<coord_type> rect_type;
 
     //--------------------------------------------------------------------
-        rasterizer_sl_clip() :  
+    rasterizer_sl_clip()
-            m_clip_box(0,0,0,0),
+        : m_clip_box(0, 0, 0, 0)
-            m_x1(0),
+        , m_x1(0)
-            m_y1(0),
+        , m_y1(0)
-            m_f1(0),
+        , m_f1(0)
-            m_clipping(false) 
+        , m_clipping(false)
     {}
 
     //--------------------------------------------------------------------
-        void reset_clipping()
+    void reset_clipping() { m_clipping = false; }
-        {
-            m_clipping = false;
-        }
 
     //--------------------------------------------------------------------
     void clip_box(coord_type x1, coord_type y1, coord_type x2, coord_type y2)
@@ -138,16 +115,16 @@ namespace agg
     {
         m_x1 = x1;
         m_y1 = y1;
-            if(m_clipping) m_f1 = clipping_flags(x1, y1, m_clip_box);
+        if (m_clipping)
+            m_f1 = clipping_flags(x1, y1, m_clip_box);
     }
 
   private:
     //------------------------------------------------------------------------
     template<class Rasterizer>
-        AGG_INLINE void line_clip_y(Rasterizer& ras,
+    AGG_INLINE void
-                                    coord_type x1, coord_type y1, 
+      line_clip_y(Rasterizer& ras, coord_type x1, coord_type y1, coord_type x2, coord_type y2, unsigned f1, unsigned f2)
-                                    coord_type x2, coord_type y2, 
+        const
-                                    unsigned   f1, unsigned   f2) const
     {
         f1 &= 10;
         f2 &= 10;
@@ -192,12 +169,10 @@ namespace agg
                 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), 
+            ras.line(Conv::xi(tx1), Conv::yi(ty1), Conv::xi(tx2), Conv::yi(ty2));
-                         Conv::xi(tx2), Conv::yi(ty2)); 
         }
     }
 
-
   public:
     //--------------------------------------------------------------------
     template<class Rasterizer>
@@ -288,14 +263,12 @@ namespace agg
         }
         else
         {
-                ras.line(Conv::xi(m_x1), Conv::yi(m_y1), 
+            ras.line(Conv::xi(m_x1), Conv::yi(m_y1), Conv::xi(x2), Conv::yi(y2));
-                         Conv::xi(x2),   Conv::yi(y2)); 
         }
         m_x1 = x2;
         m_y1 = y2;
     }
 
-
   private:
     rect_type m_clip_box;
     coord_type m_x1;
@@ -304,9 +277,6 @@ namespace agg
     bool m_clipping;
 };
 
-
-
-
 //---------------------------------------------------rasterizer_sl_no_clip
 class rasterizer_sl_no_clip
 {
@@ -314,11 +284,18 @@ namespace agg
     typedef ras_conv_int conv_type;
     typedef int coord_type;
 
-        rasterizer_sl_no_clip() : m_x1(0), m_y1(0) {}
+    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; }
+    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)
@@ -332,7 +309,6 @@ namespace agg
     int m_x1, m_y1;
 };
 
-
 //                                         -----rasterizer_sl_clip_int
 //                                         -----rasterizer_sl_clip_int_sat
 //                                         -----rasterizer_sl_clip_int_3x
@@ -345,7 +321,6 @@ namespace agg
 typedef rasterizer_sl_clip<ras_conv_dbl> rasterizer_sl_clip_dbl;
 typedef rasterizer_sl_clip<ras_conv_dbl_3x> rasterizer_sl_clip_dbl_3x;
 
-
+} // namespace agg
-}
 
 #endif

deps/agg/include/agg_renderer_base.h

@@ -23,11 +23,11 @@
 #include "agg_basics.h"
 #include "agg_rendering_buffer.h"
 
-namespace agg
+namespace agg {
-{
 
 //-----------------------------------------------------------renderer_base
-    template<class PixelFormat> class renderer_base
+template<class PixelFormat>
+class renderer_base
 {
   public:
     typedef PixelFormat pixfmt_type;
@@ -36,10 +36,13 @@ namespace agg
     typedef typename pixfmt_type::row_data row_data;
 
     //--------------------------------------------------------------------
-        renderer_base() : m_ren(0), m_clip_box(1, 1, 0, 0) {}
+    renderer_base()
-        explicit renderer_base(pixfmt_type& ren) :
+        : m_ren(0)
-            m_ren(&ren),
+        , m_clip_box(1, 1, 0, 0)
-            m_clip_box(0, 0, ren.width() - 1, ren.height() - 1)
+    {}
+    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)
     {
@@ -103,8 +106,7 @@ namespace agg
     //--------------------------------------------------------------------
     bool inbox(int x, int y) const
     {
-            return x >= m_clip_box.x1 && y >= m_clip_box.y1 &&
+        return x >= m_clip_box.x1 && y >= m_clip_box.y1 && x <= m_clip_box.x2 && y <= m_clip_box.y2;
-                   x <= m_clip_box.x2 && y <= m_clip_box.y2;
     }
 
     //--------------------------------------------------------------------
@@ -134,7 +136,6 @@ namespace agg
         }
     }
 
-
     //--------------------------------------------------------------------
     void copy_pixel(int x, int y, const color_type& c)
     {
@@ -154,24 +155,30 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        color_type pixel(int x, int y) const
+    color_type pixel(int x, int y) const { return inbox(x, y) ? m_ren->pixel(x, y) : color_type::no_color(); }
-        {
-            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 (x1 > x2)
-            if(y  > ymax()) return;
+        {
-            if(y  < ymin()) return;
+            int t = x2;
-            if(x1 > xmax()) return;
+            x2 = x1;
-            if(x2 < xmin()) return;
+            x1 = t;
+        }
+        if (y > ymax())
+            return;
+        if (y < ymin())
+            return;
+        if (x1 > xmax())
+            return;
+        if (x2 < xmin())
+            return;
 
-            if(x1 < xmin()) x1 = xmin();
+        if (x1 < xmin())
-            if(x2 > xmax()) x2 = xmax();
+            x1 = xmin();
+        if (x2 > xmax())
+            x2 = xmax();
 
         m_ren->copy_hline(x1, y, x2 - x1 + 1, c);
     }
@@ -179,51 +186,81 @@ namespace agg
     //--------------------------------------------------------------------
     void copy_vline(int x, int y1, int y2, const color_type& c)
     {
-            if(y1 > y2) { int t = y2; y2 = y1; y1 = t; }
+        if (y1 > y2)
-            if(x  > xmax()) return;
+        {
-            if(x  < xmin()) return;
+            int t = y2;
-            if(y1 > ymax()) return;
+            y2 = y1;
-            if(y2 < ymin()) return;
+            y1 = t;
+        }
+        if (x > xmax())
+            return;
+        if (x < xmin())
+            return;
+        if (y1 > ymax())
+            return;
+        if (y2 < ymin())
+            return;
 
-            if(y1 < ymin()) y1 = ymin();
+        if (y1 < ymin())
-            if(y2 > ymax()) y2 = ymax();
+            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,
+    void blend_hline(int x1, int y, int x2, const color_type& c, cover_type cover)
-                         const color_type& c, cover_type cover)
     {
-            if(x1 > x2) { int t = x2; x2 = x1; x1 = t; }
+        if (x1 > x2)
-            if(y  > ymax()) return;
+        {
-            if(y  < ymin()) return;
+            int t = x2;
-            if(x1 > xmax()) return;
+            x2 = x1;
-            if(x2 < xmin()) return;
+            x1 = t;
+        }
+        if (y > ymax())
+            return;
+        if (y < ymin())
+            return;
+        if (x1 > xmax())
+            return;
+        if (x2 < xmin())
+            return;
 
-            if(x1 < xmin()) x1 = xmin();
+        if (x1 < xmin())
-            if(x2 > xmax()) x2 = xmax();
+            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,
+    void blend_vline(int x, int y1, int y2, const color_type& c, cover_type cover)
-                         const color_type& c, cover_type cover)
     {
-            if(y1 > y2) { int t = y2; y2 = y1; y1 = t; }
+        if (y1 > y2)
-            if(x  > xmax()) return;
+        {
-            if(x  < xmin()) return;
+            int t = y2;
-            if(y1 > ymax()) return;
+            y2 = y1;
-            if(y2 < ymin()) return;
+            y1 = t;
+        }
+        if (x > xmax())
+            return;
+        if (x < xmin())
+            return;
+        if (y1 > ymax())
+            return;
+        if (y2 < ymin())
+            return;
 
-            if(y1 < ymin()) y1 = ymin();
+        if (y1 < ymin())
-            if(y2 > ymax()) y2 = ymax();
+            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)
     {
@@ -240,8 +277,7 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        void blend_bar(int x1, int y1, int x2, int y2,
+    void blend_bar(int x1, int y1, int x2, int y2, const color_type& c, cover_type cover)
-                       const color_type& c, cover_type cover)
     {
         rect_i rc(x1, y1, x2, y2);
         rc.normalize();
@@ -250,183 +286,209 @@ namespace agg
             int y;
             for (y = rc.y1; y <= rc.y2; y++)
             {
-                    m_ren->blend_hline(rc.x1,
+                m_ren->blend_hline(rc.x1, y, unsigned(rc.x2 - rc.x1 + 1), c, cover);
-                                       y,
-                                       unsigned(rc.x2 - rc.x1 + 1),
-                                       c,
-                                       cover);
             }
         }
     }
 
     //--------------------------------------------------------------------
-        void blend_solid_hspan(int x, int y, int len,
+    void blend_solid_hspan(int x, int y, int len, const color_type& c, const cover_type* covers)
-                               const color_type& c,
-                               const cover_type* covers)
     {
-            if(y > ymax()) return;
+        if (y > ymax())
-            if(y < ymin()) return;
+            return;
+        if (y < ymin())
+            return;
 
         if (x < xmin())
         {
             len -= xmin() - x;
-                if(len <= 0) return;
+            if (len <= 0)
+                return;
             covers += xmin() - x;
             x = xmin();
         }
         if (x + len > xmax())
         {
             len = xmax() - x + 1;
-                if(len <= 0) return;
+            if (len <= 0)
+                return;
         }
         m_ren->blend_solid_hspan(x, y, len, c, covers);
     }
 
     //--------------------------------------------------------------------
-        void blend_solid_vspan(int x, int y, int len,
+    void blend_solid_vspan(int x, int y, int len, const color_type& c, const cover_type* covers)
-                               const color_type& c,
-                               const cover_type* covers)
     {
-            if(x > xmax()) return;
+        if (x > xmax())
-            if(x < xmin()) return;
+            return;
+        if (x < xmin())
+            return;
 
         if (y < ymin())
         {
             len -= ymin() - y;
-                if(len <= 0) return;
+            if (len <= 0)
+                return;
             covers += ymin() - y;
             y = ymin();
         }
         if (y + len > ymax())
         {
             len = ymax() - y + 1;
-                if(len <= 0) return;
+            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 > ymax())
-            if(y < ymin()) return;
+            return;
+        if (y < ymin())
+            return;
 
         if (x < xmin())
         {
             int d = xmin() - x;
             len -= d;
-                if(len <= 0) return;
+            if (len <= 0)
+                return;
             colors += d;
             x = xmin();
         }
         if (x + len > xmax())
         {
             len = xmax() - x + 1;
-                if(len <= 0) return;
+            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 > xmax())
-            if(x < xmin()) return;
+            return;
+        if (x < xmin())
+            return;
 
         if (y < ymin())
         {
             int d = ymin() - y;
             len -= d;
-                if(len <= 0) return;
+            if (len <= 0)
+                return;
             colors += d;
             y = ymin();
         }
         if (y + len > ymax())
         {
             len = ymax() - y + 1;
-                if(len <= 0) return;
+            if (len <= 0)
+                return;
         }
         m_ren->copy_color_vspan(x, y, len, colors);
     }
 
-
     //--------------------------------------------------------------------
-        void blend_color_hspan(int x, int y, int len,
+    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 > ymax())
-            if(y < ymin()) return;
+            return;
+        if (y < ymin())
+            return;
 
         if (x < xmin())
         {
             int d = xmin() - x;
             len -= d;
-                if(len <= 0) return;
+            if (len <= 0)
-                if(covers) covers += d;
+                return;
+            if (covers)
+                covers += d;
             colors += d;
             x = xmin();
         }
         if (x + len > xmax())
         {
             len = xmax() - x + 1;
-                if(len <= 0) return;
+            if (len <= 0)
+                return;
         }
         m_ren->blend_color_hspan(x, y, len, colors, covers, cover);
     }
 
     //--------------------------------------------------------------------
-        void blend_color_hspan_alpha(int x, int y, int len,
+    void blend_color_hspan_alpha(int x,
+                                 int y,
+                                 int len,
                                  const color_type* colors,
                                  value_type alpha,
                                  const cover_type* covers,
                                  cover_type cover = agg::cover_full)
     {
-            if(y > ymax()) return;
+        if (y > ymax())
-            if(y < ymin()) return;
+            return;
+        if (y < ymin())
+            return;
 
         if (x < xmin())
         {
             int d = xmin() - x;
             len -= d;
-                if(len <= 0) return;
+            if (len <= 0)
-                if(covers) covers += d;
+                return;
+            if (covers)
+                covers += d;
             colors += d;
             x = xmin();
         }
         if (x + len > xmax())
         {
             len = xmax() - x + 1;
-                if(len <= 0) return;
+            if (len <= 0)
+                return;
         }
         m_ren->blend_color_hspan_alpha(x, y, len, colors, alpha, covers, cover);
     }
 
     //--------------------------------------------------------------------
-        void blend_color_vspan(int x, int y, int len,
+    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 > xmax())
-            if(x < xmin()) return;
+            return;
+        if (x < xmin())
+            return;
 
         if (y < ymin())
         {
             int d = ymin() - y;
             len -= d;
-                if(len <= 0) return;
+            if (len <= 0)
-                if(covers) covers += d;
+                return;
+            if (covers)
+                covers += d;
             colors += d;
             y = ymin();
         }
         if (y + len > ymax())
         {
             len = ymax() - y + 1;
-                if(len <= 0) return;
+            if (len <= 0)
+                return;
         }
         m_ren->blend_color_vspan(x, y, len, colors, covers, cover);
     }
@@ -450,8 +512,10 @@ namespace agg
             src.y1 = 0;
         }
 
-            if(src.x2 > wsrc) src.x2 = wsrc;
+        if (src.x2 > wsrc)
-            if(src.y2 > hsrc) src.y2 = hsrc;
+            src.x2 = wsrc;
+        if (src.y2 > hsrc)
+            src.y2 = hsrc;
 
         if (dst.x1 < cb.x1)
         {
@@ -464,23 +528,24 @@ namespace agg
             dst.y1 = cb.y1;
         }
 
-            if(dst.x2 > cb.x2) dst.x2 = cb.x2;
+        if (dst.x2 > cb.x2)
-            if(dst.y2 > cb.y2) dst.y2 = cb.y2;
+            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.x2 > src.x2 - src.x1)
-            if(rc.y2 > src.y2 - src.y1) rc.y2 = src.y2 - src.y1;
+            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,
+    void copy_from(const RenBuf& src, const rect_i* rect_src_ptr = 0, int dx = 0, int dy = 0)
-                       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)
@@ -510,10 +575,7 @@ namespace agg
             }
             while (rc.y2 > 0)
             {
-                    m_ren->copy_from(src,
+                m_ren->copy_from(src, rdst.x1, rdst.y1, rsrc.x1, rsrc.y1, rc.x2);
-                                     rdst.x1, rdst.y1,
-                                     rsrc.x1, rsrc.y1,
-                                     rc.x2);
                 rdst.y1 += incy;
                 rsrc.y1 += incy;
                 --rc.y2;
@@ -576,11 +638,7 @@ namespace agg
                         }
                         if (len > 0)
                         {
-                                m_ren->blend_from(src,
+                            m_ren->blend_from(src, x1dst, rdst.y1, x1src, rsrc.y1, len, cover);
-                                                  x1dst, rdst.y1,
-                                                  x1src, rsrc.y1,
-                                                  len,
-                                                  cover);
                         }
                     }
                 }
@@ -647,12 +705,7 @@ namespace agg
                         }
                         if (len > 0)
                         {
-                                m_ren->blend_from_color(src,
+                            m_ren->blend_from_color(src, color, x1dst, rdst.y1, x1src, rsrc.y1, len, cover);
-                                                        color,
-                                                        x1dst, rdst.y1,
-                                                        x1src, rsrc.y1,
-                                                        len,
-                                                        cover);
                         }
                     }
                 }
@@ -719,12 +772,7 @@ namespace agg
                         }
                         if (len > 0)
                         {
-                                m_ren->blend_from_lut(src,
+                            m_ren->blend_from_lut(src, color_lut, x1dst, rdst.y1, x1src, rsrc.y1, len, cover);
-                                                      color_lut,
-                                                      x1dst, rdst.y1,
-                                                      x1src, rsrc.y1,
-                                                      len,
-                                                      cover);
                         }
                     }
                 }
@@ -740,7 +788,6 @@ namespace agg
     rect_i m_clip_box;
 };
 
-
+} // namespace agg
-}
 
 #endif

deps/agg/include/agg_renderer_mclip.h

@@ -24,11 +24,11 @@
 #include "agg_array.h"
 #include "agg_renderer_base.h"
 
-namespace agg
+namespace agg {
-{
 
 //----------------------------------------------------------renderer_mclip
-    template<class PixelFormat> class renderer_mclip
+template<class PixelFormat>
+class renderer_mclip
 {
   public:
     typedef PixelFormat pixfmt_type;
@@ -37,10 +37,10 @@ namespace agg
     typedef renderer_base<pixfmt_type> base_ren_type;
 
     //--------------------------------------------------------------------
-        explicit renderer_mclip(pixfmt_type& pixf) :
+    explicit renderer_mclip(pixfmt_type& pixf)
-            m_ren(pixf),
+        : m_ren(pixf)
-            m_curr_cb(0),
+        , m_curr_cb(0)
-            m_bounds(m_ren.xmin(), m_ren.ymin(), m_ren.xmax(), m_ren.ymax())
+        , m_bounds(m_ren.xmin(), m_ren.ymin(), m_ren.xmax(), m_ren.ymax())
     {}
     void attach(pixfmt_type& pixf)
     {
@@ -110,18 +110,19 @@ namespace agg
         if (cb.clip(rect_i(0, 0, width() - 1, height() - 1)))
         {
             m_clip.add(cb);
-                if(cb.x1 < m_bounds.x1) m_bounds.x1 = cb.x1;
+            if (cb.x1 < m_bounds.x1)
-                if(cb.y1 < m_bounds.y1) m_bounds.y1 = cb.y1;
+                m_bounds.x1 = cb.x1;
-                if(cb.x2 > m_bounds.x2) m_bounds.x2 = cb.x2;
+            if (cb.y1 < m_bounds.y1)
-                if(cb.y2 > m_bounds.y2) m_bounds.y2 = cb.y2;
+                m_bounds.y1 = cb.y1;
+            if (cb.x2 > m_bounds.x2)
+                m_bounds.x2 = cb.x2;
+            if (cb.y2 > m_bounds.y2)
+                m_bounds.y2 = cb.y2;
         }
     }
 
     //--------------------------------------------------------------------
-        void clear(const color_type& c)
+    void clear(const color_type& c) { m_ren.clear(c); }
-        {
-            m_ren.clear(c);
-        }
 
     //--------------------------------------------------------------------
     void copy_pixel(int x, int y, const color_type& c)
@@ -134,8 +135,7 @@ namespace agg
                 m_ren.ren().copy_pixel(x, y, c);
                 break;
             }
-            }
+        } while (next_clip_box());
-            while(next_clip_box());
     }
 
     //--------------------------------------------------------------------
@@ -149,8 +149,7 @@ namespace agg
                 m_ren.ren().blend_pixel(x, y, c, cover);
                 break;
             }
-            }
+        } while (next_clip_box());
-            while(next_clip_box());
     }
 
     //--------------------------------------------------------------------
@@ -163,8 +162,7 @@ namespace agg
             {
                 return m_ren.ren().pixel(x, y);
             }
-            }
+        } while (next_clip_box());
-            while(next_clip_box());
         return color_type::no_color();
     }
 
@@ -175,8 +173,7 @@ namespace agg
         do
         {
             m_ren.copy_hline(x1, y, x2, c);
-            }
+        } while (next_clip_box());
-            while(next_clip_box());
     }
 
     //--------------------------------------------------------------------
@@ -186,32 +183,27 @@ namespace agg
         do
         {
             m_ren.copy_vline(x, y1, y2, c);
-            }
+        } while (next_clip_box());
-            while(next_clip_box());
     }
 
     //--------------------------------------------------------------------
-        void blend_hline(int x1, int y, int x2, 
+    void blend_hline(int x1, int y, int x2, const color_type& c, cover_type cover)
-                         const color_type& c, cover_type cover)
     {
         first_clip_box();
         do
         {
             m_ren.blend_hline(x1, y, x2, c, cover);
-            }
+        } while (next_clip_box());
-            while(next_clip_box());
     }
 
     //--------------------------------------------------------------------
-        void blend_vline(int x, int y1, int y2, 
+    void blend_vline(int x, int y1, int y2, const color_type& c, cover_type cover)
-                         const color_type& c, cover_type cover)
     {
         first_clip_box();
         do
         {
             m_ren.blend_vline(x, y1, y2, c, cover);
-            }
+        } while (next_clip_box());
-            while(next_clip_box());
     }
 
     //--------------------------------------------------------------------
@@ -221,46 +213,38 @@ namespace agg
         do
         {
             m_ren.copy_bar(x1, y1, x2, y2, c);
-            }
+        } while (next_clip_box());
-            while(next_clip_box());
     }
 
     //--------------------------------------------------------------------
-        void blend_bar(int x1, int y1, int x2, int y2, 
+    void blend_bar(int x1, int y1, int x2, int y2, const color_type& c, cover_type cover)
-                       const color_type& c, cover_type cover)
     {
         first_clip_box();
         do
         {
             m_ren.blend_bar(x1, y1, x2, y2, c, cover);
-            }
+        } while (next_clip_box());
-            while(next_clip_box());
     }
 
     //--------------------------------------------------------------------
-        void blend_solid_hspan(int x, int y, int len, 
+    void blend_solid_hspan(int x, int y, int len, const color_type& c, const cover_type* covers)
-                               const color_type& c, const cover_type* covers)
     {
         first_clip_box();
         do
         {
             m_ren.blend_solid_hspan(x, y, len, c, covers);
-            }
+        } while (next_clip_box());
-            while(next_clip_box());
     }
 
     //--------------------------------------------------------------------
-        void blend_solid_vspan(int x, int y, int len, 
+    void blend_solid_vspan(int x, int y, int len, const color_type& c, const cover_type* covers)
-                               const color_type& c, const cover_type* covers)
     {
         first_clip_box();
         do
         {
             m_ren.blend_solid_vspan(x, y, len, c, covers);
+        } while (next_clip_box());
     }
-            while(next_clip_box());
-        }
-
 
     //--------------------------------------------------------------------
     void copy_color_hspan(int x, int y, int len, const color_type* colors)
@@ -269,12 +253,13 @@ namespace agg
         do
         {
             m_ren.copy_color_hspan(x, y, len, colors);
-            }
+        } while (next_clip_box());
-            while(next_clip_box());
     }
 
     //--------------------------------------------------------------------
-        void blend_color_hspan(int x, int y, int len, 
+    void blend_color_hspan(int x,
+                           int y,
+                           int len,
                            const color_type* colors,
                            const cover_type* covers,
                            cover_type cover = cover_full)
@@ -283,12 +268,13 @@ namespace agg
         do
         {
             m_ren.blend_color_hspan(x, y, len, colors, covers, cover);
-            }
+        } while (next_clip_box());
-            while(next_clip_box());
     }
 
     //--------------------------------------------------------------------
-        void blend_color_vspan(int x, int y, int len, 
+    void blend_color_vspan(int x,
+                           int y,
+                           int len,
                            const color_type* colors,
                            const cover_type* covers,
                            cover_type cover = cover_full)
@@ -297,22 +283,17 @@ namespace agg
         do
         {
             m_ren.blend_color_vspan(x, y, len, colors, covers, cover);
-            }
+        } while (next_clip_box());
-            while(next_clip_box());
     }
 
     //--------------------------------------------------------------------
-        void copy_from(const rendering_buffer& from, 
+    void copy_from(const rendering_buffer& from, const rect_i* rc = 0, int x_to = 0, int y_to = 0)
-                       const rect_i* rc=0, 
-                       int x_to=0, 
-                       int y_to=0)
     {
         first_clip_box();
         do
         {
             m_ren.copy_from(from, rc, x_to, y_to);
-            }
+        } while (next_clip_box());
-            while(next_clip_box());
     }
 
     //--------------------------------------------------------------------
@@ -327,15 +308,12 @@ namespace agg
         do
         {
             m_ren.blend_from(src, rect_src_ptr, dx, dy, cover);
+        } while (next_clip_box());
     }
-            while(next_clip_box());
-        }
-
 
   private:
     renderer_mclip(const renderer_mclip<PixelFormat>&);
-        const renderer_mclip<PixelFormat>& 
+    const renderer_mclip<PixelFormat>& operator=(const renderer_mclip<PixelFormat>&);
-            operator = (const renderer_mclip<PixelFormat>&);
 
     base_ren_type m_ren;
     pod_bvector<rect_i, 4> m_clip;
@@ -343,7 +321,6 @@ namespace agg
     rect_i m_bounds;
 };
 
-
+} // namespace agg
-}
 
 #endif

deps/agg/include/agg_renderer_outline_image.h

@@ -22,21 +22,19 @@
 #include "agg_rendering_buffer.h"
 #include "agg_clip_liang_barsky.h"
 
-
+namespace agg {
-namespace agg
-{
 //========================================================line_image_scale
-    template<class Source> class line_image_scale
+template<class Source>
+class line_image_scale
 {
   public:
     typedef typename Source::color_type color_type;
 
-        line_image_scale(const Source& src, double height) :
+    line_image_scale(const Source& src, double height)
-            m_source(src),
+        : m_source(src)
-            m_height(height),
+        , m_height(height)
-            m_scale(src.height() / height)
+        , m_scale(src.height() / height)
-        {
+    {}
-        }
 
     double width() const { return m_source.width(); }
     double height() const { return m_height; }
@@ -61,49 +59,48 @@ namespace agg
     double m_scale;
 };
 
-
-
 //======================================================line_image_pattern
-    template<class Filter> class line_image_pattern
+template<class Filter>
+class line_image_pattern
 {
   public:
     typedef Filter filter_type;
     typedef typename filter_type::color_type color_type;
 
     //--------------------------------------------------------------------
-        line_image_pattern(const Filter& filter) :
+    line_image_pattern(const Filter& filter)
-            m_filter(&filter),
+        : m_filter(&filter)
-            m_dilation(filter.dilation() + 1),
+        , m_dilation(filter.dilation() + 1)
-            m_dilation_hr(m_dilation * line_subpixel_scale),
+        , m_dilation_hr(m_dilation * line_subpixel_scale)
-            m_data(),
+        , m_data()
-            m_width(0),
+        , m_width(0)
-            m_height(0),
+        , m_height(0)
-            m_width_hr(0),
+        , m_width_hr(0)
-            m_half_height_hr(0),
+        , m_half_height_hr(0)
-            m_offset_y_hr(0)
+        , m_offset_y_hr(0)
-        {
+    {}
-        }
 
     // Create
     //--------------------------------------------------------------------
     template<class Source>
-        line_image_pattern(const Filter& filter, const Source& src) :
+    line_image_pattern(const Filter& filter, const Source& src)
-            m_filter(&filter),
+        : m_filter(&filter)
-            m_dilation(filter.dilation() + 1),
+        , m_dilation(filter.dilation() + 1)
-            m_dilation_hr(m_dilation * line_subpixel_scale),
+        , m_dilation_hr(m_dilation * line_subpixel_scale)
-            m_data(),
+        , m_data()
-            m_width(0),
+        , m_width(0)
-            m_height(0),
+        , m_height(0)
-            m_width_hr(0),
+        , m_width_hr(0)
-            m_half_height_hr(0),
+        , m_half_height_hr(0)
-            m_offset_y_hr(0)
+        , m_offset_y_hr(0)
     {
         create(src);
     }
 
     // Create
     //--------------------------------------------------------------------
-        template<class Source> void create(const Source& src)
+    template<class Source>
+    void create(const Source& src)
     {
         m_height = uceil(src.height());
         m_width = uceil(src.width());
@@ -114,9 +111,7 @@ namespace agg
 
         m_data.resize((m_width + m_dilation * 2) * (m_height + m_dilation * 2));
 
-            m_buf.attach(&m_data[0], m_width  + m_dilation * 2,
+        m_buf.attach(&m_data[0], m_width + m_dilation * 2, m_height + m_dilation * 2, m_width + m_dilation * 2);
-                                     m_height + m_dilation * 2,
-                                     m_width  + m_dilation * 2);
         unsigned x, y;
         color_type* d1;
         color_type* d2;
@@ -170,10 +165,7 @@ namespace agg
     //--------------------------------------------------------------------
     void pixel(color_type* p, int x, int y) const
     {
-            m_filter->pixel_high_res(m_buf.rows(),
+        m_filter->pixel_high_res(m_buf.rows(), p, x % m_width_hr + m_dilation_hr, y + m_offset_y_hr);
-                                     p,
-                                     x % m_width_hr + m_dilation_hr,
-                                     y + m_offset_y_hr);
     }
 
     //--------------------------------------------------------------------
@@ -181,8 +173,7 @@ namespace agg
 
   private:
     line_image_pattern(const line_image_pattern<filter_type>&);
-        const line_image_pattern<filter_type>&
+    const line_image_pattern<filter_type>& operator=(const line_image_pattern<filter_type>&);
-            operator = (const line_image_pattern<filter_type>&);
 
   protected:
     row_ptr_cache<color_type> m_buf;
@@ -197,14 +188,9 @@ namespace agg
     int m_offset_y_hr;
 };
 
-
-
-
-
-
 //=================================================line_image_pattern_pow2
-    template<class Filter> class line_image_pattern_pow2 :
+template<class Filter>
-    public line_image_pattern<Filter>
+class line_image_pattern_pow2 : public line_image_pattern<Filter>
 {
   public:
     typedef Filter filter_type;
@@ -212,19 +198,23 @@ namespace agg
     typedef line_image_pattern<Filter> base_type;
 
     //--------------------------------------------------------------------
-        line_image_pattern_pow2(const Filter& filter) :
+    line_image_pattern_pow2(const Filter& filter)
-            line_image_pattern<Filter>(filter), m_mask(line_subpixel_mask) {}
+        : line_image_pattern<Filter>(filter)
+        , m_mask(line_subpixel_mask)
+    {}
 
     //--------------------------------------------------------------------
     template<class Source>
-        line_image_pattern_pow2(const Filter& filter, const Source& src) :
+    line_image_pattern_pow2(const Filter& filter, const Source& src)
-            line_image_pattern<Filter>(filter), m_mask(line_subpixel_mask)
+        : line_image_pattern<Filter>(filter)
+        , m_mask(line_subpixel_mask)
     {
         create(src);
     }
 
     //--------------------------------------------------------------------
-        template<class Source> void create(const Source& src)
+    template<class Source>
+    void create(const Source& src)
     {
         line_image_pattern<Filter>::create(src);
         m_mask = 1;
@@ -241,47 +231,53 @@ namespace agg
     //--------------------------------------------------------------------
     void pixel(color_type* p, int x, int y) const
     {
-            base_type::m_filter->pixel_high_res(
+        base_type::m_filter->pixel_high_res(base_type::m_buf.rows(),
-                    base_type::m_buf.rows(),
                                             p,
                                             (x & m_mask) + base_type::m_dilation_hr,
                                             y + base_type::m_offset_y_hr);
     }
+
   private:
     unsigned m_mask;
 };
 
-
-
-
-
-
-
 //===================================================distance_interpolator4
 class distance_interpolator4
 {
   public:
     //---------------------------------------------------------------------
     distance_interpolator4() {}
-        distance_interpolator4(int x1,  int y1, int x2, int y2,
+    distance_interpolator4(int x1,
-                               int sx,  int sy, int ex, int ey,
+                           int y1,
-                               int len, double scale, int x, int y) :
+                           int x2,
-            m_dx(x2 - x1),
+                           int y2,
-            m_dy(y2 - y1),
+                           int sx,
-            m_dx_start(line_mr(sx) - line_mr(x1)),
+                           int sy,
-            m_dy_start(line_mr(sy) - line_mr(y1)),
+                           int ex,
-            m_dx_end(line_mr(ex) - line_mr(x2)),
+                           int ey,
-            m_dy_end(line_mr(ey) - line_mr(y2)),
+                           int len,
+                           double scale,
+                           int x,
+                           int y)
+        : m_dx(x2 - x1)
+        , m_dy(y2 - y1)
+        , m_dx_start(line_mr(sx) - line_mr(x1))
+        , m_dy_start(line_mr(sy) - line_mr(y1))
+        , m_dx_end(line_mr(ex) - line_mr(x2))
+        , m_dy_end(line_mr(ey) - line_mr(y2))
+        ,
 
         m_dist(iround(double(x + line_subpixel_scale / 2 - x2) * double(m_dy) -
-                          double(y + line_subpixel_scale/2 - y2) * double(m_dx))),
+                      double(y + line_subpixel_scale / 2 - y2) * double(m_dx)))
+        ,
 
         m_dist_start((line_mr(x + line_subpixel_scale / 2) - line_mr(sx)) * m_dy_start -
-                         (line_mr(y + line_subpixel_scale/2) - line_mr(sy)) * m_dx_start),
+                     (line_mr(y + line_subpixel_scale / 2) - line_mr(sy)) * m_dx_start)
+        ,
 
         m_dist_end((line_mr(x + line_subpixel_scale / 2) - line_mr(ex)) * m_dy_end -
-                       (line_mr(y + line_subpixel_scale/2) - line_mr(ey)) * m_dx_end),
+                   (line_mr(y + line_subpixel_scale / 2) - line_mr(ey)) * m_dx_end)
-            m_len(uround(len / scale))
+        , m_len(uround(len / scale))
     {
         double d = len * scale;
         int dx = iround(((x2 - x1) * line_subpixel_scale) / d);
@@ -463,50 +459,57 @@ namespace agg
     int m_len;
 };
 
-
-
-
-
 //==================================================line_interpolator_image
-    template<class Renderer> class line_interpolator_image
+template<class Renderer>
+class line_interpolator_image
 {
   public:
     typedef Renderer renderer_type;
     typedef typename Renderer::color_type color_type;
 
     //---------------------------------------------------------------------
-        enum max_half_width_e
+    enum max_half_width_e { max_half_width = 64 };
-        {
-            max_half_width = 64
-        };
 
     //---------------------------------------------------------------------
-        line_interpolator_image(renderer_type& ren, const line_parameters& lp,
+    line_interpolator_image(renderer_type& ren,
-                                int sx, int sy, int ex, int ey,
+                            const line_parameters& lp,
+                            int sx,
+                            int sy,
+                            int ex,
+                            int ey,
                             int pattern_start,
-                                double scale_x) :
+                            double scale_x)
-            m_lp(lp),
+        : m_lp(lp)
-            m_li(lp.vertical ? line_dbl_hr(lp.x2 - lp.x1) :
+        , m_li(lp.vertical ? line_dbl_hr(lp.x2 - lp.x1) : line_dbl_hr(lp.y2 - lp.y1), lp.vertical ? lp.dy : lp.dx + 1)
-                 line_dbl_hr(lp.y2 - lp.y1),
+        , m_di(lp.x1,
-                 lp.vertical ? lp.dy : lp.dx + 1),
+               lp.y1,
-            m_di(lp.x1, lp.y1, lp.x2, lp.y2, sx, sy, ex, ey, lp.len, scale_x,
+               lp.x2,
-                 lp.x1 & ~line_subpixel_mask, lp.y1 & ~line_subpixel_mask),
+               lp.y2,
-            m_ren(ren),
+               sx,
-            m_x(lp.x1 >> line_subpixel_shift),
+               sy,
-            m_y(lp.y1 >> line_subpixel_shift),
+               ex,
-            m_old_x(m_x),
+               ey,
-            m_old_y(m_y),
+               lp.len,
-            m_count((lp.vertical ? std::abs((lp.y2 >> line_subpixel_shift) - m_y) :
+               scale_x,
-                                   std::abs((lp.x2 >> line_subpixel_shift) - m_x))),
+               lp.x1 & ~line_subpixel_mask,
-            m_width(ren.subpixel_width()),
+               lp.y1 & ~line_subpixel_mask)
+        , m_ren(ren)
+        , m_x(lp.x1 >> line_subpixel_shift)
+        , m_y(lp.y1 >> line_subpixel_shift)
+        , m_old_x(m_x)
+        , m_old_y(m_y)
+        , m_count((lp.vertical ? std::abs((lp.y2 >> line_subpixel_shift) - m_y)
+                               : std::abs((lp.x2 >> line_subpixel_shift) - m_x)))
+        , m_width(ren.subpixel_width())
+        ,
         // m_max_extent(m_width >> (line_subpixel_shift - 2)),
-            m_max_extent((m_width + line_subpixel_scale) >> line_subpixel_shift),
+        m_max_extent((m_width + line_subpixel_scale) >> line_subpixel_shift)
-            m_start(pattern_start + (m_max_extent + 2) * ren.pattern_width()),
+        , m_start(pattern_start + (m_max_extent + 2) * ren.pattern_width())
-            m_step(0)
+        , m_step(0)
     {
-            agg::dda2_line_interpolator li(0, lp.vertical ?
+        agg::dda2_line_interpolator li(0,
-                                              (lp.dy * agg::line_subpixel_scale) :
+                                       lp.vertical ? (lp.dy * agg::line_subpixel_scale)
-                                              (lp.dx * agg::line_subpixel_scale),
+                                                   : (lp.dx * agg::line_subpixel_scale),
                                        lp.len);
 
         unsigned i;
@@ -514,7 +517,8 @@ namespace agg
         for (i = 0; i < max_half_width; ++i)
         {
             m_dist_pos[i] = li.y();
-                if(m_dist_pos[i] >= stop) break;
+            if (m_dist_pos[i] >= stop)
+                break;
             ++li;
         }
         m_dist_pos[i] = 0x7FFF0000;
@@ -531,29 +535,33 @@ namespace agg
                 m_y -= lp.inc;
                 m_x = (m_lp.x1 + m_li.y()) >> line_subpixel_shift;
 
-                    if(lp.inc > 0) m_di.dec_y(m_x - m_old_x);
+                if (lp.inc > 0)
-                    else           m_di.inc_y(m_x - m_old_x);
+                    m_di.dec_y(m_x - m_old_x);
+                else
+                    m_di.inc_y(m_x - m_old_x);
 
                 m_old_x = m_x;
 
                 dist1_start = dist2_start = m_di.dist_start();
 
                 int dx = 0;
-                    if(dist1_start < 0) ++npix;
+                if (dist1_start < 0)
+                    ++npix;
                 do
                 {
                     dist1_start += m_di.dy_start();
                     dist2_start -= m_di.dy_start();
-                        if(dist1_start < 0) ++npix;
+                    if (dist1_start < 0)
-                        if(dist2_start < 0) ++npix;
+                        ++npix;
+                    if (dist2_start < 0)
+                        ++npix;
                     ++dx;
-                    }
+                } while (m_dist_pos[dx] <= m_width);
-                    while(m_dist_pos[dx] <= m_width);
+                if (npix == 0)
-                    if(npix == 0) break;
+                    break;
 
                 npix = 0;
-                }
+            } while (--m_step >= -m_max_extent);
-                while(--m_step >= -m_max_extent);
         }
         else
         {
@@ -564,29 +572,33 @@ namespace agg
                 m_x -= lp.inc;
                 m_y = (m_lp.y1 + m_li.y()) >> line_subpixel_shift;
 
-                    if(lp.inc > 0) m_di.dec_x(m_y - m_old_y);
+                if (lp.inc > 0)
-                    else           m_di.inc_x(m_y - m_old_y);
+                    m_di.dec_x(m_y - m_old_y);
+                else
+                    m_di.inc_x(m_y - m_old_y);
 
                 m_old_y = m_y;
 
                 dist1_start = dist2_start = m_di.dist_start();
 
                 int dy = 0;
-                    if(dist1_start < 0) ++npix;
+                if (dist1_start < 0)
+                    ++npix;
                 do
                 {
                     dist1_start -= m_di.dx_start();
                     dist2_start += m_di.dx_start();
-                        if(dist1_start < 0) ++npix;
+                    if (dist1_start < 0)
-                        if(dist2_start < 0) ++npix;
+                        ++npix;
+                    if (dist2_start < 0)
+                        ++npix;
                     ++dy;
-                    }
+                } while (m_dist_pos[dy] <= m_width);
-                    while(m_dist_pos[dy] <= m_width);
+                if (npix == 0)
-                    if(npix == 0) break;
+                    break;
 
                 npix = 0;
-                }
+            } while (--m_step >= -m_max_extent);
-                while(--m_step >= -m_max_extent);
         }
         m_li.adjust_forward();
         m_step -= m_max_extent;
@@ -599,15 +611,18 @@ namespace agg
         m_x += m_lp.inc;
         m_y = (m_lp.y1 + m_li.y()) >> line_subpixel_shift;
 
-            if(m_lp.inc > 0) m_di.inc_x(m_y - m_old_y);
+        if (m_lp.inc > 0)
-            else             m_di.dec_x(m_y - m_old_y);
+            m_di.inc_x(m_y - m_old_y);
+        else
+            m_di.dec_x(m_y - m_old_y);
 
         m_old_y = m_y;
 
         int s1 = m_di.dist() / m_lp.len;
         int s2 = -s1;
 
-            if(m_lp.inc < 0) s1 = -s1;
+        if (m_lp.inc < 0)
+            s1 = -s1;
 
         int dist_start;
         int dist_pict;
@@ -642,7 +657,8 @@ namespace agg
             p1->clear();
             if (dist_end > 0 && dist_start <= 0)
             {
-                    if(m_lp.inc > 0) dist = -dist;
+                if (m_lp.inc > 0)
+                    dist = -dist;
                 m_ren.pixel(p1, dist_pict, s2 - dist);
                 ++npix;
             }
@@ -663,21 +679,17 @@ namespace agg
             p0->clear();
             if (dist_end > 0 && dist_start <= 0)
             {
-                    if(m_lp.inc > 0) dist = -dist;
+                if (m_lp.inc > 0)
+                    dist = -dist;
                 m_ren.pixel(p0, dist_pict, s2 + dist);
                 ++npix;
             }
             ++dy;
         }
-            m_ren.blend_color_vspan(m_x,
+        m_ren.blend_color_vspan(m_x, m_y - dy + 1, unsigned(p1 - p0), p0);
-                                    m_y - dy + 1,
-                                    unsigned(p1 - p0),
-                                    p0);
         return npix && ++m_step < m_count;
     }
 
-
-
     //---------------------------------------------------------------------
     bool step_ver()
     {
@@ -685,15 +697,18 @@ namespace agg
         m_y += m_lp.inc;
         m_x = (m_lp.x1 + m_li.y()) >> line_subpixel_shift;
 
-            if(m_lp.inc > 0) m_di.inc_y(m_x - m_old_x);
+        if (m_lp.inc > 0)
-            else             m_di.dec_y(m_x - m_old_x);
+            m_di.inc_y(m_x - m_old_x);
+        else
+            m_di.dec_y(m_x - m_old_x);
 
         m_old_x = m_x;
 
         int s1 = m_di.dist() / m_lp.len;
         int s2 = -s1;
 
-            if(m_lp.inc > 0) s1 = -s1;
+        if (m_lp.inc > 0)
+            s1 = -s1;
 
         int dist_start;
         int dist_pict;
@@ -728,7 +743,8 @@ namespace agg
             p1->clear();
             if (dist_end > 0 && dist_start <= 0)
             {
-                    if(m_lp.inc > 0) dist = -dist;
+                if (m_lp.inc > 0)
+                    dist = -dist;
                 m_ren.pixel(p1, dist_pict, s2 + dist);
                 ++npix;
             }
@@ -749,20 +765,17 @@ namespace agg
             p0->clear();
             if (dist_end > 0 && dist_start <= 0)
             {
-                    if(m_lp.inc > 0) dist = -dist;
+                if (m_lp.inc > 0)
+                    dist = -dist;
                 m_ren.pixel(p0, dist_pict, s2 - dist);
                 ++npix;
             }
             ++dx;
         }
-            m_ren.blend_color_hspan(m_x - dx + 1,
+        m_ren.blend_color_hspan(m_x - dx + 1, m_y, unsigned(p1 - p0), p0);
-                                    m_y,
-                                    unsigned(p1 - p0),
-                                    p0);
         return npix && ++m_step < m_count;
     }
 
-
     //---------------------------------------------------------------------
     int pattern_end() const { return m_start + m_di.len(); }
 
@@ -773,8 +786,7 @@ namespace agg
 
   private:
     line_interpolator_image(const line_interpolator_image<Renderer>&);
-        const line_interpolator_image<Renderer>&
+    const line_interpolator_image<Renderer>& operator=(const line_interpolator_image<Renderer>&);
-            operator = (const line_interpolator_image<Renderer>&);
 
   protected:
     const line_parameters& m_lp;
@@ -795,13 +807,6 @@ namespace agg
     color_type m_colors[max_half_width * 2 + 4];
 };
 
-
-
-
-
-
-
-
 //===================================================renderer_outline_image
 template<class BaseRenderer, class ImagePattern>
 class renderer_outline_image
@@ -813,15 +818,14 @@ namespace agg
     typedef typename base_ren_type::color_type color_type;
     typedef ImagePattern pattern_type;
 
-
     //---------------------------------------------------------------------
-        renderer_outline_image(base_ren_type& ren, const pattern_type& patt) :
+    renderer_outline_image(base_ren_type& ren, const pattern_type& patt)
-            m_ren(&ren),
+        : m_ren(&ren)
-            m_pattern(&patt),
+        , m_pattern(&patt)
-            m_start(0),
+        , m_start(0)
-            m_scale_x(1.0),
+        , m_scale_x(1.0)
-            m_clip_box(0,0,0,0),
+        , m_clip_box(0, 0, 0, 0)
-            m_clipping(false)
+        , m_clipping(false)
     {}
     void attach(base_ren_type& ren) { m_ren = &ren; }
 
@@ -854,10 +858,7 @@ namespace agg
     double width() const { return double(subpixel_width()) / line_subpixel_scale; }
 
     //-------------------------------------------------------------------------
-        void pixel(color_type* p, int x, int y) const
+    void pixel(color_type* p, int x, int y) const { m_pattern->pixel(p, x, y); }
-        {
-            m_pattern->pixel(p, x, y);
-        }
 
     //-------------------------------------------------------------------------
     void blend_color_hspan(int x, int y, unsigned len, const color_type* colors)
@@ -877,32 +878,22 @@ namespace agg
     //-------------------------------------------------------------------------
     template<class Cmp>
     void semidot(Cmp, int, int, int, int)
-        {
+    {}
-        }
 
     //-------------------------------------------------------------------------
-        void pie(int, int, int, int, int, int)
+    void pie(int, int, int, int, int, int) {}
-        {
-        }
 
     //-------------------------------------------------------------------------
-        void line0(const line_parameters&)
+    void line0(const line_parameters&) {}
-        {
-        }
 
     //-------------------------------------------------------------------------
-        void line1(const line_parameters&, int, int)
+    void line1(const line_parameters&, int, int) {}
-        {
-        }
 
     //-------------------------------------------------------------------------
-        void line2(const line_parameters&, int, int)
+    void line2(const line_parameters&, int, int) {}
-        {
-        }
 
     //-------------------------------------------------------------------------
-        void line3_no_clip(const line_parameters& lp,
+    void line3_no_clip(const line_parameters& lp, int sx, int sy, int ex, int ey)
-                           int sx, int sy, int ex, int ey)
     {
         if (lp.len > line_max_length)
         {
@@ -917,24 +908,22 @@ namespace agg
 
         fix_degenerate_bisectrix_start(lp, &sx, &sy);
         fix_degenerate_bisectrix_end(lp, &ex, &ey);
-            line_interpolator_image<self_type> li(*this, lp,
+        line_interpolator_image<self_type> li(*this, lp, sx, sy, ex, ey, m_start, m_scale_x);
-                                                  sx, sy,
-                                                  ex, ey,
-                                                  m_start, m_scale_x);
         if (li.vertical())
         {
-                while(li.step_ver()) ;
+            while (li.step_ver())
+                ;
         }
         else
         {
-                while(li.step_hor()) ;
+            while (li.step_hor())
+                ;
         }
         m_start += uround(lp.len / m_scale_x);
     }
 
     //-------------------------------------------------------------------------
-        void line3(const line_parameters& lp,
+    void line3(const line_parameters& lp, int sx, int sy, int ex, int ey)
-                   int sx, int sy, int ex, int ey)
     {
         if (m_clipping)
         {
@@ -948,8 +937,7 @@ namespace agg
             {
                 if (flags)
                 {
-                        line_parameters lp2(x1, y1, x2, y2,
+                    line_parameters lp2(x1, y1, x2, y2, uround(calc_distance(x1, y1, x2, y2)));
-                                           uround(calc_distance(x1, y1, x2, y2)));
                     if (flags & 1)
                     {
                         m_start += uround(calc_distance(lp.x1, lp.y1, x1, y1) / m_scale_x);
@@ -1001,12 +989,6 @@ namespace agg
     bool m_clipping;
 };
 
-
+} // namespace agg
-
-
-
-}
-
-
 
 #endif

deps/agg/include/agg_renderer_primitives.h

@@ -25,30 +25,27 @@
 #include "agg_dda_line.h"
 #include "agg_ellipse_bresenham.h"
 
-namespace agg
+namespace agg {
-{
 //-----------------------------------------------------renderer_primitives
-    template<class BaseRenderer> class renderer_primitives
+template<class BaseRenderer>
+class renderer_primitives
 {
   public:
     typedef BaseRenderer base_ren_type;
     typedef typename base_ren_type::color_type color_type;
 
     //--------------------------------------------------------------------
-        explicit renderer_primitives(base_ren_type& ren) :
+    explicit renderer_primitives(base_ren_type& ren)
-            m_ren(&ren),
+        : m_ren(&ren)
-            m_fill_color(),
+        , m_fill_color()
-            m_line_color(),
+        , m_line_color()
-            m_curr_x(0),
+        , m_curr_x(0)
-            m_curr_y(0)
+        , m_curr_y(0)
     {}
     void attach(base_ren_type& ren) { m_ren = &ren; }
 
     //--------------------------------------------------------------------
-        static int coord(double c) 
+    static int coord(double c) { return iround(c * line_bresenham_interpolator::subpixel_scale); }
-        { 
-            return iround(c * line_bresenham_interpolator::subpixel_scale); 
-        }
 
     //--------------------------------------------------------------------
     void fill_color(const color_type& c) { m_fill_color = c; }
@@ -66,10 +63,7 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        void solid_rectangle(int x1, int y1, int x2, int y2)
+    void solid_rectangle(int x1, int y1, int x2, int y2) { m_ren->blend_bar(x1, y1, x2, y2, m_fill_color, cover_full); }
-        {
-            m_ren->blend_bar(x1, y1, x2, y2, m_fill_color, cover_full);
-        }
 
     //--------------------------------------------------------------------
     void outlined_rectangle(int x1, int y1, int x2, int y2)
@@ -93,8 +87,7 @@ namespace agg
             m_ren->blend_pixel(x - dx, y - dy, m_line_color, cover_full);
             m_ren->blend_pixel(x - dx, y + dy, m_line_color, cover_full);
             ++ei;
-            }
+        } while (dy < 0);
-            while(dy < 0);
     }
 
     //--------------------------------------------------------------------
@@ -119,8 +112,7 @@ namespace agg
             dx0 = dx;
             dy0 = dy;
             ++ei;
-            }
+        } while (dy < 0);
-            while(dy < 0);
         m_ren->blend_hline(x - dx0, y + dy0, x + dx0, m_fill_color, cover_full);
     }
 
@@ -147,8 +139,7 @@ namespace agg
                 m_ren->blend_hline(x - dx + 1, y - dy, x + dx - 1, m_fill_color, cover_full);
             }
             ++ei;
-            }
+        } while (dy < 0);
-            while(dy < 0);
     }
 
     //--------------------------------------------------------------------
@@ -166,7 +157,8 @@ namespace agg
             return;
         }
 
-            if(last) ++len;
+        if (last)
+            ++len;
 
         if (li.is_ver())
         {
@@ -174,8 +166,7 @@ namespace agg
             {
                 m_ren->blend_pixel(li.x2(), li.y1(), m_line_color, cover_full);
                 li.vstep();
-                }
+            } while (--len);
-                while(--len);
         }
         else
         {
@@ -183,8 +174,7 @@ namespace agg
             {
                 m_ren->blend_pixel(li.x1(), li.y2(), m_line_color, cover_full);
                 li.hstep();
-                }
+            } while (--len);
-                while(--len);
         }
     }
 
@@ -219,6 +209,6 @@ namespace agg
     int m_curr_y;
 };
 
-}
+} // namespace agg
 
 #endif

deps/agg/include/agg_renderer_raster_text.h

@@ -18,8 +18,7 @@
 
 #include "agg_basics.h"
 
-namespace agg
+namespace agg {
-{
 
 //==============================================renderer_raster_htext_solid
 template<class BaseRenderer, class GlyphGenerator>
@@ -31,9 +30,9 @@ namespace agg
     typedef typename glyph_gen_type::glyph_rect glyph_rect;
     typedef typename ren_type::color_type color_type;
 
-        renderer_raster_htext_solid(ren_type& ren, glyph_gen_type& glyph) :
+    renderer_raster_htext_solid(ren_type& ren, glyph_gen_type& glyph)
-            m_ren(&ren),
+        : m_ren(&ren)
-            m_glyph(&glyph)
+        , m_glyph(&glyph)
     {}
     void attach(ren_type& ren) { m_ren = &ren; }
 
@@ -56,18 +55,14 @@ namespace agg
                 {
                     for (i = r.y1; i <= r.y2; i++)
                     {
-                            m_ren->blend_solid_hspan(r.x1, i, (r.x2 - r.x1 + 1),
+                        m_ren->blend_solid_hspan(r.x1, i, (r.x2 - r.x1 + 1), m_color, m_glyph->span(r.y2 - i));
-                                                     m_color,
-                                                     m_glyph->span(r.y2 - i));
                     }
                 }
                 else
                 {
                     for (i = r.y1; i <= r.y2; i++)
                     {
-                            m_ren->blend_solid_hspan(r.x1, i, (r.x2 - r.x1 + 1),
+                        m_ren->blend_solid_hspan(r.x1, i, (r.x2 - r.x1 + 1), m_color, m_glyph->span(i - r.y1));
-                                                     m_color,
-                                                     m_glyph->span(i - r.y1));
                     }
                 }
             }
@@ -83,8 +78,6 @@ namespace agg
     color_type m_color;
 };
 
-
-
 //=============================================renderer_raster_vtext_solid
 template<class BaseRenderer, class GlyphGenerator>
 class renderer_raster_vtext_solid
@@ -95,11 +88,10 @@ namespace agg
     typedef typename glyph_gen_type::glyph_rect glyph_rect;
     typedef typename ren_type::color_type color_type;
 
-        renderer_raster_vtext_solid(ren_type& ren, glyph_gen_type& glyph) :
+    renderer_raster_vtext_solid(ren_type& ren, glyph_gen_type& glyph)
-            m_ren(&ren),
+        : m_ren(&ren)
-            m_glyph(&glyph)
+        , m_glyph(&glyph)
-        {
+    {}
-        }
 
     //--------------------------------------------------------------------
     void color(const color_type& c) { m_color = c; }
@@ -120,18 +112,14 @@ namespace agg
                 {
                     for (i = r.y1; i <= r.y2; i++)
                     {
-                            m_ren->blend_solid_vspan(i, r.x1, (r.x2 - r.x1 + 1),
+                        m_ren->blend_solid_vspan(i, r.x1, (r.x2 - r.x1 + 1), m_color, m_glyph->span(i - r.y1));
-                                                     m_color,
-                                                     m_glyph->span(i - r.y1));
                     }
                 }
                 else
                 {
                     for (i = r.y1; i <= r.y2; i++)
                     {
-                            m_ren->blend_solid_vspan(i, r.x1, (r.x2 - r.x1 + 1),
+                        m_ren->blend_solid_vspan(i, r.x1, (r.x2 - r.x1 + 1), m_color, m_glyph->span(r.y2 - i));
-                                                     m_color,
-                                                     m_glyph->span(r.y2 - i));
                     }
                 }
             }
@@ -147,11 +135,6 @@ namespace agg
     color_type m_color;
 };
 
-
-
-
-
-
 //===================================================renderer_raster_htext
 template<class ScanlineRenderer, class GlyphGenerator>
 class renderer_raster_htext
@@ -174,18 +157,19 @@ namespace agg
             const cover_type* covers;
 
             const_span() {}
-                const_span(int x_, unsigned len_, const cover_type* covers_) :
+            const_span(int x_, unsigned len_, const cover_type* covers_)
-                    x(x_), len(len_), covers(covers_) 
+                : x(x_)
+                , len(len_)
+                , covers(covers_)
             {}
         };
 
         typedef const const_span* const_iterator;
 
         //----------------------------------------------------------------
-            scanline_single_span(int x, int y, unsigned len, 
+        scanline_single_span(int x, int y, unsigned len, const cover_type* covers)
-                                 const cover_type* covers) :
+            : m_y(y)
-                m_y(y),
+            , m_span(x, len, covers)
-                m_span(x, len, covers)
         {}
 
         //----------------------------------------------------------------
@@ -199,15 +183,11 @@ namespace agg
         const_span m_span;
     };
 
-
-
     //--------------------------------------------------------------------
-        renderer_raster_htext(ren_type& ren, glyph_gen_type& glyph) :
+    renderer_raster_htext(ren_type& ren, glyph_gen_type& glyph)
-            m_ren(&ren),
+        : m_ren(&ren)
-            m_glyph(&glyph)
+        , m_glyph(&glyph)
-        {
+    {}
-        }
-
 
     //--------------------------------------------------------------------
     template<class CharT>
@@ -225,22 +205,14 @@ namespace agg
                 {
                     for (i = r.y1; i <= r.y2; i++)
                     {
-                            m_ren->render(
+                        m_ren->render(scanline_single_span(r.x1, i, (r.x2 - r.x1 + 1), m_glyph->span(r.y2 - i)));
-                                scanline_single_span(r.x1, 
-                                                     i, 
-                                                     (r.x2 - r.x1 + 1),
-                                                     m_glyph->span(r.y2 - i)));
                     }
                 }
                 else
                 {
                     for (i = r.y1; i <= r.y2; i++)
                     {
-                            m_ren->render(
+                        m_ren->render(scanline_single_span(r.x1, i, (r.x2 - r.x1 + 1), m_glyph->span(i - r.y1)));
-                                scanline_single_span(r.x1, 
-                                                     i, 
-                                                     (r.x2 - r.x1 + 1),
-                                                     m_glyph->span(i - r.y1)));
                     }
                 }
             }
@@ -255,10 +227,6 @@ namespace agg
     glyph_gen_type* m_glyph;
 };
 
-
+} // namespace agg
-
-
-}
 
 #endif
-

deps/agg/include/agg_renderer_scanline.h

@@ -19,14 +19,11 @@
 #include "agg_basics.h"
 #include "agg_renderer_base.h"
 
-namespace agg
+namespace agg {
-{
 
 //================================================render_scanline_aa_solid
 template<class Scanline, class BaseRenderer, class ColorT>
-    void render_scanline_aa_solid(const Scanline& sl,
+void render_scanline_aa_solid(const Scanline& sl, BaseRenderer& ren, const ColorT& color)
-                                  BaseRenderer& ren,
-                                  const ColorT& color)
 {
     int y = sl.y();
     unsigned num_spans = sl.num_spans();
@@ -37,26 +34,21 @@ namespace agg
         int x = span->x;
         if (span->len > 0)
         {
-                ren.blend_solid_hspan(x, y, (unsigned)span->len,
+            ren.blend_solid_hspan(x, y, (unsigned)span->len, color, span->covers);
-                                      color,
-                                      span->covers);
         }
         else
         {
-                ren.blend_hline(x, y, (unsigned)(x - span->len - 1),
+            ren.blend_hline(x, y, (unsigned)(x - span->len - 1), color, *(span->covers));
-                                color,
-                                *(span->covers));
         }
-            if(--num_spans == 0) break;
+        if (--num_spans == 0)
+            break;
         ++span;
     }
 }
 
 //===============================================render_scanlines_aa_solid
-    template<class Rasterizer, class Scanline,
+template<class Rasterizer, class Scanline, class BaseRenderer, class ColorT>
-             class BaseRenderer, class ColorT>
+void render_scanlines_aa_solid(Rasterizer& ras, Scanline& sl, BaseRenderer& ren, const ColorT& color)
-    void render_scanlines_aa_solid(Rasterizer& ras, Scanline& sl,
-                                   BaseRenderer& ren, const ColorT& color)
 {
     if (ras.rewind_scanlines())
     {
@@ -76,19 +68,21 @@ namespace agg
 }
 
 //==============================================renderer_scanline_aa_solid
-    template<class BaseRenderer> class 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) {}
+    renderer_scanline_aa_solid()
-        explicit renderer_scanline_aa_solid(base_ren_type& ren) : m_ren(&ren) {}
+        : m_ren(0)
-        void attach(base_ren_type& ren)
+    {}
-        {
+    explicit renderer_scanline_aa_solid(base_ren_type& ren)
-            m_ren = &ren;
+        : m_ren(&ren)
-        }
+    {}
+    void attach(base_ren_type& ren) { m_ren = &ren; }
 
     //--------------------------------------------------------------------
     void color(const color_type& c) { m_color = c; }
@@ -98,7 +92,8 @@ namespace agg
     void prepare() {}
 
     //--------------------------------------------------------------------
-        template<class Scanline> void render(const Scanline& sl)
+    template<class Scanline>
+    void render(const Scanline& sl)
     {
         render_scanline_aa_solid(sl, *m_ren, m_color);
     }
@@ -108,12 +103,9 @@ namespace agg
     color_type m_color;
 };
 
-
 //======================================================render_scanline_aa
-    template<class Scanline, class BaseRenderer,
+template<class Scanline, class BaseRenderer, class SpanAllocator, class SpanGenerator>
-             class SpanAllocator, class SpanGenerator>
+void render_scanline_aa(const Scanline& sl, BaseRenderer& ren, SpanAllocator& alloc, SpanGenerator& span_gen)
-    void render_scanline_aa(const Scanline& sl, BaseRenderer& ren,
-                            SpanAllocator& alloc, SpanGenerator& span_gen)
 {
     int y = sl.y();
 
@@ -125,22 +117,25 @@ namespace agg
         int len = span->len;
         const typename Scanline::cover_type* covers = span->covers;
 
-            if(len < 0) len = -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,
+        ren.blend_color_hspan(x, y, len, colors, (span->len < 0) ? 0 : covers, *covers);
-                                  (span->len < 0) ? 0 : covers, *covers);
 
-            if(--num_spans == 0) break;
+        if (--num_spans == 0)
+            break;
         ++span;
     }
 }
 
 //======================================================render_scanline_aa_alpha
-    template<class Scanline, class BaseRenderer,
+template<class Scanline, class BaseRenderer, class SpanAllocator, class SpanGenerator>
-             class SpanAllocator, class SpanGenerator>
+void render_scanline_aa_alpha(const Scanline& sl,
-    void render_scanline_aa_alpha(const Scanline& sl, BaseRenderer& ren,
+                              BaseRenderer& ren,
-                            SpanAllocator& alloc, SpanGenerator& span_gen, unsigned alpha)
+                              SpanAllocator& alloc,
+                              SpanGenerator& span_gen,
+                              unsigned alpha)
 {
     int y = sl.y();
 
@@ -152,23 +147,25 @@ namespace agg
         int len = span->len;
         const typename Scanline::cover_type* covers = span->covers;
 
-            if(len < 0) len = -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_alpha(x, y, len, colors, alpha,
+        ren.blend_color_hspan_alpha(x, y, len, colors, alpha, (span->len < 0) ? 0 : covers, *covers);
-                                  (span->len < 0) ? 0 : covers, *covers);
 
-            if(--num_spans == 0) break;
+        if (--num_spans == 0)
+            break;
         ++span;
     }
 }
 
-
 //=====================================================render_scanlines_aa
-    template<class Rasterizer, class Scanline, class BaseRenderer,
+template<class Rasterizer, class Scanline, class BaseRenderer, class SpanAllocator, class SpanGenerator>
-             class SpanAllocator, class SpanGenerator>
+void render_scanlines_aa(Rasterizer& ras,
-    void render_scanlines_aa(Rasterizer& ras, Scanline& sl, BaseRenderer& ren,
+                         Scanline& sl,
-                             SpanAllocator& alloc, SpanGenerator& span_gen)
+                         BaseRenderer& ren,
+                         SpanAllocator& alloc,
+                         SpanGenerator& span_gen)
 {
     if (ras.rewind_scanlines())
     {
@@ -191,17 +188,17 @@ namespace agg
     typedef SpanGenerator span_gen_type;
 
     //--------------------------------------------------------------------
-        renderer_scanline_aa() : m_ren(0), m_alloc(0), m_span_gen(0) {}
+    renderer_scanline_aa()
-        renderer_scanline_aa(base_ren_type& ren,
+        : m_ren(0)
-                             alloc_type& alloc,
+        , m_alloc(0)
-                             span_gen_type& span_gen) :
+        , m_span_gen(0)
-            m_ren(&ren),
-            m_alloc(&alloc),
-            m_span_gen(&span_gen)
     {}
-        void attach(base_ren_type& ren,
+    renderer_scanline_aa(base_ren_type& ren, alloc_type& alloc, span_gen_type& span_gen)
-                    alloc_type& alloc,
+        : m_ren(&ren)
-                    span_gen_type& span_gen)
+        , 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;
@@ -212,7 +209,8 @@ namespace agg
     void prepare() { m_span_gen->prepare(); }
 
     //--------------------------------------------------------------------
-        template<class Scanline> void render(const Scanline& sl)
+    template<class Scanline>
+    void render(const Scanline& sl)
     {
         render_scanline_aa(sl, *m_ren, *m_alloc, *m_span_gen);
     }
@@ -223,7 +221,6 @@ namespace agg
     span_gen_type* m_span_gen;
 };
 
-
 //====================================================renderer_scanline_aa
 template<class BaseRenderer, class SpanAllocator, class SpanGenerator>
 class renderer_scanline_aa_alpha
@@ -234,19 +231,19 @@ namespace agg
     typedef SpanGenerator span_gen_type;
 
     //--------------------------------------------------------------------
-        renderer_scanline_aa_alpha() : m_ren(0), m_alloc(0), m_span_gen(0), m_alpha(1.0) {}
+    renderer_scanline_aa_alpha()
-        renderer_scanline_aa_alpha(base_ren_type& ren,
+        : m_ren(0)
-                             alloc_type& alloc,
+        , m_alloc(0)
-                             span_gen_type& span_gen,
+        , m_span_gen(0)
-                             unsigned alpha) :
+        , m_alpha(1.0)
-            m_ren(&ren),
-            m_alloc(&alloc),
-            m_span_gen(&span_gen),
-            m_alpha(alpha)
     {}
-        void attach(base_ren_type& ren,
+    renderer_scanline_aa_alpha(base_ren_type& ren, alloc_type& alloc, span_gen_type& span_gen, unsigned alpha)
-                    alloc_type& alloc,
+        : m_ren(&ren)
-                    span_gen_type& span_gen)
+        , m_alloc(&alloc)
+        , m_span_gen(&span_gen)
+        , m_alpha(alpha)
+    {}
+    void attach(base_ren_type& ren, alloc_type& alloc, span_gen_type& span_gen)
     {
         m_ren = &ren;
         m_alloc = &alloc;
@@ -257,7 +254,8 @@ namespace agg
     void prepare() { m_span_gen->prepare(); }
 
     //--------------------------------------------------------------------
-        template<class Scanline> void render(const Scanline& sl)
+    template<class Scanline>
+    void render(const Scanline& sl)
     {
         render_scanline_aa_alpha(sl, *m_ren, *m_alloc, *m_span_gen, m_alpha);
     }
@@ -269,34 +267,24 @@ namespace agg
     unsigned m_alpha;
 };
 
-
 //===============================================render_scanline_bin_solid
 template<class Scanline, class BaseRenderer, class ColorT>
-    void render_scanline_bin_solid(const Scanline& sl,
+void render_scanline_bin_solid(const Scanline& sl, BaseRenderer& ren, const ColorT& color)
-                                   BaseRenderer& ren,
-                                   const ColorT& color)
 {
     unsigned num_spans = sl.num_spans();
     typename Scanline::const_iterator span = sl.begin();
     for (;;)
     {
-            ren.blend_hline(span->x,
+        ren.blend_hline(span->x, sl.y(), span->x - 1 + ((span->len < 0) ? -span->len : span->len), color, cover_full);
-                            sl.y(),
+        if (--num_spans == 0)
-                            span->x - 1 + ((span->len < 0) ?
+            break;
-                                              -span->len :
-                                               span->len),
-                               color,
-                               cover_full);
-            if(--num_spans == 0) break;
         ++span;
     }
 }
 
 //==============================================render_scanlines_bin_solid
-    template<class Rasterizer, class Scanline,
+template<class Rasterizer, class Scanline, class BaseRenderer, class ColorT>
-             class BaseRenderer, class ColorT>
+void render_scanlines_bin_solid(Rasterizer& ras, Scanline& sl, BaseRenderer& ren, const ColorT& color)
-    void render_scanlines_bin_solid(Rasterizer& ras, Scanline& sl,
-                                    BaseRenderer& ren, const ColorT& color)
 {
     if (ras.rewind_scanlines())
     {
@@ -322,12 +310,11 @@ namespace agg
             {
                 ren.blend_hline(span->x,
                                 sl.y(),
-                                    span->x - 1 + ((span->len < 0) ?
+                                span->x - 1 + ((span->len < 0) ? -span->len : span->len),
-                                                      -span->len :
-                                                       span->len),
                                 ren_color,
                                 cover_full);
-                    if(--num_spans == 0) break;
+                if (--num_spans == 0)
+                    break;
                 ++span;
             }
         }
@@ -335,19 +322,21 @@ namespace agg
 }
 
 //=============================================renderer_scanline_bin_solid
-    template<class BaseRenderer> class 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) {}
+    renderer_scanline_bin_solid()
-        explicit renderer_scanline_bin_solid(base_ren_type& ren) : m_ren(&ren) {}
+        : m_ren(0)
-        void attach(base_ren_type& ren)
+    {}
-        {
+    explicit renderer_scanline_bin_solid(base_ren_type& ren)
-            m_ren = &ren;
+        : m_ren(&ren)
-        }
+    {}
+    void attach(base_ren_type& ren) { m_ren = &ren; }
 
     //--------------------------------------------------------------------
     void color(const color_type& c) { m_color = c; }
@@ -357,7 +346,8 @@ namespace agg
     void prepare() {}
 
     //--------------------------------------------------------------------
-        template<class Scanline> void render(const Scanline& sl)
+    template<class Scanline>
+    void render(const Scanline& sl)
     {
         render_scanline_bin_solid(sl, *m_ren, m_color);
     }
@@ -367,18 +357,9 @@ namespace agg
     color_type m_color;
 };
 
-
-
-
-
-
-
-
 //======================================================render_scanline_bin
-    template<class Scanline, class BaseRenderer,
+template<class Scanline, class BaseRenderer, class SpanAllocator, class SpanGenerator>
-             class SpanAllocator, class SpanGenerator>
+void render_scanline_bin(const Scanline& sl, BaseRenderer& ren, SpanAllocator& alloc, SpanGenerator& span_gen)
-    void render_scanline_bin(const Scanline& sl, BaseRenderer& ren,
-                             SpanAllocator& alloc, SpanGenerator& span_gen)
 {
     int y = sl.y();
 
@@ -388,20 +369,24 @@ namespace agg
     {
         int x = span->x;
         int len = span->len;
-            if(len < 0) len = -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;
+        if (--num_spans == 0)
+            break;
         ++span;
     }
 }
 
 //=====================================================render_scanlines_bin
-    template<class Rasterizer, class Scanline, class BaseRenderer,
+template<class Rasterizer, class Scanline, class BaseRenderer, class SpanAllocator, class SpanGenerator>
-             class SpanAllocator, class SpanGenerator>
+void render_scanlines_bin(Rasterizer& ras,
-    void render_scanlines_bin(Rasterizer& ras, Scanline& sl, BaseRenderer& ren,
+                          Scanline& sl,
-                              SpanAllocator& alloc, SpanGenerator& span_gen)
+                          BaseRenderer& ren,
+                          SpanAllocator& alloc,
+                          SpanGenerator& span_gen)
 {
     if (ras.rewind_scanlines())
     {
@@ -424,17 +409,17 @@ namespace agg
     typedef SpanGenerator span_gen_type;
 
     //--------------------------------------------------------------------
-        renderer_scanline_bin() : m_ren(0), m_alloc(0), m_span_gen(0) {}
+    renderer_scanline_bin()
-        renderer_scanline_bin(base_ren_type& ren,
+        : m_ren(0)
-                              alloc_type& alloc,
+        , m_alloc(0)
-                              span_gen_type& span_gen) :
+        , m_span_gen(0)
-            m_ren(&ren),
-            m_alloc(&alloc),
-            m_span_gen(&span_gen)
     {}
-        void attach(base_ren_type& ren,
+    renderer_scanline_bin(base_ren_type& ren, alloc_type& alloc, span_gen_type& span_gen)
-                    alloc_type& alloc,
+        : m_ren(&ren)
-                    span_gen_type& span_gen)
+        , 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;
@@ -445,7 +430,8 @@ namespace agg
     void prepare() { m_span_gen->prepare(); }
 
     //--------------------------------------------------------------------
-        template<class Scanline> void render(const Scanline& sl)
+    template<class Scanline>
+    void render(const Scanline& sl)
     {
         render_scanline_bin(sl, *m_ren, *m_alloc, *m_span_gen);
     }
@@ -456,7 +442,6 @@ namespace agg
     span_gen_type* m_span_gen;
 };
 
-
 //========================================================render_scanlines
 template<class Rasterizer, class Scanline, class Renderer>
 void render_scanlines(Rasterizer& ras, Scanline& sl, Renderer& ren)
@@ -472,10 +457,8 @@ namespace agg
     }
 }
 
-
 //========================================================render_all_paths
-    template<class Rasterizer, class Scanline, class Renderer,
+template<class Rasterizer, class Scanline, class Renderer, class VertexSource, class ColorStorage, class PathId>
-             class VertexSource, class ColorStorage, class PathId>
 void render_all_paths(Rasterizer& ras,
                       Scanline& sl,
                       Renderer& r,
@@ -493,11 +476,6 @@ namespace agg
     }
 }
 
-
-
-
-
-
 //=============================================render_scanlines_compound
 template<class Rasterizer,
          class ScanlineAA,
@@ -552,18 +530,11 @@ namespace agg
                         for (;;)
                         {
                             len = span_aa->len;
-                                sh.generate_span(color_span,
+                            sh.generate_span(color_span, span_aa->x, sl_aa.y(), len, style);
-                                                 span_aa->x,
-                                                 sl_aa.y(),
-                                                 len,
-                                                 style);
 
-                                ren.blend_color_hspan(span_aa->x,
+                            ren.blend_color_hspan(span_aa->x, sl_aa.y(), span_aa->len, color_span, span_aa->covers);
-                                                      sl_aa.y(),
+                            if (--num_spans == 0)
-                                                      span_aa->len,
+                                break;
-                                                      color_span,
-                                                      span_aa->covers);
-                                if(--num_spans == 0) break;
                             ++span_aa;
                         }
                     }
@@ -579,11 +550,10 @@ namespace agg
                     num_spans = sl_bin.num_spans();
                     for (;;)
                     {
-                            memset(mix_buffer + span_bin->x - min_x,
+                        memset(mix_buffer + span_bin->x - min_x, 0, span_bin->len * sizeof(color_type));
-                                   0,
-                                   span_bin->len * sizeof(color_type));
 
-                            if(--num_spans == 0) break;
+                        if (--num_spans == 0)
+                            break;
                         ++span_bin;
                     }
 
@@ -622,9 +592,9 @@ namespace agg
                                         }
                                         ++colors;
                                         ++covers;
-                                        }
+                                    } while (--len);
-                                        while(--len);
+                                    if (--num_spans == 0)
-                                        if(--num_spans == 0) break;
+                                        break;
                                     ++span_aa;
                                 }
                             }
@@ -637,11 +607,7 @@ namespace agg
                                     len = span_aa->len;
                                     colors = mix_buffer + span_aa->x - min_x;
                                     cspan = color_span;
-                                        sh.generate_span(cspan,
+                                    sh.generate_span(cspan, span_aa->x, sl_aa.y(), len, style);
-                                                         span_aa->x,
-                                                         sl_aa.y(),
-                                                         len,
-                                                         style);
                                     covers = span_aa->covers;
                                     do
                                     {
@@ -656,9 +622,9 @@ namespace agg
                                         ++cspan;
                                         ++colors;
                                         ++covers;
-                                        }
+                                    } while (--len);
-                                        while(--len);
+                                    if (--num_spans == 0)
-                                        if(--num_spans == 0) break;
+                                        break;
                                     ++span_aa;
                                 }
                             }
@@ -677,7 +643,8 @@ namespace agg
                                               mix_buffer + span_bin->x - min_x,
                                               0,
                                               cover_full);
-                            if(--num_spans == 0) break;
+                        if (--num_spans == 0)
+                            break;
                         ++span_bin;
                     }
                 } // if(ras.sweep_scanline(sl_bin, -1))
@@ -687,11 +654,7 @@ namespace agg
 }
 
 //=======================================render_scanlines_compound_layered
-    template<class Rasterizer,
+template<class Rasterizer, class ScanlineAA, class BaseRenderer, class SpanAllocator, class StyleHandler>
-             class ScanlineAA,
-             class BaseRenderer,
-             class SpanAllocator,
-             class StyleHandler>
 void render_scanlines_compound_layered(Rasterizer& ras,
                                        ScanlineAA& sl_aa,
                                        BaseRenderer& ren,
@@ -738,18 +701,11 @@ namespace agg
                         for (;;)
                         {
                             len = span_aa->len;
-                                sh.generate_span(color_span,
+                            sh.generate_span(color_span, span_aa->x, sl_aa.y(), len, style);
-                                                 span_aa->x,
-                                                 sl_aa.y(),
-                                                 len,
-                                                 style);
 
-                                ren.blend_color_hspan(span_aa->x,
+                            ren.blend_color_hspan(span_aa->x, sl_aa.y(), span_aa->len, color_span, span_aa->covers);
-                                                      sl_aa.y(),
+                            if (--num_spans == 0)
-                                                      span_aa->len,
+                                break;
-                                                      color_span,
-                                                      span_aa->covers);
-                                if(--num_spans == 0) break;
                             ++span_aa;
                         }
                     }
@@ -762,13 +718,9 @@ namespace agg
 
                 if (sl_len)
                 {
-                        memset(mix_buffer + sl_start - min_x,
+                    memset(mix_buffer + sl_start - min_x, 0, sl_len * sizeof(color_type));
-                               0,
-                               sl_len * sizeof(color_type));
 
-                        memset(cover_buffer + sl_start - min_x,
+                    memset(cover_buffer + sl_start - min_x, 0, sl_len * sizeof(cover_type));
-                               0,
-                               sl_len * sizeof(cover_type));
 
                     int sl_y = 0x7FFFFFFF;
                     unsigned i;
@@ -813,9 +765,9 @@ namespace agg
                                         ++colors;
                                         ++src_covers;
                                         ++dst_covers;
-                                        }
+                                    } while (--len);
-                                        while(--len);
+                                    if (--num_spans == 0)
-                                        if(--num_spans == 0) break;
+                                        break;
                                     ++span_aa;
                                 }
                             }
@@ -828,11 +780,7 @@ namespace agg
                                     len = span_aa->len;
                                     colors = mix_buffer + span_aa->x - min_x;
                                     cspan = color_span;
-                                        sh.generate_span(cspan,
+                                    sh.generate_span(cspan, span_aa->x, sl_aa.y(), len, style);
-                                                         span_aa->x,
-                                                         sl_aa.y(),
-                                                         len,
-                                                         style);
                                     src_covers = span_aa->covers;
                                     dst_covers = cover_buffer + span_aa->x - min_x;
                                     do
@@ -851,27 +799,21 @@ namespace agg
                                         ++colors;
                                         ++src_covers;
                                         ++dst_covers;
-                                        }
+                                    } while (--len);
-                                        while(--len);
+                                    if (--num_spans == 0)
-                                        if(--num_spans == 0) break;
+                                        break;
                                     ++span_aa;
                                 }
                             }
                         }
                     }
-                        ren.blend_color_hspan(sl_start,
+                    ren.blend_color_hspan(sl_start, sl_y, sl_len, mix_buffer + sl_start - min_x, 0, cover_full);
-                                              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())
 }
 
-
+} // namespace agg
-}
 
 #endif

deps/agg/include/agg_rendering_buffer.h

@@ -22,37 +22,35 @@
 
 #include "agg_array.h"
 
-namespace agg
+namespace agg {
-{
 
 //===========================================================row_accessor
-    template<class T> class row_accessor
+template<class T>
+class row_accessor
 {
   public:
     typedef const_row_info<T> row_data;
 
     //-------------------------------------------------------------------
-        row_accessor() :
+    row_accessor()
-            m_buf(0),
+        : m_buf(0)
-            m_start(0),
+        , m_start(0)
-            m_width(0),
+        , m_width(0)
-            m_height(0),
+        , m_height(0)
-            m_stride(0)
+        , m_stride(0)
-        {
+    {}
-        }
 
     //--------------------------------------------------------------------
-        row_accessor(T* buf, unsigned width, unsigned height, int stride) :
+    row_accessor(T* buf, unsigned width, unsigned height, int stride)
-            m_buf(0),
+        : m_buf(0)
-            m_start(0),
+        , m_start(0)
-            m_width(0),
+        , m_width(0)
-            m_height(0),
+        , m_height(0)
-            m_stride(0)
+        , m_stride(0)
     {
         attach(buf, width, height, stride);
     }
 
-
     //--------------------------------------------------------------------
     void attach(T* buf, unsigned width, unsigned height, int stride)
     {
@@ -72,32 +70,25 @@ namespace agg
     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 
+    AGG_INLINE unsigned stride_abs() const { return (m_stride < 0) ? unsigned(-m_stride) : unsigned(m_stride); }
-        {
-            return (m_stride < 0) ? unsigned(-m_stride) : unsigned(m_stride); 
-        }
 
     //--------------------------------------------------------------------
-        AGG_INLINE       T* row_ptr(int, int y, unsigned) 
+    AGG_INLINE T* row_ptr(int, int y, unsigned) { return m_start + y * m_stride; }
-        { 
-            return m_start + y * m_stride; 
-        }
     AGG_INLINE T* row_ptr(int y) { return m_start + y * m_stride; }
     AGG_INLINE const T* row_ptr(int y) const { return m_start + y * m_stride; }
-        AGG_INLINE row_data row    (int y) const 
+    AGG_INLINE row_data row(int y) const { return row_data(0, m_width - 1, row_ptr(y)); }
-        { 
-            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();
+        if (src.height() < h)
+            h = src.height();
 
         unsigned l = stride_abs();
-            if(src.stride_abs() < l) l = src.stride_abs();
+        if (src.stride_abs() < l)
+            l = src.stride_abs();
 
         l *= sizeof(T);
 
@@ -135,32 +126,29 @@ namespace agg
     int m_stride;      // Number of bytes per row. Can be < 0
 };
 
-
-
-
 //==========================================================row_ptr_cache
-    template<class T> class row_ptr_cache
+template<class T>
+class row_ptr_cache
 {
   public:
     typedef const_row_info<T> row_data;
 
     //-------------------------------------------------------------------
-        row_ptr_cache() :
+    row_ptr_cache()
-            m_buf(0),
+        : m_buf(0)
-            m_rows(),
+        , m_rows()
-            m_width(0),
+        , m_width(0)
-            m_height(0),
+        , m_height(0)
-            m_stride(0)
+        , m_stride(0)
-        {
+    {}
-        }
 
     //--------------------------------------------------------------------
-        row_ptr_cache(T* buf, unsigned width, unsigned height, int stride) :
+    row_ptr_cache(T* buf, unsigned width, unsigned height, int stride)
-            m_buf(0),
+        : m_buf(0)
-            m_rows(),
+        , m_rows()
-            m_width(0),
+        , m_width(0)
-            m_height(0),
+        , m_height(0)
-            m_stride(0)
+        , m_stride(0)
     {
         attach(buf, width, height, stride);
     }
@@ -204,22 +192,13 @@ namespace agg
     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 
+    AGG_INLINE unsigned stride_abs() const { return (m_stride < 0) ? unsigned(-m_stride) : unsigned(m_stride); }
-        {
-            return (m_stride < 0) ? unsigned(-m_stride) : unsigned(m_stride); 
-        }
 
     //--------------------------------------------------------------------
-        AGG_INLINE       T* row_ptr(int, int y, unsigned) 
+    AGG_INLINE T* row_ptr(int, int y, unsigned) { return m_rows[y]; }
-        { 
-            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 
+    AGG_INLINE row_data row(int y) const { return row_data(0, m_width - 1, m_rows[y]); }
-        { 
-            return row_data(0, m_width-1, m_rows[y]); 
-        }
 
     //--------------------------------------------------------------------
     T const* const* rows() const { return &m_rows[0]; }
@@ -229,10 +208,12 @@ namespace agg
     void copy_from(const RenBuf& src)
     {
         unsigned h = height();
-            if(src.height() < h) h = src.height();
+        if (src.height() < h)
+            h = src.height();
 
         unsigned l = stride_abs();
-            if(src.stride_abs() < l) l = src.stride_abs();
+        if (src.stride_abs() < l)
+            l = src.stride_abs();
 
         l *= sizeof(T);
 
@@ -270,9 +251,6 @@ namespace agg
     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
@@ -299,7 +277,6 @@ namespace agg
 // typedef row_accessor<int8u> rendering_buffer;
 #endif
 
-}
+} // namespace agg
-
 
 #endif

deps/agg/include/agg_rendering_buffer_dynarow.h

@@ -22,8 +22,7 @@
 
 #include "agg_array.h"
 
-namespace agg
+namespace agg {
-{
 
 //===============================================rendering_buffer_dynarow
 // Rendering buffer class with dynamic allocation of the rows.
@@ -38,28 +37,23 @@ namespace agg
     typedef row_info<int8u> row_data;
 
     //-------------------------------------------------------------------
-        ~rendering_buffer_dynarow()
+    ~rendering_buffer_dynarow() { init(0, 0, 0); }
-        {
-            init(0,0,0);
-        }
 
     //-------------------------------------------------------------------
-        rendering_buffer_dynarow() :
+    rendering_buffer_dynarow()
-            m_rows(),
+        : m_rows()
-            m_width(0),
+        , m_width(0)
-            m_height(0),
+        , m_height(0)
-            m_byte_width(0)
+        , m_byte_width(0)
-        {
+    {}
-        }
 
     // Allocate and clear the buffer
     //--------------------------------------------------------------------
-        rendering_buffer_dynarow(unsigned width, unsigned height, 
+    rendering_buffer_dynarow(unsigned width, unsigned height, unsigned byte_width)
-                                 unsigned byte_width) :
+        : m_rows(height)
-            m_rows(height),
+        , m_width(width)
-            m_width(width),
+        , m_height(height)
-            m_height(height),
+        , m_byte_width(byte_width)
-            m_byte_width(byte_width)
     {
         memset(&m_rows[0], 0, sizeof(row_data) * height);
     }
@@ -97,8 +91,14 @@ namespace agg
         int x2 = x + len - 1;
         if (r->ptr)
         {
-                if(x  < r->x1) { r->x1 = x;  }
+            if (x < r->x1)
-                if(x2 > r->x2) { r->x2 = x2; }
+            {
+                r->x1 = x;
+            }
+            if (x2 > r->x2)
+            {
+                r->x2 = x2;
+            }
         }
         else
         {
@@ -130,8 +130,6 @@ namespace agg
     unsigned m_byte_width;      // Width in bytes
 };
 
-
+} // namespace agg
-}
-
 
 #endif

deps/agg/include/agg_rounded_rect.h

@@ -23,8 +23,7 @@
 #include "agg_basics.h"
 #include "agg_arc.h"
 
-namespace agg
+namespace agg {
-{
 //------------------------------------------------------------rounded_rect
 //
 // See Implemantation agg_rounded_rect.cpp
@@ -39,8 +38,7 @@ namespace agg
     void radius(double r);
     void radius(double rx, double ry);
     void radius(double rx_bottom, double ry_bottom, double rx_top, double ry_top);
-        void radius(double rx1, double ry1, double rx2, double ry2, 
+    void radius(double rx1, double ry1, double rx2, double ry2, double rx3, double ry3, double rx4, double ry4);
-                    double rx3, double ry3, double rx4, double ry4);
     void normalize_radius();
 
     void approximation_scale(double s) { m_arc.approximation_scale(s); }
@@ -66,7 +64,6 @@ namespace agg
     arc m_arc;
 };
 
-}
+} // namespace agg
 
 #endif
-

deps/agg/include/agg_scanline_bin.h

@@ -30,8 +30,7 @@
 
 #include "agg_array.h"
 
-namespace agg
+namespace agg {
-{
 
 //=============================================================scanline_bin
 //
@@ -54,12 +53,11 @@ namespace agg
     typedef const span* const_iterator;
 
     //--------------------------------------------------------------------
-        scanline_bin() :
+    scanline_bin()
-            m_last_x(0x7FFFFFF0),
+        : m_last_x(0x7FFFFFF0)
-            m_spans(),
+        , m_spans()
-            m_cur_span(0)
+        , m_cur_span(0)
-        {
+    {}
-        }
 
     //--------------------------------------------------------------------
     void reset(int min_x, int max_x)
@@ -106,16 +104,10 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        void add_cells(int x, unsigned len, const void*)
+    void add_cells(int x, unsigned len, const void*) { add_span(x, len, 0); }
-        {
-            add_span(x, len, 0);
-        }
 
     //--------------------------------------------------------------------
-        void finalize(int y) 
+    void finalize(int y) { m_y = y; }
-        { 
-            m_y = y; 
-        }
 
     //--------------------------------------------------------------------
     void reset_spans()
@@ -139,11 +131,6 @@ namespace agg
     span* m_cur_span;
 };
 
-
-
-
-
-
 //===========================================================scanline32_bin
 class scanline32_bin
 {
@@ -154,21 +141,23 @@ namespace agg
     struct span
     {
         span() {}
-            span(coord_type x_, coord_type len_) : x(x_), len(len_) {}
+        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) :
+        const_iterator(const span_array_type& spans)
-                m_spans(spans),
+            : m_spans(spans)
-                m_span_idx(0)
+            , m_span_idx(0)
         {}
 
         const span& operator*() const { return m_spans[m_span_idx]; }
@@ -181,9 +170,11 @@ namespace agg
         unsigned m_span_idx;
     };
 
-
     //--------------------------------------------------------------------
-        scanline32_bin() : m_max_len(0), m_last_x(0x7FFFFFF0) {}
+    scanline32_bin()
+        : m_max_len(0)
+        , m_last_x(0x7FFFFFF0)
+    {}
 
     //--------------------------------------------------------------------
     void reset(int, int)
@@ -221,16 +212,10 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        void add_cells(int x, unsigned len, const void*)
+    void add_cells(int x, unsigned len, const void*) { add_span(x, len, 0); }
-        {
-            add_span(x, len, 0);
-        }
 
     //--------------------------------------------------------------------
-        void finalize(int y) 
+    void finalize(int y) { m_y = y; }
-        { 
-            m_y = y; 
-        }
 
     //--------------------------------------------------------------------
     void reset_spans()
@@ -254,11 +239,6 @@ namespace agg
     span_array_type m_spans;
 };
 
-
+} // namespace agg
-
-
-
-}
-
 
 #endif

deps/agg/include/agg_scanline_p.h

@@ -29,8 +29,7 @@
 
 #include "agg_array.h"
 
-namespace agg
+namespace agg {
-{
 
 //=============================================================scanline_p8
 //
@@ -57,14 +56,13 @@ namespace agg
     typedef span* iterator;
     typedef const span* const_iterator;
 
-        scanline_p8() :
+    scanline_p8()
-            m_last_x(0x7FFFFFF0),
+        : m_last_x(0x7FFFFFF0)
-            m_covers(),
+        , m_covers()
-            m_cover_ptr(0),
+        , m_cover_ptr(0)
-            m_spans(),
+        , m_spans()
-            m_cur_span(0)
+        , m_cur_span(0)
-        {
+    {}
-        }
 
     //--------------------------------------------------------------------
     void reset(int min_x, int max_x)
@@ -122,9 +120,7 @@ namespace agg
     //--------------------------------------------------------------------
     void add_span(int x, unsigned len, unsigned cover)
     {
-            if(x == m_last_x+1 && 
+        if (x == m_last_x + 1 && m_cur_span->len < 0 && cover == *m_cur_span->covers)
-               m_cur_span->len < 0 && 
-               cover == *m_cur_span->covers)
         {
             m_cur_span->len -= (int16)len;
         }
@@ -140,10 +136,7 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        void finalize(int y) 
+    void finalize(int y) { m_y = y; }
-        { 
-            m_y = y; 
-        }
 
     //--------------------------------------------------------------------
     void reset_spans()
@@ -171,13 +164,6 @@ namespace agg
     span* m_cur_span;
 };
 
-
-
-
-
-
-
-
 //==========================================================scanline32_p8
 class scanline32_p8
 {
@@ -189,8 +175,11 @@ namespace agg
     struct span
     {
         span() {}
-            span(coord_type x_, coord_type len_, const cover_type* covers_) :
+        span(coord_type x_, coord_type len_, const cover_type* covers_)
-                x(x_), len(len_), covers(covers_) {}
+            : x(x_)
+            , len(len_)
+            , covers(covers_)
+        {}
 
         coord_type x;
         coord_type len; // If negative, it's a solid span, covers is valid
@@ -198,14 +187,13 @@ namespace agg
     };
     typedef pod_bvector<span, 4> span_array_type;
 
-
     //--------------------------------------------------------------------
     class const_iterator
     {
       public:
-            const_iterator(const span_array_type& spans) :
+        const_iterator(const span_array_type& spans)
-                m_spans(spans),
+            : m_spans(spans)
-                m_span_idx(0)
+            , m_span_idx(0)
         {}
 
         const span& operator*() const { return m_spans[m_span_idx]; }
@@ -219,13 +207,12 @@ namespace agg
     };
 
     //--------------------------------------------------------------------
-        scanline32_p8() :
+    scanline32_p8()
-            m_max_len(0),
+        : m_max_len(0)
-            m_last_x(0x7FFFFFF0),
+        , m_last_x(0x7FFFFFF0)
-            m_covers(),
+        , m_covers()
-            m_cover_ptr(0)
+        , m_cover_ptr(0)
-        {
+    {}
-        }
 
     //--------------------------------------------------------------------
     void reset(int min_x, int max_x)
@@ -275,10 +262,7 @@ namespace agg
     //--------------------------------------------------------------------
     void add_span(int x, unsigned len, unsigned cover)
     {
-            if(x == m_last_x+1 && 
+        if (x == m_last_x + 1 && m_spans.size() && m_spans.last().len < 0 && cover == *m_spans.last().covers)
-               m_spans.size() &&
-               m_spans.last().len < 0 && 
-               cover == *m_spans.last().covers)
         {
             m_spans.last().len -= coord_type(len);
         }
@@ -291,10 +275,7 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        void finalize(int y) 
+    void finalize(int y) { m_y = y; }
-        { 
-            m_y = y; 
-        }
 
     //--------------------------------------------------------------------
     void reset_spans()
@@ -321,9 +302,6 @@ namespace agg
     span_array_type m_spans;
 };
 
-
+} // namespace agg
-}
-
 
 #endif
-

deps/agg/include/agg_scanline_storage_aa.h

@@ -29,12 +29,11 @@
 #include <cmath>
 #include "agg_array.h"
 
-
+namespace agg {
-namespace agg
-{
 
 //----------------------------------------------scanline_cell_storage
-    template<class T> class scanline_cell_storage
+template<class T>
+class scanline_cell_storage
 {
     struct extra_span
     {
@@ -46,30 +45,25 @@ namespace agg
     typedef T value_type;
 
     //---------------------------------------------------------------
-        ~scanline_cell_storage()
+    ~scanline_cell_storage() { remove_all(); }
-        {
-            remove_all();
-        }
 
     //---------------------------------------------------------------
-        scanline_cell_storage() :
+    scanline_cell_storage()
-            m_cells(128-2),
+        : m_cells(128 - 2)
-            m_extra_storage()
+        , m_extra_storage()
     {}
 
-
     // Copying
     //---------------------------------------------------------------
-        scanline_cell_storage(const scanline_cell_storage<T>& v) :
+    scanline_cell_storage(const scanline_cell_storage<T>& v)
-            m_cells(v.m_cells),
+        : m_cells(v.m_cells)
-            m_extra_storage()
+        , m_extra_storage()
     {
         copy_extra_storage(v);
     }
 
     //---------------------------------------------------------------
-        const scanline_cell_storage<T>& 
+    const scanline_cell_storage<T>& operator=(const scanline_cell_storage<T>& v)
-        operator = (const scanline_cell_storage<T>& v)
     {
         remove_all();
         m_cells = v.m_cells;
@@ -83,8 +77,7 @@ namespace agg
         int i;
         for (i = m_extra_storage.size() - 1; i >= 0; --i)
         {
-                pod_allocator<T>::deallocate(m_extra_storage[i].ptr,
+            pod_allocator<T>::deallocate(m_extra_storage[i].ptr, m_extra_storage[i].len);
-                                             m_extra_storage[i].len);
         }
         m_extra_storage.remove_all();
         m_cells.remove_all();
@@ -113,11 +106,13 @@ namespace agg
     {
         if (idx >= 0)
         {
-                if((unsigned)idx >= m_cells.size()) return 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;
+        if (i >= m_extra_storage.size())
+            return 0;
         return m_extra_storage[i].ptr;
     }
 
@@ -126,11 +121,13 @@ namespace agg
     {
         if (idx >= 0)
         {
-                if((unsigned)idx >= m_cells.size()) return 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;
+        if (i >= m_extra_storage.size())
+            return 0;
         return m_extra_storage[i].ptr;
     }
 
@@ -153,13 +150,9 @@ namespace agg
     pod_bvector<extra_span, 6> m_extra_storage;
 };
 
-
-
-
-
-
 //-----------------------------------------------scanline_storage_aa
-    template<class T> class scanline_storage_aa
+template<class T>
+class scanline_storage_aa
 {
   public:
     typedef T cover_type;
@@ -180,7 +173,6 @@ namespace agg
         unsigned start_span;
     };
 
-
     //---------------------------------------------------------------
     class embedded_scanline
     {
@@ -197,10 +189,12 @@ namespace agg
                 const T* covers;
             };
 
-                const_iterator() : m_storage(0) {}
+            const_iterator()
-                const_iterator(const embedded_scanline& sl) :
+                : m_storage(0)
-                    m_storage(sl.m_storage),
+            {}
-                    m_span_idx(sl.m_scanline.start_span)
+            const_iterator(const embedded_scanline& sl)
+                : m_storage(sl.m_storage)
+                , m_span_idx(sl.m_scanline.start_span)
             {
                 init_span();
             }
@@ -230,10 +224,9 @@ namespace agg
 
         friend class const_iterator;
 
-
         //-----------------------------------------------------------
-            embedded_scanline(const scanline_storage_aa& storage) :
+        embedded_scanline(const scanline_storage_aa& storage)
-                m_storage(&storage)
+            : m_storage(&storage)
         {
             init(0);
         }
@@ -257,17 +250,17 @@ namespace agg
         unsigned m_scanline_idx;
     };
 
-
     //---------------------------------------------------------------
-        scanline_storage_aa() :
+    scanline_storage_aa()
-            m_covers(),
+        : m_covers()
-            m_spans(256-2),         // Block increment size
+        , m_spans(256 - 2)
-            m_scanlines(),
+        , // Block increment size
-            m_min_x( 0x7FFFFFFF),
+        m_scanlines()
-            m_min_y( 0x7FFFFFFF),
+        , m_min_x(0x7FFFFFFF)
-            m_max_x(-0x7FFFFFFF),
+        , m_min_y(0x7FFFFFFF)
-            m_max_y(-0x7FFFFFFF),
+        , m_max_x(-0x7FFFFFFF)
-            m_cur_scanline(0)
+        , m_max_y(-0x7FFFFFFF)
+        , m_cur_scanline(0)
     {
         m_fake_scanline.y = 0;
         m_fake_scanline.num_spans = 0;
@@ -292,13 +285,16 @@ namespace agg
     }
 
     //---------------------------------------------------------------
-        template<class Scanline> void render(const Scanline& sl)
+    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_min_y)
-            if(y > m_max_y) m_max_y = 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();
@@ -313,21 +309,21 @@ namespace agg
             sp.x = span_iterator->x;
             sp.len = span_iterator->len;
             int len = std::abs(int(sp.len));
-                sp.covers_id = 
+            sp.covers_id = m_covers.add_cells(span_iterator->covers, unsigned(len));
-                    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 (x1 < m_min_x)
-                if(x2 > m_max_x) m_max_x = x2;
+                m_min_x = x1;
-                if(--num_spans == 0) break;
+            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; }
@@ -342,14 +338,15 @@ namespace agg
         return m_scanlines.size() > 0;
     }
 
-
     //---------------------------------------------------------------
-        template<class Scanline> bool sweep_scanline(Scanline& sl)
+    template<class Scanline>
+    bool sweep_scanline(Scanline& sl)
     {
         sl.reset_spans();
         for (;;)
         {
-                if(m_cur_scanline >= m_scanlines.size()) return false;
+            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;
@@ -366,8 +363,7 @@ namespace agg
                 {
                     sl.add_cells(sp.x, sp.len, covers);
                 }
-                }
+            } while (--num_spans);
-                while(--num_spans);
             ++m_cur_scanline;
             if (sl.num_spans())
             {
@@ -378,18 +374,17 @@ namespace agg
         return true;
     }
 
-
     //---------------------------------------------------------------
     // Specialization for embedded_scanline
     bool sweep_scanline(embedded_scanline& sl)
     {
         do
         {
-                if(m_cur_scanline >= m_scanlines.size()) return false;
+            if (m_cur_scanline >= m_scanlines.size())
+                return false;
             sl.init(m_cur_scanline);
             ++m_cur_scanline;
-            }
+        } while (sl.num_spans() == 0);
-            while(sl.num_spans() == 0);
         return true;
     }
 
@@ -420,13 +415,11 @@ namespace agg
                 {
                     size += sizeof(T) * unsigned(sp.len); // covers
                 }
-                }
+            } while (--num_spans);
-                while(--num_spans);
         }
         return size;
     }
 
-
     //---------------------------------------------------------------
     static void write_int32(int8u* dst, int32 val)
     {
@@ -436,7 +429,6 @@ namespace agg
         dst[3] = ((const int8u*)&val)[3];
     }
 
-
     //---------------------------------------------------------------
     void serialize(int8u* data) const
     {
@@ -487,13 +479,11 @@ namespace agg
                     memcpy(data, covers, unsigned(sp.len) * sizeof(T));
                     data += sizeof(T) * unsigned(sp.len);
                 }
-                }
+            } while (--num_spans);
-                while(--num_spans);
             write_int32(size_ptr, int32(unsigned(data - size_ptr)));
         }
     }
 
-
     //---------------------------------------------------------------
     const scanline_data& scanline_by_index(unsigned i) const
     {
@@ -501,16 +491,10 @@ namespace agg
     }
 
     //---------------------------------------------------------------
-        const span_data& span_by_index(unsigned i) const
+    const span_data& span_by_index(unsigned i) const { return (i < m_spans.size()) ? m_spans[i] : m_fake_span; }
-        {
-            return (i < m_spans.size()) ? m_spans[i] : m_fake_span;
-        }
 
     //---------------------------------------------------------------
-        const T* covers_by_index(int i) const
+    const T* covers_by_index(int i) const { return m_covers[i]; }
-        {
-            return m_covers[i];
-        }
 
   private:
     scanline_cell_storage<T> m_covers;
@@ -525,16 +509,13 @@ namespace agg
     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
+template<class T>
+class serialized_scanlines_adaptor_aa
 {
   public:
     typedef T cover_type;
@@ -556,10 +537,12 @@ namespace agg
                 const T* covers;
             };
 
-                const_iterator() : m_ptr(0) {}
+            const_iterator()
-                const_iterator(const embedded_scanline& sl) :
+                : m_ptr(0)
-                    m_ptr(sl.m_ptr),
+            {}
-                    m_dx(sl.m_dx)
+            const_iterator(const embedded_scanline& sl)
+                : m_ptr(sl.m_ptr)
+                , m_dx(sl.m_dx)
             {
                 init_span();
             }
@@ -605,9 +588,12 @@ namespace agg
 
         friend class const_iterator;
 
-
         //-----------------------------------------------------------------
-            embedded_scanline() : m_ptr(0), m_y(0), m_num_spans(0) {}
+        embedded_scanline()
+            : m_ptr(0)
+            , m_y(0)
+            , m_num_spans(0)
+        {}
 
         //-----------------------------------------------------------------
         void reset(int, int) {}
@@ -615,7 +601,6 @@ namespace agg
         int y() const { return m_y; }
         const_iterator begin() const { return const_iterator(*this); }
 
-
       private:
         //-----------------------------------------------------------------
         int read_int32()
@@ -645,34 +630,31 @@ namespace agg
         int m_dx;
     };
 
-
-
   public:
     //--------------------------------------------------------------------
-        serialized_scanlines_adaptor_aa() :
+    serialized_scanlines_adaptor_aa()
-            m_data(0),
+        : m_data(0)
-            m_end(0),
+        , m_end(0)
-            m_ptr(0),
+        , m_ptr(0)
-            m_dx(0),
+        , m_dx(0)
-            m_dy(0),
+        , m_dy(0)
-            m_min_x(0x7FFFFFFF),
+        , m_min_x(0x7FFFFFFF)
-            m_min_y(0x7FFFFFFF),
+        , m_min_y(0x7FFFFFFF)
-            m_max_x(-0x7FFFFFFF),
+        , m_max_x(-0x7FFFFFFF)
-            m_max_y(-0x7FFFFFFF)
+        , m_max_y(-0x7FFFFFFF)
     {}
 
     //--------------------------------------------------------------------
-        serialized_scanlines_adaptor_aa(const int8u* data, unsigned size,
+    serialized_scanlines_adaptor_aa(const int8u* data, unsigned size, double dx, double dy)
-                                        double dx, double dy) :
+        : m_data(data)
-            m_data(data),
+        , m_end(data + size)
-            m_end(data + size),
+        , m_ptr(data)
-            m_ptr(data),
+        , m_dx(iround(dx))
-            m_dx(iround(dx)),
+        , m_dy(iround(dy))
-            m_dy(iround(dy)),
+        , m_min_x(0x7FFFFFFF)
-            m_min_x(0x7FFFFFFF),
+        , m_min_y(0x7FFFFFFF)
-            m_min_y(0x7FFFFFFF),
+        , m_max_x(-0x7FFFFFFF)
-            m_max_x(-0x7FFFFFFF),
+        , m_max_y(-0x7FFFFFFF)
-            m_max_y(-0x7FFFFFFF)
     {}
 
     //--------------------------------------------------------------------
@@ -735,12 +717,14 @@ namespace agg
     int max_y() const { return m_max_y; }
 
     //--------------------------------------------------------------------
-        template<class Scanline> bool sweep_scanline(Scanline& sl)
+    template<class Scanline>
+    bool sweep_scanline(Scanline& sl)
     {
         sl.reset_spans();
         for (;;)
         {
-                if(m_ptr >= m_end) return false;
+            if (m_ptr >= m_end)
+                return false;
 
             read_int32(); // Skip scanline size in bytes
             int y = read_int32() + m_dy;
@@ -761,8 +745,7 @@ namespace agg
                     sl.add_cells(x, len, m_ptr);
                     m_ptr += len * sizeof(T);
                 }
-                }
+            } while (--num_spans);
-                while(--num_spans);
 
             if (sl.num_spans())
             {
@@ -773,20 +756,19 @@ namespace agg
         return true;
     }
 
-
     //--------------------------------------------------------------------
     // Specialization for embedded_scanline
     bool sweep_scanline(embedded_scanline& sl)
     {
         do
         {
-                if(m_ptr >= m_end) return false;
+            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);
-            while(sl.num_spans() == 0);
         return true;
     }
 
@@ -802,14 +784,12 @@ namespace agg
     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<int16u>
-    typedef serialized_scanlines_adaptor_aa<int32u> serialized_scanlines_adaptor_aa32; //----serialized_scanlines_adaptor_aa32
+  serialized_scanlines_adaptor_aa16; //----serialized_scanlines_adaptor_aa16
-
+typedef serialized_scanlines_adaptor_aa<int32u>
-}
+  serialized_scanlines_adaptor_aa32; //----serialized_scanlines_adaptor_aa32
 
+} // namespace agg
 
 #endif
-

deps/agg/include/agg_scanline_storage_bin.h

@@ -21,7 +21,6 @@
 //
 //----------------------------------------------------------------------------
 
-
 #ifndef AGG_SCANLINE_STORAGE_BIN_INCLUDED
 #define AGG_SCANLINE_STORAGE_BIN_INCLUDED
 
@@ -30,9 +29,7 @@
 #include <cmath>
 #include "agg_array.h"
 
-
+namespace agg {
-namespace agg
-{
 
 //-----------------------------------------------scanline_storage_bin
 class scanline_storage_bin
@@ -53,7 +50,6 @@ namespace agg
         unsigned start_span;
     };
 
-
     //---------------------------------------------------------------
     class embedded_scanline
     {
@@ -63,10 +59,12 @@ namespace agg
         class const_iterator
         {
           public:
-                const_iterator() : m_storage(0) {}
+            const_iterator()
-                const_iterator(const embedded_scanline& sl) :
+                : m_storage(0)
-                    m_storage(sl.m_storage),
+            {}
-                    m_span_idx(sl.m_scanline.start_span)
+            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);
             }
@@ -88,10 +86,9 @@ namespace agg
 
         friend class const_iterator;
 
-
         //-----------------------------------------------------------
-            embedded_scanline(const scanline_storage_bin& storage) :
+        embedded_scanline(const scanline_storage_bin& storage)
-                m_storage(&storage)
+            : m_storage(&storage)
         {
             setup(0);
         }
@@ -115,16 +112,16 @@ namespace agg
         unsigned m_scanline_idx;
     };
 
-
     //---------------------------------------------------------------
-        scanline_storage_bin() :
+    scanline_storage_bin()
-            m_spans(256-2),         // Block increment size
+        : m_spans(256 - 2)
-            m_scanlines(),
+        , // Block increment size
-            m_min_x( 0x7FFFFFFF),
+        m_scanlines()
-            m_min_y( 0x7FFFFFFF),
+        , m_min_x(0x7FFFFFFF)
-            m_max_x(-0x7FFFFFFF),
+        , m_min_y(0x7FFFFFFF)
-            m_max_y(-0x7FFFFFFF),
+        , m_max_x(-0x7FFFFFFF)
-            m_cur_scanline(0)
+        , m_max_y(-0x7FFFFFFF)
+        , m_cur_scanline(0)
     {
         m_fake_scanline.y = 0;
         m_fake_scanline.num_spans = 0;
@@ -147,13 +144,16 @@ namespace agg
     }
 
     //---------------------------------------------------------------
-        template<class Scanline> void render(const Scanline& sl)
+    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_min_y)
-            if(y > m_max_y) m_max_y = 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();
@@ -169,15 +169,17 @@ namespace agg
             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 (x1 < m_min_x)
-                if(x2 > m_max_x) m_max_x = x2;
+                m_min_x = x1;
-                if(--num_spans == 0) break;
+            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; }
@@ -192,14 +194,15 @@ namespace agg
         return m_scanlines.size() > 0;
     }
 
-
     //---------------------------------------------------------------
-        template<class Scanline> bool sweep_scanline(Scanline& sl)
+    template<class Scanline>
+    bool sweep_scanline(Scanline& sl)
     {
         sl.reset_spans();
         for (;;)
         {
-                if(m_cur_scanline >= m_scanlines.size()) return false;
+            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;
@@ -208,8 +211,7 @@ namespace agg
             {
                 const span_data& sp = m_spans[span_idx++];
                 sl.add_span(sp.x, sp.len, cover_full);
-                }
+            } while (--num_spans);
-                while(--num_spans);
 
             ++m_cur_scanline;
             if (sl.num_spans())
@@ -221,22 +223,20 @@ namespace agg
         return true;
     }
 
-
     //---------------------------------------------------------------
     // Specialization for embedded_scanline
     bool sweep_scanline(embedded_scanline& sl)
     {
         do
         {
-                if(m_cur_scanline >= m_scanlines.size()) return false;
+            if (m_cur_scanline >= m_scanlines.size())
+                return false;
             sl.setup(m_cur_scanline);
             ++m_cur_scanline;
-            }
+        } while (sl.num_spans() == 0);
-            while(sl.num_spans() == 0);
         return true;
     }
 
-
     //---------------------------------------------------------------
     unsigned byte_size() const
     {
@@ -251,7 +251,6 @@ namespace agg
         return size;
     }
 
-
     //---------------------------------------------------------------
     static void write_int32(int8u* dst, int32 val)
     {
@@ -261,7 +260,6 @@ namespace agg
         dst[3] = ((const int8u*)&val)[3];
     }
 
-
     //---------------------------------------------------------------
     void serialize(int8u* data) const
     {
@@ -297,12 +295,10 @@ namespace agg
 
                 write_int32(data, sp.len); // len
                 data += sizeof(int32);
-                }
+            } while (--num_spans);
-                while(--num_spans);
         }
     }
 
-
     //---------------------------------------------------------------
     const scanline_data& scanline_by_index(unsigned i) const
     {
@@ -310,11 +306,7 @@ namespace agg
     }
 
     //---------------------------------------------------------------
-        const span_data& span_by_index(unsigned i) const
+    const span_data& span_by_index(unsigned i) const { return (i < m_spans.size()) ? m_spans[i] : m_fake_span; }
-        {
-            return (i < m_spans.size()) ? m_spans[i] : m_fake_span;
-        }
-
 
   private:
     pod_bvector<span_data, 10> m_spans;
@@ -328,18 +320,6 @@ namespace agg
     unsigned m_cur_scanline;
 };
 
-
-
-
-
-
-
-
-
-
-
-
-
 //---------------------------------------serialized_scanlines_adaptor_bin
 class serialized_scanlines_adaptor_bin
 {
@@ -361,10 +341,12 @@ namespace agg
                 int32 len;
             };
 
-                const_iterator() : m_ptr(0) {}
+            const_iterator()
-                const_iterator(const embedded_scanline& sl) :
+                : m_ptr(0)
-                    m_ptr(sl.m_ptr),
+            {}
-                    m_dx(sl.m_dx)
+            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();
@@ -397,9 +379,12 @@ namespace agg
 
         friend class const_iterator;
 
-
         //----------------------------------------------------------------
-            embedded_scanline() : m_ptr(0), m_y(0), m_num_spans(0) {}
+        embedded_scanline()
+            : m_ptr(0)
+            , m_y(0)
+            , m_num_spans(0)
+        {}
 
         //----------------------------------------------------------------
         void reset(int, int) {}
@@ -407,7 +392,6 @@ namespace agg
         int y() const { return m_y; }
         const_iterator begin() const { return const_iterator(*this); }
 
-
       private:
         //----------------------------------------------------------------
         int read_int32()
@@ -437,34 +421,31 @@ namespace agg
         int m_dx;
     };
 
-
-
   public:
     //--------------------------------------------------------------------
-        serialized_scanlines_adaptor_bin() :
+    serialized_scanlines_adaptor_bin()
-            m_data(0),
+        : m_data(0)
-            m_end(0),
+        , m_end(0)
-            m_ptr(0),
+        , m_ptr(0)
-            m_dx(0),
+        , m_dx(0)
-            m_dy(0),
+        , m_dy(0)
-            m_min_x(0x7FFFFFFF),
+        , m_min_x(0x7FFFFFFF)
-            m_min_y(0x7FFFFFFF),
+        , m_min_y(0x7FFFFFFF)
-            m_max_x(-0x7FFFFFFF),
+        , m_max_x(-0x7FFFFFFF)
-            m_max_y(-0x7FFFFFFF)
+        , m_max_y(-0x7FFFFFFF)
     {}
 
     //--------------------------------------------------------------------
-        serialized_scanlines_adaptor_bin(const int8u* data, unsigned size,
+    serialized_scanlines_adaptor_bin(const int8u* data, unsigned size, double dx, double dy)
-                                         double dx, double dy) :
+        : m_data(data)
-            m_data(data),
+        , m_end(data + size)
-            m_end(data + size),
+        , m_ptr(data)
-            m_ptr(data),
+        , m_dx(iround(dx))
-            m_dx(iround(dx)),
+        , m_dy(iround(dy))
-            m_dy(iround(dy)),
+        , m_min_x(0x7FFFFFFF)
-            m_min_x(0x7FFFFFFF),
+        , m_min_y(0x7FFFFFFF)
-            m_min_y(0x7FFFFFFF),
+        , m_max_x(-0x7FFFFFFF)
-            m_max_x(-0x7FFFFFFF),
+        , m_max_y(-0x7FFFFFFF)
-            m_max_y(-0x7FFFFFFF)
     {}
 
     //--------------------------------------------------------------------
@@ -516,12 +497,14 @@ namespace agg
     int max_y() const { return m_max_y; }
 
     //--------------------------------------------------------------------
-        template<class Scanline> bool sweep_scanline(Scanline& sl)
+    template<class Scanline>
+    bool sweep_scanline(Scanline& sl)
     {
         sl.reset_spans();
         for (;;)
         {
-                if(m_ptr >= m_end) return false;
+            if (m_ptr >= m_end)
+                return false;
 
             int y = read_int32() + m_dy;
             unsigned num_spans = read_int32();
@@ -531,10 +514,10 @@ namespace agg
                 int x = read_int32() + m_dx;
                 int len = read_int32();
 
-                    if(len < 0) len = -len;
+                if (len < 0)
+                    len = -len;
                 sl.add_span(x, unsigned(len), cover_full);
-                }
+            } while (--num_spans);
-                while(--num_spans);
 
             if (sl.num_spans())
             {
@@ -545,14 +528,14 @@ namespace agg
         return true;
     }
 
-
     //--------------------------------------------------------------------
     // Specialization for embedded_scanline
     bool sweep_scanline(embedded_scanline& sl)
     {
         do
         {
-                if(m_ptr >= m_end) return false;
+            if (m_ptr >= m_end)
+                return false;
 
             sl.init(m_ptr, m_dx, m_dy);
 
@@ -561,8 +544,7 @@ namespace agg
             read_int32();                 // Y
             int num_spans = read_int32(); // num_spans
             m_ptr += num_spans * sizeof(int32) * 2;
-            }
+        } while (sl.num_spans() == 0);
-            while(sl.num_spans() == 0);
         return true;
     }
 
@@ -578,9 +560,6 @@ namespace agg
     int m_max_y;
 };
 
-
+} // namespace agg
-
-}
 
 #endif
-

deps/agg/include/agg_scanline_u.h

@@ -26,8 +26,7 @@
 
 #include "agg_array.h"
 
-namespace agg
+namespace agg {
-{
 //=============================================================scanline_u8
 //
 // Unpacked scanline container class
@@ -125,10 +124,10 @@ namespace agg
     typedef const span* const_iterator;
 
     //--------------------------------------------------------------------
-        scanline_u8() :
+    scanline_u8()
-            m_min_x(0),
+        : m_min_x(0)
-            m_last_x(0x7FFFFFF0),
+        , m_last_x(0x7FFFFFF0)
-            m_cur_span(0)
+        , m_cur_span(0)
     {}
 
     //--------------------------------------------------------------------
@@ -203,10 +202,7 @@ namespace agg
     }
 
     //--------------------------------------------------------------------
-        void finalize(int y) 
+    void finalize(int y) { m_y = y; }
-        { 
-            m_y = y; 
-        }
 
     //--------------------------------------------------------------------
     void reset_spans()
@@ -234,9 +230,6 @@ namespace agg
     span* m_cur_span;
 };
 
-
-
-
 //==========================================================scanline_u8_am
 //
 // The scanline container with alpha-masking
@@ -251,8 +244,14 @@ namespace agg
     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()
-        scanline_u8_am(const AlphaMask& am) : base_type(), m_alpha_mask(&am) {}
+        : base_type()
+        , m_alpha_mask(0)
+    {}
+    scanline_u8_am(const AlphaMask& am)
+        : base_type()
+        , m_alpha_mask(&am)
+    {}
 
     //--------------------------------------------------------------------
     void finalize(int span_y)
@@ -264,13 +263,9 @@ namespace agg
             unsigned count = base_type::num_spans();
             do
             {
-                    m_alpha_mask->combine_hspan(span->x, 
+                m_alpha_mask->combine_hspan(span->x, base_type::y(), span->covers, span->len);
-                                                base_type::y(), 
-                                                span->covers, 
-                                                span->len);
                 ++span;
-                }
+            } while (--count);
-                while(--count);
         }
     }
 
@@ -278,9 +273,6 @@ namespace agg
     const AlphaMask* m_alpha_mask;
 };
 
-
-
-
 //===========================================================scanline32_u8
 class scanline32_u8
 {
@@ -293,8 +285,11 @@ namespace agg
     struct span
     {
         span() {}
-            span(coord_type x_, coord_type len_, cover_type* covers_) :
+        span(coord_type x_, coord_type len_, cover_type* covers_)
-                x(x_), len(len_), covers(covers_) {}
+            : x(x_)
+            , len(len_)
+            , covers(covers_)
+        {}
 
         coord_type x;
         coord_type len;
@@ -307,9 +302,9 @@ namespace agg
     class const_iterator
     {
       public:
-            const_iterator(const span_array_type& spans) :
+        const_iterator(const span_array_type& spans)
-                m_spans(spans),
+            : m_spans(spans)
-                m_span_idx(0)
+            , m_span_idx(0)
         {}
 
         const span& operator*() const { return m_spans[m_span_idx]; }
@@ -326,9 +321,9 @@ namespace agg
     class iterator
     {
       public:
-            iterator(span_array_type& spans) :
+        iterator(span_array_type& spans)
-                m_spans(spans),
+            : m_spans(spans)
-                m_span_idx(0)
+            , m_span_idx(0)
         {}
 
         span& operator*() { return m_spans[m_span_idx]; }
@@ -341,13 +336,11 @@ namespace agg
         unsigned m_span_idx;
     };
 
-
-
     //--------------------------------------------------------------------
-        scanline32_u8() :
+    scanline32_u8()
-            m_min_x(0),
+        : m_min_x(0)
-            m_last_x(0x7FFFFFF0),
+        , m_last_x(0x7FFFFFF0)
-            m_covers()
+        , m_covers()
     {}
 
     //--------------------------------------------------------------------
@@ -390,9 +383,7 @@ namespace agg
         }
         else
         {
-                m_spans.add(span(coord_type(x + m_min_x), 
+            m_spans.add(span(coord_type(x + m_min_x), coord_type(len), &m_covers[x]));
-                                 coord_type(len), 
-                                 &m_covers[x]));
         }
         m_last_x = x + len - 1;
     }
@@ -408,18 +399,13 @@ namespace agg
         }
         else
         {
-                m_spans.add(span(coord_type(x + m_min_x), 
+            m_spans.add(span(coord_type(x + m_min_x), coord_type(len), &m_covers[x]));
-                                 coord_type(len), 
-                                 &m_covers[x]));
         }
         m_last_x = x + len - 1;
     }
 
     //--------------------------------------------------------------------
-        void finalize(int y) 
+    void finalize(int y) { m_y = y; }
-        { 
-            m_y = y; 
-        }
 
     //--------------------------------------------------------------------
     void reset_spans()
@@ -446,9 +432,6 @@ namespace agg
     span_array_type m_spans;
 };
 
-
-
-
 //========================================================scanline32_u8_am
 //
 // The scanline container with alpha-masking
@@ -464,9 +447,14 @@ namespace agg
     typedef base_type::cover_type cover_type;
     typedef base_type::coord_type coord_type;
 
-
+    scanline32_u8_am()
-        scanline32_u8_am() : base_type(), m_alpha_mask(0) {}
+        : base_type()
-        scanline32_u8_am(const AlphaMask& am) : base_type(), m_alpha_mask(&am) {}
+        , m_alpha_mask(0)
+    {}
+    scanline32_u8_am(const AlphaMask& am)
+        : base_type()
+        , m_alpha_mask(&am)
+    {}
 
     //--------------------------------------------------------------------
     void finalize(int span_y)
@@ -478,13 +466,9 @@ namespace agg
             unsigned count = base_type::num_spans();
             do
             {
-                    m_alpha_mask->combine_hspan(span->x, 
+                m_alpha_mask->combine_hspan(span->x, base_type::y(), span->covers, span->len);
-                                                base_type::y(), 
-                                                span->covers, 
-                                                span->len);
                 ++span;
-                }
+            } while (--count);
-                while(--count);
         }
     }
 
@@ -492,9 +476,6 @@ namespace agg
     const AlphaMask* m_alpha_mask;
 };
 
-
+} // namespace agg
-
-}
 
 #endif
-

deps/agg/include/agg_shorten_path.h

@@ -19,8 +19,7 @@
 #include "agg_basics.h"
 #include "agg_vertex_sequence.h"
 
-namespace agg
+namespace agg {
-{
 
 //===========================================================shorten_path
 template<class VertexSequence>
@@ -35,7 +34,8 @@ namespace agg
         while (n)
         {
             d = vs[n].dist;
-                if(d > s) break;
+            if (d > s)
+                break;
             vs.remove_last();
             s -= d;
             --n;
@@ -54,13 +54,13 @@ namespace agg
             double y = prev.y + (last.y - prev.y) * d;
             last.x = x;
             last.y = y;
-                if(!prev(last)) vs.remove_last();
+            if (!prev(last))
+                vs.remove_last();
             vs.close(closed != 0);
         }
     }
 }
 
-
+} // namespace agg
-}
 
 #endif

deps/agg/include/agg_simul_eq.h

@@ -22,11 +22,11 @@
 #include <cmath>
 #include "agg_basics.h"
 
-namespace agg
+namespace agg {
-{
 
 //=============================================================swap_arrays
-    template<class T> void swap_arrays(T* a1, T* a2, unsigned n)
+template<class T>
+void swap_arrays(T* a1, T* a2, unsigned n)
 {
     unsigned i;
     for (i = 0; i < n; i++)
@@ -37,7 +37,6 @@ namespace agg
     }
 }
 
-
 //============================================================matrix_pivot
 template<unsigned Rows, unsigned Cols>
 struct matrix_pivot
@@ -72,15 +71,12 @@ namespace agg
     }
 };
 
-
-
 //===============================================================simul_eq
 template<unsigned Size, unsigned RightCols>
 struct simul_eq
 {
-        static bool solve(const double left[Size][Size], 
+    static bool
-                          const double right[Size][RightCols],
+      solve(const double left[Size][Size], const double right[Size][RightCols], double result[Size][RightCols])
-                          double result[Size][RightCols])
     {
         unsigned i, j, k;
         double a1;
@@ -123,7 +119,6 @@ namespace agg
             }
         }
 
-
         for (k = 0; k < RightCols; k++)
         {
             int m;
@@ -138,10 +133,8 @@ namespace agg
         }
         return true;
     }
-
 };
 
-
+} // namespace agg
-}
 
 #endif

deps/agg/include/agg_span_allocator.h

@@ -18,10 +18,10 @@
 
 #include "agg_array.h"
 
-namespace agg
+namespace agg {
-{
 //----------------------------------------------------------span_allocator
-    template<class ColorT> class span_allocator
+template<class ColorT>
+class span_allocator
 {
   public:
     typedef ColorT color_type;
@@ -46,9 +46,6 @@ namespace agg
   private:
     pod_array<color_type> m_span;
 };
-}
+} // namespace agg
-
 
 #endif
-
-

deps/agg/include/agg_span_converter.h

@@ -18,16 +18,18 @@
 
 #include "agg_basics.h"
 
-namespace agg
+namespace agg {
-{
 //----------------------------------------------------------span_converter
-    template<class SpanGenerator, class SpanConverter> class 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) : 
+    span_converter(SpanGenerator& span_gen, SpanConverter& span_cnv)
-            m_span_gen(&span_gen), m_span_cnv(&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; }
@@ -51,6 +53,6 @@ namespace agg
     SpanConverter* m_span_cnv;
 };
 
-}
+} // namespace agg
 
 #endif

deps/agg/include/agg_span_gouraud.h

@@ -19,11 +19,11 @@
 #include "agg_basics.h"
 #include "agg_math.h"
 
-namespace agg
+namespace agg {
-{
 
 //============================================================span_gouraud
-    template<class ColorT> class span_gouraud
+template<class ColorT>
+class span_gouraud
 {
   public:
     typedef ColorT color_type;
@@ -36,8 +36,8 @@ namespace agg
     };
 
     //--------------------------------------------------------------------
-        span_gouraud() : 
+    span_gouraud()
-            m_vertex(0)
+        : m_vertex(0)
     {
         m_cmd[0] = path_cmd_stop;
     }
@@ -46,11 +46,14 @@ namespace agg
     span_gouraud(const color_type& c1,
                  const color_type& c2,
                  const color_type& c3,
-                     double x1, double y1,
+                 double x1,
-                     double x2, double y2,
+                 double y1,
-                     double x3, double y3,
+                 double x2,
-                     double d) : 
+                 double y2,
-            m_vertex(0)
+                 double x3,
+                 double y3,
+                 double d)
+        : m_vertex(0)
     {
         colors(c1, c2, c3);
         triangle(x1, y1, x2, y2, x3, y3, d);
@@ -71,10 +74,7 @@ namespace agg
     // 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, 
+    void triangle(double x1, double y1, double x2, double y2, double x3, double y3, double d)
-                      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;
@@ -89,22 +89,48 @@ namespace agg
 
         if (d != 0.0)
         {
-                dilate_triangle(m_coord[0].x, m_coord[0].y,
+            dilate_triangle(m_coord[0].x,
-                                m_coord[1].x, m_coord[1].y,
+                            m_coord[0].y,
-                                m_coord[2].x, m_coord[2].y,
+                            m_coord[1].x,
-                                m_x, m_y, d);
+                            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],
+            calc_intersection(m_x[4],
-                                  m_x[0], m_y[0], m_x[1], m_y[1],
+                              m_y[4],
-                                  &m_coord[0].x, &m_coord[0].y);
+                              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],
+            calc_intersection(m_x[0],
-                                  m_x[2], m_y[2], m_x[3], m_y[3],
+                              m_y[0],
-                                  &m_coord[1].x, &m_coord[1].y);
+                              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],
+            calc_intersection(m_x[2],
-                                  m_x[4], m_y[4], m_x[5], m_y[5],
+                              m_y[2],
-                                  &m_coord[2].x, &m_coord[2].y);
+                              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;
@@ -114,10 +140,7 @@ namespace agg
 
     //--------------------------------------------------------------------
     // Vertex Source Interface to feed the coordinates to the rasterizer
-        void rewind(unsigned)
+    void rewind(unsigned) { m_vertex = 0; }
-        {
-            m_vertex = 0;
-        }
 
     //--------------------------------------------------------------------
     unsigned vertex(double* x, double* y)
@@ -166,7 +189,6 @@ namespace agg
     unsigned m_vertex;
 };
 
-}
+} // namespace agg
 
 #endif
-

deps/agg/include/agg_span_gouraud_gray.h

@@ -29,22 +29,18 @@
 #include "agg_dda_line.h"
 #include "agg_span_gouraud.h"
 
-namespace agg
+namespace agg {
-{
 
 //=======================================================span_gouraud_gray
-    template<class ColorT> class span_gouraud_gray : public span_gouraud<ColorT>
+template<class ColorT>
+class span_gouraud_gray : public span_gouraud<ColorT>
 {
   public:
     typedef ColorT color_type;
     typedef typename color_type::value_type value_type;
     typedef span_gouraud<color_type> base_type;
     typedef typename base_type::coord_type coord_type;
-        enum subpixel_scale_e
+    enum subpixel_scale_e { subpixel_shift = 4, subpixel_scale = 1 << subpixel_shift };
-        { 
-            subpixel_shift = 4, 
-            subpixel_scale = 1 << subpixel_shift
-        };
 
   private:
     //--------------------------------------------------------------------
@@ -66,8 +62,10 @@ namespace agg
         void calc(double y)
         {
             double k = (y - m_y1) * m_1dy;
-                if(k < 0.0) k = 0.0;
+            if (k < 0.0)
-                if(k > 1.0) k = 1.0;
+                k = 0.0;
+            if (k > 1.0)
+                k = 1.0;
             m_v = m_v1 + iround(m_dv * k);
             m_a = m_a1 + iround(m_da * k);
             m_x = iround((m_x1 + m_dx * k) * subpixel_scale);
@@ -86,18 +84,20 @@ namespace agg
         int m_x;
     };
 
-
   public:
     //--------------------------------------------------------------------
     span_gouraud_gray() {}
     span_gouraud_gray(const color_type& c1,
                       const color_type& c2,
                       const color_type& c3,
-                          double x1, double y1, 
+                      double x1,
-                          double x2, double y2,
+                      double y1,
-                          double x3, double y3, 
+                      double x2,
-                          double d = 0) : 
+                      double y2,
-            base_type(c1, c2, c3, x1, y1, x2, y2, x3, y3, d)
+                      double x3,
+                      double y3,
+                      double d = 0)
+        : base_type(c1, c2, c3, x1, y1, x2, y2, x3, y3, d)
     {}
 
     //--------------------------------------------------------------------
@@ -108,9 +108,7 @@ namespace agg
 
         m_y2 = int(coord[1].y);
 
-            m_swap = cross_product(coord[0].x, coord[0].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;
-                                   coord[2].x, coord[2].y,
-                                   coord[1].x, coord[1].y) < 0.0;
 
         m_c1.init(coord[0], coord[2]);
         m_c2.init(coord[0], coord[1]);
@@ -152,7 +150,8 @@ namespace agg
         // and protect it from division by zero
         //-------------------------
         int nlen = std::abs(pc2->m_x - pc1->m_x);
-            if(nlen <= 0) nlen = 1;
+        if (nlen <= 0)
+            nlen = 1;
 
         dda_line_interpolator<14> v(pc1->m_v, pc2->m_v, nlen);
         dda_line_interpolator<14> a(pc1->m_a, pc2->m_a, nlen);
@@ -180,8 +179,14 @@ namespace agg
         {
             vv = v.y();
             va = a.y();
-                if(vv < 0) vv = 0; if(vv > lim) vv = lim;
+            if (vv < 0)
-                if(va < 0) va = 0; if(va > lim) va = lim;
+                vv = 0;
+            if (vv > lim)
+                vv = lim;
+            if (va < 0)
+                va = 0;
+            if (va > lim)
+                va = lim;
             span->v = (value_type)vv;
             span->a = (value_type)va;
             v += subpixel_scale;
@@ -215,8 +220,14 @@ namespace agg
         {
             vv = v.y();
             va = a.y();
-                if(vv < 0) vv = 0; if(vv > lim) vv = lim;
+            if (vv < 0)
-                if(va < 0) va = 0; if(va > lim) va = lim;
+                vv = 0;
+            if (vv > lim)
+                vv = lim;
+            if (va < 0)
+                va = 0;
+            if (va > lim)
+                va = lim;
             span->v = (value_type)vv;
             span->a = (value_type)va;
             v += subpixel_scale;
@@ -226,7 +237,6 @@ namespace agg
         }
     }
 
-
   private:
     bool m_swap;
     int m_y2;
@@ -235,7 +245,6 @@ namespace agg
     gray_calc m_c3;
 };
 
-
+} // namespace agg
-}
 
 #endif

deps/agg/include/agg_span_gouraud_rgba.h

@@ -29,22 +29,18 @@
 #include "agg_dda_line.h"
 #include "agg_span_gouraud.h"
 
-namespace agg
+namespace agg {
-{
 
 //=======================================================span_gouraud_rgba
-    template<class ColorT> class span_gouraud_rgba : public span_gouraud<ColorT>
+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
+    enum subpixel_scale_e { subpixel_shift = 4, subpixel_scale = 1 << subpixel_shift };
-        { 
-            subpixel_shift = 4, 
-            subpixel_scale = 1 << subpixel_shift
-        };
 
   private:
     //--------------------------------------------------------------------
@@ -70,8 +66,10 @@ namespace agg
         void calc(double y)
         {
             double k = (y - m_y1) * m_1dy;
-                if(k < 0.0) k = 0.0;
+            if (k < 0.0)
-                if(k > 1.0) k = 1.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);
@@ -105,11 +103,14 @@ namespace agg
     span_gouraud_rgba(const color_type& c1,
                       const color_type& c2,
                       const color_type& c3,
-                          double x1, double y1, 
+                      double x1,
-                          double x2, double y2,
+                      double y1,
-                          double x3, double y3, 
+                      double x2,
-                          double d = 0) : 
+                      double y2,
-            base_type(c1, c2, c3, x1, y1, x2, y2, x3, y3, d)
+                      double x3,
+                      double y3,
+                      double d = 0)
+        : base_type(c1, c2, c3, x1, y1, x2, y2, x3, y3, d)
     {}
 
     //--------------------------------------------------------------------
@@ -120,9 +121,7 @@ namespace agg
 
         m_y2 = int(coord[1].y);
 
-            m_swap = cross_product(coord[0].x, coord[0].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;
-                                   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]);
@@ -164,7 +163,8 @@ namespace agg
         // and protect it from division by zero
         //-------------------------
         int nlen = std::abs(pc2->m_x - pc1->m_x);
-            if(nlen <= 0) nlen = 1;
+        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);
@@ -198,10 +198,22 @@ namespace agg
             vg = g.y();
             vb = b.y();
             va = a.y();
-                if(vr < 0) vr = 0; if(vr > lim) vr = lim;
+            if (vr < 0)
-                if(vg < 0) vg = 0; if(vg > lim) vg = lim;
+                vr = 0;
-                if(vb < 0) vb = 0; if(vb > lim) vb = lim;
+            if (vr > lim)
-                if(va < 0) va = 0; if(va > lim) va = 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;
@@ -245,10 +257,22 @@ namespace agg
             vg = g.y();
             vb = b.y();
             va = a.y();
-                if(vr < 0) vr = 0; if(vr > lim) vr = lim;
+            if (vr < 0)
-                if(vg < 0) vg = 0; if(vg > lim) vg = lim;
+                vr = 0;
-                if(vb < 0) vb = 0; if(vb > lim) vb = lim;
+            if (vr > lim)
-                if(va < 0) va = 0; if(va > lim) va = 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;
@@ -270,8 +294,6 @@ namespace agg
     rgba_calc m_rgba3;
 };
 
-
+} // namespace agg
-
-}
 
 #endif

deps/agg/include/agg_span_gradient.h

@@ -23,35 +23,23 @@
 #include "agg_math.h"
 #include "agg_array.h"
 
+namespace agg {
 
-namespace agg
+enum gradient_subpixel_scale_e {
-{
-
-    enum gradient_subpixel_scale_e
-    {
     gradient_subpixel_shift = 4,                            //-----gradient_subpixel_shift
     gradient_subpixel_scale = 1 << gradient_subpixel_shift, //-----gradient_subpixel_scale
     gradient_subpixel_mask = gradient_subpixel_scale - 1    //-----gradient_subpixel_mask
 };
 
-
-
 //==========================================================span_gradient
-    template<class ColorT,
+template<class ColorT, class Interpolator, class GradientF, class ColorF>
-             class Interpolator,
-             class GradientF, 
-             class ColorF>
 class span_gradient
 {
   public:
     typedef Interpolator interpolator_type;
     typedef ColorT color_type;
 
-        enum downscale_shift_e
+    enum downscale_shift_e { downscale_shift = interpolator_type::subpixel_shift - gradient_subpixel_shift };
-        {
-            downscale_shift = interpolator_type::subpixel_shift - 
-                              gradient_subpixel_shift
-        };
 
     //--------------------------------------------------------------------
     span_gradient() {}
@@ -60,12 +48,13 @@ namespace agg
     span_gradient(interpolator_type& inter,
                   const GradientF& gradient_function,
                   const ColorF& color_function,
-                      double d1, double d2) : 
+                  double d1,
-            m_interpolator(&inter),
+                  double d2)
-            m_gradient_function(&gradient_function),
+        : m_interpolator(&inter)
-            m_color_function(&color_function),
+        , m_gradient_function(&gradient_function)
-            m_d1(iround(d1 * gradient_subpixel_scale)),
+        , m_color_function(&color_function)
-            m_d2(iround(d2 * gradient_subpixel_scale))
+        , m_d1(iround(d1 * gradient_subpixel_scale))
+        , m_d2(iround(d2 * gradient_subpixel_scale))
     {}
 
     //--------------------------------------------------------------------
@@ -89,20 +78,21 @@ namespace agg
     void generate(color_type* span, int x, int y, unsigned len)
     {
         int dd = m_d2 - m_d1;
-            if(dd < 1) dd = 1;
+        if (dd < 1)
+            dd = 1;
         m_interpolator->begin(x + 0.5, y + 0.5, len);
         do
         {
             m_interpolator->coordinates(&x, &y);
-                int d = m_gradient_function->calculate(x >> downscale_shift, 
+            int d = m_gradient_function->calculate(x >> downscale_shift, y >> downscale_shift, m_d2);
-                                                       y >> downscale_shift, m_d2);
             d = ((d - m_d1) * (int)m_color_function->size()) / dd;
-                if(d < 0) d = 0;
+            if (d < 0)
-                if(d >= (int)m_color_function->size()) d = m_color_function->size() - 1;
+                d = 0;
+            if (d >= (int)m_color_function->size())
+                d = m_color_function->size() - 1;
             *span++ = (*m_color_function)[d];
             ++(*m_interpolator);
-            }
+        } while (--len);
-            while(--len);
     }
 
   private:
@@ -113,9 +103,6 @@ namespace agg
     int m_d2;
 };
 
-
-
-
 //=====================================================gradient_linear_color
 template<class ColorT>
 struct gradient_linear_color
@@ -123,15 +110,14 @@ namespace agg
     typedef ColorT color_type;
 
     gradient_linear_color() {}
-        gradient_linear_color(const color_type& c1, const color_type& c2, 
+    gradient_linear_color(const color_type& c1, const color_type& c2, unsigned size = 256)
-                              unsigned size = 256) :
+        : m_c1(c1)
-            m_c1(c1), m_c2(c2), m_size(size) {}
+        , m_c2(c2)
+        , m_size(size)
+    {}
 
     unsigned size() const { return m_size; }
-        color_type operator [] (unsigned v) const 
+    color_type operator[](unsigned v) const { return m_c1.gradient(m_c2, double(v) / double(m_size - 1)); }
-        {
-            return m_c1.gradient(m_c2, double(v) / double(m_size - 1));
-        }
 
     void colors(const color_type& c1, const color_type& c2, unsigned size = 256)
     {
@@ -145,31 +131,19 @@ namespace agg
     unsigned m_size;
 };
 
-
-
-
-
-
 //==========================================================gradient_circle
 class gradient_circle
 {
     // Actually the same as radial. Just for compatibility
   public:
-        static AGG_INLINE int calculate(int x, int y, int)
+    static AGG_INLINE int calculate(int x, int y, int) { return int(fast_sqrt(x * x + y * y)); }
-        {
-            return int(fast_sqrt(x*x + y*y));
-        }
 };
 
-
 //==========================================================gradient_radial
 class gradient_radial
 {
   public:
-        static AGG_INLINE int calculate(int x, int y, int)
+    static AGG_INLINE int calculate(int x, int y, int) { return int(fast_sqrt(x * x + y * y)); }
-        {
-            return int(fast_sqrt(x*x + y*y));
-        }
 };
 
 //========================================================gradient_radial_d
@@ -187,19 +161,19 @@ namespace agg
 {
   public:
     //---------------------------------------------------------------------
-        gradient_radial_focus() : 
+    gradient_radial_focus()
-            m_r(100 * gradient_subpixel_scale), 
+        : m_r(100 * gradient_subpixel_scale)
-            m_fx(0), 
+        , m_fx(0)
-            m_fy(0)
+        , m_fy(0)
     {
         update_values();
     }
 
     //---------------------------------------------------------------------
-        gradient_radial_focus(double r, double fx, double fy) : 
+    gradient_radial_focus(double r, double fx, double fy)
-            m_r (iround(r  * gradient_subpixel_scale)), 
+        : m_r(iround(r * gradient_subpixel_scale))
-            m_fx(iround(fx * gradient_subpixel_scale)), 
+        , m_fx(iround(fx * gradient_subpixel_scale))
-            m_fy(iround(fy * gradient_subpixel_scale))
+        , m_fy(iround(fy * gradient_subpixel_scale))
     {
         update_values();
     }
@@ -244,8 +218,20 @@ namespace agg
         double d = (m_r2 - (m_fx2 + m_fy2));
         if (d == 0)
         {
-                if(m_fx) { if(m_fx < 0) ++m_fx; else --m_fx; }
+            if (m_fx)
-                if(m_fy) { if(m_fy < 0) ++m_fy; else --m_fy; }
+            {
+                if (m_fx < 0)
+                    ++m_fx;
+                else
+                    --m_fx;
+            }
+            if (m_fy)
+            {
+                if (m_fy < 0)
+                    ++m_fy;
+                else
+                    --m_fy;
+            }
             m_fx2 = double(m_fx) * double(m_fx);
             m_fy2 = double(m_fy) * double(m_fy);
             d = (m_r2 - (m_fx2 + m_fy2));
@@ -262,7 +248,6 @@ namespace agg
     double m_mul;
 };
 
-
 //==============================================================gradient_x
 class gradient_x
 {
@@ -270,7 +255,6 @@ namespace agg
     static int calculate(int x, int, int) { return x; }
 };
 
-
 //==============================================================gradient_y
 class gradient_y
 {
@@ -294,20 +278,14 @@ namespace agg
 class gradient_xy
 {
   public:
-        static AGG_INLINE int calculate(int x, int y, int d) 
+    static AGG_INLINE int calculate(int x, int y, int d) { return std::abs(x) * std::abs(y) / d; }
-        { 
-            return std::abs(x) * std::abs(y) / d; 
-        }
 };
 
 //========================================================gradient_sqrt_xy
 class gradient_sqrt_xy
 {
   public:
-        static AGG_INLINE int calculate(int x, int y, int) 
+    static AGG_INLINE int calculate(int x, int y, int) { return fast_sqrt(std::abs(x) * std::abs(y)); }
-        { 
-            return fast_sqrt(std::abs(x) * std::abs(y)); 
-        }
 };
 
 //==========================================================gradient_conic
@@ -321,16 +299,19 @@ namespace agg
 };
 
 //=================================================gradient_repeat_adaptor
-    template<class GradientF> class gradient_repeat_adaptor
+template<class GradientF>
+class gradient_repeat_adaptor
 {
   public:
-        gradient_repeat_adaptor(const GradientF& gradient) : 
+    gradient_repeat_adaptor(const GradientF& gradient)
-            m_gradient(&gradient) {}
+        : m_gradient(&gradient)
+    {}
 
     AGG_INLINE int calculate(int x, int y, int d) const
     {
         int ret = m_gradient->calculate(x, y, d) % d;
-            if(ret < 0) ret += d;
+        if (ret < 0)
+            ret += d;
         return ret;
     }
 
@@ -339,18 +320,22 @@ namespace agg
 };
 
 //================================================gradient_reflect_adaptor
-    template<class GradientF> class gradient_reflect_adaptor
+template<class GradientF>
+class gradient_reflect_adaptor
 {
   public:
-        gradient_reflect_adaptor(const GradientF& gradient) : 
+    gradient_reflect_adaptor(const GradientF& gradient)
-            m_gradient(&gradient) {}
+        : m_gradient(&gradient)
+    {}
 
     AGG_INLINE int calculate(int x, int y, int d) const
     {
         int d2 = d << 1;
         int ret = m_gradient->calculate(x, y, d) % d2;
-            if(ret <  0) ret += d2;
+        if (ret < 0)
-            if(ret >= d) ret  = d2 - ret;
+            ret += d2;
+        if (ret >= d)
+            ret = d2 - ret;
         return ret;
     }
 
@@ -358,7 +343,6 @@ namespace agg
     const GradientF* m_gradient;
 };
 
-
+} // namespace agg
-}
 
 #endif

deps/agg/include/agg_span_gradient_alpha.h

@@ -18,13 +18,9 @@
 
 #include "agg_span_gradient.h"
 
-namespace agg
+namespace agg {
-{
 //======================================================span_gradient_alpha
-    template<class ColorT, 
+template<class ColorT, class Interpolator, class GradientF, class AlphaF>
-             class Interpolator,
-             class GradientF, 
-             class AlphaF>
 class span_gradient_alpha
 {
   public:
@@ -32,11 +28,7 @@ namespace agg
     typedef ColorT color_type;
     typedef typename color_type::value_type alpha_type;
 
-        enum downscale_shift_e
+    enum downscale_shift_e { downscale_shift = interpolator_type::subpixel_shift - gradient_subpixel_shift };
-        {
-            downscale_shift = interpolator_type::subpixel_shift - gradient_subpixel_shift
-        };
-
 
     //--------------------------------------------------------------------
     span_gradient_alpha() {}
@@ -45,12 +37,13 @@ namespace agg
     span_gradient_alpha(interpolator_type& inter,
                         const GradientF& gradient_function,
                         const AlphaF& alpha_function,
-                            double d1, double d2) : 
+                        double d1,
-            m_interpolator(&inter),
+                        double d2)
-            m_gradient_function(&gradient_function),
+        : m_interpolator(&inter)
-            m_alpha_function(&alpha_function),
+        , m_gradient_function(&gradient_function)
-            m_d1(iround(d1 * gradient_subpixel_scale)),
+        , m_alpha_function(&alpha_function)
-            m_d2(iround(d2 * gradient_subpixel_scale))
+        , m_d1(iround(d1 * gradient_subpixel_scale))
+        , m_d2(iround(d2 * gradient_subpixel_scale))
     {}
 
     //--------------------------------------------------------------------
@@ -74,21 +67,22 @@ namespace agg
     void generate(color_type* span, int x, int y, unsigned len)
     {
         int dd = m_d2 - m_d1;
-            if(dd < 1) dd = 1;
+        if (dd < 1)
+            dd = 1;
         m_interpolator->begin(x + 0.5, y + 0.5, len);
         do
         {
             m_interpolator->coordinates(&x, &y);
-                int d = m_gradient_function->calculate(x >> downscale_shift, 
+            int d = m_gradient_function->calculate(x >> downscale_shift, y >> downscale_shift, m_d2);
-                                                       y >> downscale_shift, m_d2);
             d = ((d - m_d1) * (int)m_alpha_function->size()) / dd;
-                if(d < 0) d = 0;
+            if (d < 0)
-                if(d >= (int)m_alpha_function->size()) d = m_alpha_function->size() - 1;
+                d = 0;
+            if (d >= (int)m_alpha_function->size())
+                d = m_alpha_function->size() - 1;
             span->a = (*m_alpha_function)[d];
             ++span;
             ++(*m_interpolator);
-            }
+        } while (--len);
-            while(--len);
     }
 
   private:
@@ -99,9 +93,9 @@ namespace agg
     int m_d2;
 };
 
-
 //=======================================================gradient_alpha_x
-    template<class ColorT> struct gradient_alpha_x
+template<class ColorT>
+struct gradient_alpha_x
 {
     typedef typename ColorT::value_type alpha_type;
     alpha_type operator[](alpha_type x) const { return x; }
@@ -121,6 +115,6 @@ namespace agg
     alpha_type operator[](alpha_type x) const { return 255 - x; }
 };
 
-}
+} // namespace agg
 
 #endif

deps/agg/include/agg_span_image_filter.h

@@ -23,11 +23,11 @@
 #include "agg_image_filters.h"
 #include "agg_span_interpolator_linear.h"
 
-namespace agg
+namespace agg {
-{
 
 //-------------------------------------------------------span_image_filter
-    template<class Source, class Interpolator> class span_image_filter
+template<class Source, class Interpolator>
+class span_image_filter
 {
   public:
     typedef Source source_type;
@@ -35,16 +35,14 @@ namespace agg
 
     //--------------------------------------------------------------------
     span_image_filter() {}
-        span_image_filter(source_type& src, 
+    span_image_filter(source_type& src, interpolator_type& interpolator, const image_filter_lut* filter)
-                          interpolator_type& interpolator,
+        : m_src(&src)
-                          const image_filter_lut* filter) : 
+        , m_interpolator(&interpolator)
-            m_src(&src),
+        , m_filter(filter)
-            m_interpolator(&interpolator),
+        , m_dx_dbl(0.5)
-            m_filter(filter),
+        , m_dy_dbl(0.5)
-            m_dx_dbl(0.5),
+        , m_dx_int(image_subpixel_scale / 2)
-            m_dy_dbl(0.5),
+        , m_dy_int(image_subpixel_scale / 2)
-            m_dx_int(image_subpixel_scale / 2),
-            m_dy_int(image_subpixel_scale / 2)
     {}
     void attach(source_type& v) { m_src = &v; }
 
@@ -86,13 +84,9 @@ namespace agg
     unsigned m_dy_int;
 };
 
-
-
-
 //==============================================span_image_resample_affine
 template<class Source>
-    class span_image_resample_affine : 
+class span_image_resample_affine : public span_image_filter<Source, span_interpolator_linear<trans_affine>>
-    public span_image_filter<Source, span_interpolator_linear<trans_affine> >
 {
   public:
     typedef Source source_type;
@@ -100,23 +94,20 @@ namespace agg
     typedef span_image_filter<source_type, interpolator_type> base_type;
 
     //--------------------------------------------------------------------
-        span_image_resample_affine() : 
+    span_image_resample_affine()
-            m_scale_limit(200.0),
+        : m_scale_limit(200.0)
-            m_blur_x(1.0),
+        , m_blur_x(1.0)
-            m_blur_y(1.0)
+        , m_blur_y(1.0)
     {}
 
     //--------------------------------------------------------------------
-        span_image_resample_affine(source_type& src, 
+    span_image_resample_affine(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
-                                   interpolator_type& inter,
+        : base_type(src, inter, &filter)
-                                   const image_filter_lut& filter) :
+        , m_scale_limit(200.0)
-            base_type(src, inter, &filter),
+        , m_blur_x(1.0)
-            m_scale_limit(200.0),
+        , m_blur_y(1.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; }
@@ -142,17 +133,23 @@ namespace agg
             scale_y = scale_y * m_scale_limit / (scale_x * scale_y);
         }
 
-            if(scale_x < 1) scale_x = 1;
+        if (scale_x < 1)
-            if(scale_y < 1) scale_y = 1;
+            scale_x = 1;
+        if (scale_y < 1)
+            scale_y = 1;
 
-            if(scale_x > m_scale_limit) scale_x = m_scale_limit;
+        if (scale_x > m_scale_limit)
-            if(scale_y > m_scale_limit) scale_y = 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_x < 1)
-            if(scale_y < 1) scale_y = 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));
@@ -173,12 +170,9 @@ namespace agg
     double m_blur_y;
 };
 
-
-
 //=====================================================span_image_resample
 template<class Source, class Interpolator>
-    class span_image_resample : 
+class span_image_resample : public span_image_filter<Source, Interpolator>
-    public span_image_filter<Source, Interpolator>
 {
   public:
     typedef Source source_type;
@@ -186,20 +180,18 @@ namespace agg
     typedef span_image_filter<source_type, interpolator_type> base_type;
 
     //--------------------------------------------------------------------
-        span_image_resample() : 
+    span_image_resample()
-            m_scale_limit(20),
+        : m_scale_limit(20)
-            m_blur_x(image_subpixel_scale),
+        , m_blur_x(image_subpixel_scale)
-            m_blur_y(image_subpixel_scale)
+        , m_blur_y(image_subpixel_scale)
     {}
 
     //--------------------------------------------------------------------
-        span_image_resample(source_type& src, 
+    span_image_resample(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
-                            interpolator_type& inter,
+        : base_type(src, inter, &filter)
-                            const image_filter_lut& filter) :
+        , m_scale_limit(20)
-            base_type(src, inter, &filter),
+        , m_blur_x(image_subpixel_scale)
-            m_scale_limit(20),
+        , m_blur_y(image_subpixel_scale)
-            m_blur_x(image_subpixel_scale),
-            m_blur_y(image_subpixel_scale)
     {}
 
     //--------------------------------------------------------------------
@@ -211,14 +203,15 @@ namespace agg
     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 = 
+    void blur(double v) { m_blur_x = m_blur_y = uround(v * double(image_subpixel_scale)); }
-                                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 (*rx < image_subpixel_scale)
-            if(*ry < image_subpixel_scale) *ry = 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;
@@ -229,8 +222,10 @@ namespace agg
         }
         *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 (*rx < image_subpixel_scale)
-            if(*ry < image_subpixel_scale) *ry = image_subpixel_scale;
+            *rx = image_subpixel_scale;
+        if (*ry < image_subpixel_scale)
+            *ry = image_subpixel_scale;
     }
 
     int m_scale_limit;
@@ -238,9 +233,6 @@ namespace agg
     int m_blur_y;
 };
 
-
+} // namespace agg
-
-
-}
 
 #endif

deps/agg/include/agg_span_image_filter_gray.h

@@ -27,14 +27,11 @@
 #include "agg_color_gray.h"
 #include "agg_span_image_filter.h"
 
-
+namespace agg {
-namespace agg
-{
 
 //==============================================span_image_filter_gray_nn
 template<class Source, class Interpolator>
-    class span_image_filter_gray_nn : 
+class span_image_filter_gray_nn : public span_image_filter<Source, Interpolator>
-    public span_image_filter<Source, Interpolator>
 {
   public:
     typedef Source source_type;
@@ -43,31 +40,23 @@ namespace agg
     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;
-        enum base_scale_e
+    enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
-        {
-            base_shift = color_type::base_shift,
-            base_mask  = color_type::base_mask
-        };
 
     //--------------------------------------------------------------------
     span_image_filter_gray_nn() {}
-        span_image_filter_gray_nn(source_type& src, 
+    span_image_filter_gray_nn(source_type& src, interpolator_type& inter)
-                                  interpolator_type& inter) :
+        : base_type(src, inter, 0)
-            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(), 
+        base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
-                                            y + base_type::filter_dy_dbl(), len);
         do
         {
             base_type::interpolator().coordinates(&x, &y);
-                span->v = *(const value_type*)
+            span->v =
-                    base_type::source().span(x >> image_subpixel_shift, 
+              *(const value_type*)base_type::source().span(x >> image_subpixel_shift, y >> image_subpixel_shift, 1);
-                                             y >> image_subpixel_shift, 
-                                             1);
             span->a = base_mask;
             ++span;
             ++base_type::interpolator();
@@ -75,12 +64,9 @@ namespace agg
     }
 };
 
-
-
 //=========================================span_image_filter_gray_bilinear
 template<class Source, class Interpolator>
-    class span_image_filter_gray_bilinear : 
+class span_image_filter_gray_bilinear : public span_image_filter<Source, Interpolator>
-    public span_image_filter<Source, Interpolator>
 {
   public:
     typedef Source source_type;
@@ -89,25 +75,18 @@ namespace agg
     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;
-        enum base_scale_e
+    enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
-        {
-            base_shift = color_type::base_shift,
-            base_mask  = color_type::base_mask
-        };
 
     //--------------------------------------------------------------------
     span_image_filter_gray_bilinear() {}
-        span_image_filter_gray_bilinear(source_type& src, 
+    span_image_filter_gray_bilinear(source_type& src, interpolator_type& inter)
-                                        interpolator_type& inter) :
+        : base_type(src, inter, 0)
-            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(), 
+        base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
-                                            y + base_type::filter_dy_dbl(), len);
         calc_type fg;
         const value_type* fg_ptr;
         do
@@ -149,11 +128,9 @@ namespace agg
     }
 };
 
-
 //====================================span_image_filter_gray_bilinear_clip
 template<class Source, class Interpolator>
-    class span_image_filter_gray_bilinear_clip : 
+class span_image_filter_gray_bilinear_clip : public span_image_filter<Source, Interpolator>
-    public span_image_filter<Source, Interpolator>
 {
   public:
     typedef Source source_type;
@@ -162,19 +139,13 @@ namespace agg
     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;
-        enum base_scale_e
+    enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
-        {
-            base_shift = color_type::base_shift,
-            base_mask  = color_type::base_mask
-        };
 
     //--------------------------------------------------------------------
     span_image_filter_gray_bilinear_clip() {}
-        span_image_filter_gray_bilinear_clip(source_type& src, 
+    span_image_filter_gray_bilinear_clip(source_type& src, const color_type& back_color, interpolator_type& inter)
-                                             const color_type& back_color,
+        : base_type(src, inter, 0)
-                                             interpolator_type& inter) :
+        , m_back_color(back_color)
-            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; }
@@ -182,8 +153,7 @@ namespace agg
     //--------------------------------------------------------------------
     void generate(color_type* span, int x, int y, unsigned len)
     {
-            base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 
+        base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
-                                            y + base_type::filter_dy_dbl(), len);
         calc_type fg;
         calc_type src_alpha;
         value_type back_v = m_back_color.v;
@@ -207,8 +177,7 @@ namespace agg
             int x_lr = x_hr >> image_subpixel_shift;
             int y_lr = y_hr >> image_subpixel_shift;
 
-                if(x_lr >= 0    && y_lr >= 0 &&
+            if (x_lr >= 0 && y_lr >= 0 && x_lr < maxx && y_lr < maxy)
-                   x_lr <  maxx && y_lr <  maxy) 
             {
                 fg = image_subpixel_scale * image_subpixel_scale / 2;
 
@@ -231,27 +200,22 @@ namespace agg
             else
             {
                 unsigned weight;
-                    if(x_lr < -1   || y_lr < -1 ||
+                if (x_lr < -1 || y_lr < -1 || x_lr > maxx || y_lr > maxy)
-                       x_lr > maxx || y_lr > maxy)
                 {
                     fg = back_v;
                     src_alpha = back_a;
                 }
                 else
                 {
-                        fg = 
+                    fg = src_alpha = image_subpixel_scale * image_subpixel_scale / 2;
-                        src_alpha = image_subpixel_scale * image_subpixel_scale / 2;
 
                     x_hr &= image_subpixel_mask;
                     y_hr &= image_subpixel_mask;
 
-                        weight = (image_subpixel_scale - x_hr) * 
+                    weight = (image_subpixel_scale - x_hr) * (image_subpixel_scale - y_hr);
-                                 (image_subpixel_scale - y_hr);
+                    if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
-                        if(x_lr >= 0    && y_lr >= 0 &&
-                           x_lr <= maxx && y_lr <= maxy)
                     {
-                            fg += weight * 
+                        fg += weight * *((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
-                                *((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
                         src_alpha += weight * base_mask;
                     }
                     else
@@ -263,11 +227,9 @@ namespace agg
                     x_lr++;
 
                     weight = x_hr * (image_subpixel_scale - y_hr);
-                        if(x_lr >= 0    && y_lr >= 0 &&
+                    if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
-                           x_lr <= maxx && y_lr <= maxy)
                     {
-                            fg += weight * 
+                        fg += weight * *((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
-                                *((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
                         src_alpha += weight * base_mask;
                     }
                     else
@@ -280,11 +242,9 @@ namespace agg
                     y_lr++;
 
                     weight = (image_subpixel_scale - x_hr) * y_hr;
-                        if(x_lr >= 0    && y_lr >= 0 &&
+                    if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
-                           x_lr <= maxx && y_lr <= maxy)
                     {
-                            fg += weight * 
+                        fg += weight * *((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
-                                *((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
                         src_alpha += weight * base_mask;
                     }
                     else
@@ -296,11 +256,9 @@ namespace agg
                     x_lr++;
 
                     weight = x_hr * y_hr;
-                        if(x_lr >= 0    && y_lr >= 0 &&
+                    if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
-                           x_lr <= maxx && y_lr <= maxy)
                     {
-                            fg += weight * 
+                        fg += weight * *((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
-                                *((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
                         src_alpha += weight * base_mask;
                     }
                     else
@@ -321,16 +279,14 @@ namespace agg
 
         } while (--len);
     }
+
   private:
     color_type m_back_color;
 };
 
-
-
 //==============================================span_image_filter_gray_2x2
 template<class Source, class Interpolator>
-    class span_image_filter_gray_2x2 : 
+class span_image_filter_gray_2x2 : public span_image_filter<Source, Interpolator>
-    public span_image_filter<Source, Interpolator>
 {
   public:
     typedef Source source_type;
@@ -339,33 +295,24 @@ namespace agg
     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;
-        enum base_scale_e
+    enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
-        {
-            base_shift = color_type::base_shift,
-            base_mask  = color_type::base_mask
-        };
 
     //--------------------------------------------------------------------
     span_image_filter_gray_2x2() {}
-        span_image_filter_gray_2x2(source_type& src, 
+    span_image_filter_gray_2x2(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
-                                   interpolator_type& inter,
+        : base_type(src, inter, &filter)
-                                   const 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(), 
+        base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
-                                            y + base_type::filter_dy_dbl(), len);
 
         calc_type fg;
 
         const value_type* fg_ptr;
-            const int16* weight_array = base_type::filter().weight_array() + 
+        const int16* weight_array =
-                                        ((base_type::filter().diameter()/2 - 1) << 
+          base_type::filter().weight_array() + ((base_type::filter().diameter() / 2 - 1) << image_subpixel_shift);
-                                          image_subpixel_shift);
         do
         {
             int x_hr;
@@ -386,35 +333,28 @@ namespace agg
             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 = (weight_array[x_hr + image_subpixel_scale] * weight_array[y_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 = (weight_array[x_hr] * weight_array[y_hr + image_subpixel_scale] + image_filter_scale / 2) >>
-                          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 = (weight_array[x_hr + image_subpixel_scale] * weight_array[y_hr] + image_filter_scale / 2) >>
-                          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 = (weight_array[x_hr] * weight_array[y_hr] + image_filter_scale / 2) >> image_filter_shift;
-                          weight_array[y_hr] + 
-                          image_filter_scale / 2) >> 
-                          image_filter_shift;
             fg += weight * *fg_ptr;
 
             fg >>= image_filter_shift;
-                if(fg > base_mask) fg = base_mask;
+            if (fg > base_mask)
+                fg = base_mask;
 
             span->v = (value_type)fg;
             span->a = base_mask;
@@ -424,12 +364,9 @@ namespace agg
     }
 };
 
-
-
 //==================================================span_image_filter_gray
 template<class Source, class Interpolator>
-    class span_image_filter_gray : 
+class span_image_filter_gray : public span_image_filter<Source, Interpolator>
-    public span_image_filter<Source, Interpolator>
 {
   public:
     typedef Source source_type;
@@ -438,25 +375,18 @@ namespace agg
     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;
-        enum base_scale_e
+    enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
-        {
-            base_shift = color_type::base_shift,
-            base_mask  = color_type::base_mask
-        };
 
     //--------------------------------------------------------------------
     span_image_filter_gray() {}
-        span_image_filter_gray(source_type& src, 
+    span_image_filter_gray(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
-                               interpolator_type& inter,
+        : base_type(src, inter, &filter)
-                               const 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(), 
+        base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
-                                            y + base_type::filter_dy_dbl(), len);
 
         int fg;
         const value_type* fg_ptr;
@@ -487,9 +417,7 @@ namespace agg
             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, 
+            fg_ptr = (const value_type*)base_type::source().span(x_lr + start, y_lr + start, diameter);
-                                                                     y_lr + start, 
-                                                                     diameter);
             for (;;)
             {
                 x_count = diameter;
@@ -497,23 +425,24 @@ namespace agg
                 x_hr = image_subpixel_mask - x_fract;
                 for (;;)
                 {
-                        fg += *fg_ptr * 
+                    fg += *fg_ptr * ((weight_y * weight_array[x_hr] + image_filter_scale / 2) >> image_filter_shift);
-                              ((weight_y * weight_array[x_hr] + 
+                    if (--x_count == 0)
-                                image_filter_scale / 2) >> 
+                        break;
-                                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;
+                if (--y_count == 0)
+                    break;
                 y_hr += image_subpixel_scale;
                 fg_ptr = (const value_type*)base_type::source().next_y();
             }
 
             fg >>= image_filter_shift;
-                if(fg < 0) fg = 0;
+            if (fg < 0)
-                if(fg > base_mask) fg = base_mask;
+                fg = 0;
+            if (fg > base_mask)
+                fg = base_mask;
             span->v = (value_type)fg;
             span->a = base_mask;
 
@@ -524,12 +453,9 @@ namespace agg
     }
 };
 
-
-
 //=========================================span_image_resample_gray_affine
 template<class Source>
-    class span_image_resample_gray_affine : 
+class span_image_resample_gray_affine : public span_image_resample_affine<Source>
-    public span_image_resample_affine<Source>
 {
   public:
     typedef Source source_type;
@@ -538,8 +464,7 @@ namespace agg
     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
+    enum base_scale_e {
-        {
         base_shift = color_type::base_shift,
         base_mask = color_type::base_mask,
         downscale_shift = image_filter_shift
@@ -547,18 +472,14 @@ namespace agg
 
     //--------------------------------------------------------------------
     span_image_resample_gray_affine() {}
-        span_image_resample_gray_affine(source_type& src, 
+    span_image_resample_gray_affine(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
-                                        interpolator_type& inter,
+        : base_type(src, inter, filter)
-                                        const 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(), 
+        base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
-                                            y + base_type::filter_dy_dbl(), len);
 
         long_type fg;
 
@@ -566,9 +487,7 @@ namespace agg
         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     = 
+        int len_x_lr = (diameter * base_type::m_rx + image_subpixel_mask) >> image_subpixel_shift;
-                (diameter * base_type::m_rx + image_subpixel_mask) >> 
-                    image_subpixel_shift;
 
         const int16* weight_array = base_type::filter().weight_array();
 
@@ -582,42 +501,41 @@ namespace agg
             fg = image_filter_scale / 2;
 
             int y_lr = y >> image_subpixel_shift;
-                int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) * 
+            int y_hr =
-                                base_type::m_ry_inv) >> 
+              ((image_subpixel_mask - (y & image_subpixel_mask)) * base_type::m_ry_inv) >> image_subpixel_shift;
-                                    image_subpixel_shift;
             int total_weight = 0;
             int x_lr = x >> image_subpixel_shift;
-                int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) * 
+            int x_hr =
-                                base_type::m_rx_inv) >> 
+              ((image_subpixel_mask - (x & image_subpixel_mask)) * base_type::m_rx_inv) >> image_subpixel_shift;
-                                    image_subpixel_shift;
 
             int x_hr2 = x_hr;
-                const value_type* fg_ptr = 
+            const value_type* fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
-                    (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] + 
+                    int weight = (weight_y * weight_array[x_hr] + image_filter_scale / 2) >> downscale_shift;
-                                     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;
+                    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;
+                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 < 0)
-                if(fg > base_mask) fg = base_mask;
+                fg = 0;
+            if (fg > base_mask)
+                fg = base_mask;
 
             span->v = (value_type)fg;
             span->a = base_mask;
@@ -628,12 +546,9 @@ namespace agg
     }
 };
 
-
-
 //================================================span_image_resample_gray
 template<class Source, class Interpolator>
-    class span_image_resample_gray : 
+class span_image_resample_gray : public span_image_resample<Source, Interpolator>
-    public span_image_resample<Source, Interpolator>
 {
   public:
     typedef Source source_type;
@@ -642,8 +557,7 @@ namespace agg
     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
+    enum base_scale_e {
-        {
         base_shift = color_type::base_shift,
         base_mask = color_type::base_mask,
         downscale_shift = image_filter_shift
@@ -651,17 +565,14 @@ namespace agg
 
     //--------------------------------------------------------------------
     span_image_resample_gray() {}
-        span_image_resample_gray(source_type& src, 
+    span_image_resample_gray(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
-                                 interpolator_type& inter,
+        : base_type(src, inter, filter)
-                                 const 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(), 
+        base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
-                                            y + base_type::filter_dy_dbl(), len);
         long_type fg;
 
         int diameter = base_type::filter().diameter();
@@ -683,9 +594,7 @@ namespace agg
 
             int radius_x = (diameter * rx) >> 1;
             int radius_y = (diameter * ry) >> 1;
-                int len_x_lr = 
+            int len_x_lr = (diameter * rx + image_subpixel_mask) >> image_subpixel_shift;
-                    (diameter * rx + image_subpixel_mask) >> 
-                        image_subpixel_shift;
 
             x += base_type::filter_dx_int() - radius_x;
             y += base_type::filter_dy_int() - radius_y;
@@ -693,17 +602,12 @@ namespace agg
             fg = image_filter_scale / 2;
 
             int y_lr = y >> image_subpixel_shift;
-                int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) * 
+            int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) * ry_inv) >> image_subpixel_shift;
-                               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)) * 
+            int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) * rx_inv) >> image_subpixel_shift;
-                               rx_inv) >> 
-                                   image_subpixel_shift;
             int x_hr2 = x_hr;
-                const value_type* fg_ptr = 
+            const value_type* fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
-                    (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
 
             for (;;)
             {
@@ -711,23 +615,25 @@ namespace agg
                 x_hr = x_hr2;
                 for (;;)
                 {
-                        int weight = (weight_y * weight_array[x_hr] + 
+                    int weight = (weight_y * weight_array[x_hr] + image_filter_scale / 2) >> downscale_shift;
-                                     image_filter_scale / 2) >> 
-                                     downscale_shift;
                     fg += *fg_ptr * weight;
                     total_weight += weight;
                     x_hr += rx_inv;
-                        if(x_hr >= filter_scale) break;
+                    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;
+                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 < 0)
-                if(fg > base_mask) fg = base_mask;
+                fg = 0;
+            if (fg > base_mask)
+                fg = base_mask;
 
             span->v = (value_type)fg;
             span->a = base_mask;
@@ -738,11 +644,6 @@ namespace agg
     }
 };
 
-
+} // namespace agg
-}
-
 
 #endif
-
-
-

deps/agg/include/agg_span_image_filter_rgb.h

@@ -27,14 +27,11 @@
 #include "agg_color_rgba.h"
 #include "agg_span_image_filter.h"
 
-
+namespace agg {
-namespace agg
-{
 
 //===============================================span_image_filter_rgb_nn
 template<class Source, class Interpolator>
-    class span_image_filter_rgb_nn : 
+class span_image_filter_rgb_nn : public span_image_filter<Source, Interpolator>
-    public span_image_filter<Source, Interpolator>
 {
   public:
     typedef Source source_type;
@@ -44,31 +41,23 @@ namespace agg
     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;
-        enum base_scale_e
+    enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
-        {
-            base_shift = color_type::base_shift,
-            base_mask  = color_type::base_mask
-        };
 
     //--------------------------------------------------------------------
     span_image_filter_rgb_nn() {}
-        span_image_filter_rgb_nn(source_type& src, 
+    span_image_filter_rgb_nn(source_type& src, interpolator_type& inter)
-                                 interpolator_type& inter) :
+        : base_type(src, inter, 0)
-            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(), 
+        base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
-                                            y + base_type::filter_dy_dbl(), len);
         do
         {
             base_type::interpolator().coordinates(&x, &y);
-                const value_type* fg_ptr = (const value_type*)
+            const value_type* fg_ptr =
-                    base_type::source().span(x >> image_subpixel_shift, 
+              (const value_type*)base_type::source().span(x >> image_subpixel_shift, y >> image_subpixel_shift, 1);
-                                             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];
@@ -80,12 +69,9 @@ namespace agg
     }
 };
 
-
-
 //==========================================span_image_filter_rgb_bilinear
 template<class Source, class Interpolator>
-    class span_image_filter_rgb_bilinear : 
+class span_image_filter_rgb_bilinear : public span_image_filter<Source, Interpolator>
-    public span_image_filter<Source, Interpolator>
 {
   public:
     typedef Source source_type;
@@ -95,25 +81,18 @@ namespace agg
     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;
-        enum base_scale_e
+    enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
-        {
-            base_shift = color_type::base_shift,
-            base_mask  = color_type::base_mask
-        };
 
     //--------------------------------------------------------------------
     span_image_filter_rgb_bilinear() {}
-        span_image_filter_rgb_bilinear(source_type& src, 
+    span_image_filter_rgb_bilinear(source_type& src, interpolator_type& inter)
-                                       interpolator_type& inter) :
+        : base_type(src, inter, 0)
-            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(), 
+        base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
-                                            y + base_type::filter_dy_dbl(), len);
         calc_type fg[3];
         const value_type* fg_ptr;
         do
@@ -131,16 +110,13 @@ namespace agg
 
             unsigned weight;
 
-                fg[0] = 
+            fg[0] = fg[1] = fg[2] = image_subpixel_scale * image_subpixel_scale / 2;
-                fg[1] = 
-                fg[2] = 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) * 
+            weight = (image_subpixel_scale - x_hr) * (image_subpixel_scale - y_hr);
-                         (image_subpixel_scale - y_hr);
             fg[0] += weight * *fg_ptr++;
             fg[1] += weight * *fg_ptr++;
             fg[2] += weight * *fg_ptr;
@@ -175,12 +151,9 @@ namespace agg
     }
 };
 
-
-
 //=====================================span_image_filter_rgb_bilinear_clip
 template<class Source, class Interpolator>
-    class span_image_filter_rgb_bilinear_clip : 
+class span_image_filter_rgb_bilinear_clip : public span_image_filter<Source, Interpolator>
-    public span_image_filter<Source, Interpolator>
 {
   public:
     typedef Source source_type;
@@ -190,19 +163,13 @@ namespace agg
     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;
-        enum base_scale_e
+    enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
-        {
-            base_shift = color_type::base_shift,
-            base_mask  = color_type::base_mask
-        };
 
     //--------------------------------------------------------------------
     span_image_filter_rgb_bilinear_clip() {}
-        span_image_filter_rgb_bilinear_clip(source_type& src, 
+    span_image_filter_rgb_bilinear_clip(source_type& src, const color_type& back_color, interpolator_type& inter)
-                                            const color_type& back_color,
+        : base_type(src, inter, 0)
-                                            interpolator_type& inter) :
+        , m_back_color(back_color)
-            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; }
@@ -210,8 +177,7 @@ namespace agg
     //--------------------------------------------------------------------
     void generate(color_type* span, int x, int y, unsigned len)
     {
-            base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 
+        base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
-                                            y + base_type::filter_dy_dbl(), len);
         calc_type fg[3];
         calc_type src_alpha;
         value_type back_r = m_back_color.r;
@@ -238,21 +204,16 @@ namespace agg
             int y_lr = y_hr >> image_subpixel_shift;
             unsigned weight;
 
-                if(x_lr >= 0    && y_lr >= 0 &&
+            if (x_lr >= 0 && y_lr >= 0 && x_lr < maxx && y_lr < maxy)
-                   x_lr <  maxx && y_lr <  maxy) 
             {
-                    fg[0] = 
+                fg[0] = fg[1] = fg[2] = image_subpixel_scale * image_subpixel_scale / 2;
-                    fg[1] = 
-                    fg[2] = image_subpixel_scale * image_subpixel_scale / 2;
 
                 x_hr &= image_subpixel_mask;
                 y_hr &= image_subpixel_mask;
 
-                    fg_ptr = (const value_type*)
+                fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
-                        base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
 
-                    weight = (image_subpixel_scale - x_hr) * 
+                weight = (image_subpixel_scale - x_hr) * (image_subpixel_scale - y_hr);
-                             (image_subpixel_scale - y_hr);
                 fg[0] += weight * *fg_ptr++;
                 fg[1] += weight * *fg_ptr++;
                 fg[2] += weight * *fg_ptr++;
@@ -263,8 +224,7 @@ namespace agg
                 fg[2] += weight * *fg_ptr++;
 
                 ++y_lr;
-                    fg_ptr = (const value_type*)
+                fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
-                        base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
 
                 weight = (image_subpixel_scale - x_hr) * y_hr;
                 fg[0] += weight * *fg_ptr++;
@@ -283,8 +243,7 @@ namespace agg
             }
             else
             {
-                    if(x_lr < -1   || y_lr < -1 ||
+                if (x_lr < -1 || y_lr < -1 || x_lr > maxx || y_lr > maxy)
-                       x_lr > maxx || y_lr > maxy)
                 {
                     fg[order_type::R] = back_r;
                     fg[order_type::G] = back_g;
@@ -293,21 +252,15 @@ namespace agg
                 }
                 else
                 {
-                        fg[0] = 
+                    fg[0] = fg[1] = fg[2] = src_alpha = image_subpixel_scale * image_subpixel_scale / 2;
-                        fg[1] = 
-                        fg[2] = 
-                        src_alpha = image_subpixel_scale * image_subpixel_scale / 2;
 
                     x_hr &= image_subpixel_mask;
                     y_hr &= image_subpixel_mask;
 
-                        weight = (image_subpixel_scale - x_hr) * 
+                    weight = (image_subpixel_scale - x_hr) * (image_subpixel_scale - y_hr);
-                                 (image_subpixel_scale - y_hr);
+                    if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
-                        if(x_lr >= 0    && y_lr >= 0 &&
-                           x_lr <= maxx && y_lr <= maxy)
                     {
-                            fg_ptr = (const value_type*)
+                        fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
-                                base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
 
                         fg[0] += weight * *fg_ptr++;
                         fg[1] += weight * *fg_ptr++;
@@ -325,11 +278,9 @@ namespace agg
                     x_lr++;
 
                     weight = x_hr * (image_subpixel_scale - y_hr);
-                        if(x_lr >= 0    && y_lr >= 0 &&
+                    if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
-                           x_lr <= maxx && y_lr <= maxy)
                     {
-                            fg_ptr = (const value_type*)
+                        fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
-                                base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
 
                         fg[0] += weight * *fg_ptr++;
                         fg[1] += weight * *fg_ptr++;
@@ -348,11 +299,9 @@ namespace agg
                     y_lr++;
 
                     weight = (image_subpixel_scale - x_hr) * y_hr;
-                        if(x_lr >= 0    && y_lr >= 0 &&
+                    if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
-                           x_lr <= maxx && y_lr <= maxy)
                     {
-                            fg_ptr = (const value_type*)
+                        fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
-                                base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
 
                         fg[0] += weight * *fg_ptr++;
                         fg[1] += weight * *fg_ptr++;
@@ -370,11 +319,9 @@ namespace agg
                     x_lr++;
 
                     weight = x_hr * y_hr;
-                        if(x_lr >= 0    && y_lr >= 0 &&
+                    if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
-                           x_lr <= maxx && y_lr <= maxy)
                     {
-                            fg_ptr = (const value_type*)
+                        fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
-                                base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
 
                         fg[0] += weight * *fg_ptr++;
                         fg[1] += weight * *fg_ptr++;
@@ -405,16 +352,14 @@ namespace agg
 
         } while (--len);
     }
+
   private:
     color_type m_back_color;
 };
 
-
-
 //===============================================span_image_filter_rgb_2x2
 template<class Source, class Interpolator>
-    class span_image_filter_rgb_2x2 : 
+class span_image_filter_rgb_2x2 : public span_image_filter<Source, Interpolator>
-    public span_image_filter<Source, Interpolator>
 {
   public:
     typedef Source source_type;
@@ -424,33 +369,24 @@ namespace agg
     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;
-        enum base_scale_e
+    enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
-        {
-            base_shift = color_type::base_shift,
-            base_mask  = color_type::base_mask
-        };
 
     //--------------------------------------------------------------------
     span_image_filter_rgb_2x2() {}
-        span_image_filter_rgb_2x2(source_type& src, 
+    span_image_filter_rgb_2x2(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
-                                  interpolator_type& inter,
+        : base_type(src, inter, &filter)
-                                  const 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(), 
+        base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
-                                            y + base_type::filter_dy_dbl(), len);
 
         calc_type fg[3];
 
         const value_type* fg_ptr;
-            const int16* weight_array = base_type::filter().weight_array() + 
+        const int16* weight_array =
-                                        ((base_type::filter().diameter()/2 - 1) << 
+          base_type::filter().weight_array() + ((base_type::filter().diameter() / 2 - 1) << image_subpixel_shift);
-                                          image_subpixel_shift);
         do
         {
             int x_hr;
@@ -471,8 +407,7 @@ namespace agg
             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 = (weight_array[x_hr + image_subpixel_scale] * weight_array[y_hr + image_subpixel_scale] +
-                          weight_array[y_hr + image_subpixel_scale] + 
                       image_filter_scale / 2) >>
                      image_filter_shift;
             fg[0] += weight * *fg_ptr++;
@@ -480,28 +415,21 @@ namespace agg
             fg[2] += weight * *fg_ptr;
 
             fg_ptr = (const value_type*)base_type::source().next_x();
-                weight = (weight_array[x_hr] * 
+            weight = (weight_array[x_hr] * weight_array[y_hr + image_subpixel_scale] + image_filter_scale / 2) >>
-                          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_ptr = (const value_type*)base_type::source().next_y();
-                weight = (weight_array[x_hr + image_subpixel_scale] * 
+            weight = (weight_array[x_hr + image_subpixel_scale] * weight_array[y_hr] + image_filter_scale / 2) >>
-                          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_ptr = (const value_type*)base_type::source().next_x();
-                weight = (weight_array[x_hr] * 
+            weight = (weight_array[x_hr] * weight_array[y_hr] + image_filter_scale / 2) >> image_filter_shift;
-                          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;
@@ -510,9 +438,12 @@ namespace agg
             fg[1] >>= image_filter_shift;
             fg[2] >>= image_filter_shift;
 
-                if(fg[order_type::R] > base_mask) fg[order_type::R] = base_mask;
+            if (fg[order_type::R] > base_mask)
-                if(fg[order_type::G] > base_mask) fg[order_type::G] = base_mask;
+                fg[order_type::R] = base_mask;
-                if(fg[order_type::B] > base_mask) fg[order_type::B] = base_mask;
+            if (fg[order_type::G] > base_mask)
+                fg[order_type::G] = base_mask;
+            if (fg[order_type::B] > base_mask)
+                fg[order_type::B] = base_mask;
 
             span->r = (value_type)fg[order_type::R];
             span->g = (value_type)fg[order_type::G];
@@ -526,12 +457,9 @@ namespace agg
     }
 };
 
-
-
 //===================================================span_image_filter_rgb
 template<class Source, class Interpolator>
-    class span_image_filter_rgb : 
+class span_image_filter_rgb : public span_image_filter<Source, Interpolator>
-    public span_image_filter<Source, Interpolator>
 {
   public:
     typedef Source source_type;
@@ -541,25 +469,18 @@ namespace agg
     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;
-        enum base_scale_e
+    enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
-        {
-            base_shift = color_type::base_shift,
-            base_mask  = color_type::base_mask
-        };
 
     //--------------------------------------------------------------------
     span_image_filter_rgb() {}
-        span_image_filter_rgb(source_type& src, 
+    span_image_filter_rgb(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
-                              interpolator_type& inter,
+        : base_type(src, inter, &filter)
-                              const 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(), 
+        base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
-                                            y + base_type::filter_dy_dbl(), len);
 
         int fg[3];
         const value_type* fg_ptr;
@@ -590,9 +511,7 @@ namespace agg
             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, 
+            fg_ptr = (const value_type*)base_type::source().span(x_lr + start, y_lr + start, diameter);
-                                                                     y_lr + start, 
-                                                                     diameter);
             for (;;)
             {
                 x_count = diameter;
@@ -600,20 +519,20 @@ namespace agg
                 x_hr = image_subpixel_mask - x_fract;
                 for (;;)
                 {
-                        int weight = (weight_y * weight_array[x_hr] + 
+                    int weight = (weight_y * weight_array[x_hr] + image_filter_scale / 2) >> image_filter_shift;
-                                     image_filter_scale / 2) >> 
-                                     image_filter_shift;
 
                     fg[0] += weight * *fg_ptr++;
                     fg[1] += weight * *fg_ptr++;
                     fg[2] += weight * *fg_ptr;
 
-                        if(--x_count == 0) break;
+                    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;
+                if (--y_count == 0)
+                    break;
                 y_hr += image_subpixel_scale;
                 fg_ptr = (const value_type*)base_type::source().next_y();
             }
@@ -622,13 +541,19 @@ namespace agg
             fg[1] >>= image_filter_shift;
             fg[2] >>= image_filter_shift;
 
-                if(fg[0] < 0) fg[0] = 0;
+            if (fg[0] < 0)
-                if(fg[1] < 0) fg[1] = 0;
+                fg[0] = 0;
-                if(fg[2] < 0) fg[2] = 0;
+            if (fg[1] < 0)
+                fg[1] = 0;
+            if (fg[2] < 0)
+                fg[2] = 0;
 
-                if(fg[order_type::R] > base_mask) fg[order_type::R] = base_mask;
+            if (fg[order_type::R] > base_mask)
-                if(fg[order_type::G] > base_mask) fg[order_type::G] = base_mask;
+                fg[order_type::R] = base_mask;
-                if(fg[order_type::B] > base_mask) fg[order_type::B] = base_mask;
+            if (fg[order_type::G] > base_mask)
+                fg[order_type::G] = base_mask;
+            if (fg[order_type::B] > base_mask)
+                fg[order_type::B] = base_mask;
 
             span->r = (value_type)fg[order_type::R];
             span->g = (value_type)fg[order_type::G];
@@ -642,12 +567,9 @@ namespace agg
     }
 };
 
-
-
 //==========================================span_image_resample_rgb_affine
 template<class Source>
-    class span_image_resample_rgb_affine : 
+class span_image_resample_rgb_affine : public span_image_resample_affine<Source>
-    public span_image_resample_affine<Source>
 {
   public:
     typedef Source source_type;
@@ -657,8 +579,7 @@ namespace agg
     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
+    enum base_scale_e {
-        {
         base_shift = color_type::base_shift,
         base_mask = color_type::base_mask,
         downscale_shift = image_filter_shift
@@ -666,18 +587,14 @@ namespace agg
 
     //--------------------------------------------------------------------
     span_image_resample_rgb_affine() {}
-        span_image_resample_rgb_affine(source_type& src, 
+    span_image_resample_rgb_affine(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
-                                       interpolator_type& inter,
+        : base_type(src, inter, filter)
-                                       const 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(), 
+        base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
-                                            y + base_type::filter_dy_dbl(), len);
 
         long_type fg[3];
 
@@ -685,9 +602,7 @@ namespace agg
         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     = 
+        int len_x_lr = (diameter * base_type::m_rx + image_subpixel_mask) >> image_subpixel_shift;
-                (diameter * base_type::m_rx + image_subpixel_mask) >> 
-                    image_subpixel_shift;
 
         const int16* weight_array = base_type::filter().weight_array();
 
@@ -701,38 +616,35 @@ namespace agg
             fg[0] = fg[1] = fg[2] = image_filter_scale / 2;
 
             int y_lr = y >> image_subpixel_shift;
-                int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) * 
+            int y_hr =
-                                base_type::m_ry_inv) >> 
+              ((image_subpixel_mask - (y & image_subpixel_mask)) * base_type::m_ry_inv) >> image_subpixel_shift;
-                                    image_subpixel_shift;
             int total_weight = 0;
             int x_lr = x >> image_subpixel_shift;
-                int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) * 
+            int x_hr =
-                                base_type::m_rx_inv) >> 
+              ((image_subpixel_mask - (x & image_subpixel_mask)) * base_type::m_rx_inv) >> image_subpixel_shift;
-                                    image_subpixel_shift;
 
             int x_hr2 = x_hr;
-                const value_type* fg_ptr = 
+            const value_type* fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
-                    (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] + 
+                    int weight = (weight_y * weight_array[x_hr] + image_filter_scale / 2) >> downscale_shift;
-                                     image_filter_scale / 2) >> 
-                                     downscale_shift;
 
                     fg[0] += *fg_ptr++ * weight;
                     fg[1] += *fg_ptr++ * weight;
                     fg[2] += *fg_ptr * weight;
                     total_weight += weight;
                     x_hr += base_type::m_rx_inv;
-                        if(x_hr >= filter_scale) break;
+                    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;
+                if (y_hr >= filter_scale)
+                    break;
                 fg_ptr = (const value_type*)base_type::source().next_y();
             }
 
@@ -740,13 +652,19 @@ namespace agg
             fg[1] /= total_weight;
             fg[2] /= total_weight;
 
-                if(fg[0] < 0) fg[0] = 0;
+            if (fg[0] < 0)
-                if(fg[1] < 0) fg[1] = 0;
+                fg[0] = 0;
-                if(fg[2] < 0) fg[2] = 0;
+            if (fg[1] < 0)
+                fg[1] = 0;
+            if (fg[2] < 0)
+                fg[2] = 0;
 
-                if(fg[order_type::R] > base_mask) fg[order_type::R] = base_mask;
+            if (fg[order_type::R] > base_mask)
-                if(fg[order_type::G] > base_mask) fg[order_type::G] = base_mask;
+                fg[order_type::R] = base_mask;
-                if(fg[order_type::B] > base_mask) fg[order_type::B] = base_mask;
+            if (fg[order_type::G] > base_mask)
+                fg[order_type::G] = base_mask;
+            if (fg[order_type::B] > base_mask)
+                fg[order_type::B] = base_mask;
 
             span->r = (value_type)fg[order_type::R];
             span->g = (value_type)fg[order_type::G];
@@ -759,12 +677,9 @@ namespace agg
     }
 };
 
-
-
 //=================================================span_image_resample_rgb
 template<class Source, class Interpolator>
-    class span_image_resample_rgb : 
+class span_image_resample_rgb : public span_image_resample<Source, Interpolator>
-    public span_image_resample<Source, Interpolator>
 {
   public:
     typedef Source source_type;
@@ -774,8 +689,7 @@ namespace agg
     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
+    enum base_scale_e {
-        {
         base_shift = color_type::base_shift,
         base_mask = color_type::base_mask,
         downscale_shift = image_filter_shift
@@ -783,17 +697,14 @@ namespace agg
 
     //--------------------------------------------------------------------
     span_image_resample_rgb() {}
-        span_image_resample_rgb(source_type& src, 
+    span_image_resample_rgb(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
-                                interpolator_type& inter,
+        : base_type(src, inter, filter)
-                                const 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(), 
+        base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
-                                            y + base_type::filter_dy_dbl(), len);
         long_type fg[3];
 
         int diameter = base_type::filter().diameter();
@@ -815,9 +726,7 @@ namespace agg
 
             int radius_x = (diameter * rx) >> 1;
             int radius_y = (diameter * ry) >> 1;
-                int len_x_lr = 
+            int len_x_lr = (diameter * rx + image_subpixel_mask) >> image_subpixel_shift;
-                    (diameter * rx + image_subpixel_mask) >> 
-                        image_subpixel_shift;
 
             x += base_type::filter_dx_int() - radius_x;
             y += base_type::filter_dy_int() - radius_y;
@@ -825,17 +734,12 @@ namespace agg
             fg[0] = fg[1] = fg[2] = image_filter_scale / 2;
 
             int y_lr = y >> image_subpixel_shift;
-                int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) * 
+            int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) * ry_inv) >> image_subpixel_shift;
-                               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)) * 
+            int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) * rx_inv) >> image_subpixel_shift;
-                               rx_inv) >> 
-                                   image_subpixel_shift;
             int x_hr2 = x_hr;
-                const value_type* fg_ptr = 
+            const value_type* fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
-                    (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
 
             for (;;)
             {
@@ -843,19 +747,19 @@ namespace agg
                 x_hr = x_hr2;
                 for (;;)
                 {
-                        int weight = (weight_y * weight_array[x_hr] + 
+                    int weight = (weight_y * weight_array[x_hr] + image_filter_scale / 2) >> downscale_shift;
-                                     image_filter_scale / 2) >> 
-                                     downscale_shift;
                     fg[0] += *fg_ptr++ * weight;
                     fg[1] += *fg_ptr++ * weight;
                     fg[2] += *fg_ptr * weight;
                     total_weight += weight;
                     x_hr += rx_inv;
-                        if(x_hr >= filter_scale) break;
+                    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;
+                if (y_hr >= filter_scale)
+                    break;
                 fg_ptr = (const value_type*)base_type::source().next_y();
             }
 
@@ -863,13 +767,19 @@ namespace agg
             fg[1] /= total_weight;
             fg[2] /= total_weight;
 
-                if(fg[0] < 0) fg[0] = 0;
+            if (fg[0] < 0)
-                if(fg[1] < 0) fg[1] = 0;
+                fg[0] = 0;
-                if(fg[2] < 0) fg[2] = 0;
+            if (fg[1] < 0)
+                fg[1] = 0;
+            if (fg[2] < 0)
+                fg[2] = 0;
 
-                if(fg[order_type::R] > base_mask) fg[order_type::R] = base_mask;
+            if (fg[order_type::R] > base_mask)
-                if(fg[order_type::G] > base_mask) fg[order_type::G] = base_mask;
+                fg[order_type::R] = base_mask;
-                if(fg[order_type::B] > base_mask) fg[order_type::B] = base_mask;
+            if (fg[order_type::G] > base_mask)
+                fg[order_type::G] = base_mask;
+            if (fg[order_type::B] > base_mask)
+                fg[order_type::B] = base_mask;
 
             span->r = (value_type)fg[order_type::R];
             span->g = (value_type)fg[order_type::G];
@@ -882,11 +792,6 @@ namespace agg
     }
 };
 
-
+} // namespace agg
-}
-
 
 #endif
-
-
-

deps/agg/include/agg_span_image_filter_rgba.h

@@ -27,14 +27,11 @@
 #include "agg_color_rgba.h"
 #include "agg_span_image_filter.h"
 
-
+namespace agg {
-namespace agg
-{
 
 //==============================================span_image_filter_rgba_nn
 template<class Source, class Interpolator>
-    class span_image_filter_rgba_nn : 
+class span_image_filter_rgba_nn : public span_image_filter<Source, Interpolator>
-    public span_image_filter<Source, Interpolator>
 {
   public:
     typedef Source source_type;
@@ -44,31 +41,23 @@ namespace agg
     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;
-        enum base_scale_e
+    enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
-        {
-            base_shift = color_type::base_shift,
-            base_mask  = color_type::base_mask
-        };
 
     //--------------------------------------------------------------------
     span_image_filter_rgba_nn() {}
-        span_image_filter_rgba_nn(source_type& src, 
+    span_image_filter_rgba_nn(source_type& src, interpolator_type& inter)
-                                  interpolator_type& inter) :
+        : base_type(src, inter, 0)
-            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(), 
+        base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
-                                            y + base_type::filter_dy_dbl(), len);
         do
         {
             base_type::interpolator().coordinates(&x, &y);
-                const value_type* fg_ptr = (const value_type*)
+            const value_type* fg_ptr =
-                    base_type::source().span(x >> image_subpixel_shift, 
+              (const value_type*)base_type::source().span(x >> image_subpixel_shift, y >> image_subpixel_shift, 1);
-                                             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];
@@ -80,12 +69,9 @@ namespace agg
     }
 };
 
-
-
 //=========================================span_image_filter_rgba_bilinear
 template<class Source, class Interpolator>
-    class span_image_filter_rgba_bilinear : 
+class span_image_filter_rgba_bilinear : public span_image_filter<Source, Interpolator>
-    public span_image_filter<Source, Interpolator>
 {
   public:
     typedef Source source_type;
@@ -95,25 +81,18 @@ namespace agg
     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;
-        enum base_scale_e
+    enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
-        {
-            base_shift = color_type::base_shift,
-            base_mask  = color_type::base_mask
-        };
 
     //--------------------------------------------------------------------
     span_image_filter_rgba_bilinear() {}
-        span_image_filter_rgba_bilinear(source_type& src, 
+    span_image_filter_rgba_bilinear(source_type& src, interpolator_type& inter)
-                                        interpolator_type& inter) :
+        : base_type(src, inter, 0)
-            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(), 
+        base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
-                                            y + base_type::filter_dy_dbl(), len);
 
         calc_type fg[4];
         const value_type* fg_ptr;
@@ -133,17 +112,13 @@ namespace agg
 
             unsigned weight;
 
-                fg[0] = 
+            fg[0] = fg[1] = fg[2] = fg[3] = image_subpixel_scale * image_subpixel_scale / 2;
-                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) * 
+            weight = (image_subpixel_scale - x_hr) * (image_subpixel_scale - y_hr);
-                         (image_subpixel_scale - y_hr);
             fg[0] += weight * *fg_ptr++;
             fg[1] += weight * *fg_ptr++;
             fg[2] += weight * *fg_ptr++;
@@ -182,11 +157,9 @@ namespace agg
     }
 };
 
-
 //====================================span_image_filter_rgba_bilinear_clip
 template<class Source, class Interpolator>
-    class span_image_filter_rgba_bilinear_clip : 
+class span_image_filter_rgba_bilinear_clip : public span_image_filter<Source, Interpolator>
-    public span_image_filter<Source, Interpolator>
 {
   public:
     typedef Source source_type;
@@ -196,29 +169,21 @@ namespace agg
     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;
-        enum base_scale_e
+    enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
-        {
-            base_shift = color_type::base_shift,
-            base_mask  = color_type::base_mask
-        };
 
     //--------------------------------------------------------------------
     span_image_filter_rgba_bilinear_clip() {}
-        span_image_filter_rgba_bilinear_clip(source_type& src, 
+    span_image_filter_rgba_bilinear_clip(source_type& src, const color_type& back_color, interpolator_type& inter)
-                                             const color_type& back_color,
+        : base_type(src, inter, 0)
-                                             interpolator_type& inter) :
+        , m_back_color(back_color)
-            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(), 
+        base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
-                                            y + base_type::filter_dy_dbl(), len);
 
         calc_type fg[4];
         value_type back_r = m_back_color.r;
@@ -245,22 +210,16 @@ namespace agg
 
             unsigned weight;
 
-                if(x_lr >= 0    && y_lr >= 0 &&
+            if (x_lr >= 0 && y_lr >= 0 && x_lr < maxx && y_lr < maxy)
-                   x_lr <  maxx && y_lr <  maxy) 
             {
-                    fg[0] = 
+                fg[0] = fg[1] = fg[2] = fg[3] = image_subpixel_scale * image_subpixel_scale / 2;
-                    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*)
+                fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + (x_lr << 2);
-                        base_type::source().row_ptr(y_lr) + (x_lr << 2);
 
-                    weight = (image_subpixel_scale - x_hr) * 
+                weight = (image_subpixel_scale - x_hr) * (image_subpixel_scale - y_hr);
-                             (image_subpixel_scale - y_hr);
                 fg[0] += weight * *fg_ptr++;
                 fg[1] += weight * *fg_ptr++;
                 fg[2] += weight * *fg_ptr++;
@@ -273,8 +232,7 @@ namespace agg
                 fg[3] += weight * *fg_ptr++;
 
                 ++y_lr;
-                    fg_ptr = (const value_type*)
+                fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + (x_lr << 2);
-                        base_type::source().row_ptr(y_lr) + (x_lr << 2);
 
                 weight = (image_subpixel_scale - x_hr) * y_hr;
                 fg[0] += weight * *fg_ptr++;
@@ -295,8 +253,7 @@ namespace agg
             }
             else
             {
-                    if(x_lr < -1   || y_lr < -1 ||
+                if (x_lr < -1 || y_lr < -1 || x_lr > maxx || y_lr > maxy)
-                       x_lr > maxx || y_lr > maxy)
                 {
                     fg[order_type::R] = back_r;
                     fg[order_type::G] = back_g;
@@ -305,21 +262,15 @@ namespace agg
                 }
                 else
                 {
-                        fg[0] = 
+                    fg[0] = fg[1] = fg[2] = fg[3] = image_subpixel_scale * image_subpixel_scale / 2;
-                        fg[1] = 
-                        fg[2] = 
-                        fg[3] = image_subpixel_scale * image_subpixel_scale / 2;
 
                     x_hr &= image_subpixel_mask;
                     y_hr &= image_subpixel_mask;
 
-                        weight = (image_subpixel_scale - x_hr) * 
+                    weight = (image_subpixel_scale - x_hr) * (image_subpixel_scale - y_hr);
-                                 (image_subpixel_scale - y_hr);
+                    if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
-                        if(x_lr >= 0    && y_lr >= 0 &&
-                           x_lr <= maxx && y_lr <= maxy)
                     {
-                            fg_ptr = (const value_type*)
+                        fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + (x_lr << 2);
-                                base_type::source().row_ptr(y_lr) + (x_lr << 2);
 
                         fg[0] += weight * *fg_ptr++;
                         fg[1] += weight * *fg_ptr++;
@@ -337,11 +288,9 @@ namespace agg
                     x_lr++;
 
                     weight = x_hr * (image_subpixel_scale - y_hr);
-                        if(x_lr >= 0    && y_lr >= 0 &&
+                    if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
-                           x_lr <= maxx && y_lr <= maxy)
                     {
-                            fg_ptr = (const value_type*)
+                        fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + (x_lr << 2);
-                                base_type::source().row_ptr(y_lr) + (x_lr << 2);
 
                         fg[0] += weight * *fg_ptr++;
                         fg[1] += weight * *fg_ptr++;
@@ -360,11 +309,9 @@ namespace agg
                     y_lr++;
 
                     weight = (image_subpixel_scale - x_hr) * y_hr;
-                        if(x_lr >= 0    && y_lr >= 0 &&
+                    if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
-                           x_lr <= maxx && y_lr <= maxy)
                     {
-                            fg_ptr = (const value_type*)
+                        fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + (x_lr << 2);
-                                base_type::source().row_ptr(y_lr) + (x_lr << 2);
 
                         fg[0] += weight * *fg_ptr++;
                         fg[1] += weight * *fg_ptr++;
@@ -382,11 +329,9 @@ namespace agg
                     x_lr++;
 
                     weight = x_hr * y_hr;
-                        if(x_lr >= 0    && y_lr >= 0 &&
+                    if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
-                           x_lr <= maxx && y_lr <= maxy)
                     {
-                            fg_ptr = (const value_type*)
+                        fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + (x_lr << 2);
-                                base_type::source().row_ptr(y_lr) + (x_lr << 2);
 
                         fg[0] += weight * *fg_ptr++;
                         fg[1] += weight * *fg_ptr++;
@@ -417,15 +362,14 @@ namespace agg
 
         } while (--len);
     }
+
   private:
     color_type m_back_color;
 };
 
-
 //==============================================span_image_filter_rgba_2x2
 template<class Source, class Interpolator>
-    class span_image_filter_rgba_2x2 : 
+class span_image_filter_rgba_2x2 : public span_image_filter<Source, Interpolator>
-    public span_image_filter<Source, Interpolator>
 {
   public:
     typedef Source source_type;
@@ -435,33 +379,24 @@ namespace agg
     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;
-        enum base_scale_e
+    enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
-        {
-            base_shift = color_type::base_shift,
-            base_mask  = color_type::base_mask
-        };
 
     //--------------------------------------------------------------------
     span_image_filter_rgba_2x2() {}
-        span_image_filter_rgba_2x2(source_type& src, 
+    span_image_filter_rgba_2x2(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
-                                   interpolator_type& inter,
+        : base_type(src, inter, &filter)
-                                   const 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(), 
+        base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
-                                            y + base_type::filter_dy_dbl(), len);
 
         calc_type fg[4];
 
         const value_type* fg_ptr;
-            const int16* weight_array = base_type::filter().weight_array() + 
+        const int16* weight_array =
-                                        ((base_type::filter().diameter()/2 - 1) << 
+          base_type::filter().weight_array() + ((base_type::filter().diameter() / 2 - 1) << image_subpixel_shift);
-                                          image_subpixel_shift);
 
         do
         {
@@ -483,8 +418,7 @@ namespace agg
             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 = (weight_array[x_hr + image_subpixel_scale] * weight_array[y_hr + image_subpixel_scale] +
-                          weight_array[y_hr + image_subpixel_scale] + 
                       image_filter_scale / 2) >>
                      image_filter_shift;
             fg[0] += weight * *fg_ptr++;
@@ -493,9 +427,7 @@ namespace agg
             fg[3] += weight * *fg_ptr;
 
             fg_ptr = (const value_type*)base_type::source().next_x();
-                weight = (weight_array[x_hr] * 
+            weight = (weight_array[x_hr] * weight_array[y_hr + image_subpixel_scale] + image_filter_scale / 2) >>
-                          weight_array[y_hr + image_subpixel_scale] + 
-                          image_filter_scale / 2) >> 
                      image_filter_shift;
             fg[0] += weight * *fg_ptr++;
             fg[1] += weight * *fg_ptr++;
@@ -503,9 +435,7 @@ namespace agg
             fg[3] += weight * *fg_ptr;
 
             fg_ptr = (const value_type*)base_type::source().next_y();
-                weight = (weight_array[x_hr + image_subpixel_scale] * 
+            weight = (weight_array[x_hr + image_subpixel_scale] * weight_array[y_hr] + image_filter_scale / 2) >>
-                          weight_array[y_hr] + 
-                          image_filter_scale / 2) >> 
                      image_filter_shift;
             fg[0] += weight * *fg_ptr++;
             fg[1] += weight * *fg_ptr++;
@@ -513,10 +443,7 @@ namespace agg
             fg[3] += weight * *fg_ptr;
 
             fg_ptr = (const value_type*)base_type::source().next_x();
-                weight = (weight_array[x_hr] * 
+            weight = (weight_array[x_hr] * weight_array[y_hr] + image_filter_scale / 2) >> image_filter_shift;
-                          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++;
@@ -527,10 +454,14 @@ namespace agg
             fg[2] >>= image_filter_shift;
             fg[3] >>= image_filter_shift;
 
-                if(fg[order_type::A] > base_mask)         fg[order_type::A] = base_mask;
+            if (fg[order_type::A] > base_mask)
-                if(fg[order_type::R] > fg[order_type::A]) fg[order_type::R] = fg[order_type::A];
+                fg[order_type::A] = base_mask;
-                if(fg[order_type::G] > fg[order_type::A]) fg[order_type::G] = fg[order_type::A];
+            if (fg[order_type::R] > fg[order_type::A])
-                if(fg[order_type::B] > fg[order_type::A]) fg[order_type::B] = 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];
@@ -543,12 +474,9 @@ namespace agg
     }
 };
 
-
-
 //==================================================span_image_filter_rgba
 template<class Source, class Interpolator>
-    class span_image_filter_rgba : 
+class span_image_filter_rgba : public span_image_filter<Source, Interpolator>
-    public span_image_filter<Source, Interpolator>
 {
   public:
     typedef Source source_type;
@@ -558,25 +486,18 @@ namespace agg
     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;
-        enum base_scale_e
+    enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
-        {
-            base_shift = color_type::base_shift,
-            base_mask  = color_type::base_mask
-        };
 
     //--------------------------------------------------------------------
     span_image_filter_rgba() {}
-        span_image_filter_rgba(source_type& src, 
+    span_image_filter_rgba(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
-                               interpolator_type& inter,
+        : base_type(src, inter, &filter)
-                               const 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(), 
+        base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
-                                            y + base_type::filter_dy_dbl(), len);
 
         int fg[4];
         const value_type* fg_ptr;
@@ -607,9 +528,7 @@ namespace agg
             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, 
+            fg_ptr = (const value_type*)base_type::source().span(x_lr + start, y_lr + start, diameter);
-                                                                     y_lr + start, 
-                                                                     diameter);
             for (;;)
             {
                 x_count = diameter;
@@ -617,21 +536,21 @@ namespace agg
                 x_hr = image_subpixel_mask - x_fract;
                 for (;;)
                 {
-                        int weight = (weight_y * weight_array[x_hr] + 
+                    int weight = (weight_y * weight_array[x_hr] + image_filter_scale / 2) >> image_filter_shift;
-                                     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;
+                    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;
+                if (--y_count == 0)
+                    break;
                 y_hr += image_subpixel_scale;
                 fg_ptr = (const value_type*)base_type::source().next_y();
             }
@@ -641,15 +560,23 @@ namespace agg
             fg[2] >>= image_filter_shift;
             fg[3] >>= image_filter_shift;
 
-                if(fg[0] < 0) fg[0] = 0;
+            if (fg[0] < 0)
-                if(fg[1] < 0) fg[1] = 0;
+                fg[0] = 0;
-                if(fg[2] < 0) fg[2] = 0;
+            if (fg[1] < 0)
-                if(fg[3] < 0) fg[3] = 0;
+                fg[1] = 0;
+            if (fg[2] < 0)
+                fg[2] = 0;
+            if (fg[3] < 0)
+                fg[3] = 0;
 
-                if(fg[order_type::A] > base_mask)         fg[order_type::A] = base_mask;
+            if (fg[order_type::A] > base_mask)
-                if(fg[order_type::R] > fg[order_type::A]) fg[order_type::R] = fg[order_type::A];
+                fg[order_type::A] = base_mask;
-                if(fg[order_type::G] > fg[order_type::A]) fg[order_type::G] = fg[order_type::A];
+            if (fg[order_type::R] > fg[order_type::A])
-                if(fg[order_type::B] > fg[order_type::A]) fg[order_type::B] = 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];
@@ -662,12 +589,9 @@ namespace agg
     }
 };
 
-
-
 //========================================span_image_resample_rgba_affine
 template<class Source>
-    class span_image_resample_rgba_affine : 
+class span_image_resample_rgba_affine : public span_image_resample_affine<Source>
-    public span_image_resample_affine<Source>
 {
   public:
     typedef Source source_type;
@@ -677,8 +601,7 @@ namespace agg
     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
+    enum base_scale_e {
-        {
         base_shift = color_type::base_shift,
         base_mask = color_type::base_mask,
         downscale_shift = image_filter_shift
@@ -686,18 +609,14 @@ namespace agg
 
     //--------------------------------------------------------------------
     span_image_resample_rgba_affine() {}
-        span_image_resample_rgba_affine(source_type& src, 
+    span_image_resample_rgba_affine(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
-                                        interpolator_type& inter,
+        : base_type(src, inter, filter)
-                                        const 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(), 
+        base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
-                                            y + base_type::filter_dy_dbl(), len);
 
         long_type fg[4];
 
@@ -705,9 +624,7 @@ namespace agg
         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     = 
+        int len_x_lr = (diameter * base_type::m_rx + image_subpixel_mask) >> image_subpixel_shift;
-                (diameter * base_type::m_rx + image_subpixel_mask) >> 
-                    image_subpixel_shift;
 
         const int16* weight_array = base_type::filter().weight_array();
 
@@ -721,27 +638,22 @@ namespace agg
             fg[0] = fg[1] = fg[2] = fg[3] = image_filter_scale / 2;
 
             int y_lr = y >> image_subpixel_shift;
-                int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) * 
+            int y_hr =
-                                base_type::m_ry_inv) >> 
+              ((image_subpixel_mask - (y & image_subpixel_mask)) * base_type::m_ry_inv) >> image_subpixel_shift;
-                                    image_subpixel_shift;
             int total_weight = 0;
             int x_lr = x >> image_subpixel_shift;
-                int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) * 
+            int x_hr =
-                                base_type::m_rx_inv) >> 
+              ((image_subpixel_mask - (x & image_subpixel_mask)) * base_type::m_rx_inv) >> image_subpixel_shift;
-                                    image_subpixel_shift;
 
             int x_hr2 = x_hr;
-                const value_type* fg_ptr = 
+            const value_type* fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
-                    (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] + 
+                    int weight = (weight_y * weight_array[x_hr] + image_filter_scale / 2) >> downscale_shift;
-                                     image_filter_scale / 2) >> 
-                                     downscale_shift;
 
                     fg[0] += *fg_ptr++ * weight;
                     fg[1] += *fg_ptr++ * weight;
@@ -749,11 +661,13 @@ namespace agg
                     fg[3] += *fg_ptr++ * weight;
                     total_weight += weight;
                     x_hr += base_type::m_rx_inv;
-                        if(x_hr >= filter_scale) break;
+                    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;
+                if (y_hr >= filter_scale)
+                    break;
                 fg_ptr = (const value_type*)base_type::source().next_y();
             }
 
@@ -762,15 +676,23 @@ namespace agg
             fg[2] /= total_weight;
             fg[3] /= total_weight;
 
-                if(fg[0] < 0) fg[0] = 0;
+            if (fg[0] < 0)
-                if(fg[1] < 0) fg[1] = 0;
+                fg[0] = 0;
-                if(fg[2] < 0) fg[2] = 0;
+            if (fg[1] < 0)
-                if(fg[3] < 0) fg[3] = 0;
+                fg[1] = 0;
+            if (fg[2] < 0)
+                fg[2] = 0;
+            if (fg[3] < 0)
+                fg[3] = 0;
 
-                if(fg[order_type::A] > base_mask)         fg[order_type::A] = base_mask;
+            if (fg[order_type::A] > base_mask)
-                if(fg[order_type::R] > fg[order_type::A]) fg[order_type::R] = fg[order_type::A];
+                fg[order_type::A] = base_mask;
-                if(fg[order_type::G] > fg[order_type::A]) fg[order_type::G] = fg[order_type::A];
+            if (fg[order_type::R] > fg[order_type::A])
-                if(fg[order_type::B] > fg[order_type::A]) fg[order_type::B] = 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];
@@ -783,12 +705,9 @@ namespace agg
     }
 };
 
-
-
 //==============================================span_image_resample_rgba
 template<class Source, class Interpolator>
-    class span_image_resample_rgba : 
+class span_image_resample_rgba : public span_image_resample<Source, Interpolator>
-    public span_image_resample<Source, Interpolator>
 {
   public:
     typedef Source source_type;
@@ -798,8 +717,7 @@ namespace agg
     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
+    enum base_scale_e {
-        {
         base_shift = color_type::base_shift,
         base_mask = color_type::base_mask,
         downscale_shift = image_filter_shift
@@ -807,17 +725,14 @@ namespace agg
 
     //--------------------------------------------------------------------
     span_image_resample_rgba() {}
-        span_image_resample_rgba(source_type& src, 
+    span_image_resample_rgba(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
-                                 interpolator_type& inter,
+        : base_type(src, inter, filter)
-                                 const 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(), 
+        base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
-                                            y + base_type::filter_dy_dbl(), len);
         long_type fg[4];
 
         int diameter = base_type::filter().diameter();
@@ -839,9 +754,7 @@ namespace agg
 
             int radius_x = (diameter * rx) >> 1;
             int radius_y = (diameter * ry) >> 1;
-                int len_x_lr = 
+            int len_x_lr = (diameter * rx + image_subpixel_mask) >> image_subpixel_shift;
-                    (diameter * rx + image_subpixel_mask) >> 
-                        image_subpixel_shift;
 
             x += base_type::filter_dx_int() - radius_x;
             y += base_type::filter_dy_int() - radius_y;
@@ -849,17 +762,12 @@ namespace agg
             fg[0] = fg[1] = fg[2] = fg[3] = image_filter_scale / 2;
 
             int y_lr = y >> image_subpixel_shift;
-                int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) * 
+            int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) * ry_inv) >> image_subpixel_shift;
-                               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)) * 
+            int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) * rx_inv) >> image_subpixel_shift;
-                               rx_inv) >> 
-                                   image_subpixel_shift;
             int x_hr2 = x_hr;
-                const value_type* fg_ptr = 
+            const value_type* fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
-                    (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
 
             for (;;)
             {
@@ -867,20 +775,20 @@ namespace agg
                 x_hr = x_hr2;
                 for (;;)
                 {
-                        int weight = (weight_y * weight_array[x_hr] + 
+                    int weight = (weight_y * weight_array[x_hr] + image_filter_scale / 2) >> downscale_shift;
-                                     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;
+                    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;
+                if (y_hr >= filter_scale)
+                    break;
                 fg_ptr = (const value_type*)base_type::source().next_y();
             }
 
@@ -889,15 +797,23 @@ namespace agg
             fg[2] /= total_weight;
             fg[3] /= total_weight;
 
-                if(fg[0] < 0) fg[0] = 0;
+            if (fg[0] < 0)
-                if(fg[1] < 0) fg[1] = 0;
+                fg[0] = 0;
-                if(fg[2] < 0) fg[2] = 0;
+            if (fg[1] < 0)
-                if(fg[3] < 0) fg[3] = 0;
+                fg[1] = 0;
+            if (fg[2] < 0)
+                fg[2] = 0;
+            if (fg[3] < 0)
+                fg[3] = 0;
 
-                if(fg[order_type::A] > base_mask)         fg[order_type::A] = base_mask;
+            if (fg[order_type::A] > base_mask)
-                if(fg[order_type::R] > fg[order_type::A]) fg[order_type::R] = fg[order_type::A];
+                fg[order_type::A] = base_mask;
-                if(fg[order_type::G] > fg[order_type::A]) fg[order_type::G] = fg[order_type::A];
+            if (fg[order_type::R] > fg[order_type::A])
-                if(fg[order_type::B] > fg[order_type::A]) fg[order_type::B] = 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];
@@ -910,11 +826,6 @@ namespace agg
     }
 };
 
-
+} // namespace agg
-}
-
 
 #endif
-
-
-

deps/agg/include/agg_span_interpolator_adaptor.h

@@ -18,8 +18,7 @@
 
 #include "agg_basics.h"
 
-namespace agg
+namespace agg {
-{
 
 //===============================================span_interpolator_adaptor
 template<class Interpolator, class Distortion>
@@ -32,33 +31,22 @@ namespace agg
 
     //--------------------------------------------------------------------
     span_interpolator_adaptor() {}
-        span_interpolator_adaptor(const trans_type& trans, 
+    span_interpolator_adaptor(const trans_type& trans, const distortion_type& dist)
-                                  const distortion_type& dist) :
+        : base_type(trans)
-            base_type(trans),
+        , m_distortion(&dist)
-            m_distortion(&dist)
+    {}
-        {   
-        }
 
     //--------------------------------------------------------------------
-        span_interpolator_adaptor(const trans_type& trans,
+    span_interpolator_adaptor(const trans_type& trans, const distortion_type& dist, double x, double y, unsigned len)
-                                  const distortion_type& dist,
+        : base_type(trans, x, y, len)
-                                  double x, double y, unsigned len) :
+        , m_distortion(&dist)
-            base_type(trans, x, y, len),
+    {}
-            m_distortion(&dist)
-        {
-        }
 
     //--------------------------------------------------------------------
-        const distortion_type& distortion() const
+    const distortion_type& distortion() const { return *m_distortion; }
-        {
-            return *m_distortion;
-        }
 
     //--------------------------------------------------------------------
-        void distortion(const distortion_type& dist)
+    void distortion(const distortion_type& dist) { m_distortion = dist; }
-        {
-            m_distortion = dist;
-        }
 
     //--------------------------------------------------------------------
     void coordinates(int* x, int* y) const
@@ -71,7 +59,6 @@ namespace agg
     //--------------------------------------------------------------------
     const distortion_type* m_distortion;
 };
-}
+} // namespace agg
-
 
 #endif

deps/agg/include/agg_span_interpolator_linear.h

@@ -20,8 +20,7 @@
 #include "agg_dda_line.h"
 #include "agg_trans_affine.h"
 
-namespace agg
+namespace agg {
-{
 
 //================================================span_interpolator_linear
 template<class Transformer = trans_affine, unsigned SubpixelShift = 8>
@@ -30,18 +29,15 @@ namespace agg
   public:
     typedef Transformer trans_type;
 
-        enum subpixel_scale_e
+    enum subpixel_scale_e { subpixel_shift = SubpixelShift, subpixel_scale = 1 << subpixel_shift };
-        {
-            subpixel_shift = SubpixelShift,
-            subpixel_scale  = 1 << subpixel_shift
-        };
 
     //--------------------------------------------------------------------
     span_interpolator_linear() {}
-        span_interpolator_linear(const trans_type& trans) : m_trans(&trans) {}
+    span_interpolator_linear(const trans_type& trans)
-        span_interpolator_linear(const trans_type& trans,
+        : m_trans(&trans)
-                                 double x, double y, unsigned len) :
+    {}
-            m_trans(&trans)
+    span_interpolator_linear(const trans_type& trans, double x, double y, unsigned len)
+        : m_trans(&trans)
     {
         begin(x, y, len);
     }
@@ -100,11 +96,6 @@ namespace agg
     dda2_line_interpolator m_li_y;
 };
 
-
-
-
-
-
 //=====================================span_interpolator_linear_subdiv
 template<class Transformer = trans_affine, unsigned SubpixelShift = 8>
 class span_interpolator_linear_subdiv
@@ -112,33 +103,31 @@ namespace agg
   public:
     typedef Transformer trans_type;
 
-        enum subpixel_scale_e
+    enum subpixel_scale_e { subpixel_shift = SubpixelShift, subpixel_scale = 1 << subpixel_shift };
-        {
-            subpixel_shift = SubpixelShift,
-            subpixel_scale = 1 << subpixel_shift
-        };
-
 
     //----------------------------------------------------------------
-        span_interpolator_linear_subdiv() :
+    span_interpolator_linear_subdiv()
-            m_subdiv_shift(4),
+        : m_subdiv_shift(4)
-            m_subdiv_size(1 << m_subdiv_shift),
+        , m_subdiv_size(1 << m_subdiv_shift)
-            m_subdiv_mask(m_subdiv_size - 1) {}
+        , m_subdiv_mask(m_subdiv_size - 1)
+    {}
+
+    span_interpolator_linear_subdiv(const 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(const trans_type& trans,
-                                        unsigned subdiv_shift = 4) : 
+                                    double x,
-            m_subdiv_shift(subdiv_shift),
+                                    double y,
-            m_subdiv_size(1 << m_subdiv_shift),
+                                    unsigned len,
-            m_subdiv_mask(m_subdiv_size - 1),
+                                    unsigned subdiv_shift = 4)
-            m_trans(&trans) {}
+        : m_subdiv_shift(subdiv_shift)
-
+        , m_subdiv_size(1 << m_subdiv_shift)
-        span_interpolator_linear_subdiv(const trans_type& trans,
+        , m_subdiv_mask(m_subdiv_size - 1)
-                                        double x, double y, unsigned len,
+        , m_trans(&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)
     {
         begin(x, y, len);
     }
@@ -166,7 +155,8 @@ namespace agg
         m_src_y = y;
         m_len = len;
 
-            if(len > m_subdiv_size) len = m_subdiv_size;
+        if (len > m_subdiv_size)
+            len = m_subdiv_size;
         tx = x;
         ty = y;
         m_trans->transform(&tx, &ty);
@@ -189,7 +179,8 @@ namespace agg
         if (m_pos >= m_subdiv_size)
         {
             unsigned len = m_len;
-                if(len > m_subdiv_size) len = m_subdiv_size;
+            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);
@@ -222,11 +213,6 @@ namespace agg
     unsigned m_len;
 };
 
-
+} // namespace agg
-}
-
-
 
 #endif
-
-