sij/mapnik
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix all files

Browse source 
format files
This commit is contained in:
Mathis Logemann 2022-08-11 22:54:50 +02:00
parent 88052447b9
commit eb16e7a647
214 changed files with 58865 additions and 58183 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

318
deps/agg/include/agg_alpha_mask_u8.h vendored
View file

@ -23,57 +23,47 @@
#include "agg_basics.h"
#include "agg_rendering_buffer.h"
namespace agg
namespace agg {
//===================================================one_component_mask_u8
struct one_component_mask_u8
{
//===================================================one_component_mask_u8
struct one_component_mask_u8
{
static unsigned calculate(const int8u* p) { return *p; }
};
};
//=====================================================rgb_to_gray_mask_u8
template<unsigned R, unsigned G, unsigned B>
struct rgb_to_gray_mask_u8
{
static unsigned calculate(const int8u* p) { return (p[R] * 77 + p[G] * 150 + p[B] * 29) >> 8; }
};
//=====================================================rgb_to_gray_mask_u8
template<unsigned R, unsigned G, unsigned B>
struct rgb_to_gray_mask_u8
{
static unsigned calculate(const int8u* p)
{
return (p[R]*77 + p[G]*150 + p[B]*29) >> 8;
}
};
//==========================================================alpha_mask_u8
template<unsigned Step=1, unsigned Offset=0, class MaskF=one_component_mask_u8>
class alpha_mask_u8
{
//==========================================================alpha_mask_u8
template<unsigned Step = 1, unsigned Offset = 0, class MaskF = one_component_mask_u8>
class alpha_mask_u8
{
public:
typedef int8u cover_type;
typedef alpha_mask_u8<Step, Offset, MaskF> self_type;
enum cover_scale_e
{
cover_shift = 8,
cover_none = 0,
cover_full = 255
};
enum cover_scale_e { cover_shift = 8, cover_none = 0, cover_full = 255 };
alpha_mask_u8() : m_rbuf(0) {}
explicit alpha_mask_u8(rendering_buffer& rbuf) : m_rbuf(&rbuf) {}
alpha_mask_u8()
: m_rbuf(0)
{}
explicit alpha_mask_u8(rendering_buffer& rbuf)
: m_rbuf(&rbuf)
{}
void attach(rendering_buffer& rbuf) { m_rbuf = &rbuf; }
MaskF& mask_function() { return m_mask_function; }
const MaskF& mask_function() const { return m_mask_function; }
//--------------------------------------------------------------------
cover_type pixel(int x, int y) const
{
if(x >= 0 && y >= 0 &&
x < (int)m_rbuf->width() &&
y < (int)m_rbuf->height())
if (x >= 0 && y >= 0 && x < (int)m_rbuf->width() && y < (int)m_rbuf->height())
{
return (cover_type)m_mask_function.calculate(
m_rbuf->row_ptr(y) + x * Step + Offset);
return (cover_type)m_mask_function.calculate(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 &&
x < (int)m_rbuf->width() &&
y < (int)m_rbuf->height())
if (x >= 0 && y >= 0 && x < (int)m_rbuf->width() && y < (int)m_rbuf->height())
{
return (cover_type)((cover_full + val *
m_mask_function.calculate(
m_rbuf->row_ptr(y) + x * Step + Offset)) >>
return (
cover_type)((cover_full + val * m_mask_function.calculate(m_rbuf->row_ptr(y) + x * Step + Offset)) >>
cover_shift);
}
return 0;
}
//--------------------------------------------------------------------
void fill_hspan(int x, int y, cover_type* dst, int num_pix) const
{
@ -103,16 +89,16 @@ namespace agg
int count = num_pix;
cover_type* covers = dst;
if(y < 0 || y > ymax)
if (y < 0 || y > ymax)
{
memset(dst, 0, num_pix * sizeof(cover_type));
return;
}
if(x < 0)
if (x < 0)
{
count += x;
if(count <= 0)
if (count <= 0)
{
memset(dst, 0, num_pix * sizeof(cover_type));
return;
@ -122,11 +108,11 @@ namespace agg
x = 0;
}
if(x + count > xmax)
if (x + count > xmax)
{
int rest = x + count - xmax - 1;
count -= rest;
if(count <= 0)
if (count <= 0)
{
memset(dst, 0, num_pix * sizeof(cover_type));
return;
@ -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
@ -153,16 +137,16 @@ namespace agg
int count = num_pix;
cover_type* covers = dst;
if(y < 0 || y > ymax)
if (y < 0 || y > ymax)
{
memset(dst, 0, num_pix * sizeof(cover_type));
return;
}
if(x < 0)
if (x < 0)
{
count += x;
if(count <= 0)
if (count <= 0)
{
memset(dst, 0, num_pix * sizeof(cover_type));
return;
@ -172,11 +156,11 @@ namespace agg
x = 0;
}
if(x + count > xmax)
if (x + count > xmax)
{
int rest = x + count - xmax - 1;
count -= rest;
if(count <= 0)
if (count <= 0)
{
memset(dst, 0, num_pix * sizeof(cover_type));
return;
@ -187,13 +171,10 @@ namespace agg
const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
do
{
*covers = (cover_type)((cover_full + (*covers) *
m_mask_function.calculate(mask)) >>
cover_shift);
*covers = (cover_type)((cover_full + (*covers) * m_mask_function.calculate(mask)) >> cover_shift);
++covers;
mask += Step;
}
while(--count);
} while (--count);
}
//--------------------------------------------------------------------
@ -205,16 +186,16 @@ namespace agg
int count = num_pix;
cover_type* covers = dst;
if(x < 0 || x > xmax)
if (x < 0 || x > xmax)
{
memset(dst, 0, num_pix * sizeof(cover_type));
return;
}
if(y < 0)
if (y < 0)
{
count += y;
if(count <= 0)
if (count <= 0)
{
memset(dst, 0, num_pix * sizeof(cover_type));
return;
@ -224,11 +205,11 @@ namespace agg
y = 0;
}
if(y + count > ymax)
if (y + count > ymax)
{
int rest = y + count - ymax - 1;
count -= rest;
if(count <= 0)
if (count <= 0)
{
memset(dst, 0, num_pix * sizeof(cover_type));
return;
@ -241,8 +222,7 @@ namespace agg
{
*covers++ = (cover_type)m_mask_function.calculate(mask);
mask += m_rbuf->stride();
}
while(--count);
} while (--count);
}
//--------------------------------------------------------------------
@ -254,16 +234,16 @@ namespace agg
int count = num_pix;
cover_type* covers = dst;
if(x < 0 || x > xmax)
if (x < 0 || x > xmax)
{
memset(dst, 0, num_pix * sizeof(cover_type));
return;
}
if(y < 0)
if (y < 0)
{
count += y;
if(count <= 0)
if (count <= 0)
{
memset(dst, 0, num_pix * sizeof(cover_type));
return;
@ -273,11 +253,11 @@ namespace agg
y = 0;
}
if(y + count > ymax)
if (y + count > ymax)
{
int rest = y + count - ymax - 1;
count -= rest;
if(count <= 0)
if (count <= 0)
{
memset(dst, 0, num_pix * sizeof(cover_type));
return;
@ -288,105 +268,91 @@ namespace agg
const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
do
{
*covers = (cover_type)((cover_full + (*covers) *
m_mask_function.calculate(mask)) >>
cover_shift);
*covers = (cover_type)((cover_full + (*covers) * m_mask_function.calculate(mask)) >> cover_shift);
++covers;
mask += m_rbuf->stride();
} while (--count);
}
while(--count);
}
private:
alpha_mask_u8(const self_type&);
const self_type& operator = (const self_type&);
const self_type& operator=(const self_type&);
rendering_buffer* m_rbuf;
MaskF m_mask_function;
};
};
typedef alpha_mask_u8<1, 0> alpha_mask_gray8; //----alpha_mask_gray8
typedef alpha_mask_u8<1, 0> alpha_mask_gray8; //----alpha_mask_gray8
typedef alpha_mask_u8<3, 0> alpha_mask_rgb24r; //----alpha_mask_rgb24r
typedef alpha_mask_u8<3, 1> alpha_mask_rgb24g; //----alpha_mask_rgb24g
typedef alpha_mask_u8<3, 2> alpha_mask_rgb24b; //----alpha_mask_rgb24b
typedef alpha_mask_u8<3, 0> alpha_mask_rgb24r; //----alpha_mask_rgb24r
typedef alpha_mask_u8<3, 1> alpha_mask_rgb24g; //----alpha_mask_rgb24g
typedef alpha_mask_u8<3, 2> alpha_mask_rgb24b; //----alpha_mask_rgb24b
typedef alpha_mask_u8<3, 2> alpha_mask_bgr24r; //----alpha_mask_bgr24r
typedef alpha_mask_u8<3, 1> alpha_mask_bgr24g; //----alpha_mask_bgr24g
typedef alpha_mask_u8<3, 0> alpha_mask_bgr24b; //----alpha_mask_bgr24b
typedef alpha_mask_u8<3, 2> alpha_mask_bgr24r; //----alpha_mask_bgr24r
typedef alpha_mask_u8<3, 1> alpha_mask_bgr24g; //----alpha_mask_bgr24g
typedef alpha_mask_u8<3, 0> alpha_mask_bgr24b; //----alpha_mask_bgr24b
typedef alpha_mask_u8<4, 0> alpha_mask_rgba32r; //----alpha_mask_rgba32r
typedef alpha_mask_u8<4, 1> alpha_mask_rgba32g; //----alpha_mask_rgba32g
typedef alpha_mask_u8<4, 2> alpha_mask_rgba32b; //----alpha_mask_rgba32b
typedef alpha_mask_u8<4, 3> alpha_mask_rgba32a; //----alpha_mask_rgba32a
typedef alpha_mask_u8<4, 0> alpha_mask_rgba32r; //----alpha_mask_rgba32r
typedef alpha_mask_u8<4, 1> alpha_mask_rgba32g; //----alpha_mask_rgba32g
typedef alpha_mask_u8<4, 2> alpha_mask_rgba32b; //----alpha_mask_rgba32b
typedef alpha_mask_u8<4, 3> alpha_mask_rgba32a; //----alpha_mask_rgba32a
typedef alpha_mask_u8<4, 1> alpha_mask_argb32r; //----alpha_mask_argb32r
typedef alpha_mask_u8<4, 2> alpha_mask_argb32g; //----alpha_mask_argb32g
typedef alpha_mask_u8<4, 3> alpha_mask_argb32b; //----alpha_mask_argb32b
typedef alpha_mask_u8<4, 0> alpha_mask_argb32a; //----alpha_mask_argb32a
typedef alpha_mask_u8<4, 1> alpha_mask_argb32r; //----alpha_mask_argb32r
typedef alpha_mask_u8<4, 2> alpha_mask_argb32g; //----alpha_mask_argb32g
typedef alpha_mask_u8<4, 3> alpha_mask_argb32b; //----alpha_mask_argb32b
typedef alpha_mask_u8<4, 0> alpha_mask_argb32a; //----alpha_mask_argb32a
typedef alpha_mask_u8<4, 2> alpha_mask_bgra32r; //----alpha_mask_bgra32r
typedef alpha_mask_u8<4, 1> alpha_mask_bgra32g; //----alpha_mask_bgra32g
typedef alpha_mask_u8<4, 0> alpha_mask_bgra32b; //----alpha_mask_bgra32b
typedef alpha_mask_u8<4, 3> alpha_mask_bgra32a; //----alpha_mask_bgra32a
typedef alpha_mask_u8<4, 2> alpha_mask_bgra32r; //----alpha_mask_bgra32r
typedef alpha_mask_u8<4, 1> alpha_mask_bgra32g; //----alpha_mask_bgra32g
typedef alpha_mask_u8<4, 0> alpha_mask_bgra32b; //----alpha_mask_bgra32b
typedef alpha_mask_u8<4, 3> alpha_mask_bgra32a; //----alpha_mask_bgra32a
typedef alpha_mask_u8<4, 3> alpha_mask_abgr32r; //----alpha_mask_abgr32r
typedef alpha_mask_u8<4, 2> alpha_mask_abgr32g; //----alpha_mask_abgr32g
typedef alpha_mask_u8<4, 1> alpha_mask_abgr32b; //----alpha_mask_abgr32b
typedef alpha_mask_u8<4, 0> alpha_mask_abgr32a; //----alpha_mask_abgr32a
typedef alpha_mask_u8<4, 3> alpha_mask_abgr32r; //----alpha_mask_abgr32r
typedef alpha_mask_u8<4, 2> alpha_mask_abgr32g; //----alpha_mask_abgr32g
typedef alpha_mask_u8<4, 1> alpha_mask_abgr32b; //----alpha_mask_abgr32b
typedef alpha_mask_u8<4, 0> alpha_mask_abgr32a; //----alpha_mask_abgr32a
typedef alpha_mask_u8<3, 0, rgb_to_gray_mask_u8<0, 1, 2>> alpha_mask_rgb24gray; //----alpha_mask_rgb24gray
typedef alpha_mask_u8<3, 0, rgb_to_gray_mask_u8<2, 1, 0>> alpha_mask_bgr24gray; //----alpha_mask_bgr24gray
typedef alpha_mask_u8<4, 0, rgb_to_gray_mask_u8<0, 1, 2>> alpha_mask_rgba32gray; //----alpha_mask_rgba32gray
typedef alpha_mask_u8<4, 1, rgb_to_gray_mask_u8<0, 1, 2>> alpha_mask_argb32gray; //----alpha_mask_argb32gray
typedef alpha_mask_u8<4, 0, rgb_to_gray_mask_u8<2, 1, 0>> alpha_mask_bgra32gray; //----alpha_mask_bgra32gray
typedef alpha_mask_u8<4, 1, rgb_to_gray_mask_u8<2, 1, 0>> alpha_mask_abgr32gray; //----alpha_mask_abgr32gray
typedef alpha_mask_u8<3, 0, rgb_to_gray_mask_u8<0, 1, 2> > alpha_mask_rgb24gray; //----alpha_mask_rgb24gray
typedef alpha_mask_u8<3, 0, rgb_to_gray_mask_u8<2, 1, 0> > alpha_mask_bgr24gray; //----alpha_mask_bgr24gray
typedef alpha_mask_u8<4, 0, rgb_to_gray_mask_u8<0, 1, 2> > alpha_mask_rgba32gray; //----alpha_mask_rgba32gray
typedef alpha_mask_u8<4, 1, rgb_to_gray_mask_u8<0, 1, 2> > alpha_mask_argb32gray; //----alpha_mask_argb32gray
typedef alpha_mask_u8<4, 0, rgb_to_gray_mask_u8<2, 1, 0> > alpha_mask_bgra32gray; //----alpha_mask_bgra32gray
typedef alpha_mask_u8<4, 1, rgb_to_gray_mask_u8<2, 1, 0> > alpha_mask_abgr32gray; //----alpha_mask_abgr32gray
//==========================================================amask_no_clip_u8
template<unsigned Step=1, unsigned Offset=0, class MaskF=one_component_mask_u8>
class amask_no_clip_u8
{
//==========================================================amask_no_clip_u8
template<unsigned Step = 1, unsigned Offset = 0, class MaskF = one_component_mask_u8>
class amask_no_clip_u8
{
public:
typedef int8u cover_type;
typedef amask_no_clip_u8<Step, Offset, MaskF> self_type;
enum cover_scale_e
{
cover_shift = 8,
cover_none = 0,
cover_full = 255
};
enum cover_scale_e { cover_shift = 8, cover_none = 0, cover_full = 255 };
amask_no_clip_u8() : m_rbuf(0) {}
explicit amask_no_clip_u8(rendering_buffer& rbuf) : m_rbuf(&rbuf) {}
amask_no_clip_u8()
: m_rbuf(0)
{}
explicit amask_no_clip_u8(rendering_buffer& rbuf)
: m_rbuf(&rbuf)
{}
void attach(rendering_buffer& rbuf) { m_rbuf = &rbuf; }
MaskF& mask_function() { return m_mask_function; }
const MaskF& mask_function() const { return m_mask_function; }
//--------------------------------------------------------------------
cover_type pixel(int x, int y) const
{
return (cover_type)m_mask_function.calculate(
m_rbuf->row_ptr(y) + x * Step + Offset);
return (cover_type)m_mask_function.calculate(m_rbuf->row_ptr(y) + x * Step + Offset);
}
//--------------------------------------------------------------------
cover_type combine_pixel(int x, int y, cover_type val) const
{
return (cover_type)((cover_full + val *
m_mask_function.calculate(
m_rbuf->row_ptr(y) + x * Step + Offset)) >>
return (cover_type)((cover_full + val * m_mask_function.calculate(m_rbuf->row_ptr(y) + x * Step + Offset)) >>
cover_shift);
}
//--------------------------------------------------------------------
void fill_hspan(int x, int y, cover_type* dst, int num_pix) const
{
@ -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) *
m_mask_function.calculate(mask)) >>
cover_shift);
*dst = (cover_type)((cover_full + (*dst) * 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,64 +393,57 @@ namespace agg
const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
do
{
*dst = (cover_type)((cover_full + (*dst) *
m_mask_function.calculate(mask)) >>
cover_shift);
*dst = (cover_type)((cover_full + (*dst) * m_mask_function.calculate(mask)) >> cover_shift);
++dst;
mask += m_rbuf->stride();
}
while(--num_pix);
} while (--num_pix);
}
private:
amask_no_clip_u8(const self_type&);
const self_type& operator = (const self_type&);
const self_type& operator=(const self_type&);
rendering_buffer* m_rbuf;
MaskF m_mask_function;
};
};
typedef amask_no_clip_u8<1, 0> amask_no_clip_gray8; //----amask_no_clip_gray8
typedef amask_no_clip_u8<1, 0> amask_no_clip_gray8; //----amask_no_clip_gray8
typedef amask_no_clip_u8<3, 0> amask_no_clip_rgb24r; //----amask_no_clip_rgb24r
typedef amask_no_clip_u8<3, 1> amask_no_clip_rgb24g; //----amask_no_clip_rgb24g
typedef amask_no_clip_u8<3, 2> amask_no_clip_rgb24b; //----amask_no_clip_rgb24b
typedef amask_no_clip_u8<3, 0> amask_no_clip_rgb24r; //----amask_no_clip_rgb24r
typedef amask_no_clip_u8<3, 1> amask_no_clip_rgb24g; //----amask_no_clip_rgb24g
typedef amask_no_clip_u8<3, 2> amask_no_clip_rgb24b; //----amask_no_clip_rgb24b
typedef amask_no_clip_u8<3, 2> amask_no_clip_bgr24r; //----amask_no_clip_bgr24r
typedef amask_no_clip_u8<3, 1> amask_no_clip_bgr24g; //----amask_no_clip_bgr24g
typedef amask_no_clip_u8<3, 0> amask_no_clip_bgr24b; //----amask_no_clip_bgr24b
typedef amask_no_clip_u8<3, 2> amask_no_clip_bgr24r; //----amask_no_clip_bgr24r
typedef amask_no_clip_u8<3, 1> amask_no_clip_bgr24g; //----amask_no_clip_bgr24g
typedef amask_no_clip_u8<3, 0> amask_no_clip_bgr24b; //----amask_no_clip_bgr24b
typedef amask_no_clip_u8<4, 0> amask_no_clip_rgba32r; //----amask_no_clip_rgba32r
typedef amask_no_clip_u8<4, 1> amask_no_clip_rgba32g; //----amask_no_clip_rgba32g
typedef amask_no_clip_u8<4, 2> amask_no_clip_rgba32b; //----amask_no_clip_rgba32b
typedef amask_no_clip_u8<4, 3> amask_no_clip_rgba32a; //----amask_no_clip_rgba32a
typedef amask_no_clip_u8<4, 0> amask_no_clip_rgba32r; //----amask_no_clip_rgba32r
typedef amask_no_clip_u8<4, 1> amask_no_clip_rgba32g; //----amask_no_clip_rgba32g
typedef amask_no_clip_u8<4, 2> amask_no_clip_rgba32b; //----amask_no_clip_rgba32b
typedef amask_no_clip_u8<4, 3> amask_no_clip_rgba32a; //----amask_no_clip_rgba32a
typedef amask_no_clip_u8<4, 1> amask_no_clip_argb32r; //----amask_no_clip_argb32r
typedef amask_no_clip_u8<4, 2> amask_no_clip_argb32g; //----amask_no_clip_argb32g
typedef amask_no_clip_u8<4, 3> amask_no_clip_argb32b; //----amask_no_clip_argb32b
typedef amask_no_clip_u8<4, 0> amask_no_clip_argb32a; //----amask_no_clip_argb32a
typedef amask_no_clip_u8<4, 1> amask_no_clip_argb32r; //----amask_no_clip_argb32r
typedef amask_no_clip_u8<4, 2> amask_no_clip_argb32g; //----amask_no_clip_argb32g
typedef amask_no_clip_u8<4, 3> amask_no_clip_argb32b; //----amask_no_clip_argb32b
typedef amask_no_clip_u8<4, 0> amask_no_clip_argb32a; //----amask_no_clip_argb32a
typedef amask_no_clip_u8<4, 2> amask_no_clip_bgra32r; //----amask_no_clip_bgra32r
typedef amask_no_clip_u8<4, 1> amask_no_clip_bgra32g; //----amask_no_clip_bgra32g
typedef amask_no_clip_u8<4, 0> amask_no_clip_bgra32b; //----amask_no_clip_bgra32b
typedef amask_no_clip_u8<4, 3> amask_no_clip_bgra32a; //----amask_no_clip_bgra32a
typedef amask_no_clip_u8<4, 2> amask_no_clip_bgra32r; //----amask_no_clip_bgra32r
typedef amask_no_clip_u8<4, 1> amask_no_clip_bgra32g; //----amask_no_clip_bgra32g
typedef amask_no_clip_u8<4, 0> amask_no_clip_bgra32b; //----amask_no_clip_bgra32b
typedef amask_no_clip_u8<4, 3> amask_no_clip_bgra32a; //----amask_no_clip_bgra32a
typedef amask_no_clip_u8<4, 3> amask_no_clip_abgr32r; //----amask_no_clip_abgr32r
typedef amask_no_clip_u8<4, 2> amask_no_clip_abgr32g; //----amask_no_clip_abgr32g
typedef amask_no_clip_u8<4, 1> amask_no_clip_abgr32b; //----amask_no_clip_abgr32b
typedef amask_no_clip_u8<4, 0> amask_no_clip_abgr32a; //----amask_no_clip_abgr32a
typedef amask_no_clip_u8<3, 0, rgb_to_gray_mask_u8<0, 1, 2> > amask_no_clip_rgb24gray; //----amask_no_clip_rgb24gray
typedef amask_no_clip_u8<3, 0, rgb_to_gray_mask_u8<2, 1, 0> > amask_no_clip_bgr24gray; //----amask_no_clip_bgr24gray
typedef amask_no_clip_u8<4, 0, rgb_to_gray_mask_u8<0, 1, 2> > amask_no_clip_rgba32gray; //----amask_no_clip_rgba32gray
typedef amask_no_clip_u8<4, 1, rgb_to_gray_mask_u8<0, 1, 2> > amask_no_clip_argb32gray; //----amask_no_clip_argb32gray
typedef amask_no_clip_u8<4, 0, rgb_to_gray_mask_u8<2, 1, 0> > amask_no_clip_bgra32gray; //----amask_no_clip_bgra32gray
typedef amask_no_clip_u8<4, 1, rgb_to_gray_mask_u8<2, 1, 0> > amask_no_clip_abgr32gray; //----amask_no_clip_abgr32gray
}
typedef amask_no_clip_u8<4, 3> amask_no_clip_abgr32r; //----amask_no_clip_abgr32r
typedef amask_no_clip_u8<4, 2> amask_no_clip_abgr32g; //----amask_no_clip_abgr32g
typedef amask_no_clip_u8<4, 1> amask_no_clip_abgr32b; //----amask_no_clip_abgr32b
typedef amask_no_clip_u8<4, 0> amask_no_clip_abgr32a; //----amask_no_clip_abgr32a
typedef amask_no_clip_u8<3, 0, rgb_to_gray_mask_u8<0, 1, 2>> amask_no_clip_rgb24gray; //----amask_no_clip_rgb24gray
typedef amask_no_clip_u8<3, 0, rgb_to_gray_mask_u8<2, 1, 0>> amask_no_clip_bgr24gray; //----amask_no_clip_bgr24gray
typedef amask_no_clip_u8<4, 0, rgb_to_gray_mask_u8<0, 1, 2>> amask_no_clip_rgba32gray; //----amask_no_clip_rgba32gray
typedef amask_no_clip_u8<4, 1, rgb_to_gray_mask_u8<0, 1, 2>> amask_no_clip_argb32gray; //----amask_no_clip_argb32gray
typedef amask_no_clip_u8<4, 0, rgb_to_gray_mask_u8<2, 1, 0>> amask_no_clip_bgra32gray; //----amask_no_clip_bgra32gray
typedef amask_no_clip_u8<4, 1, rgb_to_gray_mask_u8<2, 1, 0>> amask_no_clip_abgr32gray; //----amask_no_clip_abgr32gray
} // namespace agg
#endif

36
deps/agg/include/agg_arc.h vendored
View file

@ -23,26 +23,22 @@
#include <cmath>
#include "agg_basics.h"
namespace agg
namespace agg {
//=====================================================================arc
//
// See Implementation agg_arc.cpp
//
class arc
{
//=====================================================================arc
//
// See Implementation agg_arc.cpp
//
class arc
{
public:
arc() : m_scale(1.0), m_initialized(false) {}
arc(double x, double y,
double rx, double ry,
double a1, double a2,
bool ccw=true);
arc()
: m_scale(1.0)
, m_initialized(false)
{}
arc(double x, double y, double rx, double ry, double a1, double a2, bool ccw = true);
void init(double x, double y,
double rx, double ry,
double a1, double a2,
bool ccw=true);
void init(double x, double y, double rx, double ry, double a1, double a2, bool ccw = true);
void approximation_scale(double s);
double approximation_scale() const { return m_scale; }
@ -65,10 +61,8 @@ namespace agg
bool m_ccw;
bool m_initialized;
unsigned m_path_cmd;
};
}
};
} // namespace agg
#endif

941
deps/agg/include/agg_array.h vendored
View file

File diff suppressed because it is too large Load diff

19
deps/agg/include/agg_arrowhead.h vendored
View file

@ -21,15 +21,14 @@
#include "agg_basics.h"
namespace agg
{
namespace agg {
//===============================================================arrowhead
//
// See implementation agg_arrowhead.cpp
//
class arrowhead
{
//===============================================================arrowhead
//
// See implementation agg_arrowhead.cpp
//
class arrowhead
{
public:
arrowhead();
@ -75,8 +74,8 @@ namespace agg
unsigned m_cmd[8];
unsigned m_curr_id;
unsigned m_curr_coord;
};
};
}
} // namespace agg
#endif

550
deps/agg/include/agg_basics.h vendored
View file

@ -23,41 +23,41 @@
#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
// replace new/delete to malloc/free. The constructors and destructors
// won't be called in this case, however everything will remain working.
// The second argument of deallocate() is the size of the allocated
// block. You can use this information if you wish.
//------------------------------------------------------------pod_allocator
template<class T>
struct pod_allocator
{
// The policy of all AGG containers and memory allocation strategy
// in general is that no allocated data requires explicit construction.
// It means that the allocator can be really simple; you can even
// replace new/delete to malloc/free. The constructors and destructors
// won't be called in this case, however everything will remain working.
// The second argument of deallocate() is the size of the allocated
// block. You can use this information if you wish.
//------------------------------------------------------------pod_allocator
template<class T> struct pod_allocator
{
//static T* allocate(unsigned num) { return static_cast<T*>(::operator new(sizeof(T)*num));}
//static void deallocate(T* ptr, unsigned) { ::operator delete(ptr) ;}
static T* allocate(unsigned num) { return new T [num]; }
static void deallocate(T* ptr, unsigned) { delete [] ptr; }
};
// static T* allocate(unsigned num) { return static_cast<T*>(::operator new(sizeof(T)*num));}
// static void deallocate(T* ptr, unsigned) { ::operator delete(ptr) ;}
static T* allocate(unsigned num) { return new T[num]; }
static void deallocate(T* ptr, unsigned) { delete[] ptr; }
};
// Single object allocator. It's also can be replaced with your custom
// allocator. The difference is that it can only allocate a single
// object and the constructor and destructor must be called.
// In AGG there is no need to allocate an array of objects with
// calling their constructors (only single ones). So that, if you
// replace these new/delete to malloc/free make sure that the in-place
// new is called and take care of calling the destructor too.
//------------------------------------------------------------obj_allocator
template<class T> struct obj_allocator
{
// Single object allocator. It's also can be replaced with your custom
// allocator. The difference is that it can only allocate a single
// object and the constructor and destructor must be called.
// In AGG there is no need to allocate an array of objects with
// calling their constructors (only single ones). So that, if you
// replace these new/delete to malloc/free make sure that the in-place
// new is called and take care of calling the destructor too.
//------------------------------------------------------------obj_allocator
template<class T>
struct obj_allocator
{
static T* allocate() { return new T; }
static void deallocate(T* ptr) { delete ptr; }
};
}
};
} // namespace agg
#endif
//-------------------------------------------------------- Default basic types
//
// If the compiler has different capacity of the basic types you can redefine
@ -98,7 +98,7 @@ namespace agg
//------------------------------------------------ Some fixes for MS Visual C++
#if defined(_MSC_VER)
#pragma warning(disable:4786) // Identifier was truncated...
#pragma warning(disable: 4786) // Identifier was truncated...
#endif
#if defined(_MSC_VER)
@ -107,150 +107,163 @@ namespace agg
#define AGG_INLINE inline
#endif
namespace agg
namespace agg {
//-------------------------------------------------------------------------
typedef AGG_INT8 int8; //----int8
typedef AGG_INT8U int8u; //----int8u
typedef AGG_INT16 int16; //----int16
typedef AGG_INT16U int16u; //----int16u
typedef AGG_INT32 int32; //----int32
typedef AGG_INT32U int32u; //----int32u
typedef AGG_INT64 int64; //----int64
typedef AGG_INT64U int64u; //----int64u
AGG_INLINE int iround(double v)
{
//-------------------------------------------------------------------------
typedef AGG_INT8 int8; //----int8
typedef AGG_INT8U int8u; //----int8u
typedef AGG_INT16 int16; //----int16
typedef AGG_INT16U int16u; //----int16u
typedef AGG_INT32 int32; //----int32
typedef AGG_INT32U int32u; //----int32u
typedef AGG_INT64 int64; //----int64
typedef AGG_INT64U int64u; //----int64u
AGG_INLINE int iround(double v)
{
return int((v < 0.0) ? v - 0.5 : v + 0.5);
}
AGG_INLINE int uround(double v)
{
}
AGG_INLINE int uround(double v)
{
return unsigned(v + 0.5);
}
AGG_INLINE unsigned ufloor(double v)
{
}
AGG_INLINE unsigned ufloor(double v)
{
return unsigned(v);
}
AGG_INLINE unsigned uceil(double v)
{
}
AGG_INLINE unsigned uceil(double v)
{
return unsigned(std::ceil(v));
}
}
//---------------------------------------------------------------saturation
template<int Limit> struct saturation
{
//---------------------------------------------------------------saturation
template<int Limit>
struct saturation
{
AGG_INLINE static int iround(double v)
{
if(v < double(-Limit)) return -Limit;
if(v > double( Limit)) return Limit;
if (v < double(-Limit))
return -Limit;
if (v > double(Limit))
return Limit;
return agg::iround(v);
}
};
};
//------------------------------------------------------------------mul_one
template<unsigned Shift> struct mul_one
{
//------------------------------------------------------------------mul_one
template<unsigned Shift>
struct mul_one
{
AGG_INLINE static unsigned mul(unsigned a, unsigned b)
{
unsigned q = a * b + (1 << (Shift-1));
unsigned q = a * b + (1 << (Shift - 1));
return (q + (q >> Shift)) >> Shift;
}
};
};
//-------------------------------------------------------------------------
typedef unsigned char cover_type; //----cover_type
enum cover_scale_e
{
//-------------------------------------------------------------------------
typedef unsigned char cover_type; //----cover_type
enum cover_scale_e {
cover_shift = 8, //----cover_shift
cover_size = 1 << cover_shift, //----cover_size
cover_mask = cover_size - 1, //----cover_mask
cover_none = 0, //----cover_none
cover_full = cover_mask //----cover_full
};
};
//----------------------------------------------------poly_subpixel_scale_e
// These constants determine the subpixel accuracy, to be more precise,
// the number of bits of the fractional part of the coordinates.
// The possible coordinate capacity in bits can be calculated by formula:
// sizeof(int) * 8 - poly_subpixel_shift, i.e, for 32-bit integers and
// 8-bits fractional part the capacity is 24 bits.
enum poly_subpixel_scale_e
{
//----------------------------------------------------poly_subpixel_scale_e
// These constants determine the subpixel accuracy, to be more precise,
// the number of bits of the fractional part of the coordinates.
// The possible coordinate capacity in bits can be calculated by formula:
// sizeof(int) * 8 - poly_subpixel_shift, i.e, for 32-bit integers and
// 8-bits fractional part the capacity is 24 bits.
enum poly_subpixel_scale_e {
poly_subpixel_shift = 8, //----poly_subpixel_shift
poly_subpixel_scale = 1<<poly_subpixel_shift, //----poly_subpixel_scale
poly_subpixel_mask = poly_subpixel_scale-1 //----poly_subpixel_mask
};
poly_subpixel_scale = 1 << poly_subpixel_shift, //----poly_subpixel_scale
poly_subpixel_mask = poly_subpixel_scale - 1 //----poly_subpixel_mask
};
//----------------------------------------------------------filling_rule_e
enum filling_rule_e
{
fill_non_zero,
fill_even_odd
};
//----------------------------------------------------------filling_rule_e
enum filling_rule_e { fill_non_zero, fill_even_odd };
//-----------------------------------------------------------------------pi
const double pi = 3.14159265358979323846;
//-----------------------------------------------------------------------pi
const double pi = 3.14159265358979323846;
//------------------------------------------------------------------deg2rad
inline double deg2rad(double deg)
{
//------------------------------------------------------------------deg2rad
inline double deg2rad(double deg)
{
return deg * pi / 180.0;
}
}
//------------------------------------------------------------------rad2deg
inline double rad2deg(double rad)
{
//------------------------------------------------------------------rad2deg
inline double rad2deg(double rad)
{
return rad * 180.0 / pi;
}
}
//----------------------------------------------------------------rect_base
template<class T> struct rect_base
{
//----------------------------------------------------------------rect_base
template<class T>
struct rect_base
{
typedef T value_type;
typedef rect_base<T> self_type;
T x1, y1, x2, y2;
rect_base() {}
rect_base(T x1_, T y1_, T x2_, T y2_) :
x1(x1_), y1(y1_), x2(x2_), y2(y2_) {}
rect_base(T x1_, T y1_, T x2_, T y2_)
: x1(x1_)
, y1(y1_)
, x2(x2_)
, y2(y2_)
{}
void init(T x1_, T y1_, T x2_, T y2_)
{
x1 = x1_; y1 = y1_; x2 = x2_; y2 = y2_;
x1 = x1_;
y1 = y1_;
x2 = x2_;
y2 = y2_;
}
const self_type& normalize()
{
T t;
if(x1 > x2) { t = x1; x1 = x2; x2 = t; }
if(y1 > y2) { t = y1; y1 = y2; y2 = t; }
if (x1 > x2)
{
t = x1;
x1 = x2;
x2 = t;
}
if (y1 > y2)
{
t = y1;
y1 = y2;
y2 = t;
}
return *this;
}
bool clip(const self_type& r)
{
if(x2 > r.x2) x2 = r.x2;
if(y2 > r.y2) y2 = r.y2;
if(x1 < r.x1) x1 = r.x1;
if(y1 < r.y1) y1 = r.y1;
if (x2 > r.x2)
x2 = r.x2;
if (y2 > r.y2)
y2 = r.y2;
if (x1 < r.x1)
x1 = r.x1;
if (y1 < r.y1)
y1 = r.y1;
return x1 <= x2 && y1 <= y2;
}
bool is_valid() const
{
return x1 <= x2 && y1 <= y2;
}
bool is_valid() const { return x1 <= x2 && y1 <= y2; }
bool hit_test(T x, T y) const
{
return (x >= x1 && x <= x2 && y >= y1 && y <= y2);
}
};
bool hit_test(T x, T y) const { return (x >= x1 && x <= x2 && y >= y1 && y <= y2); }
};
//-----------------------------------------------------intersect_rectangles
template<class Rect>
inline Rect intersect_rectangles(const Rect& r1, const Rect& r2)
{
//-----------------------------------------------------intersect_rectangles
template<class Rect>
inline Rect intersect_rectangles(const Rect& r1, const Rect& r2)
{
Rect r = r1;
// First process x2,y2 because the other order
@ -258,33 +271,39 @@ 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.y2 > r2.y2) r.y2 = r2.y2;
if(r.x1 < r2.x1) r.x1 = r2.x1;
if(r.y1 < r2.y1) r.y1 = r2.y1;
if (r.x2 > r2.x2)
r.x2 = r2.x2;
if (r.y2 > r2.y2)
r.y2 = r2.y2;
if (r.x1 < r2.x1)
r.x1 = r2.x1;
if (r.y1 < r2.y1)
r.y1 = r2.y1;
return r;
}
}
//---------------------------------------------------------unite_rectangles
template<class Rect>
inline Rect unite_rectangles(const Rect& r1, const Rect& r2)
{
//---------------------------------------------------------unite_rectangles
template<class Rect>
inline Rect unite_rectangles(const Rect& r1, const Rect& r2)
{
Rect r = r1;
if(r.x2 < r2.x2) r.x2 = r2.x2;
if(r.y2 < r2.y2) r.y2 = r2.y2;
if(r.x1 > r2.x1) r.x1 = r2.x1;
if(r.y1 > r2.y1) r.y1 = r2.y1;
if (r.x2 < r2.x2)
r.x2 = r2.x2;
if (r.y2 < r2.y2)
r.y2 = r2.y2;
if (r.x1 > r2.x1)
r.x1 = r2.x1;
if (r.y1 > r2.y1)
r.y1 = r2.y1;
return r;
}
}
typedef rect_base<int> rect_i; //----rect_i
typedef rect_base<float> rect_f; //----rect_f
typedef rect_base<double> rect_d; //----rect_d
typedef rect_base<int> rect_i; //----rect_i
typedef rect_base<float> rect_f; //----rect_f
typedef rect_base<double> rect_d; //----rect_d
//---------------------------------------------------------path_commands_e
enum path_commands_e
{
//---------------------------------------------------------path_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
@ -295,184 +314,201 @@ namespace agg
path_cmd_ubspline = 7, //----path_cmd_ubspline
path_cmd_end_poly = 0x0F, //----path_cmd_end_poly
path_cmd_mask = 0x0F //----path_cmd_mask
};
};
//------------------------------------------------------------path_flags_e
enum path_flags_e
{
//------------------------------------------------------------path_flags_e
enum path_flags_e {
path_flags_none = 0, //----path_flags_none
path_flags_ccw = 0x10, //----path_flags_ccw
path_flags_cw = 0x20, //----path_flags_cw
path_flags_close = 0x40, //----path_flags_close
path_flags_mask = 0xF0 //----path_flags_mask
};
};
//---------------------------------------------------------------is_vertex
inline bool is_vertex(unsigned c)
{
//---------------------------------------------------------------is_vertex
inline bool is_vertex(unsigned c)
{
return c >= path_cmd_move_to && c < path_cmd_end_poly;
}
}
//--------------------------------------------------------------is_drawing
inline bool is_drawing(unsigned c)
{
//--------------------------------------------------------------is_drawing
inline bool is_drawing(unsigned c)
{
return c >= path_cmd_line_to && c < path_cmd_end_poly;
}
}
//-----------------------------------------------------------------is_stop
inline bool is_stop(unsigned c)
{
//-----------------------------------------------------------------is_stop
inline bool is_stop(unsigned c)
{
return c == path_cmd_stop;
}
}
//--------------------------------------------------------------is_move_to
inline bool is_move_to(unsigned c)
{
//--------------------------------------------------------------is_move_to
inline bool is_move_to(unsigned c)
{
return c == path_cmd_move_to;
}
}
//--------------------------------------------------------------is_line_to
inline bool is_line_to(unsigned c)
{
//--------------------------------------------------------------is_line_to
inline bool is_line_to(unsigned c)
{
return c == path_cmd_line_to;
}
}
//----------------------------------------------------------------is_curve
inline bool is_curve(unsigned c)
{
//----------------------------------------------------------------is_curve
inline bool is_curve(unsigned c)
{
return c == path_cmd_curve3 || c == path_cmd_curve4;
}
}
//---------------------------------------------------------------is_curve3
inline bool is_curve3(unsigned c)
{
//---------------------------------------------------------------is_curve3
inline bool is_curve3(unsigned c)
{
return c == path_cmd_curve3;
}
}
//---------------------------------------------------------------is_curve4
inline bool is_curve4(unsigned c)
{
//---------------------------------------------------------------is_curve4
inline bool is_curve4(unsigned c)
{
return c == path_cmd_curve4;
}
}
//-------------------------------------------------------------is_end_poly
inline bool is_end_poly(unsigned c)
{
//-------------------------------------------------------------is_end_poly
inline bool is_end_poly(unsigned c)
{
return (c & path_cmd_mask) == path_cmd_end_poly;
}
}
//----------------------------------------------------------------is_close
inline bool is_close(unsigned c)
{
//----------------------------------------------------------------is_close
inline bool is_close(unsigned c)
{
return (c & ~(path_flags_cw | path_flags_ccw)) ==
(path_cmd_end_poly | static_cast<path_commands_e>(path_flags_close));
}
}
//------------------------------------------------------------is_next_poly
inline bool is_next_poly(unsigned c)
{
//------------------------------------------------------------is_next_poly
inline bool is_next_poly(unsigned c)
{
return is_stop(c) || is_move_to(c) || is_end_poly(c);
}
}
//-------------------------------------------------------------------is_cw
inline bool is_cw(unsigned c)
{
//-------------------------------------------------------------------is_cw
inline bool is_cw(unsigned c)
{
return (c & path_flags_cw) != 0;
}
}
//------------------------------------------------------------------is_ccw
inline bool is_ccw(unsigned c)
{
//------------------------------------------------------------------is_ccw
inline bool is_ccw(unsigned c)
{
return (c & path_flags_ccw) != 0;
}
}
//-------------------------------------------------------------is_oriented
inline bool is_oriented(unsigned c)
{
//-------------------------------------------------------------is_oriented
inline bool is_oriented(unsigned c)
{
return (c & (path_flags_cw | path_flags_ccw)) != 0;
}
}
//---------------------------------------------------------------is_closed
inline bool is_closed(unsigned c)
{
//---------------------------------------------------------------is_closed
inline bool is_closed(unsigned c)
{
return (c & path_flags_close) != 0;
}
}
//----------------------------------------------------------get_close_flag
inline unsigned get_close_flag(unsigned c)
{
//----------------------------------------------------------get_close_flag
inline unsigned get_close_flag(unsigned c)
{
return c & path_flags_close;
}
}
//-------------------------------------------------------clear_orientation
inline unsigned clear_orientation(unsigned c)
{
//-------------------------------------------------------clear_orientation
inline unsigned clear_orientation(unsigned c)
{
return c & ~(path_flags_cw | path_flags_ccw);
}
}
//---------------------------------------------------------get_orientation
inline unsigned get_orientation(unsigned c)
{
//---------------------------------------------------------get_orientation
inline unsigned get_orientation(unsigned c)
{
return c & (path_flags_cw | path_flags_ccw);
}
}
//---------------------------------------------------------set_orientation
inline unsigned set_orientation(unsigned c, unsigned o)
{
//---------------------------------------------------------set_orientation
inline unsigned set_orientation(unsigned c, unsigned o)
{
return clear_orientation(c) | o;
}
}
//--------------------------------------------------------------point_base
template<class T> struct point_base
{
//--------------------------------------------------------------point_base
template<class T>
struct point_base
{
typedef T value_type;
T x,y;
T x, y;
point_base() {}
point_base(T x_, T y_) : x(x_), y(y_) {}
};
typedef point_base<int> point_i; //-----point_i
typedef point_base<float> point_f; //-----point_f
typedef point_base<double> point_d; //-----point_d
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
{
//-------------------------------------------------------------vertex_base
template<class T>
struct vertex_base
{
typedef T value_type;
T x,y;
T x, y;
unsigned cmd;
vertex_base() {}
vertex_base(T x_, T y_, unsigned cmd_) : x(x_), y(y_), cmd(cmd_) {}
};
typedef vertex_base<int> vertex_i; //-----vertex_i
typedef vertex_base<float> vertex_f; //-----vertex_f
typedef vertex_base<double> vertex_d; //-----vertex_d
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
{
//----------------------------------------------------------------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
{
//----------------------------------------------------------const_row_info
template<class T>
struct const_row_info
{
int x1, x2;
const T* ptr;
const_row_info() {}
const_row_info(int x1_, int x2_, const T* ptr_) :
x1(x1_), x2(x2_), ptr(ptr_) {}
};
const_row_info(int x1_, int x2_, const T* ptr_)
: x1(x1_)
, x2(x2_)
, ptr(ptr_)
{}
};
//------------------------------------------------------------is_equal_eps
template<class T> inline bool is_equal_eps(T v1, T v2, T epsilon)
{
//------------------------------------------------------------is_equal_eps
template<class T>
inline bool is_equal_eps(T v1, T v2, T epsilon)
{
return std::fabs(v1 - v2) <= double(epsilon);
}
}
} // namespace agg
#endif

122
deps/agg/include/agg_bezier_arc.h vendored
View file

@ -23,48 +23,40 @@
#include "agg_conv_transform.h"
namespace agg
namespace agg {
//-----------------------------------------------------------------------
void arc_to_bezier(double cx, double cy, double rx, double ry, double start_angle, double sweep_angle, double* curve);
//==============================================================bezier_arc
//
// See implemantaion agg_bezier_arc.cpp
//
class bezier_arc
{
//-----------------------------------------------------------------------
void arc_to_bezier(double cx, double cy, double rx, double ry,
double start_angle, double sweep_angle,
double* curve);
//==============================================================bezier_arc
//
// See implemantaion agg_bezier_arc.cpp
//
class bezier_arc
{
public:
//--------------------------------------------------------------------
bezier_arc() : m_vertex(26), m_num_vertices(0), m_cmd(path_cmd_line_to) {}
bezier_arc(double x, double y,
double rx, double ry,
double start_angle,
double sweep_angle)
bezier_arc()
: m_vertex(26)
, m_num_vertices(0)
, m_cmd(path_cmd_line_to)
{}
bezier_arc(double x, double y, double rx, double ry, double start_angle, double sweep_angle)
{
init(x, y, rx, ry, start_angle, sweep_angle);
}
//--------------------------------------------------------------------
void init(double x, double y,
double rx, double ry,
double start_angle,
double sweep_angle);
void init(double x, double y, double rx, double ry, double start_angle, double sweep_angle);
//--------------------------------------------------------------------
void rewind(unsigned)
{
m_vertex = 0;
}
void rewind(unsigned) { 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;
@ -83,60 +75,62 @@ namespace agg
unsigned m_num_vertices;
double m_vertices[26];
unsigned m_cmd;
};
};
//==========================================================bezier_arc_svg
// Compute an SVG-style bezier arc.
//
// Computes an elliptical arc from (x1, y1) to (x2, y2). The size and
// orientation of the ellipse are defined by two radii (rx, ry)
// and an x-axis-rotation, which indicates how the ellipse as a whole
// is rotated relative to the current coordinate system. The center
// (cx, cy) of the ellipse is calculated automatically to satisfy the
// constraints imposed by the other parameters.
// large-arc-flag and sweep-flag contribute to the automatic calculations
// and help determine how the arc is drawn.
class bezier_arc_svg
{
//==========================================================bezier_arc_svg
// Compute an SVG-style bezier arc.
//
// Computes an elliptical arc from (x1, y1) to (x2, y2). The size and
// orientation of the ellipse are defined by two radii (rx, ry)
// and an x-axis-rotation, which indicates how the ellipse as a whole
// is rotated relative to the current coordinate system. The center
// (cx, cy) of the ellipse is calculated automatically to satisfy the
// constraints imposed by the other parameters.
// large-arc-flag and sweep-flag contribute to the automatic calculations
// and help determine how the arc is drawn.
class bezier_arc_svg
{
public:
//--------------------------------------------------------------------
bezier_arc_svg() : m_arc(), m_radii_ok(false) {}
bezier_arc_svg()
: m_arc()
, m_radii_ok(false)
{}
bezier_arc_svg(double x1, double y1,
double rx, double ry,
bezier_arc_svg(double x1,
double y1,
double rx,
double ry,
double angle,
bool large_arc_flag,
bool sweep_flag,
double x2, double y2) :
m_arc(), m_radii_ok(false)
double x2,
double y2)
: m_arc()
, m_radii_ok(false)
{
init(x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2);
}
//--------------------------------------------------------------------
void init(double x1, double y1,
double rx, double ry,
void init(double x1,
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)
{
m_arc.rewind(0);
}
void rewind(unsigned) { m_arc.rewind(0); }
//--------------------------------------------------------------------
unsigned vertex(double* x, double* y)
{
return m_arc.vertex(x, y);
}
unsigned vertex(double* x, double* y) { return m_arc.vertex(x, y); }
// Supplemantary functions. num_vertices() actually returns doubled
// number of vertices. That is, for 1 vertex it returns 2.
@ -148,12 +142,8 @@ namespace agg
private:
bezier_arc m_arc;
bool m_radii_ok;
};
}
};
} // namespace agg
#endif

26
deps/agg/include/agg_bitset_iterator.h vendored
View file

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

593
deps/agg/include/agg_blur.h vendored
View file

File diff suppressed because it is too large Load diff

75
deps/agg/include/agg_bounding_rect.h vendored
View file

@ -21,15 +21,19 @@
#include "agg_basics.h"
namespace agg
{
namespace agg {
//-----------------------------------------------------------bounding_rect
template<class VertexSource, class GetId, class CoordT>
bool bounding_rect(VertexSource& vs, GetId& gi,
unsigned start, unsigned num,
CoordT* x1, CoordT* y1, CoordT* x2, CoordT* y2)
{
//-----------------------------------------------------------bounding_rect
template<class VertexSource, class GetId, class CoordT>
bool bounding_rect(VertexSource& vs,
GetId& gi,
unsigned start,
unsigned num,
CoordT* x1,
CoordT* y1,
CoordT* x2,
CoordT* y2)
{
unsigned i;
double x;
double y;
@ -40,15 +44,15 @@ namespace agg
*x2 = CoordT(0);
*y2 = CoordT(0);
for(i = 0; i < num; i++)
for (i = 0; i < num; i++)
{
vs.rewind(gi[start + i]);
unsigned cmd;
while(!is_stop(cmd = vs.vertex(&x, &y)))
while (!is_stop(cmd = vs.vertex(&x, &y)))
{
if(is_vertex(cmd))
if (is_vertex(cmd))
{
if(first)
if (first)
{
*x1 = CoordT(x);
*y1 = CoordT(y);
@ -58,23 +62,25 @@ namespace agg
}
else
{
if(CoordT(x) < *x1) *x1 = CoordT(x);
if(CoordT(y) < *y1) *y1 = CoordT(y);
if(CoordT(x) > *x2) *x2 = CoordT(x);
if(CoordT(y) > *y2) *y2 = CoordT(y);
if (CoordT(x) < *x1)
*x1 = CoordT(x);
if (CoordT(y) < *y1)
*y1 = CoordT(y);
if (CoordT(x) > *x2)
*x2 = CoordT(x);
if (CoordT(y) > *y2)
*y2 = CoordT(y);
}
}
}
}
return *x1 <= *x2 && *y1 <= *y2;
}
}
//-----------------------------------------------------bounding_rect_single
template<class VertexSource, class CoordT>
bool bounding_rect_single(VertexSource& vs, unsigned path_id,
CoordT* x1, CoordT* y1, CoordT* x2, CoordT* y2)
{
//-----------------------------------------------------bounding_rect_single
template<class VertexSource, class CoordT>
bool bounding_rect_single(VertexSource& vs, unsigned path_id, CoordT* x1, CoordT* y1, CoordT* x2, CoordT* y2)
{
double x;
double y;
bool first = true;
@ -86,11 +92,11 @@ namespace agg
vs.rewind(path_id);
unsigned cmd;
while(!is_stop(cmd = vs.vertex(&x, &y)))
while (!is_stop(cmd = vs.vertex(&x, &y)))
{
if(is_vertex(cmd))
if (is_vertex(cmd))
{
if(first)
if (first)
{
*x1 = CoordT(x);
*y1 = CoordT(y);
@ -100,17 +106,20 @@ namespace agg
}
else
{
if(CoordT(x) < *x1) *x1 = CoordT(x);
if(CoordT(y) < *y1) *y1 = CoordT(y);
if(CoordT(x) > *x2) *x2 = CoordT(x);
if(CoordT(y) > *y2) *y2 = CoordT(y);
if (CoordT(x) < *x1)
*x1 = CoordT(x);
if (CoordT(y) < *y1)
*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

40
deps/agg/include/agg_bspline.h vendored
View file

@ -22,23 +22,22 @@
#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,
// x, y - arrays of X and Y values respectively. Here Y must be a function
// of X. It means that all the X-coordinates must be arranged in the ascending
// order.
// Then call get(x) that calculates a value Y for the respective X.
// The class supports extrapolation, i.e. you can call get(x) where x is
// outside the given with init() X-range. Extrapolation is a simple linear
// function.
//
// See Implementation agg_bspline.cpp
//------------------------------------------------------------------------
class bspline
{
//----------------------------------------------------------------bspline
// A very simple class of Bi-cubic Spline interpolation.
// First call init(num, x[], y[]) where num - number of source points,
// x, y - arrays of X and Y values respectively. Here Y must be a function
// of X. It means that all the X-coordinates must be arranged in the ascending
// order.
// Then call get(x) that calculates a value Y for the respective X.
// The class supports extrapolation, i.e. you can call get(x) where x is
// outside the given with init() X-range. Extrapolation is a simple linear
// function.
//
// See Implementation agg_bspline.cpp
//------------------------------------------------------------------------
class bspline
{
public:
bspline();
bspline(int num);
@ -55,9 +54,9 @@ namespace agg
private:
bspline(const bspline&);
const bspline& operator = (const bspline&);
const bspline& operator=(const bspline&);
static void bsearch(int n, const double *x, double x0, int *i);
static void bsearch(int n, const double* x, double x0, int* i);
double extrapolation_left(double x) const;
double extrapolation_right(double x) const;
double interpolation(double x, int i) const;
@ -68,9 +67,8 @@ namespace agg
double* m_y;
pod_array<double> m_am;
mutable int m_last_idx;
};
};
}
} // namespace agg
#endif

183
deps/agg/include/agg_clip_liang_barsky.h vendored
View file

@ -21,69 +21,60 @@
#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,
clipping_flags_y2_clipped = 2,
clipping_flags_x_clipped = clipping_flags_x1_clipped | clipping_flags_x2_clipped,
clipping_flags_y_clipped = clipping_flags_y1_clipped | clipping_flags_y2_clipped
};
};
//----------------------------------------------------------clipping_flags
// Determine the clipping code of the vertex according to the
// Cyrus-Beck line clipping algorithm
//
// | |
// 0110 | 0010 | 0011
// | |
// -------+--------+-------- clip_box.y2
// | |
// 0100 | 0000 | 0001
// | |
// -------+--------+-------- clip_box.y1
// | |
// 1100 | 1000 | 1001
// | |
// clip_box.x1 clip_box.x2
//
//
template<class T>
inline unsigned clipping_flags(T x, T y, const rect_base<T>& clip_box)
{
return (x > clip_box.x2) |
((y > clip_box.y2) << 1) |
((x < clip_box.x1) << 2) |
((y < clip_box.y1) << 3);
}
//----------------------------------------------------------clipping_flags
// Determine the clipping code of the vertex according to the
// Cyrus-Beck line clipping algorithm
//
// | |
// 0110 | 0010 | 0011
// | |
// -------+--------+-------- clip_box.y2
// | |
// 0100 | 0000 | 0001
// | |
// -------+--------+-------- clip_box.y1
// | |
// 1100 | 1000 | 1001
// | |
// clip_box.x1 clip_box.x2
//
//
template<class T>
inline unsigned clipping_flags(T x, T y, const rect_base<T>& clip_box)
{
return (x > clip_box.x2) | ((y > clip_box.y2) << 1) | ((x < clip_box.x1) << 2) | ((y < clip_box.y1) << 3);
}
//--------------------------------------------------------clipping_flags_x
template<class T>
inline unsigned clipping_flags_x(T x, const rect_base<T>& clip_box)
{
//--------------------------------------------------------clipping_flags_x
template<class T>
inline unsigned clipping_flags_x(T x, const rect_base<T>& clip_box)
{
return (x > clip_box.x2) | ((x < clip_box.x1) << 2);
}
}
//--------------------------------------------------------clipping_flags_y
template<class T>
inline unsigned clipping_flags_y(T y, const rect_base<T>& clip_box)
{
//--------------------------------------------------------clipping_flags_y
template<class T>
inline unsigned clipping_flags_y(T y, const rect_base<T>& clip_box)
{
return ((y > clip_box.y2) << 1) | ((y < clip_box.y1) << 3);
}
}
//-------------------------------------------------------clip_liang_barsky
template<class T>
inline unsigned clip_liang_barsky(T x1, T y1, T x2, T y2,
const rect_base<T>& clip_box,
T* x, T* y)
{
//-------------------------------------------------------clip_liang_barsky
template<class T>
inline unsigned clip_liang_barsky(T x1, T y1, T x2, T y2, const rect_base<T>& clip_box, T* x, T* y)
{
const double nearzero = 1e-30;
double deltax = x2 - x1;
@ -101,19 +92,19 @@ namespace agg
double tout1;
unsigned np = 0;
if(deltax == 0.0)
if (deltax == 0.0)
{
// bump off of the vertical
deltax = (x1 > clip_box.x1) ? -nearzero : nearzero;
}
if(deltay == 0.0)
if (deltay == 0.0)
{
// bump off of the horizontal
deltay = (y1 > clip_box.y1) ? -nearzero : nearzero;
}
if(deltax > 0.0)
if (deltax > 0.0)
{
// points to right
xin = clip_box.x1;
@ -125,7 +116,7 @@ namespace agg
xout = clip_box.x1;
}
if(deltay > 0.0)
if (deltay > 0.0)
{
// points up
yin = clip_box.y1;
@ -153,29 +144,29 @@ namespace agg
tin2 = tinx;
}
if(tin1 <= 1.0)
if (tin1 <= 1.0)
{
if(0.0 < tin1)
if (0.0 < tin1)
{
*x++ = (T)xin;
*y++ = (T)yin;
++np;
}
if(tin2 <= 1.0)
if (tin2 <= 1.0)
{
toutx = (xout - x1) / deltax;
touty = (yout - y1) / deltay;
tout1 = (toutx < touty) ? toutx : touty;
if(tin2 > 0.0 || tout1 > 0.0)
if (tin2 > 0.0 || tout1 > 0.0)
{
if(tin2 <= tout1)
if (tin2 <= tout1)
{
if(tin2 > 0.0)
if (tin2 > 0.0)
{
if(tinx > tiny)
if (tinx > tiny)
{
*x++ = (T)xin;
*y++ = (T)(y1 + tinx * deltay);
@ -188,9 +179,9 @@ namespace agg
++np;
}
if(tout1 < 1.0)
if (tout1 < 1.0)
{
if(toutx < touty)
if (toutx < touty)
{
*x++ = (T)xout;
*y++ = (T)(y1 + toutx * deltay);
@ -210,7 +201,7 @@ namespace agg
}
else
{
if(tinx > tiny)
if (tinx > tiny)
{
*x++ = (T)xin;
*y++ = (T)yout;
@ -226,20 +217,17 @@ namespace agg
}
}
return np;
}
}
//----------------------------------------------------------------------------
template<class T>
bool clip_move_point(T x1, T y1, T x2, T y2,
const rect_base<T>& clip_box,
T* x, T* y, unsigned flags)
{
//----------------------------------------------------------------------------
template<class T>
bool clip_move_point(T x1, T y1, T x2, T y2, const rect_base<T>& clip_box, T* x, T* y, unsigned flags)
{
T bound;
if(flags & clipping_flags_x_clipped)
if (flags & clipping_flags_x_clipped)
{
if(x1 == x2)
if (x1 == x2)
{
return false;
}
@ -249,9 +237,9 @@ namespace agg
}
flags = clipping_flags_y(*y, clip_box);
if(flags & clipping_flags_y_clipped)
if (flags & clipping_flags_y_clipped)
{
if(y1 == y2)
if (y1 == y2)
{
return false;
}
@ -260,36 +248,33 @@ namespace agg
*y = bound;
}
return true;
}
}
//-------------------------------------------------------clip_line_segment
// Returns: ret >= 4 - Fully clipped
// (ret & 1) != 0 - First point has been moved
// (ret & 2) != 0 - Second point has been moved
//
template<class T>
unsigned clip_line_segment(T* x1, T* y1, T* x2, T* y2,
const rect_base<T>& clip_box)
{
//-------------------------------------------------------clip_line_segment
// Returns: ret >= 4 - Fully clipped
// (ret & 1) != 0 - First point has been moved
// (ret & 2) != 0 - Second point has been moved
//
template<class T>
unsigned clip_line_segment(T* x1, T* y1, T* x2, T* y2, const rect_base<T>& clip_box)
{
unsigned f1 = clipping_flags(*x1, *y1, clip_box);
unsigned f2 = clipping_flags(*x2, *y2, clip_box);
unsigned ret = 0;
if((f2 | f1) == 0)
if ((f2 | f1) == 0)
{
// Fully visible
return 0;
}
if((f1 & clipping_flags_x_clipped) != 0 &&
(f1 & clipping_flags_x_clipped) == (f2 & clipping_flags_x_clipped))
if ((f1 & clipping_flags_x_clipped) != 0 && (f1 & clipping_flags_x_clipped) == (f2 & clipping_flags_x_clipped))
{
// Fully clipped
return 4;
}
if((f1 & clipping_flags_y_clipped) != 0 &&
(f1 & clipping_flags_y_clipped) == (f2 & clipping_flags_y_clipped))
if ((f1 & clipping_flags_y_clipped) != 0 && (f1 & clipping_flags_y_clipped) == (f2 & clipping_flags_y_clipped))
{
// Fully clipped
return 4;
@ -299,35 +284,33 @@ namespace agg
T ty1 = *y1;
T tx2 = *x2;
T ty2 = *y2;
if(f1)
if (f1)
{
if(!clip_move_point(tx1, ty1, tx2, ty2, clip_box, x1, y1, f1))
if (!clip_move_point(tx1, ty1, tx2, ty2, clip_box, x1, y1, f1))
{
return 4;
}
if(*x1 == *x2 && *y1 == *y2)
if (*x1 == *x2 && *y1 == *y2)
{
return 4;
}
ret |= 1;
}
if(f2)
if (f2)
{
if(!clip_move_point(tx1, ty1, tx2, ty2, clip_box, x2, y2, f2))
if (!clip_move_point(tx1, ty1, tx2, ty2, clip_box, x2, y2, f2))
{
return 4;
}
if(*x1 == *x2 && *y1 == *y2)
if (*x1 == *x2 && *y1 == *y2)
{
return 4;
}
ret |= 2;
}
return ret;
}
}
} // namespace agg
#endif

505
deps/agg/include/agg_color_gray.h vendored
View file

@ -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) :
v(int8u(v_)), a(int8u(a_)) {}
gray8T(unsigned v_, unsigned a_ = base_mask)
: v(int8u(v_))
, a(int8u(a_))
{}
//--------------------------------------------------------------------
gray8T(const self_type& c, unsigned a_) :
v(c.v), a(value_type(a_)) {}
gray8T(const self_type& c, unsigned a_)
: v(c.v)
, a(value_type(a_))
{}
//--------------------------------------------------------------------
gray8T(const rgba& c) :
v(luminance(c)),
a(value_type(uround(c.a * base_mask))) {}
gray8T(const rgba& c)
: v(luminance(c))
, a(value_type(uround(c.a * base_mask)))
{}
//--------------------------------------------------------------------
template<class T>
@ -147,36 +150,18 @@ struct gray8T
}
//--------------------------------------------------------------------
rgba8 make_rgba8(const linear&) const
{
return rgba8(v, v, v, a);
}
rgba8 make_rgba8(const linear&) const { return rgba8(v, v, v, a); }
rgba8 make_rgba8(const sRGB&) const
{
return convert_from_sRGB<srgba8>();
}
rgba8 make_rgba8(const sRGB&) const { return convert_from_sRGB<srgba8>(); }
operator rgba8() const
{
return make_rgba8(Colorspace());
}
operator rgba8() const { return make_rgba8(Colorspace()); }
//--------------------------------------------------------------------
srgba8 make_srgba8(const linear&) const
{
return convert_to_sRGB<rgba8>();
}
srgba8 make_srgba8(const linear&) const { return convert_to_sRGB<rgba8>(); }
srgba8 make_srgba8(const sRGB&) const
{
return srgba8(v, v, v, a);
}
srgba8 make_srgba8(const sRGB&) const { return srgba8(v, v, v, a); }
operator srgba8() const
{
return make_rgba8(Colorspace());
}
operator srgba8() const { 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
{
return convert_from_sRGB<rgba16>();
}
rgba16 make_rgba16(const sRGB&) const { return convert_from_sRGB<rgba16>(); }
operator rgba16() const
{
return make_rgba16(Colorspace());
}
operator rgba16() const { 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
{
return convert_from_sRGB<rgba32>();
}
rgba32 make_rgba32(const sRGB&) const { return convert_from_sRGB<rgba32>(); }
operator rgba32() const
{
return make_rgba32(Colorspace());
}
operator rgba32() const { return make_rgba32(Colorspace()); }
//--------------------------------------------------------------------
static AGG_INLINE double to_double(value_type a)
{
return double(a) / base_mask;
}
static AGG_INLINE double to_double(value_type a) { return double(a) / base_mask; }
//--------------------------------------------------------------------
static AGG_INLINE value_type from_double(double a)
{
return value_type(uround(a * base_mask));
}
static AGG_INLINE value_type from_double(double a) { return value_type(uround(a * base_mask)); }
//--------------------------------------------------------------------
static AGG_INLINE value_type empty_value()
{
return 0;
}
static AGG_INLINE value_type empty_value() { return 0; }
//--------------------------------------------------------------------
static AGG_INLINE value_type full_value()
{
return base_mask;
}
static AGG_INLINE value_type full_value() { return base_mask; }
//--------------------------------------------------------------------
AGG_INLINE bool is_transparent() const
{
return a == 0;
}
AGG_INLINE bool is_transparent() const { return a == 0; }
//--------------------------------------------------------------------
AGG_INLINE bool is_opaque() const
{
return a == base_mask;
}
AGG_INLINE bool is_opaque() const { 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)
{
return multiply(a, b);
}
static AGG_INLINE value_type mult_cover(value_type a, value_type b) { return multiply(a, b); }
//--------------------------------------------------------------------
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
{
return multiply(b, a);
}
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b) { return multiply(b, a); }
//--------------------------------------------------------------------
// Interpolate p to q by a, assuming q is premultiplied by a.
static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a)
{
return p + q - multiply(p, a);
}
static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a) { return p + q - multiply(p, a); }
//--------------------------------------------------------------------
// Interpolate p to q by a.
@ -330,25 +277,27 @@ struct gray8T
//--------------------------------------------------------------------
self_type& opacity(double a_)
{
if (a_ < 0) a = 0;
else if (a_ > 1) a = 1;
else a = (value_type)uround(a_ * double(base_mask));
if (a_ < 0)
a = 0;
else if (a_ > 1)
a = 1;
else
a = (value_type)uround(a_ * double(base_mask));
return *this;
}
//--------------------------------------------------------------------
double opacity() const
{
return double(a) / double(base_mask);
}
double opacity() const { return double(a) / double(base_mask); }
//--------------------------------------------------------------------
self_type& premultiply()
{
if (a < base_mask)
{
if (a == 0) v = 0;
else v = multiply(v, a);
if (a == 0)
v = 0;
else
v = multiply(v, a);
}
return *this;
}
@ -408,21 +357,19 @@ struct gray8T
}
//--------------------------------------------------------------------
static self_type no_color() { return self_type(0,0); }
static self_type no_color() { return self_type(0, 0); }
};
typedef gray8T<linear> gray8;
typedef gray8T<sRGB> sgray8;
//==================================================================gray16
struct gray16
{
typedef int16u value_type;
typedef int32u calc_type;
typedef int64 long_type;
enum base_scale_e
{
enum base_scale_e {
base_shift = 16,
base_scale = 1 << base_shift,
base_mask = base_scale - 1,
@ -436,8 +383,7 @@ struct gray16
static value_type luminance(const rgba& c)
{
// Calculate grayscale value as per ITU-R BT.709.
return value_type(uround((0.2126 * c.r + 0.7152 * c.g + 0.0722 * c.b)
* static_cast<double>(base_mask)));
return value_type(uround((0.2126 * c.r + 0.7152 * c.g + 0.0722 * c.b) * static_cast<double>(base_mask)));
}
static value_type luminance(const rgba16& c)
@ -446,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)
{
return luminance(rgba16(c));
}
static value_type luminance(const rgba8& c) { return luminance(rgba16(c)); }
static value_type luminance(const srgba8& c)
{
return luminance(rgba16(c));
}
static value_type luminance(const srgba8& c) { return luminance(rgba16(c)); }
static value_type luminance(const rgba32& c)
{
return luminance(rgba(c));
}
static value_type luminance(const rgba32& c) { return luminance(rgba(c)); }
//--------------------------------------------------------------------
gray16() {}
//--------------------------------------------------------------------
gray16(unsigned v_, unsigned a_ = base_mask) :
v(int16u(v_)), a(int16u(a_)) {}
gray16(unsigned v_, unsigned a_ = base_mask)
: v(int16u(v_))
, a(int16u(a_))
{}
//--------------------------------------------------------------------
gray16(const self_type& c, unsigned a_) :
v(c.v), a(value_type(a_)) {}
gray16(const self_type& c, unsigned a_)
: v(c.v)
, a(value_type(a_))
{}
//--------------------------------------------------------------------
gray16(const rgba& c) :
v(luminance(c)),
a((value_type)uround(c.a * double(base_mask))) {}
gray16(const rgba& c)
: v(luminance(c))
, a((value_type)uround(c.a * double(base_mask)))
{}
//--------------------------------------------------------------------
gray16(const rgba8& c) :
v(luminance(c)),
a((value_type(c.a) << 8) | c.a) {}
gray16(const rgba8& c)
: v(luminance(c))
, a((value_type(c.a) << 8) | c.a)
{}
//--------------------------------------------------------------------
gray16(const srgba8& c) :
v(luminance(c)),
a((value_type(c.a) << 8) | c.a) {}
gray16(const srgba8& c)
: v(luminance(c))
, a((value_type(c.a) << 8) | c.a)
{}
//--------------------------------------------------------------------
gray16(const rgba16& c) :
v(luminance(c)),
a(c.a) {}
gray16(const rgba16& c)
: v(luminance(c))
, a(c.a)
{}
//--------------------------------------------------------------------
gray16(const gray8& c) :
v((value_type(c.v) << 8) | c.v),
a((value_type(c.a) << 8) | c.a) {}
gray16(const gray8& c)
: v((value_type(c.v) << 8) | c.v)
, a((value_type(c.a) << 8) | c.a)
{}
//--------------------------------------------------------------------
gray16(const sgray8& c) :
v(sRGB_conv<value_type>::rgb_from_sRGB(c.v)),
a(sRGB_conv<value_type>::alpha_from_sRGB(c.a)) {}
gray16(const sgray8& c)
: v(sRGB_conv<value_type>::rgb_from_sRGB(c.v))
, a(sRGB_conv<value_type>::alpha_from_sRGB(c.a))
{}
//--------------------------------------------------------------------
operator rgba8() const
{
return rgba8(v >> 8, v >> 8, v >> 8, a >> 8);
}
operator rgba8() const { return rgba8(v >> 8, v >> 8, v >> 8, a >> 8); }
//--------------------------------------------------------------------
operator srgba8() const
@ -516,30 +460,19 @@ struct gray16
}
//--------------------------------------------------------------------
operator rgba16() const
{
return rgba16(v, v, v, a);
}
operator rgba16() const { return rgba16(v, v, v, a); }
//--------------------------------------------------------------------
operator gray8() const
{
return gray8(v >> 8, a >> 8);
}
operator gray8() const { return gray8(v >> 8, a >> 8); }
//--------------------------------------------------------------------
operator sgray8() const
{
return sgray8(
sRGB_conv<value_type>::rgb_to_sRGB(v),
sRGB_conv<value_type>::alpha_to_sRGB(a));
return sgray8(sRGB_conv<value_type>::rgb_to_sRGB(v), sRGB_conv<value_type>::alpha_to_sRGB(a));
}
//--------------------------------------------------------------------
static AGG_INLINE double to_double(value_type a)
{
return static_cast<double>(a) / static_cast<double>(base_mask);
}
static AGG_INLINE double to_double(value_type a) { return static_cast<double>(a) / static_cast<double>(base_mask); }
//--------------------------------------------------------------------
static AGG_INLINE value_type from_double(double a)
@ -548,28 +481,16 @@ struct gray16
}
//--------------------------------------------------------------------
static AGG_INLINE value_type empty_value()
{
return 0;
}
static AGG_INLINE value_type empty_value() { return 0; }
//--------------------------------------------------------------------
static AGG_INLINE value_type full_value()
{
return base_mask;
}
static AGG_INLINE value_type full_value() { return base_mask; }
//--------------------------------------------------------------------
AGG_INLINE bool is_transparent() const
{
return a == 0;
}
AGG_INLINE bool is_transparent() const { return a == 0; }
//--------------------------------------------------------------------
AGG_INLINE bool is_opaque() const
{
return a == base_mask;
}
AGG_INLINE bool is_opaque() const { return a == base_mask; }
//--------------------------------------------------------------------
// Fixed-point multiply, exact over int16u.
@ -590,7 +511,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);
}
//--------------------------------------------------------------------
@ -610,23 +532,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)
{
return multiply(a, b << 8 | b);
}
static AGG_INLINE value_type mult_cover(value_type a, cover_type b) { return multiply(a, b << 8 | b); }
//--------------------------------------------------------------------
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
{
return mult_cover(b, a) >> 8;
}
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b) { return mult_cover(b, a) >> 8; }
//--------------------------------------------------------------------
// Interpolate p to q by a, assuming q is premultiplied by a.
static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a)
{
return p + q - multiply(p, a);
}
static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a) { return p + q - multiply(p, a); }
//--------------------------------------------------------------------
// Interpolate p to q by a.
@ -653,26 +566,27 @@ struct gray16
//--------------------------------------------------------------------
self_type& opacity(double a_)
{
if (a_ < 0) a = 0;
else if(a_ > 1) a = 1;
else a = (value_type)uround(a_ * double(base_mask));
if (a_ < 0)
a = 0;
else if (a_ > 1)
a = 1;
else
a = (value_type)uround(a_ * double(base_mask));
return *this;
}
//--------------------------------------------------------------------
double opacity() const
{
return double(a) / double(base_mask);
}
double opacity() const { return double(a) / double(base_mask); }
//--------------------------------------------------------------------
self_type& premultiply()
{
if (a < base_mask)
{
if(a == 0) v = 0;
else v = multiply(v, a);
if (a == 0)
v = 0;
else
v = multiply(v, a);
}
return *this;
}
@ -732,10 +646,9 @@ struct gray16
}
//--------------------------------------------------------------------
static self_type no_color() { return self_type(0,0); }
static self_type no_color() { return self_type(0, 0); }
};
//===================================================================gray32
struct gray32
{
@ -747,8 +660,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,
@ -760,103 +672,92 @@ struct gray32
return value_type(0.2126 * r + 0.7152 * g + 0.0722 * b);
}
static value_type luminance(const rgba& c)
{
return luminance(c.r, c.g, c.b);
}
static value_type luminance(const rgba& c) { return luminance(c.r, c.g, c.b); }
static value_type luminance(const rgba32& c)
{
return luminance(c.r, c.g, c.b);
}
static value_type luminance(const rgba32& c) { return luminance(c.r, c.g, c.b); }
static value_type luminance(const rgba8& c)
{
return luminance(c.r / 255.0, c.g / 255.0, c.g / 255.0);
}
static value_type luminance(const rgba8& c) { return luminance(c.r / 255.0, c.g / 255.0, c.g / 255.0); }
static value_type luminance(const rgba16& c)
{
return luminance(c.r / 65535.0, c.g / 65535.0, c.g / 65535.0);
}
static value_type luminance(const rgba16& c) { return luminance(c.r / 65535.0, c.g / 65535.0, c.g / 65535.0); }
//--------------------------------------------------------------------
gray32() {}
//--------------------------------------------------------------------
gray32(value_type v_, value_type a_ = 1) :
v(v_), a(a_) {}
gray32(value_type v_, value_type a_ = 1)
: v(v_)
, a(a_)
{}
//--------------------------------------------------------------------
gray32(const self_type& c, value_type a_) :
v(c.v), a(a_) {}
gray32(const self_type& c, value_type a_)
: v(c.v)
, a(a_)
{}
//--------------------------------------------------------------------
gray32(const rgba& c) :
v(luminance(c)),
a(value_type(c.a)) {}
gray32(const rgba& c)
: v(luminance(c))
, a(value_type(c.a))
{}
//--------------------------------------------------------------------
gray32(const rgba8& c) :
v(luminance(c)),
a(value_type(c.a / 255.0)) {}
gray32(const rgba8& c)
: v(luminance(c))
, a(value_type(c.a / 255.0))
{}
//--------------------------------------------------------------------
gray32(const srgba8& c) :
v(luminance(rgba32(c))),
a(value_type(c.a / 255.0)) {}
gray32(const srgba8& c)
: v(luminance(rgba32(c)))
, a(value_type(c.a / 255.0))
{}
//--------------------------------------------------------------------
gray32(const rgba16& c) :
v(luminance(c)),
a(value_type(c.a / 65535.0)) {}
gray32(const rgba16& c)
: v(luminance(c))
, a(value_type(c.a / 65535.0))
{}
//--------------------------------------------------------------------
gray32(const rgba32& c) :
v(luminance(c)),
a(value_type(c.a)) {}
gray32(const rgba32& c)
: v(luminance(c))
, a(value_type(c.a))
{}
//--------------------------------------------------------------------
gray32(const gray8& c) :
v(value_type(c.v / 255.0)),
a(value_type(c.a / 255.0)) {}
gray32(const gray8& c)
: v(value_type(c.v / 255.0))
, a(value_type(c.a / 255.0))
{}
//--------------------------------------------------------------------
gray32(const sgray8& c) :
v(sRGB_conv<value_type>::rgb_from_sRGB(c.v)),
a(sRGB_conv<value_type>::alpha_from_sRGB(c.a)) {}
gray32(const sgray8& c)
: v(sRGB_conv<value_type>::rgb_from_sRGB(c.v))
, a(sRGB_conv<value_type>::alpha_from_sRGB(c.a))
{}
//--------------------------------------------------------------------
gray32(const gray16& c) :
v(value_type(c.v / 65535.0)),
a(value_type(c.a / 65535.0)) {}
gray32(const gray16& c)
: v(value_type(c.v / 65535.0))
, a(value_type(c.a / 65535.0))
{}
//--------------------------------------------------------------------
operator rgba() const
{
return rgba(v, v, v, a);
}
operator rgba() const { return rgba(v, v, v, a); }
//--------------------------------------------------------------------
operator gray8() const
{
return gray8(uround(v * 255.0), uround(a * 255.0));
}
operator gray8() const { return gray8(uround(v * 255.0), uround(a * 255.0)); }
//--------------------------------------------------------------------
operator sgray8() const
{
// Return (non-premultiplied) sRGB values.
return sgray8(
sRGB_conv<value_type>::rgb_to_sRGB(v),
sRGB_conv<value_type>::alpha_to_sRGB(a));
return sgray8(sRGB_conv<value_type>::rgb_to_sRGB(v), sRGB_conv<value_type>::alpha_to_sRGB(a));
}
//--------------------------------------------------------------------
operator gray16() const
{
return gray16(uround(v * 65535.0), uround(a * 65535.0));
}
operator gray16() const { return gray16(uround(v * 65535.0), uround(a * 65535.0)); }
//--------------------------------------------------------------------
operator rgba8() const
@ -880,58 +781,31 @@ struct gray32
}
//--------------------------------------------------------------------
static AGG_INLINE double to_double(value_type a)
{
return a;
}
static AGG_INLINE double to_double(value_type a) { return a; }
//--------------------------------------------------------------------
static AGG_INLINE value_type from_double(double a)
{
return value_type(a);
}
static AGG_INLINE value_type from_double(double a) { return value_type(a); }
//--------------------------------------------------------------------
static AGG_INLINE value_type empty_value()
{
return 0;
}
static AGG_INLINE value_type empty_value() { return 0; }
//--------------------------------------------------------------------
static AGG_INLINE value_type full_value()
{
return 1;
}
static AGG_INLINE value_type full_value() { return 1; }
//--------------------------------------------------------------------
AGG_INLINE bool is_transparent() const
{
return a <= 0;
}
AGG_INLINE bool is_transparent() const { return a <= 0; }
//--------------------------------------------------------------------
AGG_INLINE bool is_opaque() const
{
return a >= 1;
}
AGG_INLINE bool is_opaque() const { return a >= 1; }
//--------------------------------------------------------------------
static AGG_INLINE value_type invert(value_type x)
{
return 1 - x;
}
static AGG_INLINE value_type invert(value_type x) { return 1 - x; }
//--------------------------------------------------------------------
static AGG_INLINE value_type multiply(value_type a, value_type b)
{
return value_type(a * b);
}
static AGG_INLINE value_type multiply(value_type a, value_type b) { return value_type(a * b); }
//--------------------------------------------------------------------
static AGG_INLINE value_type demultiply(value_type a, value_type b)
{
return (b == 0) ? 0 : value_type(a / b);
}
static AGG_INLINE value_type demultiply(value_type a, value_type b) { return (b == 0) ? 0 : value_type(a / b); }
//--------------------------------------------------------------------
template<typename T>
@ -954,10 +828,7 @@ struct gray32
}
//--------------------------------------------------------------------
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
{
return cover_type(uround(a * b));
}
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b) { return cover_type(uround(a * b)); }
//--------------------------------------------------------------------
// Interpolate p to q by a, assuming q is premultiplied by a.
@ -994,49 +865,47 @@ struct gray32
//--------------------------------------------------------------------
self_type& opacity(double a_)
{
if (a_ < 0) a = 0;
else if (a_ > 1) a = 1;
else a = value_type(a_);
if (a_ < 0)
a = 0;
else if (a_ > 1)
a = 1;
else
a = value_type(a_);
return *this;
}
//--------------------------------------------------------------------
double opacity() const
{
return a;
}
double opacity() const { return a; }
//--------------------------------------------------------------------
self_type& premultiply()
{
if (a < 0) v = 0;
else if(a < 1) v *= a;
if (a < 0)
v = 0;
else if (a < 1)
v *= a;
return *this;
}
//--------------------------------------------------------------------
self_type& demultiply()
{
if (a < 0) v = 0;
else if (a < 1) v /= a;
if (a < 0)
v = 0;
else if (a < 1)
v /= a;
return *this;
}
//--------------------------------------------------------------------
self_type gradient(self_type c, double k) const
{
return self_type(
value_type(v + (c.v - v) * k),
value_type(a + (c.a - a) * k));
return self_type(value_type(v + (c.v - v) * k), value_type(a + (c.a - a) * k));
}
//--------------------------------------------------------------------
static self_type no_color() { return self_type(0,0); }
static self_type no_color() { return self_type(0, 0); }
};
}
} // namespace agg
#endif

491
deps/agg/include/agg_color_rgba.h vendored
View file

@ -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_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
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
struct order_rgb
{
enum rgb_e { R = 0, G = 1, B = 2, rgb_tag, hasAlpha = false };
}; //----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
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 sRGB {};
struct linear
{};
struct sRGB
{};
//====================================================================rgba
struct rgba
@ -57,11 +76,20 @@ struct rgba
rgba() {}
//--------------------------------------------------------------------
rgba(double r_, double g_, double b_, double a_=1.0) :
r(r_), g(g_), b(b_), a(a_) {}
rgba(double r_, double g_, double b_, double a_ = 1.0)
: r(r_)
, g(g_)
, b(b_)
, a(a_)
{}
//--------------------------------------------------------------------
rgba(const rgba& c, double a_) : r(c.r), g(c.g), b(c.b), a(a_) {}
rgba(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;
else if (a_ > 1) a = 1;
else a = a_;
if (a_ < 0)
a = 0;
else if (a_ > 1)
a = 1;
else
a = a_;
return *this;
}
//--------------------------------------------------------------------
double opacity() const
{
return a;
}
double opacity() const { return a; }
//--------------------------------------------------------------------
rgba& premultiply()
@ -136,7 +164,6 @@ struct rgba
return *this;
}
//--------------------------------------------------------------------
rgba gradient(rgba c, double k) const
{
@ -167,17 +194,13 @@ struct rgba
}
//--------------------------------------------------------------------
static rgba no_color() { return rgba(0,0,0,0); }
static rgba no_color() { return rgba(0, 0, 0, 0); }
//--------------------------------------------------------------------
static rgba from_wavelength(double wl, double gamma = 1.0);
//--------------------------------------------------------------------
explicit rgba(double wavelen, double gamma=1.0)
{
*this = from_wavelength(wavelen, gamma);
}
explicit rgba(double wavelen, double gamma = 1.0) { *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);
else if (wl < 420.0) s = 0.3 + 0.7 * (wl - 380.0) / (420.0 - 380.0);
if (wl > 700.0)
s = 0.3 + 0.7 * (780.0 - wl) / (780.0 - 700.0);
else if (wl < 420.0)
s = 0.3 + 0.7 * (wl - 380.0) / (420.0 - 380.0);
t.r = pow(t.r * s, gamma);
t.g = pow(t.g * s, gamma);
@ -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) :
r(value_type(r_)),
g(value_type(g_)),
b(value_type(b_)),
a(value_type(a_)) {}
rgba8T(unsigned r_, unsigned g_, unsigned b_, unsigned a_ = base_mask)
: r(value_type(r_))
, g(value_type(g_))
, b(value_type(b_))
, a(value_type(a_))
{}
//--------------------------------------------------------------------
rgba8T(const rgba& c)
{
convert(*this, c);
}
rgba8T(const rgba& c) { convert(*this, c); }
//--------------------------------------------------------------------
rgba8T(const self_type& c, unsigned a_) :
r(c.r), g(c.g), b(c.b), a(value_type(a_)) {}
rgba8T(const self_type& c, unsigned 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)
{
return double(a) / base_mask;
}
static AGG_INLINE double to_double(value_type a) { return double(a) / base_mask; }
//--------------------------------------------------------------------
static AGG_INLINE value_type from_double(double a)
{
return value_type(uround(a * base_mask));
}
static AGG_INLINE value_type from_double(double a) { return value_type(uround(a * base_mask)); }
//--------------------------------------------------------------------
static AGG_INLINE value_type empty_value()
{
return 0;
}
static AGG_INLINE value_type empty_value() { return 0; }
//--------------------------------------------------------------------
static AGG_INLINE value_type full_value()
{
return base_mask;
}
static AGG_INLINE value_type full_value() { return base_mask; }
//--------------------------------------------------------------------
AGG_INLINE bool is_transparent() const
{
return a == 0;
}
AGG_INLINE bool is_transparent() const { return a == 0; }
//--------------------------------------------------------------------
AGG_INLINE bool is_opaque() const
{
return a == base_mask;
}
AGG_INLINE bool is_opaque() const { return a == base_mask; }
//--------------------------------------------------------------------
static AGG_INLINE value_type invert(value_type x)
{
return base_mask - x;
}
static AGG_INLINE value_type invert(value_type 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)
{
return multiply(a, b);
}
static AGG_INLINE value_type mult_cover(value_type a, cover_type b) { return multiply(a, b); }
//--------------------------------------------------------------------
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
{
return multiply(b, a);
}
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b) { return multiply(b, a); }
//--------------------------------------------------------------------
// Interpolate p to q by a, assuming q is premultiplied by a.
static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a)
{
return p + q - multiply(p, a);
}
static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a) { return p + q - multiply(p, a); }
//--------------------------------------------------------------------
// Interpolate p to q by a.
@ -472,17 +467,17 @@ struct rgba8T
//--------------------------------------------------------------------
self_type& opacity(double a_)
{
if (a_ < 0) a = 0;
else if (a_ > 1) a = 1;
else a = (value_type)uround(a_ * double(base_mask));
if (a_ < 0)
a = 0;
else if (a_ > 1)
a = 1;
else
a = (value_type)uround(a_ * double(base_mask));
return *this;
}
//--------------------------------------------------------------------
double opacity() const
{
return double(a) / double(base_mask);
}
double opacity() const { return double(a) / double(base_mask); }
//--------------------------------------------------------------------
AGG_INLINE self_type& premultiply()
@ -604,7 +599,7 @@ struct rgba8T
}
//--------------------------------------------------------------------
static self_type no_color() { return self_type(0,0,0,0); }
static self_type no_color() { return self_type(0, 0, 0, 0); }
//--------------------------------------------------------------------
static self_type from_wavelength(double wl, double gamma = 1.0)
@ -617,10 +612,9 @@ typedef rgba8T<linear> rgba8;
typedef rgba8T<sRGB> srgba8;
//-------------------------------------------------------------rgba8_pre
inline rgba8 rgba8_pre(unsigned r, unsigned g, unsigned b,
unsigned a = rgba8::base_mask)
inline rgba8 rgba8_pre(unsigned r, unsigned g, unsigned b, unsigned a = rgba8::base_mask)
{
return rgba8(r,g,b,a).premultiply();
return rgba8(r, g, b, a).premultiply();
}
inline rgba8 rgba8_pre(const rgba8& c)
{
@ -628,7 +622,7 @@ inline rgba8 rgba8_pre(const rgba8& c)
}
inline rgba8 rgba8_pre(const rgba8& c, unsigned a)
{
return rgba8(c,a).premultiply();
return rgba8(c, a).premultiply();
}
inline rgba8 rgba8_pre(const rgba& c)
{
@ -636,12 +630,9 @@ inline rgba8 rgba8_pre(const rgba& c)
}
inline rgba8 rgba8_pre(const rgba& c, double a)
{
return rgba8(c,a).premultiply();
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,69 +688,63 @@ struct rgba16
rgba16() {}
//--------------------------------------------------------------------
rgba16(unsigned r_, unsigned g_, unsigned b_, unsigned a_=base_mask) :
r(value_type(r_)),
g(value_type(g_)),
b(value_type(b_)),
a(value_type(a_)) {}
rgba16(unsigned r_, unsigned g_, unsigned b_, unsigned a_ = base_mask)
: r(value_type(r_))
, g(value_type(g_))
, b(value_type(b_))
, a(value_type(a_))
{}
//--------------------------------------------------------------------
rgba16(const self_type& c, unsigned a_) :
r(c.r), g(c.g), b(c.b), a(value_type(a_)) {}
rgba16(const self_type& c, unsigned a_)
: r(c.r)
, g(c.g)
, b(c.b)
, a(value_type(a_))
{}
//--------------------------------------------------------------------
rgba16(const rgba& c) :
r((value_type)uround(c.r * double(base_mask))),
g((value_type)uround(c.g * double(base_mask))),
b((value_type)uround(c.b * double(base_mask))),
a((value_type)uround(c.a * double(base_mask))) {}
rgba16(const rgba& c)
: r((value_type)uround(c.r * double(base_mask)))
, g((value_type)uround(c.g * double(base_mask)))
, b((value_type)uround(c.b * double(base_mask)))
, a((value_type)uround(c.a * double(base_mask)))
{}
//--------------------------------------------------------------------
rgba16(const rgba8& c) :
r(value_type((value_type(c.r) << 8) | c.r)),
g(value_type((value_type(c.g) << 8) | c.g)),
b(value_type((value_type(c.b) << 8) | c.b)),
a(value_type((value_type(c.a) << 8) | c.a)) {}
rgba16(const rgba8& c)
: r(value_type((value_type(c.r) << 8) | c.r))
, g(value_type((value_type(c.g) << 8) | c.g))
, b(value_type((value_type(c.b) << 8) | c.b))
, a(value_type((value_type(c.a) << 8) | c.a))
{}
//--------------------------------------------------------------------
rgba16(const srgba8& c) :
r(sRGB_conv<value_type>::rgb_from_sRGB(c.r)),
g(sRGB_conv<value_type>::rgb_from_sRGB(c.g)),
b(sRGB_conv<value_type>::rgb_from_sRGB(c.b)),
a(sRGB_conv<value_type>::alpha_from_sRGB(c.a)) {}
rgba16(const srgba8& c)
: r(sRGB_conv<value_type>::rgb_from_sRGB(c.r))
, g(sRGB_conv<value_type>::rgb_from_sRGB(c.g))
, b(sRGB_conv<value_type>::rgb_from_sRGB(c.b))
, a(sRGB_conv<value_type>::alpha_from_sRGB(c.a))
{}
//--------------------------------------------------------------------
operator rgba() const
{
return rgba(
r / 65535.0,
g / 65535.0,
b / 65535.0,
a / 65535.0);
}
operator rgba() const { return rgba(r / 65535.0, g / 65535.0, b / 65535.0, a / 65535.0); }
//--------------------------------------------------------------------
operator rgba8() const
{
return rgba8(r >> 8, g >> 8, b >> 8, a >> 8);
}
operator rgba8() const { return rgba8(r >> 8, g >> 8, b >> 8, a >> 8); }
//--------------------------------------------------------------------
operator srgba8() const
{
// Return (non-premultiplied) sRGB values.
return srgba8(
sRGB_conv<value_type>::rgb_to_sRGB(r),
return srgba8(sRGB_conv<value_type>::rgb_to_sRGB(r),
sRGB_conv<value_type>::rgb_to_sRGB(g),
sRGB_conv<value_type>::rgb_to_sRGB(b),
sRGB_conv<value_type>::alpha_to_sRGB(a));
}
//--------------------------------------------------------------------
static AGG_INLINE double to_double(value_type a)
{
return static_cast<double>(a) / static_cast<double>(base_mask);
}
static AGG_INLINE double to_double(value_type a) { return static_cast<double>(a) / static_cast<double>(base_mask); }
//--------------------------------------------------------------------
static AGG_INLINE value_type from_double(double a)
@ -771,34 +753,19 @@ struct rgba16
}
//--------------------------------------------------------------------
static AGG_INLINE value_type empty_value()
{
return 0;
}
static AGG_INLINE value_type empty_value() { return 0; }
//--------------------------------------------------------------------
static AGG_INLINE value_type full_value()
{
return base_mask;
}
static AGG_INLINE value_type full_value() { return base_mask; }
//--------------------------------------------------------------------
AGG_INLINE bool is_transparent() const
{
return a == 0;
}
AGG_INLINE bool is_transparent() const { return a == 0; }
//--------------------------------------------------------------------
AGG_INLINE bool is_opaque() const
{
return a == base_mask;
}
AGG_INLINE bool is_opaque() const { return a == base_mask; }
//--------------------------------------------------------------------
static AGG_INLINE value_type invert(value_type x)
{
return base_mask - x;
}
static AGG_INLINE value_type invert(value_type x) { return base_mask - x; }
//--------------------------------------------------------------------
// Fixed-point multiply, exact over int16u.
@ -819,7 +786,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 +807,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)
{
return multiply(a, (b << 8) | b);
}
static AGG_INLINE value_type mult_cover(value_type a, cover_type b) { return multiply(a, (b << 8) | b); }
//--------------------------------------------------------------------
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
{
return multiply((a << 8) | a, b) >> 8;
}
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b) { return multiply((a << 8) | a, b) >> 8; }
//--------------------------------------------------------------------
// Interpolate p to q by a, assuming q is premultiplied by a.
static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a)
{
return p + q - multiply(p, a);
}
static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a) { return p + q - multiply(p, a); }
//--------------------------------------------------------------------
// Interpolate p to q by a.
@ -882,17 +841,16 @@ struct rgba16
//--------------------------------------------------------------------
AGG_INLINE self_type& opacity(double a_)
{
if (a_ < 0) a = 0;
if (a_ > 1) a = 1;
if (a_ < 0)
a = 0;
if (a_ > 1)
a = 1;
a = value_type(uround(a_ * double(base_mask)));
return *this;
}
//--------------------------------------------------------------------
double opacity() const
{
return double(a) / double(base_mask);
}
double opacity() const { return double(a) / double(base_mask); }
//--------------------------------------------------------------------
AGG_INLINE self_type& premultiply()
@ -1014,7 +972,7 @@ struct rgba16
}
//--------------------------------------------------------------------
static self_type no_color() { return self_type(0,0,0,0); }
static self_type no_color() { return self_type(0, 0, 0, 0); }
//--------------------------------------------------------------------
static self_type from_wavelength(double wl, double gamma = 1.0)
@ -1023,7 +981,6 @@ struct rgba16
}
};
//------------------------------------------------------rgba16_gamma_dir
template<class GammaLUT>
rgba16 rgba16_gamma_dir(rgba16 c, const GammaLUT& gamma)
@ -1055,59 +1012,63 @@ struct rgba32
rgba32() {}
//--------------------------------------------------------------------
rgba32(value_type r_, value_type g_, value_type b_, value_type a_= 1) :
r(r_), g(g_), b(b_), a(a_) {}
rgba32(value_type r_, value_type g_, value_type b_, value_type a_ = 1)
: r(r_)
, g(g_)
, b(b_)
, a(a_)
{}
//--------------------------------------------------------------------
rgba32(const self_type& c, float a_) :
r(c.r), g(c.g), b(c.b), a(a_) {}
rgba32(const self_type& c, float a_)
: r(c.r)
, g(c.g)
, b(c.b)
, a(a_)
{}
//--------------------------------------------------------------------
rgba32(const rgba& c) :
r(value_type(c.r)), g(value_type(c.g)), b(value_type(c.b)), a(value_type(c.a)) {}
rgba32(const rgba& c)
: r(value_type(c.r))
, g(value_type(c.g))
, b(value_type(c.b))
, a(value_type(c.a))
{}
//--------------------------------------------------------------------
rgba32(const rgba8& c) :
r(value_type(c.r / 255.0)),
g(value_type(c.g / 255.0)),
b(value_type(c.b / 255.0)),
a(value_type(c.a / 255.0)) {}
rgba32(const rgba8& c)
: r(value_type(c.r / 255.0))
, g(value_type(c.g / 255.0))
, b(value_type(c.b / 255.0))
, a(value_type(c.a / 255.0))
{}
//--------------------------------------------------------------------
rgba32(const srgba8& c) :
r(sRGB_conv<value_type>::rgb_from_sRGB(c.r)),
g(sRGB_conv<value_type>::rgb_from_sRGB(c.g)),
b(sRGB_conv<value_type>::rgb_from_sRGB(c.b)),
a(sRGB_conv<value_type>::alpha_from_sRGB(c.a)) {}
rgba32(const srgba8& c)
: r(sRGB_conv<value_type>::rgb_from_sRGB(c.r))
, g(sRGB_conv<value_type>::rgb_from_sRGB(c.g))
, b(sRGB_conv<value_type>::rgb_from_sRGB(c.b))
, a(sRGB_conv<value_type>::alpha_from_sRGB(c.a))
{}
//--------------------------------------------------------------------
rgba32(const rgba16& c) :
r(value_type(c.r / 65535.0)),
g(value_type(c.g / 65535.0)),
b(value_type(c.b / 65535.0)),
a(value_type(c.a / 65535.0)) {}
rgba32(const rgba16& c)
: r(value_type(c.r / 65535.0))
, g(value_type(c.g / 65535.0))
, b(value_type(c.b / 65535.0))
, a(value_type(c.a / 65535.0))
{}
//--------------------------------------------------------------------
operator rgba() const
{
return rgba(r, g, b, a);
}
operator rgba() const { return rgba(r, g, b, a); }
//--------------------------------------------------------------------
operator rgba8() const
{
return rgba8(
uround(r * 255.0),
uround(g * 255.0),
uround(b * 255.0),
uround(a * 255.0));
}
operator rgba8() const { return rgba8(uround(r * 255.0), uround(g * 255.0), uround(b * 255.0), uround(a * 255.0)); }
//--------------------------------------------------------------------
operator srgba8() const
{
return srgba8(
sRGB_conv<value_type>::rgb_to_sRGB(r),
return srgba8(sRGB_conv<value_type>::rgb_to_sRGB(r),
sRGB_conv<value_type>::rgb_to_sRGB(g),
sRGB_conv<value_type>::rgb_to_sRGB(b),
sRGB_conv<value_type>::alpha_to_sRGB(a));
@ -1116,66 +1077,35 @@ struct rgba32
//--------------------------------------------------------------------
operator rgba16() const
{
return rgba8(
uround(r * 65535.0),
uround(g * 65535.0),
uround(b * 65535.0),
uround(a * 65535.0));
return rgba8(uround(r * 65535.0), uround(g * 65535.0), uround(b * 65535.0), uround(a * 65535.0));
}
//--------------------------------------------------------------------
static AGG_INLINE double to_double(value_type a)
{
return a;
}
static AGG_INLINE double to_double(value_type a) { return a; }
//--------------------------------------------------------------------
static AGG_INLINE value_type from_double(double a)
{
return value_type(a);
}
static AGG_INLINE value_type from_double(double a) { return value_type(a); }
//--------------------------------------------------------------------
static AGG_INLINE value_type empty_value()
{
return 0;
}
static AGG_INLINE value_type empty_value() { return 0; }
//--------------------------------------------------------------------
static AGG_INLINE value_type full_value()
{
return 1;
}
static AGG_INLINE value_type full_value() { return 1; }
//--------------------------------------------------------------------
AGG_INLINE bool is_transparent() const
{
return a <= 0;
}
AGG_INLINE bool is_transparent() const { return a <= 0; }
//--------------------------------------------------------------------
AGG_INLINE bool is_opaque() const
{
return a >= 1;
}
AGG_INLINE bool is_opaque() const { return a >= 1; }
//--------------------------------------------------------------------
static AGG_INLINE value_type invert(value_type x)
{
return 1 - x;
}
static AGG_INLINE value_type invert(value_type x) { return 1 - x; }
//--------------------------------------------------------------------
static AGG_INLINE value_type multiply(value_type a, value_type b)
{
return value_type(a * b);
}
static AGG_INLINE value_type multiply(value_type a, value_type b) { return value_type(a * b); }
//--------------------------------------------------------------------
static AGG_INLINE value_type demultiply(value_type a, value_type b)
{
return (b == 0) ? 0 : value_type(a / b);
}
static AGG_INLINE value_type demultiply(value_type a, value_type b) { return (b == 0) ? 0 : value_type(a / b); }
//--------------------------------------------------------------------
template<typename T>
@ -1198,10 +1128,7 @@ struct rgba32
}
//--------------------------------------------------------------------
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
{
return cover_type(uround(a * b));
}
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b) { return cover_type(uround(a * b)); }
//--------------------------------------------------------------------
// Interpolate p to q by a, assuming q is premultiplied by a.
@ -1238,17 +1165,17 @@ struct rgba32
//--------------------------------------------------------------------
AGG_INLINE self_type& opacity(double a_)
{
if (a_ < 0) a = 0;
else if (a_ > 1) a = 1;
else a = value_type(a_);
if (a_ < 0)
a = 0;
else if (a_ > 1)
a = 1;
else
a = value_type(a_);
return *this;
}
//--------------------------------------------------------------------
double opacity() const
{
return a;
}
double opacity() const { return a; }
//--------------------------------------------------------------------
AGG_INLINE self_type& premultiply()
@ -1324,10 +1251,14 @@ struct rgba32
b += mult_cover(c.b, cover);
a += mult_cover(c.a, cover);
}
if (a > 1) a = 1;
if (r > a) r = a;
if (g > a) g = a;
if (b > a) b = a;
if (a > 1)
a = 1;
if (r > a)
r = a;
if (g > a)
g = a;
if (b > a)
b = a;
}
//--------------------------------------------------------------------
@ -1349,7 +1280,7 @@ struct rgba32
}
//--------------------------------------------------------------------
static self_type no_color() { return self_type(0,0,0,0); }
static self_type no_color() { return self_type(0, 0, 0, 0); }
//--------------------------------------------------------------------
static self_type from_wavelength(double wl, double gamma = 1)
@ -1357,8 +1288,6 @@ struct rgba32
return self_type(rgba::from_wavelength(wl, gamma));
}
};
}
} // namespace agg
#endif

1
deps/agg/include/agg_config.h vendored
View file

@ -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:
//

73
deps/agg/include/agg_conv_adaptor_vcgen.h vendored
View file

@ -18,11 +18,10 @@
#include "agg_basics.h"
namespace agg
namespace agg {
//------------------------------------------------------------null_markers
struct null_markers
{
//------------------------------------------------------------null_markers
struct null_markers
{
void remove_all() {}
void add_vertex(double, double, unsigned) {}
void prepare_src() {}
@ -30,28 +29,21 @@ namespace agg
void rewind(unsigned) {}
unsigned vertex(double*, double*) { return path_cmd_stop; }
unsigned type() const { return 0; }
};
};
//------------------------------------------------------conv_adaptor_vcgen
template<class VertexSource,
class Generator,
class Markers=null_markers> class conv_adaptor_vcgen
{
enum status
{
initial,
accumulate,
generate
};
//------------------------------------------------------conv_adaptor_vcgen
template<class VertexSource, class Generator, class Markers = null_markers>
class conv_adaptor_vcgen
{
enum status { initial, accumulate, generate };
public:
explicit conv_adaptor_vcgen(VertexSource& source) :
m_source(&source),
m_status(initial)
explicit conv_adaptor_vcgen(VertexSource& source)
: m_source(&source)
, m_status(initial)
{}
conv_adaptor_vcgen(conv_adaptor_vcgen<VertexSource, Generator, Markers> &&) = default;
conv_adaptor_vcgen(conv_adaptor_vcgen<VertexSource, Generator, Markers>&&) = default;
void attach(VertexSource& source) { m_source = &source; }
@ -74,7 +66,7 @@ namespace agg
// Prohibit copying
conv_adaptor_vcgen(const conv_adaptor_vcgen<VertexSource, Generator, Markers>&);
const conv_adaptor_vcgen<VertexSource, Generator, Markers>&
operator = (const conv_adaptor_vcgen<VertexSource, Generator, Markers>&);
operator=(const conv_adaptor_vcgen<VertexSource, Generator, Markers>&);
VertexSource* m_source;
Generator m_generator;
@ -83,21 +75,17 @@ namespace agg
unsigned m_last_cmd;
double m_start_x;
double m_start_y;
};
};
//------------------------------------------------------------------------
template<class VertexSource, class Generator, class Markers>
unsigned conv_adaptor_vcgen<VertexSource, Generator, Markers>::vertex(double* x, double* y)
{
//------------------------------------------------------------------------
template<class VertexSource, class Generator, class Markers>
unsigned conv_adaptor_vcgen<VertexSource, Generator, Markers>::vertex(double* x, double* y)
{
unsigned cmd = path_cmd_stop;
bool done = false;
while(!done)
while (!done)
{
switch(m_status)
switch (m_status)
{
case initial:
m_markers.remove_all();
@ -105,19 +93,20 @@ 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);
m_markers.add_vertex(m_start_x, m_start_y, path_cmd_move_to);
for(;;)
for (;;)
{
cmd = m_source->vertex(x, y);
if(is_vertex(cmd))
if (is_vertex(cmd))
{
m_last_cmd = cmd;
if(is_move_to(cmd))
if (is_move_to(cmd))
{
m_start_x = *x;
m_start_y = *y;
@ -128,12 +117,12 @@ namespace agg
}
else
{
if(is_stop(cmd))
if (is_stop(cmd))
{
m_last_cmd = path_cmd_stop;
break;
}
if(is_end_poly(cmd))
if (is_end_poly(cmd))
{
m_generator.add_vertex(*x, *y, cmd);
break;
@ -145,7 +134,7 @@ namespace agg
case generate:
cmd = m_generator.vertex(x, y);
if(is_stop(cmd))
if (is_stop(cmd))
{
m_status = accumulate;
break;
@ -155,8 +144,8 @@ namespace agg
}
}
return cmd;
}
}
} // namespace agg
#endif

78
deps/agg/include/agg_conv_adaptor_vpgen.h vendored
View file

@ -18,14 +18,16 @@
#include "agg_basics.h"
namespace agg
{
namespace agg {
//======================================================conv_adaptor_vpgen
template<class VertexSource, class VPGen> class conv_adaptor_vpgen
{
//======================================================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>&
operator = (const conv_adaptor_vpgen<VertexSource, VPGen>&);
const conv_adaptor_vpgen<VertexSource, VPGen>& operator=(const conv_adaptor_vpgen<VertexSource, VPGen>&);
VertexSource* m_source;
VPGen m_vpgen;
@ -46,34 +47,32 @@ namespace agg
double m_start_y;
unsigned m_poly_flags;
int m_vertices;
};
};
//------------------------------------------------------------------------
template<class VertexSource, class VPGen>
void conv_adaptor_vpgen<VertexSource, VPGen>::rewind(unsigned path_id)
{
//------------------------------------------------------------------------
template<class VertexSource, class VPGen>
void conv_adaptor_vpgen<VertexSource, VPGen>::rewind(unsigned path_id)
{
m_source->rewind(path_id);
m_vpgen.reset();
m_start_x = 0;
m_start_y = 0;
m_poly_flags = 0;
m_vertices = 0;
}
}
//------------------------------------------------------------------------
template<class VertexSource, class VPGen>
unsigned conv_adaptor_vpgen<VertexSource, VPGen>::vertex(double* x, double* y)
{
//------------------------------------------------------------------------
template<class VertexSource, class VPGen>
unsigned conv_adaptor_vpgen<VertexSource, VPGen>::vertex(double* x, double* y)
{
unsigned cmd = path_cmd_stop;
for(;;)
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())
if (m_poly_flags && !m_vpgen.auto_unclose())
{
*x = 0.0;
*y = 0.0;
@ -82,9 +81,9 @@ namespace agg
break;
}
if(m_vertices < 0)
if (m_vertices < 0)
{
if(m_vertices < -1)
if (m_vertices < -1)
{
m_vertices = 0;
return path_cmd_stop;
@ -96,15 +95,14 @@ namespace agg
double tx, ty;
cmd = m_source->vertex(&tx, &ty);
if(is_vertex(cmd))
if (is_vertex(cmd))
{
if(is_move_to(cmd))
if (is_move_to(cmd))
{
if(m_vpgen.auto_close() && m_vertices > 2)
if (m_vpgen.auto_close() && m_vertices > 2)
{
m_vpgen.line_to(m_start_x, m_start_y);
m_poly_flags = path_cmd_end_poly
| static_cast<path_commands_e>(path_flags_close);
m_poly_flags = path_cmd_end_poly | static_cast<path_commands_e>(path_flags_close);
m_start_x = tx;
m_start_y = ty;
m_vertices = -1;
@ -123,13 +121,14 @@ namespace agg
}
else
{
if(is_end_poly(cmd))
if (is_end_poly(cmd))
{
m_poly_flags = cmd;
if(is_closed(cmd) || m_vpgen.auto_close())
if (is_closed(cmd) || m_vpgen.auto_close())
{
if(m_vpgen.auto_close()) m_poly_flags |= path_flags_close;
if(m_vertices > 2)
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);
}
@ -139,11 +138,10 @@ namespace agg
else
{
// path_cmd_stop
if(m_vpgen.auto_close() && m_vertices > 2)
if (m_vpgen.auto_close() && m_vertices > 2)
{
m_vpgen.line_to(m_start_x, m_start_y);
m_poly_flags = path_cmd_end_poly
| static_cast<path_commands_e>(path_flags_close);
m_poly_flags = path_cmd_end_poly | static_cast<path_commands_e>(path_flags_close);
m_vertices = -2;
continue;
}
@ -152,10 +150,8 @@ namespace agg
}
}
return cmd;
}
}
} // namespace agg
#endif

24
deps/agg/include/agg_conv_bspline.h vendored
View file

@ -19,30 +19,26 @@
#include "agg_vcgen_bspline.h"
#include "agg_conv_adaptor_vcgen.h"
namespace agg {
namespace agg
//---------------------------------------------------------conv_bspline
template<class VertexSource>
struct conv_bspline : public conv_adaptor_vcgen<VertexSource, vcgen_bspline>
{
//---------------------------------------------------------conv_bspline
template<class VertexSource>
struct conv_bspline : public conv_adaptor_vcgen<VertexSource, vcgen_bspline>
{
typedef conv_adaptor_vcgen<VertexSource, vcgen_bspline> base_type;
conv_bspline(VertexSource& vs) :
conv_adaptor_vcgen<VertexSource, vcgen_bspline>(vs) {}
conv_bspline(VertexSource& 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>&
operator = (const conv_bspline<VertexSource>&);
};
}
const conv_bspline<VertexSource>& operator=(const conv_bspline<VertexSource>&);
};
} // namespace agg
#endif

28
deps/agg/include/agg_conv_clip_polygon.h vendored
View file

@ -30,22 +30,19 @@
#include "agg_conv_adaptor_vpgen.h"
#include "agg_vpgen_clip_polygon.h"
namespace agg
{
namespace agg {
//=======================================================conv_clip_polygon
template<class VertexSource>
struct conv_clip_polygon : public conv_adaptor_vpgen<VertexSource, vpgen_clip_polygon>
{
//=======================================================conv_clip_polygon
template<class VertexSource>
struct conv_clip_polygon : public conv_adaptor_vpgen<VertexSource, vpgen_clip_polygon>
{
typedef conv_adaptor_vpgen<VertexSource, vpgen_clip_polygon> base_type;
conv_clip_polygon(VertexSource& vs) :
conv_adaptor_vpgen<VertexSource, vpgen_clip_polygon>(vs) {}
conv_clip_polygon(VertexSource& vs)
: conv_adaptor_vpgen<VertexSource, vpgen_clip_polygon>(vs)
{}
void clip_box(double _x1, double _y1, double _x2, double _y2)
{
base_type::vpgen().clip_box(_x1, _y1, _x2, _y2);
}
void clip_box(double _x1, double _y1, double _x2, double _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>&
operator = (const conv_clip_polygon<VertexSource>&);
};
const conv_clip_polygon<VertexSource>& operator=(const conv_clip_polygon<VertexSource>&);
};
}
} // namespace agg
#endif

28
deps/agg/include/agg_conv_clip_polyline.h vendored
View file

@ -30,22 +30,19 @@
#include "agg_conv_adaptor_vpgen.h"
#include "agg_vpgen_clip_polyline.h"
namespace agg
{
namespace agg {
//=======================================================conv_clip_polyline
template<class VertexSource>
struct conv_clip_polyline : public conv_adaptor_vpgen<VertexSource, vpgen_clip_polyline>
{
//=======================================================conv_clip_polyline
template<class VertexSource>
struct conv_clip_polyline : public conv_adaptor_vpgen<VertexSource, vpgen_clip_polyline>
{
typedef conv_adaptor_vpgen<VertexSource, vpgen_clip_polyline> base_type;
conv_clip_polyline(VertexSource& vs) :
conv_adaptor_vpgen<VertexSource, vpgen_clip_polyline>(vs) {}
conv_clip_polyline(VertexSource& vs)
: conv_adaptor_vpgen<VertexSource, vpgen_clip_polyline>(vs)
{}
void clip_box(double _x1, double _y1, double _x2, double _y2)
{
base_type::vpgen().clip_box(_x1, _y1, _x2, _y2);
}
void clip_box(double _x1, double _y1, double _x2, double _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>&
operator = (const conv_clip_polyline<VertexSource>&);
};
const conv_clip_polyline<VertexSource>& operator=(const conv_clip_polyline<VertexSource>&);
};
}
} // namespace agg
#endif

61
deps/agg/include/agg_conv_close_polygon.h vendored
View file

@ -18,14 +18,16 @@
#include "agg_basics.h"
namespace agg
{
namespace agg {
//======================================================conv_close_polygon
template<class VertexSource> class conv_close_polygon
{
//======================================================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>&
operator = (const conv_close_polygon<VertexSource>&);
const conv_close_polygon<VertexSource>& operator=(const conv_close_polygon<VertexSource>&);
VertexSource* m_source;
unsigned m_cmd[2];
@ -42,29 +43,25 @@ namespace agg
double m_y[2];
unsigned m_vertex;
bool m_line_to;
};
};
//------------------------------------------------------------------------
template<class VertexSource>
void conv_close_polygon<VertexSource>::rewind(unsigned path_id)
{
//------------------------------------------------------------------------
template<class VertexSource>
void conv_close_polygon<VertexSource>::rewind(unsigned path_id)
{
m_source->rewind(path_id);
m_vertex = 2;
m_line_to = false;
}
}
//------------------------------------------------------------------------
template<class VertexSource>
unsigned conv_close_polygon<VertexSource>::vertex(double* x, double* y)
{
//------------------------------------------------------------------------
template<class VertexSource>
unsigned conv_close_polygon<VertexSource>::vertex(double* x, double* y)
{
unsigned cmd = path_cmd_stop;
for(;;)
for (;;)
{
if(m_vertex < 2)
if (m_vertex < 2)
{
*x = m_x[m_vertex];
*y = m_y[m_vertex];
@ -75,15 +72,15 @@ namespace agg
cmd = m_source->vertex(x, y);
if(is_end_poly(cmd))
if (is_end_poly(cmd))
{
cmd |= path_flags_close;
break;
}
if(is_stop(cmd))
if (is_stop(cmd))
{
if(m_line_to)
if (m_line_to)
{
m_cmd[0] = path_cmd_end_poly | path_flags_close;
m_cmd[1] = path_cmd_stop;
@ -94,9 +91,9 @@ namespace agg
break;
}
if(is_move_to(cmd))
if (is_move_to(cmd))
{
if(m_line_to)
if (m_line_to)
{
m_x[0] = 0.0;
m_y[0] = 0.0;
@ -111,15 +108,15 @@ namespace agg
break;
}
if(is_vertex(cmd))
if (is_vertex(cmd))
{
m_line_to = true;
break;
}
}
return cmd;
}
}
} // namespace agg
#endif

39
deps/agg/include/agg_conv_concat.h vendored
View file

@ -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
{
//=============================================================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
{
public:
conv_concat(VS1& source1, VS2& source2) :
m_source1(&source1), m_source2(&source2), m_status(2) {}
conv_concat(VS1& source1, VS2& source2)
: 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);
@ -42,16 +44,18 @@ namespace agg
unsigned vertex(double* x, double* y)
{
unsigned cmd;
if(m_status == 0)
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)
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>&
operator = (const conv_concat<VS1, VS2>&);
const conv_concat<VS1, VS2>& operator=(const conv_concat<VS1, VS2>&);
VS1* m_source1;
VS2* m_source2;
int m_status;
};
}
};
} // namespace agg
#endif

25
deps/agg/include/agg_conv_contour.h vendored
View file

@ -23,19 +23,17 @@
#include "agg_vcgen_contour.h"
#include "agg_conv_adaptor_vcgen.h"
namespace agg
{
namespace agg {
//-----------------------------------------------------------conv_contour
template<class VertexSource>
struct conv_contour : public conv_adaptor_vcgen<VertexSource, vcgen_contour>
{
//-----------------------------------------------------------conv_contour
template<class VertexSource>
struct conv_contour : public conv_adaptor_vcgen<VertexSource, vcgen_contour>
{
typedef conv_adaptor_vcgen<VertexSource, vcgen_contour> base_type;
conv_contour(VertexSource& vs) :
conv_adaptor_vcgen<VertexSource, vcgen_contour>(vs)
{
}
conv_contour(VertexSource& vs)
: conv_adaptor_vcgen<VertexSource, vcgen_contour>(vs)
{}
void line_join(line_join_e lj) { base_type::generator().line_join(lj); }
void inner_join(inner_join_e ij) { base_type::generator().inner_join(ij); }
@ -56,10 +54,9 @@ namespace agg
private:
conv_contour(const conv_contour<VertexSource>&);
const conv_contour<VertexSource>&
operator = (const conv_contour<VertexSource>&);
};
const conv_contour<VertexSource>& operator=(const conv_contour<VertexSource>&);
};
}
} // namespace agg
#endif

141
deps/agg/include/agg_conv_curve.h vendored
View file

@ -23,47 +23,47 @@
#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
// by their control points. There're two types of curves supported: curve3
// and curve4. Curve3 is a conic Bezier curve with 2 endpoints and 1 control
// point. Curve4 has 2 control points (4 points in total) and can be used
// to interpolate more complicated curves. Curve4, unlike curve3 can be used
// to approximate arcs, both circular and elliptical. Curves are approximated
// with straight lines and one of the approaches is just to store the whole
// sequence of vertices that approximate our curve. It takes additional
// memory, and at the same time the consecutive vertices can be calculated
// on demand.
//
// Initially, path storages are not suppose to keep all the vertices of the
// curves (although, nothing prevents us from doing so). Instead, path_storage
// keeps only vertices, needed to calculate a curve on demand. Those vertices
// are marked with special commands. So, if the path_storage contains curves
// (which are not real curves yet), and we render this storage directly,
// all we will see is only 2 or 3 straight line segments (for curve3 and
// curve4 respectively). If we need to see real curves drawn we need to
// include this class into the conversion pipeline.
//
// Class conv_curve recognizes commands path_cmd_curve3 and path_cmd_curve4
// and converts these vertices into a move_to/line_to sequence.
//-----------------------------------------------------------------------
template<class VertexSource, class Curve3 = curve3, class Curve4 = curve4>
class conv_curve
{
//---------------------------------------------------------------conv_curve
// Curve converter class. Any path storage can have Bezier curves defined
// by their control points. There're two types of curves supported: curve3
// and curve4. Curve3 is a conic Bezier curve with 2 endpoints and 1 control
// point. Curve4 has 2 control points (4 points in total) and can be used
// to interpolate more complicated curves. Curve4, unlike curve3 can be used
// to approximate arcs, both circular and elliptical. Curves are approximated
// with straight lines and one of the approaches is just to store the whole
// sequence of vertices that approximate our curve. It takes additional
// memory, and at the same time the consecutive vertices can be calculated
// on demand.
//
// Initially, path storages are not suppose to keep all the vertices of the
// curves (although, nothing prevents us from doing so). Instead, path_storage
// keeps only vertices, needed to calculate a curve on demand. Those vertices
// are marked with special commands. So, if the path_storage contains curves
// (which are not real curves yet), and we render this storage directly,
// all we will see is only 2 or 3 straight line segments (for curve3 and
// curve4 respectively). If we need to see real curves drawn we need to
// include this class into the conversion pipeline.
//
// Class conv_curve recognizes commands path_cmd_curve3 and path_cmd_curve4
// and converts these vertices into a move_to/line_to sequence.
//-----------------------------------------------------------------------
template<class VertexSource,
class Curve3=curve3,
class Curve4=curve4> class conv_curve
{
public:
typedef Curve3 curve3_type;
typedef Curve4 curve4_type;
typedef conv_curve<VertexSource, Curve3, Curve4> self_type;
explicit conv_curve(VertexSource& source) :
m_source(&source), m_last_x(0.0), m_last_y(0.0) {}
explicit conv_curve(VertexSource& source)
: m_source(&source)
, m_last_x(0.0)
, m_last_y(0.0)
{}
conv_curve(self_type &&) = default;
conv_curve(self_type&&) = default;
void attach(VertexSource& source) { m_source = &source; }
@ -73,10 +73,7 @@ namespace agg
m_curve4.approximation_method(v);
}
curve_approximation_method_e approximation_method() const
{
return m_curve4.approximation_method();
}
curve_approximation_method_e approximation_method() const { 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
{
return m_curve4.approximation_scale();
}
double approximation_scale() const { 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
{
return m_curve4.angle_tolerance();
}
double angle_tolerance() const { return m_curve4.angle_tolerance(); }
void cusp_limit(double v)
{
@ -106,71 +97,63 @@ namespace agg
m_curve4.cusp_limit(v);
}
double cusp_limit() const
{
return m_curve4.cusp_limit();
}
double cusp_limit() const { return m_curve4.cusp_limit(); }
void rewind(unsigned path_id);
unsigned vertex(double* x, double* y);
private:
conv_curve(const self_type&);
const self_type& operator = (const self_type&);
const self_type& operator=(const self_type&);
VertexSource* m_source;
double m_last_x;
double m_last_y;
curve3_type m_curve3;
curve4_type m_curve4;
};
};
//------------------------------------------------------------------------
template<class VertexSource, class Curve3, class Curve4>
void conv_curve<VertexSource, Curve3, Curve4>::rewind(unsigned path_id)
{
//------------------------------------------------------------------------
template<class VertexSource, class Curve3, class Curve4>
void conv_curve<VertexSource, Curve3, Curve4>::rewind(unsigned path_id)
{
m_source->rewind(path_id);
m_last_x = 0.0;
m_last_y = 0.0;
m_curve3.reset();
m_curve4.reset();
}
}
//------------------------------------------------------------------------
template<class VertexSource, class Curve3, class Curve4>
unsigned conv_curve<VertexSource, Curve3, Curve4>::vertex(double* x, double* y)
{
if(!is_stop(m_curve3.vertex(x, y)))
//------------------------------------------------------------------------
template<class VertexSource, class Curve3, class Curve4>
unsigned conv_curve<VertexSource, Curve3, Curve4>::vertex(double* x, double* y)
{
if (!is_stop(m_curve3.vertex(x, y)))
{
m_last_x = *x;
m_last_y = *y;
return path_cmd_line_to;
}
if(!is_stop(m_curve4.vertex(x, y)))
if (!is_stop(m_curve4.vertex(x, y)))
{
m_last_x = *x;
m_last_y = *y;
return path_cmd_line_to;
}
double ct2_x=0;
double ct2_y=0;
double end_x=0;
double end_y=0;
double ct2_x = 0;
double ct2_y = 0;
double end_x = 0;
double end_y = 0;
unsigned cmd = m_source->vertex(x, y);
switch(cmd)
switch (cmd)
{
case path_cmd_curve3:
m_source->vertex(&end_x, &end_y);
m_curve3.init(m_last_x, m_last_y,
*x, *y,
end_x, end_y);
m_curve3.init(m_last_x, m_last_y, *x, *y, end_x, end_y);
m_curve3.vertex(x, y); // First call returns path_cmd_move_to
m_curve3.vertex(x, y); // This is the first vertex of the curve
@ -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,
*x, *y,
ct2_x, ct2_y,
end_x, end_y);
m_curve4.init(m_last_x, m_last_y, *x, *y, ct2_x, ct2_y, end_x, end_y);
m_curve4.vertex(x, y); // First call returns path_cmd_move_to
m_curve4.vertex(x, y); // This is the first vertex of the curve
@ -194,11 +174,8 @@ namespace agg
m_last_x = *x;
m_last_y = *y;
return cmd;
}
}
} // namespace agg
#endif

41
deps/agg/include/agg_conv_dash.h vendored
View file

@ -23,46 +23,33 @@
#include "agg_vcgen_dash.h"
#include "agg_conv_adaptor_vcgen.h"
namespace agg
{
namespace agg {
//---------------------------------------------------------------conv_dash
template<class VertexSource, class Markers=null_markers>
struct conv_dash : public conv_adaptor_vcgen<VertexSource, vcgen_dash, Markers>
{
//---------------------------------------------------------------conv_dash
template<class VertexSource, class Markers = null_markers>
struct conv_dash : public conv_adaptor_vcgen<VertexSource, vcgen_dash, Markers>
{
typedef Markers marker_type;
typedef conv_adaptor_vcgen<VertexSource, vcgen_dash, Markers> base_type;
conv_dash(VertexSource& vs) :
conv_adaptor_vcgen<VertexSource, vcgen_dash, Markers>(vs)
{
}
conv_dash(VertexSource& vs)
: conv_adaptor_vcgen<VertexSource, vcgen_dash, Markers>(vs)
{}
void remove_all_dashes()
{
base_type::generator().remove_all_dashes();
}
void remove_all_dashes() { base_type::generator().remove_all_dashes(); }
void add_dash(double dash_len, double gap_len)
{
base_type::generator().add_dash(dash_len, gap_len);
}
void add_dash(double dash_len, double gap_len) { base_type::generator().add_dash(dash_len, gap_len); }
void dash_start(double ds)
{
base_type::generator().dash_start(ds);
}
void dash_start(double ds) { base_type::generator().dash_start(ds); }
void shorten(double s) { base_type::generator().shorten(s); }
double shorten() const { return base_type::generator().shorten(); }
private:
conv_dash(const conv_dash<VertexSource, Markers>&);
const conv_dash<VertexSource, Markers>&
operator = (const conv_dash<VertexSource, Markers>&);
};
const conv_dash<VertexSource, Markers>& operator=(const conv_dash<VertexSource, Markers>&);
};
}
} // namespace agg
#endif

271
deps/agg/include/agg_conv_gpc.h vendored
View file

@ -28,32 +28,18 @@
#include "agg_basics.h"
#include "agg_array.h"
extern "C"
{
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 };
//================================================================conv_gpc
template<class VSA, class VSB>
class conv_gpc
{
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
{
enum status
{
status_move_to,
status_line_to,
status_stop
};
enum status { status_move_to, status_line_to, status_stop };
struct contour_header_type
{
@ -65,24 +51,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()
{
free_gpc_data();
}
~conv_gpc() { free_gpc_data(); }
conv_gpc(source_a_type& a, source_b_type& b, gpc_op_e op = gpc_or) :
m_src_a(&a),
m_src_b(&b),
m_status(status_move_to),
m_vertex(-1),
m_contour(-1),
m_operation(op)
conv_gpc(source_a_type& a, source_b_type& b, gpc_op_e op = gpc_or)
: m_src_a(&a)
, m_src_b(&b)
, m_status(status_move_to)
, m_vertex(-1)
, m_contour(-1)
, m_operation(op)
{
memset(&m_poly_a, 0, sizeof(m_poly_a));
memset(&m_poly_b, 0, sizeof(m_poly_b));
@ -100,7 +82,7 @@ namespace agg
private:
conv_gpc(const conv_gpc<VSA, VSB>&);
const conv_gpc<VSA, VSB>& operator = (const conv_gpc<VSA, VSB>&);
const conv_gpc<VSA, VSB>& operator=(const conv_gpc<VSA, VSB>&);
//--------------------------------------------------------------------
void free_polygon(gpc_polygon& p);
@ -114,9 +96,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;
@ -127,13 +109,13 @@ namespace agg
m_contour_accumulator.remove_all();
while(!is_stop(cmd = src.vertex(&x, &y)))
while (!is_stop(cmd = src.vertex(&x, &y)))
{
if(is_vertex(cmd))
if (is_vertex(cmd))
{
if(is_move_to(cmd))
if (is_move_to(cmd))
{
if(line_to)
if (line_to)
{
end_contour(orientation);
orientation = 0;
@ -147,24 +129,23 @@ namespace agg
}
else
{
if(is_end_poly(cmd))
if (is_end_poly(cmd))
{
orientation = get_orientation(cmd);
if(line_to && is_closed(cmd))
if (line_to && is_closed(cmd))
{
add_vertex(start_x, start_y);
}
}
}
}
if(line_to)
if (line_to)
{
end_contour(orientation);
}
make_polygon(p);
}
private:
//--------------------------------------------------------------------
source_a_type* m_src_a;
@ -178,92 +159,81 @@ namespace agg
gpc_polygon m_poly_a;
gpc_polygon m_poly_b;
gpc_polygon m_result;
};
};
//------------------------------------------------------------------------
template<class VSA, class VSB>
void conv_gpc<VSA, VSB>::free_polygon(gpc_polygon& p)
{
//------------------------------------------------------------------------
template<class VSA, class VSB>
void conv_gpc<VSA, VSB>::free_polygon(gpc_polygon& p)
{
int i;
for(i = 0; i < p.num_contours; i++)
for (i = 0; i < p.num_contours; i++)
{
pod_allocator<gpc_vertex>::deallocate(p.contour[i].vertex,
p.contour[i].num_vertices);
pod_allocator<gpc_vertex>::deallocate(p.contour[i].vertex, 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()
{
if(m_result.contour)
//------------------------------------------------------------------------
template<class VSA, class VSB>
void conv_gpc<VSA, VSB>::free_result()
{
if (m_result.contour)
{
gpc_free_polygon(&m_result);
}
memset(&m_result, 0, sizeof(m_result));
}
}
//------------------------------------------------------------------------
template<class VSA, class VSB>
void conv_gpc<VSA, VSB>::free_gpc_data()
{
//------------------------------------------------------------------------
template<class VSA, class VSB>
void conv_gpc<VSA, VSB>::free_gpc_data()
{
free_polygon(m_poly_a);
free_polygon(m_poly_b);
free_result();
}
}
//------------------------------------------------------------------------
template<class VSA, class VSB>
void conv_gpc<VSA, VSB>::start_contour()
{
//------------------------------------------------------------------------
template<class VSA, class VSB>
void conv_gpc<VSA, VSB>::start_contour()
{
contour_header_type h;
memset(&h, 0, sizeof(h));
m_contour_accumulator.add(h);
m_vertex_accumulator.remove_all();
}
}
//------------------------------------------------------------------------
template<class VSA, class VSB>
inline void conv_gpc<VSA, VSB>::add_vertex(double x, double y)
{
//------------------------------------------------------------------------
template<class VSA, class VSB>
inline void conv_gpc<VSA, VSB>::add_vertex(double x, double y)
{
gpc_vertex v;
v.x = x;
v.y = y;
m_vertex_accumulator.add(v);
}
}
//------------------------------------------------------------------------
template<class VSA, class VSB>
void conv_gpc<VSA, VSB>::end_contour(unsigned orientation)
//------------------------------------------------------------------------
template<class VSA, class VSB>
void conv_gpc<VSA, VSB>::end_contour(unsigned orientation)
{
if (m_contour_accumulator.size())
{
if(m_contour_accumulator.size())
if (m_vertex_accumulator.size() > 2)
{
if(m_vertex_accumulator.size() > 2)
{
contour_header_type& h =
m_contour_accumulator[m_contour_accumulator.size() - 1];
contour_header_type& h = m_contour_accumulator[m_contour_accumulator.size() - 1];
h.num_vertices = m_vertex_accumulator.size();
h.hole_flag = 0;
// TO DO: Clarify the "holes"
//if(is_cw(orientation)) h.hole_flag = 1;
// if(is_cw(orientation)) h.hole_flag = 1;
h.vertices = pod_allocator<gpc_vertex>::allocate(h.num_vertices);
gpc_vertex* d = h.vertices;
int i;
for(i = 0; i < h.num_vertices; i++)
for (i = 0; i < h.num_vertices; i++)
{
const gpc_vertex& s = m_vertex_accumulator[i];
d->x = s.x;
@ -276,15 +246,14 @@ namespace agg
m_vertex_accumulator.remove_last();
}
}
}
}
//------------------------------------------------------------------------
template<class VSA, class VSB>
void conv_gpc<VSA, VSB>::make_polygon(gpc_polygon& p)
{
//------------------------------------------------------------------------
template<class VSA, class VSB>
void conv_gpc<VSA, VSB>::make_polygon(gpc_polygon& p)
{
free_polygon(p);
if(m_contour_accumulator.size())
if (m_contour_accumulator.size())
{
p.num_contours = m_contour_accumulator.size();
@ -293,7 +262,7 @@ namespace agg
int i;
gpc_vertex_list* pv = p.contour;
for(i = 0; i < p.num_contours; i++)
for (i = 0; i < p.num_contours; i++)
{
const contour_header_type& h = m_contour_accumulator[i];
pv->num_vertices = h.num_vertices;
@ -301,38 +270,35 @@ namespace agg
++pv;
}
}
}
}
//------------------------------------------------------------------------
template<class VSA, class VSB>
void conv_gpc<VSA, VSB>::start_extracting()
{
//------------------------------------------------------------------------
template<class VSA, class VSB>
void conv_gpc<VSA, VSB>::start_extracting()
{
m_status = status_move_to;
m_contour = -1;
m_vertex = -1;
}
}
//------------------------------------------------------------------------
template<class VSA, class VSB>
bool conv_gpc<VSA, VSB>::next_contour()
{
if(++m_contour < m_result.num_contours)
//------------------------------------------------------------------------
template<class VSA, class VSB>
bool conv_gpc<VSA, VSB>::next_contour()
{
if (++m_contour < m_result.num_contours)
{
m_vertex = -1;
return true;
}
return false;
}
}
//------------------------------------------------------------------------
template<class VSA, class VSB>
inline bool conv_gpc<VSA, VSB>::next_vertex(double* x, double* y)
{
//------------------------------------------------------------------------
template<class VSA, class VSB>
inline bool conv_gpc<VSA, VSB>::next_vertex(double* x, double* y)
{
const gpc_vertex_list& vlist = m_result.contour[m_contour];
if(++m_vertex < vlist.num_vertices)
if (++m_vertex < vlist.num_vertices)
{
const gpc_vertex& v = vlist.vertex[m_vertex];
*x = v.x;
@ -340,68 +306,51 @@ namespace agg
return true;
}
return false;
}
}
//------------------------------------------------------------------------
template<class VSA, class VSB>
void conv_gpc<VSA, VSB>::rewind(unsigned path_id)
{
//------------------------------------------------------------------------
template<class VSA, class VSB>
void conv_gpc<VSA, VSB>::rewind(unsigned path_id)
{
free_result();
m_src_a->rewind(path_id);
m_src_b->rewind(path_id);
add(*m_src_a, m_poly_a);
add(*m_src_b, m_poly_b);
switch(m_operation)
switch (m_operation)
{
case gpc_or:
gpc_polygon_clip(GPC_UNION,
&m_poly_a,
&m_poly_b,
&m_result);
gpc_polygon_clip(GPC_UNION, &m_poly_a, &m_poly_b, &m_result);
break;
case gpc_and:
gpc_polygon_clip(GPC_INT,
&m_poly_a,
&m_poly_b,
&m_result);
gpc_polygon_clip(GPC_INT, &m_poly_a, &m_poly_b, &m_result);
break;
case gpc_xor:
gpc_polygon_clip(GPC_XOR,
&m_poly_a,
&m_poly_b,
&m_result);
gpc_polygon_clip(GPC_XOR, &m_poly_a, &m_poly_b, &m_result);
break;
case gpc_a_minus_b:
gpc_polygon_clip(GPC_DIFF,
&m_poly_a,
&m_poly_b,
&m_result);
gpc_polygon_clip(GPC_DIFF, &m_poly_a, &m_poly_b, &m_result);
break;
case gpc_b_minus_a:
gpc_polygon_clip(GPC_DIFF,
&m_poly_b,
&m_poly_a,
&m_result);
gpc_polygon_clip(GPC_DIFF, &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)
//------------------------------------------------------------------------
template<class VSA, class VSB>
unsigned conv_gpc<VSA, VSB>::vertex(double* x, double* y)
{
if (m_status == status_move_to)
{
if(m_status == status_move_to)
if (next_contour())
{
if(next_contour())
{
if(next_vertex(x, y))
if (next_vertex(x, y))
{
m_status = status_line_to;
return path_cmd_move_to;
@ -412,7 +361,7 @@ namespace agg
}
else
{
if(next_vertex(x, y))
if (next_vertex(x, y))
{
return path_cmd_line_to;
}
@ -423,10 +372,8 @@ namespace agg
return path_cmd_end_poly | path_flags_close;
}
return path_cmd_stop;
}
}
} // namespace agg
#endif

78
deps/agg/include/agg_conv_marker.h vendored
View file

@ -22,12 +22,11 @@
#include "agg_basics.h"
#include "agg_trans_affine.h"
namespace agg
namespace agg {
//-------------------------------------------------------------conv_marker
template<class MarkerLocator, class MarkerShapes>
class conv_marker
{
//-------------------------------------------------------------conv_marker
template<class MarkerLocator, class MarkerShapes>
class conv_marker
{
public:
conv_marker(MarkerLocator& ml, MarkerShapes& ms);
@ -39,16 +38,9 @@ namespace agg
private:
conv_marker(const conv_marker<MarkerLocator, MarkerShapes>&);
const conv_marker<MarkerLocator, MarkerShapes>&
operator = (const conv_marker<MarkerLocator, MarkerShapes>&);
const conv_marker<MarkerLocator, MarkerShapes>& operator=(const conv_marker<MarkerLocator, MarkerShapes>&);
enum status_e
{
initial,
markers,
polygon,
stop
};
enum status_e { initial, markers, polygon, stop };
MarkerLocator* m_marker_locator;
MarkerShapes* m_marker_shapes;
@ -57,44 +49,40 @@ namespace agg
status_e m_status;
unsigned m_marker;
unsigned m_num_markers;
};
};
//------------------------------------------------------------------------
template<class MarkerLocator, class MarkerShapes>
conv_marker<MarkerLocator, MarkerShapes>::conv_marker(MarkerLocator& ml, MarkerShapes& ms)
: m_marker_locator(&ml)
, m_marker_shapes(&ms)
, m_status(initial)
, m_marker(0)
, m_num_markers(1)
{}
//------------------------------------------------------------------------
template<class MarkerLocator, class MarkerShapes>
conv_marker<MarkerLocator, MarkerShapes>::conv_marker(MarkerLocator& ml, MarkerShapes& ms) :
m_marker_locator(&ml),
m_marker_shapes(&ms),
m_status(initial),
m_marker(0),
m_num_markers(1)
{
}
//------------------------------------------------------------------------
template<class MarkerLocator, class MarkerShapes>
void conv_marker<MarkerLocator, MarkerShapes>::rewind(unsigned)
{
//------------------------------------------------------------------------
template<class MarkerLocator, class MarkerShapes>
void conv_marker<MarkerLocator, MarkerShapes>::rewind(unsigned)
{
m_status = initial;
m_marker = 0;
m_num_markers = 1;
}
}
//------------------------------------------------------------------------
template<class MarkerLocator, class MarkerShapes>
unsigned conv_marker<MarkerLocator, MarkerShapes>::vertex(double* x, double* y)
{
//------------------------------------------------------------------------
template<class MarkerLocator, class MarkerShapes>
unsigned conv_marker<MarkerLocator, MarkerShapes>::vertex(double* x, double* y)
{
unsigned cmd = path_cmd_move_to;
double x1, y1, x2, y2;
while(!is_stop(cmd))
while (!is_stop(cmd))
{
switch(m_status)
switch (m_status)
{
case initial:
if(m_num_markers == 0)
if (m_num_markers == 0)
{
cmd = path_cmd_stop;
break;
@ -105,12 +93,12 @@ namespace agg
m_status = markers;
case markers:
if(is_stop(m_marker_locator->vertex(&x1, &y1)))
if (is_stop(m_marker_locator->vertex(&x1, &y1)))
{
m_status = initial;
break;
}
if(is_stop(m_marker_locator->vertex(&x2, &y2)))
if (is_stop(m_marker_locator->vertex(&x2, &y2)))
{
m_status = initial;
break;
@ -124,7 +112,7 @@ namespace agg
case polygon:
cmd = m_marker_shapes->vertex(x, y);
if(is_stop(cmd))
if (is_stop(cmd))
{
cmd = path_cmd_move_to;
m_status = markers;
@ -139,10 +127,8 @@ namespace agg
}
}
return cmd;
}
}
} // namespace agg
#endif

27
deps/agg/include/agg_conv_marker_adaptor.h vendored
View file

@ -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 :
public conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence, Markers>
{
//=====================================================conv_marker_adaptor
template<class VertexSource, class Markers = null_markers>
struct conv_marker_adaptor : 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_adaptor_vcgen<VertexSource, vcgen_vertex_sequence, Markers>(vs)
{
}
conv_marker_adaptor(VertexSource& 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>&
operator = (const conv_marker_adaptor<VertexSource, Markers>&);
};
const conv_marker_adaptor<VertexSource, Markers>& operator=(const conv_marker_adaptor<VertexSource, Markers>&);
};
}
} // namespace agg
#endif

133
deps/agg/include/agg_conv_offset.h vendored
View file

@ -22,16 +22,16 @@
#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;
typedef conv_offset<source_a_type> self_type;
private:
private:
source_a_type* m_src_a;
double m_offset;
status m_status;
@ -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,
int scaling_factor = 0)
: m_src_a(&a),
m_offset(offset),
m_status(status_move_to),
m_vertex(-1),
m_contour(-1)
public:
conv_offset(source_a_type& a, double offset = 0.0, int scaling_factor = 0)
: m_src_a(&a)
, m_offset(offset)
, m_status(status_move_to)
, m_vertex(-1)
, m_contour(-1)
{
m_scaling_factor = std::max(std::min(scaling_factor, 6),0);
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
{
return static_cast<unsigned>(m_src_a->type());
}
void set_offset(double offset) { m_offset = offset; }
unsigned type() const { return static_cast<unsigned>(m_src_a->type()); }
double get_offset() const
{
return m_offset;
}
double get_offset() const { return m_offset; }
void rewind(unsigned path_id);
unsigned vertex(double* x, double* y);
@ -82,13 +76,17 @@ public:
bool next_contour();
bool next_vertex(double* x, double* y);
void start_extracting();
void add_vertex_(double &x, double &y);
void end_contour(ClipperLib::Paths &p);
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;
@ -96,26 +94,27 @@ public:
starting_first_line = true;
p.resize(0);
cmd = src->vertex( &x , &y );
while(!is_stop(cmd))
cmd = src->vertex(&x, &y);
while (!is_stop(cmd))
{
if(is_vertex(cmd))
if (is_vertex(cmd))
{
if(is_move_to(cmd))
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;
}
add_vertex_( x, y );
add_vertex_(x, y);
starting_first_line = false;
}
else if(is_end_poly(cmd))
else if (is_end_poly(cmd))
{
if(!starting_first_line && is_closed(cmd))
add_vertex_( start_x, start_y );
if (!starting_first_line && is_closed(cmd))
add_vertex_(start_x, start_y);
}
cmd = src->vertex( &x, &y );
cmd = src->vertex(&x, &y);
}
end_contour(p);
}
@ -135,42 +134,43 @@ void conv_offset<VSA>::start_extracting()
template<class VSA>
void conv_offset<VSA>::rewind(unsigned path_id)
{
m_src_a->rewind( path_id );
//m_src_b->rewind( path_id );
m_src_a->rewind(path_id);
// m_src_b->rewind( path_id );
add( m_src_a , m_poly_a );
//add( m_src_b , m_poly_b );
add(m_src_a, m_poly_a);
// add( m_src_b , m_poly_b );
m_result.resize(0);
m_clipper_offset.Clear();
m_clipper_offset.AddPaths(m_poly_a,ClipperLib::jtMiter, ClipperLib::etOpenButt);//ClosedLine);//Polygon);
m_clipper_offset.AddPaths(m_poly_a, ClipperLib::jtMiter, ClipperLib::etOpenButt); // ClosedLine);//Polygon);
m_clipper_offset.Execute(m_result, m_offset * m_scaling_factor);
start_extracting();
}
//------------------------------------------------------------------------------
template<class VSA>
void conv_offset<VSA>::end_contour( ClipperLib::Paths &p)
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.resize(len + 1);
p[len].resize(m_vertex_accumulator.size());
for( i = 0 ; i < m_vertex_accumulator.size() ; i++ )
for (i = 0; i < m_vertex_accumulator.size(); i++)
p[len][i] = m_vertex_accumulator[i];
m_vertex_accumulator.remove_all();
}
//------------------------------------------------------------------------------
template<class VSA>
void conv_offset<VSA>::add_vertex_(double &x, double &y)
void conv_offset<VSA>::add_vertex_(double& x, double& y)
{
ClipperLib::IntPoint v;
v.X = Round(x * m_scaling_factor);
v.Y = Round(y * m_scaling_factor);
m_vertex_accumulator.add( v );
m_vertex_accumulator.add(v);
}
//------------------------------------------------------------------------------
@ -178,33 +178,35 @@ template<class VSA>
bool conv_offset<VSA>::next_contour()
{
m_contour++;
if(m_contour >= (int)m_result.size()) return false;
m_vertex =-1;
if (m_contour >= (int)m_result.size())
return false;
m_vertex = -1;
return true;
}
//------------------------------------------------------------------------------
template<class VSA>
bool conv_offset<VSA>::next_vertex(double *x, double *y)
bool conv_offset<VSA>::next_vertex(double* x, double* y)
{
m_vertex++;
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;
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;
}
//------------------------------------------------------------------------------
template<class VSA>
unsigned conv_offset<VSA>::vertex(double *x, double *y)
unsigned conv_offset<VSA>::vertex(double* x, double* y)
{
if( m_status == status_move_to )
if (m_status == status_move_to)
{
if( next_contour() )
if (next_contour())
{
if( next_vertex( x, y ) )
if (next_vertex(x, y))
{
m_status =status_line_to;
m_status = status_line_to;
return path_cmd_move_to;
}
else
@ -218,7 +220,7 @@ unsigned conv_offset<VSA>::vertex(double *x, double *y)
}
else
{
if( next_vertex( x, y ) )
if (next_vertex(x, y))
{
return path_cmd_line_to;
}
@ -231,6 +233,5 @@ unsigned conv_offset<VSA>::vertex(double *x, double *y)
}
//------------------------------------------------------------------------------
} //namespace agg
#endif //AGG_CONV_OFFSET_INCLUDED
} // namespace agg
#endif // AGG_CONV_OFFSET_INCLUDED

25
deps/agg/include/agg_conv_segmentator.h vendored
View file

@ -20,29 +20,26 @@
#include "agg_conv_adaptor_vpgen.h"
#include "agg_vpgen_segmentator.h"
namespace agg
{
namespace agg {
//========================================================conv_segmentator
template<class VertexSource>
struct conv_segmentator : public conv_adaptor_vpgen<VertexSource, vpgen_segmentator>
{
//========================================================conv_segmentator
template<class VertexSource>
struct conv_segmentator : public conv_adaptor_vpgen<VertexSource, vpgen_segmentator>
{
typedef conv_adaptor_vpgen<VertexSource, vpgen_segmentator> base_type;
conv_segmentator(VertexSource& vs) :
conv_adaptor_vpgen<VertexSource, vpgen_segmentator>(vs) {}
conv_segmentator(VertexSource& vs)
: conv_adaptor_vpgen<VertexSource, vpgen_segmentator>(vs)
{}
void approximation_scale(double s) { base_type::vpgen().approximation_scale(s); }
double approximation_scale() const { return base_type::vpgen().approximation_scale(); }
private:
conv_segmentator(const conv_segmentator<VertexSource>&);
const conv_segmentator<VertexSource>&
operator = (const conv_segmentator<VertexSource>&);
};
const conv_segmentator<VertexSource>& operator=(const conv_segmentator<VertexSource>&);
};
}
} // namespace agg
#endif

26
deps/agg/include/agg_conv_shorten_path.h vendored
View file

@ -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 :
public conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence>
{
//=======================================================conv_shorten_path
template<class VertexSource>
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_adaptor_vcgen<VertexSource, vcgen_vertex_sequence>(vs)
{
}
conv_shorten_path(VertexSource& 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>&
operator = (const conv_shorten_path<VertexSource>&);
};
const conv_shorten_path<VertexSource>& operator=(const conv_shorten_path<VertexSource>&);
};
}
} // namespace agg
#endif

64
deps/agg/include/agg_conv_smooth_poly1.h vendored
View file

@ -24,57 +24,51 @@
#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 : public conv_adaptor_vcgen<VertexSource, VertexGenerator>
{
//-------------------------------------------------------conv_smooth
template<class VertexSource, class VertexGenerator>
struct conv_smooth :
public conv_adaptor_vcgen<VertexSource, VertexGenerator>
{
typedef conv_adaptor_vcgen<VertexSource, VertexGenerator> base_type;
conv_smooth(VertexSource& vs) :
conv_adaptor_vcgen<VertexSource, VertexGenerator>(vs)
{
}
conv_smooth(VertexSource& vs)
: conv_adaptor_vcgen<VertexSource, VertexGenerator>(vs)
{}
conv_smooth(conv_smooth<VertexSource, VertexGenerator> &&) = default;
conv_smooth(conv_smooth<VertexSource, VertexGenerator>&&) = default;
conv_smooth(const conv_smooth<VertexSource, VertexGenerator>&) = delete;
const conv_smooth<VertexSource, VertexGenerator>&
operator = (const conv_smooth<VertexSource, VertexGenerator>&) = delete;
operator=(const conv_smooth<VertexSource, VertexGenerator>&) = delete;
void smooth_value(double v) { base_type::generator().smooth_value(v); }
double smooth_value() const { return base_type::generator().smooth_value(); }
unsigned type() const { return base_type::type(); }
};
};
template<class VertexSource>
using conv_smooth_poly1 = conv_smooth<VertexSource, vcgen_smooth_poly1>;
template<class VertexSource>
using conv_smooth_poly1 = conv_smooth<VertexSource, vcgen_smooth_poly1>;
//-------------------------------------------------conv_smooth_curve
template<class VertexSource, class VertexGenerator>
struct conv_smooth_curve :
public conv_curve<conv_smooth<VertexSource, VertexGenerator>>
{
conv_smooth_curve(VertexSource& vs) :
conv_curve<conv_smooth<VertexSource, VertexGenerator>>(m_smooth),
m_smooth(vs)
{
}
//-------------------------------------------------conv_smooth_curve
template<class VertexSource, class VertexGenerator>
struct conv_smooth_curve : public conv_curve<conv_smooth<VertexSource, VertexGenerator>>
{
conv_smooth_curve(VertexSource& vs)
: conv_curve<conv_smooth<VertexSource, VertexGenerator>>(m_smooth)
, m_smooth(vs)
{}
conv_smooth_curve(conv_smooth_curve<VertexSource, VertexGenerator> && rhs) :
conv_curve<conv_smooth<VertexSource, VertexGenerator>>(std::move(rhs)),
m_smooth(std::move(rhs.m_smooth))
conv_smooth_curve(conv_smooth_curve<VertexSource, VertexGenerator>&& rhs)
: conv_curve<conv_smooth<VertexSource, VertexGenerator>>(std::move(rhs))
, m_smooth(std::move(rhs.m_smooth))
{
this->attach(m_smooth);
}
conv_smooth_curve(const conv_smooth_curve<VertexSource, VertexGenerator>&) = delete;
const conv_smooth_curve<VertexSource, VertexGenerator>&
operator = (const conv_smooth_curve<VertexSource, VertexGenerator>&) = delete;
operator=(const conv_smooth_curve<VertexSource, VertexGenerator>&) = delete;
void smooth_value(double v) { m_smooth.generator().smooth_value(v); }
double smooth_value() const { return m_smooth.generator().smooth_value(); }
@ -82,12 +76,10 @@ namespace agg
private:
conv_smooth<VertexSource, VertexGenerator> m_smooth;
};
template<class VertexSource>
using conv_smooth_poly1_curve = conv_smooth_curve<VertexSource, vcgen_smooth_poly1>;
}
};
template<class VertexSource>
using conv_smooth_poly1_curve = conv_smooth_curve<VertexSource, vcgen_smooth_poly1>;
} // namespace agg
#endif

27
deps/agg/include/agg_conv_stroke.h vendored
View file

@ -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 :
public conv_adaptor_vcgen<VertexSource, vcgen_stroke, Markers>
{
//-------------------------------------------------------------conv_stroke
template<class VertexSource, class Markers = null_markers>
struct conv_stroke : public conv_adaptor_vcgen<VertexSource, vcgen_stroke, Markers>
{
typedef Markers marker_type;
typedef conv_adaptor_vcgen<VertexSource, vcgen_stroke, Markers> base_type;
conv_stroke(VertexSource& vs) :
conv_adaptor_vcgen<VertexSource, vcgen_stroke, Markers>(vs)
{
}
conv_stroke(VertexSource& vs)
: conv_adaptor_vcgen<VertexSource, vcgen_stroke, Markers>(vs)
{}
void line_cap(line_cap_e lc) { base_type::generator().line_cap(lc); }
void line_join(line_join_e lj) { base_type::generator().line_join(lj); }
@ -63,11 +60,9 @@ namespace agg
private:
conv_stroke(const conv_stroke<VertexSource, Markers>&);
const conv_stroke<VertexSource, Markers>&
operator = (const conv_stroke<VertexSource, Markers>&);
const conv_stroke<VertexSource, Markers>& operator=(const conv_stroke<VertexSource, Markers>&);
};
};
}
} // namespace agg
#endif

36
deps/agg/include/agg_conv_transform.h vendored
View file

@ -22,50 +22,44 @@
#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
{
//----------------------------------------------------------conv_transform
template<class VertexSource, class Transformer = trans_affine>
class conv_transform
{
public:
conv_transform(VertexSource& source, Transformer& tr) :
m_source(&source), m_trans(&tr) {}
conv_transform(VertexSource& source, Transformer& tr)
: m_source(&source)
, m_trans(&tr)
{}
void attach(VertexSource& source) { m_source = &source; }
void rewind(unsigned path_id)
{
m_source->rewind(path_id);
}
void rewind(unsigned path_id) { m_source->rewind(path_id); }
unsigned vertex(double* x, double* y)
{
unsigned cmd = m_source->vertex(x, y);
if(is_vertex(cmd))
if (is_vertex(cmd))
{
m_trans->transform(x, y);
}
return cmd;
}
void transformer(Transformer& tr)
{
m_trans = &tr;
}
void transformer(Transformer& tr) { m_trans = &tr; }
unsigned type() const { return m_source->type(); }
private:
conv_transform(const conv_transform<VertexSource>&);
const conv_transform<VertexSource>&
operator = (const conv_transform<VertexSource>&);
const conv_transform<VertexSource>& operator=(const conv_transform<VertexSource>&);
VertexSource* m_source;
const Transformer* m_trans;
};
};
}
} // namespace agg
#endif

27
deps/agg/include/agg_conv_unclose_polygon.h vendored
View file

@ -18,35 +18,34 @@
#include "agg_basics.h"
namespace agg
namespace agg {
//====================================================conv_unclose_polygon
template<class VertexSource>
class conv_unclose_polygon
{
//====================================================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)
{
m_source->rewind(path_id);
}
void rewind(unsigned path_id) { m_source->rewind(path_id); }
unsigned vertex(double* x, double* y)
{
unsigned cmd = m_source->vertex(x, y);
if(is_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>&
operator = (const conv_unclose_polygon<VertexSource>&);
const conv_unclose_polygon<VertexSource>& operator=(const conv_unclose_polygon<VertexSource>&);
VertexSource* m_source;
};
};
}
} // namespace agg
#endif

558
deps/agg/include/agg_curves.h vendored
View file

@ -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 { curve_inc, curve_div };
//--------------------------------------------------------------curve3_inc
class MAPNIK_DECL curve3_inc
{
// See Implementation agg_curves.cpp
//--------------------------------------------curve_approximation_method_e
enum curve_approximation_method_e
{
curve_inc,
curve_div
};
//--------------------------------------------------------------curve3_inc
class MAPNIK_DECL curve3_inc
{
public:
curve3_inc() :
m_num_steps(0), m_step(0), m_scale(1.0) { }
curve3_inc()
: m_num_steps(0)
, m_step(0)
, m_scale(1.0)
{}
curve3_inc(double x1, double y1,
double x2, double y2,
double x3, double y3) :
m_num_steps(0), m_step(0), m_scale(1.0)
curve3_inc(double x1, double y1, double x2, double y2, double x3, double y3)
: m_num_steps(0)
, m_step(0)
, m_scale(1.0)
{
init(x1, y1, x2, y2, x3, y3);
}
void reset() { m_num_steps = 0; m_step = -1; }
void init(double x1, double y1,
double x2, double y2,
double x3, double y3);
void reset()
{
m_num_steps = 0;
m_step = -1;
}
void init(double x1, double y1, double x2, double y2, double x3, double y3);
void approximation_method(curve_approximation_method_e) {}
curve_approximation_method_e approximation_method() const { return curve_inc; }
@ -86,36 +86,32 @@ namespace agg
double m_saved_fy;
double m_saved_dfx;
double m_saved_dfy;
};
};
//-------------------------------------------------------------curve3_div
class MAPNIK_DECL curve3_div
{
//-------------------------------------------------------------curve3_div
class MAPNIK_DECL curve3_div
{
public:
curve3_div() :
m_approximation_scale(1.0),
m_angle_tolerance(0.0),
m_count(0)
curve3_div()
: m_approximation_scale(1.0)
, m_angle_tolerance(0.0)
, m_count(0)
{}
curve3_div(double x1, double y1,
double x2, double y2,
double x3, double y3) :
m_approximation_scale(1.0),
m_angle_tolerance(0.0),
m_count(0)
curve3_div(double x1, double y1, double x2, double y2, double x3, double y3)
: m_approximation_scale(1.0)
, m_angle_tolerance(0.0)
, m_count(0)
{
init(x1, y1, x2, y2, x3, y3);
}
void reset() { m_points.remove_all(); m_count = 0; }
void init(double x1, double y1,
double x2, double y2,
double x3, double y3);
void reset()
{
m_points.remove_all();
m_count = 0;
}
void init(double x1, double y1, double x2, double y2, double x3, double y3);
void approximation_method(curve_approximation_method_e) {}
curve_approximation_method_e approximation_method() const { return curve_div; }
@ -129,14 +125,12 @@ namespace agg
void cusp_limit(double) {}
double cusp_limit() const { return 0.0; }
void rewind(unsigned)
{
m_count = 0;
}
void rewind(unsigned) { 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,86 +138,81 @@ namespace agg
}
private:
void bezier(double x1, double y1,
double x2, double y2,
double x3, double y3);
void recursive_bezier(double x1, double y1,
double x2, double y2,
double x3, double y3,
unsigned level);
void bezier(double x1, double y1, double x2, double y2, double x3, double y3);
void recursive_bezier(double x1, double y1, double x2, double y2, double x3, double y3, unsigned level);
double m_approximation_scale;
double m_distance_tolerance_square;
double m_angle_tolerance;
unsigned m_count;
pod_bvector<point_d> m_points;
};
};
//-------------------------------------------------------------curve4_points
struct MAPNIK_DECL curve4_points
{
//-------------------------------------------------------------curve4_points
struct MAPNIK_DECL curve4_points
{
double cp[8];
curve4_points() {}
curve4_points(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4)
curve4_points(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
{
cp[0] = x1; cp[1] = y1; cp[2] = x2; cp[3] = y2;
cp[4] = x3; cp[5] = y3; cp[6] = x4; cp[7] = y4;
cp[0] = x1;
cp[1] = y1;
cp[2] = x2;
cp[3] = y2;
cp[4] = x3;
cp[5] = y3;
cp[6] = x4;
cp[7] = y4;
}
void init(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4)
void init(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
{
cp[0] = x1; cp[1] = y1; cp[2] = x2; cp[3] = y2;
cp[4] = x3; cp[5] = y3; cp[6] = x4; cp[7] = y4;
cp[0] = x1;
cp[1] = y1;
cp[2] = x2;
cp[3] = y2;
cp[4] = x3;
cp[5] = y3;
cp[6] = x4;
cp[7] = y4;
}
double operator [] (unsigned i) const { return cp[i]; }
double& operator [] (unsigned i) { return cp[i]; }
};
double operator[](unsigned i) const { return cp[i]; }
double& operator[](unsigned i) { return cp[i]; }
};
//-------------------------------------------------------------curve4_inc
class MAPNIK_DECL curve4_inc
{
//-------------------------------------------------------------curve4_inc
class MAPNIK_DECL curve4_inc
{
public:
curve4_inc() :
m_num_steps(0), m_step(0), m_scale(1.0) { }
curve4_inc()
: m_num_steps(0)
, m_step(0)
, m_scale(1.0)
{}
curve4_inc(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4) :
m_num_steps(0), m_step(0), m_scale(1.0)
curve4_inc(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
: m_num_steps(0)
, m_step(0)
, m_scale(1.0)
{
init(x1, y1, x2, y2, x3, y3, x4, y4);
}
curve4_inc(const curve4_points& cp) :
m_num_steps(0), m_step(0), m_scale(1.0)
curve4_inc(const curve4_points& cp)
: m_num_steps(0)
, m_step(0)
, m_scale(1.0)
{
init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
}
void reset() { m_num_steps = 0; m_step = -1; }
void init(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4);
void init(const curve4_points& cp)
void reset()
{
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; }
@ -262,16 +251,12 @@ namespace agg
double m_saved_dfy;
double m_saved_ddfx;
double m_saved_ddfy;
};
};
//-------------------------------------------------------catrom_to_bezier
inline curve4_points catrom_to_bezier(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4)
{
//-------------------------------------------------------catrom_to_bezier
inline curve4_points
catrom_to_bezier(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
{
// Trans. matrix Catmull-Rom to Bezier
//
// 0 1 0 0
@ -279,34 +264,26 @@ namespace agg
// 0 1/6 1 -1/6
// 0 0 1 0
//
return curve4_points(
x2,
return curve4_points(x2,
y2,
(-x1 + 6*x2 + x3) / 6,
(-y1 + 6*y2 + y3) / 6,
( x2 + 6*x3 - x4) / 6,
( y2 + 6*y3 - y4) / 6,
(-x1 + 6 * x2 + x3) / 6,
(-y1 + 6 * y2 + y3) / 6,
(x2 + 6 * x3 - x4) / 6,
(y2 + 6 * y3 - y4) / 6,
x3,
y3);
}
}
//-----------------------------------------------------------------------
inline curve4_points catrom_to_bezier(const curve4_points& cp)
{
return catrom_to_bezier(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
}
//-----------------------------------------------------------------------
inline curve4_points
catrom_to_bezier(const curve4_points& cp)
{
return catrom_to_bezier(cp[0], cp[1], cp[2], cp[3],
cp[4], cp[5], cp[6], cp[7]);
}
//-----------------------------------------------------ubspline_to_bezier
inline curve4_points ubspline_to_bezier(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4)
{
//-----------------------------------------------------ubspline_to_bezier
inline curve4_points
ubspline_to_bezier(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
{
// Trans. matrix Uniform BSpline to Bezier
//
// 1/6 4/6 1/6 0
@ -314,35 +291,26 @@ namespace agg
// 0 2/6 4/6 0
// 0 1/6 4/6 1/6
//
return curve4_points(
(x1 + 4*x2 + x3) / 6,
(y1 + 4*y2 + y3) / 6,
(4*x2 + 2*x3) / 6,
(4*y2 + 2*y3) / 6,
(2*x2 + 4*x3) / 6,
(2*y2 + 4*y3) / 6,
(x2 + 4*x3 + x4) / 6,
(y2 + 4*y3 + y4) / 6);
}
return curve4_points((x1 + 4 * x2 + x3) / 6,
(y1 + 4 * y2 + y3) / 6,
(4 * x2 + 2 * x3) / 6,
(4 * y2 + 2 * y3) / 6,
(2 * x2 + 4 * x3) / 6,
(2 * y2 + 4 * y3) / 6,
(x2 + 4 * x3 + x4) / 6,
(y2 + 4 * y3 + y4) / 6);
}
//-----------------------------------------------------------------------
inline curve4_points ubspline_to_bezier(const curve4_points& cp)
{
return ubspline_to_bezier(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
}
//-----------------------------------------------------------------------
inline curve4_points
ubspline_to_bezier(const curve4_points& cp)
{
return ubspline_to_bezier(cp[0], cp[1], cp[2], cp[3],
cp[4], cp[5], cp[6], cp[7]);
}
//------------------------------------------------------hermite_to_bezier
inline curve4_points hermite_to_bezier(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4)
{
//------------------------------------------------------hermite_to_bezier
inline curve4_points
hermite_to_bezier(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
{
// Trans. matrix Hermite to Bezier
//
// 1 0 0 0
@ -350,76 +318,55 @@ namespace agg
// 0 1 0 -1/3
// 0 1 0 0
//
return curve4_points(
x1,
y1,
(3*x1 + x3) / 3,
(3*y1 + y3) / 3,
(3*x2 - x4) / 3,
(3*y2 - y4) / 3,
x2,
y2);
}
return curve4_points(x1, y1, (3 * x1 + x3) / 3, (3 * y1 + y3) / 3, (3 * x2 - x4) / 3, (3 * y2 - y4) / 3, x2, y2);
}
//-----------------------------------------------------------------------
inline curve4_points hermite_to_bezier(const curve4_points& cp)
{
return hermite_to_bezier(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
}
//-----------------------------------------------------------------------
inline curve4_points
hermite_to_bezier(const curve4_points& cp)
{
return hermite_to_bezier(cp[0], cp[1], cp[2], cp[3],
cp[4], cp[5], cp[6], cp[7]);
}
//-------------------------------------------------------------curve4_div
class MAPNIK_DECL curve4_div
{
//-------------------------------------------------------------curve4_div
class MAPNIK_DECL curve4_div
{
public:
curve4_div() :
m_approximation_scale(1.0),
m_angle_tolerance(0.0),
m_cusp_limit(0.0),
m_count(0)
curve4_div()
: m_approximation_scale(1.0)
, m_angle_tolerance(0.0)
, m_cusp_limit(0.0)
, m_count(0)
{}
curve4_div(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4) :
m_approximation_scale(1.0),
m_angle_tolerance(0.0),
m_cusp_limit(0.0),
m_count(0)
curve4_div(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
: m_approximation_scale(1.0)
, m_angle_tolerance(0.0)
, m_cusp_limit(0.0)
, m_count(0)
{
init(x1, y1, x2, y2, x3, y3, x4, y4);
}
curve4_div(const curve4_points& cp) :
m_approximation_scale(1.0),
m_angle_tolerance(0.0),
m_count(0)
curve4_div(const curve4_points& cp)
: m_approximation_scale(1.0)
, m_angle_tolerance(0.0)
, m_count(0)
{
init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
}
void reset() { m_points.remove_all(); m_count = 0; }
void init(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4);
void init(const curve4_points& cp)
void reset()
{
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
{
return curve_div;
}
curve_approximation_method_e approximation_method() const { return curve_div; }
void approximation_scale(double s) { m_approximation_scale = s; }
double approximation_scale() const { return m_approximation_scale; }
@ -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)
{
m_cusp_limit = (v == 0.0) ? 0.0 : pi - v;
}
void cusp_limit(double v) { m_cusp_limit = (v == 0.0) ? 0.0 : pi - v; }
double cusp_limit() const
{
return (m_cusp_limit == 0.0) ? 0.0 : pi - m_cusp_limit;
}
double cusp_limit() const { return (m_cusp_limit == 0.0) ? 0.0 : pi - m_cusp_limit; }
void rewind(unsigned)
{
m_count = 0;
}
void rewind(unsigned) { 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,
double x2, double y2,
double x3, double y3,
double x4, double y4);
void bezier(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4);
void recursive_bezier(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4,
void recursive_bezier(double x1,
double y1,
double x2,
double y2,
double x3,
double y3,
double x4,
double y4,
unsigned level);
double m_approximation_scale;
@ -469,18 +409,17 @@ namespace agg
double m_cusp_limit;
unsigned m_count;
pod_bvector<point_d> m_points;
};
};
//-----------------------------------------------------------------curve3
class MAPNIK_DECL curve3
{
//-----------------------------------------------------------------curve3
class MAPNIK_DECL curve3
{
public:
curve3() : m_approximation_method(curve_div) {}
curve3(double x1, double y1,
double x2, double y2,
double x3, double y3) :
m_approximation_method(curve_div)
curve3()
: m_approximation_method(curve_div)
{}
curve3(double x1, double y1, double x2, double y2, double x3, double y3)
: m_approximation_method(curve_div)
{
init(x1, y1, x2, y2, x3, y3);
}
@ -491,11 +430,9 @@ namespace agg
m_curve_div.reset();
}
void init(double x1, double y1,
double x2, double y2,
double x3, double y3)
void init(double x1, double y1, double x2, double y2, double x3, double y3)
{
if(m_approximation_method == curve_inc)
if (m_approximation_method == curve_inc)
{
m_curve_inc.init(x1, y1, x2, y2, x3, y3);
}
@ -505,15 +442,9 @@ namespace agg
}
}
void approximation_method(curve_approximation_method_e v)
{
m_approximation_method = v;
}
void approximation_method(curve_approximation_method_e v) { m_approximation_method = v; }
curve_approximation_method_e approximation_method() const
{
return m_approximation_method;
}
curve_approximation_method_e approximation_method() const { return m_approximation_method; }
void approximation_scale(double s)
{
@ -521,34 +452,19 @@ namespace agg
m_curve_div.approximation_scale(s);
}
double approximation_scale() const
{
return m_curve_inc.approximation_scale();
}
double approximation_scale() const { return m_curve_inc.approximation_scale(); }
void angle_tolerance(double a)
{
m_curve_div.angle_tolerance(a);
}
void angle_tolerance(double a) { m_curve_div.angle_tolerance(a); }
double angle_tolerance() const
{
return m_curve_div.angle_tolerance();
}
double angle_tolerance() const { return m_curve_div.angle_tolerance(); }
void cusp_limit(double v)
{
m_curve_div.cusp_limit(v);
}
void cusp_limit(double v) { m_curve_div.cusp_limit(v); }
double cusp_limit() const
{
return m_curve_div.cusp_limit();
}
double cusp_limit() const { return m_curve_div.cusp_limit(); }
void rewind(unsigned path_id)
{
if(m_approximation_method == curve_inc)
if (m_approximation_method == curve_inc)
{
m_curve_inc.rewind(path_id);
}
@ -560,7 +476,7 @@ namespace agg
unsigned vertex(double* x, double* y)
{
if(m_approximation_method == curve_inc)
if (m_approximation_method == curve_inc)
{
return m_curve_inc.vertex(x, y);
}
@ -571,28 +487,23 @@ namespace agg
curve3_inc m_curve_inc;
curve3_div m_curve_div;
curve_approximation_method_e m_approximation_method;
};
};
//-----------------------------------------------------------------curve4
class MAPNIK_DECL curve4
{
//-----------------------------------------------------------------curve4
class MAPNIK_DECL curve4
{
public:
curve4() : m_approximation_method(curve_div) {}
curve4(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4) :
m_approximation_method(curve_div)
curve4()
: m_approximation_method(curve_div)
{}
curve4(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
: m_approximation_method(curve_div)
{
init(x1, y1, x2, y2, x3, y3, x4, y4);
}
curve4(const curve4_points& cp) :
m_approximation_method(curve_div)
curve4(const curve4_points& cp)
: m_approximation_method(curve_div)
{
init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
}
@ -603,12 +514,9 @@ namespace agg
m_curve_div.reset();
}
void init(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4)
void init(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
{
if(m_approximation_method == curve_inc)
if (m_approximation_method == curve_inc)
{
m_curve_inc.init(x1, y1, x2, y2, x3, y3, x4, y4);
}
@ -618,20 +526,11 @@ namespace agg
}
}
void init(const curve4_points& cp)
{
init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
}
void init(const curve4_points& cp) { init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]); }
void approximation_method(curve_approximation_method_e v)
{
m_approximation_method = v;
}
void approximation_method(curve_approximation_method_e v) { m_approximation_method = v; }
curve_approximation_method_e approximation_method() const
{
return m_approximation_method;
}
curve_approximation_method_e approximation_method() const { return m_approximation_method; }
void approximation_scale(double s)
{
@ -640,29 +539,17 @@ namespace agg
}
double approximation_scale() const { return m_curve_inc.approximation_scale(); }
void angle_tolerance(double v)
{
m_curve_div.angle_tolerance(v);
}
void angle_tolerance(double v) { m_curve_div.angle_tolerance(v); }
double angle_tolerance() const
{
return m_curve_div.angle_tolerance();
}
double angle_tolerance() const { return m_curve_div.angle_tolerance(); }
void cusp_limit(double v)
{
m_curve_div.cusp_limit(v);
}
void cusp_limit(double v) { m_curve_div.cusp_limit(v); }
double cusp_limit() const
{
return m_curve_div.cusp_limit();
}
double cusp_limit() const { return m_curve_div.cusp_limit(); }
void rewind(unsigned path_id)
{
if(m_approximation_method == curve_inc)
if (m_approximation_method == curve_inc)
{
m_curve_inc.rewind(path_id);
}
@ -674,7 +561,7 @@ namespace agg
unsigned vertex(double* x, double* y)
{
if(m_approximation_method == curve_inc)
if (m_approximation_method == curve_inc)
{
return m_curve_inc.vertex(x, y);
}
@ -685,11 +572,8 @@ namespace agg
curve4_inc m_curve_inc;
curve4_div m_curve_div;
curve_approximation_method_e m_approximation_method;
};
};
}
} // namespace agg
#endif

161
deps/agg/include/agg_dda_line.h vendored
View file

@ -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
{
//===================================================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) :
m_y(y1),
m_inc(((y2 - y1) * factor) / static_cast<int>(count)),
m_dy(0)
{
}
dda_line_interpolator(int y1, int y2, unsigned count)
: m_y(y1)
, m_inc(((y2 - y1) * factor) / static_cast<int>(count))
, m_dy(0)
{}
//--------------------------------------------------------------------
void operator ++ ()
{
m_dy += m_inc;
}
void operator++() { m_dy += m_inc; }
//--------------------------------------------------------------------
void operator -- ()
{
m_dy -= m_inc;
}
void operator--() { m_dy -= m_inc; }
//--------------------------------------------------------------------
void operator += (unsigned n)
{
m_dy += m_inc * n;
}
void operator+=(unsigned n) { m_dy += m_inc * n; }
//--------------------------------------------------------------------
void operator -= (unsigned n)
{
m_dy -= m_inc * n;
}
void operator-=(unsigned n) { m_dy -= m_inc * n; }
//--------------------------------------------------------------------
int y() const { return m_y + (m_dy >> (FractionShift - YShift)); }
@ -75,15 +62,11 @@ namespace agg
int m_y;
int m_inc;
int m_dy;
};
};
//=================================================dda2_line_interpolator
class dda2_line_interpolator
{
//=================================================dda2_line_interpolator
class dda2_line_interpolator
{
public:
typedef int save_data_type;
enum save_size_e { save_size = 2 };
@ -92,14 +75,14 @@ namespace agg
dda2_line_interpolator() {}
//-------------------------------------------- Forward-adjusted line
dda2_line_interpolator(int y1, int y2, int count) :
m_cnt(count <= 0 ? 1 : count),
m_lft((y2 - y1) / m_cnt),
m_rem((y2 - y1) % m_cnt),
m_mod(m_rem),
m_y(y1)
dda2_line_interpolator(int y1, int y2, int count)
: m_cnt(count <= 0 ? 1 : count)
, m_lft((y2 - y1) / m_cnt)
, m_rem((y2 - y1) % m_cnt)
, m_mod(m_rem)
, m_y(y1)
{
if(m_mod <= 0)
if (m_mod <= 0)
{
m_mod += count;
m_rem += count;
@ -109,14 +92,14 @@ namespace agg
}
//-------------------------------------------- Backward-adjusted line
dda2_line_interpolator(int y1, int y2, int count, int) :
m_cnt(count <= 0 ? 1 : count),
m_lft((y2 - y1) / m_cnt),
m_rem((y2 - y1) % m_cnt),
m_mod(m_rem),
m_y(y1)
dda2_line_interpolator(int y1, int y2, int count, int)
: m_cnt(count <= 0 ? 1 : count)
, m_lft((y2 - y1) / m_cnt)
, m_rem((y2 - y1) % m_cnt)
, m_mod(m_rem)
, m_y(y1)
{
if(m_mod <= 0)
if (m_mod <= 0)
{
m_mod += count;
m_rem += count;
@ -125,14 +108,14 @@ namespace agg
}
//-------------------------------------------- Backward-adjusted line
dda2_line_interpolator(int y, int count) :
m_cnt(count <= 0 ? 1 : count),
m_lft(y / m_cnt),
m_rem(y % m_cnt),
m_mod(m_rem),
m_y(0)
dda2_line_interpolator(int y, int count)
: m_cnt(count <= 0 ? 1 : count)
, m_lft(y / m_cnt)
, m_rem(y % m_cnt)
, m_mod(m_rem)
, m_y(0)
{
if(m_mod <= 0)
if (m_mod <= 0)
{
m_mod += count;
m_rem += count;
@ -140,7 +123,6 @@ namespace agg
}
}
//--------------------------------------------------------------------
void save(save_data_type* data) const
{
@ -160,7 +142,7 @@ namespace agg
{
m_mod += m_rem;
m_y += m_lft;
if(m_mod > 0)
if (m_mod > 0)
{
m_mod -= m_cnt;
m_y++;
@ -170,7 +152,7 @@ namespace agg
//--------------------------------------------------------------------
void operator--()
{
if(m_mod <= m_rem)
if (m_mod <= m_rem)
{
m_mod += m_cnt;
m_y--;
@ -180,16 +162,10 @@ namespace agg
}
//--------------------------------------------------------------------
void adjust_forward()
{
m_mod -= m_cnt;
}
void adjust_forward() { m_mod -= m_cnt; }
//--------------------------------------------------------------------
void adjust_backward()
{
m_mod += m_cnt;
}
void adjust_backward() { m_mod += m_cnt; }
//--------------------------------------------------------------------
int mod() const { return m_mod; }
@ -205,20 +181,13 @@ namespace agg
int m_rem;
int m_mod;
int m_y;
};
};
//---------------------------------------------line_bresenham_interpolator
class line_bresenham_interpolator
{
//---------------------------------------------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) :
m_x1_lr(line_lr(x1)),
m_y1_lr(line_lr(y1)),
m_x2_lr(line_lr(x2)),
m_y2_lr(line_lr(y2)),
m_ver(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) :
std::abs(m_x2_lr - m_x1_lr)),
m_inc(m_ver ? ((y2 > y1) ? 1 : -1) : ((x2 > x1) ? 1 : -1)),
m_interpolator(m_ver ? x1 : y1,
m_ver ? x2 : y2,
m_len)
{
}
line_bresenham_interpolator(int x1, int y1, int x2, int y2)
: m_x1_lr(line_lr(x1))
, m_y1_lr(line_lr(y1))
, m_x2_lr(line_lr(x2))
, m_y2_lr(line_lr(y2))
, m_ver(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) : std::abs(m_x2_lr - m_x1_lr))
, m_inc(m_ver ? ((y2 > y1) ? 1 : -1) : ((x2 > x1) ? 1 : -1))
, m_interpolator(m_ver ? x1 : y1, m_ver ? x2 : y2, m_len)
{}
//--------------------------------------------------------------------
bool is_ver() const { return m_ver; }
@ -279,12 +244,8 @@ namespace agg
unsigned m_len;
int m_inc;
dda2_line_interpolator m_interpolator;
};
};
}
} // namespace agg
#endif

101
deps/agg/include/agg_ellipse.h vendored
View file

@ -23,27 +23,38 @@
#include "agg_basics.h"
#include <cmath>
namespace agg
namespace agg {
//----------------------------------------------------------------ellipse
class ellipse
{
//----------------------------------------------------------------ellipse
class ellipse
{
public:
ellipse() :
m_x(0.0), 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()
: m_x(0.0)
, 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,
unsigned num_steps=0, bool cw=false) :
m_x(x), m_y(y), m_rx(rx), m_ry(ry), m_scale(1.0),
m_num(num_steps), m_step(0), m_cw(cw)
ellipse(double x, double y, double rx, double ry, unsigned num_steps = 0, bool cw = false)
: m_x(x)
, m_y(y)
, 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,
unsigned num_steps=0, bool cw=false);
void init(double x, double y, double rx, double ry, unsigned num_steps = 0, bool cw = false);
void approximation_scale(double scale);
void rewind(unsigned path_id);
@ -61,12 +72,11 @@ namespace agg
unsigned m_num;
unsigned m_step;
bool m_cw;
};
};
//------------------------------------------------------------------------
inline void ellipse::init(double x, double y, double rx, double ry,
unsigned num_steps, bool cw)
{
//------------------------------------------------------------------------
inline void ellipse::init(double x, double y, double rx, double ry, unsigned num_steps, bool cw)
{
m_x = x;
m_y = y;
m_rx = rx;
@ -74,51 +84,50 @@ 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();
}
//------------------------------------------------------------------------
inline void ellipse::approximation_scale(double scale)
{
//------------------------------------------------------------------------
inline void ellipse::approximation_scale(double scale)
{
m_scale = scale;
calc_num_steps();
}
}
//------------------------------------------------------------------------
inline void ellipse::calc_num_steps()
{
//------------------------------------------------------------------------
inline void ellipse::calc_num_steps()
{
double ra = (std::fabs(m_rx) + std::fabs(m_ry)) / 2;
double da = std::acos(ra / (ra + 0.125 / m_scale)) * 2;
m_num = uround(2*pi / da);
}
m_num = uround(2 * pi / da);
}
//------------------------------------------------------------------------
inline void ellipse::rewind(unsigned)
{
//------------------------------------------------------------------------
inline void ellipse::rewind(unsigned)
{
m_step = 0;
}
}
//------------------------------------------------------------------------
inline unsigned ellipse::vertex(double* x, double* y)
{
if(m_step == m_num)
//------------------------------------------------------------------------
inline unsigned ellipse::vertex(double* x, double* y)
{
if (m_step == m_num)
{
++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

52
deps/agg/include/agg_ellipse_bresenham.h vendored
View file

@ -20,50 +20,50 @@
#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
{
//------------------------------------------ellipse_bresenham_interpolator
class ellipse_bresenham_interpolator
{
public:
ellipse_bresenham_interpolator(int rx, int ry) :
m_rx2(rx * rx),
m_ry2(ry * ry),
m_two_rx2(m_rx2 << 1),
m_two_ry2(m_ry2 << 1),
m_dx(0),
m_dy(0),
m_inc_x(0),
m_inc_y(-ry * m_two_rx2),
m_cur_f(0)
ellipse_bresenham_interpolator(int rx, int ry)
: m_rx2(rx * rx)
, m_ry2(ry * ry)
, m_two_rx2(m_rx2 << 1)
, m_two_ry2(m_ry2 << 1)
, m_dx(0)
, m_dy(0)
, m_inc_x(0)
, m_inc_y(-ry * m_two_rx2)
, m_cur_f(0)
{}
int dx() const { return m_dx; }
int dy() const { return m_dy; }
void operator++ ()
void operator++()
{
int mx, my, mxy, min_m;
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;
if(min_m > my)
if (min_m > my)
{
min_m = my;
flag = false;
@ -71,7 +71,7 @@ namespace agg
m_dx = m_dy = 0;
if(min_m > mxy)
if (min_m > mxy)
{
m_inc_x += m_two_ry2;
m_inc_y += m_two_rx2;
@ -81,7 +81,7 @@ namespace agg
return;
}
if(flag)
if (flag)
{
m_inc_x += m_two_ry2;
m_cur_f = fx;
@ -104,10 +104,8 @@ namespace agg
int m_inc_x;
int m_inc_y;
int m_cur_f;
};
};
}
} // namespace agg
#endif

73
deps/agg/include/agg_embedded_raster_fonts.h vendored
View file

@ -18,42 +18,41 @@
#include "agg_basics.h"
namespace agg
{
extern const int8u gse4x6[];
extern const int8u gse4x8[];
extern const int8u gse5x7[];
extern const int8u gse5x9[];
extern const int8u gse6x12[];
extern const int8u gse6x9[];
extern const int8u gse7x11[];
extern const int8u gse7x11_bold[];
extern const int8u gse7x15[];
extern const int8u gse7x15_bold[];
extern const int8u gse8x16[];
extern const int8u gse8x16_bold[];
extern const int8u mcs11_prop[];
extern const int8u mcs11_prop_condensed[];
extern const int8u mcs12_prop[];
extern const int8u mcs13_prop[];
extern const int8u mcs5x10_mono[];
extern const int8u mcs5x11_mono[];
extern const int8u mcs6x10_mono[];
extern const int8u mcs6x11_mono[];
extern const int8u mcs7x12_mono_high[];
extern const int8u mcs7x12_mono_low[];
extern const int8u verdana12[];
extern const int8u verdana12_bold[];
extern const int8u verdana13[];
extern const int8u verdana13_bold[];
extern const int8u verdana14[];
extern const int8u verdana14_bold[];
extern const int8u verdana16[];
extern const int8u verdana16_bold[];
extern const int8u verdana17[];
extern const int8u verdana17_bold[];
extern const int8u verdana18[];
extern const int8u verdana18_bold[];
}
namespace agg {
extern const int8u gse4x6[];
extern const int8u gse4x8[];
extern const int8u gse5x7[];
extern const int8u gse5x9[];
extern const int8u gse6x12[];
extern const int8u gse6x9[];
extern const int8u gse7x11[];
extern const int8u gse7x11_bold[];
extern const int8u gse7x15[];
extern const int8u gse7x15_bold[];
extern const int8u gse8x16[];
extern const int8u gse8x16_bold[];
extern const int8u mcs11_prop[];
extern const int8u mcs11_prop_condensed[];
extern const int8u mcs12_prop[];
extern const int8u mcs13_prop[];
extern const int8u mcs5x10_mono[];
extern const int8u mcs5x11_mono[];
extern const int8u mcs6x10_mono[];
extern const int8u mcs6x11_mono[];
extern const int8u mcs7x12_mono_high[];
extern const int8u mcs7x12_mono_low[];
extern const int8u verdana12[];
extern const int8u verdana12_bold[];
extern const int8u verdana13[];
extern const int8u verdana13_bold[];
extern const int8u verdana14[];
extern const int8u verdana14_bold[];
extern const int8u verdana16[];
extern const int8u verdana16_bold[];
extern const int8u verdana17[];
extern const int8u verdana17_bold[];
extern const int8u verdana18[];
extern const int8u verdana18_bold[];
} // namespace agg
#endif

193
deps/agg/include/agg_font_cache_manager.h vendored
View file

@ -19,22 +19,14 @@
#include <cstring>
#include "agg_array.h"
namespace agg
namespace agg {
//---------------------------------------------------------glyph_data_type
enum glyph_data_type { glyph_data_invalid = 0, glyph_data_mono = 1, glyph_data_gray8 = 2, glyph_data_outline = 3 };
//-------------------------------------------------------------glyph_cache
struct glyph_cache
{
//---------------------------------------------------------glyph_data_type
enum glyph_data_type
{
glyph_data_invalid = 0,
glyph_data_mono = 1,
glyph_data_gray8 = 2,
glyph_data_outline = 3
};
//-------------------------------------------------------------glyph_cache
struct glyph_cache
{
unsigned glyph_index;
int8u* data;
unsigned data_size;
@ -42,19 +34,18 @@ namespace agg
rect_i bounds;
double advance_x;
double advance_y;
};
};
//--------------------------------------------------------------font_cache
class font_cache
{
//--------------------------------------------------------------font_cache
class font_cache
{
public:
enum block_size_e { block_size = 16384-16 };
enum block_size_e { block_size = 16384 - 16 };
//--------------------------------------------------------------------
font_cache() :
m_allocator(block_size),
m_font_signature(0)
font_cache()
: m_allocator(block_size)
, m_font_signature(0)
{}
//--------------------------------------------------------------------
@ -66,16 +57,13 @@ namespace agg
}
//--------------------------------------------------------------------
bool font_is(const char* font_signature) const
{
return strcmp(font_signature, m_font_signature) == 0;
}
bool font_is(const char* font_signature) const { return strcmp(font_signature, m_font_signature) == 0; }
//--------------------------------------------------------------------
const glyph_cache* find_glyph(unsigned glyph_code) const
{
unsigned msb = (glyph_code >> 8) & 0xFF;
if(m_glyphs[msb])
if (m_glyphs[msb])
{
return m_glyphs[msb][glyph_code & 0xFF];
}
@ -92,20 +80,17 @@ namespace agg
double advance_y)
{
unsigned msb = (glyph_code >> 8) & 0xFF;
if(m_glyphs[msb] == 0)
if (m_glyphs[msb] == 0)
{
m_glyphs[msb] =
(glyph_cache**)m_allocator.allocate(sizeof(glyph_cache*) * 256,
sizeof(glyph_cache*));
m_glyphs[msb] = (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*)m_allocator.allocate(sizeof(glyph_cache),
sizeof(double));
glyph_cache* glyph = (glyph_cache*)m_allocator.allocate(sizeof(glyph_cache), sizeof(double));
glyph->glyph_index = glyph_index;
glyph->data = m_allocator.allocate(data_size);
@ -121,23 +106,17 @@ namespace agg
block_allocator m_allocator;
glyph_cache** m_glyphs[256];
char* m_font_signature;
};
};
//---------------------------------------------------------font_cache_pool
class font_cache_pool
{
//---------------------------------------------------------font_cache_pool
class font_cache_pool
{
public:
//--------------------------------------------------------------------
~font_cache_pool()
{
unsigned i;
for(i = 0; i < m_num_fonts; ++i)
for (i = 0; i < m_num_fonts; ++i)
{
obj_allocator<font_cache>::deallocate(m_fonts[i]);
}
@ -145,21 +124,20 @@ namespace agg
}
//--------------------------------------------------------------------
font_cache_pool(unsigned max_fonts=32) :
m_fonts(pod_allocator<font_cache*>::allocate(max_fonts)),
m_max_fonts(max_fonts),
m_num_fonts(0),
m_cur_font(0)
font_cache_pool(unsigned max_fonts = 32)
: m_fonts(pod_allocator<font_cache*>::allocate(max_fonts))
, m_max_fonts(max_fonts)
, m_num_fonts(0)
, m_cur_font(0)
{}
//--------------------------------------------------------------------
void font(const char* font_signature, bool reset_cache = false)
{
int idx = find_font(font_signature);
if(idx >= 0)
if (idx >= 0)
{
if(reset_cache)
if (reset_cache)
{
obj_allocator<font_cache>::deallocate(m_fonts[idx]);
m_fonts[idx] = obj_allocator<font_cache>::allocate();
@ -169,12 +147,10 @@ namespace agg
}
else
{
if(m_num_fonts >= m_max_fonts)
if (m_num_fonts >= m_max_fonts)
{
obj_allocator<font_cache>::deallocate(m_fonts[0]);
memcpy(m_fonts,
m_fonts + 1,
(m_max_fonts - 1) * sizeof(font_cache*));
memcpy(m_fonts, 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
{
return m_cur_font;
}
const font_cache* font() const { 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;
}
@ -206,27 +180,21 @@ namespace agg
double advance_x,
double advance_y)
{
if(m_cur_font)
if (m_cur_font)
{
return m_cur_font->cache_glyph(glyph_code,
glyph_index,
data_size,
data_type,
bounds,
advance_x,
advance_y);
return m_cur_font->cache_glyph(glyph_code, 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++)
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;
}
@ -236,27 +204,21 @@ namespace agg
unsigned m_max_fonts;
unsigned m_num_fonts;
font_cache* m_cur_font;
};
};
//------------------------------------------------------------------------
enum glyph_rendering
{
//------------------------------------------------------------------------
enum glyph_rendering {
glyph_ren_native_mono,
glyph_ren_native_gray8,
glyph_ren_outline,
glyph_ren_agg_mono,
glyph_ren_agg_gray8
};
};
//------------------------------------------------------font_cache_manager
template<class FontEngine> class font_cache_manager
{
//------------------------------------------------------font_cache_manager
template<class FontEngine>
class font_cache_manager
{
public:
typedef FontEngine font_engine_type;
typedef font_cache_manager<FontEngine> self_type;
@ -267,33 +229,30 @@ namespace agg
typedef typename mono_adaptor_type::embedded_scanline mono_scanline_type;
//--------------------------------------------------------------------
font_cache_manager(font_engine_type& engine, unsigned max_fonts=32) :
m_fonts(max_fonts),
m_engine(engine),
m_change_stamp(-1),
m_prev_glyph(0),
m_last_glyph(0)
font_cache_manager(font_engine_type& engine, unsigned max_fonts = 32)
: m_fonts(max_fonts)
, m_engine(engine)
, m_change_stamp(-1)
, m_prev_glyph(0)
, m_last_glyph(0)
{}
//--------------------------------------------------------------------
void reset_last_glyph()
{
m_prev_glyph = m_last_glyph = 0;
}
void reset_last_glyph() { m_prev_glyph = m_last_glyph = 0; }
//--------------------------------------------------------------------
const glyph_cache* glyph(unsigned glyph_code)
{
synchronize();
const glyph_cache* gl = m_fonts.find_glyph(glyph_code);
if(gl)
if (gl)
{
m_prev_glyph = m_last_glyph;
return m_last_glyph = gl;
}
else
{
if(m_engine.prepare_glyph(glyph_code))
if (m_engine.prepare_glyph(glyph_code))
{
m_prev_glyph = m_last_glyph;
m_last_glyph = m_fonts.cache_glyph(glyph_code,
@ -311,15 +270,14 @@ namespace agg
}
//--------------------------------------------------------------------
void init_embedded_adaptors(const glyph_cache* gl,
double x, double y,
double scale=1.0)
void init_embedded_adaptors(const glyph_cache* gl, double x, double y, double scale = 1.0)
{
if(gl)
if (gl)
{
switch(gl->data_type)
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; }
@ -350,11 +307,9 @@ namespace agg
//--------------------------------------------------------------------
bool add_kerning(double* x, double* y)
{
if(m_prev_glyph && m_last_glyph)
if (m_prev_glyph && m_last_glyph)
{
return m_engine.add_kerning(m_prev_glyph->glyph_index,
m_last_glyph->glyph_index,
x, y);
return m_engine.add_kerning(m_prev_glyph->glyph_index, 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);
}
//--------------------------------------------------------------------
@ -376,12 +332,12 @@ namespace agg
private:
//--------------------------------------------------------------------
font_cache_manager(const self_type&);
const self_type& operator = (const self_type&);
const self_type& operator=(const self_type&);
//--------------------------------------------------------------------
void synchronize()
{
if(m_change_stamp != m_engine.change_stamp())
if (m_change_stamp != m_engine.change_stamp())
{
m_fonts.font(m_engine.font_signature());
m_change_stamp = m_engine.change_stamp();
@ -401,9 +357,8 @@ namespace agg
gray8_scanline_type m_gray8_scanline;
mono_adaptor_type m_mono_adaptor;
mono_scanline_type m_mono_scanline;
};
};
}
} // namespace agg
#endif

127
deps/agg/include/agg_gamma_functions.h vendored
View file

@ -19,116 +19,135 @@
#include <cmath>
#include "agg_basics.h"
namespace agg
namespace agg {
//===============================================================gamma_none
struct gamma_none
{
//===============================================================gamma_none
struct gamma_none
{
double operator()(double x) const { return x; }
};
};
//==============================================================gamma_power
class gamma_power
{
//==============================================================gamma_power
class gamma_power
{
public:
gamma_power() : m_gamma(1.0) {}
gamma_power(double g) : m_gamma(g) {}
gamma_power()
: m_gamma(1.0)
{}
gamma_power(double g)
: m_gamma(g)
{}
void gamma(double g) { m_gamma = g; }
double gamma() const { return m_gamma; }
double operator() (double x) const
double operator()(double x) const
{
if (x == 0.0) return 0.0;
if (x == 0.0)
return 0.0;
return pow(x, m_gamma);
}
private:
double m_gamma;
};
};
//==========================================================gamma_threshold
class gamma_threshold
{
//==========================================================gamma_threshold
class gamma_threshold
{
public:
gamma_threshold() : m_threshold(0.5) {}
gamma_threshold(double t) : m_threshold(t) {}
gamma_threshold()
: m_threshold(0.5)
{}
gamma_threshold(double t)
: m_threshold(t)
{}
void threshold(double t) { m_threshold = t; }
double threshold() const { return m_threshold; }
double operator() (double x) const
{
return (x < m_threshold) ? 0.0 : 1.0;
}
double operator()(double x) const { return (x < m_threshold) ? 0.0 : 1.0; }
private:
double m_threshold;
};
};
//============================================================gamma_linear
class gamma_linear
{
//============================================================gamma_linear
class gamma_linear
{
public:
gamma_linear() : m_start(0.0), m_end(1.0) {}
gamma_linear(double s, double e) : m_start(s), m_end(e) {}
gamma_linear()
: m_start(0.0)
, m_end(1.0)
{}
gamma_linear(double s, double e)
: m_start(s)
, m_end(e)
{}
void set(double s, double e) { m_start = s; m_end = e; }
void set(double s, double e)
{
m_start = s;
m_end = e;
}
void start(double s) { m_start = s; }
void end(double e) { m_end = e; }
double start() const { return m_start; }
double end() const { return m_end; }
double operator() (double x) const
double operator()(double x) const
{
if(x < m_start) return 0.0;
if(x > m_end) return 1.0;
if (x < m_start)
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;
}
private:
double m_start;
double m_end;
};
};
//==========================================================gamma_multiply
class gamma_multiply
{
//==========================================================gamma_multiply
class gamma_multiply
{
public:
gamma_multiply() : m_mul(1.0) {}
gamma_multiply(double v) : m_mul(v) {}
gamma_multiply()
: m_mul(1.0)
{}
gamma_multiply(double v)
: m_mul(v)
{}
void value(double v) { m_mul = v; }
double value() const { return m_mul; }
double operator() (double x) const
double 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;
}
private:
double m_mul;
};
};
inline double sRGB_to_linear(double x)
{
inline double sRGB_to_linear(double x)
{
return (x <= 0.04045) ? (x / 12.92) : pow((x + 0.055) / (1.055), 2.4);
}
inline double linear_to_sRGB(double x)
{
return (x <= 0.0031308) ? (x * 12.92) : (1.055 * pow(x, 1 / 2.4) - 0.055);
}
}
inline double linear_to_sRGB(double x)
{
return (x <= 0.0031308) ? (x * 12.92) : (1.055 * pow(x, 1 / 2.4) - 0.055);
}
} // namespace agg
#endif

255
deps/agg/include/agg_gamma_lut.h vendored
View file

@ -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>
class gamma_lut
{
template<class LoResT=int8u,
class HiResT=int8u,
unsigned GammaShift=8,
unsigned HiResShift=8> class gamma_lut
{
public:
typedef gamma_lut<LoResT, HiResT, GammaShift, HiResShift> self_type;
enum gamma_scale_e
{
gamma_shift = GammaShift,
gamma_size = 1 << gamma_shift,
gamma_mask = gamma_size - 1
};
enum gamma_scale_e { gamma_shift = GammaShift, gamma_size = 1 << gamma_shift, gamma_mask = gamma_size - 1 };
enum hi_res_scale_e
{
hi_res_shift = HiResShift,
hi_res_size = 1 << hi_res_shift,
hi_res_mask = hi_res_size - 1
};
enum hi_res_scale_e { hi_res_shift = HiResShift, hi_res_size = 1 << hi_res_shift, hi_res_mask = hi_res_size - 1 };
~gamma_lut()
{
@ -50,27 +37,27 @@ namespace agg
pod_allocator<HiResT>::deallocate(m_dir_gamma, gamma_size);
}
gamma_lut() :
m_gamma(1.0),
m_dir_gamma(pod_allocator<HiResT>::allocate(gamma_size)),
m_inv_gamma(pod_allocator<LoResT>::allocate(hi_res_size))
gamma_lut()
: m_gamma(1.0)
, m_dir_gamma(pod_allocator<HiResT>::allocate(gamma_size))
, m_inv_gamma(pod_allocator<LoResT>::allocate(hi_res_size))
{
unsigned i;
for(i = 0; i < gamma_size; i++)
for (i = 0; i < gamma_size; i++)
{
m_dir_gamma[i] = HiResT(i << (hi_res_shift - gamma_shift));
}
for(i = 0; i < hi_res_size; i++)
for (i = 0; i < hi_res_size; i++)
{
m_inv_gamma[i] = LoResT(i >> (hi_res_shift - gamma_shift));
}
}
gamma_lut(double g) :
m_gamma(1.0),
m_dir_gamma(pod_allocator<HiResT>::allocate(gamma_size)),
m_inv_gamma(pod_allocator<LoResT>::allocate(hi_res_size))
gamma_lut(double g)
: m_gamma(1.0)
, m_dir_gamma(pod_allocator<HiResT>::allocate(gamma_size))
, m_inv_gamma(pod_allocator<LoResT>::allocate(hi_res_size))
{
gamma(g);
}
@ -80,72 +67,66 @@ namespace agg
m_gamma = g;
unsigned i;
for(i = 0; i < gamma_size; i++)
for (i = 0; i < gamma_size; i++)
{
m_dir_gamma[i] = (HiResT)
uround(pow(i / double(gamma_mask), m_gamma) * double(hi_res_mask));
m_dir_gamma[i] = (HiResT)uround(pow(i / double(gamma_mask), m_gamma) * double(hi_res_mask));
}
double inv_g = 1.0 / g;
for(i = 0; i < hi_res_size; i++)
for (i = 0; i < hi_res_size; i++)
{
m_inv_gamma[i] = (LoResT)
uround(pow(i / double(hi_res_mask), inv_g) * double(gamma_mask));
m_inv_gamma[i] = (LoResT)uround(pow(i / double(hi_res_mask), inv_g) * double(gamma_mask));
}
}
double gamma() const
{
return m_gamma;
}
double gamma() const { return m_gamma; }
HiResT dir(LoResT v) const
{
return m_dir_gamma[unsigned(v)];
}
HiResT dir(LoResT v) const { return m_dir_gamma[unsigned(v)]; }
LoResT inv(HiResT v) const
{
return m_inv_gamma[unsigned(v)];
}
LoResT inv(HiResT v) const { return m_inv_gamma[unsigned(v)]; }
private:
gamma_lut(const self_type&);
const self_type& operator = (const self_type&);
const self_type& operator=(const self_type&);
double m_gamma;
HiResT* m_dir_gamma;
LoResT* m_inv_gamma;
};
};
//
// sRGB support classes
//
//
// sRGB support classes
//
// Optimized sRGB lookup table. The direct conversion (sRGB to linear)
// is a straightforward lookup. The inverse conversion (linear to sRGB)
// is implemented using binary search.
template<class LinearType>
class sRGB_lut_base
{
// Optimized sRGB lookup table. The direct conversion (sRGB to linear)
// is a straightforward lookup. The inverse conversion (linear to sRGB)
// is implemented using binary search.
template<class LinearType>
class sRGB_lut_base
{
public:
LinearType dir(int8u v) const
{
return m_dir_table[v];
}
LinearType dir(int8u v) const { return m_dir_table[v]; }
int8u inv(LinearType v) const
{
// Unrolled binary search.
int8u x = 0;
if (v > m_inv_table[128]) x = 128;
if (v > m_inv_table[x + 64]) x += 64;
if (v > m_inv_table[x + 32]) x += 32;
if (v > m_inv_table[x + 16]) x += 16;
if (v > m_inv_table[x + 8]) x += 8;
if (v > m_inv_table[x + 4]) x += 4;
if (v > m_inv_table[x + 2]) x += 2;
if (v > m_inv_table[x + 1]) x += 1;
if (v > m_inv_table[128])
x = 128;
if (v > m_inv_table[x + 64])
x += 64;
if (v > m_inv_table[x + 32])
x += 32;
if (v > m_inv_table[x + 16])
x += 16;
if (v > m_inv_table[x + 8])
x += 8;
if (v > m_inv_table[x + 4])
x += 4;
if (v > m_inv_table[x + 2])
x += 2;
if (v > m_inv_table[x + 1])
x += 1;
return x;
}
@ -154,19 +135,17 @@ 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.
// Base template is undefined, specializations are provided below.
template<class LinearType>
class sRGB_lut;
// sRGB_lut - implements sRGB conversion for the various types.
// Base template is undefined, specializations are provided below.
template<class LinearType>
class sRGB_lut;
template<>
class sRGB_lut<float> : public sRGB_lut_base<float>
{
template<>
class sRGB_lut<float> : public sRGB_lut_base<float>
{
public:
sRGB_lut()
{
@ -180,11 +159,11 @@ namespace agg
m_inv_table[i] = float(sRGB_to_linear((i - 0.5) / 255.0));
}
}
};
};
template<>
class sRGB_lut<int16u> : public sRGB_lut_base<int16u>
{
template<>
class sRGB_lut<int16u> : public sRGB_lut_base<int16u>
{
public:
sRGB_lut()
{
@ -198,11 +177,11 @@ namespace agg
m_inv_table[i] = uround(65535.0 * sRGB_to_linear((i - 0.5) / 255.0));
}
}
};
};
template<>
class sRGB_lut<int8u> : public sRGB_lut_base<int8u>
{
template<>
class sRGB_lut<int8u> : public sRGB_lut_base<int8u>
{
public:
sRGB_lut()
{
@ -222,84 +201,66 @@ namespace agg
// In this case, the inverse transform is a simple lookup.
return m_inv_table[v];
}
};
};
// Common base class for sRGB_conv objects. Defines an internal
// sRGB_lut object so that users don't have to.
template<class T>
class sRGB_conv_base
{
// Common base class for sRGB_conv objects. Defines an internal
// sRGB_lut object so that users don't have to.
template<class T>
class sRGB_conv_base
{
public:
static T rgb_from_sRGB(int8u x)
{
return lut.dir(x);
}
static T rgb_from_sRGB(int8u x) { return lut.dir(x); }
static int8u rgb_to_sRGB(T x)
{
return lut.inv(x);
}
static int8u rgb_to_sRGB(T x) { return lut.inv(x); }
private:
static sRGB_lut<T> lut;
};
};
// Definition of sRGB_conv_base::lut. Due to the fact that this a template,
// we don't need to place the definition in a cpp file. Hurrah.
template<class T>
sRGB_lut<T> sRGB_conv_base<T>::lut;
// Definition of sRGB_conv_base::lut. Due to the fact that this a template,
// we don't need to place the definition in a cpp file. Hurrah.
template<class T>
sRGB_lut<T> sRGB_conv_base<T>::lut;
// Wrapper for sRGB-linear conversion.
// Base template is undefined, specializations are provided below.
template<class T>
class sRGB_conv;
// Wrapper for sRGB-linear conversion.
// Base template is undefined, specializations are provided below.
template<class T>
class sRGB_conv;
template<>
class sRGB_conv<float> : public sRGB_conv_base<float>
{
template<>
class sRGB_conv<float> : public sRGB_conv_base<float>
{
public:
static float alpha_from_sRGB(int8u x)
{
return float(x / 255.0);
}
static float alpha_from_sRGB(int8u x) { return float(x / 255.0); }
static int8u alpha_to_sRGB(float x)
{
if (x <= 0) return 0;
else if (x >= 1) return 255;
else return int8u(0.5 + x * 255);
if (x <= 0)
return 0;
else if (x >= 1)
return 255;
else
return int8u(0.5 + x * 255);
}
};
};
template<>
class sRGB_conv<int16u> : public sRGB_conv_base<int16u>
{
template<>
class sRGB_conv<int16u> : public sRGB_conv_base<int16u>
{
public:
static int16u alpha_from_sRGB(int8u x)
{
return (x << 8) | x;
}
static int16u alpha_from_sRGB(int8u x) { return (x << 8) | x; }
static int8u alpha_to_sRGB(int16u x)
{
return x >> 8;
}
};
static int8u alpha_to_sRGB(int16u x) { return x >> 8; }
};
template<>
class sRGB_conv<int8u> : public sRGB_conv_base<int8u>
{
template<>
class sRGB_conv<int8u> : public sRGB_conv_base<int8u>
{
public:
static int8u alpha_from_sRGB(int8u x)
{
return x;
}
static int8u alpha_from_sRGB(int8u x) { return x; }
static int8u alpha_to_sRGB(int8u x)
{
return x;
}
};
}
static int8u alpha_to_sRGB(int8u x) { return x; }
};
} // namespace agg
#endif

43
deps/agg/include/agg_glyph_raster_bin.h vendored
View file

@ -19,29 +19,30 @@
#include <cstring>
#include "agg_basics.h"
namespace agg
{
namespace agg {
//========================================================glyph_raster_bin
template<class ColorT> class glyph_raster_bin
{
//========================================================glyph_raster_bin
template<class ColorT>
class glyph_raster_bin
{
public:
typedef ColorT color_type;
//--------------------------------------------------------------------
struct glyph_rect
{
int x1,y1,x2,y2;
int x1, y1, x2, y2;
double dx, dy;
};
//--------------------------------------------------------------------
glyph_raster_bin(const int8u* font) :
m_font(font),
m_big_endian(false)
glyph_raster_bin(const int8u* font)
: m_font(font)
, 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));
}
@ -61,11 +62,10 @@ namespace agg
unsigned num_chars = m_font[3];
unsigned w = 0;
while(*str)
while (*str)
{
unsigned glyph = *str;
const int8u* bits = m_font + 4 + num_chars * 2 +
value(m_font + 4 + (glyph - start_char) * 2);
const int8u* bits = m_font + 4 + num_chars * 2 + value(m_font + 4 + (glyph - start_char) * 2);
w += *bits;
++str;
}
@ -78,15 +78,14 @@ namespace agg
unsigned start_char = m_font[2];
unsigned num_chars = m_font[3];
m_bits = m_font + 4 + num_chars * 2 +
value(m_font + 4 + (glyph - start_char) * 2);
m_bits = m_font + 4 + num_chars * 2 + value(m_font + 4 + (glyph - start_char) * 2);
m_glyph_width = *m_bits++;
m_glyph_byte_width = (m_glyph_width + 7) >> 3;
r->x1 = int(x);
r->x2 = r->x1 + m_glyph_width - 1;
if(flip)
if (flip)
{
r->y1 = int(y) - m_font[0] + m_font[1];
r->y2 = r->y1 + m_font[0] - 1;
@ -108,11 +107,11 @@ namespace agg
unsigned j;
unsigned val = *bits;
unsigned nb = 0;
for(j = 0; j < m_glyph_width; ++j)
for (j = 0; j < m_glyph_width; ++j)
{
m_span[j] = (cover_type)((val & 0x80) ? cover_full : cover_none);
val <<= 1;
if(++nb >= 8)
if (++nb >= 8)
{
val = *++bits;
nb = 0;
@ -126,7 +125,7 @@ namespace agg
int16u value(const int8u* p) const
{
int16u v;
if(m_big_endian)
if (m_big_endian)
{
*(int8u*)&v = p[1];
*((int8u*)&v + 1) = p[0];
@ -139,7 +138,6 @@ namespace agg
return v;
}
//--------------------------------------------------------------------
const int8u* m_font;
bool m_big_endian;
@ -147,9 +145,8 @@ namespace agg
const int8u* m_bits;
unsigned m_glyph_width;
unsigned m_glyph_byte_width;
};
};
}
} // namespace agg
#endif

194
deps/agg/include/agg_gradient_lut.h vendored
View file

@ -21,110 +21,100 @@
#include "agg_color_rgba.h"
#include "agg_color_gray.h"
namespace agg
{
namespace agg {
//======================================================color_interpolator
template<class ColorT> struct color_interpolator
{
//======================================================color_interpolator
template<class ColorT>
struct color_interpolator
{
public:
typedef ColorT color_type;
color_interpolator(const color_type& c1,
const color_type& c2,
unsigned len) :
m_c1(c1),
m_c2(c2),
m_len(len),
m_count(0)
color_interpolator(const color_type& c1, const color_type& c2, unsigned len)
: m_c1(c1)
, m_c2(c2)
, m_len(len)
, m_count(0)
{}
void operator ++ ()
{
++m_count;
}
void operator++() { ++m_count; }
color_type color() const
{
return m_c1.gradient(m_c2, double(m_count) / m_len);
}
color_type color() const { return m_c1.gradient(m_c2, double(m_count) / m_len); }
private:
color_type m_c1;
color_type m_c2;
unsigned m_len;
unsigned m_count;
};
};
//========================================================================
// Fast specialization for rgba8
template<> struct color_interpolator<rgba8>
{
//========================================================================
// Fast specialization for rgba8
template<>
struct color_interpolator<rgba8>
{
public:
typedef rgba8 color_type;
color_interpolator(const color_type& c1,
const color_type& c2,
unsigned len) :
r(c1.r, c2.r, len),
g(c1.g, c2.g, len),
b(c1.b, c2.b, len),
a(c1.a, c2.a, len)
color_interpolator(const color_type& c1, const color_type& c2, unsigned len)
: r(c1.r, c2.r, len)
, g(c1.g, c2.g, len)
, b(c1.b, c2.b, len)
, a(c1.a, c2.a, len)
{}
void operator ++ ()
void operator++()
{
++r; ++g; ++b; ++a;
++r;
++g;
++b;
++a;
}
color_type color() const
{
return color_type(r.y(), g.y(), b.y(), a.y());
}
color_type color() const { return color_type(r.y(), g.y(), b.y(), a.y()); }
private:
agg::dda_line_interpolator<14> r, g, b, a;
};
};
//========================================================================
// Fast specialization for gray8
template<> struct color_interpolator<gray8>
{
//========================================================================
// Fast specialization for gray8
template<>
struct color_interpolator<gray8>
{
public:
typedef gray8 color_type;
color_interpolator(const color_type& c1,
const color_type& c2,
unsigned len) :
v(c1.v, c2.v, len),
a(c1.a, c2.a, len)
color_interpolator(const color_type& c1, const color_type& c2, unsigned len)
: v(c1.v, c2.v, len)
, a(c1.a, c2.a, len)
{}
void operator ++ ()
void operator++()
{
++v; ++a;
++v;
++a;
}
color_type color() const
{
return color_type(v.y(), a.y());
}
color_type color() const { return color_type(v.y(), a.y()); }
private:
agg::dda_line_interpolator<14> v,a;
};
agg::dda_line_interpolator<14> v, a;
};
//============================================================gradient_lut
template<class ColorInterpolator,
unsigned ColorLutSize=256> class gradient_lut
{
//============================================================gradient_lut
template<class ColorInterpolator, unsigned ColorLutSize = 256>
class gradient_lut
{
public:
typedef ColorInterpolator interpolator_type;
typedef typename interpolator_type::color_type color_type;
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()
{
return color_lut_size;
}
const color_type& operator [] (unsigned i) const
{
return m_color_lut[i];
}
static unsigned size() { return color_lut_size; }
const color_type& operator[](unsigned i) const { return m_color_lut[i]; }
private:
//--------------------------------------------------------------------
@ -160,69 +144,62 @@ namespace agg
color_type color;
color_point() {}
color_point(double off, const color_type& c) :
offset(off), color(c)
color_point(double off, const color_type& c)
: offset(off)
, color(c)
{
if(offset < 0.0) offset = 0.0;
if(offset > 1.0) offset = 1.0;
if (offset < 0.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)
{
return a.offset < b.offset;
}
static bool offset_equal(const color_point& a, const color_point& b)
{
return a.offset == b.offset;
}
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; }
//--------------------------------------------------------------------
color_profile_type m_color_profile;
color_lut_type m_color_lut;
};
};
//------------------------------------------------------------------------
template<class T, unsigned S>
void gradient_lut<T,S>::remove_all()
{
//------------------------------------------------------------------------
template<class T, unsigned S>
void gradient_lut<T, S>::remove_all()
{
m_color_profile.remove_all();
}
}
//------------------------------------------------------------------------
template<class T, unsigned S>
void gradient_lut<T,S>::add_color(double offset, const color_type& color)
{
//------------------------------------------------------------------------
template<class T, unsigned S>
void gradient_lut<T, S>::add_color(double offset, const color_type& color)
{
m_color_profile.add(color_point(offset, color));
}
}
//------------------------------------------------------------------------
template<class T, unsigned S>
bool gradient_lut<T,S>::build_lut()
{
//------------------------------------------------------------------------
template<class T, unsigned S>
bool gradient_lut<T, S>::build_lut()
{
quick_sort(m_color_profile, offset_less);
m_color_profile.cut_at(remove_duplicates(m_color_profile, offset_equal));
if(m_color_profile.size() >= 2)
if (m_color_profile.size() >= 2)
{
unsigned i;
unsigned start = uround(m_color_profile[0].offset * color_lut_size);
unsigned end = 0;
color_type c = m_color_profile[0].color;
for(i = 0; i < start; i++)
for (i = 0; i < start; i++)
{
m_color_lut[i] = c;
}
for(i = 1; i < m_color_profile.size(); i++)
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,
m_color_profile[i ].color,
end - start + 1);
while(start < end)
interpolator_type ci(m_color_profile[i - 1].color, m_color_profile[i].color, end - start + 1);
while (start < end)
{
m_color_lut[start] = ci.color();
++ci;
@ -230,17 +207,14 @@ namespace agg
}
}
c = m_color_profile.last().color;
for(; end < m_color_lut.size(); end++)
for (; end < m_color_lut.size(); end++)
{
m_color_lut[end] = c;
}
return true;
}
return false;
}
}
} // namespace agg
#endif

73
deps/agg/include/agg_gsv_text.h vendored
View file

@ -24,23 +24,15 @@
#include "agg_conv_stroke.h"
#include "agg_conv_transform.h"
namespace agg
namespace agg {
//---------------------------------------------------------------gsv_text
//
// See Implementation agg_gsv_text.cpp
//
class gsv_text
{
//---------------------------------------------------------------gsv_text
//
// See Implementation agg_gsv_text.cpp
//
class gsv_text
{
enum status
{
initial,
next_char,
start_glyph,
glyph
};
enum status { initial, next_char, start_glyph, glyph };
public:
gsv_text();
@ -48,7 +40,7 @@ namespace agg
void font(const void* font);
void flip(bool flip_y) { m_flip = flip_y; }
void load_font(const char* file);
void size(double height, double width=0.0);
void size(double height, double width = 0.0);
void space(double space);
void line_space(double line_space);
void start_point(double x, double y);
@ -62,12 +54,12 @@ namespace agg
private:
// not supposed to be copied
gsv_text(const gsv_text&);
const gsv_text& operator = (const gsv_text&);
const gsv_text& operator=(const gsv_text&);
int16u value(const int8u* p) const
{
int16u v;
if(m_big_endian)
if (m_big_endian)
{
*(int8u*)&v = p[1];
*((int8u*)&v + 1) = p[0];
@ -103,30 +95,21 @@ namespace agg
int8* m_eglyph;
double m_w;
double m_h;
};
};
//--------------------------------------------------------gsv_text_outline
template<class Transformer = trans_affine> class gsv_text_outline
{
//--------------------------------------------------------gsv_text_outline
template<class Transformer = trans_affine>
class gsv_text_outline
{
public:
gsv_text_outline(gsv_text& text, const Transformer& trans) :
m_polyline(text),
m_trans(m_polyline, trans)
{
}
gsv_text_outline(gsv_text& text, const Transformer& trans)
: m_polyline(text)
, m_trans(m_polyline, trans)
{}
void width(double w)
{
m_polyline.width(w);
}
void width(double w) { m_polyline.width(w); }
void transformer(const Transformer* trans)
{
m_trans->transformer(trans);
}
void transformer(const 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)
{
return m_trans.vertex(x, y);
}
unsigned vertex(double* x, double* 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

319
deps/agg/include/agg_image_accessors.h vendored
View file

@ -18,12 +18,12 @@
#include "agg_basics.h"
namespace agg
{
namespace agg {
//-----------------------------------------------------image_accessor_clip
template<class PixFmt> class image_accessor_clip
{
//-----------------------------------------------------image_accessor_clip
template<class PixFmt>
class image_accessor_clip
{
public:
typedef PixFmt pixfmt_type;
typedef typename pixfmt_type::color_type color_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,
const color_type& bk) :
m_pixf(&pixf)
explicit image_accessor_clip(const pixfmt_type& pixf, const color_type& bk)
: m_pixf(&pixf)
{
pixfmt_type::make_pix(m_bk_buf, bk);
}
void attach(const pixfmt_type& pixf)
{
m_pixf = &pixf;
}
void attach(const pixfmt_type& pixf) { m_pixf = &pixf; }
void background_color(const color_type& bk)
{
pixfmt_type::make_pix(m_bk_buf, bk);
}
void background_color(const color_type& bk) { pixfmt_type::make_pix(m_bk_buf, bk); }
private:
AGG_INLINE const int8u* pixel() const
{
if(m_y >= 0 && m_y < (int)m_pixf->height() &&
m_x >= 0 && m_x < (int)m_pixf->width())
if (m_y >= 0 && m_y < (int)m_pixf->height() && m_x >= 0 && m_x < (int)m_pixf->width())
{
return m_pixf->pix_ptr(m_x, m_y);
}
@ -65,8 +57,7 @@ namespace agg
{
m_x = m_x0 = x;
m_y = y;
if(y >= 0 && y < (int)m_pixf->height() &&
x >= 0 && x+(int)len <= (int)m_pixf->width())
if (y >= 0 && y < (int)m_pixf->height() && x >= 0 && x + (int)len <= (int)m_pixf->width())
{
return m_pix_ptr = m_pixf->pix_ptr(x, y);
}
@ -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 &&
m_y >= 0 && m_y < (int)m_pixf->height())
if (m_pix_ptr && m_y >= 0 && m_y < (int)m_pixf->height())
{
return m_pix_ptr = m_pixf->pix_ptr(m_x, m_y);
}
@ -99,14 +90,12 @@ namespace agg
int8u m_bk_buf[4];
int m_x, m_x0, m_y;
const int8u* m_pix_ptr;
};
};
//--------------------------------------------------image_accessor_no_clip
template<class PixFmt> class image_accessor_no_clip
{
//--------------------------------------------------image_accessor_no_clip
template<class PixFmt>
class image_accessor_no_clip
{
public:
typedef PixFmt pixfmt_type;
typedef typename pixfmt_type::color_type color_type;
@ -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) :
m_pixf(&pixf)
explicit image_accessor_no_clip(const pixfmt_type& pixf)
: m_pixf(&pixf)
{}
void attach(const pixfmt_type& pixf)
{
m_pixf = &pixf;
}
void attach(const pixfmt_type& 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()
{
return m_pix_ptr += pix_width;
}
AGG_INLINE const int8u* next_x() { return m_pix_ptr += pix_width; }
AGG_INLINE const int8u* next_y()
{
@ -146,14 +129,12 @@ namespace agg
const pixfmt_type* m_pixf;
int m_x, m_y;
const int8u* m_pix_ptr;
};
};
//----------------------------------------------------image_accessor_clone
template<class PixFmt> class image_accessor_clone
{
//----------------------------------------------------image_accessor_clone
template<class PixFmt>
class image_accessor_clone
{
public:
typedef PixFmt pixfmt_type;
typedef typename pixfmt_type::color_type color_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) :
m_pixf(&pixf)
explicit image_accessor_clone(const pixfmt_type& pixf)
: m_pixf(&pixf)
{}
void attach(const pixfmt_type& pixf)
{
m_pixf = &pixf;
}
void attach(const pixfmt_type& pixf) { m_pixf = &pixf; }
private:
AGG_INLINE const int8u* pixel() const
{
int x = m_x;
int y = m_y;
if(x < 0) x = 0;
if(y < 0) y = 0;
if(x >= (int)m_pixf->width()) x = m_pixf->width() - 1;
if(y >= (int)m_pixf->height()) y = m_pixf->height() - 1;
if (x < 0)
x = 0;
if (y < 0)
y = 0;
if (x >= (int)m_pixf->width())
x = m_pixf->width() - 1;
if (y >= (int)m_pixf->height())
y = m_pixf->height() - 1;
return m_pixf->pix_ptr(x, y);
}
@ -188,8 +170,7 @@ namespace agg
{
m_x = m_x0 = x;
m_y = y;
if(y >= 0 && y < (int)m_pixf->height() &&
x >= 0 && x+(int)len <= (int)m_pixf->width())
if (y >= 0 && y < (int)m_pixf->height() && x >= 0 && x + (int)len <= (int)m_pixf->width())
{
return m_pix_ptr = m_pixf->pix_ptr(x, y);
}
@ -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 &&
m_y >= 0 && m_y < (int)m_pixf->height())
if (m_pix_ptr && m_y >= 0 && m_y < (int)m_pixf->height())
{
return m_pix_ptr = m_pixf->pix_ptr(m_x, m_y);
}
@ -221,15 +202,12 @@ namespace agg
const pixfmt_type* m_pixf;
int m_x, m_x0, m_y;
const int8u* m_pix_ptr;
};
};
//-----------------------------------------------------image_accessor_wrap
template<class PixFmt, class WrapX, class WrapY> class image_accessor_wrap
{
//-----------------------------------------------------image_accessor_wrap
template<class PixFmt, class WrapX, class WrapY>
class image_accessor_wrap
{
public:
typedef PixFmt pixfmt_type;
typedef typename pixfmt_type::color_type color_type;
@ -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) :
m_pixf(&pixf),
m_wrap_x(pixf.width()),
m_wrap_y(pixf.height())
explicit image_accessor_wrap(const pixfmt_type& pixf)
: m_pixf(&pixf)
, m_wrap_x(pixf.width())
, m_wrap_y(pixf.height())
{}
void attach(const pixfmt_type& pixf)
{
m_pixf = &pixf;
}
void attach(const pixfmt_type& pixf) { m_pixf = &pixf; }
AGG_INLINE const int8u* span(int x, int y, unsigned)
{
@ -274,88 +249,85 @@ namespace agg
int m_x;
WrapX m_wrap_x;
WrapY m_wrap_y;
};
};
//--------------------------------------------------------wrap_mode_repeat
class wrap_mode_repeat
{
//--------------------------------------------------------wrap_mode_repeat
class wrap_mode_repeat
{
public:
wrap_mode_repeat() {}
wrap_mode_repeat(unsigned size) :
m_size(size),
m_add(size * (0x3FFFFFFF / size)),
m_value(0)
wrap_mode_repeat(unsigned size)
: m_size(size)
, m_add(size * (0x3FFFFFFF / size))
, m_value(0)
{}
AGG_INLINE unsigned operator() (int v)
{
return m_value = (unsigned(v) + m_add) % m_size;
}
AGG_INLINE unsigned operator()(int v) { return m_value = (unsigned(v) + m_add) % m_size; }
AGG_INLINE unsigned operator++ ()
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
{
//---------------------------------------------------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)
{
return m_value = unsigned(v) & m_mask;
}
AGG_INLINE unsigned operator++ ()
AGG_INLINE unsigned operator()(int v) { return m_value = unsigned(v) & m_mask; }
AGG_INLINE unsigned operator++()
{
++m_value;
if(m_value > m_mask) m_value = 0;
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
{
//----------------------------------------------wrap_mode_repeat_auto_pow2
class wrap_mode_repeat_auto_pow2
{
public:
wrap_mode_repeat_auto_pow2() {}
wrap_mode_repeat_auto_pow2(unsigned size) :
m_size(size),
m_add(size * (0x3FFFFFFF / size)),
m_mask((m_size & (m_size-1)) ? 0 : m_size-1),
m_value(0)
wrap_mode_repeat_auto_pow2(unsigned size)
: m_size(size)
, m_add(size * (0x3FFFFFFF / size))
, m_mask((m_size & (m_size - 1)) ? 0 : m_size - 1)
, m_value(0)
{}
AGG_INLINE unsigned operator() (int v)
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++ ()
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;
}
@ -364,105 +336,110 @@ namespace agg
unsigned m_add;
unsigned m_mask;
unsigned m_value;
};
};
//-------------------------------------------------------wrap_mode_reflect
class wrap_mode_reflect
{
//-------------------------------------------------------wrap_mode_reflect
class wrap_mode_reflect
{
public:
wrap_mode_reflect() {}
wrap_mode_reflect(unsigned size) :
m_size(size),
m_size2(size * 2),
m_add(m_size2 * (0x3FFFFFFF / m_size2)),
m_value(0)
wrap_mode_reflect(unsigned size)
: m_size(size)
, m_size2(size * 2)
, m_add(m_size2 * (0x3FFFFFFF / m_size2))
, m_value(0)
{}
AGG_INLINE unsigned operator() (int v)
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++ ()
AGG_INLINE unsigned operator++()
{
++m_value;
if(m_value >= m_size2) m_value = 0;
if(m_value >= m_size) return m_size2 - m_value - 1;
if (m_value >= m_size2)
m_value = 0;
if (m_value >= m_size)
return m_size2 - m_value - 1;
return m_value;
}
private:
unsigned m_size;
unsigned m_size2;
unsigned m_add;
unsigned m_value;
};
};
//--------------------------------------------------wrap_mode_reflect_pow2
class wrap_mode_reflect_pow2
{
//--------------------------------------------------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;
while(m_mask < size)
while (m_mask < size)
{
m_mask = (m_mask << 1) | 1;
m_size <<= 1;
}
}
AGG_INLINE unsigned operator() (int v)
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++ ()
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
{
//---------------------------------------------wrap_mode_reflect_auto_pow2
class wrap_mode_reflect_auto_pow2
{
public:
wrap_mode_reflect_auto_pow2() {}
wrap_mode_reflect_auto_pow2(unsigned size) :
m_size(size),
m_size2(size * 2),
m_add(m_size2 * (0x3FFFFFFF / m_size2)),
m_mask((m_size2 & (m_size2-1)) ? 0 : m_size2-1),
m_value(0)
wrap_mode_reflect_auto_pow2(unsigned size)
: m_size(size)
, m_size2(size * 2)
, m_add(m_size2 * (0x3FFFFFFF / m_size2))
, m_mask((m_size2 & (m_size2 - 1)) ? 0 : m_size2 - 1)
, m_value(0)
{}
AGG_INLINE unsigned operator() (int v)
AGG_INLINE unsigned operator()(int v)
{
m_value = m_mask ? unsigned(v) & m_mask :
(unsigned(v) + m_add) % m_size2;
if(m_value >= m_size) return m_size2 - m_value - 1;
m_value = m_mask ? unsigned(v) & m_mask : (unsigned(v) + m_add) % m_size2;
if (m_value >= m_size)
return m_size2 - m_value - 1;
return m_value;
}
AGG_INLINE unsigned operator++ ()
AGG_INLINE unsigned operator++()
{
++m_value;
if(m_value >= m_size2) m_value = 0;
if(m_value >= m_size) return m_size2 - m_value - 1;
if (m_value >= m_size2)
m_value = 0;
if (m_value >= m_size)
return m_size2 - m_value - 1;
return m_value;
}
@ -472,10 +449,8 @@ namespace agg
unsigned m_add;
unsigned m_mask;
unsigned m_value;
};
}
};
} // namespace agg
#endif

539
deps/agg/include/agg_image_filters.h vendored
View file

@ -24,57 +24,56 @@
#include "agg_math.h"
#include <cstdint>
namespace agg
{
namespace agg {
// See Implementation agg_image_filters.cpp
// 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
{
//-----------------------------------------------------image_filter_lut
class image_filter_lut
{
public:
template<class FilterF> void calculate(const FilterF& filter,
bool normalization=true)
template<class FilterF>
void calculate(const FilterF& filter, bool normalization = true)
{
double r = filter.radius();
realloc_lut(r);
unsigned i;
unsigned pivot = diameter() << (image_subpixel_shift - 1);
for(i = 0; i < pivot; i++)
for (i = 0; i < pivot; i++)
{
double x = double(i) / double(image_subpixel_scale);
double y = filter.calc_weight(x);
m_weight_array[pivot + i] =
m_weight_array[pivot - i] =
m_weight_array[pivot + i] = m_weight_array[pivot - i] =
static_cast<std::int16_t>(iround(y * static_cast<double>(image_filter_scale)));
}
unsigned end = (diameter() << image_subpixel_shift) - 1;
m_weight_array[0] = m_weight_array[end];
if(normalization)
if (normalization)
{
normalize();
}
}
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,
bool normalization=true)
template<class FilterF>
image_filter_lut(const FilterF& filter, bool normalization = true)
{
calculate(filter, normalization);
}
@ -88,121 +87,101 @@ namespace agg
private:
void realloc_lut(double radius);
image_filter_lut(const image_filter_lut&);
const image_filter_lut& operator = (const image_filter_lut&);
const image_filter_lut& operator=(const image_filter_lut&);
double m_radius;
unsigned m_diameter;
int m_start;
pod_array<std::int16_t> m_weight_array;
};
};
//--------------------------------------------------------image_filter
template<class FilterF> class image_filter : public image_filter_lut
{
//--------------------------------------------------------image_filter
template<class FilterF>
class image_filter : public image_filter_lut
{
public:
image_filter()
{
calculate(m_filter_function);
}
image_filter() { calculate(m_filter_function); }
private:
FilterF m_filter_function;
};
};
//-----------------------------------------------image_filter_bilinear
struct image_filter_bilinear
{
//-----------------------------------------------image_filter_bilinear
struct image_filter_bilinear
{
static double radius() { return 1.0; }
static double calc_weight(double x)
{
return 1.0 - x;
}
};
static double calc_weight(double x) { return 1.0 - x; }
};
//-----------------------------------------------image_filter_hanning
struct image_filter_hanning
{
//-----------------------------------------------image_filter_hanning
struct image_filter_hanning
{
static double radius() { return 1.0; }
static double calc_weight(double x)
{
return 0.5 + 0.5 * std::cos(pi * x);
}
};
static double calc_weight(double x) { return 0.5 + 0.5 * std::cos(pi * x); }
};
//-----------------------------------------------image_filter_hamming
struct image_filter_hamming
{
//-----------------------------------------------image_filter_hamming
struct image_filter_hamming
{
static double radius() { return 1.0; }
static double calc_weight(double x)
{
return 0.54 + 0.46 * std::cos(pi * x);
}
};
static double calc_weight(double x) { return 0.54 + 0.46 * std::cos(pi * x); }
};
//-----------------------------------------------image_filter_hermite
struct image_filter_hermite
{
//-----------------------------------------------image_filter_hermite
struct image_filter_hermite
{
static double radius() { return 1.0; }
static double calc_weight(double x)
{
return (2.0 * x - 3.0) * x * x + 1.0;
}
};
static double calc_weight(double x) { return (2.0 * x - 3.0) * x * x + 1.0; }
};
//------------------------------------------------image_filter_quadric
struct image_filter_quadric
{
//------------------------------------------------image_filter_quadric
struct image_filter_quadric
{
static double radius() { return 1.5; }
static double calc_weight(double x)
{
double t;
if(x < 0.5) return 0.75 - x * x;
if(x < 1.5) {t = x - 1.5; return 0.5 * t * t;}
if (x < 0.5)
return 0.75 - x * x;
if (x < 1.5)
{
t = x - 1.5;
return 0.5 * t * t;
}
return 0.0;
}
};
};
//------------------------------------------------image_filter_bicubic
class image_filter_bicubic
{
static double pow3(double x)
{
return (x <= 0.0) ? 0.0 : x * x * x;
}
//------------------------------------------------image_filter_bicubic
class image_filter_bicubic
{
static double pow3(double x) { return (x <= 0.0) ? 0.0 : x * x * x; }
public:
static double radius() { return 2.0; }
static double calc_weight(double x)
{
return
(1.0/6.0) *
(pow3(x + 2) - 4 * pow3(x + 1) + 6 * pow3(x) - 4 * pow3(x - 1));
return (1.0 / 6.0) * (pow3(x + 2) - 4 * pow3(x + 1) + 6 * pow3(x) - 4 * pow3(x - 1));
}
};
};
//-------------------------------------------------image_filter_kaiser
class image_filter_kaiser
{
//-------------------------------------------------image_filter_kaiser
class image_filter_kaiser
{
double a;
double i0a;
double epsilon;
public:
image_filter_kaiser(double b = 6.33) :
a(b), epsilon(1e-12)
image_filter_kaiser(double b = 6.33)
: a(b)
, epsilon(1e-12)
{
i0a = 1.0 / bessel_i0(b);
}
static double radius() { return 1.0; }
double calc_weight(double x) const
{
return bessel_i0(a * sqrt(1. - x * x)) * i0a;
}
double calc_weight(double x) const { return bessel_i0(a * sqrt(1. - x * x)) * i0a; }
private:
double bessel_i0(double x) const
@ -214,237 +193,331 @@ namespace agg
y = x * x / 4.;
t = y;
for(i = 2; t > epsilon; i++)
for (i = 2; t > epsilon; i++)
{
sum += t;
t *= (double)y / (i * i);
}
return sum;
}
};
};
//----------------------------------------------image_filter_catrom
struct image_filter_catrom
{
//----------------------------------------------image_filter_catrom
struct image_filter_catrom
{
static double radius() { return 2.0; }
static double calc_weight(double x)
{
if(x < 1.0) return 0.5 * (2.0 + x * x * (-5.0 + x * 3.0));
if(x < 2.0) return 0.5 * (4.0 + x * (-8.0 + x * (5.0 - x)));
if (x < 1.0)
return 0.5 * (2.0 + x * x * (-5.0 + x * 3.0));
if (x < 2.0)
return 0.5 * (4.0 + x * (-8.0 + x * (5.0 - x)));
return 0.;
}
};
};
//---------------------------------------------image_filter_mitchell
class image_filter_mitchell
{
//---------------------------------------------image_filter_mitchell
class image_filter_mitchell
{
double p0, p2, p3;
double q0, q1, q2, q3;
public:
image_filter_mitchell(double b = 1.0/3.0, double c = 1.0/3.0) :
p0((6.0 - 2.0 * b) / 6.0),
p2((-18.0 + 12.0 * b + 6.0 * c) / 6.0),
p3((12.0 - 9.0 * b - 6.0 * c) / 6.0),
q0((8.0 * b + 24.0 * c) / 6.0),
q1((-12.0 * b - 48.0 * c) / 6.0),
q2((6.0 * b + 30.0 * c) / 6.0),
q3((-b - 6.0 * c) / 6.0)
image_filter_mitchell(double b = 1.0 / 3.0, double c = 1.0 / 3.0)
: p0((6.0 - 2.0 * b) / 6.0)
, p2((-18.0 + 12.0 * b + 6.0 * c) / 6.0)
, p3((12.0 - 9.0 * b - 6.0 * c) / 6.0)
, q0((8.0 * b + 24.0 * c) / 6.0)
, q1((-12.0 * b - 48.0 * c) / 6.0)
, q2((6.0 * b + 30.0 * c) / 6.0)
, q3((-b - 6.0 * c) / 6.0)
{}
static double radius() { return 2.0; }
double calc_weight(double x) const
{
if(x < 1.0) return p0 + x * x * (p2 + x * p3);
if(x < 2.0) return q0 + x * (q1 + x * (q2 + x * q3));
if (x < 1.0)
return p0 + x * x * (p2 + x * p3);
if (x < 2.0)
return q0 + x * (q1 + x * (q2 + x * q3));
return 0.0;
}
};
};
//----------------------------------------------image_filter_spline16
struct image_filter_spline16
{
//----------------------------------------------image_filter_spline16
struct image_filter_spline16
{
static double radius() { return 2.0; }
static double calc_weight(double x)
{
if(x < 1.0)
if (x < 1.0)
{
return ((x - 9.0/5.0 ) * x - 1.0/5.0 ) * x + 1.0;
return ((x - 9.0 / 5.0) * x - 1.0 / 5.0) * x + 1.0;
}
return ((-1.0/3.0 * (x-1) + 4.0/5.0) * (x-1) - 7.0/15.0 ) * (x-1);
return ((-1.0 / 3.0 * (x - 1) + 4.0 / 5.0) * (x - 1) - 7.0 / 15.0) * (x - 1);
}
};
};
//---------------------------------------------image_filter_spline36
struct image_filter_spline36
{
//---------------------------------------------image_filter_spline36
struct image_filter_spline36
{
static double radius() { return 3.0; }
static double calc_weight(double x)
{
if(x < 1.0)
if (x < 1.0)
{
return ((13.0/11.0 * x - 453.0/209.0) * x - 3.0/209.0) * x + 1.0;
return ((13.0 / 11.0 * x - 453.0 / 209.0) * x - 3.0 / 209.0) * x + 1.0;
}
if(x < 2.0)
if (x < 2.0)
{
return ((-6.0/11.0 * (x-1) + 270.0/209.0) * (x-1) - 156.0/ 209.0) * (x-1);
return ((-6.0 / 11.0 * (x - 1) + 270.0 / 209.0) * (x - 1) - 156.0 / 209.0) * (x - 1);
}
return ((1.0/11.0 * (x-2) - 45.0/209.0) * (x-2) + 26.0/209.0) * (x-2);
return ((1.0 / 11.0 * (x - 2) - 45.0 / 209.0) * (x - 2) + 26.0 / 209.0) * (x - 2);
}
};
};
//----------------------------------------------image_filter_gaussian
struct image_filter_gaussian
{
//----------------------------------------------image_filter_gaussian
struct image_filter_gaussian
{
static double radius() { return 2.0; }
static double calc_weight(double x)
{
return exp(-2.0 * x * x) * sqrt(2.0 / pi);
}
};
static double calc_weight(double x) { return exp(-2.0 * x * x) * sqrt(2.0 / pi); }
};
//------------------------------------------------image_filter_bessel
struct image_filter_bessel
{
//------------------------------------------------image_filter_bessel
struct image_filter_bessel
{
static double radius() { return 3.2383; }
static double calc_weight(double x)
{
return (x == 0.0) ? pi / 4.0 : besj(pi * x, 1) / (2.0 * x);
}
};
static double calc_weight(double x) { return (x == 0.0) ? pi / 4.0 : besj(pi * x, 1) / (2.0 * x); }
};
//-------------------------------------------------image_filter_sinc
class image_filter_sinc
{
//-------------------------------------------------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
{
//-----------------------------------------------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 > m_radius) return 0.0;
if (x == 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
{
//----------------------------------------------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 > m_radius) return 0.0;
if (x == 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));
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){} };
//------------------------------------------------image_filter_sinc36
class image_filter_sinc36 : public image_filter_sinc
{
public:
image_filter_sinc36()
: image_filter_sinc(3.0)
{}
};
//------------------------------------------------image_filter_sinc64
class image_filter_sinc64 : public image_filter_sinc
{ public: image_filter_sinc64() : image_filter_sinc(4.0){} };
//------------------------------------------------image_filter_sinc64
class image_filter_sinc64 : public image_filter_sinc
{
public:
image_filter_sinc64()
: image_filter_sinc(4.0)
{}
};
//-----------------------------------------------image_filter_sinc100
class image_filter_sinc100 : public image_filter_sinc
{ public: image_filter_sinc100() : image_filter_sinc(5.0){} };
//-----------------------------------------------image_filter_sinc100
class image_filter_sinc100 : public image_filter_sinc
{
public:
image_filter_sinc100()
: image_filter_sinc(5.0)
{}
};
//-----------------------------------------------image_filter_sinc144
class image_filter_sinc144 : public image_filter_sinc
{ public: image_filter_sinc144() : image_filter_sinc(6.0){} };
//-----------------------------------------------image_filter_sinc144
class image_filter_sinc144 : public image_filter_sinc
{
public:
image_filter_sinc144()
: image_filter_sinc(6.0)
{}
};
//-----------------------------------------------image_filter_sinc196
class image_filter_sinc196 : public image_filter_sinc
{ public: image_filter_sinc196() : image_filter_sinc(7.0){} };
//-----------------------------------------------image_filter_sinc196
class image_filter_sinc196 : public image_filter_sinc
{
public:
image_filter_sinc196()
: image_filter_sinc(7.0)
{}
};
//-----------------------------------------------image_filter_sinc256
class image_filter_sinc256 : public image_filter_sinc
{ public: image_filter_sinc256() : image_filter_sinc(8.0){} };
//-----------------------------------------------image_filter_sinc256
class image_filter_sinc256 : public image_filter_sinc
{
public:
image_filter_sinc256()
: image_filter_sinc(8.0)
{}
};
//---------------------------------------------image_filter_lanczos36
class image_filter_lanczos36 : public image_filter_lanczos
{ public: image_filter_lanczos36() : image_filter_lanczos(3.0){} };
//---------------------------------------------image_filter_lanczos36
class image_filter_lanczos36 : public image_filter_lanczos
{
public:
image_filter_lanczos36()
: image_filter_lanczos(3.0)
{}
};
//---------------------------------------------image_filter_lanczos64
class image_filter_lanczos64 : public image_filter_lanczos
{ public: image_filter_lanczos64() : image_filter_lanczos(4.0){} };
//---------------------------------------------image_filter_lanczos64
class image_filter_lanczos64 : public image_filter_lanczos
{
public:
image_filter_lanczos64()
: image_filter_lanczos(4.0)
{}
};
//--------------------------------------------image_filter_lanczos100
class image_filter_lanczos100 : public image_filter_lanczos
{ public: image_filter_lanczos100() : image_filter_lanczos(5.0){} };
//--------------------------------------------image_filter_lanczos100
class image_filter_lanczos100 : public image_filter_lanczos
{
public:
image_filter_lanczos100()
: image_filter_lanczos(5.0)
{}
};
//--------------------------------------------image_filter_lanczos144
class image_filter_lanczos144 : public image_filter_lanczos
{ public: image_filter_lanczos144() : image_filter_lanczos(6.0){} };
//--------------------------------------------image_filter_lanczos144
class image_filter_lanczos144 : public image_filter_lanczos
{
public:
image_filter_lanczos144()
: image_filter_lanczos(6.0)
{}
};
//--------------------------------------------image_filter_lanczos196
class image_filter_lanczos196 : public image_filter_lanczos
{ public: image_filter_lanczos196() : image_filter_lanczos(7.0){} };
//--------------------------------------------image_filter_lanczos196
class image_filter_lanczos196 : public image_filter_lanczos
{
public:
image_filter_lanczos196()
: image_filter_lanczos(7.0)
{}
};
//--------------------------------------------image_filter_lanczos256
class image_filter_lanczos256 : public image_filter_lanczos
{ public: image_filter_lanczos256() : image_filter_lanczos(8.0){} };
//--------------------------------------------image_filter_lanczos256
class image_filter_lanczos256 : public image_filter_lanczos
{
public:
image_filter_lanczos256()
: image_filter_lanczos(8.0)
{}
};
//--------------------------------------------image_filter_blackman36
class image_filter_blackman36 : public image_filter_blackman
{ public: image_filter_blackman36() : image_filter_blackman(3.0){} };
//--------------------------------------------image_filter_blackman36
class image_filter_blackman36 : public image_filter_blackman
{
public:
image_filter_blackman36()
: image_filter_blackman(3.0)
{}
};
//--------------------------------------------image_filter_blackman64
class image_filter_blackman64 : public image_filter_blackman
{ public: image_filter_blackman64() : image_filter_blackman(4.0){} };
//--------------------------------------------image_filter_blackman64
class image_filter_blackman64 : public image_filter_blackman
{
public:
image_filter_blackman64()
: image_filter_blackman(4.0)
{}
};
//-------------------------------------------image_filter_blackman100
class image_filter_blackman100 : public image_filter_blackman
{ public: image_filter_blackman100() : image_filter_blackman(5.0){} };
//-------------------------------------------image_filter_blackman100
class image_filter_blackman100 : public image_filter_blackman
{
public:
image_filter_blackman100()
: image_filter_blackman(5.0)
{}
};
//-------------------------------------------image_filter_blackman144
class image_filter_blackman144 : public image_filter_blackman
{ public: image_filter_blackman144() : image_filter_blackman(6.0){} };
//-------------------------------------------image_filter_blackman144
class image_filter_blackman144 : public image_filter_blackman
{
public:
image_filter_blackman144()
: image_filter_blackman(6.0)
{}
};
//-------------------------------------------image_filter_blackman196
class image_filter_blackman196 : public image_filter_blackman
{ public: image_filter_blackman196() : image_filter_blackman(7.0){} };
//-------------------------------------------image_filter_blackman196
class image_filter_blackman196 : public image_filter_blackman
{
public:
image_filter_blackman196()
: image_filter_blackman(7.0)
{}
};
//-------------------------------------------image_filter_blackman256
class image_filter_blackman256 : public image_filter_blackman
{ public: image_filter_blackman256() : image_filter_blackman(8.0){} };
//-------------------------------------------image_filter_blackman256
class image_filter_blackman256 : public image_filter_blackman
{
public:
image_filter_blackman256()
: image_filter_blackman(8.0)
{}
};
}
} // namespace agg
#endif

141
deps/agg/include/agg_line_aa_basics.h vendored
View file

@ -18,82 +18,78 @@
#include <cstdlib>
#include "agg_basics.h"
namespace agg
{
namespace agg {
// See Implementation agg_line_aa_basics.cpp
// 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
line_max_coord = (1 << 28) - 1, //----line_max_coord
line_max_length = 1 << (line_subpixel_shift + 10) //----line_max_length
};
};
//-------------------------------------------------------------------------
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
};
};
//------------------------------------------------------------------line_mr
AGG_INLINE int line_mr(int x)
{
//------------------------------------------------------------------line_mr
AGG_INLINE int line_mr(int x)
{
return x >> (line_subpixel_shift - static_cast<line_subpixel_scale_e>(line_mr_subpixel_shift));
}
}
//-------------------------------------------------------------------line_hr
AGG_INLINE int line_hr(int x)
{
//-------------------------------------------------------------------line_hr
AGG_INLINE int line_hr(int x)
{
return x << (line_subpixel_shift - static_cast<line_subpixel_scale_e>(line_mr_subpixel_shift));
}
}
//---------------------------------------------------------------line_dbl_hr
AGG_INLINE int line_dbl_hr(int x)
{
//---------------------------------------------------------------line_dbl_hr
AGG_INLINE int line_dbl_hr(int x)
{
return x * line_subpixel_scale;
}
}
//---------------------------------------------------------------line_coord
struct line_coord
{
AGG_INLINE static int conv(double x)
{
return iround(x * static_cast<double>(line_subpixel_scale));
}
};
//---------------------------------------------------------------line_coord
struct line_coord
{
AGG_INLINE static int conv(double x) { return iround(x * static_cast<double>(line_subpixel_scale)); }
};
//-----------------------------------------------------------line_coord_sat
struct line_coord_sat
{
//-----------------------------------------------------------line_coord_sat
struct line_coord_sat
{
AGG_INLINE static int conv(double x)
{
return saturation<line_max_coord>::iround(x * static_cast<double>(line_subpixel_scale));
}
};
};
//==========================================================line_parameters
struct line_parameters
{
//==========================================================line_parameters
struct line_parameters
{
//---------------------------------------------------------------------
line_parameters() {}
line_parameters(int x1_, int y1_, int x2_, int y2_, int len_) :
x1(x1_), y1(y1_), x2(x2_), y2(y2_),
dx(std::abs(x2_ - x1_)),
dy(std::abs(y2_ - y1_)),
sx((x2_ > x1_) ? 1 : -1),
sy((y2_ > y1_) ? 1 : -1),
vertical(dy >= dx),
inc(vertical ? sy : sx),
len(len_),
octant((sy & 4) | (sx & 2) | int(vertical))
{
}
line_parameters(int x1_, int y1_, int x2_, int y2_, int len_)
: x1(x1_)
, y1(y1_)
, x2(x2_)
, y2(y2_)
, dx(std::abs(x2_ - x1_))
, dy(std::abs(y2_ - y1_))
, sx((x2_ > x1_) ? 1 : -1)
, sy((y2_ > y1_) ? 1 : -1)
, 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]; }
@ -144,46 +140,35 @@ namespace agg
//---------------------------------------------------------------------
static const int8u s_orthogonal_quadrant[8];
static const int8u s_diagonal_quadrant[8];
};
};
// See Implementation agg_line_aa_basics.cpp
//----------------------------------------------------------------bisectrix
void bisectrix(const line_parameters& l1, const line_parameters& l2, int* x, int* y);
// See Implementation agg_line_aa_basics.cpp
//----------------------------------------------------------------bisectrix
void bisectrix(const line_parameters& l1,
const line_parameters& l2,
int* x, int* y);
//-------------------------------------------fix_degenerate_bisectrix_start
void inline fix_degenerate_bisectrix_start(const line_parameters& lp,
int* x, int* y)
{
int d = iround((double(*x - lp.x2) * double(lp.y2 - lp.y1) -
double(*y - lp.y2) * double(lp.x2 - lp.x1)) / lp.len);
if(d < line_subpixel_scale/2)
//-------------------------------------------fix_degenerate_bisectrix_start
void inline fix_degenerate_bisectrix_start(const line_parameters& lp, int* x, int* y)
{
int d = iround((double(*x - lp.x2) * double(lp.y2 - lp.y1) - double(*y - lp.y2) * double(lp.x2 - lp.x1)) / lp.len);
if (d < line_subpixel_scale / 2)
{
*x = lp.x1 + (lp.y2 - lp.y1);
*y = lp.y1 - (lp.x2 - lp.x1);
}
}
}
//---------------------------------------------fix_degenerate_bisectrix_end
void inline fix_degenerate_bisectrix_end(const line_parameters& lp,
int* x, int* y)
{
int d = iround((double(*x - lp.x2) * double(lp.y2 - lp.y1) -
double(*y - lp.y2) * double(lp.x2 - lp.x1)) / lp.len);
if(d < line_subpixel_scale/2)
//---------------------------------------------fix_degenerate_bisectrix_end
void inline fix_degenerate_bisectrix_end(const line_parameters& lp, int* x, int* y)
{
int d = iround((double(*x - lp.x2) * double(lp.y2 - lp.y1) - double(*y - lp.y2) * double(lp.x2 - lp.x1)) / lp.len);
if (d < line_subpixel_scale / 2)
{
*x = lp.x2 + (lp.y2 - lp.y1);
*y = lp.y2 - (lp.x2 - lp.x1);
}
}
}
} // namespace agg
#endif

412
deps/agg/include/agg_math.h vendored
View file

@ -22,77 +22,67 @@
#include <cmath>
#include "agg_basics.h"
namespace agg
namespace agg {
//------------------------------------------------------vertex_dist_epsilon
// Coinciding points maximal distance (Epsilon)
const double vertex_dist_epsilon = 1e-5;
//-----------------------------------------------------intersection_epsilon
// See calc_intersection
const double intersection_epsilon = 1.0e-30;
//------------------------------------------------------------cross_product
AGG_INLINE double cross_product(double x1, double y1, double x2, double y2, double x, double y)
{
//------------------------------------------------------vertex_dist_epsilon
// Coinciding points maximal distance (Epsilon)
const double vertex_dist_epsilon = 1e-5;
//-----------------------------------------------------intersection_epsilon
// See calc_intersection
const double intersection_epsilon = 1.0e-30;
//------------------------------------------------------------cross_product
AGG_INLINE double cross_product(double x1, double y1,
double x2, double y2,
double x, double y)
{
return (x - x2) * (y2 - y1) - (y - y2) * (x2 - x1);
}
}
//--------------------------------------------------------point_in_triangle
AGG_INLINE bool point_in_triangle(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x, double y)
{
//--------------------------------------------------------point_in_triangle
AGG_INLINE bool point_in_triangle(double x1, double y1, double x2, double y2, double x3, double y3, double x, double y)
{
bool cp1 = cross_product(x1, y1, x2, y2, x, y) < 0.0;
bool cp2 = cross_product(x2, y2, x3, y3, x, y) < 0.0;
bool cp3 = cross_product(x3, y3, x1, y1, x, y) < 0.0;
return cp1 == cp2 && cp2 == cp3 && cp3 == cp1;
}
}
//-----------------------------------------------------------calc_distance
AGG_INLINE double calc_distance(double x1, double y1, double x2, double y2)
{
double dx = x2-x1;
double dy = y2-y1;
//-----------------------------------------------------------calc_distance
AGG_INLINE double calc_distance(double x1, double y1, double x2, double y2)
{
double dx = x2 - x1;
double dy = y2 - y1;
return sqrt(dx * dx + dy * dy);
}
}
//--------------------------------------------------------calc_sq_distance
AGG_INLINE double calc_sq_distance(double x1, double y1, double x2, double y2)
{
double dx = x2-x1;
double dy = y2-y1;
//--------------------------------------------------------calc_sq_distance
AGG_INLINE double calc_sq_distance(double x1, double y1, double x2, double y2)
{
double dx = x2 - x1;
double dy = y2 - y1;
return dx * dx + dy * dy;
}
}
//------------------------------------------------calc_line_point_distance
AGG_INLINE double calc_line_point_distance(double x1, double y1,
double x2, double y2,
double x, double y)
{
double dx = x2-x1;
double dy = y2-y1;
//------------------------------------------------calc_line_point_distance
AGG_INLINE double calc_line_point_distance(double x1, double y1, double x2, double y2, double x, double y)
{
double dx = x2 - x1;
double dy = y2 - y1;
double d = sqrt(dx * dx + dy * dy);
if(d < vertex_dist_epsilon)
if (d < vertex_dist_epsilon)
{
return calc_distance(x1, y1, x, y);
}
return ((x - x2) * dy - (y - y2) * dx) / d;
}
}
//-------------------------------------------------------calc_line_point_u
AGG_INLINE double calc_segment_point_u(double x1, double y1,
double x2, double y2,
double x, double y)
{
//-------------------------------------------------------calc_line_point_u
AGG_INLINE double calc_segment_point_u(double x1, double y1, double x2, double y2, double x, double y)
{
double dx = x2 - x1;
double dy = y2 - y1;
if(dx == 0 && dy == 0)
if (dx == 0 && dy == 0)
{
return 0;
}
@ -101,108 +91,100 @@ namespace agg
double pdy = y - y1;
return (pdx * dx + pdy * dy) / (dx * dx + dy * dy);
}
}
//---------------------------------------------calc_line_point_sq_distance
AGG_INLINE double calc_segment_point_sq_distance(double x1, double y1,
double x2, double y2,
double x, double y,
double u)
{
if(u <= 0)
//---------------------------------------------calc_line_point_sq_distance
AGG_INLINE double
calc_segment_point_sq_distance(double x1, double y1, double x2, double y2, double x, double y, double u)
{
if (u <= 0)
{
return calc_sq_distance(x, y, x1, y1);
}
else
if(u >= 1)
else if (u >= 1)
{
return calc_sq_distance(x, y, x2, y2);
}
return calc_sq_distance(x, y, x1 + u * (x2 - x1), y1 + u * (y2 - y1));
}
}
//---------------------------------------------calc_line_point_sq_distance
AGG_INLINE double calc_segment_point_sq_distance(double x1, double y1,
double x2, double y2,
double x, double y)
{
return
calc_segment_point_sq_distance(
x1, y1, x2, y2, x, y,
calc_segment_point_u(x1, y1, x2, y2, x, y));
}
//---------------------------------------------calc_line_point_sq_distance
AGG_INLINE double calc_segment_point_sq_distance(double x1, double y1, double x2, double y2, double x, double y)
{
return calc_segment_point_sq_distance(x1, y1, x2, y2, x, y, calc_segment_point_u(x1, y1, x2, y2, x, y));
}
//-------------------------------------------------------calc_intersection
AGG_INLINE bool calc_intersection(double ax, double ay, double bx, double by,
double cx, double cy, double dx, double dy,
double* x, double* y)
{
double num = (ay-cy) * (dx-cx) - (ax-cx) * (dy-cy);
double den = (bx-ax) * (dy-cy) - (by-ay) * (dx-cx);
if(std::fabs(den) < intersection_epsilon) return false;
//-------------------------------------------------------calc_intersection
AGG_INLINE bool calc_intersection(double ax,
double ay,
double bx,
double by,
double cx,
double cy,
double dx,
double dy,
double* x,
double* y)
{
double num = (ay - cy) * (dx - cx) - (ax - cx) * (dy - cy);
double den = (bx - ax) * (dy - cy) - (by - ay) * (dx - cx);
if (std::fabs(den) < intersection_epsilon)
return false;
double r = num / den;
*x = ax + r * (bx-ax);
*y = ay + r * (by-ay);
*x = ax + r * (bx - ax);
*y = ay + r * (by - ay);
return true;
}
}
//-----------------------------------------------------intersection_exists
AGG_INLINE bool intersection_exists(double x1, double y1, double x2, double y2,
double x3, double y3, double x4, double y4)
{
//-----------------------------------------------------intersection_exists
AGG_INLINE bool
intersection_exists(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
{
// It's less expensive but you can't control the
// boundary conditions: Less or LessEqual
double dx1 = x2 - x1;
double dy1 = y2 - y1;
double dx2 = x4 - x3;
double dy2 = y4 - y3;
return ((x3 - x2) * dy1 - (y3 - y2) * dx1 < 0.0) !=
((x4 - x2) * dy1 - (y4 - y2) * dx1 < 0.0) &&
((x1 - x4) * dy2 - (y1 - y4) * dx2 < 0.0) !=
((x2 - x4) * dy2 - (y2 - y4) * dx2 < 0.0);
return ((x3 - x2) * dy1 - (y3 - y2) * dx1 < 0.0) != ((x4 - x2) * dy1 - (y4 - y2) * dx1 < 0.0) &&
((x1 - x4) * dy2 - (y1 - y4) * dx2 < 0.0) != ((x2 - x4) * dy2 - (y2 - y4) * dx2 < 0.0);
// It's is more expensive but more flexible
// in terms of boundary conditions.
//--------------------
//double den = (x2-x1) * (y4-y3) - (y2-y1) * (x4-x3);
//if(std::fabs(den) < intersection_epsilon) return false;
//double nom1 = (x4-x3) * (y1-y3) - (y4-y3) * (x1-x3);
//double nom2 = (x2-x1) * (y1-y3) - (y2-y1) * (x1-x3);
//double ua = nom1 / den;
//double ub = nom2 / den;
//return ua >= 0.0 && ua <= 1.0 && ub >= 0.0 && ub <= 1.0;
}
// double den = (x2-x1) * (y4-y3) - (y2-y1) * (x4-x3);
// if(std::fabs(den) < intersection_epsilon) return false;
// double nom1 = (x4-x3) * (y1-y3) - (y4-y3) * (x1-x3);
// double nom2 = (x2-x1) * (y1-y3) - (y2-y1) * (x1-x3);
// double ua = nom1 / den;
// double ub = nom2 / den;
// return ua >= 0.0 && ua <= 1.0 && ub >= 0.0 && ub <= 1.0;
}
//--------------------------------------------------------calc_orthogonal
AGG_INLINE void calc_orthogonal(double thickness,
double x1, double y1,
double x2, double y2,
double* x, double* y)
{
//--------------------------------------------------------calc_orthogonal
AGG_INLINE void calc_orthogonal(double thickness, double x1, double y1, double x2, double y2, double* x, double* y)
{
double dx = x2 - x1;
double dy = y2 - y1;
double d = sqrt(dx*dx + dy*dy);
double d = sqrt(dx * dx + dy * dy);
*x = thickness * dy / d;
*y = -thickness * dx / d;
}
}
//--------------------------------------------------------dilate_triangle
AGG_INLINE void dilate_triangle(double x1, double y1,
double x2, double y2,
double x3, double y3,
double *x, double* y,
double d)
{
double dx1=0.0;
double dy1=0.0;
double dx2=0.0;
double dy2=0.0;
double dx3=0.0;
double dy3=0.0;
//--------------------------------------------------------dilate_triangle
AGG_INLINE void
dilate_triangle(double x1, double y1, double x2, double y2, double x3, double y3, double* x, double* y, double d)
{
double dx1 = 0.0;
double dy1 = 0.0;
double dx2 = 0.0;
double dy2 = 0.0;
double dx3 = 0.0;
double dy3 = 0.0;
double loc = cross_product(x1, y1, x2, y2, x3, y3);
if(std::fabs(loc) > intersection_epsilon)
if (std::fabs(loc) > intersection_epsilon)
{
if(cross_product(x1, y1, x2, y2, x3, y3) > 0.0)
if (cross_product(x1, y1, x2, y2, x3, y3) > 0.0)
{
d = -d;
}
@ -210,25 +192,30 @@ 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++ = x2 + dx1; *y++ = y2 + dy1;
*x++ = x2 + dx2; *y++ = y2 + dy2;
*x++ = x3 + dx2; *y++ = y3 + dy2;
*x++ = x3 + dx3; *y++ = y3 + dy3;
*x++ = x1 + dx3; *y++ = y1 + dy3;
}
*x++ = x1 + dx1;
*y++ = y1 + dy1;
*x++ = x2 + dx1;
*y++ = y2 + dy1;
*x++ = x2 + dx2;
*y++ = y2 + dy2;
*x++ = x3 + dx2;
*y++ = y3 + dy2;
*x++ = x3 + dx3;
*y++ = y3 + dy3;
*x++ = x1 + dx3;
*y++ = y1 + dy3;
}
//------------------------------------------------------calc_triangle_area
AGG_INLINE double calc_triangle_area(double x1, double y1,
double x2, double y2,
double x3, double y3)
{
return (x1*y2 - x2*y1 + x2*y3 - x3*y2 + x3*y1 - x1*y3) * 0.5;
}
//------------------------------------------------------calc_triangle_area
AGG_INLINE double calc_triangle_area(double x1, double y1, double x2, double y2, double x3, double y3)
{
return (x1 * y2 - x2 * y1 + x2 * y3 - x3 * y2 + x3 * y1 - x1 * y3) * 0.5;
}
//-------------------------------------------------------calc_polygon_area
template<class Storage> double calc_polygon_area(const Storage& st)
{
//-------------------------------------------------------calc_polygon_area
template<class Storage>
double calc_polygon_area(const Storage& st)
{
unsigned i;
double sum = 0.0;
double x = st[0].x;
@ -236,7 +223,7 @@ namespace agg
double xs = x;
double ys = y;
for(i = 1; i < st.size(); i++)
for (i = 1; i < st.size(); i++)
{
const typename Storage::value_type& v = st[i];
sum += x * v.y - y * v.x;
@ -244,29 +231,27 @@ namespace agg
y = v.y;
}
return (sum + x * ys - y * xs) * 0.5;
}
}
//------------------------------------------------------------------------
// Tables for fast sqrt
extern int16u g_sqrt_table[1024];
extern int8 g_elder_bit_table[256];
//------------------------------------------------------------------------
// Tables for fast sqrt
extern int16u g_sqrt_table[1024];
extern int8 g_elder_bit_table[256];
//---------------------------------------------------------------fast_sqrt
//Fast integer Sqrt - really fast: no cycles, divisions or multiplications
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4035) //Disable warning "no return value"
#endif
AGG_INLINE unsigned fast_sqrt(unsigned val)
{
#if defined(_M_IX86) && defined(_MSC_VER) && !defined(AGG_NO_ASM)
//For Ix86 family processors this assembler code is used.
//The key command here is bsr - determination the number of the most
//significant bit of the value. For other processors
//---------------------------------------------------------------fast_sqrt
// Fast integer Sqrt - really fast: no cycles, divisions or multiplications
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable: 4035) // Disable warning "no return value"
#endif
AGG_INLINE unsigned fast_sqrt(unsigned val)
{
#if defined(_M_IX86) && defined(_MSC_VER) && !defined(AGG_NO_ASM)
// For Ix86 family processors this assembler code is used.
// The key command here is bsr - determination the number of the most
// significant bit of the value. For other processors
//(and maybe compilers) the pure C "#else" section is used.
__asm
{
__asm {
mov ebx, val
mov edx, 11
bsr ecx, ebx
@ -283,35 +268,35 @@ namespace agg
mov ecx, edx
shr eax, cl
}
#else
#else
//This code is actually pure C and portable to most
//arcitectures including 64bit ones.
// This code is actually pure C and portable to most
// arcitectures including 64bit ones.
unsigned t = val;
int bit=0;
int bit = 0;
unsigned shift = 11;
//The following piece of code is just an emulation of the
//Ix86 assembler command "bsr" (see above). However on old
//Intels (like Intel MMX 233MHz) this code is about twice
//faster (sic!) then just one "bsr". On PIII and PIV the
//bsr is optimized quite well.
// The following piece of code is just an emulation of the
// Ix86 assembler command "bsr" (see above). However on old
// Intels (like Intel MMX 233MHz) this code is about twice
// faster (sic!) then just one "bsr". On PIII and PIV the
// bsr is optimized quite well.
bit = t >> 24;
if(bit)
if (bit)
{
bit = g_elder_bit_table[bit] + 24;
}
else
{
bit = (t >> 16) & 0xFF;
if(bit)
if (bit)
{
bit = g_elder_bit_table[bit] + 16;
}
else
{
bit = (t >> 8) & 0xFF;
if(bit)
if (bit)
{
bit = g_elder_bit_table[bit] + 8;
}
@ -322,63 +307,61 @@ namespace agg
}
}
//This code calculates the sqrt.
// This code calculates the sqrt.
bit -= 9;
if(bit > 0)
if (bit > 0)
{
bit = (bit >> 1) + (bit & 1);
shift -= bit;
val >>= (bit << 1);
}
return g_sqrt_table[val] >> shift;
#endif
}
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
#endif
}
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
//--------------------------------------------------------------------besj
// Function BESJ calculates Bessel function of first kind of order n
// Arguments:
// n - an integer (>=0), the order
// x - value at which the Bessel function is required
//--------------------
// C++ Mathematical Library
// Convereted from equivalent FORTRAN library
// Converetd by Gareth Walker for use by course 392 computational project
// All functions tested and yield the same results as the corresponding
// FORTRAN versions.
//
// If you have any problems using these functions please report them to
// M.Muldoon@UMIST.ac.uk
//
// Documentation available on the web
// http://www.ma.umist.ac.uk/mrm/Teaching/392/libs/392.html
// Version 1.0 8/98
// 29 October, 1999
//--------------------
// Adapted for use in AGG library by Andy Wilk (castor.vulgaris@gmail.com)
//------------------------------------------------------------------------
inline double besj(double x, int n)
{
if(n < 0)
//--------------------------------------------------------------------besj
// Function BESJ calculates Bessel function of first kind of order n
// Arguments:
// n - an integer (>=0), the order
// x - value at which the Bessel function is required
//--------------------
// C++ Mathematical Library
// Convereted from equivalent FORTRAN library
// Converetd by Gareth Walker for use by course 392 computational project
// All functions tested and yield the same results as the corresponding
// FORTRAN versions.
//
// If you have any problems using these functions please report them to
// M.Muldoon@UMIST.ac.uk
//
// Documentation available on the web
// http://www.ma.umist.ac.uk/mrm/Teaching/392/libs/392.html
// Version 1.0 8/98
// 29 October, 1999
//--------------------
// Adapted for use in AGG library by Andy Wilk (castor.vulgaris@gmail.com)
//------------------------------------------------------------------------
inline double besj(double x, int n)
{
if (n < 0)
{
return 0;
}
double d = 1E-6;
double b = 0;
if(std::fabs(x) <= d)
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
// Set up a starting order for recurrence
int m1 = (int)fabs(x) + 6;
if(std::fabs(x) > 5)
if (std::fabs(x) > 5)
{
m1 = (int)(std::fabs(1.4 * x + 60 / x));
}
@ -389,7 +372,7 @@ namespace agg
}
// Apply recurrence down from curent max order
for(;;)
for (;;)
{
double c3 = 0;
double c2 = 1E-30;
@ -405,7 +388,7 @@ namespace agg
double c6 = 2 * (m2 - i) * c2 / x - c3;
c3 = c2;
c2 = c6;
if(m2 - i - 1 == n)
if (m2 - i - 1 == n)
{
b = c6;
}
@ -416,22 +399,21 @@ namespace agg
}
}
double c6 = 2 * c2 / x - c3;
if(n == 0)
if (n == 0)
{
b = c6;
}
c4 += c6;
b /= c4;
if(std::fabs(b - b1) < d)
if (std::fabs(b - b1) < d)
{
return b;
}
b1 = b;
m2 += 3;
}
}
}
} // namespace agg
#endif

291
deps/agg/include/agg_math_stroke.h vendored
View file

@ -23,39 +23,20 @@
#include "agg_math.h"
#include "agg_vertex_sequence.h"
namespace agg
namespace agg {
//-------------------------------------------------------------line_cap_e
enum line_cap_e { butt_cap, square_cap, round_cap };
//------------------------------------------------------------line_join_e
enum line_join_e { miter_join = 0, miter_join_revert = 1, round_join = 2, bevel_join = 3, miter_join_round = 4 };
//-----------------------------------------------------------inner_join_e
enum inner_join_e { inner_bevel, inner_miter, inner_jag, inner_round };
//------------------------------------------------------------math_stroke
template<class VertexConsumer>
class math_stroke
{
//-------------------------------------------------------------line_cap_e
enum line_cap_e
{
butt_cap,
square_cap,
round_cap
};
//------------------------------------------------------------line_join_e
enum line_join_e
{
miter_join = 0,
miter_join_revert = 1,
round_join = 2,
bevel_join = 3,
miter_join_round = 4
};
//-----------------------------------------------------------inner_join_e
enum inner_join_e
{
inner_bevel,
inner_miter,
inner_jag,
inner_round
};
//------------------------------------------------------------math_stroke
template<class VertexConsumer> class math_stroke
{
public:
typedef typename VertexConsumer::value_type coord_type;
@ -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,
const vertex_dist& v0,
const vertex_dist& v1,
double len);
void calc_cap(VertexConsumer& vc, 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)
{
vc.add(coord_type(x, y));
}
AGG_INLINE void add_vertex(VertexConsumer& vc, double x, double y) { vc.add(coord_type(x, y)); }
void calc_arc(VertexConsumer& vc,
double x, double y,
double dx1, double dy1,
double dx2, double dy2);
void calc_arc(VertexConsumer& vc, double x, double y, double dx1, double dy1, double dx2, double dy2);
void calc_miter(VertexConsumer& vc,
const vertex_dist& v0,
const vertex_dist& v1,
const vertex_dist& v2,
double dx1, double dy1,
double dx2, double dy2,
double dx1,
double dy1,
double dx2,
double dy2,
line_join_e lj,
double mlimit,
double dbevel);
@ -123,28 +97,29 @@ namespace agg
line_cap_e m_line_cap;
line_join_e m_line_join;
inner_join_e m_inner_join;
};
};
//-----------------------------------------------------------------------
template<class VC> math_stroke<VC>::math_stroke() :
m_width(0.5),
m_width_abs(0.5),
m_width_eps(0.5/1024.0),
m_width_sign(1),
m_miter_limit(4.0),
m_inner_miter_limit(1.01),
m_approx_scale(1.0),
m_line_cap(butt_cap),
m_line_join(miter_join),
m_inner_join(inner_miter)
{
}
//-----------------------------------------------------------------------
template<class VC>
math_stroke<VC>::math_stroke()
: m_width(0.5)
, m_width_abs(0.5)
, m_width_eps(0.5 / 1024.0)
, m_width_sign(1)
, m_miter_limit(4.0)
, m_inner_miter_limit(1.01)
, m_approx_scale(1.0)
, m_line_cap(butt_cap)
, m_line_join(miter_join)
, m_inner_join(inner_miter)
{}
//-----------------------------------------------------------------------
template<class VC> void math_stroke<VC>::width(double w)
{
//-----------------------------------------------------------------------
template<class VC>
void math_stroke<VC>::width(double w)
{
m_width = w * 0.5;
if(m_width < 0)
if (m_width < 0)
{
m_width_abs = -m_width;
m_width_sign = -1;
@ -155,21 +130,19 @@ namespace agg
m_width_sign = 1;
}
m_width_eps = m_width / 1024.0;
}
}
//-----------------------------------------------------------------------
template<class VC> void math_stroke<VC>::miter_limit_theta(double t)
{
m_miter_limit = 1.0 / std::sin(t * 0.5) ;
}
//-----------------------------------------------------------------------
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,
double x, double y,
double dx1, double dy1,
double dx2, double dy2)
{
//-----------------------------------------------------------------------
template<class VC>
void math_stroke<VC>::calc_arc(VC& vc, double x, double y, double dx1, double dy1, double dx2, double dy2)
{
double a1 = std::atan2(dy1 * m_width_sign, dx1 * m_width_sign);
double a2 = std::atan2(dy2 * m_width_sign, dx2 * m_width_sign);
double da = a1 - a2;
@ -178,13 +151,14 @@ namespace agg
da = std::acos(m_width_abs / (m_width_abs + 0.125 / m_approx_scale)) * 2;
add_vertex(vc, x + dx1, y + dy1);
if(m_width_sign > 0)
if (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;
for(i = 0; i < n; i++)
for (i = 0; i < n; i++)
{
add_vertex(vc, x + std::cos(a1) * m_width, y + std::sin(a1) * m_width);
a1 += da;
@ -192,31 +166,34 @@ 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;
for(i = 0; i < n; i++)
for (i = 0; i < n; i++)
{
add_vertex(vc, x + std::cos(a1) * m_width, y + std::sin(a1) * m_width);
a1 -= da;
}
}
add_vertex(vc, x + dx2, y + dy2);
}
}
//-----------------------------------------------------------------------
template<class VC>
void math_stroke<VC>::calc_miter(VC& vc,
//-----------------------------------------------------------------------
template<class VC>
void math_stroke<VC>::calc_miter(VC& vc,
const vertex_dist& v0,
const vertex_dist& v1,
const vertex_dist& v2,
double dx1, double dy1,
double dx2, double dy2,
double dx1,
double dy1,
double dx2,
double dy2,
line_join_e lj,
double mlimit,
double dbevel)
{
{
double xi = v1.x;
double yi = v1.y;
double di = 1;
@ -224,16 +201,21 @@ 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,
v1.x + dx1, v1.y - dy1,
v1.x + dx2, v1.y - dy2,
v2.x + dx2, v2.y - dy2,
&xi, &yi))
if (calc_intersection(v0.x + dx1,
v0.y - dy1,
v1.x + dx1,
v1.y - dy1,
v1.x + dx2,
v1.y - dy2,
v2.x + dx2,
v2.y - dy2,
&xi,
&yi))
{
// Calculation of the intersection succeeded
//---------------------
di = calc_distance(v1.x, v1.y, xi, yi);
if(di <= lim)
if (di <= lim)
{
// Inside the miter limit
//---------------------
@ -254,7 +236,7 @@ namespace agg
//----------------
double x2 = v1.x + dx1;
double y2 = v1.y - dy1;
if((cross_product(v0.x, v0.y, v1.x, v1.y, x2, y2) < 0.0) ==
if ((cross_product(v0.x, v0.y, v1.x, v1.y, x2, y2) < 0.0) ==
(cross_product(v1.x, v1.y, v2.x, v2.y, x2, y2) < 0.0))
{
// This case means that the next segment continues
@ -265,11 +247,11 @@ namespace agg
}
}
if(miter_limit_exceeded)
if (miter_limit_exceeded)
{
// Miter limit exceeded
//------------------------
switch(lj)
switch (lj)
{
case miter_join_revert:
// For the compatibility with SVG, PDF, etc,
@ -287,13 +269,11 @@ namespace agg
default:
// If no miter-revert, calculate new dx1, dy1, dx2, dy2
//----------------
if(intersection_failed)
if (intersection_failed)
{
mlimit *= m_width_sign;
add_vertex(vc, v1.x + dx1 + dy1 * mlimit,
v1.y - dy1 + dx1 * mlimit);
add_vertex(vc, v1.x + dx2 - dy2 * mlimit,
v1.y - dy2 - dx2 * mlimit);
add_vertex(vc, v1.x + dx1 + dy1 * mlimit, v1.y - dy1 + dx1 * mlimit);
add_vertex(vc, v1.x + dx2 - dy2 * mlimit, v1.y - dy2 - dx2 * mlimit);
}
else
{
@ -302,23 +282,18 @@ namespace agg
double x2 = v1.x + dx2;
double y2 = v1.y - dy2;
di = (lim - dbevel) / (di - dbevel);
add_vertex(vc, x1 + (xi - x1) * di,
y1 + (yi - y1) * di);
add_vertex(vc, x2 + (xi - x2) * di,
y2 + (yi - y2) * di);
add_vertex(vc, x1 + (xi - x1) * di, y1 + (yi - y1) * di);
add_vertex(vc, x2 + (xi - x2) * di, y2 + (yi - y2) * di);
}
break;
}
}
}
}
//--------------------------------------------------------stroke_calc_cap
template<class VC>
void math_stroke<VC>::calc_cap(VC& vc,
const vertex_dist& v0,
const vertex_dist& v1,
double len)
{
//--------------------------------------------------------stroke_calc_cap
template<class VC>
void math_stroke<VC>::calc_cap(VC& vc, const vertex_dist& v0, const vertex_dist& v1, double len)
{
vc.remove_all();
double dx1 = (v1.y - v0.y) / len;
@ -329,9 +304,9 @@ namespace agg
dx1 *= m_width;
dy1 *= m_width;
if(m_line_cap != round_cap)
if (m_line_cap != round_cap)
{
if(m_line_cap == square_cap)
if (m_line_cap == square_cap)
{
dx2 = dy1 * m_width_sign;
dy2 = dx1 * m_width_sign;
@ -348,14 +323,13 @@ namespace agg
da = pi / (n + 1);
add_vertex(vc, v0.x - dx1, v0.y + dy1);
if(m_width_sign > 0)
if (m_width_sign > 0)
{
a1 = std::atan2(dy1, -dx1);
a1 += da;
for(i = 0; i < n; i++)
for (i = 0; i < n; i++)
{
add_vertex(vc, v0.x + std::cos(a1) * m_width,
v0.y + std::sin(a1) * m_width);
add_vertex(vc, v0.x + std::cos(a1) * m_width, v0.y + std::sin(a1) * m_width);
a1 += da;
}
}
@ -363,26 +337,25 @@ namespace agg
{
a1 = std::atan2(-dy1, dx1);
a1 -= da;
for(i = 0; i < n; i++)
for (i = 0; i < n; i++)
{
add_vertex(vc, v0.x + std::cos(a1) * m_width,
v0.y + std::sin(a1) * m_width);
add_vertex(vc, v0.x + std::cos(a1) * m_width, v0.y + std::sin(a1) * m_width);
a1 -= da;
}
}
add_vertex(vc, v0.x + dx1, v0.y - dy1);
}
}
}
//-----------------------------------------------------------------------
template<class VC>
void math_stroke<VC>::calc_join(VC& vc,
//-----------------------------------------------------------------------
template<class VC>
void math_stroke<VC>::calc_join(VC& vc,
const vertex_dist& v0,
const vertex_dist& v1,
const vertex_dist& v2,
double len1,
double len2)
{
{
double dx1 = m_width * (v1.y - v0.y) / len1;
double dy1 = m_width * (v1.x - v0.x) / len1;
double dx2 = m_width * (v2.y - v1.y) / len2;
@ -401,7 +374,7 @@ namespace agg
limit = m_inner_miter_limit;
}
switch(m_inner_join)
switch (m_inner_join)
{
default: // inner_bevel
add_vertex(vc, v1.x + dx1, v1.y - dy1);
@ -409,36 +382,30 @@ namespace agg
break;
case inner_miter:
calc_miter(vc,
v0, v1, v2, dx1, dy1, dx2, dy2,
miter_join_revert,
limit, 0);
calc_miter(vc, v0, v1, v2, dx1, dy1, dx2, dy2, miter_join_revert, limit, 0);
break;
case inner_jag:
case inner_round:
cp = (dx1-dx2) * (dx1-dx2) + (dy1-dy2) * (dy1-dy2);
if(cp < len1 * len1 && cp < len2 * len2)
cp = (dx1 - dx2) * (dx1 - dx2) + (dy1 - dy2) * (dy1 - dy2);
if (cp < len1 * len1 && cp < len2 * len2)
{
calc_miter(vc,
v0, v1, v2, dx1, dy1, dx2, dy2,
miter_join_revert,
limit, 0);
calc_miter(vc, v0, v1, v2, dx1, dy1, dx2, dy2, miter_join_revert, limit, 0);
}
else
{
if(m_inner_join == inner_jag)
if (m_inner_join == inner_jag)
{
add_vertex(vc, v1.x + dx1, v1.y - dy1);
add_vertex(vc, v1.x, v1.y );
add_vertex(vc, v1.x, v1.y);
add_vertex(vc, v1.x + dx2, v1.y - dy2);
}
else
{
add_vertex(vc, v1.x + dx1, v1.y - dy1);
add_vertex(vc, v1.x, v1.y );
add_vertex(vc, v1.x, v1.y);
calc_arc(vc, v1.x, v1.y, dx2, -dy2, dx1, -dy1);
add_vertex(vc, v1.x, v1.y );
add_vertex(vc, v1.x, v1.y);
add_vertex(vc, v1.x + dx2, v1.y - dy2);
}
}
@ -457,7 +424,7 @@ namespace agg
double dy = (dy1 + dy2) / 2;
double dbevel = sqrt(dx * dx + dy * dy);
if(m_line_join == round_join || m_line_join == bevel_join)
if (m_line_join == round_join || m_line_join == bevel_join)
{
// This is an optimization that reduces the number of points
// in cases of almost collinear segments. If there's no
@ -476,13 +443,18 @@ namespace agg
// the same as in round joins and caps. You can safely comment
// out this entire "if".
//-------------------
if(m_approx_scale * (m_width_abs - dbevel) < m_width_eps)
if (m_approx_scale * (m_width_abs - dbevel) < m_width_eps)
{
if(calc_intersection(v0.x + dx1, v0.y - dy1,
v1.x + dx1, v1.y - dy1,
v1.x + dx2, v1.y - dy2,
v2.x + dx2, v2.y - dy2,
&dx, &dy))
if (calc_intersection(v0.x + dx1,
v0.y - dy1,
v1.x + dx1,
v1.y - dy1,
v1.x + dx2,
v1.y - dy2,
v2.x + dx2,
v2.y - dy2,
&dx,
&dy))
{
add_vertex(vc, dx, dy);
}
@ -494,16 +466,12 @@ namespace agg
}
}
switch(m_line_join)
switch (m_line_join)
{
case miter_join:
case miter_join_revert:
case miter_join_round:
calc_miter(vc,
v0, v1, v2, dx1, dy1, dx2, dy2,
m_line_join,
m_miter_limit,
dbevel);
calc_miter(vc, v0, v1, v2, dx1, dy1, dx2, dy2, m_line_join, m_miter_limit, dbevel);
break;
case round_join:
@ -516,11 +484,8 @@ namespace agg
break;
}
}
}
}
} // namespace agg
#endif

17
deps/agg/include/agg_path_length.h vendored
View file

@ -17,11 +17,10 @@
#include "agg_math.h"
namespace agg
namespace agg {
template<class VertexSource>
double path_length(VertexSource& vs, unsigned path_id = 0)
{
template<class VertexSource>
double path_length(VertexSource& vs, unsigned path_id = 0)
{
double len = 0.0;
double start_x = 0.0;
double start_y = 0.0;
@ -33,11 +32,11 @@ namespace agg
unsigned cmd;
vs.rewind(path_id);
while(!is_stop(cmd = vs.vertex(&x2, &y2)))
while (!is_stop(cmd = vs.vertex(&x2, &y2)))
{
if(is_vertex(cmd))
if (is_vertex(cmd))
{
if(first || is_move_to(cmd))
if (first || is_move_to(cmd))
{
start_x = x2;
start_y = y2;
@ -52,14 +51,14 @@ namespace agg
}
else
{
if(is_close(cmd) && !first)
if (is_close(cmd) && !first)
{
len += calc_distance(x1, y1, start_x, start_y);
}
}
}
return len;
}
}
} // namespace agg
#endif

1256
deps/agg/include/agg_path_storage.h vendored
View file

File diff suppressed because it is too large Load diff

170
deps/agg/include/agg_path_storage_integer.h vendored
View file

@ -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
{
//---------------------------------------------------------vertex_integer
template<class T, unsigned CoordShift=6> struct vertex_integer
{
enum path_cmd
{
cmd_move_to = 0,
cmd_line_to = 1,
cmd_curve3 = 2,
cmd_curve4 = 3
};
enum path_cmd { cmd_move_to = 0, cmd_line_to = 1, cmd_curve3 = 2, cmd_curve4 = 3 };
enum coord_scale_e
{
coord_shift = CoordShift,
coord_scale = 1 << coord_shift
};
enum coord_scale_e { coord_shift = CoordShift, coord_scale = 1 << coord_shift };
T x,y;
T x, y;
vertex_integer() {}
vertex_integer(T x_, T y_, unsigned flag) :
x(((x_ << 1) & ~1) | (flag & 1)),
y(((y_ << 1) & ~1) | (flag >> 1)) {}
vertex_integer(T x_, T y_, unsigned flag)
: x(((x_ << 1) & ~1) | (flag & 1))
, y(((y_ << 1) & ~1) | (flag >> 1))
{}
unsigned vertex(double* x_, double* y_,
double dx=0, double dy=0,
double scale=1.0) const
unsigned vertex(double* x_, double* y_, 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))
switch (((y & 1) << 1) | (x & 1))
{
case cmd_move_to: return path_cmd_move_to;
case cmd_line_to: return path_cmd_line_to;
case cmd_curve3: return path_cmd_curve3;
case cmd_curve4: return path_cmd_curve4;
case cmd_move_to:
return path_cmd_move_to;
case cmd_line_to:
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
{
//---------------------------------------------------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)
{
m_storage.add(vertex_integer_type(x, y, vertex_integer_type::cmd_move_to));
}
void move_to(T x, T y) { m_storage.add(vertex_integer_type(x, y, vertex_integer_type::cmd_move_to)); }
//--------------------------------------------------------------------
void line_to(T x, T y)
{
m_storage.add(vertex_integer_type(x, y, vertex_integer_type::cmd_line_to));
}
void line_to(T x, T y) { m_storage.add(vertex_integer_type(x, y, vertex_integer_type::cmd_line_to)); }
//--------------------------------------------------------------------
void curve3(T x_ctrl, T y_ctrl,
T x_to, T y_to)
void curve3(T x_ctrl, T y_ctrl, 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,
T x_ctrl2, T y_ctrl2,
T x_to, T y_to)
void curve4(T x_ctrl1, T y_ctrl1, 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,17 +98,14 @@ namespace agg
//--------------------------------------------------------------------
unsigned size() const { return m_storage.size(); }
unsigned vertex(unsigned idx, double* x, double* y) const
{
return m_storage[idx].vertex(x, y);
}
unsigned vertex(unsigned idx, double* x, double* y) const { return m_storage[idx].vertex(x, y); }
//--------------------------------------------------------------------
unsigned byte_size() const { return m_storage.size() * sizeof(vertex_integer_type); }
void serialize(int8u* ptr) const
{
unsigned i;
for(i = 0; i < m_storage.size(); i++)
for (i = 0; i < m_storage.size(); i++)
{
memcpy(ptr, &m_storage[i], sizeof(vertex_integer_type));
ptr += sizeof(vertex_integer_type);
@ -137,13 +122,13 @@ namespace agg
//--------------------------------------------------------------------
unsigned vertex(double* x, double* y)
{
if(m_storage.size() < 2 || m_vertex_idx > m_storage.size())
if (m_storage.size() < 2 || m_vertex_idx > m_storage.size())
{
*x = 0;
*y = 0;
return path_cmd_stop;
}
if(m_vertex_idx == m_storage.size())
if (m_vertex_idx == m_storage.size())
{
*x = 0;
*y = 0;
@ -151,7 +136,7 @@ namespace agg
return path_cmd_end_poly | path_flags_close;
}
unsigned cmd = m_storage[m_vertex_idx].vertex(x, y);
if(is_move_to(cmd) && !m_closed)
if (is_move_to(cmd) && !m_closed)
{
*x = 0;
*y = 0;
@ -167,21 +152,25 @@ namespace agg
rect_d bounding_rect() const
{
rect_d bounds(1e100, 1e100, -1e100, -1e100);
if(m_storage.size() == 0)
if (m_storage.size() == 0)
{
bounds.x1 = bounds.y1 = bounds.x2 = bounds.y2 = 0.0;
}
else
{
unsigned i;
for(i = 0; i < m_storage.size(); i++)
for (i = 0; i < m_storage.size(); i++)
{
double x, y;
m_storage[i].vertex(&x, &y);
if(x < bounds.x1) bounds.x1 = x;
if(y < bounds.y1) bounds.y1 = y;
if(x > bounds.x2) bounds.x2 = x;
if(y > bounds.y2) bounds.y2 = y;
if (x < bounds.x1)
bounds.x1 = x;
if (y < bounds.y1)
bounds.y1 = y;
if (x > bounds.x2)
bounds.x2 = x;
if (y > bounds.y2)
bounds.y2 = y;
}
}
return bounds;
@ -191,42 +180,38 @@ namespace agg
pod_bvector<vertex_integer_type, 6> m_storage;
unsigned m_vertex_idx;
bool m_closed;
};
};
//-----------------------------------------serialized_integer_path_adaptor
template<class T, unsigned CoordShift=6> class serialized_integer_path_adaptor
{
//-----------------------------------------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() :
m_data(0),
m_end(0),
m_ptr(0),
m_dx(0.0),
m_dy(0.0),
m_scale(1.0),
m_vertices(0)
serialized_integer_path_adaptor()
: m_data(0)
, m_end(0)
, m_ptr(0)
, m_dx(0.0)
, m_dy(0.0)
, m_scale(1.0)
, m_vertices(0)
{}
//--------------------------------------------------------------------
serialized_integer_path_adaptor(const int8u* data, unsigned size,
double dx, double dy) :
m_data(data),
m_end(data + size),
m_ptr(data),
m_dx(dx),
m_dy(dy),
m_vertices(0)
serialized_integer_path_adaptor(const int8u* data, unsigned size, double dx, double dy)
: m_data(data)
, m_end(data + size)
, m_ptr(data)
, m_dx(dx)
, m_dy(dy)
, m_vertices(0)
{}
//--------------------------------------------------------------------
void init(const int8u* data, unsigned size,
double dx, double dy, double scale=1.0)
void init(const int8u* data, unsigned size, 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)
{
@ -248,14 +232,14 @@ namespace agg
//--------------------------------------------------------------------
unsigned vertex(double* x, double* y)
{
if(m_data == 0 || m_ptr > m_end)
if (m_data == 0 || m_ptr > m_end)
{
*x = 0;
*y = 0;
return path_cmd_stop;
}
if(m_ptr == m_end)
if (m_ptr == m_end)
{
*x = 0;
*y = 0;
@ -266,7 +250,7 @@ namespace agg
vertex_integer_type v;
memcpy(&v, m_ptr, sizeof(vertex_integer_type));
unsigned cmd = v.vertex(x, y, m_dx, m_dy, m_scale);
if(is_move_to(cmd) && m_vertices > 2)
if (is_move_to(cmd) && m_vertices > 2)
{
*x = 0;
*y = 0;
@ -286,10 +270,8 @@ namespace agg
double m_dy;
double m_scale;
unsigned m_vertices;
};
}
};
} // namespace agg
#endif

58
deps/agg/include/agg_pattern_filters_rgba.h vendored
View file

@ -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
{
//=======================================================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,
color_type* p, int x, int y)
static void AGG_INLINE pixel_low_res(color_type const* const* buf, color_type* p, int x, int y) { *p = buf[y][x]; }
static void AGG_INLINE pixel_high_res(color_type const* const* buf, color_type* p, int x, int y)
{
*p = buf[y][x];
*p = buf[y >> line_subpixel_shift][x >> line_subpixel_shift];
}
};
static void AGG_INLINE pixel_high_res(color_type const* const* buf,
color_type* p, int x, int y)
{
*p = buf[y >> 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;
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
{
//===========================================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,
color_type* p, int x, int y)
{
*p = buf[y][x];
}
static AGG_INLINE void pixel_low_res(color_type const* const* buf, color_type* p, int x, int y) { *p = buf[y][x]; }
static AGG_INLINE void pixel_high_res(color_type const* const* buf,
color_type* p, int x, int y)
static AGG_INLINE void pixel_high_res(color_type const* const* buf, 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) *
(line_subpixel_scale - y);
weight = (line_subpixel_scale - x) * (line_subpixel_scale - y);
r += weight * ptr->r;
g += weight * ptr->g;
b += weight * ptr->b;
@ -113,10 +99,10 @@ namespace agg
p->b = (value_type)(b >> line_subpixel_shift * 2);
p->a = (value_type)(a >> line_subpixel_shift * 2);
}
};
};
typedef pattern_filter_bilinear_rgba<rgba8> pattern_filter_bilinear_rgba8;
typedef pattern_filter_bilinear_rgba<rgba16> pattern_filter_bilinear_rgba16;
}
typedef pattern_filter_bilinear_rgba<rgba8> pattern_filter_bilinear_rgba8;
typedef pattern_filter_bilinear_rgba<rgba16> pattern_filter_bilinear_rgba16;
} // namespace agg
#endif

81
deps/agg/include/agg_pixfmt_amask_adaptor.h vendored
View file

@ -16,17 +16,15 @@
#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
{
//==================================================pixfmt_amask_adaptor
template<class PixFmt, class AlphaMask> class pixfmt_amask_adaptor
{
public:
typedef PixFmt pixfmt_type;
typedef typename pixfmt_type::color_type color_type;
@ -39,7 +37,7 @@ namespace agg
void realloc_span(unsigned len)
{
if(len > m_span.size())
if (len > m_span.size())
{
m_span.resize(len + span_extra_tail);
}
@ -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) :
m_pixf(&pixf), m_mask(&mask), m_span()
pixfmt_amask_adaptor(pixfmt_type& pixf, const amask_type& mask)
: 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)
{
return m_pixf->pixel(x, y);
}
color_type pixel(int x, int y) { return m_pixf->pixel(x, y); }
//--------------------------------------------------------------------
void copy_pixel(int x, int y, const color_type& c)
{
m_pixf->blend_pixel(x, y, c, m_mask->pixel(x, y));
}
void copy_pixel(int x, int y, const color_type& c) { m_pixf->blend_pixel(x, y, c, m_mask->pixel(x, y)); }
//--------------------------------------------------------------------
void blend_pixel(int x, int y, const color_type& c, cover_type cover)
@ -96,9 +89,7 @@ namespace agg
}
//--------------------------------------------------------------------
void copy_hline(int x, int y,
unsigned len,
const color_type& c)
void copy_hline(int x, int y, unsigned len, const color_type& c)
{
realloc_span(len);
m_mask->fill_hspan(x, y, &m_span[0], len);
@ -106,10 +97,7 @@ namespace agg
}
//--------------------------------------------------------------------
void blend_hline(int x, int y,
unsigned len,
const color_type& c,
cover_type cover)
void blend_hline(int x, int y, unsigned len, const color_type& c, cover_type cover)
{
init_span(len);
m_mask->combine_hspan(x, y, &m_span[0], len);
@ -117,9 +105,7 @@ namespace agg
}
//--------------------------------------------------------------------
void copy_vline(int x, int y,
unsigned len,
const color_type& c)
void copy_vline(int x, int y, unsigned len, const color_type& c)
{
realloc_span(len);
m_mask->fill_vspan(x, y, &m_span[0], len);
@ -127,10 +113,7 @@ namespace agg
}
//--------------------------------------------------------------------
void blend_vline(int x, int y,
unsigned len,
const color_type& c,
cover_type cover)
void blend_vline(int x, int y, unsigned len, const color_type& c, cover_type cover)
{
init_span(len);
m_mask->combine_vspan(x, y, &m_span[0], len);
@ -138,39 +121,27 @@ namespace agg
}
//--------------------------------------------------------------------
void copy_from(const rendering_buffer& from,
int xdst, int ydst,
int xsrc, int ysrc,
unsigned len)
void copy_from(const rendering_buffer& from, int xdst, int ydst, int xsrc, int ysrc, unsigned len)
{
m_pixf->copy_from(from, xdst, ydst, xsrc, ysrc, len);
}
//--------------------------------------------------------------------
void blend_solid_hspan(int x, int y,
unsigned len,
const color_type& c,
const cover_type* covers)
void blend_solid_hspan(int x, int y, unsigned len, const color_type& c, const cover_type* covers)
{
init_span(len, covers);
m_mask->combine_hspan(x, y, &m_span[0], len);
m_pixf->blend_solid_hspan(x, y, len, c, &m_span[0]);
}
//--------------------------------------------------------------------
void blend_solid_vspan(int x, int y,
unsigned len,
const color_type& c,
const cover_type* covers)
void blend_solid_vspan(int x, int y, unsigned len, const color_type& c, const cover_type* covers)
{
init_span(len, covers);
m_mask->combine_vspan(x, y, &m_span[0], len);
m_pixf->blend_solid_vspan(x, y, len, c, &m_span[0]);
}
//--------------------------------------------------------------------
void copy_color_hspan(int x, int y, unsigned len, const color_type* colors)
{
@ -188,13 +159,14 @@ 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,
cover_type cover = cover_full)
{
if(covers)
if (covers)
{
init_span(len, covers);
m_mask->combine_hspan(x, y, &m_span[0], len);
@ -207,15 +179,15 @@ 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,
cover_type cover = cover_full)
{
if(covers)
if (covers)
{
init_span(len, covers);
m_mask->combine_vspan(x, y, &m_span[0], len);
@ -232,9 +204,8 @@ namespace agg
pixfmt_type* m_pixf;
const amask_type* m_mask;
pod_array<cover_type> m_span;
};
};
}
} // namespace agg
#endif

47
deps/agg/include/agg_pixfmt_base.h vendored
View file

@ -20,24 +20,20 @@
#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>
struct blender_base
{
struct pixfmt_gray_tag
{
};
struct pixfmt_rgb_tag
{
};
struct pixfmt_rgba_tag
{
};
//--------------------------------------------------------------blender_base
template<class ColorT, class Order = void>
struct blender_base
{
typedef ColorT color_type;
typedef Order order_type;
typedef typename color_type::value_type value_type;
@ -46,8 +42,7 @@ namespace agg
{
if (cover > cover_none)
{
rgba c(
color_type::to_double(r),
rgba c(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(
p[order_type::R],
p[order_type::G],
p[order_type::B],
p[order_type::A],
cover);
return get(p[order_type::R], p[order_type::G], p[order_type::B], p[order_type::A], cover);
}
static void set(value_type* p, value_type r, value_type g, value_type b, value_type a)
@ -91,7 +82,7 @@ namespace agg
p[order_type::B] = color_type::from_double(c.b);
p[order_type::A] = color_type::from_double(c.a);
}
};
}
};
} // namespace agg
#endif

352
deps/agg/include/agg_pixfmt_gray.h vendored
View file

@ -28,12 +28,12 @@
#include "agg_pixfmt_base.h"
#include "agg_rendering_buffer.h"
namespace agg
{
namespace agg {
//============================================================blender_gray
template<class ColorT> struct blender_gray
{
//============================================================blender_gray
template<class ColorT>
struct blender_gray
{
typedef ColorT color_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::calc_type calc_type;
@ -43,23 +43,21 @@ 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,
value_type cv, value_type alpha, cover_type cover)
static AGG_INLINE void blend_pix(value_type* p, value_type cv, value_type alpha, cover_type cover)
{
blend_pix(p, cv, color_type::mult_cover(alpha, cover));
}
static AGG_INLINE void blend_pix(value_type* p,
value_type cv, value_type alpha)
static AGG_INLINE void blend_pix(value_type* p, value_type cv, value_type alpha)
{
*p = color_type::lerp(*p, cv, alpha);
}
};
};
//======================================================blender_gray_pre
template<class ColorT> struct blender_gray_pre
{
//======================================================blender_gray_pre
template<class ColorT>
struct blender_gray_pre
{
typedef ColorT color_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::calc_type calc_type;
@ -68,63 +66,55 @@ namespace agg
// Blend pixels using the premultiplied form of Alvy-Ray Smith's
// compositing function.
static AGG_INLINE void blend_pix(value_type* p,
value_type cv, value_type alpha, cover_type cover)
static AGG_INLINE void blend_pix(value_type* p, value_type cv, value_type alpha, cover_type cover)
{
blend_pix(p, color_type::mult_cover(cv, cover), color_type::mult_cover(alpha, cover));
}
static AGG_INLINE void blend_pix(value_type* p,
value_type cv, value_type alpha)
static AGG_INLINE void blend_pix(value_type* p, value_type cv, value_type alpha)
{
*p = color_type::prelerp(*p, cv, alpha);
}
};
};
//=====================================================apply_gamma_dir_gray
template<class ColorT, class GammaLut> class apply_gamma_dir_gray
{
//=====================================================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)
{
*p = m_gamma.dir(*p);
}
AGG_INLINE void operator()(value_type* p) { *p = m_gamma.dir(*p); }
private:
const GammaLut& m_gamma;
};
};
//=====================================================apply_gamma_inv_gray
template<class ColorT, class GammaLut> class apply_gamma_inv_gray
{
//=====================================================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)
{
*p = m_gamma.inv(*p);
}
AGG_INLINE void operator()(value_type* p) { *p = m_gamma.inv(*p); }
private:
const GammaLut& m_gamma;
};
};
//=================================================pixfmt_alpha_blend_gray
template<class Blender, class RenBuf, unsigned Step = 1, unsigned Offset = 0>
class pixfmt_alpha_blend_gray
{
//=================================================pixfmt_alpha_blend_gray
template<class Blender, class RenBuf, unsigned Step = 1, unsigned Offset = 0>
class pixfmt_alpha_blend_gray
{
public:
typedef pixfmt_gray_tag pixfmt_category;
typedef RenBuf rbuf_type;
@ -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)
{
c[0] = v;
}
void set(value_type v) { c[0] = v; }
void set(const color_type& color)
{
set(color.v);
}
void set(const color_type& color) { set(color.v); }
void get(value_type& v) const
{
v = c[0];
}
void get(value_type& v) const { v = c[0]; }
color_type get() const
{
return color_type(c[0]);
}
color_type get() const { return color_type(c[0]); }
pixel_type* next()
{
return (pixel_type*)(c + pix_step);
}
pixel_type* next() { return (pixel_type*)(c + pix_step); }
const pixel_type* next() const
{
return (const pixel_type*)(c + pix_step);
}
const pixel_type* next() const { return (const pixel_type*)(c + pix_step); }
pixel_type* advance(int n)
{
return (pixel_type*)(c + n * pix_step);
}
pixel_type* advance(int n) { return (pixel_type*)(c + n * pix_step); }
const pixel_type* advance(int n) const
{
return (const pixel_type*)(c + n * pix_step);
}
const pixel_type* advance(int n) const { return (const pixel_type*)(c + n * pix_step); }
};
private:
//--------------------------------------------------------------------
AGG_INLINE void blend_pix(pixel_type* p,
value_type v, value_type a,
unsigned cover)
AGG_INLINE void blend_pix(pixel_type* p, value_type v, value_type a, unsigned cover)
{
blender_type::blend_pix(p->c, v, a, cover);
}
//--------------------------------------------------------------------
AGG_INLINE void blend_pix(pixel_type* p, value_type v, value_type a)
{
blender_type::blend_pix(p->c, v, a);
}
AGG_INLINE void blend_pix(pixel_type* p, value_type v, value_type a) { blender_type::blend_pix(p->c, v, a); }
//--------------------------------------------------------------------
AGG_INLINE void blend_pix(pixel_type* p, const color_type& c, unsigned cover)
@ -208,10 +168,7 @@ namespace agg
}
//--------------------------------------------------------------------
AGG_INLINE void blend_pix(pixel_type* p, const color_type& c)
{
blender_type::blend_pix(p->c, c.v, c.a);
}
AGG_INLINE void blend_pix(pixel_type* p, const color_type& c) { blender_type::blend_pix(p->c, c.v, c.a); }
//--------------------------------------------------------------------
AGG_INLINE void copy_or_blend_pix(pixel_type* p, const color_type& c, unsigned cover)
@ -247,8 +204,8 @@ namespace agg
public:
//--------------------------------------------------------------------
explicit pixfmt_alpha_blend_gray(rbuf_type& rb) :
m_rbuf(&rb)
explicit pixfmt_alpha_blend_gray(rbuf_type& rb)
: m_rbuf(&rb)
{}
void attach(rbuf_type& rb) { m_rbuf = &rb; }
//--------------------------------------------------------------------
@ -257,13 +214,10 @@ namespace agg
bool attach(PixFmt& pixf, int x1, int y1, int x2, int y2)
{
rect_i r(x1, y1, x2, y2);
if (r.clip(rect_i(0, 0, pixf.width()-1, pixf.height()-1)))
if (r.clip(rect_i(0, 0, pixf.width() - 1, pixf.height() - 1)))
{
int stride = pixf.stride();
m_rbuf->attach(pixf.pix_ptr(r.x1, stride < 0 ? r.y2 : r.y1),
(r.x2 - r.x1) + 1,
(r.y2 - r.y1) + 1,
stride);
m_rbuf->attach(pixf.pix_ptr(r.x1, stride < 0 ? r.y2 : r.y1), (r.x2 - r.x1) + 1, (r.y2 - r.y1) + 1, stride);
return true;
}
return false;
@ -304,10 +258,7 @@ namespace agg
}
// Get pixel pointer from raw buffer pointer.
AGG_INLINE static pixel_type* pix_value_ptr(void* p)
{
return (pixel_type*)((value_type*)p + pix_offset);
}
AGG_INLINE static pixel_type* pix_value_ptr(void* p) { return (pixel_type*)((value_type*)p + pix_offset); }
// Get pixel pointer from raw buffer pointer.
AGG_INLINE static const pixel_type* pix_value_ptr(const void* p)
@ -324,16 +275,10 @@ namespace agg
}
//--------------------------------------------------------------------
AGG_INLINE static color_type read_plain_color(const void* p)
{
return pix_value_ptr(p)->get();
}
AGG_INLINE static color_type read_plain_color(const void* p) { return pix_value_ptr(p)->get(); }
//--------------------------------------------------------------------
AGG_INLINE static void make_pix(int8u* p, const color_type& c)
{
((pixel_type*)p)->set(c);
}
AGG_INLINE static void make_pix(int8u* p, const color_type& c) { ((pixel_type*)p)->set(c); }
//--------------------------------------------------------------------
AGG_INLINE color_type pixel(int x, int y) const
@ -346,10 +291,7 @@ namespace agg
}
//--------------------------------------------------------------------
AGG_INLINE void copy_pixel(int x, int y, const color_type& c)
{
pix_value_ptr(x, y, 1)->set(c);
}
AGG_INLINE void copy_pixel(int x, int y, const color_type& c) { pix_value_ptr(x, y, 1)->set(c); }
//--------------------------------------------------------------------
AGG_INLINE void blend_pixel(int x, int y, const color_type& c, int8u cover)
@ -358,38 +300,27 @@ namespace agg
}
//--------------------------------------------------------------------
AGG_INLINE void copy_hline(int x, int y,
unsigned len,
const color_type& c)
AGG_INLINE void copy_hline(int x, int y, unsigned len, const color_type& c)
{
pixel_type* p = pix_value_ptr(x, y, len);
do
{
p->set(c);
p = p->next();
} while (--len);
}
while(--len);
}
//--------------------------------------------------------------------
AGG_INLINE void copy_vline(int x, int y,
unsigned len,
const color_type& c)
AGG_INLINE void copy_vline(int x, int y, unsigned len, const color_type& c)
{
do
{
pix_value_ptr(x, y++, 1)->set(c);
} while (--len);
}
while (--len);
}
//--------------------------------------------------------------------
void blend_hline(int x, int y,
unsigned len,
const color_type& c,
int8u cover)
void blend_hline(int x, int y, 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,
unsigned len,
const color_type& c,
int8u cover)
void blend_vline(int x, int y, 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,
unsigned len,
const color_type& c,
const int8u* covers)
void blend_solid_hspan(int x, int y, 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,
unsigned len,
const color_type& c,
const int8u* covers)
void blend_solid_vspan(int x, int y, 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,
unsigned len,
const color_type* colors)
void copy_color_hspan(int x, int y, 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,
unsigned len,
const color_type* colors)
void copy_color_vspan(int x, int y, unsigned len, const color_type* colors)
{
do
{
pix_value_ptr(x, y++, 1)->set(*colors++);
} while (--len);
}
while (--len);
}
//--------------------------------------------------------------------
void blend_color_hspan(int x, int y,
unsigned len,
const color_type* colors,
const int8u* covers,
int8u cover)
void blend_color_hspan(int x, int y, unsigned len, const color_type* colors, const int8u* covers, int8u cover)
{
pixel_type* p = pix_value_ptr(x, y, len);
@ -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,
unsigned len,
const color_type* colors,
const int8u* covers,
int8u cover)
void blend_color_vspan(int x, int y, unsigned len, const color_type* colors, const int8u* covers, int8u cover)
{
if (covers)
{
do
{
copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++, *covers++);
}
while (--len);
} 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,
int xdst, int ydst,
int xsrc, int ysrc,
unsigned len)
void copy_from(const RenBuf2& from, int xdst, int ydst, int xsrc, int ysrc, unsigned len)
{
if (const int8u* p = from.row_ptr(ysrc))
{
memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width,
p + xsrc * pix_width,
len * pix_width);
memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * 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 xsrc, int ysrc,
int xdst,
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 xsrc, int ysrc,
int xdst,
int ydst,
int xsrc,
int ysrc,
unsigned len,
int8u cover)
{
@ -704,34 +593,33 @@ namespace agg
copy_or_blend_pix(pdst, color_lut[psrc->c[0]], cover);
psrc = psrc->next();
pdst = pdst->next();
}
while (--len);
} while (--len);
}
}
private:
rbuf_type* m_rbuf;
};
};
typedef blender_gray<gray8> blender_gray8;
typedef blender_gray<sgray8> blender_sgray8;
typedef blender_gray<gray16> blender_gray16;
typedef blender_gray<gray32> blender_gray32;
typedef blender_gray<gray8> blender_gray8;
typedef blender_gray<sgray8> blender_sgray8;
typedef blender_gray<gray16> blender_gray16;
typedef blender_gray<gray32> blender_gray32;
typedef blender_gray_pre<gray8> blender_gray8_pre;
typedef blender_gray_pre<sgray8> blender_sgray8_pre;
typedef blender_gray_pre<gray16> blender_gray16_pre;
typedef blender_gray_pre<gray32> blender_gray32_pre;
typedef blender_gray_pre<gray8> blender_gray8_pre;
typedef blender_gray_pre<sgray8> blender_sgray8_pre;
typedef blender_gray_pre<gray16> blender_gray16_pre;
typedef blender_gray_pre<gray32> blender_gray32_pre;
typedef pixfmt_alpha_blend_gray<blender_gray8, rendering_buffer> pixfmt_gray8;
typedef pixfmt_alpha_blend_gray<blender_sgray8, rendering_buffer> pixfmt_sgray8;
typedef pixfmt_alpha_blend_gray<blender_gray16, rendering_buffer> pixfmt_gray16;
typedef pixfmt_alpha_blend_gray<blender_gray32, rendering_buffer> pixfmt_gray32;
typedef pixfmt_alpha_blend_gray<blender_gray8, rendering_buffer> pixfmt_gray8;
typedef pixfmt_alpha_blend_gray<blender_sgray8, rendering_buffer> pixfmt_sgray8;
typedef pixfmt_alpha_blend_gray<blender_gray16, rendering_buffer> pixfmt_gray16;
typedef pixfmt_alpha_blend_gray<blender_gray32, rendering_buffer> pixfmt_gray32;
typedef pixfmt_alpha_blend_gray<blender_gray8_pre, rendering_buffer> pixfmt_gray8_pre;
typedef pixfmt_alpha_blend_gray<blender_sgray8_pre, rendering_buffer> pixfmt_sgray8_pre;
typedef pixfmt_alpha_blend_gray<blender_gray16_pre, rendering_buffer> pixfmt_gray16_pre;
typedef pixfmt_alpha_blend_gray<blender_gray32_pre, rendering_buffer> pixfmt_gray32_pre;
}
typedef pixfmt_alpha_blend_gray<blender_gray8_pre, rendering_buffer> pixfmt_gray8_pre;
typedef pixfmt_alpha_blend_gray<blender_sgray8_pre, rendering_buffer> pixfmt_sgray8_pre;
typedef pixfmt_alpha_blend_gray<blender_gray16_pre, rendering_buffer> pixfmt_gray16_pre;
typedef pixfmt_alpha_blend_gray<blender_gray32_pre, rendering_buffer> pixfmt_gray32_pre;
} // namespace agg
#endif

478
deps/agg/include/agg_pixfmt_rgb.h vendored
View file

@ -29,18 +29,20 @@
#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
{
//=====================================================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)
AGG_INLINE void operator()(value_type* p)
{
p[Order::R] = m_gamma.dir(p[Order::R]);
p[Order::G] = m_gamma.dir(p[Order::G]);
@ -49,19 +51,20 @@ namespace agg
private:
const GammaLut& m_gamma;
};
};
//=====================================================apply_gamma_inv_rgb
template<class ColorT, class Order, class GammaLut> class apply_gamma_inv_rgb
{
//=====================================================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)
AGG_INLINE void operator()(value_type* p)
{
p[Order::R] = m_gamma.inv(p[Order::R]);
p[Order::G] = m_gamma.inv(p[Order::G]);
@ -70,12 +73,12 @@ namespace agg
private:
const GammaLut& m_gamma;
};
};
//=========================================================blender_rgb
template<class ColorT, class Order> struct blender_rgb
{
//=========================================================blender_rgb
template<class ColorT, class Order>
struct blender_rgb
{
typedef ColorT color_type;
typedef Order order_type;
typedef typename color_type::value_type value_type;
@ -83,21 +86,19 @@ namespace agg
enum base_scale_e { base_shift = color_type::base_shift };
//--------------------------------------------------------------------
static AGG_INLINE void blend_pix(value_type* p,
unsigned cr, unsigned cg, unsigned cb,
unsigned alpha,
unsigned cover=0)
static AGG_INLINE void
blend_pix(value_type* p, unsigned cr, unsigned cg, unsigned cb, 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);
p[Order::B] += (value_type)(((cb - p[Order::B]) * alpha) >> base_shift);
}
};
};
//======================================================blender_rgb_pre
template<class ColorT, class Order> struct blender_rgb_pre
{
//======================================================blender_rgb_pre
template<class ColorT, class Order>
struct blender_rgb_pre
{
typedef ColorT color_type;
typedef Order order_type;
typedef typename color_type::value_type value_type;
@ -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,
unsigned cr, unsigned cg, unsigned cb,
unsigned alpha,
unsigned cover)
static AGG_INLINE void
blend_pix(value_type* p, unsigned cr, unsigned cg, unsigned cb, unsigned alpha, unsigned cover)
{
alpha = color_type::base_mask - alpha;
cover = (cover + 1) << (base_shift - 8);
@ -118,23 +117,19 @@ namespace agg
}
//--------------------------------------------------------------------
static AGG_INLINE void blend_pix(value_type* p,
unsigned cr, unsigned cg, unsigned cb,
unsigned alpha)
static AGG_INLINE void blend_pix(value_type* p, 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
{
//===================================================blender_rgb_gamma
template<class ColorT, class Order, class Gamma>
class blender_rgb_gamma
{
public:
typedef ColorT color_type;
typedef Order order_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,
unsigned cr, unsigned cg, unsigned cb,
unsigned alpha,
unsigned cover=0)
AGG_INLINE void blend_pix(value_type* p, 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]);
@ -163,14 +157,12 @@ namespace agg
private:
const gamma_type* m_gamma;
};
};
//==================================================pixfmt_alpha_blend_rgb
template<class Blender, class RenBuf> class pixfmt_alpha_blend_rgb
{
//==================================================pixfmt_alpha_blend_rgb
template<class Blender, class RenBuf>
class pixfmt_alpha_blend_rgb
{
public:
typedef RenBuf rbuf_type;
typedef Blender blender_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,14 +180,12 @@ namespace agg
private:
//--------------------------------------------------------------------
AGG_INLINE void copy_or_blend_pix(value_type* p,
const color_type& c,
unsigned cover)
AGG_INLINE void copy_or_blend_pix(value_type* p, const color_type& c, unsigned cover)
{
if (c.a)
{
calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8;
if(alpha == base_mask)
if (alpha == base_mask)
{
p[order_type::R] = c.r;
p[order_type::G] = c.g;
@ -210,12 +199,11 @@ namespace agg
}
//--------------------------------------------------------------------
AGG_INLINE void copy_or_blend_pix(value_type* p,
const color_type& c)
AGG_INLINE void copy_or_blend_pix(value_type* p, const color_type& c)
{
if (c.a)
{
if(c.a == base_mask)
if (c.a == base_mask)
{
p[order_type::R] = c.r;
p[order_type::G] = c.g;
@ -228,11 +216,10 @@ namespace agg
}
}
public:
//--------------------------------------------------------------------
explicit pixfmt_alpha_blend_rgb(rbuf_type& rb) :
m_rbuf(&rb)
explicit pixfmt_alpha_blend_rgb(rbuf_type& rb)
: m_rbuf(&rb)
{}
void attach(rbuf_type& rb) { m_rbuf = &rb; }
@ -241,13 +228,10 @@ namespace agg
bool attach(PixFmt& pixf, int x1, int y1, int x2, int y2)
{
rect_i r(x1, y1, x2, y2);
if(r.clip(rect_i(0, 0, pixf.width()-1, pixf.height()-1)))
if (r.clip(rect_i(0, 0, pixf.width() - 1, pixf.height() - 1)))
{
int stride = pixf.stride();
m_rbuf->attach(pixf.pix_ptr(r.x1, stride < 0 ? r.y2 : r.y1),
(r.x2 - r.x1) + 1,
(r.y2 - r.y1) + 1,
stride);
m_rbuf->attach(pixf.pix_ptr(r.x1, stride < 0 ? r.y2 : r.y1), (r.x2 - r.x1) + 1, (r.y2 - r.y1) + 1, stride);
return true;
}
return false;
@ -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)
{
return m_rbuf->row_ptr(y) + x * pix_width;
}
AGG_INLINE int8u* pix_ptr(int x, int y) { return m_rbuf->row_ptr(y) + x * pix_width; }
AGG_INLINE const int8u* pix_ptr(int x, int y) const
{
return m_rbuf->row_ptr(y) + x * pix_width;
}
AGG_INLINE const int8u* pix_ptr(int x, int y) const { 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],
p[order_type::G],
p[order_type::B]);
return color_type(p[order_type::R], 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,
unsigned len,
const color_type& c)
AGG_INLINE void copy_hline(int x, int y, unsigned len, const color_type& c)
{
value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + x + x + x;
do
@ -322,41 +295,30 @@ 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,
unsigned len,
const color_type& c)
AGG_INLINE void copy_vline(int x, int y, unsigned len, const color_type& c)
{
do
{
value_type* p = (value_type*)
m_rbuf->row_ptr(x, y++, 1) + x + x + x;
value_type* p = (value_type*)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,
unsigned len,
const color_type& c,
int8u cover)
void blend_hline(int x, int y, unsigned len, const color_type& c, int8u cover)
{
if (c.a)
{
value_type* p = (value_type*)
m_rbuf->row_ptr(x, y, len) + x + x + x;
value_type* p = (value_type*)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)
if (alpha == base_mask)
{
do
{
@ -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,66 +334,52 @@ 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,
unsigned len,
const color_type& c,
int8u cover)
void blend_vline(int x, int y, unsigned len, const color_type& c, int8u cover)
{
if (c.a)
{
value_type* p;
calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8;
if(alpha == base_mask)
if (alpha == base_mask)
{
do
{
p = (value_type*)
m_rbuf->row_ptr(x, y++, 1) + x + x + x;
p = (value_type*)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*)
m_rbuf->row_ptr(x, y++, 1) + x + x + x;
p = (value_type*)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,
unsigned len,
const color_type& c,
const int8u* covers)
void blend_solid_hspan(int x, int y, unsigned len, const color_type& c, const int8u* covers)
{
if (c.a)
{
value_type* p = (value_type*)
m_rbuf->row_ptr(x, y, len) + x + x + x;
value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + x + x + x;
do
{
calc_type alpha = (calc_type(c.a) * (calc_type(*covers) + 1)) >> 8;
if(alpha == base_mask)
if (alpha == base_mask)
{
p[order_type::R] = c.r;
p[order_type::G] = c.g;
@ -444,27 +391,21 @@ namespace agg
}
p += 3;
++covers;
}
while(--len);
} while (--len);
}
}
//--------------------------------------------------------------------
void blend_solid_vspan(int x, int y,
unsigned len,
const color_type& c,
const int8u* covers)
void blend_solid_vspan(int x, int y, unsigned len, const color_type& c, const int8u* covers)
{
if (c.a)
{
do
{
value_type* p = (value_type*)
m_rbuf->row_ptr(x, y++, 1) + x + x + x;
value_type* p = (value_type*)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)
if (alpha == base_mask)
{
p[order_type::R] = c.r;
p[order_type::G] = c.g;
@ -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,
unsigned len,
const color_type* colors)
void copy_color_hspan(int x, int y, unsigned len, const color_type* colors)
{
value_type* p = (value_type*)
m_rbuf->row_ptr(x, y, len) + x + x + x;
value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + x + x + x;
do
{
@ -496,58 +432,44 @@ namespace agg
p[order_type::B] = colors->b;
++colors;
p += 3;
} while (--len);
}
while(--len);
}
//--------------------------------------------------------------------
void copy_color_vspan(int x, int y,
unsigned len,
const color_type* colors)
void copy_color_vspan(int x, int y, unsigned len, const color_type* colors)
{
do
{
value_type* p = (value_type*)
m_rbuf->row_ptr(x, y++, 1) + x + x + x;
value_type* p = (value_type*)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,
unsigned len,
const color_type* colors,
const int8u* covers,
int8u cover)
void blend_color_hspan(int x, int y, unsigned len, const color_type* colors, const int8u* covers, int8u cover)
{
value_type* p = (value_type*)
m_rbuf->row_ptr(x, y, len) + x + x + x;
value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + x + x + x;
if(covers)
if (covers)
{
do
{
copy_or_blend_pix(p, *colors++, *covers++);
p += 3;
}
while(--len);
} while (--len);
}
else
{
if(cover == 255)
if (cover == 255)
{
do
{
copy_or_blend_pix(p, *colors++);
p += 3;
}
while(--len);
} while (--len);
}
else
{
@ -555,136 +477,114 @@ namespace agg
{
copy_or_blend_pix(p, *colors++, cover);
p += 3;
}
while(--len);
} while (--len);
}
}
}
//--------------------------------------------------------------------
void blend_color_vspan(int x, int y,
unsigned len,
const color_type* colors,
const int8u* covers,
int8u cover)
void blend_color_vspan(int x, int y, unsigned len, const color_type* colors, const int8u* covers, int8u cover)
{
value_type* p;
if(covers)
if (covers)
{
do
{
p = (value_type*)
m_rbuf->row_ptr(x, y++, 1) + x + x + x;
p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + x + x + x;
copy_or_blend_pix(p, *colors++, *covers++);
}
while(--len);
} while (--len);
}
else
{
if(cover == 255)
if (cover == 255)
{
do
{
p = (value_type*)
m_rbuf->row_ptr(x, y++, 1) + x + x + x;
p = (value_type*)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*)
m_rbuf->row_ptr(x, y++, 1) + x + x + x;
p = (value_type*)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)
for (y = 0; y < height(); ++y)
{
row_data r = m_rbuf->row(y);
if(r.ptr)
if (r.ptr)
{
unsigned len = r.x2 - r.x1 + 1;
value_type* p = (value_type*)
m_rbuf->row_ptr(r.x1, y, len) + r.x1 * 3;
value_type* p = (value_type*)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,
int xdst, int ydst,
int xsrc, int ysrc,
unsigned len)
void copy_from(const RenBuf2& from, int xdst, int ydst, int xsrc, int ysrc, unsigned len)
{
const int8u* p = from.row_ptr(ysrc);
if(p)
if (p)
{
memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width,
p + xsrc * pix_width,
len * pix_width);
memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width, p + xsrc * pix_width, len * pix_width);
}
}
//--------------------------------------------------------------------
template<class SrcPixelFormatRenderer>
void blend_from(const SrcPixelFormatRenderer& from,
int xdst, int ydst,
int xsrc, int ysrc,
unsigned len,
int8u cover)
void
blend_from(const SrcPixelFormatRenderer& from, int xdst, int ydst, int xsrc, int ysrc, unsigned len, int8u cover)
{
typedef typename SrcPixelFormatRenderer::order_type src_order;
const value_type* psrc = (const value_type*)from.row_ptr(ysrc);
if(psrc)
if (psrc)
{
psrc += xsrc * 4;
value_type* pdst =
(value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;
value_type* pdst = (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;
if(cover == 255)
if (cover == 255)
{
do
{
value_type alpha = psrc[src_order::A];
if(alpha)
if (alpha)
{
if(alpha == base_mask)
if (alpha == base_mask)
{
pdst[order_type::R] = psrc[src_order::R];
pdst[order_type::G] = psrc[src_order::G];
@ -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,26 +624,24 @@ namespace agg
template<class SrcPixelFormatRenderer>
void blend_from_color(const SrcPixelFormatRenderer& from,
const color_type& color,
int xdst, int ydst,
int xsrc, int ysrc,
int xdst,
int ydst,
int xsrc,
int ysrc,
unsigned len,
int8u cover)
{
typedef typename SrcPixelFormatRenderer::value_type src_value_type;
const src_value_type* psrc = (src_value_type*)from.row_ptr(ysrc);
if(psrc)
if (psrc)
{
value_type* pdst =
(value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;
value_type* pdst = (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;
do
{
copy_or_blend_pix(pdst,
color,
(*psrc * cover + base_mask) >> base_shift);
copy_or_blend_pix(pdst, color, (*psrc * cover + base_mask) >> base_shift);
++psrc;
pdst += 3;
}
while(--len);
} while (--len);
}
}
@ -753,29 +649,28 @@ namespace agg
template<class SrcPixelFormatRenderer>
void blend_from_lut(const SrcPixelFormatRenderer& from,
const color_type* color_lut,
int xdst, int ydst,
int xsrc, int ysrc,
int xdst,
int ydst,
int xsrc,
int ysrc,
unsigned len,
int8u cover)
{
typedef typename SrcPixelFormatRenderer::value_type src_value_type;
const src_value_type* psrc = (src_value_type*)from.row_ptr(ysrc);
if(psrc)
if (psrc)
{
value_type* pdst =
(value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;
value_type* pdst = (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;
if(cover == 255)
if (cover == 255)
{
do
{
const color_type& color = color_lut[*psrc];
m_blender.blend_pix(pdst,
color.r, color.g, color.b, color.a);
m_blender.blend_pix(pdst, 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);
}
}
}
@ -793,68 +687,70 @@ namespace agg
private:
rbuf_type* m_rbuf;
Blender m_blender;
};
};
typedef pixfmt_alpha_blend_rgb<blender_rgb<rgba8, order_rgb>, rendering_buffer> pixfmt_rgb24; //----pixfmt_rgb24
typedef pixfmt_alpha_blend_rgb<blender_rgb<rgba8, order_bgr>, rendering_buffer> pixfmt_bgr24; //----pixfmt_bgr24
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<rgba8, order_rgb>, rendering_buffer> pixfmt_rgb24; //----pixfmt_rgb24
typedef pixfmt_alpha_blend_rgb<blender_rgb<rgba8, order_bgr>, rendering_buffer> pixfmt_bgr24; //----pixfmt_bgr24
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_bgr>, rendering_buffer> 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
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_bgr>, rendering_buffer>
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 :
public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_rgb, Gamma>, rendering_buffer>
{
//-----------------------------------------------------pixfmt_rgb24_gamma
template<class Gamma>
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_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_rgb, Gamma>, rendering_buffer>(rb)
pixfmt_rgb24_gamma(rendering_buffer& rb, const Gamma& g)
: 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 :
public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_bgr, Gamma>, rendering_buffer>
{
//-----------------------------------------------------pixfmt_bgr24_gamma
template<class Gamma>
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_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_bgr, Gamma>, rendering_buffer>(rb)
pixfmt_bgr24_gamma(rendering_buffer& rb, const Gamma& g)
: 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 :
public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_rgb, Gamma>, rendering_buffer>
{
//-----------------------------------------------------pixfmt_rgb48_gamma
template<class Gamma>
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_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_rgb, Gamma>, rendering_buffer>(rb)
pixfmt_rgb48_gamma(rendering_buffer& rb, const Gamma& g)
: 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 :
public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_bgr, Gamma>, rendering_buffer>
{
//-----------------------------------------------------pixfmt_bgr48_gamma
template<class Gamma>
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_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_bgr, Gamma>, rendering_buffer>(rb)
pixfmt_bgr48_gamma(rendering_buffer& rb, const Gamma& g)
: pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_bgr, Gamma>, rendering_buffer>(rb)
{
this->blender().gamma(g);
}
};
};
}
} // namespace agg
#endif

859
deps/agg/include/agg_pixfmt_rgb_packed.h vendored
View file

File diff suppressed because it is too large Load diff

1726
deps/agg/include/agg_pixfmt_rgba.h vendored
View file

File diff suppressed because it is too large Load diff

95
deps/agg/include/agg_pixfmt_transposer.h vendored
View file

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

407
deps/agg/include/agg_rasterizer_cells_aa.h vendored
View file

@ -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
{
//-----------------------------------------------------rasterizer_cells_aa
// An internal class that implements the main rasterization algorithm.
// Used in the rasterizer. Should not be used direcly.
template<class Cell> class rasterizer_cells_aa
{
enum cell_block_scale_e
{
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
{
return m_num_cells;
}
unsigned total_cells() const { return m_num_cells; }
unsigned scanline_num_cells(unsigned y) const
{
return m_sorted_y[y - m_min_y].num;
}
unsigned scanline_num_cells(unsigned y) const { return m_sorted_y[y - m_min_y].num; }
const cell_type* const* scanline_cells(unsigned y) const
{
@ -96,7 +88,7 @@ namespace agg
private:
rasterizer_cells_aa(const self_type&);
const self_type& operator = (const self_type&);
const self_type& operator=(const self_type&);
void set_curr_cell(int x, int y);
void add_curr_cell();
@ -119,19 +111,16 @@ namespace agg
int m_max_x;
int m_max_y;
bool m_sorted;
};
};
//------------------------------------------------------------------------
template<class Cell>
rasterizer_cells_aa<Cell>::~rasterizer_cells_aa()
{
if(m_num_blocks)
//------------------------------------------------------------------------
template<class Cell>
rasterizer_cells_aa<Cell>::~rasterizer_cells_aa()
{
if (m_num_blocks)
{
cell_type** ptr = m_cells + m_num_blocks - 1;
while(m_num_blocks > 0)
while (m_num_blocks > 0)
{
pod_allocator<cell_type>::deallocate(*ptr, cell_block_size);
ptr--;
@ -139,33 +128,33 @@ namespace agg
}
pod_allocator<cell_type*>::deallocate(m_cells, m_max_blocks);
}
}
}
//------------------------------------------------------------------------
template<class Cell>
rasterizer_cells_aa<Cell>::rasterizer_cells_aa() :
m_num_blocks(0),
m_max_blocks(0),
m_curr_block(0),
m_num_cells(0),
m_cells(0),
m_curr_cell_ptr(0),
m_sorted_cells(),
m_sorted_y(),
m_min_x(0x7FFFFFFF),
m_min_y(0x7FFFFFFF),
m_max_x(-0x7FFFFFFF),
m_max_y(-0x7FFFFFFF),
m_sorted(false)
{
//------------------------------------------------------------------------
template<class Cell>
rasterizer_cells_aa<Cell>::rasterizer_cells_aa()
: m_num_blocks(0)
, m_max_blocks(0)
, m_curr_block(0)
, m_num_cells(0)
, m_cells(0)
, m_curr_cell_ptr(0)
, m_sorted_cells()
, m_sorted_y()
, m_min_x(0x7FFFFFFF)
, m_min_y(0x7FFFFFFF)
, m_max_x(-0x7FFFFFFF)
, m_max_y(-0x7FFFFFFF)
, m_sorted(false)
{
m_style_cell.initial();
m_curr_cell.initial();
}
}
//------------------------------------------------------------------------
template<class Cell>
void rasterizer_cells_aa<Cell>::reset()
{
//------------------------------------------------------------------------
template<class Cell>
void rasterizer_cells_aa<Cell>::reset()
{
m_num_cells = 0;
m_curr_block = 0;
m_curr_cell.initial();
@ -175,29 +164,30 @@ namespace agg
m_min_y = 0x7FFFFFFF;
m_max_x = -0x7FFFFFFF;
m_max_y = -0x7FFFFFFF;
}
}
//------------------------------------------------------------------------
template<class Cell>
AGG_INLINE void rasterizer_cells_aa<Cell>::add_curr_cell()
//------------------------------------------------------------------------
template<class Cell>
AGG_INLINE void rasterizer_cells_aa<Cell>::add_curr_cell()
{
if (m_curr_cell.area | m_curr_cell.cover)
{
if(m_curr_cell.area | m_curr_cell.cover)
if ((m_num_cells & cell_block_mask) == 0)
{
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;
++m_num_cells;
}
}
}
//------------------------------------------------------------------------
template<class Cell>
AGG_INLINE void rasterizer_cells_aa<Cell>::set_curr_cell(int x, int y)
{
if(m_curr_cell.not_equal(x, y, m_style_cell))
//------------------------------------------------------------------------
template<class Cell>
AGG_INLINE void rasterizer_cells_aa<Cell>::set_curr_cell(int x, int y)
{
if (m_curr_cell.not_equal(x, y, m_style_cell))
{
add_curr_cell();
m_curr_cell.style(m_style_cell);
@ -206,14 +196,12 @@ namespace agg
m_curr_cell.cover = 0;
m_curr_cell.area = 0;
}
}
}
//------------------------------------------------------------------------
template<class Cell>
AGG_INLINE void rasterizer_cells_aa<Cell>::render_hline(int ey,
int x1, int y1,
int x2, int y2)
{
//------------------------------------------------------------------------
template<class Cell>
AGG_INLINE void rasterizer_cells_aa<Cell>::render_hline(int ey, int x1, int y1, int x2, int y2)
{
int ex1 = x1 >> poly_subpixel_shift;
int ex2 = x2 >> poly_subpixel_shift;
int fx1 = x1 & poly_subpixel_mask;
@ -222,15 +210,15 @@ namespace agg
int delta, p, first, dx;
int incr, lift, mod, rem;
//trivial case. Happens often
if(y1 == y2)
// trivial case. Happens often
if (y1 == y2)
{
set_curr_cell(ex2, ey);
return;
}
//everything is located in a single cell. That is easy!
if(ex1 == ex2)
// everything is located in a single cell. That is easy!
if (ex1 == ex2)
{
delta = y2 - y1;
m_curr_cell.cover += delta;
@ -238,15 +226,15 @@ namespace agg
return;
}
//ok, we'll have to render a run of adjacent cells on the same
//hline...
// ok, we'll have to render a run of adjacent cells on the same
// hline...
p = (poly_subpixel_scale - fx1) * (y2 - y1);
first = poly_subpixel_scale;
incr = 1;
dx = x2 - x1;
if(dx < 0)
if (dx < 0)
{
p = fx1 * (y2 - y1);
first = 0;
@ -257,7 +245,7 @@ namespace agg
delta = p / dx;
mod = p % dx;
if(mod < 0)
if (mod < 0)
{
delta--;
mod += dx;
@ -270,7 +258,7 @@ namespace agg
set_curr_cell(ex1, ey);
y1 += delta;
if(ex1 != ex2)
if (ex1 != ex2)
{
p = poly_subpixel_scale * (y2 - y1 + delta);
lift = p / dx;
@ -288,7 +276,7 @@ namespace agg
{
delta = lift;
mod += rem;
if(mod >= 0)
if (mod >= 0)
{
mod -= dx;
delta++;
@ -304,31 +292,33 @@ namespace agg
delta = y2 - y1;
m_curr_cell.cover += delta;
m_curr_cell.area += (fx2 + poly_subpixel_scale - first) * delta;
}
}
//------------------------------------------------------------------------
template<class Cell>
AGG_INLINE void rasterizer_cells_aa<Cell>::style(const cell_type& style_cell)
{
//------------------------------------------------------------------------
template<class Cell>
AGG_INLINE void rasterizer_cells_aa<Cell>::style(const cell_type& style_cell)
{
m_style_cell.style(style_cell);
}
}
//------------------------------------------------------------------------
template<class Cell>
void rasterizer_cells_aa<Cell>::line(int x1, int y1, int x2, int y2)
{
//------------------------------------------------------------------------
template<class Cell>
void rasterizer_cells_aa<Cell>::line(int x1, int y1, int x2, int y2)
{
enum dx_limit_e { dx_limit = 16384 << poly_subpixel_shift };
int dx = x2 - x1;
if(dx >= dx_limit || dx <= -dx_limit)
if (dx >= dx_limit || dx <= -dx_limit)
{
int cx = (x1 + x2) >> 1;
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) ||
(std::abs(x2) >= std::numeric_limits<int>::max()/2) || (std::abs(y2) >= std::numeric_limits<int>::max()/2))
if ((std::abs(x1) >= 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,37 +336,45 @@ 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_max_x) m_max_x = ex1;
if(ey1 < m_min_y) m_min_y = ey1;
if(ey1 > m_max_y) m_max_y = ey1;
if(ex2 < m_min_x) m_min_x = ex2;
if(ex2 > m_max_x) m_max_x = ex2;
if(ey2 < m_min_y) m_min_y = ey2;
if(ey2 > m_max_y) m_max_y = ey2;
if (ex1 < m_min_x)
m_min_x = ex1;
if (ex1 > m_max_x)
m_max_x = ex1;
if (ey1 < m_min_y)
m_min_y = ey1;
if (ey1 > m_max_y)
m_max_y = ey1;
if (ex2 < m_min_x)
m_min_x = ex2;
if (ex2 > m_max_x)
m_max_x = ex2;
if (ey2 < m_min_y)
m_min_y = ey2;
if (ey2 > m_max_y)
m_max_y = ey2;
set_curr_cell(ex1, ey1);
//everything is on a single hline
if(ey1 == ey2)
// everything is on a single hline
if (ey1 == ey2)
{
render_hline(ey1, x1, fy1, x2, fy2);
return;
}
//Vertical line - we have to calculate start and end cells,
//and then - the common values of the area and coverage for
//all cells of the line. We know exactly there's only one
//cell, so, we don't have to call render_hline().
// Vertical line - we have to calculate start and end cells,
// and then - the common values of the area and coverage for
// all cells of the line. We know exactly there's only one
// cell, so, we don't have to call render_hline().
incr = 1;
if(dx == 0)
if (dx == 0)
{
int ex = x1 >> poly_subpixel_shift;
int two_fx = (x1 - (ex << poly_subpixel_shift)) << 1;
int area;
first = poly_subpixel_scale;
if(dy < 0)
if (dy < 0)
{
first = 0;
incr = -1;
@ -384,7 +382,7 @@ namespace agg
x_from = x1;
//render_hline(ey1, x_from, fy1, x_from, first);
// render_hline(ey1, x_from, fy1, x_from, first);
delta = first - fy1;
m_curr_cell.cover += delta;
m_curr_cell.area += two_fx * delta;
@ -394,26 +392,26 @@ namespace agg
delta = first + first - poly_subpixel_scale;
area = two_fx * delta;
while(ey1 != ey2)
while (ey1 != ey2)
{
//render_hline(ey1, x_from, poly_subpixel_scale - first, x_from, first);
// render_hline(ey1, x_from, poly_subpixel_scale - first, x_from, first);
m_curr_cell.cover = delta;
m_curr_cell.area = area;
ey1 += incr;
set_curr_cell(ex, ey1);
}
//render_hline(ey1, x_from, poly_subpixel_scale - first, x_from, fy2);
// render_hline(ey1, x_from, poly_subpixel_scale - first, x_from, fy2);
delta = fy2 - poly_subpixel_scale + first;
m_curr_cell.cover += delta;
m_curr_cell.area += two_fx * delta;
return;
}
//ok, we have to render several hlines
// ok, we have to render several hlines
p = (poly_subpixel_scale - fy1) * dx;
first = poly_subpixel_scale;
if(dy < 0)
if (dy < 0)
{
p = fy1 * dx;
first = 0;
@ -424,7 +422,7 @@ namespace agg
delta = p / dy;
mod = p % dy;
if(mod < 0)
if (mod < 0)
{
delta--;
mod += dy;
@ -436,20 +434,20 @@ namespace agg
ey1 += incr;
set_curr_cell(x_from >> poly_subpixel_shift, ey1);
if(ey1 != ey2)
if (ey1 != ey2)
{
p = poly_subpixel_scale * dx;
lift = p / dy;
rem = p % dy;
if(rem < 0)
if (rem < 0)
{
lift--;
rem += dy;
}
mod -= dy;
while(ey1 != ey2)
while (ey1 != ey2)
{
delta = lift;
mod += rem;
@ -468,21 +466,19 @@ namespace agg
}
}
render_hline(ey1, x_from, poly_subpixel_scale - first, x2, fy2);
}
}
//------------------------------------------------------------------------
template<class Cell>
void rasterizer_cells_aa<Cell>::allocate_block()
//------------------------------------------------------------------------
template<class Cell>
void rasterizer_cells_aa<Cell>::allocate_block()
{
if (m_curr_block >= m_num_blocks)
{
if(m_curr_block >= m_num_blocks)
if (m_num_blocks >= m_max_blocks)
{
if(m_num_blocks >= m_max_blocks)
{
cell_type** new_cells =
pod_allocator<cell_type*>::allocate(m_max_blocks +
cell_block_pool);
cell_type** new_cells = pod_allocator<cell_type*>::allocate(m_max_blocks + cell_block_pool);
if(m_cells)
if (m_cells)
{
memcpy(new_cells, m_cells, m_max_blocks * sizeof(cell_type*));
pod_allocator<cell_type*>::deallocate(m_cells, m_max_blocks);
@ -491,35 +487,27 @@ namespace agg
m_max_blocks += cell_block_pool;
}
m_cells[m_num_blocks++] =
pod_allocator<cell_type>::allocate(cell_block_size);
m_cells[m_num_blocks++] = pod_allocator<cell_type>::allocate(cell_block_size);
}
m_curr_cell_ptr = m_cells[m_curr_block++];
}
}
//------------------------------------------------------------------------
template <class T> static AGG_INLINE void swap_cells(T* a, T* b)
{
//------------------------------------------------------------------------
template<class T>
static AGG_INLINE void swap_cells(T* a, T* b)
{
T temp = *a;
*a = *b;
*b = temp;
}
}
//------------------------------------------------------------------------
enum { qsort_threshold = 9 };
//------------------------------------------------------------------------
enum
{
qsort_threshold = 9
};
//------------------------------------------------------------------------
template<class Cell>
void qsort_cells(Cell** start, unsigned num)
{
//------------------------------------------------------------------------
template<class Cell>
void qsort_cells(Cell** start, unsigned num)
{
Cell** stack[80];
Cell*** top;
Cell** limit;
@ -537,7 +525,7 @@ namespace agg
Cell** j;
Cell** pivot;
if(len > qsort_threshold)
if (len > qsort_threshold)
{
// we use base + len/2 as the pivot
pivot = base + len / 2;
@ -547,28 +535,32 @@ namespace agg
j = limit - 1;
// now ensure that *i <= *base <= *j
if((*j)->x < (*i)->x)
if ((*j)->x < (*i)->x)
{
swap_cells(i, j);
}
if((*base)->x < (*i)->x)
if ((*base)->x < (*i)->x)
{
swap_cells(base, i);
}
if((*j)->x < (*base)->x)
if ((*j)->x < (*base)->x)
{
swap_cells(base, j);
}
for(;;)
for (;;)
{
int x = (*base)->x;
do i++; while( (*i)->x < x );
do j--; while( x < (*j)->x );
do
i++;
while ((*i)->x < x);
do
j--;
while (x < (*j)->x);
if(i > j)
if (i > j)
{
break;
}
@ -579,7 +571,7 @@ namespace agg
swap_cells(base, j);
// now, push the largest sub-array
if(j - base > limit - i)
if (j - base > limit - i)
{
top[0] = base;
top[1] = j;
@ -599,9 +591,9 @@ namespace agg
j = base;
i = j + 1;
for(; i < limit; j = i, i++)
for (; i < limit; j = i, i++)
{
for(; j[1]->x < (*j)->x; j--)
for (; j[1]->x < (*j)->x; j--)
{
swap_cells(j + 1, j);
if (j == base)
@ -611,7 +603,7 @@ namespace agg
}
}
if(top > stack)
if (top > stack)
{
top -= 2;
base = top[0];
@ -623,14 +615,14 @@ namespace agg
}
}
}
}
}
//------------------------------------------------------------------------
template<class Cell>
void rasterizer_cells_aa<Cell>::sort_cells()
{
if(m_sorted) return; //Perform sort only the first time.
//------------------------------------------------------------------------
template<class Cell>
void rasterizer_cells_aa<Cell>::sort_cells()
{
if (m_sorted)
return; // Perform sort only the first time.
add_curr_cell();
m_curr_cell.x = 0x7FFFFFFF;
@ -638,20 +630,21 @@ 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++)
//{
// cell_type* cell = m_cells[nc >> cell_block_shift] + (nc & cell_block_mask);
// if(cell->x < m_min_x ||
// cell->y < m_min_y ||
// cell->x > m_max_x ||
// cell->y > m_max_y)
// {
// cell = cell; // Breakpoint here
// }
//}
// DBG: Check to see if min/max works well.
// for(unsigned nc = 0; nc < m_num_cells; nc++)
//{
// cell_type* cell = m_cells[nc >> cell_block_shift] + (nc & cell_block_mask);
// if(cell->x < m_min_x ||
// cell->y < m_min_y ||
// cell->x > m_max_x ||
// cell->y > m_max_y)
// {
// cell = cell; // Breakpoint here
// }
//}
// Allocate the array of cell pointers
m_sorted_cells.allocate(m_num_cells, 16);
@ -664,11 +657,11 @@ namespace agg
cell_type* cell_ptr;
unsigned nb = m_num_cells >> cell_block_shift;
unsigned i;
while(nb > 0)
while (nb > 0)
{
cell_ptr = *block_ptr++;
i = cell_block_size;
while(i > 0)
while (i > 0)
{
m_sorted_y[cell_ptr->y - m_min_y].start++;
++cell_ptr;
@ -679,7 +672,7 @@ namespace agg
cell_ptr = *block_ptr++;
i = m_num_cells & cell_block_mask;
while(i > 0)
while (i > 0)
{
m_sorted_y[cell_ptr->y - m_min_y].start++;
++cell_ptr;
@ -688,7 +681,7 @@ namespace agg
// Convert the Y-histogram into the array of starting indexes
unsigned start = 0;
for(i = 0; i < m_sorted_y.size(); i++)
for (i = 0; i < m_sorted_y.size(); i++)
{
unsigned v = m_sorted_y[i].start;
m_sorted_y[i].start = start;
@ -698,11 +691,11 @@ namespace agg
// Fill the cell pointer array sorted by Y
block_ptr = m_cells;
nb = m_num_cells >> cell_block_shift;
while(nb > 0)
while (nb > 0)
{
cell_ptr = *block_ptr++;
i = cell_block_size;
while(i > 0)
while (i > 0)
{
sorted_y& curr_y = m_sorted_y[cell_ptr->y - m_min_y];
m_sorted_cells[curr_y.start + curr_y.num] = cell_ptr;
@ -715,7 +708,7 @@ namespace agg
cell_ptr = *block_ptr++;
i = m_num_cells & cell_block_mask;
while(i > 0)
while (i > 0)
{
sorted_y& curr_y = m_sorted_y[cell_ptr->y - m_min_y];
m_sorted_cells[curr_y.start + curr_y.num] = cell_ptr;
@ -725,34 +718,37 @@ namespace agg
}
// Finally arrange the X-arrays
for(i = 0; i < m_sorted_y.size(); i++)
for (i = 0; i < m_sorted_y.size(); i++)
{
const sorted_y& curr_y = m_sorted_y[i];
if(curr_y.num)
if (curr_y.num)
{
qsort_cells(m_sorted_cells.data() + curr_y.start, curr_y.num);
}
}
m_sorted = true;
}
}
//------------------------------------------------------scanline_hit_test
class scanline_hit_test
{
//------------------------------------------------------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; }
@ -760,9 +756,8 @@ namespace agg
private:
int m_x;
bool m_hit;
};
};
}
} // namespace agg
#endif

497
deps/agg/include/agg_rasterizer_compound_aa.h vendored
View file

@ -32,15 +32,14 @@
#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
// intentionally in order to avoid extra overhead when allocating an
// array of cells.
struct cell_style_aa
{
//-----------------------------------------------------------cell_style_aa
// A pixel cell. There're no constructors defined and it was done
// intentionally in order to avoid extra overhead when allocating an
// array of cells.
struct cell_style_aa
{
int x;
int y;
int cover;
@ -67,21 +66,19 @@ namespace agg
{
return (ex - x) | (ey - y) | (left - c.left) | (right - c.right);
}
};
};
//===========================================================layer_order_e
enum layer_order_e
{
//===========================================================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
{
//==================================================rasterizer_compound_aa
template<class Clip = rasterizer_sl_clip_int>
class rasterizer_compound_aa
{
struct style_info
{
unsigned start_cell;
@ -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() :
m_outline(),
m_clipper(),
m_filling_rule(fill_non_zero),
m_layer_order(layer_direct),
m_styles(), // Active Styles
m_ast(), // Active Style Table (unique values)
m_asm(), // Active Style Mask
m_cells(),
m_cover_buf(),
m_master_alpha(),
m_min_style(0x7FFFFFFF),
m_max_style(-0x7FFFFFFF),
m_start_x(0),
m_start_y(0),
m_scan_y(0x7FFFFFFF),
m_sl_start(0),
m_sl_len(0)
rasterizer_compound_aa()
: m_outline()
, m_clipper()
, m_filling_rule(fill_non_zero)
, m_layer_order(layer_direct)
, m_styles()
, // Active Styles
m_ast()
, // Active Style Table (unique values)
m_asm()
, // Active Style Mask
m_cells()
, m_cover_buf()
, m_master_alpha()
, m_min_style(0x7FFFFFFF)
, m_max_style(-0x7FFFFFFF)
, m_start_x(0)
, m_start_y(0)
, m_scan_y(0x7FFFFFFF)
, m_sl_start(0)
, m_sl_len(0)
{}
//--------------------------------------------------------------------
@ -150,21 +149,21 @@ namespace agg
//-------------------------------------------------------------------
template<class VertexSource>
void add_path(VertexSource& vs, unsigned path_id=0)
void add_path(VertexSource& vs, unsigned path_id = 0)
{
double x;
double y;
unsigned cmd;
vs.rewind(path_id);
if(m_outline.sorted()) reset();
while(!is_stop(cmd = vs.vertex(&x, &y)))
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(); }
@ -190,33 +189,37 @@ 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(m_filling_rule == fill_even_odd)
int cover = area >> (poly_subpixel_shift * 2 + 1 - aa_shift);
if (cover < 0)
cover = -cover;
if (m_filling_rule == fill_even_odd)
{
cover &= aa_mask2;
if(cover > aa_scale)
if (cover > aa_scale)
{
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();
unsigned master_alpha = aa_mask;
if(style_idx < 0)
if (style_idx < 0)
{
style_idx = 0;
}
@ -232,7 +235,7 @@ namespace agg
cell_info* cell = &m_cells[st.start_cell];
int cover = 0;
while(num_cells--)
while (num_cells--)
{
unsigned alpha;
int x = cell->x;
@ -242,26 +245,25 @@ namespace agg
++cell;
if(area)
if (area)
{
alpha = calculate_alpha((cover << (poly_subpixel_shift + 1)) - area,
master_alpha);
alpha = calculate_alpha((cover << (poly_subpixel_shift + 1)) - area, master_alpha);
sl.add_cell(x, alpha);
x++;
}
if(num_cells && cell->x > x)
if (num_cells && cell->x > x)
{
alpha = calculate_alpha(cover << (poly_subpixel_shift + 1),
master_alpha);
if(alpha)
alpha = calculate_alpha(cover << (poly_subpixel_shift + 1), master_alpha);
if (alpha)
{
sl.add_span(x, cell->x - x, alpha);
}
}
}
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>&
operator = (const rasterizer_compound_aa<Clip>&);
const rasterizer_compound_aa<Clip>& operator=(const rasterizer_compound_aa<Clip>&);
private:
rasterizer_cells_aa<cell_style_aa> m_outline;
@ -295,172 +296,156 @@ namespace agg
int m_scan_y;
int m_sl_start;
unsigned m_sl_len;
};
};
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::reset()
{
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::reset()
{
m_outline.reset();
m_min_style = 0x7FFFFFFF;
m_max_style = -0x7FFFFFFF;
m_scan_y = 0x7FFFFFFF;
m_sl_start = 0;
m_sl_len = 0;
}
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::filling_rule(filling_rule_e filling_rule)
{
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::filling_rule(filling_rule_e filling_rule)
{
m_filling_rule = filling_rule;
}
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::layer_order(layer_order_e order)
{
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::layer_order(layer_order_e order)
{
m_layer_order = order;
}
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::clip_box(double x1, double y1,
double x2, double y2)
{
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::clip_box(double x1, double y1, double x2, double y2)
{
reset();
m_clipper.clip_box(conv_type::upscale(x1), conv_type::upscale(y1),
conv_type::upscale(x2), conv_type::upscale(y2));
}
m_clipper.clip_box(conv_type::upscale(x1), conv_type::upscale(y1), conv_type::upscale(x2), conv_type::upscale(y2));
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::reset_clipping()
{
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::reset_clipping()
{
reset();
m_clipper.reset_clipping();
}
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::styles(int left, int right)
{
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::styles(int left, int right)
{
cell_style_aa cell;
cell.initial();
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_max_style) 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;
}
if (left >= 0 && left < m_min_style)
m_min_style = left;
if (left >= 0 && left > m_max_style)
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();
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>::move_to(int x, int y)
{
if (m_outline.sorted())
reset();
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,
conv_type::downscale(x),
conv_type::downscale(y));
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::line_to(int x, int y)
{
m_clipper.line_to(m_outline, 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();
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>::move_to_d(double x, double y)
{
if (m_outline.sorted())
reset();
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,
conv_type::upscale(x),
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, conv_type::upscale(x), conv_type::upscale(y));
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::add_vertex(double x, double y, unsigned cmd)
{
if(is_move_to(cmd))
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::add_vertex(double x, double y, unsigned cmd)
{
if (is_move_to(cmd))
{
move_to_d(x, y);
}
else
if(is_vertex(cmd))
else if (is_vertex(cmd))
{
line_to_d(x, y);
}
else
if(is_close(cmd))
else if (is_close(cmd))
{
m_clipper.line_to(m_outline, m_start_x, m_start_y);
}
}
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::edge(int x1, int y1, int x2, int y2)
{
if(m_outline.sorted()) reset();
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::edge(int x1, int y1, int x2, int y2)
{
if (m_outline.sorted())
reset();
m_clipper.move_to(conv_type::downscale(x1), conv_type::downscale(y1));
m_clipper.line_to(m_outline,
conv_type::downscale(x2),
conv_type::downscale(y2));
}
m_clipper.line_to(m_outline, conv_type::downscale(x2), conv_type::downscale(y2));
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::edge_d(double x1, double y1,
double x2, double y2)
{
if(m_outline.sorted()) reset();
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::edge_d(double x1, double y1, double x2, double y2)
{
if (m_outline.sorted())
reset();
m_clipper.move_to(conv_type::upscale(x1), conv_type::upscale(y1));
m_clipper.line_to(m_outline,
conv_type::upscale(x2),
conv_type::upscale(y2));
}
m_clipper.line_to(m_outline, conv_type::upscale(x2), conv_type::upscale(y2));
}
//------------------------------------------------------------------------
template<class Clip>
AGG_INLINE void rasterizer_compound_aa<Clip>::sort()
{
//------------------------------------------------------------------------
template<class Clip>
AGG_INLINE void rasterizer_compound_aa<Clip>::sort()
{
m_outline.sort_cells();
}
}
//------------------------------------------------------------------------
template<class Clip>
AGG_INLINE bool rasterizer_compound_aa<Clip>::rewind_scanlines()
{
//------------------------------------------------------------------------
template<class Clip>
AGG_INLINE bool rasterizer_compound_aa<Clip>::rewind_scanlines()
{
m_outline.sort_cells();
if(m_outline.total_cells() == 0)
if (m_outline.total_cells() == 0)
{
return false;
}
if(m_max_style < m_min_style)
if (m_max_style < m_min_style)
{
return false;
}
@ -468,20 +453,22 @@ namespace agg
m_styles.allocate(m_max_style - m_min_style + 2, 128);
allocate_master_alpha();
return true;
}
}
//------------------------------------------------------------------------
template<class Clip>
AGG_INLINE void rasterizer_compound_aa<Clip>::add_style(int style_id)
{
if(style_id < 0) style_id = 0;
else style_id -= m_min_style - 1;
//------------------------------------------------------------------------
template<class Clip>
AGG_INLINE void rasterizer_compound_aa<Clip>::add_style(int style_id)
{
if (style_id < 0)
style_id = 0;
else
style_id -= m_min_style - 1;
unsigned nbyte = style_id >> 3;
unsigned mask = 1 << (style_id & 7);
style_info* style = &m_styles[style_id];
if((m_asm[nbyte] & mask) == 0)
if ((m_asm[nbyte] & mask) == 0)
{
m_ast.add(style_id);
m_asm[nbyte] |= mask;
@ -490,16 +477,17 @@ namespace agg
style->last_x = -0x7FFFFFFF;
}
++style->start_cell;
}
}
//------------------------------------------------------------------------
// Returns the number of styles
template<class Clip>
unsigned rasterizer_compound_aa<Clip>::sweep_styles()
//------------------------------------------------------------------------
// Returns the number of styles
template<class Clip>
unsigned rasterizer_compound_aa<Clip>::sweep_styles()
{
for (;;)
{
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;
@ -513,7 +501,7 @@ namespace agg
m_asm.allocate((num_styles + 7) >> 3, 8);
m_asm.zero();
if(num_cells)
if (num_cells)
{
// Pre-add zero (for no-fill style, that is, -1).
// We need that to ensure that the "-1 style" would go first.
@ -525,8 +513,8 @@ namespace agg
style->last_x = -0x7FFFFFFF;
m_sl_start = cells[0]->x;
m_sl_len = cells[num_cells-1]->x - m_sl_start + 1;
while(num_cells--)
m_sl_len = cells[num_cells - 1]->x - m_sl_start + 1;
while (num_cells--)
{
curr_cell = *cells++;
add_style(curr_cell->left);
@ -536,7 +524,7 @@ namespace agg
// Convert the Y-histogram into the array of starting indexes
unsigned i;
unsigned start_cell = 0;
for(i = 0; i < m_ast.size(); i++)
for (i = 0; i < m_ast.size(); i++)
{
style_info& st = m_styles[m_ast[i]];
unsigned v = st.start_cell;
@ -547,14 +535,13 @@ namespace agg
cells = m_outline.scanline_cells(m_scan_y);
num_cells = m_outline.scanline_num_cells(m_scan_y);
while(num_cells--)
while (num_cells--)
{
curr_cell = *cells++;
style_id = (curr_cell->left < 0) ? 0 :
curr_cell->left - m_min_style + 1;
style_id = (curr_cell->left < 0) ? 0 : curr_cell->left - m_min_style + 1;
style = &m_styles[style_id];
if(curr_cell->x == style->last_x)
if (curr_cell->x == style->last_x)
{
cell = &m_cells[style->start_cell + style->num_cells - 1];
cell->area += curr_cell->area;
@ -570,11 +557,10 @@ namespace agg
style->num_cells++;
}
style_id = (curr_cell->right < 0) ? 0 :
curr_cell->right - m_min_style + 1;
style_id = (curr_cell->right < 0) ? 0 : curr_cell->right - m_min_style + 1;
style = &m_styles[style_id];
if(curr_cell->x == style->last_x)
if (curr_cell->x == style->last_x)
{
cell = &m_cells[style->start_cell + style->num_cells - 1];
cell->area -= curr_cell->area;
@ -591,44 +577,46 @@ namespace agg
}
}
}
if(m_ast.size() > 1) break;
if (m_ast.size() > 1)
break;
++m_scan_y;
}
++m_scan_y;
if(m_layer_order != layer_unsorted)
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);
else quick_sort(ra, unsigned_less);
range_adaptor<pod_vector<unsigned>> ra(m_ast, 1, m_ast.size() - 1);
if (m_layer_order == layer_direct)
quick_sort(ra, unsigned_greater);
else
quick_sort(ra, unsigned_less);
}
return m_ast.size() - 1;
}
}
//------------------------------------------------------------------------
// Returns style ID depending of the existing style index
template<class Clip>
AGG_INLINE
unsigned rasterizer_compound_aa<Clip>::style(unsigned style_idx) const
{
//------------------------------------------------------------------------
// Returns style ID depending of the existing style index
template<class Clip>
AGG_INLINE unsigned rasterizer_compound_aa<Clip>::style(unsigned style_idx) const
{
return m_ast[style_idx + 1] + m_min_style - 1;
}
}
//------------------------------------------------------------------------
template<class Clip>
AGG_INLINE bool rasterizer_compound_aa<Clip>::navigate_scanline(int y)
{
//------------------------------------------------------------------------
template<class Clip>
AGG_INLINE bool rasterizer_compound_aa<Clip>::navigate_scanline(int y)
{
m_outline.sort_cells();
if(m_outline.total_cells() == 0)
if (m_outline.total_cells() == 0)
{
return false;
}
if(m_max_style < m_min_style)
if (m_max_style < m_min_style)
{
return false;
}
if(y < m_outline.min_y() || y > m_outline.max_y())
if (y < m_outline.min_y() || y > m_outline.max_y())
{
return false;
}
@ -636,19 +624,19 @@ namespace agg
m_styles.allocate(m_max_style - m_min_style + 2, 128);
allocate_master_alpha();
return true;
}
}
//------------------------------------------------------------------------
template<class Clip>
bool rasterizer_compound_aa<Clip>::hit_test(int tx, int ty)
{
if(!navigate_scanline(ty))
//------------------------------------------------------------------------
template<class Clip>
bool rasterizer_compound_aa<Clip>::hit_test(int tx, int ty)
{
if (!navigate_scanline(ty))
{
return false;
}
unsigned num_styles = sweep_styles();
if(num_styles <= 0)
if (num_styles <= 0)
{
return false;
}
@ -656,43 +644,40 @@ namespace agg
scanline_hit_test sl(tx);
sweep_scanline(sl, -1);
return sl.hit();
}
}
//------------------------------------------------------------------------
template<class Clip>
cover_type* rasterizer_compound_aa<Clip>::allocate_cover_buffer(unsigned len)
{
//------------------------------------------------------------------------
template<class Clip>
cover_type* rasterizer_compound_aa<Clip>::allocate_cover_buffer(unsigned len)
{
m_cover_buf.allocate(len, 256);
return &m_cover_buf[0];
}
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::allocate_master_alpha()
{
while((int)m_master_alpha.size() <= m_max_style)
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::allocate_master_alpha()
{
while ((int)m_master_alpha.size() <= m_max_style)
{
m_master_alpha.add(aa_mask);
}
}
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::master_alpha(int style, double alpha)
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::master_alpha(int style, double alpha)
{
if (style >= 0)
{
if(style >= 0)
{
while((int)m_master_alpha.size() <= style)
while ((int)m_master_alpha.size() <= style)
{
m_master_alpha.add(aa_mask);
}
m_master_alpha[style] = uround(alpha * aa_mask);
}
}
}
} // namespace agg
#endif

65
deps/agg/include/agg_rasterizer_outline.h vendored
View file

@ -17,21 +17,20 @@
#include "agg_basics.h"
namespace agg
namespace agg {
//======================================================rasterizer_outline
template<class Renderer>
class rasterizer_outline
{
//======================================================rasterizer_outline
template<class Renderer> class rasterizer_outline
{
public:
explicit rasterizer_outline(Renderer& ren) :
m_ren(&ren),
m_start_x(0),
m_start_y(0),
m_vertices(0)
explicit rasterizer_outline(Renderer& ren)
: m_ren(&ren)
, m_start_x(0)
, m_start_y(0)
, m_vertices(0)
{}
void attach(Renderer& ren) { m_ren = &ren; }
//--------------------------------------------------------------------
void move_to(int x, int y)
{
@ -47,21 +46,15 @@ namespace agg
}
//--------------------------------------------------------------------
void move_to_d(double x, double y)
{
move_to(m_ren->coord(x), m_ren->coord(y));
}
void move_to_d(double x, double y) { move_to(m_ren->coord(x), m_ren->coord(y)); }
//--------------------------------------------------------------------
void line_to_d(double x, double y)
{
line_to(m_ren->coord(x), m_ren->coord(y));
}
void line_to_d(double x, double y) { line_to(m_ren->coord(x), m_ren->coord(y)); }
//--------------------------------------------------------------------
void close()
{
if(m_vertices > 2)
if (m_vertices > 2)
{
line_to(m_start_x, m_start_y);
}
@ -71,15 +64,16 @@ namespace agg
//--------------------------------------------------------------------
void add_vertex(double x, double y, unsigned cmd)
{
if(is_move_to(cmd))
if (is_move_to(cmd))
{
move_to_d(x, y);
}
else
{
if(is_end_poly(cmd))
if (is_end_poly(cmd))
{
if(is_closed(cmd)) close();
if (is_closed(cmd))
close();
}
else
{
@ -88,60 +82,51 @@ namespace agg
}
}
//--------------------------------------------------------------------
template<class VertexSource>
void add_path(VertexSource& vs, unsigned path_id=0)
void add_path(VertexSource& vs, unsigned path_id = 0)
{
double x;
double y;
unsigned cmd;
vs.rewind(path_id);
while(!is_stop(cmd = vs.vertex(&x, &y)))
while (!is_stop(cmd = vs.vertex(&x, &y)))
{
add_vertex(x, y, cmd);
}
}
//--------------------------------------------------------------------
template<class VertexSource, class ColorStorage, class PathId>
void render_all_paths(VertexSource& vs,
const ColorStorage& colors,
const PathId& path_id,
unsigned num_paths)
void render_all_paths(VertexSource& vs, const ColorStorage& colors, const PathId& path_id, unsigned num_paths)
{
for(unsigned i = 0; i < num_paths; i++)
for (unsigned i = 0; i < num_paths; i++)
{
m_ren->line_color(colors[i]);
add_path(vs, path_id[i]);
}
}
//--------------------------------------------------------------------
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++)
for (i = 0; i < c.num_paths(); i++)
{
m_ren->line_color(c.color(i));
add_path(c, i);
}
}
private:
Renderer* m_ren;
int m_start_x;
int m_start_y;
unsigned m_vertices;
};
}
};
} // namespace agg
#endif

299
deps/agg/include/agg_rasterizer_outline_aa.h vendored
View file

@ -19,54 +19,54 @@
#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_end(int d)
{
return d <= 0;
}
//-------------------------------------------------------------------------
inline bool cmp_dist_start(int d) { 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
// the distance between the last and the first points
struct line_aa_vertex
{
//-----------------------------------------------------------line_aa_vertex
// Vertex (x, y) with the distance to the next one. The last vertex has
// the distance between the last and the first points
struct line_aa_vertex
{
int x;
int y;
int len;
line_aa_vertex() {}
line_aa_vertex(int x_, int y_) :
x(x_),
y(y_),
len(0)
{
}
line_aa_vertex(int x_, int y_)
: x(x_)
, y(y_)
, len(0)
{}
bool operator () (const line_aa_vertex& val)
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))) >
(line_subpixel_scale + line_subpixel_scale / 2);
return (len = uround(sqrt(dx * dx + dy * dy))) > (line_subpixel_scale + line_subpixel_scale / 2);
}
};
};
//----------------------------------------------------------outline_aa_join_e
enum outline_aa_join_e
{
//----------------------------------------------------------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
outline_miter_accurate_join //-----outline_accurate_join
};
};
//=======================================================rasterizer_outline_aa
template<class Renderer, class Coord=line_coord> class rasterizer_outline_aa
{
//=======================================================rasterizer_outline_aa
template<class Renderer, class Coord = line_coord>
class rasterizer_outline_aa
{
private:
//------------------------------------------------------------------------
struct draw_vars
@ -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) :
m_ren(&ren),
m_line_join(ren.accurate_join_only() ?
outline_miter_accurate_join :
outline_round_join),
m_round_cap(false),
m_start_x(0),
m_start_y(0)
explicit rasterizer_outline_aa(Renderer& ren)
: m_ren(&ren)
, m_line_join(ren.accurate_join_only() ? outline_miter_accurate_join : outline_round_join)
, m_round_cap(false)
, 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() ?
outline_miter_accurate_join :
join;
m_line_join = m_ren->accurate_join_only() ? 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)
{
m_src_vertices.modify_last(vertex_type(m_start_x = x, m_start_y = y));
}
void move_to(int x, int y) { m_src_vertices.modify_last(vertex_type(m_start_x = x, m_start_y = y)); }
//------------------------------------------------------------------------
void line_to(int x, int y)
{
m_src_vertices.add(vertex_type(x, y));
}
void line_to(int x, int y) { m_src_vertices.add(vertex_type(x, y)); }
//------------------------------------------------------------------------
void move_to_d(double x, double y)
{
move_to(Coord::conv(x), Coord::conv(y));
}
void move_to_d(double x, double y) { move_to(Coord::conv(x), Coord::conv(y)); }
//------------------------------------------------------------------------
void line_to_d(double x, double y)
{
line_to(Coord::conv(x), Coord::conv(y));
}
void line_to_d(double x, double y) { line_to(Coord::conv(x), Coord::conv(y)); }
//------------------------------------------------------------------------
void render(bool close_polygon);
@ -139,17 +123,17 @@ namespace agg
//------------------------------------------------------------------------
void add_vertex(double x, double y, unsigned cmd)
{
if(is_move_to(cmd))
if (is_move_to(cmd))
{
render(false);
move_to_d(x, y);
}
else
{
if(is_end_poly(cmd))
if (is_end_poly(cmd))
{
render(is_closed(cmd));
if(is_closed(cmd))
if (is_closed(cmd))
{
move_to(m_start_x, m_start_y);
}
@ -163,41 +147,37 @@ namespace agg
//------------------------------------------------------------------------
template<class VertexSource>
void add_path(VertexSource& vs, unsigned path_id=0)
void add_path(VertexSource& vs, unsigned path_id = 0)
{
double x;
double y;
unsigned cmd;
vs.rewind(path_id);
while(!is_stop(cmd = vs.vertex(&x, &y)))
while (!is_stop(cmd = vs.vertex(&x, &y)))
{
add_vertex(x, y, cmd);
}
render(false);
}
//------------------------------------------------------------------------
template<class VertexSource, class ColorStorage, class PathId>
void render_all_paths(VertexSource& vs,
const ColorStorage& colors,
const PathId& path_id,
unsigned num_paths)
void render_all_paths(VertexSource& vs, const ColorStorage& colors, const PathId& path_id, unsigned num_paths)
{
for(unsigned i = 0; i < num_paths; i++)
for (unsigned i = 0; i < num_paths; i++)
{
m_ren->color(colors[i]);
add_path(vs, path_id[i]);
}
}
//------------------------------------------------------------------------
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++)
for (i = 0; i < c.num_paths(); i++)
{
m_ren->color(c.color(i));
add_path(c, 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>&);
const rasterizer_outline_aa<Renderer, Coord>& operator=(const rasterizer_outline_aa<Renderer, Coord>&);
Renderer* m_ren;
vertex_storage_type m_src_vertices;
@ -215,27 +194,18 @@ namespace agg
bool m_round_cap;
int m_start_x;
int m_start_y;
};
};
//----------------------------------------------------------------------------
template<class Renderer, class Coord>
void rasterizer_outline_aa<Renderer, Coord>::draw(draw_vars& dv,
unsigned start,
unsigned end)
{
//----------------------------------------------------------------------------
template<class Renderer, class Coord>
void rasterizer_outline_aa<Renderer, Coord>::draw(draw_vars& dv, unsigned start, unsigned end)
{
unsigned i;
const vertex_storage_type::value_type* v;
for(i = start; i < end; i++)
for (i = start; i < end; i++)
{
if(m_line_join == outline_round_join)
if (m_line_join == outline_round_join)
{
dv.xb1 = dv.curr.x1 + (dv.curr.y2 - dv.curr.y1);
dv.yb1 = dv.curr.y1 - (dv.curr.x2 - dv.curr.x1);
@ -243,17 +213,26 @@ namespace agg
dv.yb2 = dv.curr.y2 - (dv.curr.x2 - dv.curr.x1);
}
switch(dv.flags)
switch (dv.flags)
{
case 0: m_ren->line3(dv.curr, dv.xb1, dv.yb1, dv.xb2, dv.yb2); 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;
case 0:
m_ren->line3(dv.curr, dv.xb1, dv.yb1, dv.xb2, dv.yb2);
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)
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;
@ -277,7 +257,7 @@ namespace agg
dv.xb1 = dv.xb2;
dv.yb1 = dv.yb2;
switch(m_line_join)
switch (m_line_join)
{
case outline_no_join:
dv.flags = 3;
@ -285,9 +265,8 @@ namespace agg
case outline_miter_join:
dv.flags >>= 1;
dv.flags |= ((dv.curr.diagonal_quadrant() ==
dv.next.diagonal_quadrant()) << 1);
if((dv.flags & 2) == 0)
dv.flags |= ((dv.curr.diagonal_quadrant() == 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.next.diagonal_quadrant()) << 1);
dv.flags |= ((dv.curr.diagonal_quadrant() == dv.next.diagonal_quadrant()) << 1);
break;
case outline_miter_accurate_join:
@ -305,15 +283,12 @@ namespace agg
break;
}
}
}
}
//----------------------------------------------------------------------------
template<class Renderer, class Coord>
void rasterizer_outline_aa<Renderer, Coord>::render(bool close_polygon)
{
//----------------------------------------------------------------------------
template<class Renderer, class Coord>
void rasterizer_outline_aa<Renderer, Coord>::render(bool close_polygon)
{
m_src_vertices.close(close_polygon);
draw_vars dv;
const vertex_storage_type::value_type* v;
@ -323,7 +298,7 @@ namespace agg
int y2;
int lprev;
if(close_polygon && (m_src_vertices.size() >= 3))
if (close_polygon && (m_src_vertices.size() >= 3))
{
dv.idx = 2;
@ -354,7 +329,7 @@ namespace agg
dv.xb2 = 0;
dv.yb2 = 0;
switch(m_line_join)
switch (m_line_join)
{
case outline_no_join:
dv.flags = 3;
@ -362,8 +337,7 @@ namespace agg
case outline_miter_join:
case outline_round_join:
dv.flags =
(prev.diagonal_quadrant() == dv.curr.diagonal_quadrant()) |
dv.flags = (prev.diagonal_quadrant() == dv.curr.diagonal_quadrant()) |
((dv.curr.diagonal_quadrant() == dv.next.diagonal_quadrant()) << 1);
break;
@ -372,12 +346,12 @@ namespace agg
break;
}
if((dv.flags & 1) == 0 && m_line_join != outline_round_join)
if ((dv.flags & 1) == 0 && m_line_join != outline_round_join)
{
bisectrix(prev, dv.curr, &dv.xb1, &dv.yb1);
}
if((dv.flags & 2) == 0 && m_line_join != outline_round_join)
if ((dv.flags & 2) == 0 && m_line_join != outline_round_join)
{
bisectrix(dv.curr, dv.next, &dv.xb2, &dv.yb2);
}
@ -385,14 +359,13 @@ namespace agg
}
else
{
switch(m_src_vertices.size())
switch (m_src_vertices.size())
{
case 0:
case 1:
break;
case 2:
{
case 2: {
v = &m_src_vertices[0];
x1 = v->x;
y1 = v->y;
@ -401,24 +374,19 @@ namespace agg
x2 = v->x;
y2 = v->y;
line_parameters lp(x1, y1, x2, y2, lprev);
if(m_round_cap)
if (m_round_cap)
{
m_ren->semidot(cmp_dist_start, x1, y1, x1 + (y2 - y1), y1 - (x2 - x1));
}
m_ren->line3(lp,
x1 + (y2 - y1),
y1 - (x2 - x1),
x2 + (y2 - y1),
y2 - (x2 - x1));
if(m_round_cap)
m_ren->line3(lp, 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));
}
}
break;
case 3:
{
case 3: {
int x3, y3;
int lnext;
v = &m_src_vertices[0];
@ -435,40 +403,34 @@ namespace agg
line_parameters lp1(x1, y1, x2, y2, lprev);
line_parameters lp2(x2, y2, x3, y3, lnext);
if(m_round_cap)
if (m_round_cap)
{
m_ren->semidot(cmp_dist_start, x1, y1, x1 + (y2 - y1), y1 - (x2 - x1));
}
if(m_line_join == outline_round_join)
if (m_line_join == outline_round_join)
{
m_ren->line3(lp1, x1 + (y2 - y1), y1 - (x2 - x1),
x2 + (y2 - y1), y2 - (x2 - x1));
m_ren->line3(lp1, x1 + (y2 - y1), y1 - (x2 - x1), x2 + (y2 - y1), y2 - (x2 - x1));
m_ren->pie(x2, y2, x2 + (y2 - y1), y2 - (x2 - x1),
x2 + (y3 - y2), y2 - (x3 - x2));
m_ren->pie(x2, y2, x2 + (y2 - y1), y2 - (x2 - x1), x2 + (y3 - y2), y2 - (x3 - x2));
m_ren->line3(lp2, x2 + (y3 - y2), y2 - (x3 - x2),
x3 + (y3 - y2), y3 - (x3 - x2));
m_ren->line3(lp2, x2 + (y3 - y2), y2 - (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),
dv.xb1, dv.yb1);
m_ren->line3(lp1, x1 + (y2 - y1), y1 - (x2 - x1), dv.xb1, dv.yb1);
m_ren->line3(lp2, dv.xb1, dv.yb1,
x3 + (y3 - y2), y3 - (x3 - x2));
m_ren->line3(lp2, dv.xb1, dv.yb1, x3 + (y3 - y2), y3 - (x3 - x2));
}
if(m_round_cap)
if (m_round_cap)
{
m_ren->semidot(cmp_dist_end, x3, y3, x3 + (y3 - y2), y3 - (x3 - x2));
}
}
break;
default:
{
default: {
dv.idx = 3;
v = &m_src_vertices[0];
@ -498,7 +460,7 @@ namespace agg
dv.xb2 = 0;
dv.yb2 = 0;
switch(m_line_join)
switch (m_line_join)
{
case outline_no_join:
dv.flags = 3;
@ -506,8 +468,7 @@ namespace agg
case outline_miter_join:
case outline_round_join:
dv.flags =
(prev.diagonal_quadrant() == dv.curr.diagonal_quadrant()) |
dv.flags = (prev.diagonal_quadrant() == dv.curr.diagonal_quadrant()) |
((dv.curr.diagonal_quadrant() == dv.next.diagonal_quadrant()) << 1);
break;
@ -516,44 +477,42 @@ namespace agg
break;
}
if(m_round_cap)
if (m_round_cap)
{
m_ren->semidot(cmp_dist_start, x1, y1, x1 + (y2 - y1), y1 - (x2 - x1));
}
if((dv.flags & 1) == 0)
if ((dv.flags & 1) == 0)
{
if(m_line_join == outline_round_join)
if (m_line_join == outline_round_join)
{
m_ren->line3(prev, x1 + (y2 - y1), y1 - (x2 - x1),
x2 + (y2 - y1), y2 - (x2 - x1));
m_ren->pie(prev.x2, prev.y2,
x2 + (y2 - y1), y2 - (x2 - x1),
m_ren->line3(prev, x1 + (y2 - y1), y1 - (x2 - x1), x2 + (y2 - y1), y2 - (x2 - x1));
m_ren->pie(prev.x2,
prev.y2,
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),
dv.xb1, dv.yb1);
m_ren->line3(prev, x1 + (y2 - y1), y1 - (x2 - x1), dv.xb1, dv.yb1);
}
}
else
{
m_ren->line1(prev,
x1 + (y2 - y1),
y1 - (x2 - x1));
m_ren->line1(prev, x1 + (y2 - y1), y1 - (x2 - x1));
}
if((dv.flags & 2) == 0 && m_line_join != outline_round_join)
if ((dv.flags & 2) == 0 && m_line_join != outline_round_join)
{
bisectrix(dv.curr, dv.next, &dv.xb2, &dv.yb2);
}
draw(dv, 1, m_src_vertices.size() - 2);
if((dv.flags & 1) == 0)
if ((dv.flags & 1) == 0)
{
if(m_line_join == outline_round_join)
if (m_line_join == outline_round_join)
{
m_ren->line3(dv.curr,
dv.curr.x1 + (dv.curr.y2 - dv.curr.y1),
@ -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));
}
@ -574,23 +535,21 @@ namespace agg
dv.curr.x2 + (dv.curr.y2 - dv.curr.y1),
dv.curr.y2 - (dv.curr.x2 - dv.curr.x1));
}
if(m_round_cap)
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;
}
}
m_src_vertices.remove_all();
}
}
} // namespace agg
#endif

448
deps/agg/include/agg_rasterizer_scanline_aa.h vendored
View file

@ -33,17 +33,14 @@
#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
// intentionally in order to avoid extra overhead when allocating an
// array of cells.
struct cell_aa
{
//-----------------------------------------------------------------cell_aa
// A pixel cell. There're no constructors defined and it was done
// intentionally in order to avoid extra overhead when allocating an
// array of cells.
struct cell_aa
{
int x;
int y;
int cover;
@ -59,61 +56,51 @@ namespace agg
void style(const cell_aa&) {}
int not_equal(int ex, int ey, const cell_aa&) const
{
return (ex - x) | (ey - y);
}
};
int not_equal(int ex, int ey, const cell_aa&) const { 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
// integer coordinates in format 24.8, i.e. 24 bits for integer part
// and 8 bits for fractional - see poly_subpixel_shift. This class can be
// used in the following way:
//
// 1. filling_rule(filling_rule_e ft) - optional.
//
// 2. gamma() - optional.
//
// 3. reset()
//
// 4. move_to(x, y) / line_to(x, y) - make the polygon. One can create
// more than one contour, but each contour must consist of at least 3
// vertices, i.e. move_to(x1, y1); line_to(x2, y2); line_to(x3, y3);
// is the absolute minimum of vertices that define a triangle.
// The algorithm does not check either the number of vertices nor
// coincidence of their coordinates, but in the worst case it just
// won't draw anything.
// The orger of the vertices (clockwise or counterclockwise)
// is important when using the non-zero filling rule (fill_non_zero).
// In this case the vertex order of all the contours must be the same
// if you want your intersecting polygons to be without "holes".
// You actually can use different vertices order. If the contours do not
// intersect each other the order is not important anyway. If they do,
// contours with the same vertex order will be rendered without "holes"
// while the intersecting contours with different orders will have "holes".
//
// filling_rule() and gamma() can be called anytime before "sweeping".
//------------------------------------------------------------------------
template<class Clip=rasterizer_sl_clip_int> class rasterizer_scanline_aa
{
enum status
{
status_initial,
status_move_to,
status_line_to,
status_closed
};
//==================================================rasterizer_scanline_aa
// Polygon rasterizer that is used to render filled polygons with
// high-quality Anti-Aliasing. Internally, by default, the class uses
// integer coordinates in format 24.8, i.e. 24 bits for integer part
// and 8 bits for fractional - see poly_subpixel_shift. This class can be
// used in the following way:
//
// 1. filling_rule(filling_rule_e ft) - optional.
//
// 2. gamma() - optional.
//
// 3. reset()
//
// 4. move_to(x, y) / line_to(x, y) - make the polygon. One can create
// more than one contour, but each contour must consist of at least 3
// vertices, i.e. move_to(x1, y1); line_to(x2, y2); line_to(x3, y3);
// is the absolute minimum of vertices that define a triangle.
// The algorithm does not check either the number of vertices nor
// coincidence of their coordinates, but in the worst case it just
// won't draw anything.
// The orger of the vertices (clockwise or counterclockwise)
// is important when using the non-zero filling rule (fill_non_zero).
// In this case the vertex order of all the contours must be the same
// if you want your intersecting polygons to be without "holes".
// You actually can use different vertices order. If the contours do not
// intersect each other the order is not important anyway. If they do,
// contours with the same vertex order will be rendered without "holes"
// while the intersecting contours with different orders will have "holes".
//
// filling_rule() and gamma() can be called anytime before "sweeping".
//------------------------------------------------------------------------
template<class Clip = rasterizer_sl_clip_int>
class rasterizer_scanline_aa
{
enum status { status_initial, status_move_to, status_line_to, status_closed };
public:
typedef Clip clip_type;
typedef typename Clip::conv_type conv_type;
typedef typename Clip::coord_type coord_type;
enum aa_scale_e
{
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() :
m_outline(),
m_clipper(),
m_filling_rule(fill_non_zero),
m_auto_close(true),
m_start_x(0),
m_start_y(0),
m_status(status_initial)
rasterizer_scanline_aa()
: m_outline()
, m_clipper()
, m_filling_rule(fill_non_zero)
, m_auto_close(true)
, m_start_x(0)
, m_start_y(0)
, m_status(status_initial)
{
int i;
for(i = 0; i < aa_scale; i++) m_gamma[i] = i;
for (i = 0; i < aa_scale; i++)
m_gamma[i] = i;
}
//--------------------------------------------------------------------
template<class GammaF>
rasterizer_scanline_aa(const GammaF& gamma_function) :
m_outline(),
m_clipper(m_outline),
m_filling_rule(fill_non_zero),
m_auto_close(true),
m_start_x(0),
m_start_y(0),
m_status(status_initial)
rasterizer_scanline_aa(const GammaF& gamma_function)
: m_outline()
, m_clipper(m_outline)
, m_filling_rule(fill_non_zero)
, m_auto_close(true)
, m_start_x(0)
, m_start_y(0)
, m_status(status_initial)
{
gamma(gamma_function);
}
@ -157,20 +145,18 @@ 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++)
for (i = 0; i < aa_scale; i++)
{
m_gamma[i] = uround(gamma_function(double(i) / aa_mask) * aa_mask);
}
}
//--------------------------------------------------------------------
unsigned apply_gamma(unsigned cover) const
{
return m_gamma[cover];
}
unsigned apply_gamma(unsigned cover) const { return m_gamma[cover]; }
//--------------------------------------------------------------------
void move_to(int x, int y);
@ -185,15 +171,16 @@ namespace agg
//-------------------------------------------------------------------
template<class VertexSource>
void add_path(VertexSource& vs, unsigned path_id=0)
void add_path(VertexSource& vs, unsigned path_id = 0)
{
double x;
double y;
unsigned cmd;
vs.rewind(path_id);
if(m_outline.sorted()) reset();
while(!is_stop(cmd = vs.vertex(&x, &y)))
if (m_outline.sorted())
reset();
while (!is_stop(cmd = vs.vertex(&x, &y)))
{
add_vertex(x, y, cmd);
}
@ -213,33 +200,37 @@ namespace agg
//--------------------------------------------------------------------
AGG_INLINE unsigned calculate_alpha(int area) const
{
int cover = area >> (poly_subpixel_shift*2 + 1 - aa_shift);
int cover = area >> (poly_subpixel_shift * 2 + 1 - aa_shift);
if(cover < 0) cover = -cover;
if(m_filling_rule == fill_even_odd)
if (cover < 0)
cover = -cover;
if (m_filling_rule == fill_even_odd)
{
cover &= aa_mask2;
if(cover > aa_scale)
if (cover > aa_scale)
{
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(;;)
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);
unsigned cover = 0;
while(num_cells)
while (num_cells)
{
const cell_aa* cur_cell = *cells;
int x = cur_cell->x;
@ -248,36 +239,38 @@ namespace agg
cover += cur_cell->cover;
//accumulate all cells with the same X
while(--num_cells)
// accumulate all cells with the same X
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;
}
if(area)
if (area)
{
alpha = calculate_alpha((cover << (poly_subpixel_shift + 1)) - area);
if(alpha)
if (alpha)
{
sl.add_cell(x, alpha);
}
x++;
}
if(num_cells && cur_cell->x > x)
if (num_cells && cur_cell->x > x)
{
alpha = calculate_alpha(cover << (poly_subpixel_shift + 1));
if(alpha)
if (alpha)
{
sl.add_span(x, cur_cell->x - x, alpha);
}
}
}
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>&
operator = (const rasterizer_scanline_aa<Clip>&);
const rasterizer_scanline_aa<Clip>& operator=(const rasterizer_scanline_aa<Clip>&);
private:
rasterizer_cells_aa<cell_aa> m_outline;
@ -307,203 +298,180 @@ namespace agg
coord_type m_start_y;
unsigned m_status;
int m_scan_y;
};
};
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::reset()
{
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::reset()
{
m_outline.reset();
m_status = status_initial;
}
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::filling_rule(filling_rule_e filling_rule)
{
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::filling_rule(filling_rule_e filling_rule)
{
m_filling_rule = filling_rule;
}
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::clip_box(double x1, double y1,
double x2, double y2)
{
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::clip_box(double x1, double y1, double x2, double y2)
{
reset();
m_clipper.clip_box(conv_type::upscale(x1), conv_type::upscale(y1),
conv_type::upscale(x2), conv_type::upscale(y2));
}
m_clipper.clip_box(conv_type::upscale(x1), conv_type::upscale(y1), conv_type::upscale(x2), conv_type::upscale(y2));
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::reset_clipping()
{
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::reset_clipping()
{
reset();
m_clipper.reset_clipping();
}
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::close_polygon()
{
if(m_status == status_line_to)
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::close_polygon()
{
if (m_status == status_line_to)
{
m_clipper.line_to(m_outline, m_start_x, m_start_y);
m_status = status_closed;
}
}
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::move_to(int x, int y)
{
if(m_outline.sorted()) reset();
if(m_auto_close) close_polygon();
m_clipper.move_to(m_start_x = conv_type::downscale(x),
m_start_y = conv_type::downscale(y));
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::move_to(int x, int y)
{
if (m_outline.sorted())
reset();
if (m_auto_close)
close_polygon();
m_clipper.move_to(m_start_x = conv_type::downscale(x), m_start_y = conv_type::downscale(y));
m_status = status_move_to;
}
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::line_to(int x, int y)
{
m_clipper.line_to(m_outline,
conv_type::downscale(x),
conv_type::downscale(y));
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::line_to(int x, int y)
{
m_clipper.line_to(m_outline, conv_type::downscale(x), conv_type::downscale(y));
m_status = status_line_to;
}
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::move_to_d(double x, double y)
{
if(m_outline.sorted()) reset();
if(m_auto_close) close_polygon();
m_clipper.move_to(m_start_x = conv_type::upscale(x),
m_start_y = conv_type::upscale(y));
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::move_to_d(double x, double y)
{
if (m_outline.sorted())
reset();
if (m_auto_close)
close_polygon();
m_clipper.move_to(m_start_x = conv_type::upscale(x), m_start_y = conv_type::upscale(y));
m_status = status_move_to;
}
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::line_to_d(double x, double y)
{
m_clipper.line_to(m_outline,
conv_type::upscale(x),
conv_type::upscale(y));
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::line_to_d(double x, double y)
{
m_clipper.line_to(m_outline, conv_type::upscale(x), conv_type::upscale(y));
m_status = status_line_to;
}
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::add_vertex(double x, double y, unsigned cmd)
{
if(is_move_to(cmd))
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::add_vertex(double x, double y, unsigned cmd)
{
if (is_move_to(cmd))
{
move_to_d(x, y);
}
else
if(is_vertex(cmd))
else if (is_vertex(cmd))
{
line_to_d(x, y);
}
else
if(is_close(cmd))
else if (is_close(cmd))
{
close_polygon();
}
}
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::edge(int x1, int y1, int x2, int y2)
{
if(m_outline.sorted()) reset();
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::edge(int x1, int y1, int x2, int y2)
{
if (m_outline.sorted())
reset();
m_clipper.move_to(conv_type::downscale(x1), conv_type::downscale(y1));
m_clipper.line_to(m_outline,
conv_type::downscale(x2),
conv_type::downscale(y2));
m_clipper.line_to(m_outline, conv_type::downscale(x2), conv_type::downscale(y2));
m_status = status_move_to;
}
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::edge_d(double x1, double y1,
double x2, double y2)
{
if(m_outline.sorted()) reset();
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::edge_d(double x1, double y1, double x2, double y2)
{
if (m_outline.sorted())
reset();
m_clipper.move_to(conv_type::upscale(x1), conv_type::upscale(y1));
m_clipper.line_to(m_outline,
conv_type::upscale(x2),
conv_type::upscale(y2));
m_clipper.line_to(m_outline, conv_type::upscale(x2), conv_type::upscale(y2));
m_status = status_move_to;
}
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::sort()
{
if(m_auto_close) close_polygon();
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::sort()
{
if (m_auto_close)
close_polygon();
m_outline.sort_cells();
}
}
//------------------------------------------------------------------------
template<class Clip>
AGG_INLINE bool rasterizer_scanline_aa<Clip>::rewind_scanlines()
{
if(m_auto_close) close_polygon();
//------------------------------------------------------------------------
template<class Clip>
AGG_INLINE bool rasterizer_scanline_aa<Clip>::rewind_scanlines()
{
if (m_auto_close)
close_polygon();
m_outline.sort_cells();
if(m_outline.total_cells() == 0)
if (m_outline.total_cells() == 0)
{
return false;
}
m_scan_y = m_outline.min_y();
return true;
}
}
//------------------------------------------------------------------------
template<class Clip>
AGG_INLINE bool rasterizer_scanline_aa<Clip>::navigate_scanline(int y)
{
if(m_auto_close) close_polygon();
//------------------------------------------------------------------------
template<class Clip>
AGG_INLINE bool rasterizer_scanline_aa<Clip>::navigate_scanline(int y)
{
if (m_auto_close)
close_polygon();
m_outline.sort_cells();
if(m_outline.total_cells() == 0 ||
y < m_outline.min_y() ||
y > m_outline.max_y())
if (m_outline.total_cells() == 0 || y < m_outline.min_y() || y > m_outline.max_y())
{
return false;
}
m_scan_y = y;
return true;
}
}
//------------------------------------------------------------------------
template<class Clip>
bool rasterizer_scanline_aa<Clip>::hit_test(int tx, int ty)
{
if(!navigate_scanline(ty)) return false;
//------------------------------------------------------------------------
template<class Clip>
bool rasterizer_scanline_aa<Clip>::hit_test(int tx, int ty)
{
if (!navigate_scanline(ty))
return false;
scanline_hit_test sl(tx);
sweep_scanline(sl);
return sl.hit();
}
}
} // namespace agg
#endif

208
deps/agg/include/agg_rasterizer_sl_clip.h vendored
View file

@ -17,31 +17,26 @@
#include "agg_clip_liang_barsky.h"
namespace agg
{
//--------------------------------------------------------poly_max_coord_e
enum poly_max_coord_e
{
namespace agg {
//--------------------------------------------------------poly_max_coord_e
enum poly_max_coord_e {
poly_max_coord = (1 << 30) - 1 //----poly_max_coord
};
};
//------------------------------------------------------------ras_conv_int
struct ras_conv_int
{
//------------------------------------------------------------ras_conv_int
struct ras_conv_int
{
typedef int coord_type;
static AGG_INLINE int mul_div(double a, double b, double c)
{
return iround(a * b / c);
}
static AGG_INLINE int mul_div(double a, double b, double c) { return iround(a * b / c); }
static int xi(int v) { return v; }
static int yi(int v) { return v; }
static int upscale(double v) { return iround(v * static_cast<double>(poly_subpixel_scale)); }
static int downscale(int v) { return v; }
};
};
//--------------------------------------------------------ras_conv_int_sat
struct ras_conv_int_sat
{
//--------------------------------------------------------ras_conv_int_sat
struct ras_conv_int_sat
{
typedef int coord_type;
static AGG_INLINE int mul_div(double a, double b, double c)
{
@ -54,76 +49,61 @@ namespace agg
return saturation<poly_max_coord>::iround(v * static_cast<double>(poly_subpixel_scale));
}
static int downscale(int v) { return v; }
};
};
//---------------------------------------------------------ras_conv_int_3x
struct ras_conv_int_3x
{
//---------------------------------------------------------ras_conv_int_3x
struct ras_conv_int_3x
{
typedef int coord_type;
static AGG_INLINE int mul_div(double a, double b, double c)
{
return iround(a * b / c);
}
static AGG_INLINE int mul_div(double a, double b, double c) { return iround(a * b / c); }
static int xi(int v) { return v * 3; }
static int yi(int v) { return v; }
static int upscale(double v) { return iround(v * static_cast<double>(poly_subpixel_scale)); }
static int downscale(int v) { return v; }
};
};
//-----------------------------------------------------------ras_conv_dbl
struct ras_conv_dbl
{
//-----------------------------------------------------------ras_conv_dbl
struct ras_conv_dbl
{
typedef double coord_type;
static AGG_INLINE double mul_div(double a, double b, double c)
{
return a * b / c;
}
static AGG_INLINE double mul_div(double a, double b, double c) { return a * b / c; }
static int xi(double v) { return iround(v * static_cast<double>(poly_subpixel_scale)); }
static int yi(double v) { return iround(v * static_cast<double>(poly_subpixel_scale)); }
static double upscale(double v) { return v; }
static double downscale(int v) { return v / static_cast<double>(poly_subpixel_scale); }
};
};
//--------------------------------------------------------ras_conv_dbl_3x
struct ras_conv_dbl_3x
{
//--------------------------------------------------------ras_conv_dbl_3x
struct ras_conv_dbl_3x
{
typedef double coord_type;
static AGG_INLINE double mul_div(double a, double b, double c)
{
return a * b / c;
}
static AGG_INLINE double mul_div(double a, double b, double c) { return a * b / c; }
static int xi(double v) { return iround(v * static_cast<double>(poly_subpixel_scale) * 3); }
static int yi(double v) { return iround(v * static_cast<double>(poly_subpixel_scale)); }
static double upscale(double v) { return v; }
static double downscale(int v) { return v / static_cast<double>(poly_subpixel_scale); }
};
};
//------------------------------------------------------rasterizer_sl_clip
template<class Conv> class rasterizer_sl_clip
{
//------------------------------------------------------rasterizer_sl_clip
template<class Conv>
class rasterizer_sl_clip
{
public:
typedef Conv conv_type;
typedef typename Conv::coord_type coord_type;
typedef rect_base<coord_type> rect_type;
//--------------------------------------------------------------------
rasterizer_sl_clip() :
m_clip_box(0,0,0,0),
m_x1(0),
m_y1(0),
m_f1(0),
m_clipping(false)
rasterizer_sl_clip()
: m_clip_box(0, 0, 0, 0)
, m_x1(0)
, m_y1(0)
, m_f1(0)
, m_clipping(false)
{}
//--------------------------------------------------------------------
void reset_clipping()
{
m_clipping = false;
}
void reset_clipping() { m_clipping = false; }
//--------------------------------------------------------------------
void clip_box(coord_type x1, coord_type y1, coord_type x2, coord_type y2)
@ -138,27 +118,27 @@ 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,
coord_type x1, coord_type y1,
coord_type x2, coord_type y2,
unsigned f1, unsigned f2) const
AGG_INLINE void
line_clip_y(Rasterizer& ras, coord_type x1, coord_type y1, coord_type x2, coord_type y2, unsigned f1, unsigned f2)
const
{
f1 &= 10;
f2 &= 10;
if((f1 | f2) == 0)
if ((f1 | f2) == 0)
{
// Fully visible
ras.line(Conv::xi(x1), Conv::yi(y1), Conv::xi(x2), Conv::yi(y2));
}
else
{
if(f1 == f2)
if (f1 == f2)
{
// Invisible by Y
return;
@ -169,45 +149,43 @@ namespace agg
coord_type tx2 = x2;
coord_type ty2 = y2;
if(f1 & 8) // y1 < clip.y1
if (f1 & 8) // y1 < clip.y1
{
tx1 = x1 + Conv::mul_div(m_clip_box.y1-y1, x2-x1, y2-y1);
tx1 = x1 + Conv::mul_div(m_clip_box.y1 - y1, x2 - x1, y2 - y1);
ty1 = m_clip_box.y1;
}
if(f1 & 2) // y1 > clip.y2
if (f1 & 2) // y1 > clip.y2
{
tx1 = x1 + Conv::mul_div(m_clip_box.y2-y1, x2-x1, y2-y1);
tx1 = x1 + Conv::mul_div(m_clip_box.y2 - y1, x2 - x1, y2 - y1);
ty1 = m_clip_box.y2;
}
if(f2 & 8) // y2 < clip.y1
if (f2 & 8) // y2 < clip.y1
{
tx2 = x1 + Conv::mul_div(m_clip_box.y1-y1, x2-x1, y2-y1);
tx2 = x1 + Conv::mul_div(m_clip_box.y1 - y1, x2 - x1, y2 - y1);
ty2 = m_clip_box.y1;
}
if(f2 & 2) // y2 > clip.y2
if (f2 & 2) // y2 > clip.y2
{
tx2 = x1 + Conv::mul_div(m_clip_box.y2-y1, x2-x1, y2-y1);
tx2 = x1 + Conv::mul_div(m_clip_box.y2 - y1, x2 - x1, y2 - y1);
ty2 = m_clip_box.y2;
}
ras.line(Conv::xi(tx1), Conv::yi(ty1),
Conv::xi(tx2), Conv::yi(ty2));
ras.line(Conv::xi(tx1), Conv::yi(ty1), Conv::xi(tx2), Conv::yi(ty2));
}
}
public:
//--------------------------------------------------------------------
template<class Rasterizer>
void line_to(Rasterizer& ras, coord_type x2, coord_type y2)
{
if(m_clipping)
if (m_clipping)
{
unsigned f2 = clipping_flags(x2, y2, m_clip_box);
if((m_f1 & 10) == (f2 & 10) && (m_f1 & 10) != 0)
if ((m_f1 & 10) == (f2 & 10) && (m_f1 & 10) != 0)
{
// Invisible by Y
m_x1 = x2;
@ -222,21 +200,21 @@ namespace agg
coord_type y3, y4;
unsigned f3, f4;
switch(((f1 & 5) << 1) | (f2 & 5))
switch (((f1 & 5) << 1) | (f2 & 5))
{
case 0: // Visible by X
line_clip_y(ras, x1, y1, x2, y2, f1, f2);
break;
case 1: // x2 > clip.x2
y3 = y1 + Conv::mul_div(m_clip_box.x2-x1, y2-y1, x2-x1);
y3 = y1 + Conv::mul_div(m_clip_box.x2 - x1, y2 - y1, x2 - x1);
f3 = clipping_flags_y(y3, m_clip_box);
line_clip_y(ras, x1, y1, m_clip_box.x2, y3, f1, f3);
line_clip_y(ras, m_clip_box.x2, y3, m_clip_box.x2, y2, f3, f2);
break;
case 2: // x1 > clip.x2
y3 = y1 + Conv::mul_div(m_clip_box.x2-x1, y2-y1, x2-x1);
y3 = y1 + Conv::mul_div(m_clip_box.x2 - x1, y2 - y1, x2 - x1);
f3 = clipping_flags_y(y3, m_clip_box);
line_clip_y(ras, m_clip_box.x2, y1, m_clip_box.x2, y3, f1, f3);
line_clip_y(ras, m_clip_box.x2, y3, x2, y2, f3, f2);
@ -247,15 +225,15 @@ namespace agg
break;
case 4: // x2 < clip.x1
y3 = y1 + Conv::mul_div(m_clip_box.x1-x1, y2-y1, x2-x1);
y3 = y1 + Conv::mul_div(m_clip_box.x1 - x1, y2 - y1, x2 - x1);
f3 = clipping_flags_y(y3, m_clip_box);
line_clip_y(ras, x1, y1, m_clip_box.x1, y3, f1, f3);
line_clip_y(ras, m_clip_box.x1, y3, m_clip_box.x1, y2, f3, f2);
break;
case 6: // x1 > clip.x2 && x2 < clip.x1
y3 = y1 + Conv::mul_div(m_clip_box.x2-x1, y2-y1, x2-x1);
y4 = y1 + Conv::mul_div(m_clip_box.x1-x1, y2-y1, x2-x1);
y3 = y1 + Conv::mul_div(m_clip_box.x2 - x1, y2 - y1, x2 - x1);
y4 = y1 + Conv::mul_div(m_clip_box.x1 - x1, y2 - y1, x2 - x1);
f3 = clipping_flags_y(y3, m_clip_box);
f4 = clipping_flags_y(y4, m_clip_box);
line_clip_y(ras, m_clip_box.x2, y1, m_clip_box.x2, y3, f1, f3);
@ -264,15 +242,15 @@ namespace agg
break;
case 8: // x1 < clip.x1
y3 = y1 + Conv::mul_div(m_clip_box.x1-x1, y2-y1, x2-x1);
y3 = y1 + Conv::mul_div(m_clip_box.x1 - x1, y2 - y1, x2 - x1);
f3 = clipping_flags_y(y3, m_clip_box);
line_clip_y(ras, m_clip_box.x1, y1, m_clip_box.x1, y3, f1, f3);
line_clip_y(ras, m_clip_box.x1, y3, x2, y2, f3, f2);
break;
case 9: // x1 < clip.x1 && x2 > clip.x2
y3 = y1 + Conv::mul_div(m_clip_box.x1-x1, y2-y1, x2-x1);
y4 = y1 + Conv::mul_div(m_clip_box.x2-x1, y2-y1, x2-x1);
y3 = y1 + Conv::mul_div(m_clip_box.x1 - x1, y2 - y1, x2 - x1);
y4 = y1 + Conv::mul_div(m_clip_box.x2 - x1, y2 - y1, x2 - x1);
f3 = clipping_flags_y(y3, m_clip_box);
f4 = clipping_flags_y(y4, m_clip_box);
line_clip_y(ras, m_clip_box.x1, y1, m_clip_box.x1, y3, f1, f3);
@ -288,37 +266,39 @@ namespace agg
}
else
{
ras.line(Conv::xi(m_x1), Conv::yi(m_y1),
Conv::xi(x2), Conv::yi(y2));
ras.line(Conv::xi(m_x1), Conv::yi(m_y1), Conv::xi(x2), Conv::yi(y2));
}
m_x1 = x2;
m_y1 = y2;
}
private:
rect_type m_clip_box;
coord_type m_x1;
coord_type m_y1;
unsigned m_f1;
bool m_clipping;
};
};
//---------------------------------------------------rasterizer_sl_no_clip
class rasterizer_sl_no_clip
{
//---------------------------------------------------rasterizer_sl_no_clip
class rasterizer_sl_no_clip
{
public:
typedef ras_conv_int conv_type;
typedef int coord_type;
rasterizer_sl_no_clip() : m_x1(0), m_y1(0) {}
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)
@ -330,22 +310,20 @@ namespace agg
private:
int m_x1, m_y1;
};
};
// -----rasterizer_sl_clip_int
// -----rasterizer_sl_clip_int_sat
// -----rasterizer_sl_clip_int_3x
// -----rasterizer_sl_clip_dbl
// -----rasterizer_sl_clip_dbl_3x
//------------------------------------------------------------------------
typedef rasterizer_sl_clip<ras_conv_int> rasterizer_sl_clip_int;
typedef rasterizer_sl_clip<ras_conv_int_sat> rasterizer_sl_clip_int_sat;
typedef rasterizer_sl_clip<ras_conv_int_3x> rasterizer_sl_clip_int_3x;
typedef rasterizer_sl_clip<ras_conv_dbl> rasterizer_sl_clip_dbl;
typedef rasterizer_sl_clip<ras_conv_dbl_3x> rasterizer_sl_clip_dbl_3x;
// -----rasterizer_sl_clip_int
// -----rasterizer_sl_clip_int_sat
// -----rasterizer_sl_clip_int_3x
// -----rasterizer_sl_clip_dbl
// -----rasterizer_sl_clip_dbl_3x
//------------------------------------------------------------------------
typedef rasterizer_sl_clip<ras_conv_int> rasterizer_sl_clip_int;
typedef rasterizer_sl_clip<ras_conv_int_sat> rasterizer_sl_clip_int_sat;
typedef rasterizer_sl_clip<ras_conv_int_3x> rasterizer_sl_clip_int_3x;
typedef rasterizer_sl_clip<ras_conv_dbl> rasterizer_sl_clip_dbl;
typedef rasterizer_sl_clip<ras_conv_dbl_3x> rasterizer_sl_clip_dbl_3x;
}
} // namespace agg
#endif

445
deps/agg/include/agg_renderer_base.h vendored
View file

@ -23,12 +23,12 @@
#include "agg_basics.h"
#include "agg_rendering_buffer.h"
namespace agg
{
namespace agg {
//-----------------------------------------------------------renderer_base
template<class PixelFormat> class renderer_base
{
//-----------------------------------------------------------renderer_base
template<class PixelFormat>
class renderer_base
{
public:
typedef PixelFormat pixfmt_type;
typedef typename pixfmt_type::color_type color_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) {}
explicit renderer_base(pixfmt_type& ren) :
m_ren(&ren),
m_clip_box(0, 0, ren.width() - 1, ren.height() - 1)
renderer_base()
: m_ren(0)
, m_clip_box(1, 1, 0, 0)
{}
explicit renderer_base(pixfmt_type& ren)
: m_ren(&ren)
, m_clip_box(0, 0, ren.width() - 1, ren.height() - 1)
{}
void attach(pixfmt_type& ren)
{
@ -60,7 +63,7 @@ namespace agg
{
rect_i cb(x1, y1, x2, y2);
cb.normalize();
if(cb.clip(rect_i(0, 0, width() - 1, height() - 1)))
if (cb.clip(rect_i(0, 0, width() - 1, height() - 1)))
{
m_clip_box = cb;
return true;
@ -75,7 +78,7 @@ namespace agg
//--------------------------------------------------------------------
void reset_clipping(bool visibility)
{
if(visibility)
if (visibility)
{
m_clip_box.x1 = 0;
m_clip_box.y1 = 0;
@ -103,8 +106,7 @@ namespace agg
//--------------------------------------------------------------------
bool inbox(int x, int y) const
{
return x >= m_clip_box.x1 && y >= m_clip_box.y1 &&
x <= m_clip_box.x2 && y <= m_clip_box.y2;
return x >= m_clip_box.x1 && y >= m_clip_box.y1 && x <= m_clip_box.x2 && y <= m_clip_box.y2;
}
//--------------------------------------------------------------------
@ -125,20 +127,19 @@ namespace agg
void clear(const color_type& c)
{
unsigned y;
if(width())
if (width())
{
for(y = 0; y < height(); y++)
for (y = 0; y < height(); y++)
{
m_ren->copy_hline(0, y, width(), c);
}
}
}
//--------------------------------------------------------------------
void copy_pixel(int x, int y, const color_type& c)
{
if(inbox(x, y))
if (inbox(x, y))
{
m_ren->copy_pixel(x, y, c);
}
@ -147,31 +148,37 @@ namespace agg
//--------------------------------------------------------------------
void blend_pixel(int x, int y, const color_type& c, cover_type cover)
{
if(inbox(x, y))
if (inbox(x, y))
{
m_ren->blend_pixel(x, y, c, cover);
}
}
//--------------------------------------------------------------------
color_type pixel(int x, int y) const
{
return inbox(x, y) ?
m_ren->pixel(x, y) :
color_type::no_color();
}
color_type pixel(int x, int y) const { return inbox(x, y) ? m_ren->pixel(x, y) : color_type::no_color(); }
//--------------------------------------------------------------------
void copy_hline(int x1, int y, int x2, const color_type& c)
{
if(x1 > x2) { int t = x2; x2 = x1; x1 = t; }
if(y > ymax()) return;
if(y < ymin()) return;
if(x1 > xmax()) return;
if(x2 < xmin()) return;
if (x1 > x2)
{
int t = x2;
x2 = x1;
x1 = t;
}
if (y > ymax())
return;
if (y < ymin())
return;
if (x1 > xmax())
return;
if (x2 < xmin())
return;
if(x1 < xmin()) x1 = xmin();
if(x2 > xmax()) x2 = xmax();
if (x1 < xmin())
x1 = xmin();
if (x2 > xmax())
x2 = xmax();
m_ren->copy_hline(x1, y, x2 - x1 + 1, c);
}
@ -179,60 +186,90 @@ 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(x > xmax()) return;
if(x < xmin()) return;
if(y1 > ymax()) return;
if(y2 < ymin()) return;
if (y1 > y2)
{
int t = y2;
y2 = y1;
y1 = t;
}
if (x > xmax())
return;
if (x < xmin())
return;
if (y1 > ymax())
return;
if (y2 < ymin())
return;
if(y1 < ymin()) y1 = ymin();
if(y2 > ymax()) y2 = ymax();
if (y1 < ymin())
y1 = ymin();
if (y2 > ymax())
y2 = ymax();
m_ren->copy_vline(x, y1, y2 - y1 + 1, c);
}
//--------------------------------------------------------------------
void blend_hline(int x1, int y, int x2,
const color_type& c, cover_type cover)
void blend_hline(int x1, int y, int x2, const color_type& c, cover_type cover)
{
if(x1 > x2) { int t = x2; x2 = x1; x1 = t; }
if(y > ymax()) return;
if(y < ymin()) return;
if(x1 > xmax()) return;
if(x2 < xmin()) return;
if (x1 > x2)
{
int t = x2;
x2 = x1;
x1 = t;
}
if (y > ymax())
return;
if (y < ymin())
return;
if (x1 > xmax())
return;
if (x2 < xmin())
return;
if(x1 < xmin()) x1 = xmin();
if(x2 > xmax()) x2 = xmax();
if (x1 < xmin())
x1 = xmin();
if (x2 > xmax())
x2 = xmax();
m_ren->blend_hline(x1, y, x2 - x1 + 1, c, cover);
}
//--------------------------------------------------------------------
void blend_vline(int x, int y1, int y2,
const color_type& c, cover_type cover)
void blend_vline(int x, int y1, int y2, const color_type& c, cover_type cover)
{
if(y1 > y2) { int t = y2; y2 = y1; y1 = t; }
if(x > xmax()) return;
if(x < xmin()) return;
if(y1 > ymax()) return;
if(y2 < ymin()) return;
if (y1 > y2)
{
int t = y2;
y2 = y1;
y1 = t;
}
if (x > xmax())
return;
if (x < xmin())
return;
if (y1 > ymax())
return;
if (y2 < ymin())
return;
if(y1 < ymin()) y1 = ymin();
if(y2 > ymax()) y2 = ymax();
if (y1 < ymin())
y1 = ymin();
if (y2 > ymax())
y2 = ymax();
m_ren->blend_vline(x, y1, y2 - y1 + 1, c, cover);
}
//--------------------------------------------------------------------
void copy_bar(int x1, int y1, int x2, int y2, const color_type& c)
{
rect_i rc(x1, y1, x2, y2);
rc.normalize();
if(rc.clip(clip_box()))
if (rc.clip(clip_box()))
{
int y;
for(y = rc.y1; y <= rc.y2; y++)
for (y = rc.y1; y <= rc.y2; y++)
{
m_ren->copy_hline(rc.x1, y, unsigned(rc.x2 - rc.x1 + 1), c);
}
@ -240,193 +277,218 @@ namespace agg
}
//--------------------------------------------------------------------
void blend_bar(int x1, int y1, int x2, int y2,
const color_type& c, cover_type cover)
void blend_bar(int x1, int y1, int x2, int y2, const color_type& c, cover_type cover)
{
rect_i rc(x1, y1, x2, y2);
rc.normalize();
if(rc.clip(clip_box()))
if (rc.clip(clip_box()))
{
int y;
for(y = rc.y1; y <= rc.y2; y++)
for (y = rc.y1; y <= rc.y2; y++)
{
m_ren->blend_hline(rc.x1,
y,
unsigned(rc.x2 - rc.x1 + 1),
c,
cover);
m_ren->blend_hline(rc.x1, y, unsigned(rc.x2 - rc.x1 + 1), c, cover);
}
}
}
//--------------------------------------------------------------------
void blend_solid_hspan(int x, int y, int len,
const color_type& c,
const cover_type* covers)
void blend_solid_hspan(int x, int y, int len, const color_type& c, const cover_type* covers)
{
if(y > ymax()) return;
if(y < ymin()) return;
if (y > ymax())
return;
if (y < ymin())
return;
if(x < xmin())
if (x < xmin())
{
len -= xmin() - x;
if(len <= 0) return;
if (len <= 0)
return;
covers += xmin() - x;
x = xmin();
}
if(x + len > xmax())
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,
const color_type& c,
const cover_type* covers)
void blend_solid_vspan(int x, int y, int len, const color_type& c, const cover_type* covers)
{
if(x > xmax()) return;
if(x < xmin()) return;
if (x > xmax())
return;
if (x < xmin())
return;
if(y < ymin())
if (y < ymin())
{
len -= ymin() - y;
if(len <= 0) return;
if (len <= 0)
return;
covers += ymin() - y;
y = ymin();
}
if(y + len > ymax())
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 < ymin()) return;
if (y > ymax())
return;
if (y < ymin())
return;
if(x < xmin())
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())
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 < xmin()) return;
if (x > xmax())
return;
if (x < xmin())
return;
if(y < ymin())
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())
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 < ymin()) return;
if (y > ymax())
return;
if (y < ymin())
return;
if(x < xmin())
if (x < xmin())
{
int d = xmin() - x;
len -= d;
if(len <= 0) return;
if(covers) covers += d;
if (len <= 0)
return;
if (covers)
covers += d;
colors += d;
x = xmin();
}
if(x + len > xmax())
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 < ymin()) return;
if (y > ymax())
return;
if (y < ymin())
return;
if(x < xmin())
if (x < xmin())
{
int d = xmin() - x;
len -= d;
if(len <= 0) return;
if(covers) covers += d;
if (len <= 0)
return;
if (covers)
covers += d;
colors += d;
x = xmin();
}
if(x + len > xmax())
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 < xmin()) return;
if (x > xmax())
return;
if (x < xmin())
return;
if(y < ymin())
if (y < ymin())
{
int d = ymin() - y;
len -= d;
if(len <= 0) return;
if(covers) covers += d;
if (len <= 0)
return;
if (covers)
covers += d;
colors += d;
y = ymin();
}
if(y + len > ymax())
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);
}
@ -434,56 +496,59 @@ namespace agg
//--------------------------------------------------------------------
rect_i clip_rect_area(rect_i& dst, rect_i& src, int wsrc, int hsrc) const
{
rect_i rc(0,0,0,0);
rect_i rc(0, 0, 0, 0);
rect_i cb = clip_box();
++cb.x2;
++cb.y2;
if(src.x1 < 0)
if (src.x1 < 0)
{
dst.x1 -= src.x1;
src.x1 = 0;
}
if(src.y1 < 0)
if (src.y1 < 0)
{
dst.y1 -= src.y1;
src.y1 = 0;
}
if(src.x2 > wsrc) src.x2 = wsrc;
if(src.y2 > hsrc) src.y2 = hsrc;
if (src.x2 > wsrc)
src.x2 = wsrc;
if (src.y2 > hsrc)
src.y2 = hsrc;
if(dst.x1 < cb.x1)
if (dst.x1 < cb.x1)
{
src.x1 += cb.x1 - dst.x1;
dst.x1 = cb.x1;
}
if(dst.y1 < cb.y1)
if (dst.y1 < cb.y1)
{
src.y1 += cb.y1 - dst.y1;
dst.y1 = cb.y1;
}
if(dst.x2 > cb.x2) dst.x2 = cb.x2;
if(dst.y2 > cb.y2) dst.y2 = cb.y2;
if (dst.x2 > cb.x2)
dst.x2 = cb.x2;
if (dst.y2 > cb.y2)
dst.y2 = cb.y2;
rc.x2 = dst.x2 - dst.x1;
rc.y2 = dst.y2 - dst.y1;
if(rc.x2 > src.x2 - src.x1) rc.x2 = src.x2 - src.x1;
if(rc.y2 > src.y2 - src.y1) rc.y2 = src.y2 - src.y1;
if (rc.x2 > src.x2 - src.x1)
rc.x2 = src.x2 - src.x1;
if (rc.y2 > src.y2 - src.y1)
rc.y2 = src.y2 - src.y1;
return rc;
}
//--------------------------------------------------------------------
template<class RenBuf>
void copy_from(const RenBuf& src,
const rect_i* rect_src_ptr = 0,
int dx = 0,
int dy = 0)
void copy_from(const RenBuf& src, const rect_i* rect_src_ptr = 0, int dx = 0, int dy = 0)
{
rect_i rsrc(0, 0, src.width(), src.height());
if(rect_src_ptr)
if (rect_src_ptr)
{
rsrc.x1 = rect_src_ptr->x1;
rsrc.y1 = rect_src_ptr->y1;
@ -492,28 +557,25 @@ namespace agg
}
// Version with xdst, ydst (absolute positioning)
//rect_i rdst(xdst, ydst, xdst + rsrc.x2 - rsrc.x1, ydst + rsrc.y2 - rsrc.y1);
// rect_i rdst(xdst, ydst, xdst + rsrc.x2 - rsrc.x1, ydst + rsrc.y2 - rsrc.y1);
// Version with dx, dy (relative positioning)
rect_i rdst(rsrc.x1 + dx, rsrc.y1 + dy, rsrc.x2 + dx, rsrc.y2 + dy);
rect_i rc = clip_rect_area(rdst, rsrc, src.width(), src.height());
if(rc.x2 > 0)
if (rc.x2 > 0)
{
int incy = 1;
if(rdst.y1 > rsrc.y1)
if (rdst.y1 > rsrc.y1)
{
rsrc.y1 += rc.y2 - 1;
rdst.y1 += rc.y2 - 1;
incy = -1;
}
while(rc.y2 > 0)
while (rc.y2 > 0)
{
m_ren->copy_from(src,
rdst.x1, rdst.y1,
rsrc.x1, rsrc.y1,
rc.x2);
m_ren->copy_from(src, rdst.x1, rdst.y1, rsrc.x1, rsrc.y1, rc.x2);
rdst.y1 += incy;
rsrc.y1 += incy;
--rc.y2;
@ -530,7 +592,7 @@ namespace agg
cover_type cover = agg::cover_full)
{
rect_i rsrc(0, 0, src.width(), src.height());
if(rect_src_ptr)
if (rect_src_ptr)
{
rsrc.x1 = rect_src_ptr->x1;
rsrc.y1 = rect_src_ptr->y1;
@ -539,48 +601,44 @@ namespace agg
}
// Version with xdst, ydst (absolute positioning)
//rect_i rdst(xdst, ydst, xdst + rsrc.x2 - rsrc.x1, ydst + rsrc.y2 - rsrc.y1);
// rect_i rdst(xdst, ydst, xdst + rsrc.x2 - rsrc.x1, ydst + rsrc.y2 - rsrc.y1);
// Version with dx, dy (relative positioning)
rect_i rdst(rsrc.x1 + dx, rsrc.y1 + dy, rsrc.x2 + dx, rsrc.y2 + dy);
rect_i rc = clip_rect_area(rdst, rsrc, src.width(), src.height());
if(rc.x2 > 0)
if (rc.x2 > 0)
{
int incy = 1;
if(rdst.y1 > rsrc.y1)
if (rdst.y1 > rsrc.y1)
{
rsrc.y1 += rc.y2 - 1;
rdst.y1 += rc.y2 - 1;
incy = -1;
}
while(rc.y2 > 0)
while (rc.y2 > 0)
{
typename SrcPixelFormatRenderer::row_data rw = src.row(rsrc.y1);
if(rw.ptr)
if (rw.ptr)
{
int x1src = rsrc.x1;
int x1dst = rdst.x1;
int len = rc.x2;
if(rw.x1 > x1src)
if (rw.x1 > x1src)
{
x1dst += rw.x1 - x1src;
len -= rw.x1 - x1src;
x1src = rw.x1;
}
if(len > 0)
if (len > 0)
{
if(x1src + len-1 > rw.x2)
if (x1src + len - 1 > rw.x2)
{
len -= x1src + len - rw.x2 - 1;
}
if(len > 0)
if (len > 0)
{
m_ren->blend_from(src,
x1dst, rdst.y1,
x1src, rsrc.y1,
len,
cover);
m_ren->blend_from(src, x1dst, rdst.y1, x1src, rsrc.y1, len, cover);
}
}
}
@ -601,7 +659,7 @@ namespace agg
cover_type cover = agg::cover_full)
{
rect_i rsrc(0, 0, src.width(), src.height());
if(rect_src_ptr)
if (rect_src_ptr)
{
rsrc.x1 = rect_src_ptr->x1;
rsrc.y1 = rect_src_ptr->y1;
@ -610,49 +668,44 @@ namespace agg
}
// Version with xdst, ydst (absolute positioning)
//rect_i rdst(xdst, ydst, xdst + rsrc.x2 - rsrc.x1, ydst + rsrc.y2 - rsrc.y1);
// rect_i rdst(xdst, ydst, xdst + rsrc.x2 - rsrc.x1, ydst + rsrc.y2 - rsrc.y1);
// Version with dx, dy (relative positioning)
rect_i rdst(rsrc.x1 + dx, rsrc.y1 + dy, rsrc.x2 + dx, rsrc.y2 + dy);
rect_i rc = clip_rect_area(rdst, rsrc, src.width(), src.height());
if(rc.x2 > 0)
if (rc.x2 > 0)
{
int incy = 1;
if(rdst.y1 > rsrc.y1)
if (rdst.y1 > rsrc.y1)
{
rsrc.y1 += rc.y2 - 1;
rdst.y1 += rc.y2 - 1;
incy = -1;
}
while(rc.y2 > 0)
while (rc.y2 > 0)
{
typename SrcPixelFormatRenderer::row_data rw = src.row(rsrc.y1);
if(rw.ptr)
if (rw.ptr)
{
int x1src = rsrc.x1;
int x1dst = rdst.x1;
int len = rc.x2;
if(rw.x1 > x1src)
if (rw.x1 > x1src)
{
x1dst += rw.x1 - x1src;
len -= rw.x1 - x1src;
x1src = rw.x1;
}
if(len > 0)
if (len > 0)
{
if(x1src + len-1 > rw.x2)
if (x1src + len - 1 > rw.x2)
{
len -= x1src + len - rw.x2 - 1;
}
if(len > 0)
if (len > 0)
{
m_ren->blend_from_color(src,
color,
x1dst, rdst.y1,
x1src, rsrc.y1,
len,
cover);
m_ren->blend_from_color(src, color, x1dst, rdst.y1, x1src, rsrc.y1, len, cover);
}
}
}
@ -673,7 +726,7 @@ namespace agg
cover_type cover = agg::cover_full)
{
rect_i rsrc(0, 0, src.width(), src.height());
if(rect_src_ptr)
if (rect_src_ptr)
{
rsrc.x1 = rect_src_ptr->x1;
rsrc.y1 = rect_src_ptr->y1;
@ -682,49 +735,44 @@ namespace agg
}
// Version with xdst, ydst (absolute positioning)
//rect_i rdst(xdst, ydst, xdst + rsrc.x2 - rsrc.x1, ydst + rsrc.y2 - rsrc.y1);
// rect_i rdst(xdst, ydst, xdst + rsrc.x2 - rsrc.x1, ydst + rsrc.y2 - rsrc.y1);
// Version with dx, dy (relative positioning)
rect_i rdst(rsrc.x1 + dx, rsrc.y1 + dy, rsrc.x2 + dx, rsrc.y2 + dy);
rect_i rc = clip_rect_area(rdst, rsrc, src.width(), src.height());
if(rc.x2 > 0)
if (rc.x2 > 0)
{
int incy = 1;
if(rdst.y1 > rsrc.y1)
if (rdst.y1 > rsrc.y1)
{
rsrc.y1 += rc.y2 - 1;
rdst.y1 += rc.y2 - 1;
incy = -1;
}
while(rc.y2 > 0)
while (rc.y2 > 0)
{
typename SrcPixelFormatRenderer::row_data rw = src.row(rsrc.y1);
if(rw.ptr)
if (rw.ptr)
{
int x1src = rsrc.x1;
int x1dst = rdst.x1;
int len = rc.x2;
if(rw.x1 > x1src)
if (rw.x1 > x1src)
{
x1dst += rw.x1 - x1src;
len -= rw.x1 - x1src;
x1src = rw.x1;
}
if(len > 0)
if (len > 0)
{
if(x1src + len-1 > rw.x2)
if (x1src + len - 1 > rw.x2)
{
len -= x1src + len - rw.x2 - 1;
}
if(len > 0)
if (len > 0)
{
m_ren->blend_from_lut(src,
color_lut,
x1dst, rdst.y1,
x1src, rsrc.y1,
len,
cover);
m_ren->blend_from_lut(src, color_lut, x1dst, rdst.y1, x1src, rsrc.y1, len, cover);
}
}
}
@ -738,9 +786,8 @@ namespace agg
private:
pixfmt_type* m_ren;
rect_i m_clip_box;
};
};
}
} // namespace agg
#endif

1222
deps/agg/include/agg_renderer_markers.h vendored
View file

File diff suppressed because it is too large Load diff

133
deps/agg/include/agg_renderer_mclip.h vendored
View file

@ -24,12 +24,12 @@
#include "agg_array.h"
#include "agg_renderer_base.h"
namespace agg
{
namespace agg {
//----------------------------------------------------------renderer_mclip
template<class PixelFormat> class renderer_mclip
{
//----------------------------------------------------------renderer_mclip
template<class PixelFormat>
class renderer_mclip
{
public:
typedef PixelFormat pixfmt_type;
typedef typename pixfmt_type::color_type color_type;
@ -37,10 +37,10 @@ namespace agg
typedef renderer_base<pixfmt_type> base_ren_type;
//--------------------------------------------------------------------
explicit renderer_mclip(pixfmt_type& pixf) :
m_ren(pixf),
m_curr_cb(0),
m_bounds(m_ren.xmin(), m_ren.ymin(), m_ren.xmax(), m_ren.ymax())
explicit renderer_mclip(pixfmt_type& pixf)
: m_ren(pixf)
, m_curr_cb(0)
, m_bounds(m_ren.xmin(), m_ren.ymin(), m_ren.xmax(), m_ren.ymax())
{}
void attach(pixfmt_type& pixf)
{
@ -74,7 +74,7 @@ namespace agg
void first_clip_box()
{
m_curr_cb = 0;
if(m_clip.size())
if (m_clip.size())
{
const rect_i& cb = m_clip[0];
m_ren.clip_box_naked(cb.x1, cb.y1, cb.x2, cb.y2);
@ -84,7 +84,7 @@ namespace agg
//--------------------------------------------------------------------
bool next_clip_box()
{
if(++m_curr_cb < m_clip.size())
if (++m_curr_cb < m_clip.size())
{
const rect_i& cb = m_clip[m_curr_cb];
m_ren.clip_box_naked(cb.x1, cb.y1, cb.x2, cb.y2);
@ -107,21 +107,22 @@ namespace agg
{
rect_i cb(x1, y1, x2, y2);
cb.normalize();
if(cb.clip(rect_i(0, 0, width() - 1, height() - 1)))
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.y1 < m_bounds.y1) 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;
if (cb.x1 < m_bounds.x1)
m_bounds.x1 = cb.x1;
if (cb.y1 < m_bounds.y1)
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)
{
m_ren.clear(c);
}
void clear(const color_type& c) { m_ren.clear(c); }
//--------------------------------------------------------------------
void copy_pixel(int x, int y, const color_type& c)
@ -129,13 +130,12 @@ namespace agg
first_clip_box();
do
{
if(m_ren.inbox(x, y))
if (m_ren.inbox(x, y))
{
m_ren.ren().copy_pixel(x, y, c);
break;
}
}
while(next_clip_box());
} while (next_clip_box());
}
//--------------------------------------------------------------------
@ -144,13 +144,12 @@ namespace agg
first_clip_box();
do
{
if(m_ren.inbox(x, y))
if (m_ren.inbox(x, y))
{
m_ren.ren().blend_pixel(x, y, c, cover);
break;
}
}
while(next_clip_box());
} while (next_clip_box());
}
//--------------------------------------------------------------------
@ -159,12 +158,11 @@ namespace agg
first_clip_box();
do
{
if(m_ren.inbox(x, y))
if (m_ren.inbox(x, y))
{
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,
const color_type& c, cover_type cover)
void blend_hline(int x1, int y, int x2, 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,
const color_type& c, cover_type cover)
void blend_vline(int x, int y1, int y2, 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,
const color_type& c, cover_type cover)
void blend_bar(int x1, int y1, int x2, int y2, 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,
const color_type& c, const cover_type* covers)
void blend_solid_hspan(int x, int y, int len, 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,
const color_type& c, const cover_type* covers)
void blend_solid_vspan(int x, int y, int len, 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,
const rect_i* rc=0,
int x_to=0,
int y_to=0)
void copy_from(const rendering_buffer& from, 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,23 +308,19 @@ 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>&
operator = (const renderer_mclip<PixelFormat>&);
const renderer_mclip<PixelFormat>& operator=(const renderer_mclip<PixelFormat>&);
base_ren_type m_ren;
pod_bvector<rect_i, 4> m_clip;
unsigned m_curr_cb;
rect_i m_bounds;
};
};
}
} // namespace agg
#endif

961
deps/agg/include/agg_renderer_outline_aa.h vendored
View file

File diff suppressed because it is too large Load diff

534
deps/agg/include/agg_renderer_outline_image.h vendored
View file

@ -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
{
//========================================================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) :
m_source(src),
m_height(height),
m_scale(src.height() / height)
{
}
line_image_scale(const Source& src, double height)
: m_source(src)
, m_height(height)
, m_scale(src.height() / height)
{}
double width() const { return m_source.width(); }
double height() const { return m_height; }
@ -54,76 +52,73 @@ namespace agg
private:
line_image_scale(const line_image_scale<Source>&);
const line_image_scale<Source>& operator = (const line_image_scale<Source>&);
const line_image_scale<Source>& operator=(const line_image_scale<Source>&);
const Source& m_source;
double m_height;
double m_scale;
};
};
//======================================================line_image_pattern
template<class Filter> class line_image_pattern
{
//======================================================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) :
m_filter(&filter),
m_dilation(filter.dilation() + 1),
m_dilation_hr(m_dilation * line_subpixel_scale),
m_data(),
m_width(0),
m_height(0),
m_width_hr(0),
m_half_height_hr(0),
m_offset_y_hr(0)
{
}
line_image_pattern(const Filter& filter)
: m_filter(&filter)
, m_dilation(filter.dilation() + 1)
, m_dilation_hr(m_dilation * line_subpixel_scale)
, m_data()
, m_width(0)
, m_height(0)
, m_width_hr(0)
, m_half_height_hr(0)
, m_offset_y_hr(0)
{}
// Create
//--------------------------------------------------------------------
template<class Source>
line_image_pattern(const Filter& filter, const Source& src) :
m_filter(&filter),
m_dilation(filter.dilation() + 1),
m_dilation_hr(m_dilation * line_subpixel_scale),
m_data(),
m_width(0),
m_height(0),
m_width_hr(0),
m_half_height_hr(0),
m_offset_y_hr(0)
line_image_pattern(const Filter& filter, const Source& src)
: m_filter(&filter)
, m_dilation(filter.dilation() + 1)
, m_dilation_hr(m_dilation * line_subpixel_scale)
, m_data()
, m_width(0)
, m_height(0)
, m_width_hr(0)
, m_half_height_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());
m_width_hr = uround(src.width() * line_subpixel_scale);
m_half_height_hr = uround(src.height() * line_subpixel_scale/2);
m_offset_y_hr = m_dilation_hr + m_half_height_hr - line_subpixel_scale/2;
m_half_height_hr += line_subpixel_scale/2;
m_half_height_hr = uround(src.height() * line_subpixel_scale / 2);
m_offset_y_hr = m_dilation_hr + m_half_height_hr - line_subpixel_scale / 2;
m_half_height_hr += line_subpixel_scale / 2;
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_height + m_dilation * 2,
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);
unsigned x, y;
color_type* d1;
color_type* d2;
for(y = 0; y < m_height; y++)
for (y = 0; y < m_height; y++)
{
d1 = m_buf.row_ptr(y + m_dilation) + m_dilation;
for(x = 0; x < m_width; x++)
for (x = 0; x < m_width; x++)
{
*d1++ = src.pixel(x, y);
}
@ -131,13 +126,13 @@ namespace agg
const color_type* s1;
const color_type* s2;
for(y = 0; y < m_dilation; y++)
for (y = 0; y < m_dilation; y++)
{
//s1 = m_buf.row_ptr(m_height + m_dilation - 1) + m_dilation;
//s2 = m_buf.row_ptr(m_dilation) + m_dilation;
// s1 = m_buf.row_ptr(m_height + m_dilation - 1) + m_dilation;
// s2 = m_buf.row_ptr(m_dilation) + m_dilation;
d1 = m_buf.row_ptr(m_dilation + m_height + y) + m_dilation;
d2 = m_buf.row_ptr(m_dilation - y - 1) + m_dilation;
for(x = 0; x < m_width; x++)
for (x = 0; x < m_width; x++)
{
//*d1++ = color_type(*s1++, 0);
//*d2++ = color_type(*s2++, 0);
@ -147,14 +142,14 @@ namespace agg
}
unsigned h = m_height + m_dilation * 2;
for(y = 0; y < h; y++)
for (y = 0; y < h; y++)
{
s1 = m_buf.row_ptr(y) + m_dilation;
s2 = m_buf.row_ptr(y) + m_dilation + m_width;
d1 = m_buf.row_ptr(y) + m_dilation + m_width;
d2 = m_buf.row_ptr(y) + m_dilation;
for(x = 0; x < m_dilation; x++)
for (x = 0; x < m_dilation; x++)
{
*d1++ = *s1++;
*--d2 = *--s2;
@ -170,10 +165,7 @@ namespace agg
//--------------------------------------------------------------------
void pixel(color_type* p, int x, int y) const
{
m_filter->pixel_high_res(m_buf.rows(),
p,
x % m_width_hr + m_dilation_hr,
y + m_offset_y_hr);
m_filter->pixel_high_res(m_buf.rows(), 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>&
operator = (const line_image_pattern<filter_type>&);
const line_image_pattern<filter_type>& operator=(const line_image_pattern<filter_type>&);
protected:
row_ptr_cache<color_type> m_buf;
@ -195,40 +186,39 @@ namespace agg
int m_width_hr;
int m_half_height_hr;
int m_offset_y_hr;
};
};
//=================================================line_image_pattern_pow2
template<class Filter> class line_image_pattern_pow2 :
public line_image_pattern<Filter>
{
//=================================================line_image_pattern_pow2
template<class Filter>
class line_image_pattern_pow2 : public line_image_pattern<Filter>
{
public:
typedef Filter filter_type;
typedef typename filter_type::color_type color_type;
typedef line_image_pattern<Filter> base_type;
//--------------------------------------------------------------------
line_image_pattern_pow2(const Filter& filter) :
line_image_pattern<Filter>(filter), m_mask(line_subpixel_mask) {}
line_image_pattern_pow2(const Filter& filter)
: 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<Filter>(filter), m_mask(line_subpixel_mask)
line_image_pattern_pow2(const Filter& filter, const Source& src)
: 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;
while(m_mask < base_type::m_width)
while (m_mask < base_type::m_width)
{
m_mask <<= 1;
m_mask |= 1;
@ -241,55 +231,61 @@ namespace agg
//--------------------------------------------------------------------
void pixel(color_type* p, int x, int y) const
{
base_type::m_filter->pixel_high_res(
base_type::m_buf.rows(),
base_type::m_filter->pixel_high_res(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
{
//===================================================distance_interpolator4
class distance_interpolator4
{
public:
//---------------------------------------------------------------------
distance_interpolator4() {}
distance_interpolator4(int x1, int y1, int x2, int y2,
int sx, int sy, int ex, int ey,
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)),
distance_interpolator4(int x1,
int y1,
int x2,
int y2,
int sx,
int sy,
int ex,
int ey,
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))),
m_dist(iround(double(x + line_subpixel_scale / 2 - x2) * double(m_dy) -
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),
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)
,
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),
m_len(uround(len / scale))
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)
, m_len(uround(len / scale))
{
double d = len * scale;
int dx = iround(((x2 - x1) * line_subpixel_scale) / d);
int dy = iround(((y2 - y1) * line_subpixel_scale) / d);
m_dx_pict = -dy;
m_dy_pict = dx;
m_dist_pict = ((x + line_subpixel_scale/2 - (x1 - dy)) * m_dy_pict -
(y + line_subpixel_scale/2 - (y1 + dx)) * m_dx_pict) >>
m_dist_pict = ((x + line_subpixel_scale / 2 - (x1 - dy)) * m_dy_pict -
(y + line_subpixel_scale / 2 - (y1 + dx)) * m_dx_pict) >>
line_subpixel_shift;
m_dx *= line_subpixel_scale;
@ -343,14 +339,14 @@ namespace agg
m_dist_start += m_dy_start;
m_dist_pict += m_dy_pict;
m_dist_end += m_dy_end;
if(dy > 0)
if (dy > 0)
{
m_dist -= m_dx;
m_dist_start -= m_dx_start;
m_dist_pict -= m_dx_pict;
m_dist_end -= m_dx_end;
}
if(dy < 0)
if (dy < 0)
{
m_dist += m_dx;
m_dist_start += m_dx_start;
@ -366,14 +362,14 @@ namespace agg
m_dist_start -= m_dy_start;
m_dist_pict -= m_dy_pict;
m_dist_end -= m_dy_end;
if(dy > 0)
if (dy > 0)
{
m_dist -= m_dx;
m_dist_start -= m_dx_start;
m_dist_pict -= m_dx_pict;
m_dist_end -= m_dx_end;
}
if(dy < 0)
if (dy < 0)
{
m_dist += m_dx;
m_dist_start += m_dx_start;
@ -389,14 +385,14 @@ namespace agg
m_dist_start -= m_dx_start;
m_dist_pict -= m_dx_pict;
m_dist_end -= m_dx_end;
if(dx > 0)
if (dx > 0)
{
m_dist += m_dy;
m_dist_start += m_dy_start;
m_dist_pict += m_dy_pict;
m_dist_end += m_dy_end;
}
if(dx < 0)
if (dx < 0)
{
m_dist -= m_dy;
m_dist_start -= m_dy_start;
@ -412,14 +408,14 @@ namespace agg
m_dist_start += m_dx_start;
m_dist_pict += m_dx_pict;
m_dist_end += m_dx_end;
if(dx > 0)
if (dx > 0)
{
m_dist += m_dy;
m_dist_start += m_dy_start;
m_dist_pict += m_dy_pict;
m_dist_end += m_dy_end;
}
if(dx < 0)
if (dx < 0)
{
m_dist -= m_dy;
m_dist_start -= m_dy_start;
@ -461,60 +457,68 @@ namespace agg
int m_dist_pict;
int m_dist_end;
int m_len;
};
};
//==================================================line_interpolator_image
template<class Renderer> class line_interpolator_image
{
//==================================================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
{
max_half_width = 64
};
enum max_half_width_e { max_half_width = 64 };
//---------------------------------------------------------------------
line_interpolator_image(renderer_type& ren, const line_parameters& lp,
int sx, int sy, int ex, int ey,
line_interpolator_image(renderer_type& ren,
const line_parameters& lp,
int sx,
int sy,
int ex,
int ey,
int pattern_start,
double scale_x) :
m_lp(lp),
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),
m_di(lp.x1, lp.y1, lp.x2, lp.y2, sx, sy, ex, ey, lp.len, scale_x,
lp.x1 & ~line_subpixel_mask, 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_start(pattern_start + (m_max_extent + 2) * ren.pattern_width()),
m_step(0)
double scale_x)
: m_lp(lp)
, 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)
, m_di(lp.x1,
lp.y1,
lp.x2,
lp.y2,
sx,
sy,
ex,
ey,
lp.len,
scale_x,
lp.x1 & ~line_subpixel_mask,
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_start(pattern_start + (m_max_extent + 2) * ren.pattern_width())
, m_step(0)
{
agg::dda2_line_interpolator li(0, lp.vertical ?
(lp.dy * agg::line_subpixel_scale) :
(lp.dx * agg::line_subpixel_scale),
agg::dda2_line_interpolator li(0,
lp.vertical ? (lp.dy * agg::line_subpixel_scale)
: (lp.dx * agg::line_subpixel_scale),
lp.len);
unsigned i;
int stop = m_width + line_subpixel_scale * 2;
for(i = 0; i < max_half_width; ++i)
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;
@ -523,7 +527,7 @@ namespace agg
int dist2_start;
int npix = 1;
if(lp.vertical)
if (lp.vertical)
{
do
{
@ -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);
else m_di.inc_y(m_x - m_old_x);
if (lp.inc > 0)
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(dist2_start < 0) ++npix;
if (dist1_start < 0)
++npix;
if (dist2_start < 0)
++npix;
++dx;
}
while(m_dist_pos[dx] <= m_width);
if(npix == 0) break;
} while (m_dist_pos[dx] <= m_width);
if (npix == 0)
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);
else m_di.inc_x(m_y - m_old_y);
if (lp.inc > 0)
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(dist2_start < 0) ++npix;
if (dist1_start < 0)
++npix;
if (dist2_start < 0)
++npix;
++dy;
}
while(m_dist_pos[dy] <= m_width);
if(npix == 0) break;
} while (m_dist_pos[dy] <= m_width);
if (npix == 0)
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);
else m_di.dec_x(m_y - m_old_y);
if (m_lp.inc > 0)
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;
@ -623,9 +638,9 @@ namespace agg
int npix = 0;
p1->clear();
if(dist_end > 0)
if (dist_end > 0)
{
if(dist_start <= 0)
if (dist_start <= 0)
{
m_ren.pixel(p1, dist_pict, s2);
}
@ -634,15 +649,16 @@ namespace agg
++p1;
dy = 1;
while((dist = m_dist_pos[dy]) - s1 <= m_width)
while ((dist = m_dist_pos[dy]) - s1 <= m_width)
{
dist_start -= m_di.dx_start();
dist_pict -= m_di.dx_pict();
dist_end -= m_di.dx_end();
p1->clear();
if(dist_end > 0 && dist_start <= 0)
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;
}
@ -654,30 +670,26 @@ namespace agg
dist_start = m_di.dist_start();
dist_pict = m_di.dist_pict() + m_start;
dist_end = m_di.dist_end();
while((dist = m_dist_pos[dy]) + s1 <= m_width)
while ((dist = m_dist_pos[dy]) + s1 <= m_width)
{
dist_start += m_di.dx_start();
dist_pict += m_di.dx_pict();
dist_end += m_di.dx_end();
--p0;
p0->clear();
if(dist_end > 0 && dist_start <= 0)
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_y - dy + 1,
unsigned(p1 - p0),
p0);
m_ren.blend_color_vspan(m_x, 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);
else m_di.dec_y(m_x - m_old_x);
if (m_lp.inc > 0)
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;
@ -709,9 +724,9 @@ namespace agg
int npix = 0;
p1->clear();
if(dist_end > 0)
if (dist_end > 0)
{
if(dist_start <= 0)
if (dist_start <= 0)
{
m_ren.pixel(p1, dist_pict, s2);
}
@ -720,15 +735,16 @@ namespace agg
++p1;
dx = 1;
while((dist = m_dist_pos[dx]) - s1 <= m_width)
while ((dist = m_dist_pos[dx]) - s1 <= m_width)
{
dist_start += m_di.dy_start();
dist_pict += m_di.dy_pict();
dist_end += m_di.dy_end();
p1->clear();
if(dist_end > 0 && dist_start <= 0)
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;
}
@ -740,29 +756,26 @@ namespace agg
dist_start = m_di.dist_start();
dist_pict = m_di.dist_pict() + m_start;
dist_end = m_di.dist_end();
while((dist = m_dist_pos[dx]) + s1 <= m_width)
while ((dist = m_dist_pos[dx]) + s1 <= m_width)
{
dist_start -= m_di.dy_start();
dist_pict -= m_di.dy_pict();
dist_end -= m_di.dy_end();
--p0;
p0->clear();
if(dist_end > 0 && dist_start <= 0)
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_y,
unsigned(p1 - p0),
p0);
m_ren.blend_color_hspan(m_x - dx + 1, 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>&
operator = (const line_interpolator_image<Renderer>&);
const line_interpolator_image<Renderer>& operator=(const line_interpolator_image<Renderer>&);
protected:
const line_parameters& m_lp;
@ -793,19 +805,12 @@ namespace agg
int m_step;
int m_dist_pos[max_half_width + 1];
color_type m_colors[max_half_width * 2 + 4];
};
};
//===================================================renderer_outline_image
template<class BaseRenderer, class ImagePattern>
class renderer_outline_image
{
//===================================================renderer_outline_image
template<class BaseRenderer, class ImagePattern>
class renderer_outline_image
{
public:
//---------------------------------------------------------------------
typedef BaseRenderer base_ren_type;
@ -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) :
m_ren(&ren),
m_pattern(&patt),
m_start(0),
m_scale_x(1.0),
m_clip_box(0,0,0,0),
m_clipping(false)
renderer_outline_image(base_ren_type& ren, const pattern_type& patt)
: m_ren(&ren)
, m_pattern(&patt)
, m_start(0)
, m_scale_x(1.0)
, m_clip_box(0, 0, 0, 0)
, 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
{
m_pattern->pixel(p, x, y);
}
void pixel(color_type* p, int x, int y) const { m_pattern->pixel(p, x, y); }
//-------------------------------------------------------------------------
void blend_color_hspan(int x, int y, unsigned len, const color_type* colors)
@ -877,34 +878,24 @@ 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,
int sx, int sy, int ex, int ey)
void line3_no_clip(const line_parameters& lp, int sx, int sy, int ex, int ey)
{
if(lp.len > line_max_length)
if (lp.len > line_max_length)
{
line_parameters lp1, lp2;
lp.divide(lp1, lp2);
@ -917,26 +908,24 @@ namespace agg
fix_degenerate_bisectrix_start(lp, &sx, &sy);
fix_degenerate_bisectrix_end(lp, &ex, &ey);
line_interpolator_image<self_type> li(*this, lp,
sx, sy,
ex, ey,
m_start, m_scale_x);
if(li.vertical())
line_interpolator_image<self_type> li(*this, lp, 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,
int sx, int sy, int ex, int ey)
void line3(const line_parameters& lp, int sx, int sy, int ex, int ey)
{
if(m_clipping)
if (m_clipping)
{
int x1 = lp.x1;
int y1 = lp.y1;
@ -944,13 +933,12 @@ namespace agg
int y2 = lp.y2;
unsigned flags = clip_line_segment(&x1, &y1, &x2, &y2, m_clip_box);
int start = m_start;
if((flags & 4) == 0)
if ((flags & 4) == 0)
{
if(flags)
if (flags)
{
line_parameters lp2(x1, y1, x2, y2,
uround(calc_distance(x1, y1, x2, y2)));
if(flags & 1)
line_parameters lp2(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);
sx = x1 + (y2 - y1);
@ -958,20 +946,20 @@ namespace agg
}
else
{
while(std::abs(sx - lp.x1) + std::abs(sy - lp.y1) > 1 + lp2.len)
while (std::abs(sx - lp.x1) + std::abs(sy - lp.y1) > 1 + lp2.len)
{
sx = (lp.x1 + sx) >> 1;
sy = (lp.y1 + sy) >> 1;
}
}
if(flags & 2)
if (flags & 2)
{
ex = x2 + (y2 - y1);
ey = y2 - (x2 - x1);
}
else
{
while(std::abs(ex - lp.x2) + std::abs(ey - lp.y2) > 1 + lp2.len)
while (std::abs(ex - lp.x2) + std::abs(ey - lp.y2) > 1 + lp2.len)
{
ex = (lp.x2 + ex) >> 1;
ey = (lp.y2 + ey) >> 1;
@ -999,14 +987,8 @@ namespace agg
double m_scale_x;
rect_i m_clip_box;
bool m_clipping;
};
}
};
} // namespace agg
#endif

86
deps/agg/include/agg_renderer_primitives.h vendored
View file

@ -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
{
//-----------------------------------------------------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) :
m_ren(&ren),
m_fill_color(),
m_line_color(),
m_curr_x(0),
m_curr_y(0)
explicit renderer_primitives(base_ren_type& ren)
: m_ren(&ren)
, m_fill_color()
, m_line_color()
, m_curr_x(0)
, m_curr_y(0)
{}
void attach(base_ren_type& ren) { m_ren = &ren; }
//--------------------------------------------------------------------
static int coord(double c)
{
return iround(c * line_bresenham_interpolator::subpixel_scale);
}
static int coord(double c) { return iround(c * line_bresenham_interpolator::subpixel_scale); }
//--------------------------------------------------------------------
void fill_color(const color_type& c) { m_fill_color = c; }
@ -59,23 +56,20 @@ namespace agg
//--------------------------------------------------------------------
void rectangle(int x1, int y1, int x2, int y2)
{
m_ren->blend_hline(x1, y1, x2-1, m_line_color, cover_full);
m_ren->blend_vline(x2, y1, y2-1, m_line_color, cover_full);
m_ren->blend_hline(x1+1, y2, x2, m_line_color, cover_full);
m_ren->blend_vline(x1, y1+1, y2, m_line_color, cover_full);
m_ren->blend_hline(x1, y1, x2 - 1, m_line_color, cover_full);
m_ren->blend_vline(x2, y1, y2 - 1, m_line_color, cover_full);
m_ren->blend_hline(x1 + 1, y2, x2, m_line_color, cover_full);
m_ren->blend_vline(x1, y1 + 1, y2, m_line_color, cover_full);
}
//--------------------------------------------------------------------
void solid_rectangle(int x1, int y1, int x2, int y2)
{
m_ren->blend_bar(x1, y1, x2, y2, m_fill_color, cover_full);
}
void solid_rectangle(int x1, int y1, int x2, int y2) { m_ren->blend_bar(x1, y1, x2, y2, m_fill_color, cover_full); }
//--------------------------------------------------------------------
void outlined_rectangle(int x1, int y1, int x2, int y2)
{
rectangle(x1, y1, x2, y2);
m_ren->blend_bar(x1+1, y1+1, x2-1, y2-1, m_fill_color, cover_full);
m_ren->blend_bar(x1 + 1, y1 + 1, x2 - 1, y2 - 1, m_fill_color, cover_full);
}
//--------------------------------------------------------------------
@ -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);
}
//--------------------------------------------------------------------
@ -111,17 +104,16 @@ namespace agg
dx += ei.dx();
dy += ei.dy();
if(dy != dy0)
if (dy != dy0)
{
m_ren->blend_hline(x-dx0, y+dy0, x+dx0, m_fill_color, cover_full);
m_ren->blend_hline(x-dx0, y-dy0, x+dx0, m_fill_color, cover_full);
m_ren->blend_hline(x - dx0, y + dy0, x + dx0, m_fill_color, cover_full);
m_ren->blend_hline(x - dx0, y - dy0, x + dx0, m_fill_color, cover_full);
}
dx0 = dx;
dy0 = dy;
++ei;
}
while(dy < 0);
m_ren->blend_hline(x-dx0, y+dy0, x+dx0, m_fill_color, cover_full);
} while (dy < 0);
m_ren->blend_hline(x - dx0, y + dy0, x + dx0, m_fill_color, cover_full);
}
//--------------------------------------------------------------------
@ -141,41 +133,40 @@ 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);
if(ei.dy() && dx)
if (ei.dy() && dx)
{
m_ren->blend_hline(x-dx+1, y+dy, x+dx-1, m_fill_color, cover_full);
m_ren->blend_hline(x-dx+1, y-dy, x+dx-1, m_fill_color, cover_full);
m_ren->blend_hline(x - dx + 1, y + dy, x + dx - 1, m_fill_color, cover_full);
m_ren->blend_hline(x - dx + 1, y - dy, x + dx - 1, m_fill_color, cover_full);
}
++ei;
}
while(dy < 0);
} while (dy < 0);
}
//--------------------------------------------------------------------
void line(int x1, int y1, int x2, int y2, bool last=false)
void line(int x1, int y1, int x2, int y2, bool last = false)
{
line_bresenham_interpolator li(x1, y1, x2, y2);
unsigned len = li.len();
if(len == 0)
if (len == 0)
{
if(last)
if (last)
{
m_ren->blend_pixel(li.line_lr(x1), li.line_lr(y1), m_line_color, cover_full);
}
return;
}
if(last) ++len;
if (last)
++len;
if(li.is_ver())
if (li.is_ver())
{
do
{
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);
}
}
@ -196,7 +186,7 @@ namespace agg
}
//--------------------------------------------------------------------
void line_to(int x, int y, bool last=false)
void line_to(int x, int y, bool last = false)
{
line(m_curr_x, m_curr_y, x, y, last);
m_curr_x = x;
@ -217,8 +207,8 @@ namespace agg
color_type m_line_color;
int m_curr_x;
int m_curr_y;
};
};
}
} // namespace agg
#endif

150
deps/agg/include/agg_renderer_raster_text.h vendored
View file

@ -18,22 +18,21 @@
#include "agg_basics.h"
namespace agg
{
namespace agg {
//==============================================renderer_raster_htext_solid
template<class BaseRenderer, class GlyphGenerator>
class renderer_raster_htext_solid
{
//==============================================renderer_raster_htext_solid
template<class BaseRenderer, class GlyphGenerator>
class renderer_raster_htext_solid
{
public:
typedef BaseRenderer ren_type;
typedef GlyphGenerator glyph_gen_type;
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) :
m_ren(&ren),
m_glyph(&glyph)
renderer_raster_htext_solid(ren_type& ren, glyph_gen_type& glyph)
: m_ren(&ren)
, m_glyph(&glyph)
{}
void attach(ren_type& ren) { m_ren = &ren; }
@ -43,31 +42,27 @@ namespace agg
//--------------------------------------------------------------------
template<class CharT>
void render_text(double x, double y, const CharT* str, bool flip=false)
void render_text(double x, double y, const CharT* str, bool flip = false)
{
glyph_rect r;
while(*str)
while (*str)
{
m_glyph->prepare(&r, x, y, *str, flip);
if(r.x2 >= r.x1)
if (r.x2 >= r.x1)
{
int i;
if(flip)
if (flip)
{
for(i = r.y1; i <= r.y2; i++)
for (i = r.y1; i <= r.y2; i++)
{
m_ren->blend_solid_hspan(r.x1, i, (r.x2 - r.x1 + 1),
m_color,
m_glyph->span(r.y2 - i));
m_ren->blend_solid_hspan(r.x1, i, (r.x2 - r.x1 + 1), m_color, m_glyph->span(r.y2 - i));
}
}
else
{
for(i = r.y1; i <= r.y2; i++)
for (i = r.y1; i <= r.y2; i++)
{
m_ren->blend_solid_hspan(r.x1, i, (r.x2 - r.x1 + 1),
m_color,
m_glyph->span(i - r.y1));
m_ren->blend_solid_hspan(r.x1, i, (r.x2 - r.x1 + 1), m_color, m_glyph->span(i - r.y1));
}
}
}
@ -81,25 +76,22 @@ namespace agg
ren_type* m_ren;
glyph_gen_type* m_glyph;
color_type m_color;
};
};
//=============================================renderer_raster_vtext_solid
template<class BaseRenderer, class GlyphGenerator>
class renderer_raster_vtext_solid
{
//=============================================renderer_raster_vtext_solid
template<class BaseRenderer, class GlyphGenerator>
class renderer_raster_vtext_solid
{
public:
typedef BaseRenderer ren_type;
typedef GlyphGenerator glyph_gen_type;
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) :
m_ren(&ren),
m_glyph(&glyph)
{
}
renderer_raster_vtext_solid(ren_type& ren, glyph_gen_type& glyph)
: m_ren(&ren)
, m_glyph(&glyph)
{}
//--------------------------------------------------------------------
void color(const color_type& c) { m_color = c; }
@ -107,31 +99,27 @@ namespace agg
//--------------------------------------------------------------------
template<class CharT>
void render_text(double x, double y, const CharT* str, bool flip=false)
void render_text(double x, double y, const CharT* str, bool flip = false)
{
glyph_rect r;
while(*str)
while (*str)
{
m_glyph->prepare(&r, x, y, *str, !flip);
if(r.x2 >= r.x1)
if (r.x2 >= r.x1)
{
int i;
if(flip)
if (flip)
{
for(i = r.y1; i <= r.y2; i++)
for (i = r.y1; i <= r.y2; i++)
{
m_ren->blend_solid_vspan(i, r.x1, (r.x2 - r.x1 + 1),
m_color,
m_glyph->span(i - r.y1));
m_ren->blend_solid_vspan(i, r.x1, (r.x2 - r.x1 + 1), m_color, m_glyph->span(i - r.y1));
}
}
else
{
for(i = r.y1; i <= r.y2; i++)
for (i = r.y1; i <= r.y2; i++)
{
m_ren->blend_solid_vspan(i, r.x1, (r.x2 - r.x1 + 1),
m_color,
m_glyph->span(r.y2 - i));
m_ren->blend_solid_vspan(i, r.x1, (r.x2 - r.x1 + 1), m_color, m_glyph->span(r.y2 - i));
}
}
}
@ -145,17 +133,12 @@ namespace agg
ren_type* m_ren;
glyph_gen_type* m_glyph;
color_type m_color;
};
};
//===================================================renderer_raster_htext
template<class ScanlineRenderer, class GlyphGenerator>
class renderer_raster_htext
{
//===================================================renderer_raster_htext
template<class ScanlineRenderer, class GlyphGenerator>
class renderer_raster_htext
{
public:
typedef ScanlineRenderer ren_type;
typedef GlyphGenerator glyph_gen_type;
@ -174,18 +157,19 @@ namespace agg
const cover_type* covers;
const_span() {}
const_span(int x_, unsigned len_, const cover_type* covers_) :
x(x_), len(len_), covers(covers_)
const_span(int x_, unsigned len_, const cover_type* covers_)
: x(x_)
, len(len_)
, covers(covers_)
{}
};
typedef const const_span* const_iterator;
//----------------------------------------------------------------
scanline_single_span(int x, int y, unsigned len,
const cover_type* covers) :
m_y(y),
m_span(x, len, covers)
scanline_single_span(int x, int y, unsigned len, const cover_type* covers)
: m_y(y)
, m_span(x, len, covers)
{}
//----------------------------------------------------------------
@ -199,48 +183,36 @@ namespace agg
const_span m_span;
};
//--------------------------------------------------------------------
renderer_raster_htext(ren_type& ren, glyph_gen_type& glyph) :
m_ren(&ren),
m_glyph(&glyph)
{
}
renderer_raster_htext(ren_type& ren, glyph_gen_type& glyph)
: m_ren(&ren)
, m_glyph(&glyph)
{}
//--------------------------------------------------------------------
template<class CharT>
void render_text(double x, double y, const CharT* str, bool flip=false)
void render_text(double x, double y, const CharT* str, bool flip = false)
{
glyph_rect r;
while(*str)
while (*str)
{
m_glyph->prepare(&r, x, y, *str, flip);
if(r.x2 >= r.x1)
if (r.x2 >= r.x1)
{
m_ren->prepare();
int i;
if(flip)
if (flip)
{
for(i = r.y1; i <= r.y2; i++)
for (i = r.y1; i <= r.y2; i++)
{
m_ren->render(
scanline_single_span(r.x1,
i,
(r.x2 - r.x1 + 1),
m_glyph->span(r.y2 - i)));
m_ren->render(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++)
for (i = r.y1; i <= r.y2; i++)
{
m_ren->render(
scanline_single_span(r.x1,
i,
(r.x2 - r.x1 + 1),
m_glyph->span(i - r.y1)));
m_ren->render(scanline_single_span(r.x1, i, (r.x2 - r.x1 + 1), m_glyph->span(i - r.y1)));
}
}
}
@ -253,12 +225,8 @@ namespace agg
private:
ren_type* m_ren;
glyph_gen_type* m_glyph;
};
};
}
} // namespace agg
#endif

594
deps/agg/include/agg_renderer_scanline.h vendored
View file

File diff suppressed because it is too large Load diff

189
deps/agg/include/agg_rendering_buffer.h vendored
View file

@ -22,37 +22,35 @@
#include "agg_array.h"
namespace agg
{
namespace agg {
//===========================================================row_accessor
template<class T> class row_accessor
{
//===========================================================row_accessor
template<class T>
class row_accessor
{
public:
typedef const_row_info<T> row_data;
//-------------------------------------------------------------------
row_accessor() :
m_buf(0),
m_start(0),
m_width(0),
m_height(0),
m_stride(0)
{
}
row_accessor()
: m_buf(0)
, m_start(0)
, m_width(0)
, m_height(0)
, m_stride(0)
{}
//--------------------------------------------------------------------
row_accessor(T* buf, unsigned width, unsigned height, int stride) :
m_buf(0),
m_start(0),
m_width(0),
m_height(0),
m_stride(0)
row_accessor(T* buf, unsigned width, unsigned height, int stride)
: m_buf(0)
, m_start(0)
, m_width(0)
, m_height(0)
, m_stride(0)
{
attach(buf, width, height, stride);
}
//--------------------------------------------------------------------
void attach(T* buf, unsigned width, unsigned height, int stride)
{
@ -60,7 +58,7 @@ namespace agg
m_width = width;
m_height = height;
m_stride = stride;
if(stride < 0)
if (stride < 0)
{
m_start = m_buf - int(height - 1) * 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
{
return (m_stride < 0) ? unsigned(-m_stride) : unsigned(m_stride);
}
AGG_INLINE unsigned stride_abs() const { return (m_stride < 0) ? unsigned(-m_stride) : unsigned(m_stride); }
//--------------------------------------------------------------------
AGG_INLINE T* row_ptr(int, int y, unsigned)
{
return m_start + y * m_stride;
}
AGG_INLINE T* row_ptr(int, int y, unsigned) { 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
{
return row_data(0, m_width-1, row_ptr(y));
}
AGG_INLINE row_data row(int y) const { return row_data(0, m_width - 1, row_ptr(y)); }
//--------------------------------------------------------------------
template<class RenBuf>
void copy_from(const RenBuf& src)
{
unsigned h = height();
if(src.height() < h) h = src.height();
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);
@ -115,11 +106,11 @@ namespace agg
unsigned y;
unsigned w = width();
unsigned stride = stride_abs();
for(y = 0; y < height(); y++)
for (y = 0; y < height(); y++)
{
T* p = row_ptr(0, y, w);
unsigned x;
for(x = 0; x < stride; x++)
for (x = 0; x < stride; x++)
{
*p++ = value;
}
@ -133,34 +124,31 @@ namespace agg
unsigned m_width; // Width in pixels
unsigned m_height; // Height in pixels
int m_stride; // Number of bytes per row. Can be < 0
};
};
//==========================================================row_ptr_cache
template<class T> class row_ptr_cache
{
//==========================================================row_ptr_cache
template<class T>
class row_ptr_cache
{
public:
typedef const_row_info<T> row_data;
//-------------------------------------------------------------------
row_ptr_cache() :
m_buf(0),
m_rows(),
m_width(0),
m_height(0),
m_stride(0)
{
}
row_ptr_cache()
: m_buf(0)
, m_rows()
, m_width(0)
, m_height(0)
, m_stride(0)
{}
//--------------------------------------------------------------------
row_ptr_cache(T* buf, unsigned width, unsigned height, int stride) :
m_buf(0),
m_rows(),
m_width(0),
m_height(0),
m_stride(0)
row_ptr_cache(T* buf, unsigned width, unsigned height, int stride)
: m_buf(0)
, m_rows()
, m_width(0)
, m_height(0)
, m_stride(0)
{
attach(buf, width, height, stride);
}
@ -172,25 +160,25 @@ namespace agg
m_width = width;
m_height = height;
m_stride = stride;
if(height > m_rows.size())
if (height > m_rows.size())
{
m_rows.resize(height);
}
else if(height == 0)
else if (height == 0)
{
return;
}
T* row_ptr = m_buf;
if(stride < 0)
if (stride < 0)
{
row_ptr = m_buf - int(height - 1) * stride;
}
T** rows = &m_rows[0];
while(height > 0)
while (height > 0)
{
*rows++ = row_ptr;
row_ptr += 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
{
return (m_stride < 0) ? unsigned(-m_stride) : unsigned(m_stride);
}
AGG_INLINE unsigned stride_abs() const { return (m_stride < 0) ? unsigned(-m_stride) : unsigned(m_stride); }
//--------------------------------------------------------------------
AGG_INLINE T* row_ptr(int, int y, unsigned)
{
return m_rows[y];
}
AGG_INLINE T* row_ptr(int, int y, unsigned) { return m_rows[y]; }
AGG_INLINE T* row_ptr(int y) { return m_rows[y]; }
AGG_INLINE const T* row_ptr(int y) const { return m_rows[y]; }
AGG_INLINE row_data row (int y) const
{
return row_data(0, m_width-1, m_rows[y]);
}
AGG_INLINE row_data row(int y) const { return row_data(0, m_width - 1, m_rows[y]); }
//--------------------------------------------------------------------
T const* const* rows() const { return &m_rows[0]; }
@ -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);
@ -250,11 +231,11 @@ namespace agg
unsigned y;
unsigned w = width();
unsigned stride = stride_abs();
for(y = 0; y < height(); y++)
for (y = 0; y < height(); y++)
{
T* p = row_ptr(0, y, w);
unsigned x;
for(x = 0; x < stride; x++)
for (x = 0; x < stride; x++)
{
*p++ = value;
}
@ -268,38 +249,34 @@ namespace agg
unsigned m_width; // Width in pixels
unsigned m_height; // Height in pixels
int m_stride; // Number of bytes per row. Can be < 0
};
};
//========================================================rendering_buffer
//
// The definition of the main type for accessing the rows in the frame
// buffer. It provides functionality to navigate to the rows in a
// rectangular matrix, from top to bottom or from bottom to top depending
// on stride.
//
// row_accessor is cheap to create/destroy, but performs one multiplication
// when calling row_ptr().
//
// row_ptr_cache creates an array of pointers to rows, so, the access
// via row_ptr() may be faster. But it requires memory allocation
// when creating. For example, on typical Intel Pentium hardware
// row_ptr_cache speeds span_image_filter_rgb_nn up to 10%
//
// It's used only in short hand typedefs like pixfmt_rgba32 and can be
// redefined in agg_config.h
// In real applications you can use both, depending on your needs
//------------------------------------------------------------------------
//========================================================rendering_buffer
//
// The definition of the main type for accessing the rows in the frame
// buffer. It provides functionality to navigate to the rows in a
// rectangular matrix, from top to bottom or from bottom to top depending
// on stride.
//
// row_accessor is cheap to create/destroy, but performs one multiplication
// when calling row_ptr().
//
// row_ptr_cache creates an array of pointers to rows, so, the access
// via row_ptr() may be faster. But it requires memory allocation
// when creating. For example, on typical Intel Pentium hardware
// row_ptr_cache speeds span_image_filter_rgb_nn up to 10%
//
// It's used only in short hand typedefs like pixfmt_rgba32 and can be
// redefined in agg_config.h
// In real applications you can use both, depending on your needs
//------------------------------------------------------------------------
#ifdef AGG_RENDERING_BUFFER
typedef AGG_RENDERING_BUFFER rendering_buffer;
typedef AGG_RENDERING_BUFFER rendering_buffer;
#else
typedef row_ptr_cache<int8u> rendering_buffer;
//typedef row_accessor<int8u> rendering_buffer;
typedef row_ptr_cache<int8u> rendering_buffer;
// typedef row_accessor<int8u> rendering_buffer;
#endif
}
} // namespace agg
#endif

76
deps/agg/include/agg_rendering_buffer_dynarow.h vendored
View file

@ -22,44 +22,38 @@
#include "agg_array.h"
namespace agg
{
namespace agg {
//===============================================rendering_buffer_dynarow
// Rendering buffer class with dynamic allocation of the rows.
// The rows are allocated as needed when requesting for span_ptr().
// The class automatically calculates min_x and max_x for each row.
// Generally it's more efficient to use this class as a temporary buffer
// for rendering a few lines and then to blend it with another buffer.
//
class rendering_buffer_dynarow
{
//===============================================rendering_buffer_dynarow
// Rendering buffer class with dynamic allocation of the rows.
// The rows are allocated as needed when requesting for span_ptr().
// The class automatically calculates min_x and max_x for each row.
// Generally it's more efficient to use this class as a temporary buffer
// for rendering a few lines and then to blend it with another buffer.
//
class rendering_buffer_dynarow
{
public:
typedef row_info<int8u> row_data;
//-------------------------------------------------------------------
~rendering_buffer_dynarow()
{
init(0,0,0);
}
~rendering_buffer_dynarow() { init(0, 0, 0); }
//-------------------------------------------------------------------
rendering_buffer_dynarow() :
m_rows(),
m_width(0),
m_height(0),
m_byte_width(0)
{
}
rendering_buffer_dynarow()
: m_rows()
, m_width(0)
, m_height(0)
, m_byte_width(0)
{}
// Allocate and clear the buffer
//--------------------------------------------------------------------
rendering_buffer_dynarow(unsigned width, unsigned height,
unsigned byte_width) :
m_rows(height),
m_width(width),
m_height(height),
m_byte_width(byte_width)
rendering_buffer_dynarow(unsigned width, unsigned height, unsigned byte_width)
: m_rows(height)
, m_width(width)
, m_height(height)
, m_byte_width(byte_width)
{
memset(&m_rows[0], 0, sizeof(row_data) * height);
}
@ -69,11 +63,11 @@ namespace agg
void init(unsigned width, unsigned height, unsigned byte_width)
{
unsigned i;
for(i = 0; i < m_height; ++i)
for (i = 0; i < m_height; ++i)
{
pod_allocator<int8u>::deallocate((int8u*)m_rows[i].ptr, m_byte_width);
}
if(width && height)
if (width && height)
{
m_width = width;
m_height = height;
@ -95,10 +89,16 @@ namespace agg
{
row_data* r = &m_rows[y];
int x2 = x + len - 1;
if(r->ptr)
if (r->ptr)
{
if(x < r->x1) { r->x1 = x; }
if(x2 > r->x2) { r->x2 = x2; }
if (x < r->x1)
{
r->x1 = x;
}
if (x2 > r->x2)
{
r->x2 = x2;
}
}
else
{
@ -114,13 +114,13 @@ namespace agg
//--------------------------------------------------------------------
const int8u* row_ptr(int y) const { return m_rows[y].ptr; }
int8u* row_ptr(int y) { return row_ptr(0, y, m_width); }
row_data row (int y) const { return m_rows[y]; }
row_data row(int y) const { return m_rows[y]; }
private:
//--------------------------------------------------------------------
// Prohibit copying
rendering_buffer_dynarow(const rendering_buffer_dynarow&);
const rendering_buffer_dynarow& operator = (const rendering_buffer_dynarow&);
const rendering_buffer_dynarow& operator=(const rendering_buffer_dynarow&);
private:
//--------------------------------------------------------------------
@ -128,10 +128,8 @@ namespace agg
unsigned m_width; // Width in pixels
unsigned m_height; // Height in pixels
unsigned m_byte_width; // Width in bytes
};
}
};
} // namespace agg
#endif

21
deps/agg/include/agg_rounded_rect.h vendored
View file

@ -23,14 +23,13 @@
#include "agg_basics.h"
#include "agg_arc.h"
namespace agg
namespace agg {
//------------------------------------------------------------rounded_rect
//
// See Implemantation agg_rounded_rect.cpp
//
class rounded_rect
{
//------------------------------------------------------------rounded_rect
//
// See Implemantation agg_rounded_rect.cpp
//
class rounded_rect
{
public:
rounded_rect() {}
rounded_rect(double x1, double y1, double x2, double y2, double r);
@ -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,
double rx3, double ry3, double rx4, double ry4);
void radius(double rx1, double ry1, double rx2, double ry2, double rx3, double ry3, double rx4, double ry4);
void normalize_radius();
void approximation_scale(double s) { m_arc.approximation_scale(s); }
@ -64,9 +62,8 @@ namespace agg
double m_ry4;
unsigned m_status;
arc m_arc;
};
};
}
} // namespace agg
#endif

108
deps/agg/include/agg_scanline_bin.h vendored
View file

@ -30,18 +30,17 @@
#include "agg_array.h"
namespace agg
{
namespace agg {
//=============================================================scanline_bin
//
// This is binary scaline container which supports the interface
// used in the rasterizer::render(). See description of agg_scanline_u8
// for details.
//
//------------------------------------------------------------------------
class scanline_bin
{
//=============================================================scanline_bin
//
// This is binary scaline container which supports the interface
// used in the rasterizer::render(). See description of agg_scanline_u8
// for details.
//
//------------------------------------------------------------------------
class scanline_bin
{
public:
typedef int32 coord_type;
@ -54,18 +53,17 @@ namespace agg
typedef const span* const_iterator;
//--------------------------------------------------------------------
scanline_bin() :
m_last_x(0x7FFFFFF0),
m_spans(),
m_cur_span(0)
{
}
scanline_bin()
: m_last_x(0x7FFFFFF0)
, m_spans()
, m_cur_span(0)
{}
//--------------------------------------------------------------------
void reset(int min_x, int max_x)
{
unsigned max_len = max_x - min_x + 3;
if(max_len > m_spans.size())
if (max_len > m_spans.size())
{
m_spans.resize(max_len);
}
@ -76,7 +74,7 @@ namespace agg
//--------------------------------------------------------------------
void add_cell(int x, unsigned)
{
if(x == m_last_x+1)
if (x == m_last_x + 1)
{
m_cur_span->len++;
}
@ -92,7 +90,7 @@ namespace agg
//--------------------------------------------------------------------
void add_span(int x, unsigned len, unsigned)
{
if(x == m_last_x+1)
if (x == m_last_x + 1)
{
m_cur_span->len = (int16)(m_cur_span->len + len);
}
@ -106,16 +104,10 @@ namespace agg
}
//--------------------------------------------------------------------
void add_cells(int x, unsigned len, const void*)
{
add_span(x, len, 0);
}
void add_cells(int x, unsigned len, const void*) { add_span(x, len, 0); }
//--------------------------------------------------------------------
void finalize(int y)
{
m_y = y;
}
void finalize(int y) { m_y = y; }
//--------------------------------------------------------------------
void reset_spans()
@ -131,22 +123,17 @@ namespace agg
private:
scanline_bin(const scanline_bin&);
const scanline_bin operator = (const scanline_bin&);
const scanline_bin operator=(const scanline_bin&);
int m_last_x;
int m_y;
pod_array<span> m_spans;
span* m_cur_span;
};
};
//===========================================================scanline32_bin
class scanline32_bin
{
//===========================================================scanline32_bin
class scanline32_bin
{
public:
typedef int32 coord_type;
@ -154,36 +141,40 @@ 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) :
m_spans(spans),
m_span_idx(0)
const_iterator(const span_array_type& spans)
: m_spans(spans)
, m_span_idx(0)
{}
const span& operator*() const { return m_spans[m_span_idx]; }
const span* operator->() const { return &m_spans[m_span_idx]; }
void operator ++ () { ++m_span_idx; }
void operator++() { ++m_span_idx; }
private:
const span_array_type& m_spans;
unsigned m_span_idx;
};
//--------------------------------------------------------------------
scanline32_bin() : m_max_len(0), m_last_x(0x7FFFFFF0) {}
scanline32_bin()
: m_max_len(0)
, m_last_x(0x7FFFFFF0)
{}
//--------------------------------------------------------------------
void reset(int, int)
@ -195,7 +186,7 @@ namespace agg
//--------------------------------------------------------------------
void add_cell(int x, unsigned)
{
if(x == m_last_x+1)
if (x == m_last_x + 1)
{
m_spans.last().len++;
}
@ -209,7 +200,7 @@ namespace agg
//--------------------------------------------------------------------
void add_span(int x, unsigned len, unsigned)
{
if(x == m_last_x+1)
if (x == m_last_x + 1)
{
m_spans.last().len += coord_type(len);
}
@ -221,16 +212,10 @@ namespace agg
}
//--------------------------------------------------------------------
void add_cells(int x, unsigned len, const void*)
{
add_span(x, len, 0);
}
void add_cells(int x, unsigned len, const void*) { add_span(x, len, 0); }
//--------------------------------------------------------------------
void finalize(int y)
{
m_y = y;
}
void finalize(int y) { m_y = y; }
//--------------------------------------------------------------------
void reset_spans()
@ -246,19 +231,14 @@ namespace agg
private:
scanline32_bin(const scanline32_bin&);
const scanline32_bin operator = (const scanline32_bin&);
const scanline32_bin operator=(const scanline32_bin&);
unsigned m_max_len;
int m_last_x;
int m_y;
span_array_type m_spans;
};
}
};
} // namespace agg
#endif

1449
deps/agg/include/agg_scanline_boolean_algebra.h vendored
View file

File diff suppressed because it is too large Load diff

122
deps/agg/include/agg_scanline_p.h vendored
View file

@ -29,18 +29,17 @@
#include "agg_array.h"
namespace agg
{
namespace agg {
//=============================================================scanline_p8
//
// This is a general purpose scaline container which supports the interface
// used in the rasterizer::render(). See description of scanline_u8
// for details.
//
//------------------------------------------------------------------------
class scanline_p8
{
//=============================================================scanline_p8
//
// This is a general purpose scaline container which supports the interface
// used in the rasterizer::render(). See description of scanline_u8
// for details.
//
//------------------------------------------------------------------------
class scanline_p8
{
public:
typedef scanline_p8 self_type;
typedef int8u cover_type;
@ -57,20 +56,19 @@ namespace agg
typedef span* iterator;
typedef const span* const_iterator;
scanline_p8() :
m_last_x(0x7FFFFFF0),
m_covers(),
m_cover_ptr(0),
m_spans(),
m_cur_span(0)
{
}
scanline_p8()
: m_last_x(0x7FFFFFF0)
, m_covers()
, m_cover_ptr(0)
, m_spans()
, m_cur_span(0)
{}
//--------------------------------------------------------------------
void reset(int min_x, int max_x)
{
unsigned max_len = max_x - min_x + 3;
if(max_len > m_spans.size())
if (max_len > m_spans.size())
{
m_spans.resize(max_len);
m_covers.resize(max_len);
@ -85,7 +83,7 @@ namespace agg
void add_cell(int x, unsigned cover)
{
*m_cover_ptr = (cover_type)cover;
if(x == m_last_x+1 && m_cur_span->len > 0)
if (x == m_last_x + 1 && m_cur_span->len > 0)
{
m_cur_span->len++;
}
@ -104,7 +102,7 @@ namespace agg
void add_cells(int x, unsigned len, const cover_type* covers)
{
memcpy(m_cover_ptr, covers, len * sizeof(cover_type));
if(x == m_last_x+1 && m_cur_span->len > 0)
if (x == m_last_x + 1 && m_cur_span->len > 0)
{
m_cur_span->len += (int16)len;
}
@ -122,9 +120,7 @@ namespace agg
//--------------------------------------------------------------------
void add_span(int x, unsigned len, unsigned cover)
{
if(x == m_last_x+1 &&
m_cur_span->len < 0 &&
cover == *m_cur_span->covers)
if (x == m_last_x + 1 && 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)
{
m_y = y;
}
void finalize(int y) { m_y = y; }
//--------------------------------------------------------------------
void reset_spans()
@ -161,7 +154,7 @@ namespace agg
private:
scanline_p8(const self_type&);
const self_type& operator = (const self_type&);
const self_type& operator=(const self_type&);
int m_last_x;
int m_y;
@ -169,18 +162,11 @@ namespace agg
cover_type* m_cover_ptr;
pod_array<span> m_spans;
span* m_cur_span;
};
};
//==========================================================scanline32_p8
class scanline32_p8
{
//==========================================================scanline32_p8
class scanline32_p8
{
public:
typedef scanline32_p8 self_type;
typedef int8u cover_type;
@ -189,8 +175,11 @@ namespace agg
struct span
{
span() {}
span(coord_type x_, coord_type len_, const cover_type* covers_) :
x(x_), len(len_), covers(covers_) {}
span(coord_type x_, coord_type len_, const cover_type* covers_)
: x(x_)
, len(len_)
, covers(covers_)
{}
coord_type x;
coord_type len; // If negative, it's a solid span, covers is valid
@ -198,20 +187,19 @@ namespace agg
};
typedef pod_bvector<span, 4> span_array_type;
//--------------------------------------------------------------------
class const_iterator
{
public:
const_iterator(const span_array_type& spans) :
m_spans(spans),
m_span_idx(0)
const_iterator(const span_array_type& spans)
: m_spans(spans)
, m_span_idx(0)
{}
const span& operator*() const { return m_spans[m_span_idx]; }
const span* operator->() const { return &m_spans[m_span_idx]; }
void operator ++ () { ++m_span_idx; }
void operator++() { ++m_span_idx; }
private:
const span_array_type& m_spans;
@ -219,19 +207,18 @@ namespace agg
};
//--------------------------------------------------------------------
scanline32_p8() :
m_max_len(0),
m_last_x(0x7FFFFFF0),
m_covers(),
m_cover_ptr(0)
{
}
scanline32_p8()
: m_max_len(0)
, m_last_x(0x7FFFFFF0)
, m_covers()
, m_cover_ptr(0)
{}
//--------------------------------------------------------------------
void reset(int min_x, int max_x)
{
unsigned max_len = max_x - min_x + 3;
if(max_len > m_covers.size())
if (max_len > m_covers.size())
{
m_covers.resize(max_len);
}
@ -244,7 +231,7 @@ namespace agg
void add_cell(int x, unsigned cover)
{
*m_cover_ptr = cover_type(cover);
if(x == m_last_x+1 && m_spans.size() && m_spans.last().len > 0)
if (x == m_last_x + 1 && m_spans.size() && m_spans.last().len > 0)
{
m_spans.last().len++;
}
@ -260,7 +247,7 @@ namespace agg
void add_cells(int x, unsigned len, const cover_type* covers)
{
memcpy(m_cover_ptr, covers, len * sizeof(cover_type));
if(x == m_last_x+1 && m_spans.size() && m_spans.last().len > 0)
if (x == m_last_x + 1 && m_spans.size() && m_spans.last().len > 0)
{
m_spans.last().len += coord_type(len);
}
@ -275,10 +262,7 @@ namespace agg
//--------------------------------------------------------------------
void add_span(int x, unsigned len, unsigned cover)
{
if(x == m_last_x+1 &&
m_spans.size() &&
m_spans.last().len < 0 &&
cover == *m_spans.last().covers)
if (x == m_last_x + 1 && m_spans.size() && m_spans.last().len < 0 && cover == *m_spans.last().covers)
{
m_spans.last().len -= coord_type(len);
}
@ -291,10 +275,7 @@ namespace agg
}
//--------------------------------------------------------------------
void finalize(int y)
{
m_y = y;
}
void finalize(int y) { m_y = y; }
//--------------------------------------------------------------------
void reset_spans()
@ -311,7 +292,7 @@ namespace agg
private:
scanline32_p8(const self_type&);
const self_type& operator = (const self_type&);
const self_type& operator=(const self_type&);
unsigned m_max_len;
int m_last_x;
@ -319,11 +300,8 @@ namespace agg
pod_array<cover_type> m_covers;
cover_type* m_cover_ptr;
span_array_type m_spans;
};
}
};
} // namespace agg
#endif

310
deps/agg/include/agg_scanline_storage_aa.h vendored
View file

@ -29,13 +29,12 @@
#include <cmath>
#include "agg_array.h"
namespace agg {
namespace agg
//----------------------------------------------scanline_cell_storage
template<class T>
class scanline_cell_storage
{
//----------------------------------------------scanline_cell_storage
template<class T> class scanline_cell_storage
{
struct extra_span
{
unsigned len;
@ -46,30 +45,25 @@ namespace agg
typedef T value_type;
//---------------------------------------------------------------
~scanline_cell_storage()
{
remove_all();
}
~scanline_cell_storage() { remove_all(); }
//---------------------------------------------------------------
scanline_cell_storage() :
m_cells(128-2),
m_extra_storage()
scanline_cell_storage()
: m_cells(128 - 2)
, m_extra_storage()
{}
// Copying
//---------------------------------------------------------------
scanline_cell_storage(const scanline_cell_storage<T>& v) :
m_cells(v.m_cells),
m_extra_storage()
scanline_cell_storage(const scanline_cell_storage<T>& v)
: m_cells(v.m_cells)
, m_extra_storage()
{
copy_extra_storage(v);
}
//---------------------------------------------------------------
const scanline_cell_storage<T>&
operator = (const scanline_cell_storage<T>& v)
const scanline_cell_storage<T>& operator=(const scanline_cell_storage<T>& v)
{
remove_all();
m_cells = v.m_cells;
@ -81,10 +75,9 @@ namespace agg
void remove_all()
{
int i;
for(i = m_extra_storage.size()-1; i >= 0; --i)
for (i = m_extra_storage.size() - 1; i >= 0; --i)
{
pod_allocator<T>::deallocate(m_extra_storage[i].ptr,
m_extra_storage[i].len);
pod_allocator<T>::deallocate(m_extra_storage[i].ptr, m_extra_storage[i].len);
}
m_extra_storage.remove_all();
m_cells.remove_all();
@ -94,7 +87,7 @@ namespace agg
int add_cells(const T* cells, unsigned num_cells)
{
int idx = m_cells.allocate_continuous_block(num_cells);
if(idx >= 0)
if (idx >= 0)
{
T* ptr = &m_cells[idx];
memcpy(ptr, cells, sizeof(T) * num_cells);
@ -109,28 +102,32 @@ namespace agg
}
//---------------------------------------------------------------
const T* operator [] (int idx) const
const T* operator[](int idx) const
{
if(idx >= 0)
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;
}
//---------------------------------------------------------------
T* operator [] (int idx)
T* operator[](int idx)
{
if(idx >= 0)
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;
}
@ -138,7 +135,7 @@ namespace agg
void copy_extra_storage(const scanline_cell_storage<T>& v)
{
unsigned i;
for(i = 0; i < v.m_extra_storage.size(); ++i)
for (i = 0; i < v.m_extra_storage.size(); ++i)
{
const extra_span& src = v.m_extra_storage[i];
extra_span dst;
@ -151,16 +148,12 @@ namespace agg
pod_bvector<T, 12> m_cells;
pod_bvector<extra_span, 6> m_extra_storage;
};
};
//-----------------------------------------------scanline_storage_aa
template<class T> class scanline_storage_aa
{
//-----------------------------------------------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 embedded_scanline& sl) :
m_storage(sl.m_storage),
m_span_idx(sl.m_scanline.start_span)
const_iterator()
: m_storage(0)
{}
const_iterator(const embedded_scanline& sl)
: m_storage(sl.m_storage)
, m_span_idx(sl.m_scanline.start_span)
{
init_span();
}
@ -208,7 +202,7 @@ namespace agg
const span& operator*() const { return m_span; }
const span* operator->() const { return &m_span; }
void operator ++ ()
void operator++()
{
++m_span_idx;
init_span();
@ -230,10 +224,9 @@ namespace agg
friend class const_iterator;
//-----------------------------------------------------------
embedded_scanline(const scanline_storage_aa& storage) :
m_storage(&storage)
embedded_scanline(const scanline_storage_aa& storage)
: m_storage(&storage)
{
init(0);
}
@ -257,17 +250,17 @@ namespace agg
unsigned m_scanline_idx;
};
//---------------------------------------------------------------
scanline_storage_aa() :
m_covers(),
m_spans(256-2), // Block increment size
m_scanlines(),
m_min_x( 0x7FFFFFFF),
m_min_y( 0x7FFFFFFF),
m_max_x(-0x7FFFFFFF),
m_max_y(-0x7FFFFFFF),
m_cur_scanline(0)
scanline_storage_aa()
: m_covers()
, m_spans(256 - 2)
, // Block increment size
m_scanlines()
, m_min_x(0x7FFFFFFF)
, m_min_y(0x7FFFFFFF)
, m_max_x(-0x7FFFFFFF)
, m_max_y(-0x7FFFFFFF)
, m_cur_scanline(0)
{
m_fake_scanline.y = 0;
m_fake_scanline.num_spans = 0;
@ -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_max_y) m_max_y = y;
if (y < m_min_y)
m_min_y = y;
if (y > m_max_y)
m_max_y = y;
sl_this.y = y;
sl_this.num_spans = sl.num_spans();
@ -306,28 +302,28 @@ namespace agg
typename Scanline::const_iterator span_iterator = sl.begin();
unsigned num_spans = sl_this.num_spans;
for(;;)
for (;;)
{
span_data sp;
sp.x = span_iterator->x;
sp.len = span_iterator->len;
int len = std::abs(int(sp.len));
sp.covers_id =
m_covers.add_cells(span_iterator->covers,
unsigned(len));
sp.covers_id = m_covers.add_cells(span_iterator->covers, unsigned(len));
m_spans.add(sp);
int x1 = sp.x;
int x2 = sp.x + len - 1;
if(x1 < m_min_x) m_min_x = x1;
if(x2 > m_max_x) m_max_x = x2;
if(--num_spans == 0) break;
if (x1 < m_min_x)
m_min_x = x1;
if (x2 > m_max_x)
m_max_x = x2;
if (--num_spans == 0)
break;
++span_iterator;
}
m_scanlines.add(sl_this);
}
//---------------------------------------------------------------
// Iterate scanlines interface
int min_x() const { return m_min_x; }
@ -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(;;)
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;
@ -358,7 +355,7 @@ namespace agg
{
const span_data& sp = m_spans[span_idx++];
const T* covers = covers_by_index(sp.covers_id);
if(sp.len < 0)
if (sp.len < 0)
{
sl.add_span(sp.x, unsigned(-sp.len), *covers);
}
@ -366,10 +363,9 @@ namespace agg
{
sl.add_cells(sp.x, sp.len, covers);
}
}
while(--num_spans);
} while (--num_spans);
++m_cur_scanline;
if(sl.num_spans())
if (sl.num_spans())
{
sl.finalize(sl_this.y);
break;
@ -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;
}
@ -399,7 +394,7 @@ namespace agg
unsigned i;
unsigned size = sizeof(int32) * 4; // min_x, min_y, max_x, max_y
for(i = 0; i < m_scanlines.size(); ++i)
for (i = 0; i < m_scanlines.size(); ++i)
{
size += sizeof(int32) * 3; // scanline size in bytes, Y, num_spans
@ -412,7 +407,7 @@ namespace agg
const span_data& sp = m_spans[span_idx++];
size += sizeof(int32) * 2; // X, span_len
if(sp.len < 0)
if (sp.len < 0)
{
size += sizeof(T); // cover
}
@ -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
{
@ -451,7 +443,7 @@ namespace agg
write_int32(data, max_y()); // max_y
data += sizeof(int32);
for(i = 0; i < m_scanlines.size(); ++i)
for (i = 0; i < m_scanlines.size(); ++i)
{
const scanline_data& sl_this = m_scanlines[i];
@ -477,7 +469,7 @@ namespace agg
write_int32(data, sp.len); // span_len
data += sizeof(int32);
if(sp.len < 0)
if (sp.len < 0)
{
memcpy(data, covers, sizeof(T));
data += sizeof(T);
@ -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
{
return (i < m_spans.size()) ? m_spans[i] : m_fake_span;
}
const span_data& span_by_index(unsigned i) const { return (i < m_spans.size()) ? m_spans[i] : m_fake_span; }
//---------------------------------------------------------------
const T* covers_by_index(int i) const
{
return m_covers[i];
}
const T* covers_by_index(int i) const { return m_covers[i]; }
private:
scanline_cell_storage<T> m_covers;
@ -523,19 +507,16 @@ namespace agg
int m_max_x;
int m_max_y;
unsigned m_cur_scanline;
};
};
typedef scanline_storage_aa<int8u> scanline_storage_aa8; //--------scanline_storage_aa8
typedef scanline_storage_aa<int16u> scanline_storage_aa16; //--------scanline_storage_aa16
typedef scanline_storage_aa<int32u> scanline_storage_aa32; //--------scanline_storage_aa32
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
{
//------------------------------------------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 embedded_scanline& sl) :
m_ptr(sl.m_ptr),
m_dx(sl.m_dx)
const_iterator()
: m_ptr(0)
{}
const_iterator(const embedded_scanline& sl)
: m_ptr(sl.m_ptr)
, m_dx(sl.m_dx)
{
init_span();
}
@ -567,9 +550,9 @@ namespace agg
const span& operator*() const { return m_span; }
const span* operator->() const { return &m_span; }
void operator ++ ()
void operator++()
{
if(m_span.len < 0)
if (m_span.len < 0)
{
m_ptr += sizeof(T);
}
@ -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() :
m_data(0),
m_end(0),
m_ptr(0),
m_dx(0),
m_dy(0),
m_min_x(0x7FFFFFFF),
m_min_y(0x7FFFFFFF),
m_max_x(-0x7FFFFFFF),
m_max_y(-0x7FFFFFFF)
serialized_scanlines_adaptor_aa()
: m_data(0)
, m_end(0)
, m_ptr(0)
, m_dx(0)
, m_dy(0)
, m_min_x(0x7FFFFFFF)
, m_min_y(0x7FFFFFFF)
, m_max_x(-0x7FFFFFFF)
, m_max_y(-0x7FFFFFFF)
{}
//--------------------------------------------------------------------
serialized_scanlines_adaptor_aa(const int8u* data, unsigned size,
double dx, double dy) :
m_data(data),
m_end(data + size),
m_ptr(data),
m_dx(iround(dx)),
m_dy(iround(dy)),
m_min_x(0x7FFFFFFF),
m_min_y(0x7FFFFFFF),
m_max_x(-0x7FFFFFFF),
m_max_y(-0x7FFFFFFF)
serialized_scanlines_adaptor_aa(const int8u* data, unsigned size, double dx, double dy)
: m_data(data)
, m_end(data + size)
, m_ptr(data)
, m_dx(iround(dx))
, m_dy(iround(dy))
, m_min_x(0x7FFFFFFF)
, m_min_y(0x7FFFFFFF)
, m_max_x(-0x7FFFFFFF)
, m_max_y(-0x7FFFFFFF)
{}
//--------------------------------------------------------------------
@ -718,7 +700,7 @@ namespace agg
bool rewind_scanlines()
{
m_ptr = m_data;
if(m_ptr < m_end)
if (m_ptr < m_end)
{
m_min_x = read_int32() + m_dx;
m_min_y = read_int32() + m_dy;
@ -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(;;)
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;
@ -751,7 +735,7 @@ namespace agg
int x = read_int32() + m_dx;
int len = read_int32();
if(len < 0)
if (len < 0)
{
sl.add_span(x, unsigned(-len), *m_ptr);
m_ptr += sizeof(T);
@ -761,10 +745,9 @@ namespace agg
sl.add_cells(x, len, m_ptr);
m_ptr += len * sizeof(T);
}
}
while(--num_spans);
} while (--num_spans);
if(sl.num_spans())
if (sl.num_spans())
{
sl.finalize(y);
break;
@ -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;
}
@ -800,16 +782,14 @@ namespace agg
int m_min_y;
int m_max_x;
int m_max_y;
};
};
typedef serialized_scanlines_adaptor_aa<int8u> serialized_scanlines_adaptor_aa8; //----serialized_scanlines_adaptor_aa8
typedef serialized_scanlines_adaptor_aa<int16u>
serialized_scanlines_adaptor_aa16; //----serialized_scanlines_adaptor_aa16
typedef serialized_scanlines_adaptor_aa<int32u>
serialized_scanlines_adaptor_aa32; //----serialized_scanlines_adaptor_aa32
typedef serialized_scanlines_adaptor_aa<int8u> serialized_scanlines_adaptor_aa8; //----serialized_scanlines_adaptor_aa8
typedef serialized_scanlines_adaptor_aa<int16u> serialized_scanlines_adaptor_aa16; //----serialized_scanlines_adaptor_aa16
typedef serialized_scanlines_adaptor_aa<int32u> serialized_scanlines_adaptor_aa32; //----serialized_scanlines_adaptor_aa32
}
} // namespace agg
#endif

219
deps/agg/include/agg_scanline_storage_bin.h vendored
View file

@ -21,7 +21,6 @@
//
//----------------------------------------------------------------------------
#ifndef AGG_SCANLINE_STORAGE_BIN_INCLUDED
#define AGG_SCANLINE_STORAGE_BIN_INCLUDED
@ -30,13 +29,11 @@
#include <cmath>
#include "agg_array.h"
namespace agg {
namespace agg
//-----------------------------------------------scanline_storage_bin
class scanline_storage_bin
{
//-----------------------------------------------scanline_storage_bin
class scanline_storage_bin
{
public:
//---------------------------------------------------------------
struct span_data
@ -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 embedded_scanline& sl) :
m_storage(sl.m_storage),
m_span_idx(sl.m_scanline.start_span)
const_iterator()
: m_storage(0)
{}
const_iterator(const embedded_scanline& sl)
: m_storage(sl.m_storage)
, m_span_idx(sl.m_scanline.start_span)
{
m_span = m_storage->span_by_index(m_span_idx);
}
@ -74,7 +72,7 @@ namespace agg
const span_data& operator*() const { return m_span; }
const span_data* operator->() const { return &m_span; }
void operator ++ ()
void operator++()
{
++m_span_idx;
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) :
m_storage(&storage)
embedded_scanline(const scanline_storage_bin& storage)
: m_storage(&storage)
{
setup(0);
}
@ -115,16 +112,16 @@ namespace agg
unsigned m_scanline_idx;
};
//---------------------------------------------------------------
scanline_storage_bin() :
m_spans(256-2), // Block increment size
m_scanlines(),
m_min_x( 0x7FFFFFFF),
m_min_y( 0x7FFFFFFF),
m_max_x(-0x7FFFFFFF),
m_max_y(-0x7FFFFFFF),
m_cur_scanline(0)
scanline_storage_bin()
: m_spans(256 - 2)
, // Block increment size
m_scanlines()
, m_min_x(0x7FFFFFFF)
, m_min_y(0x7FFFFFFF)
, m_max_x(-0x7FFFFFFF)
, m_max_y(-0x7FFFFFFF)
, m_cur_scanline(0)
{
m_fake_scanline.y = 0;
m_fake_scanline.num_spans = 0;
@ -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_max_y) m_max_y = y;
if (y < m_min_y)
m_min_y = y;
if (y > m_max_y)
m_max_y = y;
sl_this.y = y;
sl_this.num_spans = sl.num_spans();
@ -161,7 +161,7 @@ namespace agg
typename Scanline::const_iterator span_iterator = sl.begin();
unsigned num_spans = sl_this.num_spans;
for(;;)
for (;;)
{
span_data sp;
sp.x = span_iterator->x;
@ -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(x2 > m_max_x) m_max_x = x2;
if(--num_spans == 0) break;
if (x1 < m_min_x)
m_min_x = x1;
if (x2 > m_max_x)
m_max_x = x2;
if (--num_spans == 0)
break;
++span_iterator;
}
m_scanlines.add(sl_this);
}
//---------------------------------------------------------------
// Iterate scanlines interface
int min_x() const { return m_min_x; }
@ -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(;;)
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,11 +211,10 @@ 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())
if (sl.num_spans())
{
sl.finalize(sl_this.y);
break;
@ -221,29 +223,27 @@ 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
{
unsigned i;
unsigned size = sizeof(int32) * 4; // min_x, min_y, max_x, max_y
for(i = 0; i < m_scanlines.size(); ++i)
for (i = 0; i < m_scanlines.size(); ++i)
{
size += sizeof(int32) * 2 + // Y, num_spans
unsigned(m_scanlines[i].num_spans) * sizeof(int32) * 2; // X, span_len
@ -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
{
@ -276,7 +274,7 @@ namespace agg
write_int32(data, max_y()); // max_y
data += sizeof(int32);
for(i = 0; i < m_scanlines.size(); ++i)
for (i = 0; i < m_scanlines.size(); ++i)
{
const scanline_data& sl_this = m_scanlines[i];
@ -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
{
return (i < m_spans.size()) ? m_spans[i] : m_fake_span;
}
const span_data& span_by_index(unsigned i) const { return (i < m_spans.size()) ? m_spans[i] : m_fake_span; }
private:
pod_bvector<span_data, 10> m_spans;
@ -326,23 +318,11 @@ namespace agg
int m_max_x;
int m_max_y;
unsigned m_cur_scanline;
};
};
//---------------------------------------serialized_scanlines_adaptor_bin
class serialized_scanlines_adaptor_bin
{
//---------------------------------------serialized_scanlines_adaptor_bin
class serialized_scanlines_adaptor_bin
{
public:
typedef bool cover_type;
@ -361,10 +341,12 @@ namespace agg
int32 len;
};
const_iterator() : m_ptr(0) {}
const_iterator(const embedded_scanline& sl) :
m_ptr(sl.m_ptr),
m_dx(sl.m_dx)
const_iterator()
: m_ptr(0)
{}
const_iterator(const embedded_scanline& sl)
: m_ptr(sl.m_ptr)
, m_dx(sl.m_dx)
{
m_span.x = read_int32() + m_dx;
m_span.len = read_int32();
@ -373,7 +355,7 @@ namespace agg
const span& operator*() const { return m_span; }
const span* operator->() const { return &m_span; }
void operator ++ ()
void operator++()
{
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() :
m_data(0),
m_end(0),
m_ptr(0),
m_dx(0),
m_dy(0),
m_min_x(0x7FFFFFFF),
m_min_y(0x7FFFFFFF),
m_max_x(-0x7FFFFFFF),
m_max_y(-0x7FFFFFFF)
serialized_scanlines_adaptor_bin()
: m_data(0)
, m_end(0)
, m_ptr(0)
, m_dx(0)
, m_dy(0)
, m_min_x(0x7FFFFFFF)
, m_min_y(0x7FFFFFFF)
, m_max_x(-0x7FFFFFFF)
, m_max_y(-0x7FFFFFFF)
{}
//--------------------------------------------------------------------
serialized_scanlines_adaptor_bin(const int8u* data, unsigned size,
double dx, double dy) :
m_data(data),
m_end(data + size),
m_ptr(data),
m_dx(iround(dx)),
m_dy(iround(dy)),
m_min_x(0x7FFFFFFF),
m_min_y(0x7FFFFFFF),
m_max_x(-0x7FFFFFFF),
m_max_y(-0x7FFFFFFF)
serialized_scanlines_adaptor_bin(const int8u* data, unsigned size, double dx, double dy)
: m_data(data)
, m_end(data + size)
, m_ptr(data)
, m_dx(iround(dx))
, m_dy(iround(dy))
, m_min_x(0x7FFFFFFF)
, m_min_y(0x7FFFFFFF)
, m_max_x(-0x7FFFFFFF)
, m_max_y(-0x7FFFFFFF)
{}
//--------------------------------------------------------------------
@ -499,7 +480,7 @@ namespace agg
bool rewind_scanlines()
{
m_ptr = m_data;
if(m_ptr < m_end)
if (m_ptr < m_end)
{
m_min_x = read_int32() + m_dx;
m_min_y = read_int32() + m_dy;
@ -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(;;)
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,12 +514,12 @@ 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())
if (sl.num_spans())
{
sl.finalize(y);
break;
@ -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;
}
@ -576,11 +558,8 @@ namespace agg
int m_min_y;
int m_max_x;
int m_max_y;
};
};
}
} // namespace agg
#endif

341
deps/agg/include/agg_scanline_u.h vendored
View file

@ -26,88 +26,87 @@
#include "agg_array.h"
namespace agg
namespace agg {
//=============================================================scanline_u8
//
// Unpacked scanline container class
//
// This class is used to transfer data from a scanline rasterizer
// to the rendering buffer. It's organized very simple. The class stores
// information of horizontal spans to render it into a pixel-map buffer.
// Each span has staring X, length, and an array of bytes that determine the
// cover-values for each pixel.
// Before using this class you should know the minimal and maximal pixel
// coordinates of your scanline. The protocol of using is:
// 1. reset(min_x, max_x)
// 2. add_cell() / add_span() - accumulate scanline.
// When forming one scanline the next X coordinate must be always greater
// than the last stored one, i.e. it works only with ordered coordinates.
// 3. Call finalize(y) and render the scanline.
// 3. Call reset_spans() to prepare for the new scanline.
//
// 4. Rendering:
//
// Scanline provides an iterator class that allows you to extract
// the spans and the cover values for each pixel. Be aware that clipping
// has not been done yet, so you should perform it yourself.
// Use scanline_u8::iterator to render spans:
//-------------------------------------------------------------------------
//
// int y = sl.y(); // Y-coordinate of the scanline
//
// ************************************
// ...Perform vertical clipping here...
// ************************************
//
// scanline_u8::const_iterator span = sl.begin();
//
// unsigned char* row = m_rbuf->row(y); // The the address of the beginning
// // of the current row
//
// unsigned num_spans = sl.num_spans(); // Number of spans. It's guaranteed that
// // num_spans is always greater than 0.
//
// do
// {
// const scanline_u8::cover_type* covers =
// span->covers; // The array of the cover values
//
// int num_pix = span->len; // Number of pixels of the span.
// // Always greater than 0, still it's
// // better to use "int" instead of
// // "unsigned" because it's more
// // convenient for clipping
// int x = span->x;
//
// **************************************
// ...Perform horizontal clipping here...
// ...you have x, covers, and pix_count..
// **************************************
//
// unsigned char* dst = row + x; // Calculate the start address of the row.
// // In this case we assume a simple
// // grayscale image 1-byte per pixel.
// do
// {
// *dst++ = *covers++; // Hypotetical rendering.
// }
// while(--num_pix);
//
// ++span;
// }
// while(--num_spans); // num_spans cannot be 0, so this loop is quite safe
//------------------------------------------------------------------------
//
// The question is: why should we accumulate the whole scanline when we
// could render just separate spans when they're ready?
// That's because using the scanline is generally faster. When is consists
// of more than one span the conditions for the processor cash system
// are better, because switching between two different areas of memory
// (that can be very large) occurs less frequently.
//------------------------------------------------------------------------
class scanline_u8
{
//=============================================================scanline_u8
//
// Unpacked scanline container class
//
// This class is used to transfer data from a scanline rasterizer
// to the rendering buffer. It's organized very simple. The class stores
// information of horizontal spans to render it into a pixel-map buffer.
// Each span has staring X, length, and an array of bytes that determine the
// cover-values for each pixel.
// Before using this class you should know the minimal and maximal pixel
// coordinates of your scanline. The protocol of using is:
// 1. reset(min_x, max_x)
// 2. add_cell() / add_span() - accumulate scanline.
// When forming one scanline the next X coordinate must be always greater
// than the last stored one, i.e. it works only with ordered coordinates.
// 3. Call finalize(y) and render the scanline.
// 3. Call reset_spans() to prepare for the new scanline.
//
// 4. Rendering:
//
// Scanline provides an iterator class that allows you to extract
// the spans and the cover values for each pixel. Be aware that clipping
// has not been done yet, so you should perform it yourself.
// Use scanline_u8::iterator to render spans:
//-------------------------------------------------------------------------
//
// int y = sl.y(); // Y-coordinate of the scanline
//
// ************************************
// ...Perform vertical clipping here...
// ************************************
//
// scanline_u8::const_iterator span = sl.begin();
//
// unsigned char* row = m_rbuf->row(y); // The the address of the beginning
// // of the current row
//
// unsigned num_spans = sl.num_spans(); // Number of spans. It's guaranteed that
// // num_spans is always greater than 0.
//
// do
// {
// const scanline_u8::cover_type* covers =
// span->covers; // The array of the cover values
//
// int num_pix = span->len; // Number of pixels of the span.
// // Always greater than 0, still it's
// // better to use "int" instead of
// // "unsigned" because it's more
// // convenient for clipping
// int x = span->x;
//
// **************************************
// ...Perform horizontal clipping here...
// ...you have x, covers, and pix_count..
// **************************************
//
// unsigned char* dst = row + x; // Calculate the start address of the row.
// // In this case we assume a simple
// // grayscale image 1-byte per pixel.
// do
// {
// *dst++ = *covers++; // Hypotetical rendering.
// }
// while(--num_pix);
//
// ++span;
// }
// while(--num_spans); // num_spans cannot be 0, so this loop is quite safe
//------------------------------------------------------------------------
//
// The question is: why should we accumulate the whole scanline when we
// could render just separate spans when they're ready?
// That's because using the scanline is generally faster. When is consists
// of more than one span the conditions for the processor cash system
// are better, because switching between two different areas of memory
// (that can be very large) occurs less frequently.
//------------------------------------------------------------------------
class scanline_u8
{
public:
typedef scanline_u8 self_type;
typedef int8u cover_type;
@ -125,17 +124,17 @@ namespace agg
typedef const span* const_iterator;
//--------------------------------------------------------------------
scanline_u8() :
m_min_x(0),
m_last_x(0x7FFFFFF0),
m_cur_span(0)
scanline_u8()
: m_min_x(0)
, m_last_x(0x7FFFFFF0)
, m_cur_span(0)
{}
//--------------------------------------------------------------------
void reset(int min_x, int max_x)
{
unsigned max_len = max_x - min_x + 2;
if(max_len > m_spans.size())
if (max_len > m_spans.size())
{
m_spans.resize(max_len);
m_covers.resize(max_len);
@ -150,7 +149,7 @@ namespace agg
{
x -= m_min_x;
m_covers[x] = (cover_type)cover;
if(x == m_last_x+1)
if (x == m_last_x + 1)
{
m_cur_span->len++;
}
@ -169,7 +168,7 @@ namespace agg
{
x -= m_min_x;
memcpy(&m_covers[x], covers, len * sizeof(cover_type));
if(x == m_last_x+1)
if (x == m_last_x + 1)
{
m_cur_span->len += (coord_type)len;
}
@ -188,7 +187,7 @@ namespace agg
{
x -= m_min_x;
memset(&m_covers[x], cover, len);
if(x == m_last_x+1)
if (x == m_last_x + 1)
{
m_cur_span->len += (coord_type)len;
}
@ -203,10 +202,7 @@ namespace agg
}
//--------------------------------------------------------------------
void finalize(int y)
{
m_y = y;
}
void finalize(int y) { m_y = y; }
//--------------------------------------------------------------------
void reset_spans()
@ -223,7 +219,7 @@ namespace agg
private:
scanline_u8(const self_type&);
const self_type& operator = (const self_type&);
const self_type& operator=(const self_type&);
private:
int m_min_x;
@ -232,58 +228,54 @@ namespace agg
pod_array<cover_type> m_covers;
pod_array<span> m_spans;
span* m_cur_span;
};
};
//==========================================================scanline_u8_am
//
// The scanline container with alpha-masking
//
//------------------------------------------------------------------------
template<class AlphaMask>
class scanline_u8_am : public scanline_u8
{
//==========================================================scanline_u8_am
//
// The scanline container with alpha-masking
//
//------------------------------------------------------------------------
template<class AlphaMask>
class scanline_u8_am : public scanline_u8
{
public:
typedef scanline_u8 base_type;
typedef AlphaMask alpha_mask_type;
typedef base_type::cover_type cover_type;
typedef base_type::coord_type coord_type;
scanline_u8_am() : base_type(), m_alpha_mask(0) {}
scanline_u8_am(const AlphaMask& am) : base_type(), m_alpha_mask(&am) {}
scanline_u8_am()
: base_type()
, m_alpha_mask(0)
{}
scanline_u8_am(const AlphaMask& am)
: base_type()
, m_alpha_mask(&am)
{}
//--------------------------------------------------------------------
void finalize(int span_y)
{
base_type::finalize(span_y);
if(m_alpha_mask)
if (m_alpha_mask)
{
typename base_type::iterator span = base_type::begin();
unsigned count = base_type::num_spans();
do
{
m_alpha_mask->combine_hspan(span->x,
base_type::y(),
span->covers,
span->len);
m_alpha_mask->combine_hspan(span->x, base_type::y(), span->covers, span->len);
++span;
}
while(--count);
} while (--count);
}
}
private:
const AlphaMask* m_alpha_mask;
};
};
//===========================================================scanline32_u8
class scanline32_u8
{
//===========================================================scanline32_u8
class scanline32_u8
{
public:
typedef scanline32_u8 self_type;
typedef int8u cover_type;
@ -293,8 +285,11 @@ namespace agg
struct span
{
span() {}
span(coord_type x_, coord_type len_, cover_type* covers_) :
x(x_), len(len_), covers(covers_) {}
span(coord_type x_, coord_type len_, cover_type* covers_)
: x(x_)
, len(len_)
, covers(covers_)
{}
coord_type x;
coord_type len;
@ -307,15 +302,15 @@ namespace agg
class const_iterator
{
public:
const_iterator(const span_array_type& spans) :
m_spans(spans),
m_span_idx(0)
const_iterator(const span_array_type& spans)
: m_spans(spans)
, m_span_idx(0)
{}
const span& operator*() const { return m_spans[m_span_idx]; }
const span* operator->() const { return &m_spans[m_span_idx]; }
void operator ++ () { ++m_span_idx; }
void operator++() { ++m_span_idx; }
private:
const span_array_type& m_spans;
@ -326,35 +321,33 @@ namespace agg
class iterator
{
public:
iterator(span_array_type& spans) :
m_spans(spans),
m_span_idx(0)
iterator(span_array_type& spans)
: m_spans(spans)
, m_span_idx(0)
{}
span& operator*() { return m_spans[m_span_idx]; }
span* operator->() { return &m_spans[m_span_idx]; }
void operator ++ () { ++m_span_idx; }
void operator++() { ++m_span_idx; }
private:
span_array_type& m_spans;
unsigned m_span_idx;
};
//--------------------------------------------------------------------
scanline32_u8() :
m_min_x(0),
m_last_x(0x7FFFFFF0),
m_covers()
scanline32_u8()
: m_min_x(0)
, m_last_x(0x7FFFFFF0)
, m_covers()
{}
//--------------------------------------------------------------------
void reset(int min_x, int max_x)
{
unsigned max_len = max_x - min_x + 2;
if(max_len > m_covers.size())
if (max_len > m_covers.size())
{
m_covers.resize(max_len);
}
@ -368,7 +361,7 @@ namespace agg
{
x -= m_min_x;
m_covers[x] = cover_type(cover);
if(x == m_last_x+1)
if (x == m_last_x + 1)
{
m_spans.last().len++;
}
@ -384,15 +377,13 @@ namespace agg
{
x -= m_min_x;
memcpy(&m_covers[x], covers, len * sizeof(cover_type));
if(x == m_last_x+1)
if (x == m_last_x + 1)
{
m_spans.last().len += coord_type(len);
}
else
{
m_spans.add(span(coord_type(x + m_min_x),
coord_type(len),
&m_covers[x]));
m_spans.add(span(coord_type(x + m_min_x), coord_type(len), &m_covers[x]));
}
m_last_x = x + len - 1;
}
@ -402,24 +393,19 @@ namespace agg
{
x -= m_min_x;
memset(&m_covers[x], cover, len);
if(x == m_last_x+1)
if (x == m_last_x + 1)
{
m_spans.last().len += coord_type(len);
}
else
{
m_spans.add(span(coord_type(x + m_min_x),
coord_type(len),
&m_covers[x]));
m_spans.add(span(coord_type(x + m_min_x), coord_type(len), &m_covers[x]));
}
m_last_x = x + len - 1;
}
//--------------------------------------------------------------------
void finalize(int y)
{
m_y = y;
}
void finalize(int y) { m_y = y; }
//--------------------------------------------------------------------
void reset_spans()
@ -436,7 +422,7 @@ namespace agg
private:
scanline32_u8(const self_type&);
const self_type& operator = (const self_type&);
const self_type& operator=(const self_type&);
private:
int m_min_x;
@ -444,57 +430,52 @@ namespace agg
int m_y;
pod_array<cover_type> m_covers;
span_array_type m_spans;
};
};
//========================================================scanline32_u8_am
//
// The scanline container with alpha-masking
//
//------------------------------------------------------------------------
//========================================================scanline32_u8_am
//
// The scanline container with alpha-masking
//
//------------------------------------------------------------------------
template<class AlphaMask>
class scanline32_u8_am : public scanline32_u8
{
template<class AlphaMask>
class scanline32_u8_am : public scanline32_u8
{
public:
typedef scanline32_u8 base_type;
typedef AlphaMask alpha_mask_type;
typedef base_type::cover_type cover_type;
typedef base_type::coord_type coord_type;
scanline32_u8_am() : base_type(), m_alpha_mask(0) {}
scanline32_u8_am(const AlphaMask& am) : base_type(), m_alpha_mask(&am) {}
scanline32_u8_am()
: base_type()
, m_alpha_mask(0)
{}
scanline32_u8_am(const AlphaMask& am)
: base_type()
, m_alpha_mask(&am)
{}
//--------------------------------------------------------------------
void finalize(int span_y)
{
base_type::finalize(span_y);
if(m_alpha_mask)
if (m_alpha_mask)
{
typename base_type::iterator span = base_type::begin();
unsigned count = base_type::num_spans();
do
{
m_alpha_mask->combine_hspan(span->x,
base_type::y(),
span->covers,
span->len);
m_alpha_mask->combine_hspan(span->x, base_type::y(), span->covers, span->len);
++span;
}
while(--count);
} while (--count);
}
}
private:
const AlphaMask* m_alpha_mask;
};
};
}
} // namespace agg
#endif

30
deps/agg/include/agg_shorten_path.h vendored
View file

@ -19,48 +19,48 @@
#include "agg_basics.h"
#include "agg_vertex_sequence.h"
namespace agg
{
namespace agg {
//===========================================================shorten_path
template<class VertexSequence>
void shorten_path(VertexSequence& vs, double s, unsigned closed = 0)
{
//===========================================================shorten_path
template<class VertexSequence>
void shorten_path(VertexSequence& vs, double s, unsigned closed = 0)
{
typedef typename VertexSequence::value_type vertex_type;
if(s > 0.0 && vs.size() > 1)
if (s > 0.0 && vs.size() > 1)
{
double d;
int n = int(vs.size() - 2);
while(n)
while (n)
{
d = vs[n].dist;
if(d > s) break;
if (d > s)
break;
vs.remove_last();
s -= d;
--n;
}
if(vs.size() < 2)
if (vs.size() < 2)
{
vs.remove_all();
}
else
{
n = vs.size() - 1;
vertex_type& prev = vs[n-1];
vertex_type& prev = vs[n - 1];
vertex_type& last = vs[n];
d = (prev.dist - s) / prev.dist;
double x = prev.x + (last.x - prev.x) * d;
double y = prev.y + (last.y - prev.y) * d;
last.x = x;
last.y = y;
if(!prev(last)) vs.remove_last();
if (!prev(last))
vs.remove_last();
vs.close(closed != 0);
}
}
}
}
} // namespace agg
#endif

75
deps/agg/include/agg_simul_eq.h vendored
View file

@ -22,26 +22,25 @@
#include <cmath>
#include "agg_basics.h"
namespace agg
{
namespace agg {
//=============================================================swap_arrays
template<class T> void swap_arrays(T* a1, T* a2, unsigned n)
{
//=============================================================swap_arrays
template<class T>
void swap_arrays(T* a1, T* a2, unsigned n)
{
unsigned i;
for(i = 0; i < n; i++)
for (i = 0; i < n; i++)
{
T tmp = *a1;
*a1++ = *a2;
*a2++ = tmp;
}
}
}
//============================================================matrix_pivot
template<unsigned Rows, unsigned Cols>
struct matrix_pivot
{
//============================================================matrix_pivot
template<unsigned Rows, unsigned Cols>
struct matrix_pivot
{
static int pivot(double m[Rows][Cols], unsigned row)
{
int k = int(row);
@ -49,71 +48,68 @@ namespace agg
max_val = -1.0;
unsigned i;
for(i = row; i < Rows; i++)
for (i = row; i < Rows; i++)
{
if((tmp = std::fabs(m[i][row])) > max_val && tmp != 0.0)
if ((tmp = std::fabs(m[i][row])) > max_val && tmp != 0.0)
{
max_val = tmp;
k = i;
}
}
if(m[k][row] == 0.0)
if (m[k][row] == 0.0)
{
return -1;
}
if(k != int(row))
if (k != int(row))
{
swap_arrays(m[k], m[row], Cols);
return k;
}
return 0;
}
};
};
//===============================================================simul_eq
template<unsigned Size, unsigned RightCols>
struct simul_eq
{
static bool solve(const double left[Size][Size],
const double right[Size][RightCols],
double result[Size][RightCols])
//===============================================================simul_eq
template<unsigned Size, unsigned RightCols>
struct simul_eq
{
static bool
solve(const double left[Size][Size], const double right[Size][RightCols], double result[Size][RightCols])
{
unsigned i, j, k;
double a1;
double tmp[Size][Size + RightCols];
for(i = 0; i < Size; i++)
for (i = 0; i < Size; i++)
{
for(j = 0; j < Size; j++)
for (j = 0; j < Size; j++)
{
tmp[i][j] = left[i][j];
}
for(j = 0; j < RightCols; j++)
for (j = 0; j < RightCols; j++)
{
tmp[i][Size + j] = right[i][j];
}
}
for(k = 0; k < Size; k++)
for (k = 0; k < Size; k++)
{
if(matrix_pivot<Size, Size + RightCols>::pivot(tmp, k) < 0)
if (matrix_pivot<Size, Size + RightCols>::pivot(tmp, k) < 0)
{
return false; // Singularity....
}
a1 = tmp[k][k];
for(j = k; j < Size + RightCols; j++)
for (j = k; j < Size + RightCols; j++)
{
tmp[k][j] /= a1;
}
for(i = k + 1; i < Size; i++)
for (i = k + 1; i < Size; i++)
{
a1 = tmp[i][k];
for (j = k; j < Size + RightCols; j++)
@ -123,14 +119,13 @@ namespace agg
}
}
for(k = 0; k < RightCols; k++)
for (k = 0; k < RightCols; k++)
{
int m;
for(m = int(Size - 1); m >= 0; m--)
for (m = int(Size - 1); m >= 0; m--)
{
result[m][k] = tmp[m][Size + k];
for(j = m + 1; j < Size; j++)
for (j = m + 1; j < Size; j++)
{
result[m][k] -= tmp[m][j] * result[j][k];
}
@ -138,10 +133,8 @@ namespace agg
}
return true;
}
};
};
}
} // namespace agg
#endif

17
deps/agg/include/agg_span_allocator.h vendored
View file

@ -18,18 +18,18 @@
#include "agg_array.h"
namespace agg
namespace agg {
//----------------------------------------------------------span_allocator
template<class ColorT>
class span_allocator
{
//----------------------------------------------------------span_allocator
template<class ColorT> class span_allocator
{
public:
typedef ColorT color_type;
//--------------------------------------------------------------------
AGG_INLINE color_type* allocate(unsigned span_len)
{
if(span_len > m_span.size())
if (span_len > m_span.size())
{
// To reduce the number of reallocs we align the
// span_len to 256 color elements.
@ -45,10 +45,7 @@ namespace agg
private:
pod_array<color_type> m_span;
};
}
};
} // namespace agg
#endif

18
deps/agg/include/agg_span_converter.h vendored
View file

@ -18,16 +18,18 @@
#include "agg_basics.h"
namespace agg
namespace agg {
//----------------------------------------------------------span_converter
template<class SpanGenerator, class SpanConverter>
class span_converter
{
//----------------------------------------------------------span_converter
template<class SpanGenerator, class SpanConverter> class span_converter
{
public:
typedef typename SpanGenerator::color_type color_type;
span_converter(SpanGenerator& span_gen, SpanConverter& span_cnv) :
m_span_gen(&span_gen), m_span_cnv(&span_cnv) {}
span_converter(SpanGenerator& span_gen, SpanConverter& span_cnv)
: m_span_gen(&span_gen)
, m_span_cnv(&span_cnv)
{}
void attach_generator(SpanGenerator& span_gen) { m_span_gen = &span_gen; }
void attach_converter(SpanConverter& span_cnv) { m_span_cnv = &span_cnv; }
@ -49,8 +51,8 @@ namespace agg
private:
SpanGenerator* m_span_gen;
SpanConverter* m_span_cnv;
};
};
}
} // namespace agg
#endif

102
deps/agg/include/agg_span_gouraud.h vendored
View file

@ -19,12 +19,12 @@
#include "agg_basics.h"
#include "agg_math.h"
namespace agg
{
namespace agg {
//============================================================span_gouraud
template<class ColorT> class span_gouraud
{
//============================================================span_gouraud
template<class ColorT>
class span_gouraud
{
public:
typedef ColorT color_type;
@ -36,8 +36,8 @@ namespace agg
};
//--------------------------------------------------------------------
span_gouraud() :
m_vertex(0)
span_gouraud()
: 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 x2, double y2,
double x3, double y3,
double d) :
m_vertex(0)
double x1,
double y1,
double x2,
double y2,
double x3,
double y3,
double d)
: m_vertex(0)
{
colors(c1, c2, c3);
triangle(x1, y1, x2, y2, x3, y3, d);
@ -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,
double x2, double y2,
double x3, double y3,
double d)
void triangle(double x1, double y1, double x2, double y2, double x3, double y3, double d)
{
m_coord[0].x = m_x[0] = x1;
m_coord[0].y = m_y[0] = y1;
@ -87,24 +87,50 @@ namespace agg
m_cmd[2] = path_cmd_line_to;
m_cmd[3] = path_cmd_stop;
if(d != 0.0)
if (d != 0.0)
{
dilate_triangle(m_coord[0].x, m_coord[0].y,
m_coord[1].x, m_coord[1].y,
m_coord[2].x, m_coord[2].y,
m_x, m_y, d);
dilate_triangle(m_coord[0].x,
m_coord[0].y,
m_coord[1].x,
m_coord[1].y,
m_coord[2].x,
m_coord[2].y,
m_x,
m_y,
d);
calc_intersection(m_x[4], m_y[4], m_x[5], m_y[5],
m_x[0], m_y[0], m_x[1], m_y[1],
&m_coord[0].x, &m_coord[0].y);
calc_intersection(m_x[4],
m_y[4],
m_x[5],
m_y[5],
m_x[0],
m_y[0],
m_x[1],
m_y[1],
&m_coord[0].x,
&m_coord[0].y);
calc_intersection(m_x[0], m_y[0], m_x[1], m_y[1],
m_x[2], m_y[2], m_x[3], m_y[3],
&m_coord[1].x, &m_coord[1].y);
calc_intersection(m_x[0],
m_y[0],
m_x[1],
m_y[1],
m_x[2],
m_y[2],
m_x[3],
m_y[3],
&m_coord[1].x,
&m_coord[1].y);
calc_intersection(m_x[2], m_y[2], m_x[3], m_y[3],
m_x[4], m_y[4], m_x[5], m_y[5],
&m_coord[2].x, &m_coord[2].y);
calc_intersection(m_x[2],
m_y[2],
m_x[3],
m_y[3],
m_x[4],
m_y[4],
m_x[5],
m_y[5],
&m_coord[2].x,
&m_coord[2].y);
m_cmd[3] = path_cmd_line_to;
m_cmd[4] = path_cmd_line_to;
m_cmd[5] = path_cmd_line_to;
@ -114,10 +140,7 @@ namespace agg
//--------------------------------------------------------------------
// Vertex Source Interface to feed the coordinates to the rasterizer
void rewind(unsigned)
{
m_vertex = 0;
}
void rewind(unsigned) { m_vertex = 0; }
//--------------------------------------------------------------------
unsigned vertex(double* x, double* y)
@ -135,21 +158,21 @@ namespace agg
coord[1] = m_coord[1];
coord[2] = m_coord[2];
if(m_coord[0].y > m_coord[2].y)
if (m_coord[0].y > m_coord[2].y)
{
coord[0] = m_coord[2];
coord[2] = m_coord[0];
}
coord_type tmp;
if(coord[0].y > coord[1].y)
if (coord[0].y > coord[1].y)
{
tmp = coord[1];
coord[1] = coord[0];
coord[0] = tmp;
}
if(coord[1].y > coord[2].y)
if (coord[1].y > coord[2].y)
{
tmp = coord[2];
coord[2] = coord[1];
@ -164,9 +187,8 @@ namespace agg
double m_y[8];
unsigned m_cmd[8];
unsigned m_vertex;
};
};
}
} // namespace agg
#endif

79
deps/agg/include/agg_span_gouraud_gray.h vendored
View file

@ -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>
{
//=======================================================span_gouraud_gray
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
{
subpixel_shift = 4,
subpixel_scale = 1 << subpixel_shift
};
enum subpixel_scale_e { 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 > 1.0) k = 1.0;
if (k < 0.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 x2, double y2,
double x3, double y3,
double d = 0) :
base_type(c1, c2, c3, x1, y1, x2, y2, x3, y3, d)
double x1,
double y1,
double x2,
double y2,
double x3,
double y3,
double d = 0)
: base_type(c1, c2, c3, x1, y1, x2, y2, x3, y3, d)
{}
//--------------------------------------------------------------------
@ -108,9 +108,7 @@ namespace agg
m_y2 = int(coord[1].y);
m_swap = cross_product(coord[0].x, coord[0].y,
coord[2].x, coord[2].y,
coord[1].x, coord[1].y) < 0.0;
m_swap = cross_product(coord[0].x, coord[0].y, 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]);
@ -124,7 +122,7 @@ namespace agg
const gray_calc* pc1 = &m_c1;
const gray_calc* pc2 = &m_c2;
if(y < m_y2)
if (y < m_y2)
{
// Bottom part of the triangle (first subtriangle)
//-------------------------
@ -138,7 +136,7 @@ namespace agg
pc2 = &m_c3;
}
if(m_swap)
if (m_swap)
{
// It means that the triangle is oriented clockwise,
// so that we need to swap the controlling structures
@ -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);
@ -176,12 +175,18 @@ namespace agg
// for overflow. It lasts until "start" is positive;
// typically it's 1-2 pixels, but may be more in some cases.
//-------------------------
while(len && start > 0)
while (len && start > 0)
{
vv = v.y();
va = a.y();
if(vv < 0) vv = 0; if(vv > lim) vv = lim;
if(va < 0) va = 0; if(va > lim) va = lim;
if (vv < 0)
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;
@ -197,7 +202,7 @@ namespace agg
// because of anti-aliasing, thus, the interpolators can
// overflow. But while "nlen" is positive we are safe.
//-------------------------
while(len && nlen > 0)
while (len && nlen > 0)
{
span->v = (value_type)v.y();
span->a = (value_type)a.y();
@ -211,12 +216,18 @@ namespace agg
// Ending part; checking for overflow.
// Typically it's 1-2 pixels, but may be more in some cases.
//-------------------------
while(len)
while (len)
{
vv = v.y();
va = a.y();
if(vv < 0) vv = 0; if(vv > lim) vv = lim;
if(va < 0) va = 0; if(va > lim) va = lim;
if (vv < 0)
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,16 +237,14 @@ namespace agg
}
}
private:
bool m_swap;
int m_y2;
gray_calc m_c1;
gray_calc m_c2;
gray_calc m_c3;
};
};
}
} // namespace agg
#endif

100
deps/agg/include/agg_span_gouraud_rgba.h vendored
View file

@ -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>
{
//=======================================================span_gouraud_rgba
template<class ColorT>
class span_gouraud_rgba : public span_gouraud<ColorT>
{
public:
typedef ColorT color_type;
typedef typename ColorT::value_type value_type;
typedef span_gouraud<color_type> base_type;
typedef typename base_type::coord_type coord_type;
enum subpixel_scale_e
{
subpixel_shift = 4,
subpixel_scale = 1 << subpixel_shift
};
enum subpixel_scale_e { 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 > 1.0) k = 1.0;
if (k < 0.0)
k = 0.0;
if (k > 1.0)
k = 1.0;
m_r = m_r1 + iround(m_dr * k);
m_g = m_g1 + iround(m_dg * k);
m_b = m_b1 + iround(m_db * k);
@ -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 x2, double y2,
double x3, double y3,
double d = 0) :
base_type(c1, c2, c3, x1, y1, x2, y2, x3, y3, d)
double x1,
double y1,
double x2,
double y2,
double x3,
double y3,
double d = 0)
: base_type(c1, c2, c3, x1, y1, x2, y2, x3, y3, d)
{}
//--------------------------------------------------------------------
@ -120,9 +121,7 @@ namespace agg
m_y2 = int(coord[1].y);
m_swap = cross_product(coord[0].x, coord[0].y,
coord[2].x, coord[2].y,
coord[1].x, coord[1].y) < 0.0;
m_swap = cross_product(coord[0].x, coord[0].y, coord[2].x, coord[2].y, coord[1].x, coord[1].y) < 0.0;
m_rgba1.init(coord[0], coord[2]);
m_rgba2.init(coord[0], coord[1]);
@ -132,11 +131,11 @@ namespace agg
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
m_rgba1.calc(y);//(m_rgba1.m_1dy > 2) ? m_rgba1.m_y1 : y);
m_rgba1.calc(y); //(m_rgba1.m_1dy > 2) ? m_rgba1.m_y1 : y);
const rgba_calc* pc1 = &m_rgba1;
const rgba_calc* pc2 = &m_rgba2;
if(y <= m_y2)
if (y <= m_y2)
{
// Bottom part of the triangle (first subtriangle)
//-------------------------
@ -150,7 +149,7 @@ namespace agg
pc2 = &m_rgba3;
}
if(m_swap)
if (m_swap)
{
// It means that the triangle is oriented clockwise,
// so that we need to swap the controlling structures
@ -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);
@ -192,16 +192,28 @@ namespace agg
// for overflow. It lasts until "start" is positive;
// typically it's 1-2 pixels, but may be more in some cases.
//-------------------------
while(len && start > 0)
while (len && start > 0)
{
vr = r.y();
vg = g.y();
vb = b.y();
va = a.y();
if(vr < 0) vr = 0; if(vr > lim) vr = lim;
if(vg < 0) vg = 0; if(vg > lim) vg = lim;
if(vb < 0) vb = 0; if(vb > lim) vb = lim;
if(va < 0) va = 0; if(va > lim) va = lim;
if (vr < 0)
vr = 0;
if (vr > lim)
vr = lim;
if (vg < 0)
vg = 0;
if (vg > lim)
vg = lim;
if (vb < 0)
vb = 0;
if (vb > lim)
vb = lim;
if (va < 0)
va = 0;
if (va > lim)
va = lim;
span->r = (value_type)vr;
span->g = (value_type)vg;
span->b = (value_type)vb;
@ -221,7 +233,7 @@ namespace agg
// because of anti-aliasing, thus, the interpolators can
// overflow. But while "nlen" is positive we are safe.
//-------------------------
while(len && nlen > 0)
while (len && nlen > 0)
{
span->r = (value_type)r.y();
span->g = (value_type)g.y();
@ -239,16 +251,28 @@ namespace agg
// Ending part; checking for overflow.
// Typically it's 1-2 pixels, but may be more in some cases.
//-------------------------
while(len)
while (len)
{
vr = r.y();
vg = g.y();
vb = b.y();
va = a.y();
if(vr < 0) vr = 0; if(vr > lim) vr = lim;
if(vg < 0) vg = 0; if(vg > lim) vg = lim;
if(vb < 0) vb = 0; if(vb > lim) vb = lim;
if(va < 0) va = 0; if(va > lim) va = lim;
if (vr < 0)
vr = 0;
if (vr > lim)
vr = lim;
if (vg < 0)
vg = 0;
if (vg > lim)
vg = lim;
if (vb < 0)
vb = 0;
if (vb > lim)
vb = lim;
if (va < 0)
va = 0;
if (va > lim)
va = lim;
span->r = (value_type)vr;
span->g = (value_type)vg;
span->b = (value_type)vb;
@ -268,10 +292,8 @@ namespace agg
rgba_calc m_rgba1;
rgba_calc m_rgba2;
rgba_calc m_rgba3;
};
};
}
} // namespace agg
#endif

272
deps/agg/include/agg_span_gradient.h vendored
View file

@ -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,
class Interpolator,
class GradientF,
class ColorF>
class span_gradient
{
//==========================================================span_gradient
template<class ColorT, class Interpolator, class GradientF, class ColorF>
class span_gradient
{
public:
typedef Interpolator interpolator_type;
typedef ColorT color_type;
enum downscale_shift_e
{
downscale_shift = interpolator_type::subpixel_shift -
gradient_subpixel_shift
};
enum downscale_shift_e { 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) :
m_interpolator(&inter),
m_gradient_function(&gradient_function),
m_color_function(&color_function),
m_d1(iround(d1 * gradient_subpixel_scale)),
m_d2(iround(d2 * gradient_subpixel_scale))
double d1,
double d2)
: m_interpolator(&inter)
, m_gradient_function(&gradient_function)
, m_color_function(&color_function)
, 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;
m_interpolator->begin(x+0.5, y+0.5, len);
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,
y >> downscale_shift, m_d2);
int d = m_gradient_function->calculate(x >> downscale_shift, y >> downscale_shift, m_d2);
d = ((d - m_d1) * (int)m_color_function->size()) / dd;
if(d < 0) d = 0;
if(d >= (int)m_color_function->size()) d = m_color_function->size() - 1;
if (d < 0)
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:
@ -111,27 +101,23 @@ namespace agg
const ColorF* m_color_function;
int m_d1;
int m_d2;
};
};
//=====================================================gradient_linear_color
template<class ColorT>
struct gradient_linear_color
{
//=====================================================gradient_linear_color
template<class ColorT>
struct gradient_linear_color
{
typedef ColorT color_type;
gradient_linear_color() {}
gradient_linear_color(const color_type& c1, const color_type& c2,
unsigned size = 256) :
m_c1(c1), m_c2(c2), m_size(size) {}
gradient_linear_color(const color_type& c1, const color_type& c2, unsigned size = 256)
: m_c1(c1)
, m_c2(c2)
, m_size(size)
{}
unsigned size() const { return m_size; }
color_type operator [] (unsigned v) const
{
return m_c1.gradient(m_c2, double(v) / double(m_size - 1));
}
color_type operator[](unsigned v) const { 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)
{
@ -143,63 +129,51 @@ namespace agg
color_type m_c1;
color_type m_c2;
unsigned m_size;
};
};
//==========================================================gradient_circle
class gradient_circle
{
//==========================================================gradient_circle
class gradient_circle
{
// Actually the same as radial. Just for compatibility
public:
static AGG_INLINE int calculate(int x, int y, int)
{
return int(fast_sqrt(x*x + y*y));
}
};
static AGG_INLINE int calculate(int x, int y, int) { return int(fast_sqrt(x * x + y * y)); }
};
//==========================================================gradient_radial
class gradient_radial
{
public:
static AGG_INLINE int calculate(int x, int y, int) { return int(fast_sqrt(x * x + y * y)); }
};
//==========================================================gradient_radial
class gradient_radial
{
//========================================================gradient_radial_d
class gradient_radial_d
{
public:
static AGG_INLINE int calculate(int x, int y, int)
{
return int(fast_sqrt(x*x + y*y));
return uround(sqrt(double(x) * double(x) + double(y) * double(y)));
}
};
};
//========================================================gradient_radial_d
class gradient_radial_d
{
public:
static AGG_INLINE int calculate(int x, int y, int)
{
return uround(sqrt(double(x)*double(x) + double(y)*double(y)));
}
};
//====================================================gradient_radial_focus
class gradient_radial_focus
{
//====================================================gradient_radial_focus
class gradient_radial_focus
{
public:
//---------------------------------------------------------------------
gradient_radial_focus() :
m_r(100 * gradient_subpixel_scale),
m_fx(0),
m_fy(0)
gradient_radial_focus()
: m_r(100 * gradient_subpixel_scale)
, m_fx(0)
, m_fy(0)
{
update_values();
}
//---------------------------------------------------------------------
gradient_radial_focus(double r, double fx, double fy) :
m_r (iround(r * gradient_subpixel_scale)),
m_fx(iround(fx * gradient_subpixel_scale)),
m_fy(iround(fy * gradient_subpixel_scale))
gradient_radial_focus(double r, double fx, double fy)
: m_r(iround(r * gradient_subpixel_scale))
, m_fx(iround(fx * gradient_subpixel_scale))
, m_fy(iround(fy * gradient_subpixel_scale))
{
update_values();
}
@ -242,10 +216,22 @@ namespace agg
m_fx2 = double(m_fx) * double(m_fx);
m_fy2 = double(m_fy) * double(m_fy);
double d = (m_r2 - (m_fx2 + m_fy2));
if(d == 0)
if (d == 0)
{
if(m_fx) { if(m_fx < 0) ++m_fx; else --m_fx; }
if(m_fy) { if(m_fy < 0) ++m_fy; else --m_fy; }
if (m_fx)
{
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));
@ -260,27 +246,25 @@ namespace agg
double m_fx2;
double m_fy2;
double m_mul;
};
};
//==============================================================gradient_x
class gradient_x
{
//==============================================================gradient_x
class gradient_x
{
public:
static int calculate(int x, int, int) { return x; }
};
};
//==============================================================gradient_y
class gradient_y
{
//==============================================================gradient_y
class gradient_y
{
public:
static int calculate(int, int y, int) { return y; }
};
};
//========================================================gradient_diamond
class gradient_diamond
{
//========================================================gradient_diamond
class gradient_diamond
{
public:
static AGG_INLINE int calculate(int x, int y, int)
{
@ -288,77 +272,77 @@ namespace agg
int ay = std::abs(y);
return ax > ay ? ax : ay;
}
};
};
//=============================================================gradient_xy
class gradient_xy
{
//=============================================================gradient_xy
class gradient_xy
{
public:
static AGG_INLINE int calculate(int x, int y, int d)
{
return std::abs(x) * std::abs(y) / d;
}
};
static AGG_INLINE int calculate(int x, int y, int d) { return std::abs(x) * std::abs(y) / d; }
};
//========================================================gradient_sqrt_xy
class gradient_sqrt_xy
{
//========================================================gradient_sqrt_xy
class gradient_sqrt_xy
{
public:
static AGG_INLINE int calculate(int x, int y, int)
{
return fast_sqrt(std::abs(x) * std::abs(y));
}
};
static AGG_INLINE int calculate(int x, int y, int) { return fast_sqrt(std::abs(x) * std::abs(y)); }
};
//==========================================================gradient_conic
class gradient_conic
{
//==========================================================gradient_conic
class gradient_conic
{
public:
static AGG_INLINE int calculate(int x, int y, int d)
{
return uround(std::fabs(std::atan2(double(y), double(x))) * double(d) / pi);
}
};
};
//=================================================gradient_repeat_adaptor
template<class GradientF> class gradient_repeat_adaptor
{
//=================================================gradient_repeat_adaptor
template<class GradientF>
class gradient_repeat_adaptor
{
public:
gradient_repeat_adaptor(const GradientF& gradient) :
m_gradient(&gradient) {}
gradient_repeat_adaptor(const GradientF& 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;
}
private:
const GradientF* m_gradient;
};
};
//================================================gradient_reflect_adaptor
template<class GradientF> class gradient_reflect_adaptor
{
//================================================gradient_reflect_adaptor
template<class GradientF>
class gradient_reflect_adaptor
{
public:
gradient_reflect_adaptor(const GradientF& gradient) :
m_gradient(&gradient) {}
gradient_reflect_adaptor(const GradientF& 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 >= d) ret = d2 - ret;
if (ret < 0)
ret += d2;
if (ret >= d)
ret = d2 - ret;
return ret;
}
private:
const GradientF* m_gradient;
};
};
}
} // namespace agg
#endif

84
deps/agg/include/agg_span_gradient_alpha.h vendored
View file

@ -18,25 +18,17 @@
#include "agg_span_gradient.h"
namespace agg
namespace agg {
//======================================================span_gradient_alpha
template<class ColorT, class Interpolator, class GradientF, class AlphaF>
class span_gradient_alpha
{
//======================================================span_gradient_alpha
template<class ColorT,
class Interpolator,
class GradientF,
class AlphaF>
class span_gradient_alpha
{
public:
typedef Interpolator interpolator_type;
typedef ColorT color_type;
typedef typename color_type::value_type alpha_type;
enum downscale_shift_e
{
downscale_shift = interpolator_type::subpixel_shift - gradient_subpixel_shift
};
enum downscale_shift_e { 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) :
m_interpolator(&inter),
m_gradient_function(&gradient_function),
m_alpha_function(&alpha_function),
m_d1(iround(d1 * gradient_subpixel_scale)),
m_d2(iround(d2 * gradient_subpixel_scale))
double d1,
double d2)
: m_interpolator(&inter)
, m_gradient_function(&gradient_function)
, m_alpha_function(&alpha_function)
, 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;
m_interpolator->begin(x+0.5, y+0.5, len);
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,
y >> downscale_shift, m_d2);
int d = m_gradient_function->calculate(x >> downscale_shift, y >> downscale_shift, m_d2);
d = ((d - m_d1) * (int)m_alpha_function->size()) / dd;
if(d < 0) d = 0;
if(d >= (int)m_alpha_function->size()) d = m_alpha_function->size() - 1;
if (d < 0)
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:
@ -97,30 +91,30 @@ namespace agg
const AlphaF* m_alpha_function;
int m_d1;
int m_d2;
};
};
//=======================================================gradient_alpha_x
template<class ColorT> struct gradient_alpha_x
{
//=======================================================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; }
};
alpha_type operator[](alpha_type x) const { return x; }
};
//====================================================gradient_alpha_x_u8
struct gradient_alpha_x_u8
{
//====================================================gradient_alpha_x_u8
struct gradient_alpha_x_u8
{
typedef int8u alpha_type;
alpha_type operator [] (alpha_type x) const { return x; }
};
alpha_type operator[](alpha_type x) const { return x; }
};
//==========================================gradient_alpha_one_munus_x_u8
struct gradient_alpha_one_munus_x_u8
{
//==========================================gradient_alpha_one_munus_x_u8
struct gradient_alpha_one_munus_x_u8
{
typedef int8u alpha_type;
alpha_type operator [] (alpha_type x) const { return 255-x; }
};
alpha_type operator[](alpha_type x) const { return 255 - x; }
};
}
} // namespace agg
#endif

150
deps/agg/include/agg_span_image_filter.h vendored
View file

@ -23,28 +23,26 @@
#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
{
//-------------------------------------------------------span_image_filter
template<class Source, class Interpolator>
class span_image_filter
{
public:
typedef Source source_type;
typedef Interpolator interpolator_type;
//--------------------------------------------------------------------
span_image_filter() {}
span_image_filter(source_type& src,
interpolator_type& interpolator,
const image_filter_lut* filter) :
m_src(&src),
m_interpolator(&interpolator),
m_filter(filter),
m_dx_dbl(0.5),
m_dy_dbl(0.5),
m_dx_int(image_subpixel_scale / 2),
m_dy_int(image_subpixel_scale / 2)
span_image_filter(source_type& src, interpolator_type& interpolator, const image_filter_lut* filter)
: m_src(&src)
, m_interpolator(&interpolator)
, m_filter(filter)
, m_dx_dbl(0.5)
, m_dy_dbl(0.5)
, m_dx_int(image_subpixel_scale / 2)
, m_dy_int(image_subpixel_scale / 2)
{}
void attach(source_type& v) { m_src = &v; }
@ -84,39 +82,32 @@ namespace agg
double m_dy_dbl;
unsigned m_dx_int;
unsigned m_dy_int;
};
};
//==============================================span_image_resample_affine
template<class Source>
class span_image_resample_affine :
public span_image_filter<Source, span_interpolator_linear<trans_affine> >
{
//==============================================span_image_resample_affine
template<class Source>
class span_image_resample_affine : public span_image_filter<Source, span_interpolator_linear<trans_affine>>
{
public:
typedef Source source_type;
typedef span_interpolator_linear<trans_affine> interpolator_type;
typedef span_image_filter<source_type, interpolator_type> base_type;
//--------------------------------------------------------------------
span_image_resample_affine() :
m_scale_limit(200.0),
m_blur_x(1.0),
m_blur_y(1.0)
span_image_resample_affine()
: m_scale_limit(200.0)
, m_blur_x(1.0)
, m_blur_y(1.0)
{}
//--------------------------------------------------------------------
span_image_resample_affine(source_type& src,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, &filter),
m_scale_limit(200.0),
m_blur_x(1.0),
m_blur_y(1.0)
span_image_resample_affine(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
: base_type(src, inter, &filter)
, m_scale_limit(200.0)
, m_blur_x(1.0)
, m_blur_y(1.0)
{}
//--------------------------------------------------------------------
int scale_limit() const { return uround(m_scale_limit); }
void scale_limit(int v) { m_scale_limit = v; }
@ -136,29 +127,35 @@ namespace agg
base_type::interpolator().transformer().scaling_abs(&scale_x, &scale_y);
if(scale_x * scale_y > m_scale_limit)
if (scale_x * scale_y > m_scale_limit)
{
scale_x = scale_x * m_scale_limit / (scale_x * scale_y);
scale_y = scale_y * m_scale_limit / (scale_x * scale_y);
}
if(scale_x < 1) scale_x = 1;
if(scale_y < 1) scale_y = 1;
if (scale_x < 1)
scale_x = 1;
if (scale_y < 1)
scale_y = 1;
if(scale_x > m_scale_limit) scale_x = m_scale_limit;
if(scale_y > m_scale_limit) scale_y = m_scale_limit;
if (scale_x > m_scale_limit)
scale_x = m_scale_limit;
if (scale_y > m_scale_limit)
scale_y = m_scale_limit;
scale_x *= m_blur_x;
scale_y *= m_blur_y;
if(scale_x < 1) scale_x = 1;
if(scale_y < 1) scale_y = 1;
if (scale_x < 1)
scale_x = 1;
if (scale_y < 1)
scale_y = 1;
m_rx = uround( scale_x * double(image_subpixel_scale));
m_rx_inv = uround(1.0/scale_x * double(image_subpixel_scale));
m_rx = uround(scale_x * double(image_subpixel_scale));
m_rx_inv = uround(1.0 / scale_x * double(image_subpixel_scale));
m_ry = uround( scale_y * double(image_subpixel_scale));
m_ry_inv = uround(1.0/scale_y * double(image_subpixel_scale));
m_ry = uround(scale_y * double(image_subpixel_scale));
m_ry_inv = uround(1.0 / scale_y * double(image_subpixel_scale));
}
protected:
@ -171,35 +168,30 @@ namespace agg
double m_scale_limit;
double m_blur_x;
double m_blur_y;
};
};
//=====================================================span_image_resample
template<class Source, class Interpolator>
class span_image_resample :
public span_image_filter<Source, Interpolator>
{
//=====================================================span_image_resample
template<class Source, class Interpolator>
class span_image_resample : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
typedef Interpolator interpolator_type;
typedef span_image_filter<source_type, interpolator_type> base_type;
//--------------------------------------------------------------------
span_image_resample() :
m_scale_limit(20),
m_blur_x(image_subpixel_scale),
m_blur_y(image_subpixel_scale)
span_image_resample()
: m_scale_limit(20)
, m_blur_x(image_subpixel_scale)
, m_blur_y(image_subpixel_scale)
{}
//--------------------------------------------------------------------
span_image_resample(source_type& src,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, &filter),
m_scale_limit(20),
m_blur_x(image_subpixel_scale),
m_blur_y(image_subpixel_scale)
span_image_resample(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
: base_type(src, inter, &filter)
, m_scale_limit(20)
, m_blur_x(image_subpixel_scale)
, m_blur_y(image_subpixel_scale)
{}
//--------------------------------------------------------------------
@ -211,36 +203,36 @@ 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 =
m_blur_y = uround(v * double(image_subpixel_scale)); }
void blur(double v) { m_blur_x = m_blur_y = uround(v * double(image_subpixel_scale)); }
protected:
AGG_INLINE void adjust_scale(int* rx, int* ry)
{
if(*rx < image_subpixel_scale) *rx = image_subpixel_scale;
if(*ry < image_subpixel_scale) *ry = image_subpixel_scale;
if(*rx > image_subpixel_scale * m_scale_limit)
if (*rx < image_subpixel_scale)
*rx = image_subpixel_scale;
if (*ry < image_subpixel_scale)
*ry = image_subpixel_scale;
if (*rx > image_subpixel_scale * m_scale_limit)
{
*rx = image_subpixel_scale * m_scale_limit;
}
if(*ry > image_subpixel_scale * m_scale_limit)
if (*ry > image_subpixel_scale * m_scale_limit)
{
*ry = image_subpixel_scale * m_scale_limit;
}
*rx = (*rx * m_blur_x) >> image_subpixel_shift;
*ry = (*ry * m_blur_y) >> image_subpixel_shift;
if(*rx < image_subpixel_scale) *rx = image_subpixel_scale;
if(*ry < image_subpixel_scale) *ry = image_subpixel_scale;
if (*rx < image_subpixel_scale)
*rx = image_subpixel_scale;
if (*ry < image_subpixel_scale)
*ry = image_subpixel_scale;
}
int m_scale_limit;
int m_blur_x;
int m_blur_y;
};
};
}
} // namespace agg
#endif

385
deps/agg/include/agg_span_image_filter_gray.h vendored
View file

@ -27,15 +27,12 @@
#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 : public span_image_filter<Source, Interpolator>
{
//==============================================span_image_filter_gray_nn
template<class Source, class Interpolator>
class span_image_filter_gray_nn :
public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
typedef typename source_type::color_type color_type;
@ -43,45 +40,34 @@ 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
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { 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,
interpolator_type& inter) :
base_type(src, inter, 0)
span_image_filter_gray_nn(source_type& src, interpolator_type& inter)
: base_type(src, inter, 0)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
do
{
base_type::interpolator().coordinates(&x, &y);
span->v = *(const value_type*)
base_type::source().span(x >> image_subpixel_shift,
y >> image_subpixel_shift,
1);
span->v =
*(const value_type*)base_type::source().span(x >> image_subpixel_shift, y >> image_subpixel_shift, 1);
span->a = base_mask;
++span;
++base_type::interpolator();
} while(--len);
} while (--len);
}
};
};
//=========================================span_image_filter_gray_bilinear
template<class Source, class Interpolator>
class span_image_filter_gray_bilinear :
public span_image_filter<Source, Interpolator>
{
//=========================================span_image_filter_gray_bilinear
template<class Source, class Interpolator>
class span_image_filter_gray_bilinear : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
typedef typename source_type::color_type color_type;
@ -89,27 +75,20 @@ 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
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { 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,
interpolator_type& inter) :
base_type(src, inter, 0)
span_image_filter_gray_bilinear(source_type& src, interpolator_type& inter)
: base_type(src, inter, 0)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
calc_type fg;
const value_type *fg_ptr;
const value_type* fg_ptr;
do
{
int x_hr;
@ -145,16 +124,14 @@ namespace agg
++span;
++base_type::interpolator();
} while(--len);
} while (--len);
}
};
};
//====================================span_image_filter_gray_bilinear_clip
template<class Source, class Interpolator>
class span_image_filter_gray_bilinear_clip :
public span_image_filter<Source, Interpolator>
{
//====================================span_image_filter_gray_bilinear_clip
template<class Source, class Interpolator>
class span_image_filter_gray_bilinear_clip : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
typedef typename source_type::color_type color_type;
@ -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
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { 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,
const color_type& back_color,
interpolator_type& inter) :
base_type(src, inter, 0),
m_back_color(back_color)
span_image_filter_gray_bilinear_clip(source_type& src, const color_type& back_color, interpolator_type& inter)
: base_type(src, inter, 0)
, m_back_color(back_color)
{}
const color_type& background_color() const { return m_back_color; }
void background_color(const color_type& v) { m_back_color = v; }
@ -182,14 +153,13 @@ namespace agg
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
calc_type fg;
calc_type src_alpha;
value_type back_v = m_back_color.v;
value_type back_a = m_back_color.a;
const value_type *fg_ptr;
const value_type* fg_ptr;
int maxx = base_type::source().width() - 1;
int maxy = base_type::source().height() - 1;
@ -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 &&
x_lr < maxx && y_lr < maxy)
if (x_lr >= 0 && y_lr >= 0 && 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 ||
x_lr > maxx || y_lr > maxy)
if (x_lr < -1 || y_lr < -1 || x_lr > maxx || y_lr > maxy)
{
fg = back_v;
src_alpha = back_a;
}
else
{
fg =
src_alpha = image_subpixel_scale * image_subpixel_scale / 2;
fg = 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) *
(image_subpixel_scale - y_hr);
if(x_lr >= 0 && y_lr >= 0 &&
x_lr <= maxx && y_lr <= maxy)
weight = (image_subpixel_scale - x_hr) * (image_subpixel_scale - y_hr);
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg += weight *
*((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
fg += weight * *((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 &&
x_lr <= maxx && y_lr <= maxy)
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg += weight *
*((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
fg += weight * *((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 &&
x_lr <= maxx && y_lr <= maxy)
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg += weight *
*((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
fg += weight * *((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 &&
x_lr <= maxx && y_lr <= maxy)
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg += weight *
*((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
fg += weight * *((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
src_alpha += weight * base_mask;
}
else
@ -319,19 +277,17 @@ namespace agg
++span;
++base_type::interpolator();
} while(--len);
} while (--len);
}
private:
color_type m_back_color;
};
};
//==============================================span_image_filter_gray_2x2
template<class Source, class Interpolator>
class span_image_filter_gray_2x2 :
public span_image_filter<Source, Interpolator>
{
//==============================================span_image_filter_gray_2x2
template<class Source, class Interpolator>
class span_image_filter_gray_2x2 : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
typedef typename source_type::color_type color_type;
@ -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
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { 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,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, &filter)
span_image_filter_gray_2x2(source_type& src, interpolator_type& inter, 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(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
calc_type fg;
const value_type *fg_ptr;
const int16* weight_array = base_type::filter().weight_array() +
((base_type::filter().diameter()/2 - 1) <<
image_subpixel_shift);
const value_type* fg_ptr;
const int16* weight_array =
base_type::filter().weight_array() + ((base_type::filter().diameter() / 2 - 1) << image_subpixel_shift);
do
{
int x_hr;
@ -386,51 +333,41 @@ 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_array[y_hr + image_subpixel_scale] +
weight = (weight_array[x_hr + image_subpixel_scale] * weight_array[y_hr + image_subpixel_scale] +
image_filter_scale / 2) >>
image_filter_shift;
fg += weight * *fg_ptr;
fg_ptr = (const value_type*)base_type::source().next_x();
weight = (weight_array[x_hr] *
weight_array[y_hr + image_subpixel_scale] +
image_filter_scale / 2) >>
weight = (weight_array[x_hr] * weight_array[y_hr + image_subpixel_scale] + image_filter_scale / 2) >>
image_filter_shift;
fg += weight * *fg_ptr;
fg_ptr = (const value_type*)base_type::source().next_y();
weight = (weight_array[x_hr + image_subpixel_scale] *
weight_array[y_hr] +
image_filter_scale / 2) >>
weight = (weight_array[x_hr + image_subpixel_scale] * weight_array[y_hr] + image_filter_scale / 2) >>
image_filter_shift;
fg += weight * *fg_ptr;
fg_ptr = (const value_type*)base_type::source().next_x();
weight = (weight_array[x_hr] *
weight_array[y_hr] +
image_filter_scale / 2) >>
image_filter_shift;
weight = (weight_array[x_hr] * weight_array[y_hr] + image_filter_scale / 2) >> image_filter_shift;
fg += weight * *fg_ptr;
fg >>= image_filter_shift;
if(fg > base_mask) fg = base_mask;
if (fg > base_mask)
fg = base_mask;
span->v = (value_type)fg;
span->a = base_mask;
++span;
++base_type::interpolator();
} while(--len);
} while (--len);
}
};
};
//==================================================span_image_filter_gray
template<class Source, class Interpolator>
class span_image_filter_gray :
public span_image_filter<Source, Interpolator>
{
//==================================================span_image_filter_gray
template<class Source, class Interpolator>
class span_image_filter_gray : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
typedef typename source_type::color_type color_type;
@ -438,28 +375,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
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
//--------------------------------------------------------------------
span_image_filter_gray() {}
span_image_filter_gray(source_type& src,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, &filter)
span_image_filter_gray(source_type& src, interpolator_type& inter, 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(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
int fg;
const value_type *fg_ptr;
const value_type* fg_ptr;
unsigned diameter = base_type::filter().diameter();
int start = base_type::filter().start();
@ -487,50 +417,46 @@ 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,
y_lr + start,
diameter);
for(;;)
fg_ptr = (const value_type*)base_type::source().span(x_lr + start, y_lr + start, diameter);
for (;;)
{
x_count = diameter;
weight_y = weight_array[y_hr];
x_hr = image_subpixel_mask - x_fract;
for(;;)
for (;;)
{
fg += *fg_ptr *
((weight_y * weight_array[x_hr] +
image_filter_scale / 2) >>
image_filter_shift);
if(--x_count == 0) break;
fg += *fg_ptr * ((weight_y * weight_array[x_hr] + image_filter_scale / 2) >> image_filter_shift);
if (--x_count == 0)
break;
x_hr += image_subpixel_scale;
fg_ptr = (const value_type*)base_type::source().next_x();
}
if(--y_count == 0) break;
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 > base_mask) fg = base_mask;
if (fg < 0)
fg = 0;
if (fg > base_mask)
fg = base_mask;
span->v = (value_type)fg;
span->a = base_mask;
++span;
++base_type::interpolator();
} while(--len);
} while (--len);
}
};
};
//=========================================span_image_resample_gray_affine
template<class Source>
class span_image_resample_gray_affine :
public span_image_resample_affine<Source>
{
//=========================================span_image_resample_gray_affine
template<class Source>
class span_image_resample_gray_affine : public span_image_resample_affine<Source>
{
public:
typedef Source source_type;
typedef typename source_type::color_type color_type;
@ -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,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, filter)
span_image_resample_gray_affine(source_type& src, interpolator_type& inter, 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(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 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 =
(diameter * base_type::m_rx + image_subpixel_mask) >>
image_subpixel_shift;
int len_x_lr = (diameter * base_type::m_rx + image_subpixel_mask) >> image_subpixel_shift;
const int16* weight_array = base_type::filter().weight_array();
@ -582,59 +501,55 @@ namespace agg
fg = image_filter_scale / 2;
int y_lr = y >> image_subpixel_shift;
int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) *
base_type::m_ry_inv) >>
image_subpixel_shift;
int y_hr =
((image_subpixel_mask - (y & image_subpixel_mask)) * base_type::m_ry_inv) >> image_subpixel_shift;
int total_weight = 0;
int x_lr = x >> image_subpixel_shift;
int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) *
base_type::m_rx_inv) >>
image_subpixel_shift;
int x_hr =
((image_subpixel_mask - (x & image_subpixel_mask)) * base_type::m_rx_inv) >> image_subpixel_shift;
int x_hr2 = x_hr;
const value_type* fg_ptr =
(const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
for(;;)
const value_type* fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
for (;;)
{
int weight_y = weight_array[y_hr];
x_hr = x_hr2;
for(;;)
for (;;)
{
int weight = (weight_y * weight_array[x_hr] +
image_filter_scale / 2) >>
downscale_shift;
int weight = (weight_y * weight_array[x_hr] + image_filter_scale / 2) >> downscale_shift;
fg += *fg_ptr * weight;
total_weight += weight;
x_hr += base_type::m_rx_inv;
if(x_hr >= filter_scale) break;
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 > base_mask) fg = base_mask;
if (fg < 0)
fg = 0;
if (fg > base_mask)
fg = base_mask;
span->v = (value_type)fg;
span->a = base_mask;
++span;
++base_type::interpolator();
} while(--len);
} while (--len);
}
};
};
//================================================span_image_resample_gray
template<class Source, class Interpolator>
class span_image_resample_gray :
public span_image_resample<Source, Interpolator>
{
//================================================span_image_resample_gray
template<class Source, class Interpolator>
class span_image_resample_gray : public span_image_resample<Source, Interpolator>
{
public:
typedef Source source_type;
typedef typename source_type::color_type color_type;
@ -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,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, filter)
span_image_resample_gray(source_type& src, interpolator_type& inter, 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(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
long_type fg;
int diameter = base_type::filter().diameter();
@ -683,9 +594,7 @@ namespace agg
int radius_x = (diameter * rx) >> 1;
int radius_y = (diameter * ry) >> 1;
int len_x_lr =
(diameter * rx + image_subpixel_mask) >>
image_subpixel_shift;
int len_x_lr = (diameter * rx + image_subpixel_mask) >> image_subpixel_shift;
x += base_type::filter_dx_int() - radius_x;
y += base_type::filter_dy_int() - radius_y;
@ -693,56 +602,48 @@ namespace agg
fg = image_filter_scale / 2;
int y_lr = y >> image_subpixel_shift;
int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) *
ry_inv) >>
image_subpixel_shift;
int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) * ry_inv) >> image_subpixel_shift;
int total_weight = 0;
int x_lr = x >> image_subpixel_shift;
int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) *
rx_inv) >>
image_subpixel_shift;
int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) * rx_inv) >> image_subpixel_shift;
int x_hr2 = x_hr;
const value_type* fg_ptr =
(const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
const value_type* fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
for(;;)
for (;;)
{
int weight_y = weight_array[y_hr];
x_hr = x_hr2;
for(;;)
for (;;)
{
int weight = (weight_y * weight_array[x_hr] +
image_filter_scale / 2) >>
downscale_shift;
int weight = (weight_y * weight_array[x_hr] + image_filter_scale / 2) >> downscale_shift;
fg += *fg_ptr * weight;
total_weight += weight;
x_hr += rx_inv;
if(x_hr >= filter_scale) break;
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 > base_mask) fg = base_mask;
if (fg < 0)
fg = 0;
if (fg > base_mask)
fg = base_mask;
span->v = (value_type)fg;
span->a = base_mask;
++span;
++base_type::interpolator();
} while(--len);
} while (--len);
}
};
}
};
} // namespace agg
#endif

449
deps/agg/include/agg_span_image_filter_rgb.h vendored
View file

@ -27,15 +27,12 @@
#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 : public span_image_filter<Source, Interpolator>
{
//===============================================span_image_filter_rgb_nn
template<class Source, class Interpolator>
class span_image_filter_rgb_nn :
public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
typedef typename source_type::color_type color_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
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { 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,
interpolator_type& inter) :
base_type(src, inter, 0)
span_image_filter_rgb_nn(source_type& src, interpolator_type& inter)
: base_type(src, inter, 0)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
do
{
base_type::interpolator().coordinates(&x, &y);
const value_type* fg_ptr = (const value_type*)
base_type::source().span(x >> image_subpixel_shift,
y >> image_subpixel_shift,
1);
const value_type* fg_ptr =
(const value_type*)base_type::source().span(x >> image_subpixel_shift, y >> image_subpixel_shift, 1);
span->r = fg_ptr[order_type::R];
span->g = fg_ptr[order_type::G];
span->b = fg_ptr[order_type::B];
@ -76,17 +65,14 @@ namespace agg
++span;
++base_type::interpolator();
} while(--len);
} while (--len);
}
};
};
//==========================================span_image_filter_rgb_bilinear
template<class Source, class Interpolator>
class span_image_filter_rgb_bilinear :
public span_image_filter<Source, Interpolator>
{
//==========================================span_image_filter_rgb_bilinear
template<class Source, class Interpolator>
class span_image_filter_rgb_bilinear : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
typedef typename source_type::color_type color_type;
@ -95,27 +81,20 @@ 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
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { 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,
interpolator_type& inter) :
base_type(src, inter, 0)
span_image_filter_rgb_bilinear(source_type& src, interpolator_type& inter)
: base_type(src, inter, 0)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
calc_type fg[3];
const value_type *fg_ptr;
const value_type* fg_ptr;
do
{
int x_hr;
@ -131,16 +110,13 @@ namespace agg
unsigned weight;
fg[0] =
fg[1] =
fg[2] = image_subpixel_scale * image_subpixel_scale / 2;
fg[0] = 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) *
(image_subpixel_scale - y_hr);
weight = (image_subpixel_scale - x_hr) * (image_subpixel_scale - y_hr);
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
fg[2] += weight * *fg_ptr;
@ -171,17 +147,14 @@ namespace agg
++span;
++base_type::interpolator();
} while(--len);
} while (--len);
}
};
};
//=====================================span_image_filter_rgb_bilinear_clip
template<class Source, class Interpolator>
class span_image_filter_rgb_bilinear_clip :
public span_image_filter<Source, Interpolator>
{
//=====================================span_image_filter_rgb_bilinear_clip
template<class Source, class Interpolator>
class span_image_filter_rgb_bilinear_clip : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
typedef typename source_type::color_type color_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
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { 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,
const color_type& back_color,
interpolator_type& inter) :
base_type(src, inter, 0),
m_back_color(back_color)
span_image_filter_rgb_bilinear_clip(source_type& src, const color_type& back_color, interpolator_type& inter)
: base_type(src, inter, 0)
, m_back_color(back_color)
{}
const color_type& background_color() const { return m_back_color; }
void background_color(const color_type& v) { m_back_color = v; }
@ -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(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
calc_type fg[3];
calc_type src_alpha;
value_type back_r = m_back_color.r;
@ -219,7 +185,7 @@ namespace agg
value_type back_b = m_back_color.b;
value_type back_a = m_back_color.a;
const value_type *fg_ptr;
const value_type* fg_ptr;
int maxx = base_type::source().width() - 1;
int maxy = base_type::source().height() - 1;
@ -238,21 +204,16 @@ namespace agg
int y_lr = y_hr >> image_subpixel_shift;
unsigned weight;
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[0] =
fg[1] =
fg[2] = image_subpixel_scale * image_subpixel_scale / 2;
fg[0] = 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().row_ptr(y_lr) + x_lr + x_lr + x_lr;
fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
weight = (image_subpixel_scale - x_hr) *
(image_subpixel_scale - y_hr);
weight = (image_subpixel_scale - x_hr) * (image_subpixel_scale - y_hr);
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
fg[2] += weight * *fg_ptr++;
@ -263,8 +224,7 @@ namespace agg
fg[2] += weight * *fg_ptr++;
++y_lr;
fg_ptr = (const value_type*)
base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
fg_ptr = (const value_type*)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 ||
x_lr > maxx || y_lr > maxy)
if (x_lr < -1 || y_lr < -1 || x_lr > maxx || y_lr > maxy)
{
fg[order_type::R] = back_r;
fg[order_type::G] = back_g;
@ -293,21 +252,15 @@ namespace agg
}
else
{
fg[0] =
fg[1] =
fg[2] =
src_alpha = image_subpixel_scale * image_subpixel_scale / 2;
fg[0] = 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) *
(image_subpixel_scale - y_hr);
if(x_lr >= 0 && y_lr >= 0 &&
x_lr <= maxx && y_lr <= maxy)
weight = (image_subpixel_scale - x_hr) * (image_subpixel_scale - y_hr);
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg_ptr = (const value_type*)
base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
fg_ptr = (const value_type*)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 &&
x_lr <= maxx && y_lr <= maxy)
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg_ptr = (const value_type*)
base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
fg_ptr = (const value_type*)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 &&
x_lr <= maxx && y_lr <= maxy)
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg_ptr = (const value_type*)
base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
fg_ptr = (const value_type*)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 &&
x_lr <= maxx && y_lr <= maxy)
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg_ptr = (const value_type*)
base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
@ -403,19 +350,17 @@ namespace agg
++span;
++base_type::interpolator();
} while(--len);
} while (--len);
}
private:
color_type m_back_color;
};
};
//===============================================span_image_filter_rgb_2x2
template<class Source, class Interpolator>
class span_image_filter_rgb_2x2 :
public span_image_filter<Source, Interpolator>
{
//===============================================span_image_filter_rgb_2x2
template<class Source, class Interpolator>
class span_image_filter_rgb_2x2 : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
typedef typename source_type::color_type color_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
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { 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,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, &filter)
span_image_filter_rgb_2x2(source_type& src, interpolator_type& inter, 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(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 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() +
((base_type::filter().diameter()/2 - 1) <<
image_subpixel_shift);
const value_type* fg_ptr;
const int16* weight_array =
base_type::filter().weight_array() + ((base_type::filter().diameter() / 2 - 1) << image_subpixel_shift);
do
{
int x_hr;
@ -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_array[y_hr + image_subpixel_scale] +
weight = (weight_array[x_hr + image_subpixel_scale] * weight_array[y_hr + image_subpixel_scale] +
image_filter_scale / 2) >>
image_filter_shift;
fg[0] += weight * *fg_ptr++;
@ -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_array[y_hr + image_subpixel_scale] +
image_filter_scale / 2) >>
weight = (weight_array[x_hr] * weight_array[y_hr + image_subpixel_scale] + image_filter_scale / 2) >>
image_filter_shift;
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
fg[2] += weight * *fg_ptr;
fg_ptr = (const value_type*)base_type::source().next_y();
weight = (weight_array[x_hr + image_subpixel_scale] *
weight_array[y_hr] +
image_filter_scale / 2) >>
weight = (weight_array[x_hr + image_subpixel_scale] * weight_array[y_hr] + image_filter_scale / 2) >>
image_filter_shift;
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
fg[2] += weight * *fg_ptr;
fg_ptr = (const value_type*)base_type::source().next_x();
weight = (weight_array[x_hr] *
weight_array[y_hr] +
image_filter_scale / 2) >>
image_filter_shift;
weight = (weight_array[x_hr] * weight_array[y_hr] + image_filter_scale / 2) >> image_filter_shift;
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
fg[2] += weight * *fg_ptr;
@ -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::G] > base_mask) fg[order_type::G] = base_mask;
if(fg[order_type::B] > base_mask) fg[order_type::B] = base_mask;
if (fg[order_type::R] > base_mask)
fg[order_type::R] = 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];
@ -522,17 +453,14 @@ namespace agg
++span;
++base_type::interpolator();
} while(--len);
} while (--len);
}
};
};
//===================================================span_image_filter_rgb
template<class Source, class Interpolator>
class span_image_filter_rgb :
public span_image_filter<Source, Interpolator>
{
//===================================================span_image_filter_rgb
template<class Source, class Interpolator>
class span_image_filter_rgb : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
typedef typename source_type::color_type color_type;
@ -541,28 +469,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
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
//--------------------------------------------------------------------
span_image_filter_rgb() {}
span_image_filter_rgb(source_type& src,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, &filter)
span_image_filter_rgb(source_type& src, interpolator_type& inter, 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(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
int fg[3];
const value_type *fg_ptr;
const value_type* fg_ptr;
unsigned diameter = base_type::filter().diameter();
int start = base_type::filter().start();
@ -590,30 +511,28 @@ 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,
y_lr + start,
diameter);
for(;;)
fg_ptr = (const value_type*)base_type::source().span(x_lr + start, y_lr + start, diameter);
for (;;)
{
x_count = diameter;
weight_y = weight_array[y_hr];
x_hr = image_subpixel_mask - x_fract;
for(;;)
for (;;)
{
int weight = (weight_y * weight_array[x_hr] +
image_filter_scale / 2) >>
image_filter_shift;
int weight = (weight_y * weight_array[x_hr] + image_filter_scale / 2) >> image_filter_shift;
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
fg[2] += weight * *fg_ptr;
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[1] < 0) fg[1] = 0;
if(fg[2] < 0) fg[2] = 0;
if (fg[0] < 0)
fg[0] = 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::G] > base_mask) fg[order_type::G] = base_mask;
if(fg[order_type::B] > base_mask) fg[order_type::B] = base_mask;
if (fg[order_type::R] > base_mask)
fg[order_type::R] = 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];
@ -638,17 +563,14 @@ namespace agg
++span;
++base_type::interpolator();
} while(--len);
} while (--len);
}
};
};
//==========================================span_image_resample_rgb_affine
template<class Source>
class span_image_resample_rgb_affine :
public span_image_resample_affine<Source>
{
//==========================================span_image_resample_rgb_affine
template<class Source>
class span_image_resample_rgb_affine : public span_image_resample_affine<Source>
{
public:
typedef Source source_type;
typedef typename source_type::color_type color_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,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, filter)
span_image_resample_rgb_affine(source_type& src, interpolator_type& inter, 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(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 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 =
(diameter * base_type::m_rx + image_subpixel_mask) >>
image_subpixel_shift;
int len_x_lr = (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)) *
base_type::m_ry_inv) >>
image_subpixel_shift;
int y_hr =
((image_subpixel_mask - (y & image_subpixel_mask)) * base_type::m_ry_inv) >> image_subpixel_shift;
int total_weight = 0;
int x_lr = x >> image_subpixel_shift;
int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) *
base_type::m_rx_inv) >>
image_subpixel_shift;
int x_hr =
((image_subpixel_mask - (x & image_subpixel_mask)) * base_type::m_rx_inv) >> image_subpixel_shift;
int x_hr2 = x_hr;
const value_type* fg_ptr =
(const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
for(;;)
const value_type* fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
for (;;)
{
int weight_y = weight_array[y_hr];
x_hr = x_hr2;
for(;;)
for (;;)
{
int weight = (weight_y * weight_array[x_hr] +
image_filter_scale / 2) >>
downscale_shift;
int weight = (weight_y * weight_array[x_hr] + image_filter_scale / 2) >> downscale_shift;
fg[0] += *fg_ptr++ * weight;
fg[1] += *fg_ptr++ * weight;
fg[2] += *fg_ptr * weight;
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[1] < 0) fg[1] = 0;
if(fg[2] < 0) fg[2] = 0;
if (fg[0] < 0)
fg[0] = 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::G] > base_mask) fg[order_type::G] = base_mask;
if(fg[order_type::B] > base_mask) fg[order_type::B] = base_mask;
if (fg[order_type::R] > base_mask)
fg[order_type::R] = 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];
@ -755,17 +673,14 @@ namespace agg
++span;
++base_type::interpolator();
} while(--len);
} while (--len);
}
};
};
//=================================================span_image_resample_rgb
template<class Source, class Interpolator>
class span_image_resample_rgb :
public span_image_resample<Source, Interpolator>
{
//=================================================span_image_resample_rgb
template<class Source, class Interpolator>
class span_image_resample_rgb : public span_image_resample<Source, Interpolator>
{
public:
typedef Source source_type;
typedef typename source_type::color_type color_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,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, filter)
span_image_resample_rgb(source_type& src, interpolator_type& inter, 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(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 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 =
(diameter * rx + image_subpixel_mask) >>
image_subpixel_shift;
int len_x_lr = (diameter * rx + image_subpixel_mask) >> image_subpixel_shift;
x += base_type::filter_dx_int() - radius_x;
y += base_type::filter_dy_int() - radius_y;
@ -825,37 +734,32 @@ 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)) *
ry_inv) >>
image_subpixel_shift;
int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) * ry_inv) >> image_subpixel_shift;
int total_weight = 0;
int x_lr = x >> image_subpixel_shift;
int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) *
rx_inv) >>
image_subpixel_shift;
int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) * rx_inv) >> image_subpixel_shift;
int x_hr2 = x_hr;
const value_type* fg_ptr =
(const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
const value_type* fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
for(;;)
for (;;)
{
int weight_y = weight_array[y_hr];
x_hr = x_hr2;
for(;;)
for (;;)
{
int weight = (weight_y * weight_array[x_hr] +
image_filter_scale / 2) >>
downscale_shift;
int weight = (weight_y * weight_array[x_hr] + image_filter_scale / 2) >> downscale_shift;
fg[0] += *fg_ptr++ * weight;
fg[1] += *fg_ptr++ * weight;
fg[2] += *fg_ptr * weight;
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[1] < 0) fg[1] = 0;
if(fg[2] < 0) fg[2] = 0;
if (fg[0] < 0)
fg[0] = 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::G] > base_mask) fg[order_type::G] = base_mask;
if(fg[order_type::B] > base_mask) fg[order_type::B] = base_mask;
if (fg[order_type::R] > base_mask)
fg[order_type::R] = 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];
@ -878,15 +788,10 @@ namespace agg
++span;
++base_type::interpolator();
} while(--len);
} while (--len);
}
};
}
};
} // namespace agg
#endif

471
deps/agg/include/agg_span_image_filter_rgba.h vendored
View file

@ -27,15 +27,12 @@
#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 : public span_image_filter<Source, Interpolator>
{
//==============================================span_image_filter_rgba_nn
template<class Source, class Interpolator>
class span_image_filter_rgba_nn :
public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
typedef typename source_type::color_type color_type;
@ -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
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { 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,
interpolator_type& inter) :
base_type(src, inter, 0)
span_image_filter_rgba_nn(source_type& src, interpolator_type& inter)
: base_type(src, inter, 0)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
do
{
base_type::interpolator().coordinates(&x, &y);
const value_type* fg_ptr = (const value_type*)
base_type::source().span(x >> image_subpixel_shift,
y >> image_subpixel_shift,
1);
const value_type* fg_ptr =
(const value_type*)base_type::source().span(x >> image_subpixel_shift, y >> image_subpixel_shift, 1);
span->r = fg_ptr[order_type::R];
span->g = fg_ptr[order_type::G];
span->b = fg_ptr[order_type::B];
@ -76,17 +65,14 @@ namespace agg
++span;
++base_type::interpolator();
} while(--len);
} while (--len);
}
};
};
//=========================================span_image_filter_rgba_bilinear
template<class Source, class Interpolator>
class span_image_filter_rgba_bilinear :
public span_image_filter<Source, Interpolator>
{
//=========================================span_image_filter_rgba_bilinear
template<class Source, class Interpolator>
class span_image_filter_rgba_bilinear : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
typedef typename source_type::color_type color_type;
@ -95,28 +81,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
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { 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,
interpolator_type& inter) :
base_type(src, inter, 0)
span_image_filter_rgba_bilinear(source_type& src, interpolator_type& inter)
: base_type(src, inter, 0)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
calc_type fg[4];
const value_type *fg_ptr;
const value_type* fg_ptr;
do
{
@ -133,17 +112,13 @@ namespace agg
unsigned weight;
fg[0] =
fg[1] =
fg[2] =
fg[3] = image_subpixel_scale * image_subpixel_scale / 2;
fg[0] = fg[1] = fg[2] = fg[3] = image_subpixel_scale * image_subpixel_scale / 2;
x_hr &= image_subpixel_mask;
y_hr &= image_subpixel_mask;
fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, 2);
weight = (image_subpixel_scale - x_hr) *
(image_subpixel_scale - y_hr);
weight = (image_subpixel_scale - x_hr) * (image_subpixel_scale - y_hr);
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
fg[2] += weight * *fg_ptr++;
@ -178,16 +153,14 @@ namespace agg
++span;
++base_type::interpolator();
} while(--len);
} while (--len);
}
};
};
//====================================span_image_filter_rgba_bilinear_clip
template<class Source, class Interpolator>
class span_image_filter_rgba_bilinear_clip :
public span_image_filter<Source, Interpolator>
{
//====================================span_image_filter_rgba_bilinear_clip
template<class Source, class Interpolator>
class span_image_filter_rgba_bilinear_clip : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
typedef typename source_type::color_type color_type;
@ -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
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { 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,
const color_type& back_color,
interpolator_type& inter) :
base_type(src, inter, 0),
m_back_color(back_color)
span_image_filter_rgba_bilinear_clip(source_type& src, const color_type& back_color, interpolator_type& inter)
: base_type(src, inter, 0)
, m_back_color(back_color)
{}
const color_type& background_color() const { return m_back_color; }
void background_color(const color_type& v) { m_back_color = v; }
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
calc_type fg[4];
value_type back_r = m_back_color.r;
@ -226,7 +191,7 @@ namespace agg
value_type back_b = m_back_color.b;
value_type back_a = m_back_color.a;
const value_type *fg_ptr;
const value_type* fg_ptr;
int maxx = base_type::source().width() - 1;
int maxy = base_type::source().height() - 1;
@ -245,22 +210,16 @@ namespace agg
unsigned weight;
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[0] =
fg[1] =
fg[2] =
fg[3] = image_subpixel_scale * image_subpixel_scale / 2;
fg[0] = fg[1] = fg[2] = fg[3] = image_subpixel_scale * image_subpixel_scale / 2;
x_hr &= image_subpixel_mask;
y_hr &= image_subpixel_mask;
fg_ptr = (const value_type*)
base_type::source().row_ptr(y_lr) + (x_lr << 2);
fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + (x_lr << 2);
weight = (image_subpixel_scale - x_hr) *
(image_subpixel_scale - y_hr);
weight = (image_subpixel_scale - x_hr) * (image_subpixel_scale - y_hr);
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
fg[2] += weight * *fg_ptr++;
@ -273,8 +232,7 @@ namespace agg
fg[3] += weight * *fg_ptr++;
++y_lr;
fg_ptr = (const value_type*)
base_type::source().row_ptr(y_lr) + (x_lr << 2);
fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + (x_lr << 2);
weight = (image_subpixel_scale - x_hr) * y_hr;
fg[0] += weight * *fg_ptr++;
@ -295,8 +253,7 @@ namespace agg
}
else
{
if(x_lr < -1 || y_lr < -1 ||
x_lr > maxx || y_lr > maxy)
if (x_lr < -1 || y_lr < -1 || x_lr > maxx || y_lr > maxy)
{
fg[order_type::R] = back_r;
fg[order_type::G] = back_g;
@ -305,21 +262,15 @@ namespace agg
}
else
{
fg[0] =
fg[1] =
fg[2] =
fg[3] = image_subpixel_scale * image_subpixel_scale / 2;
fg[0] = fg[1] = fg[2] = fg[3] = image_subpixel_scale * image_subpixel_scale / 2;
x_hr &= image_subpixel_mask;
y_hr &= image_subpixel_mask;
weight = (image_subpixel_scale - x_hr) *
(image_subpixel_scale - y_hr);
if(x_lr >= 0 && y_lr >= 0 &&
x_lr <= maxx && y_lr <= maxy)
weight = (image_subpixel_scale - x_hr) * (image_subpixel_scale - y_hr);
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg_ptr = (const value_type*)
base_type::source().row_ptr(y_lr) + (x_lr << 2);
fg_ptr = (const value_type*)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 &&
x_lr <= maxx && y_lr <= maxy)
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg_ptr = (const value_type*)
base_type::source().row_ptr(y_lr) + (x_lr << 2);
fg_ptr = (const value_type*)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 &&
x_lr <= maxx && y_lr <= maxy)
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg_ptr = (const value_type*)
base_type::source().row_ptr(y_lr) + (x_lr << 2);
fg_ptr = (const value_type*)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 &&
x_lr <= maxx && y_lr <= maxy)
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg_ptr = (const value_type*)
base_type::source().row_ptr(y_lr) + (x_lr << 2);
fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + (x_lr << 2);
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
@ -415,18 +360,17 @@ namespace agg
++span;
++base_type::interpolator();
} while(--len);
} while (--len);
}
private:
color_type m_back_color;
};
};
//==============================================span_image_filter_rgba_2x2
template<class Source, class Interpolator>
class span_image_filter_rgba_2x2 :
public span_image_filter<Source, Interpolator>
{
//==============================================span_image_filter_rgba_2x2
template<class Source, class Interpolator>
class span_image_filter_rgba_2x2 : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
typedef typename source_type::color_type color_type;
@ -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
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { 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,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, &filter)
span_image_filter_rgba_2x2(source_type& src, interpolator_type& inter, 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(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 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() +
((base_type::filter().diameter()/2 - 1) <<
image_subpixel_shift);
const value_type* fg_ptr;
const int16* weight_array =
base_type::filter().weight_array() + ((base_type::filter().diameter() / 2 - 1) << 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_array[y_hr + image_subpixel_scale] +
weight = (weight_array[x_hr + image_subpixel_scale] * weight_array[y_hr + image_subpixel_scale] +
image_filter_scale / 2) >>
image_filter_shift;
fg[0] += weight * *fg_ptr++;
@ -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_array[y_hr + image_subpixel_scale] +
image_filter_scale / 2) >>
weight = (weight_array[x_hr] * weight_array[y_hr + image_subpixel_scale] + image_filter_scale / 2) >>
image_filter_shift;
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
@ -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_array[y_hr] +
image_filter_scale / 2) >>
weight = (weight_array[x_hr + image_subpixel_scale] * weight_array[y_hr] + image_filter_scale / 2) >>
image_filter_shift;
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
@ -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_array[y_hr] +
image_filter_scale / 2) >>
image_filter_shift;
weight = (weight_array[x_hr] * weight_array[y_hr] + image_filter_scale / 2) >> image_filter_shift;
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
fg[2] += weight * *fg_ptr++;
@ -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::R] > fg[order_type::A]) fg[order_type::R] = fg[order_type::A];
if(fg[order_type::G] > fg[order_type::A]) fg[order_type::G] = fg[order_type::A];
if(fg[order_type::B] > fg[order_type::A]) fg[order_type::B] = fg[order_type::A];
if (fg[order_type::A] > base_mask)
fg[order_type::A] = base_mask;
if (fg[order_type::R] > fg[order_type::A])
fg[order_type::R] = fg[order_type::A];
if (fg[order_type::G] > fg[order_type::A])
fg[order_type::G] = fg[order_type::A];
if (fg[order_type::B] > fg[order_type::A])
fg[order_type::B] = fg[order_type::A];
span->r = (value_type)fg[order_type::R];
span->g = (value_type)fg[order_type::G];
@ -539,17 +470,14 @@ namespace agg
++span;
++base_type::interpolator();
} while(--len);
} while (--len);
}
};
};
//==================================================span_image_filter_rgba
template<class Source, class Interpolator>
class span_image_filter_rgba :
public span_image_filter<Source, Interpolator>
{
//==================================================span_image_filter_rgba
template<class Source, class Interpolator>
class span_image_filter_rgba : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
typedef typename source_type::color_type color_type;
@ -558,28 +486,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
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
//--------------------------------------------------------------------
span_image_filter_rgba() {}
span_image_filter_rgba(source_type& src,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, &filter)
span_image_filter_rgba(source_type& src, interpolator_type& inter, 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(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
int fg[4];
const value_type *fg_ptr;
const value_type* fg_ptr;
unsigned diameter = base_type::filter().diameter();
int start = base_type::filter().start();
@ -607,31 +528,29 @@ 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,
y_lr + start,
diameter);
for(;;)
fg_ptr = (const value_type*)base_type::source().span(x_lr + start, y_lr + start, diameter);
for (;;)
{
x_count = diameter;
weight_y = weight_array[y_hr];
x_hr = image_subpixel_mask - x_fract;
for(;;)
for (;;)
{
int weight = (weight_y * weight_array[x_hr] +
image_filter_scale / 2) >>
image_filter_shift;
int weight = (weight_y * weight_array[x_hr] + image_filter_scale / 2) >> image_filter_shift;
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
fg[2] += weight * *fg_ptr++;
fg[3] += weight * *fg_ptr;
if(--x_count == 0) break;
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[1] < 0) fg[1] = 0;
if(fg[2] < 0) fg[2] = 0;
if(fg[3] < 0) fg[3] = 0;
if (fg[0] < 0)
fg[0] = 0;
if (fg[1] < 0)
fg[1] = 0;
if (fg[2] < 0)
fg[2] = 0;
if (fg[3] < 0)
fg[3] = 0;
if(fg[order_type::A] > base_mask) fg[order_type::A] = base_mask;
if(fg[order_type::R] > fg[order_type::A]) fg[order_type::R] = fg[order_type::A];
if(fg[order_type::G] > fg[order_type::A]) fg[order_type::G] = fg[order_type::A];
if(fg[order_type::B] > fg[order_type::A]) fg[order_type::B] = fg[order_type::A];
if (fg[order_type::A] > base_mask)
fg[order_type::A] = base_mask;
if (fg[order_type::R] > fg[order_type::A])
fg[order_type::R] = fg[order_type::A];
if (fg[order_type::G] > fg[order_type::A])
fg[order_type::G] = fg[order_type::A];
if (fg[order_type::B] > fg[order_type::A])
fg[order_type::B] = fg[order_type::A];
span->r = (value_type)fg[order_type::R];
span->g = (value_type)fg[order_type::G];
@ -658,17 +585,14 @@ namespace agg
++span;
++base_type::interpolator();
} while(--len);
} while (--len);
}
};
};
//========================================span_image_resample_rgba_affine
template<class Source>
class span_image_resample_rgba_affine :
public span_image_resample_affine<Source>
{
//========================================span_image_resample_rgba_affine
template<class Source>
class span_image_resample_rgba_affine : public span_image_resample_affine<Source>
{
public:
typedef Source source_type;
typedef typename source_type::color_type color_type;
@ -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,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, filter)
span_image_resample_rgba_affine(source_type& src, interpolator_type& inter, 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(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 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 =
(diameter * base_type::m_rx + image_subpixel_mask) >>
image_subpixel_shift;
int len_x_lr = (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)) *
base_type::m_ry_inv) >>
image_subpixel_shift;
int y_hr =
((image_subpixel_mask - (y & image_subpixel_mask)) * base_type::m_ry_inv) >> image_subpixel_shift;
int total_weight = 0;
int x_lr = x >> image_subpixel_shift;
int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) *
base_type::m_rx_inv) >>
image_subpixel_shift;
int x_hr =
((image_subpixel_mask - (x & image_subpixel_mask)) * base_type::m_rx_inv) >> image_subpixel_shift;
int x_hr2 = x_hr;
const value_type* fg_ptr =
(const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
for(;;)
const value_type* fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
for (;;)
{
int weight_y = weight_array[y_hr];
x_hr = x_hr2;
for(;;)
for (;;)
{
int weight = (weight_y * weight_array[x_hr] +
image_filter_scale / 2) >>
downscale_shift;
int weight = (weight_y * weight_array[x_hr] + 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[1] < 0) fg[1] = 0;
if(fg[2] < 0) fg[2] = 0;
if(fg[3] < 0) fg[3] = 0;
if (fg[0] < 0)
fg[0] = 0;
if (fg[1] < 0)
fg[1] = 0;
if (fg[2] < 0)
fg[2] = 0;
if (fg[3] < 0)
fg[3] = 0;
if(fg[order_type::A] > base_mask) fg[order_type::A] = base_mask;
if(fg[order_type::R] > fg[order_type::A]) fg[order_type::R] = fg[order_type::A];
if(fg[order_type::G] > fg[order_type::A]) fg[order_type::G] = fg[order_type::A];
if(fg[order_type::B] > fg[order_type::A]) fg[order_type::B] = fg[order_type::A];
if (fg[order_type::A] > base_mask)
fg[order_type::A] = base_mask;
if (fg[order_type::R] > fg[order_type::A])
fg[order_type::R] = fg[order_type::A];
if (fg[order_type::G] > fg[order_type::A])
fg[order_type::G] = fg[order_type::A];
if (fg[order_type::B] > fg[order_type::A])
fg[order_type::B] = fg[order_type::A];
span->r = (value_type)fg[order_type::R];
span->g = (value_type)fg[order_type::G];
@ -779,17 +701,14 @@ namespace agg
++span;
++base_type::interpolator();
} while(--len);
} while (--len);
}
};
};
//==============================================span_image_resample_rgba
template<class Source, class Interpolator>
class span_image_resample_rgba :
public span_image_resample<Source, Interpolator>
{
//==============================================span_image_resample_rgba
template<class Source, class Interpolator>
class span_image_resample_rgba : public span_image_resample<Source, Interpolator>
{
public:
typedef Source source_type;
typedef typename source_type::color_type color_type;
@ -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,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, filter)
span_image_resample_rgba(source_type& src, interpolator_type& inter, 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(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
long_type fg[4];
int diameter = base_type::filter().diameter();
@ -839,9 +754,7 @@ namespace agg
int radius_x = (diameter * rx) >> 1;
int radius_y = (diameter * ry) >> 1;
int len_x_lr =
(diameter * rx + image_subpixel_mask) >>
image_subpixel_shift;
int len_x_lr = (diameter * rx + image_subpixel_mask) >> image_subpixel_shift;
x += base_type::filter_dx_int() - radius_x;
y += base_type::filter_dy_int() - radius_y;
@ -849,38 +762,33 @@ 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)) *
ry_inv) >>
image_subpixel_shift;
int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) * ry_inv) >> image_subpixel_shift;
int total_weight = 0;
int x_lr = x >> image_subpixel_shift;
int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) *
rx_inv) >>
image_subpixel_shift;
int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) * rx_inv) >> image_subpixel_shift;
int x_hr2 = x_hr;
const value_type* fg_ptr =
(const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
const value_type* fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
for(;;)
for (;;)
{
int weight_y = weight_array[y_hr];
x_hr = x_hr2;
for(;;)
for (;;)
{
int weight = (weight_y * weight_array[x_hr] +
image_filter_scale / 2) >>
downscale_shift;
int weight = (weight_y * weight_array[x_hr] + image_filter_scale / 2) >> downscale_shift;
fg[0] += *fg_ptr++ * weight;
fg[1] += *fg_ptr++ * weight;
fg[2] += *fg_ptr++ * weight;
fg[3] += *fg_ptr++ * weight;
total_weight += weight;
x_hr += rx_inv;
if(x_hr >= filter_scale) break;
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[1] < 0) fg[1] = 0;
if(fg[2] < 0) fg[2] = 0;
if(fg[3] < 0) fg[3] = 0;
if (fg[0] < 0)
fg[0] = 0;
if (fg[1] < 0)
fg[1] = 0;
if (fg[2] < 0)
fg[2] = 0;
if (fg[3] < 0)
fg[3] = 0;
if(fg[order_type::A] > base_mask) fg[order_type::A] = base_mask;
if(fg[order_type::R] > fg[order_type::A]) fg[order_type::R] = fg[order_type::A];
if(fg[order_type::G] > fg[order_type::A]) fg[order_type::G] = fg[order_type::A];
if(fg[order_type::B] > fg[order_type::A]) fg[order_type::B] = fg[order_type::A];
if (fg[order_type::A] > base_mask)
fg[order_type::A] = base_mask;
if (fg[order_type::R] > fg[order_type::A])
fg[order_type::R] = fg[order_type::A];
if (fg[order_type::G] > fg[order_type::A])
fg[order_type::G] = fg[order_type::A];
if (fg[order_type::B] > fg[order_type::A])
fg[order_type::B] = fg[order_type::A];
span->r = (value_type)fg[order_type::R];
span->g = (value_type)fg[order_type::G];
@ -906,15 +822,10 @@ namespace agg
++span;
++base_type::interpolator();
} while(--len);
} while (--len);
}
};
}
};
} // namespace agg
#endif

47
deps/agg/include/agg_span_interpolator_adaptor.h vendored
View file

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

102
deps/agg/include/agg_span_interpolator_linear.h vendored
View file

@ -20,28 +20,24 @@
#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>
class span_interpolator_linear
{
//================================================span_interpolator_linear
template<class Transformer = trans_affine, unsigned SubpixelShift = 8>
class span_interpolator_linear
{
public:
typedef Transformer trans_type;
enum subpixel_scale_e
{
subpixel_shift = SubpixelShift,
subpixel_scale = 1 << subpixel_shift
};
enum subpixel_scale_e { 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,
double x, double y, unsigned len) :
m_trans(&trans)
span_interpolator_linear(const trans_type& trans)
: m_trans(&trans)
{}
span_interpolator_linear(const trans_type& trans, double x, double y, unsigned len)
: m_trans(&trans)
{
begin(x, y, len);
}
@ -98,47 +94,40 @@ namespace agg
const trans_type* m_trans;
dda2_line_interpolator m_li_x;
dda2_line_interpolator m_li_y;
};
};
//=====================================span_interpolator_linear_subdiv
template<class Transformer = trans_affine, unsigned SubpixelShift = 8>
class span_interpolator_linear_subdiv
{
//=====================================span_interpolator_linear_subdiv
template<class Transformer = trans_affine, unsigned SubpixelShift = 8>
class span_interpolator_linear_subdiv
{
public:
typedef Transformer trans_type;
enum subpixel_scale_e
{
subpixel_shift = SubpixelShift,
subpixel_scale = 1 << subpixel_shift
};
enum subpixel_scale_e { subpixel_shift = SubpixelShift, subpixel_scale = 1 << subpixel_shift };
//----------------------------------------------------------------
span_interpolator_linear_subdiv() :
m_subdiv_shift(4),
m_subdiv_size(1 << m_subdiv_shift),
m_subdiv_mask(m_subdiv_size - 1) {}
span_interpolator_linear_subdiv()
: m_subdiv_shift(4)
, m_subdiv_size(1 << m_subdiv_shift)
, 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) :
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,
double x, double y, unsigned len,
unsigned subdiv_shift = 4) :
m_subdiv_shift(subdiv_shift),
m_subdiv_size(1 << m_subdiv_shift),
m_subdiv_mask(m_subdiv_size - 1),
m_trans(&trans)
double x,
double y,
unsigned len,
unsigned subdiv_shift = 4)
: m_subdiv_shift(subdiv_shift)
, m_subdiv_size(1 << m_subdiv_shift)
, m_subdiv_mask(m_subdiv_size - 1)
, m_trans(&trans)
{
begin(x, y, len);
}
@ -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);
@ -186,10 +176,11 @@ namespace agg
{
++m_li_x;
++m_li_y;
if(m_pos >= m_subdiv_size)
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);
@ -220,13 +211,8 @@ namespace agg
double m_src_y;
unsigned m_pos;
unsigned m_len;
};
}
};
} // namespace agg
#endif

136
deps/agg/include/agg_span_interpolator_persp.h vendored
View file

@ -18,48 +18,34 @@
#include "agg_trans_perspective.h"
#include "agg_dda_line.h"
namespace agg
namespace agg {
//===========================================span_interpolator_persp_exact
template<unsigned SubpixelShift = 8>
class span_interpolator_persp_exact
{
//===========================================span_interpolator_persp_exact
template<unsigned SubpixelShift = 8>
class span_interpolator_persp_exact
{
public:
typedef trans_perspective trans_type;
typedef trans_perspective::iterator_x iterator_type;
enum subpixel_scale_e
{
subpixel_shift = SubpixelShift,
subpixel_scale = 1 << subpixel_shift
};
enum subpixel_scale_e { subpixel_shift = SubpixelShift, subpixel_scale = 1 << subpixel_shift };
//--------------------------------------------------------------------
span_interpolator_persp_exact() {}
//--------------------------------------------------------------------
// Arbitrary quadrangle transformations
span_interpolator_persp_exact(const double* src, const double* dst)
{
quad_to_quad(src, dst);
}
span_interpolator_persp_exact(const double* src, const double* dst) { quad_to_quad(src, dst); }
//--------------------------------------------------------------------
// Direct transformations
span_interpolator_persp_exact(double x1, double y1,
double x2, double y2,
const double* quad)
span_interpolator_persp_exact(double x1, double y1, double x2, double y2, const double* quad)
{
rect_to_quad(x1, y1, x2, y2, quad);
}
//--------------------------------------------------------------------
// Reverse transformations
span_interpolator_persp_exact(const double* quad,
double x1, double y1,
double x2, double y2)
span_interpolator_persp_exact(const double* quad, double x1, double y1, double x2, double y2)
{
quad_to_rect(quad, x1, y1, x2, y2);
}
@ -74,8 +60,7 @@ namespace agg
//--------------------------------------------------------------------
// Set the direct transformations, i.e., rectangle -> quadrangle
void rect_to_quad(double x1, double y1, double x2, double y2,
const double* quad)
void rect_to_quad(double x1, double y1, double x2, double y2, const double* quad)
{
double src[8];
src[0] = src[6] = x1;
@ -85,11 +70,9 @@ namespace agg
quad_to_quad(src, quad);
}
//--------------------------------------------------------------------
// Set the reverse transformations, i.e., quadrangle -> rectangle
void quad_to_rect(const double* quad,
double x1, double y1, double x2, double y2)
void quad_to_rect(const double* quad, double x1, double y1, double x2, double y2)
{
double dst[8];
dst[0] = dst[6] = x1;
@ -112,19 +95,19 @@ namespace agg
double dx;
double dy;
const double delta = 1/double(subpixel_scale);
const double delta = 1 / double(subpixel_scale);
dx = xt + delta;
dy = yt;
m_trans_inv.transform(&dx, &dy);
dx -= x;
dy -= y;
int sx1 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
int sx1 = uround(subpixel_scale / sqrt(dx * dx + dy * dy)) >> subpixel_shift;
dx = xt;
dy = yt + delta;
m_trans_inv.transform(&dx, &dy);
dx -= x;
dy -= y;
int sy1 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
int sy1 = uround(subpixel_scale / sqrt(dx * dx + dy * dy)) >> subpixel_shift;
x += len;
xt = x;
@ -136,19 +119,18 @@ namespace agg
m_trans_inv.transform(&dx, &dy);
dx -= x;
dy -= y;
int sx2 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
int sx2 = uround(subpixel_scale / sqrt(dx * dx + dy * dy)) >> subpixel_shift;
dx = xt;
dy = yt + delta;
m_trans_inv.transform(&dx, &dy);
dx -= x;
dy -= y;
int sy2 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
int sy2 = uround(subpixel_scale / sqrt(dx * dx + dy * dy)) >> subpixel_shift;
m_scale_x = dda2_line_interpolator(sx1, sx2, len);
m_scale_y = dda2_line_interpolator(sy1, sy2, len);
}
//----------------------------------------------------------------
void resynchronize(double xe, double ye, unsigned len)
{
@ -161,7 +143,7 @@ namespace agg
double yt = ye;
m_trans_dir.transform(&xt, &yt);
const double delta = 1/double(subpixel_scale);
const double delta = 1 / double(subpixel_scale);
double dx;
double dy;
@ -171,7 +153,7 @@ namespace agg
m_trans_inv.transform(&dx, &dy);
dx -= xe;
dy -= ye;
int sx2 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
int sx2 = uround(subpixel_scale / sqrt(dx * dx + dy * dy)) >> subpixel_shift;
// Calculate scale by Y at x2,y2
dx = xt;
@ -179,15 +161,13 @@ namespace agg
m_trans_inv.transform(&dx, &dy);
dx -= xe;
dy -= ye;
int sy2 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
int sy2 = uround(subpixel_scale / sqrt(dx * dx + dy * dy)) >> subpixel_shift;
// Initialize the interpolators
m_scale_x = dda2_line_interpolator(sx1, sx2, len);
m_scale_y = dda2_line_interpolator(sy1, sy2, len);
}
//----------------------------------------------------------------
void operator++()
{
@ -211,10 +191,7 @@ namespace agg
}
//----------------------------------------------------------------
void transform(double* x, double* y) const
{
m_trans_dir.transform(x, y);
}
void transform(double* x, double* y) const { m_trans_dir.transform(x, y); }
private:
trans_type m_trans_dir;
@ -222,54 +199,33 @@ namespace agg
iterator_type m_iterator;
dda2_line_interpolator m_scale_x;
dda2_line_interpolator m_scale_y;
};
};
//============================================span_interpolator_persp_lerp
template<unsigned SubpixelShift = 8>
class span_interpolator_persp_lerp
{
//============================================span_interpolator_persp_lerp
template<unsigned SubpixelShift = 8>
class span_interpolator_persp_lerp
{
public:
typedef trans_perspective trans_type;
enum subpixel_scale_e
{
subpixel_shift = SubpixelShift,
subpixel_scale = 1 << subpixel_shift
};
enum subpixel_scale_e { subpixel_shift = SubpixelShift, subpixel_scale = 1 << subpixel_shift };
//--------------------------------------------------------------------
span_interpolator_persp_lerp() {}
//--------------------------------------------------------------------
// Arbitrary quadrangle transformations
span_interpolator_persp_lerp(const double* src, const double* dst)
{
quad_to_quad(src, dst);
}
span_interpolator_persp_lerp(const double* src, const double* dst) { quad_to_quad(src, dst); }
//--------------------------------------------------------------------
// Direct transformations
span_interpolator_persp_lerp(double x1, double y1,
double x2, double y2,
const double* quad)
span_interpolator_persp_lerp(double x1, double y1, double x2, double y2, const double* quad)
{
rect_to_quad(x1, y1, x2, y2, quad);
}
//--------------------------------------------------------------------
// Reverse transformations
span_interpolator_persp_lerp(const double* quad,
double x1, double y1,
double x2, double y2)
span_interpolator_persp_lerp(const double* quad, double x1, double y1, double x2, double y2)
{
quad_to_rect(quad, x1, y1, x2, y2);
}
@ -284,8 +240,7 @@ namespace agg
//--------------------------------------------------------------------
// Set the direct transformations, i.e., rectangle -> quadrangle
void rect_to_quad(double x1, double y1, double x2, double y2,
const double* quad)
void rect_to_quad(double x1, double y1, double x2, double y2, const double* quad)
{
double src[8];
src[0] = src[6] = x1;
@ -295,11 +250,9 @@ namespace agg
quad_to_quad(src, quad);
}
//--------------------------------------------------------------------
// Set the reverse transformations, i.e., quadrangle -> rectangle
void quad_to_rect(const double* quad,
double x1, double y1, double x2, double y2)
void quad_to_rect(const double* quad, double x1, double y1, double x2, double y2)
{
double dst[8];
dst[0] = dst[6] = x1;
@ -325,7 +278,7 @@ namespace agg
double dx;
double dy;
const double delta = 1/double(subpixel_scale);
const double delta = 1 / double(subpixel_scale);
// Calculate scale by X at x1,y1
dx = xt + delta;
@ -333,7 +286,7 @@ namespace agg
m_trans_inv.transform(&dx, &dy);
dx -= x;
dy -= y;
int sx1 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
int sx1 = uround(subpixel_scale / sqrt(dx * dx + dy * dy)) >> subpixel_shift;
// Calculate scale by Y at x1,y1
dx = xt;
@ -341,7 +294,7 @@ namespace agg
m_trans_inv.transform(&dx, &dy);
dx -= x;
dy -= y;
int sy1 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
int sy1 = uround(subpixel_scale / sqrt(dx * dx + dy * dy)) >> subpixel_shift;
// Calculate transformed coordinates at x2,y2
x += len;
@ -357,7 +310,7 @@ namespace agg
m_trans_inv.transform(&dx, &dy);
dx -= x;
dy -= y;
int sx2 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
int sx2 = uround(subpixel_scale / sqrt(dx * dx + dy * dy)) >> subpixel_shift;
// Calculate scale by Y at x2,y2
dx = xt;
@ -365,7 +318,7 @@ namespace agg
m_trans_inv.transform(&dx, &dy);
dx -= x;
dy -= y;
int sy2 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
int sy2 = uround(subpixel_scale / sqrt(dx * dx + dy * dy)) >> subpixel_shift;
// Initialize the interpolators
m_coord_x = dda2_line_interpolator(x1, x2, len);
@ -374,7 +327,6 @@ namespace agg
m_scale_y = dda2_line_interpolator(sy1, sy2, len);
}
//----------------------------------------------------------------
void resynchronize(double xe, double ye, unsigned len)
{
@ -391,7 +343,7 @@ namespace agg
int x2 = iround(xt * subpixel_scale);
int y2 = iround(yt * subpixel_scale);
const double delta = 1/double(subpixel_scale);
const double delta = 1 / double(subpixel_scale);
double dx;
double dy;
@ -401,7 +353,7 @@ namespace agg
m_trans_inv.transform(&dx, &dy);
dx -= xe;
dy -= ye;
int sx2 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
int sx2 = uround(subpixel_scale / sqrt(dx * dx + dy * dy)) >> subpixel_shift;
// Calculate scale by Y at x2,y2
dx = xt;
@ -409,7 +361,7 @@ namespace agg
m_trans_inv.transform(&dx, &dy);
dx -= xe;
dy -= ye;
int sy2 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
int sy2 = uround(subpixel_scale / sqrt(dx * dx + dy * dy)) >> subpixel_shift;
// Initialize the interpolators
m_coord_x = dda2_line_interpolator(x1, x2, len);
@ -418,7 +370,6 @@ namespace agg
m_scale_y = dda2_line_interpolator(sy1, sy2, len);
}
//----------------------------------------------------------------
void operator++()
{
@ -443,10 +394,7 @@ namespace agg
}
//----------------------------------------------------------------
void transform(double* x, double* y) const
{
m_trans_dir.transform(x, y);
}
void transform(double* x, double* y) const { m_trans_dir.transform(x, y); }
private:
trans_type m_trans_dir;
@ -455,8 +403,8 @@ namespace agg
dda2_line_interpolator m_coord_y;
dda2_line_interpolator m_scale_x;
dda2_line_interpolator m_scale_y;
};
};
}
} // namespace agg
#endif

Some files were not shown because too many files have changed in this diff Show more