Difference between revisions of "Slicer3:Editor:Rasterizing:AGGextended demo"

From NAMIC Wiki
Jump to: navigation, search
(Replacing page with '<big>'''Note:''' We are migrating this content to the slicer.org domain - <font color="orange">The newer page is [http://www.slicer.org/slicerWiki/index.php/Slicer3:Editor:Rast...')
Line 1: Line 1:
An example from [http://antigrain.com The Antigrain Graphics (AGG)] code extended to 7 vertices.
+
<big>'''Note:''' We are migrating this content to the slicer.org domain - <font color="orange">The newer page is [http://www.slicer.org/slicerWiki/index.php/Slicer3:Editor:Rasterizing:AGGextended_demo here]</font></big>a
 
 
[[Image:Agg-intersection.png|right|thumb|202px]]
 
 
 
<nowiki>
 
#include "agg_basics.h"
 
#include "agg_rendering_buffer.h"
 
#include "agg_rasterizer_scanline_aa.h"
 
#include "agg_scanline_u.h"
 
#include "agg_renderer_scanline.h"
 
#include "agg_pixfmt_rgb.h"
 
#include "platform/agg_platform_support.h"
 
#include "ctrl/agg_slider_ctrl.h"
 
#include "ctrl/agg_cbox_ctrl.h"
 
 
 
enum flip_y_e { flip_y = true };
 
 
#define NUMPOINTS 7
 
 
namespace agg
 
{
 
 
    class square
 
    {
 
    public:
 
        square(double size) : m_size(size) {}
 
 
        template<class Rasterizer, class Scanline, class Renderer, class ColorT>
 
        void draw(Rasterizer& ras, Scanline& sl, Renderer& ren, ColorT color,
 
                  double x, double y)
 
        {
 
            ras.reset();
 
            ras.move_to_d(x*m_size,        y*m_size);
 
            ras.line_to_d(x*m_size+m_size, y*m_size);
 
            ras.line_to_d(x*m_size+m_size, y*m_size+m_size);
 
            ras.line_to_d(x*m_size,        y*m_size+m_size);
 
            agg::render_scanlines_aa_solid(ras, sl, ren, color);
 
        }
 
 
    private:
 
        double m_size;
 
    };
 
 
 
 
    template<class Renderer> class renderer_enlarged
 
    {
 
    public:
 
        renderer_enlarged(Renderer& ren, double size) :
 
            m_ren(ren),
 
            m_square(size),
 
            m_size(size) {}
 
 
        //--------------------------------------------------------------------
 
        void color(rgba8 c) { m_color = c; }
 
 
        //--------------------------------------------------------------------
 
        void prepare() {}
 
 
        //--------------------------------------------------------------------
 
        template<class Scanline> void render(const Scanline& sl)
 
        {
 
            int y = sl.y();
 
 
            unsigned num_spans = sl.num_spans();
 
            typename Scanline::const_iterator span = sl.begin();
 
 
            do
 
            {
 
                int x = span->x;
 
                const typename Scanline::cover_type* covers = span->covers;
 
                int num_pix = span->len;
 
 
                do
 
                {
 
                    int a = (*covers++ * m_color.a) >> 8;
 
                    m_square.draw(m_ras, m_sl, m_ren,
 
                                  rgba8(m_color.r, m_color.g, m_color.b, a),
 
                                  x, y);
 
                    ++x;
 
                }
 
                while(--num_pix);
 
            }
 
            while(--num_spans);
 
        }
 
 
    private:
 
        rasterizer_scanline_aa<> m_ras;
 
        scanline_u8 m_sl;
 
        Renderer&  m_ren;
 
        square      m_square;
 
        rgba8      m_color;
 
        double      m_size;
 
    };
 
 
 
 
};
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
class the_application : public agg::platform_support
 
{
 
    double m_x[NUMPOINTS];
 
    double m_y[NUMPOINTS];
 
    double m_dx;
 
    double m_dy;
 
    int    m_idx;
 
    int m_numPoints;
 
 
    agg::slider_ctrl<agg::rgba8> m_slider1;
 
    agg::slider_ctrl<agg::rgba8> m_slider2;
 
 
public:
 
    the_application(agg::pix_format_e format, bool flip_y) :
 
        agg::platform_support(format, flip_y),
 
        m_slider1(80, 10,    600-10, 19,    !flip_y),
 
        m_slider2(80, 10+20, 600-10, 19+20, !flip_y)
 
    {
 
        m_idx = -1;
 
        m_numPoints = NUMPOINTS;
 
        m_x[0] = 57;    m_y[0] = 100;
 
        m_x[1] = 369;  m_y[1] = 170;
 
        m_x[2] = 143;  m_y[2] = 310;
 
        m_x[3] = 153;  m_y[3] = 310;
 
        m_x[4] = 143;  m_y[4] = 360;
 
        m_x[5] = 173;  m_y[5] = 360;
 
        m_x[6] = 173;  m_y[6] = 380;
 
 
        add_ctrl(m_slider1);
 
        add_ctrl(m_slider2);
 
 
        m_slider1.range(8.0, 100.0);
 
        m_slider1.num_steps(23);
 
        m_slider1.value(32.0);
 
 
        m_slider2.range(0.1, 3.0);
 
        m_slider2.value(1.0);
 
 
        m_slider1.label("Pixel size=%1.0f");
 
        m_slider2.label("Gamma=%4.3f");
 
 
        m_slider1.no_transform();
 
        m_slider2.no_transform();
 
    }
 
 
 
    virtual ~the_application()
 
    {
 
    }
 
 
 
    virtual void on_init()
 
    {
 
    }
 
 
 
    virtual void on_draw()
 
    {
 
        typedef agg::renderer_base<agg::pixfmt_bgr24> ren_base;
 
 
        agg::pixfmt_bgr24 pixf(rbuf_window());
 
        ren_base ren(pixf);
 
        agg::scanline_u8 sl;
 
 
        ren.clear(agg::rgba(1,1,1));
 
 
        agg::rasterizer_scanline_aa<> ras;
 
 
        int size_mul = int(m_slider1.value());
 
 
        ras.gamma(agg::gamma_power(m_slider2.value()));
 
        ras.filling_rule(agg::fill_even_odd);
 
 
        agg::renderer_enlarged<ren_base> ren_en(ren, size_mul);
 
 
        ras.reset();
 
 
        ras.move_to_d(m_x[0]/size_mul, m_y[0]/size_mul);
 
        for (int i = 0; i < m_numPoints; i++)
 
          {
 
          ras.line_to_d(m_x[i]/size_mul, m_y[i]/size_mul);
 
          }
 
 
        ren_en.color(agg::rgba8(0,255,0, 255));
 
        agg::render_scanlines(ras, sl, ren_en);
 
 
 
        agg::render_scanlines_aa_solid(ras, sl, ren, agg::rgba8(0,0,0));
 
 
        ras.gamma(agg::gamma_none());
 
 
        agg::path_storage ps;
 
        agg::conv_stroke<agg::path_storage> pg(ps);
 
        pg.width(2.0);
 
 
        for (int i = 0; i < m_numPoints; i++)
 
          {
 
          int nextPoint = (i+1)%m_numPoints;
 
          ps.remove_all();
 
          ps.move_to(m_x[i], m_y[i]);
 
          ps.line_to(m_x[nextPoint], m_y[nextPoint]);
 
          ras.add_path(pg);
 
          agg::render_scanlines_aa_solid(ras, sl, ren, agg::rgba8(0,150,160, 200));
 
          }
 
 
 
        // Render the controls
 
        agg::render_ctrl(ras, sl, ren, m_slider1);
 
        agg::render_ctrl(ras, sl, ren, m_slider2);
 
    }
 
 
 
 
   
 
    virtual void on_mouse_button_down(int x, int y, unsigned flags)
 
    {
 
        if(flags & agg::mouse_left)
 
        {
 
            unsigned i;
 
            for (i = 0; i < m_numPoints; i++)
 
            {
 
                if(sqrt( (x-m_x[i]) * (x-m_x[i]) + (y-m_y[i]) * (y-m_y[i]) ) < 10.0)
 
                {
 
                    m_dx = x - m_x[i];
 
                    m_dy = y - m_y[i];
 
                    m_idx = i;
 
                    break;
 
                }
 
            }
 
            if(i == m_numPoints + 1)
 
            {
 
                if(agg::point_in_triangle(m_x[0], m_y[0],
 
                                          m_x[1], m_y[1],
 
                                          m_x[2], m_y[2],
 
                                          x, y))
 
                {
 
                    m_dx = x - m_x[0];
 
                    m_dy = y - m_y[0];
 
                    m_idx = m_numPoints + 1;
 
                }
 
            }
 
        }
 
    }
 
 
 
    virtual void on_mouse_move(int x, int y, unsigned flags)
 
    {
 
        if(flags & agg::mouse_left)
 
        {
 
            if(m_idx == m_numPoints + 1)
 
            {
 
                double dx = x - m_dx;
 
                double dy = y - m_dy;
 
                m_x[1] -= m_x[0] - dx;
 
                m_y[1] -= m_y[0] - dy;
 
                m_x[2] -= m_x[0] - dx;
 
                m_y[2] -= m_y[0] - dy;
 
                m_x[0] = dx;
 
                m_y[0] = dy;
 
                force_redraw();
 
                return;
 
            }
 
 
            if(m_idx >= 0)
 
            {
 
                m_x[m_idx] = x - m_dx;
 
                m_y[m_idx] = y - m_dy;
 
                force_redraw();
 
            }
 
        }
 
        else
 
        {
 
            on_mouse_button_up(x, y, flags);
 
        }
 
    }
 
 
    virtual void on_mouse_button_up(int x, int y, unsigned flags)
 
    {
 
        m_idx = -1;
 
    }
 
};
 
 
 
int agg_main(int argc, char* argv[])
 
{
 
    the_application app(agg::pix_format_bgr24, flip_y);
 
    app.caption("AGG Example. Anti-Aliasing Demo");
 
 
    if(app.init(600, 400, agg::window_resize))
 
    {
 
        return app.run();
 
    }
 
    return 1;
 
}
 
 
 
 
 
 
</nowiki>
 

Revision as of 18:44, 19 May 2008

Home < Slicer3:Editor:Rasterizing:AGGextended demo

Note: We are migrating this content to the slicer.org domain - The newer page is herea