agg/examples/simple_blur.cpp

261 lines
7.1 KiB
C++

#include <stdlib.h>
#include <ctype.h>
#include <stdio.h>
#include "agg_basics.h"
#include "agg_rendering_buffer.h"
#include "agg_rasterizer_scanline_aa.h"
#include "agg_rasterizer_outline.h"
#include "agg_path_storage.h"
#include "agg_conv_stroke.h"
#include "agg_conv_transform.h"
#include "agg_bounding_rect.h"
#include "agg_scanline_u.h"
#include "agg_scanline_p.h"
#include "agg_pixfmt_rgb.h"
#include "agg_renderer_base.h"
#include "agg_renderer_outline_aa.h"
#include "agg_rasterizer_outline_aa.h"
#include "agg_renderer_scanline.h"
#include "agg_span_allocator.h"
#include "agg_ellipse.h"
#include "platform/agg_platform_support.h"
// Note: example currently only supports 8-bit color
#define AGG_BGR24
#include "pixel_formats.h"
enum flip_y_e { flip_y = true };
agg::path_storage g_path;
agg::srgba8 g_colors[100];
unsigned g_path_idx[100];
unsigned g_npaths = 0;
double g_x1 = 0;
double g_y1 = 0;
double g_x2 = 0;
double g_y2 = 0;
double g_base_dx = 0;
double g_base_dy = 0;
double g_angle = 0;
double g_scale = 1.0;
double g_skew_x = 0;
double g_skew_y = 0;
int g_nclick = 0;
unsigned parse_lion(agg::path_storage& ps, agg::srgba8* colors, unsigned* path_idx);
void parse_lion()
{
g_npaths = parse_lion(g_path, g_colors, g_path_idx);
agg::pod_array_adaptor<unsigned> path_idx(g_path_idx, 100);
agg::bounding_rect(g_path, path_idx, 0, g_npaths, &g_x1, &g_y1, &g_x2, &g_y2);
g_base_dx = (g_x2 - g_x1) / 2.0;
g_base_dy = (g_y2 - g_y1) / 2.0;
}
template<class Order> class span_simple_blur_rgb24
{
public:
//--------------------------------------------------------------------
span_simple_blur_rgb24() : m_source_image(0) {}
//--------------------------------------------------------------------
span_simple_blur_rgb24(const agg::rendering_buffer& src) :
m_source_image(&src) {}
//--------------------------------------------------------------------
void source_image(const agg::rendering_buffer& src) { m_source_image = &src; }
const agg::rendering_buffer& source_image() const { return *m_source_image; }
//--------------------------------------------------------------------
void prepare() {}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, int len)
{
if(y < 1 || y >= int(m_source_image->height() - 1))
{
do
{
*span++ = color_type::no_color();
}
while(--len);
return;
}
do
{
color_type::calc_type color[3];
color[0] = color[1] = color[2] = 0;
if(x > 0 && x < int(m_source_image->width()-1))
{
int i = 3;
do
{
const agg::int8u* ptr = m_source_image->row_ptr(y - i + 2) + (x - 1) * 3;
color[0] += *ptr++;
color[1] += *ptr++;
color[2] += *ptr++;
color[0] += *ptr++;
color[1] += *ptr++;
color[2] += *ptr++;
color[0] += *ptr++;
color[1] += *ptr++;
color[2] += *ptr++;
}
while(--i);
color[0] /= 9;
color[1] /= 9;
color[2] /= 9;
}
*span++ = color_type(color[Order::R], color[Order::G], color[Order::B]);
++x;
}
while(--len);
}
private:
const agg::rendering_buffer* m_source_image;
};
class the_application : public agg::platform_support
{
double m_cx;
double m_cy;
public:
virtual ~the_application()
{
}
the_application(agg::pix_format_e format, bool flip_y) :
agg::platform_support(format, flip_y),
m_cx(100),
m_cy(102)
{
parse_lion();
}
virtual void on_resize(int cx, int cy)
{
}
virtual void on_draw()
{
typedef agg::renderer_base<pixfmt> renderer_base;
typedef agg::renderer_scanline_aa_solid<renderer_base> renderer_solid;
pixfmt pixf(rbuf_window());
renderer_base rb(pixf);
renderer_solid rs(rb);
rb.clear(agg::rgba(1, 1, 1));
agg::trans_affine mtx;
agg::conv_transform<agg::path_storage, agg::trans_affine> trans(g_path, mtx);
mtx *= agg::trans_affine_translation(-g_base_dx, -g_base_dy);
mtx *= agg::trans_affine_scaling(g_scale, g_scale);
mtx *= agg::trans_affine_rotation(g_angle + agg::pi);
mtx *= agg::trans_affine_skewing(g_skew_x/1000.0, g_skew_y/1000.0);
mtx *= agg::trans_affine_translation(initial_width()/4, initial_height()/2);
mtx *= trans_affine_resizing();
agg::rasterizer_scanline_aa<> ras2;
agg::scanline_p8 sl;
agg::scanline_u8 sl2;
agg::render_all_paths(ras2, sl, rs, trans, g_colors, g_path_idx, g_npaths);
mtx *= ~trans_affine_resizing();
mtx *= agg::trans_affine_translation(initial_width()/2, 0);
mtx *= trans_affine_resizing();
agg::line_profile_aa profile;
profile.width(1.0);
agg::renderer_outline_aa<renderer_base> rp(rb, profile);
agg::rasterizer_outline_aa<agg::renderer_outline_aa<renderer_base> > ras(rp);
ras.round_cap(true);
ras.render_all_paths(trans, g_colors, g_path_idx, g_npaths);
agg::ellipse ell(m_cx, m_cy, 100.0, 100.0, 100);
agg::conv_stroke<agg::ellipse> ell_stroke1(ell);
ell_stroke1.width(6.0);
agg::conv_stroke<agg::conv_stroke<agg::ellipse> > ell_stroke2(ell_stroke1);
ell_stroke2.width(2.0);
rs.color(agg::rgba(0,0.2,0));
ras2.add_path(ell_stroke2);
agg::render_scanlines(ras2, sl, rs);
typedef span_simple_blur_rgb24<component_order> span_blur_gen;
typedef agg::span_allocator<color_type> span_blur_alloc;
span_blur_alloc sa;
span_blur_gen sg;
sg.source_image(rbuf_img(0));
ras2.add_path(ell);
copy_window_to_img(0);
agg::render_scanlines_aa(ras2, sl2, rb, sa, sg);
// More blur if desired :-)
//copy_window_to_img(0);
//agg::render_scanlines(ras2, sl2, rblur);
//copy_window_to_img(0);
//agg::render_scanlines(ras2, sl2, rblur);
//copy_window_to_img(0);
//agg::render_scanlines(ras2, sl2, rblur);
}
virtual void on_mouse_button_down(int x, int y, unsigned flags)
{
if(flags & agg::mouse_left)
{
m_cx = x;
m_cy = y;
force_redraw();
}
}
virtual void on_mouse_move(int x, int y, unsigned flags)
{
on_mouse_button_down(x, y, flags);
}
};
int agg_main(int argc, char* argv[])
{
the_application app(pix_format, flip_y);
app.caption("AGG Example. Lion with Alpha-Masking");
if(app.init(512, 400, agg::window_resize))
{
return app.run();
}
return 1;
}