void reproject_and_scale_raster(raster & target, raster const& source, proj_transform const& prj_trans, double offset_x, double offset_y, unsigned mesh_size, double filter_radius, scaling_method_e scaling_method) { CoordTransform ts(source.data_.width(), source.data_.height(), source.ext_); CoordTransform tt(target.data_.width(), target.data_.height(), target.ext_, offset_x, offset_y); unsigned i, j; unsigned mesh_nx = ceil(source.data_.width()/double(mesh_size)+1); unsigned mesh_ny = ceil(source.data_.height()/double(mesh_size)+1); ImageData<double> xs(mesh_nx, mesh_ny); ImageData<double> ys(mesh_nx, mesh_ny); // Precalculate reprojected mesh for(j=0; j<mesh_ny; j++) { for (i=0; i<mesh_nx; i++) { xs(i,j) = i*mesh_size; ys(i,j) = j*mesh_size; ts.backward(&xs(i,j), &ys(i,j)); } } prj_trans.backward(xs.getData(), ys.getData(), NULL, mesh_nx*mesh_ny); // Initialize AGG objects typedef agg::pixfmt_rgba32 pixfmt; typedef pixfmt::color_type color_type; typedef agg::renderer_base<pixfmt> renderer_base; typedef agg::pixfmt_rgba32_pre pixfmt_pre; typedef agg::renderer_base<pixfmt_pre> renderer_base_pre; agg::rasterizer_scanline_aa<> rasterizer; agg::scanline_u8 scanline; agg::rendering_buffer buf((unsigned char*)target.data_.getData(), target.data_.width(), target.data_.height(), target.data_.width()*4); pixfmt_pre pixf_pre(buf); renderer_base_pre rb_pre(pixf_pre); rasterizer.clip_box(0, 0, target.data_.width(), target.data_.height()); agg::rendering_buffer buf_tile( (unsigned char*)source.data_.getData(), source.data_.width(), source.data_.height(), source.data_.width() * 4); pixfmt pixf_tile(buf_tile); typedef agg::image_accessor_clone<pixfmt> img_accessor_type; img_accessor_type ia(pixf_tile); agg::span_allocator<color_type> sa; // Initialize filter agg::image_filter_lut filter; switch(scaling_method) { case SCALING_NEAR: break; case SCALING_BILINEAR8: // TODO - impl this or remove? case SCALING_BILINEAR: filter.calculate(agg::image_filter_bilinear(), true); break; case SCALING_BICUBIC: filter.calculate(agg::image_filter_bicubic(), true); break; case SCALING_SPLINE16: filter.calculate(agg::image_filter_spline16(), true); break; case SCALING_SPLINE36: filter.calculate(agg::image_filter_spline36(), true); break; case SCALING_HANNING: filter.calculate(agg::image_filter_hanning(), true); break; case SCALING_HAMMING: filter.calculate(agg::image_filter_hamming(), true); break; case SCALING_HERMITE: filter.calculate(agg::image_filter_hermite(), true); break; case SCALING_KAISER: filter.calculate(agg::image_filter_kaiser(), true); break; case SCALING_QUADRIC: filter.calculate(agg::image_filter_quadric(), true); break; case SCALING_CATROM: filter.calculate(agg::image_filter_catrom(), true); break; case SCALING_GAUSSIAN: filter.calculate(agg::image_filter_gaussian(), true); break; case SCALING_BESSEL: filter.calculate(agg::image_filter_bessel(), true); break; case SCALING_MITCHELL: filter.calculate(agg::image_filter_mitchell(), true); break; case SCALING_SINC: filter.calculate(agg::image_filter_sinc(filter_radius), true); break; case SCALING_LANCZOS: filter.calculate(agg::image_filter_lanczos(filter_radius), true); break; case SCALING_BLACKMAN: filter.calculate(agg::image_filter_blackman(filter_radius), true); break; } // Project mesh cells into target interpolating raster inside each one for(j=0; j<mesh_ny-1; j++) { for (i=0; i<mesh_nx-1; i++) { double polygon[8] = {xs(i,j), ys(i,j), xs(i+1,j), ys(i+1,j), xs(i+1,j+1), ys(i+1,j+1), xs(i,j+1), ys(i,j+1)}; tt.forward(polygon+0, polygon+1); tt.forward(polygon+2, polygon+3); tt.forward(polygon+4, polygon+5); tt.forward(polygon+6, polygon+7); rasterizer.reset(); rasterizer.move_to_d(polygon[0]-1, polygon[1]-1); rasterizer.line_to_d(polygon[2]+1, polygon[3]-1); rasterizer.line_to_d(polygon[4]+1, polygon[5]+1); rasterizer.line_to_d(polygon[6]-1, polygon[7]+1); unsigned x0 = i * mesh_size; unsigned y0 = j * mesh_size; unsigned x1 = (i+1) * mesh_size; unsigned y1 = (j+1) * mesh_size; agg::trans_affine tr(polygon, x0, y0, x1, y1); if (tr.is_valid()) { typedef agg::span_interpolator_linear<agg::trans_affine> interpolator_type; interpolator_type interpolator(tr); if (scaling_method == SCALING_NEAR) { typedef agg::span_image_filter_rgba_nn <img_accessor_type, interpolator_type> span_gen_type; span_gen_type sg(ia, interpolator); agg::render_scanlines_aa(rasterizer, scanline, rb_pre, sa, sg); } else { typedef mapnik::span_image_resample_rgba_affine <img_accessor_type> span_gen_type; span_gen_type sg(ia, interpolator, filter); agg::render_scanlines_aa(rasterizer, scanline, rb_pre, sa, sg); } } } } }
virtual void on_draw() { typedef agg::renderer_base<pixfmt> renderer_base; typedef agg::renderer_base<pixfmt_pre> renderer_base_pre; pixfmt pixf(rbuf_window()); pixfmt_pre pixf_pre(rbuf_window()); renderer_base rb(pixf); renderer_base_pre rb_pre(pixf_pre); rb.clear(agg::rgba(1.0, 1.0, 1.0)); agg::trans_affine src_mtx; src_mtx *= agg::trans_affine_translation(-initial_width()/2 - 10, -initial_height()/2 - 20 - 10); src_mtx *= agg::trans_affine_rotation(m_angle.value() * agg::pi / 180.0); src_mtx *= agg::trans_affine_scaling(m_scale.value()); src_mtx *= agg::trans_affine_translation(initial_width()/2, initial_height()/2 + 20); src_mtx *= trans_affine_resizing(); agg::trans_affine img_mtx; img_mtx *= agg::trans_affine_translation(-initial_width()/2 + 10, -initial_height()/2 + 20 + 10); img_mtx *= agg::trans_affine_rotation(m_angle.value() * agg::pi / 180.0); img_mtx *= agg::trans_affine_scaling(m_scale.value()); img_mtx *= agg::trans_affine_translation(initial_width()/2, initial_height()/2 + 20); img_mtx *= trans_affine_resizing(); img_mtx.invert(); agg::span_allocator<color_type> sa; typedef agg::span_interpolator_linear<> interpolator_type; interpolator_type interpolator(img_mtx); typedef agg::image_accessor_clip<pixfmt> img_source_type; pixfmt img_pixf(rbuf_img(0)); img_source_type img_src(img_pixf, agg::rgba_pre(0, 0.4, 0, 0.5)); /* // Version without filtering (nearest neighbor) //------------------------------------------ typedef agg::span_image_filter_rgb_nn<img_source_type, interpolator_type> span_gen_type; span_gen_type sg(img_src, interpolator); //------------------------------------------ */ // Version with "hardcoded" bilinear filter and without // image_accessor (direct filter, the old variant) //------------------------------------------ typedef agg::span_image_filter_rgb_bilinear_clip<pixfmt, interpolator_type> span_gen_type; span_gen_type sg(img_pixf, agg::rgba_pre(0, 0.4, 0, 0.5), interpolator); //------------------------------------------ /* // Version with arbitrary 2x2 filter //------------------------------------------ typedef agg::span_image_filter_rgb_2x2<img_source_type, interpolator_type> span_gen_type; agg::image_filter<agg::image_filter_kaiser> filter; span_gen_type sg(img_src, interpolator, filter); //------------------------------------------ */ /* // Version with arbitrary filter //------------------------------------------ typedef agg::span_image_filter_rgb<img_source_type, interpolator_type> span_gen_type; agg::image_filter<agg::image_filter_spline36> filter; span_gen_type sg(img_src, interpolator, filter); //------------------------------------------ */ agg::rasterizer_scanline_aa<> ras; ras.clip_box(0, 0, width(), height()); agg::scanline_u8 sl; double r = initial_width(); if(initial_height() - 60 < r) r = initial_height() - 60; agg::ellipse ell(initial_width() / 2.0 + 10, initial_height() / 2.0 + 20 + 10, r / 2.0 + 16.0, r / 2.0 + 16.0, 200); agg::conv_transform<agg::ellipse> tr(ell, src_mtx); ras.add_path(tr); agg::render_scanlines_aa(ras, sl, rb_pre, sa, sg); agg::render_ctrl(ras, sl, rb, m_angle); agg::render_ctrl(ras, sl, rb, m_scale); }
virtual void on_draw() { pixfmt pixf(rbuf_window()); pixfmt_pre pixf_pre(rbuf_window()); renderer_base rb(pixf); renderer_base_pre rb_pre(pixf_pre); if(!m_test_flag) { rb.clear(agg::rgba(1, 1, 1)); } if(m_trans_type.cur_item() == 0) { // For the affine parallelogram transformations we // calculate the 4-th (implicit) point of the parallelogram m_quad.xn(3) = m_quad.xn(0) + (m_quad.xn(2) - m_quad.xn(1)); m_quad.yn(3) = m_quad.yn(0) + (m_quad.yn(2) - m_quad.yn(1)); } if(!m_test_flag) { //-------------------------- // Render the "quad" tool and controls g_rasterizer.add_path(m_quad); agg::render_scanlines_aa_solid(g_rasterizer, g_scanline, rb, agg::rgba(0, 0.3, 0.5, 0.6)); //-------------------------- agg::render_ctrl(g_rasterizer, g_scanline, rb, m_trans_type); } // Prepare the polygon to rasterize. Here we need to fill // the destination (transformed) polygon. g_rasterizer.clip_box(0, 0, width(), height()); g_rasterizer.reset(); g_rasterizer.move_to_d(m_quad.xn(0), m_quad.yn(0)); g_rasterizer.line_to_d(m_quad.xn(1), m_quad.yn(1)); g_rasterizer.line_to_d(m_quad.xn(2), m_quad.yn(2)); g_rasterizer.line_to_d(m_quad.xn(3), m_quad.yn(3)); typedef agg::span_allocator<color_type> span_alloc_type; span_alloc_type sa; agg::image_filter<agg::image_filter_hanning> filter; typedef agg::wrap_mode_reflect_auto_pow2 remainder_type; typedef agg::image_accessor_wrap<pixfmt, remainder_type, remainder_type> img_source_type; pixfmt img_pixf(rbuf_img(0)); img_source_type img_src(img_pixf); enum subdiv_shift_e { subdiv_shift = 2 }; switch(m_trans_type.cur_item()) { case 0: { // Note that we consruct an affine matrix that transforms // a parallelogram to a rectangle, i.e., it's inverted. // It's actually the same as: // tr(g_x1, g_y1, g_x2, g_y2, m_triangle.polygon()); // tr.invert(); agg::trans_affine tr(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2); // Also note that we can use the linear interpolator instead of // arbitrary span_interpolator_trans. It works much faster, // but the transformations must be linear and parellel. typedef agg::span_interpolator_linear<agg::trans_affine> interpolator_type; interpolator_type interpolator(tr); typedef span_image_filter_2x2<img_source_type, interpolator_type> span_gen_type; span_gen_type sg(img_src, interpolator, filter); agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg); break; } case 1: { agg::trans_bilinear tr(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2); if(tr.is_valid()) { typedef agg::span_interpolator_linear<agg::trans_bilinear> interpolator_type; interpolator_type interpolator(tr); typedef span_image_filter_2x2<img_source_type, interpolator_type> span_gen_type; span_gen_type sg(img_src, interpolator, filter); agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg); } break; } case 2: { agg::trans_perspective tr(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2); if(tr.is_valid()) { typedef agg::span_interpolator_linear_subdiv<agg::trans_perspective, 8> interpolator_type; interpolator_type interpolator(tr); typedef span_image_filter_2x2<img_source_type, interpolator_type> span_gen_type; span_gen_type sg(img_src, interpolator, filter); agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg); } break; } } }
//------------------------------------------------------------------------ virtual void on_draw() { double width = rbuf_window().width(); double height = rbuf_window().height(); typedef agg::renderer_base<pixfmt> renderer_base; typedef agg::renderer_base<pixfmt_pre> renderer_base_pre; pixfmt pixf(rbuf_window()); pixfmt_pre pixf_pre(rbuf_window()); renderer_base rb(pixf); renderer_base_pre rb_pre(pixf_pre); rb.clear(agg::rgba(1.0, 1.0, 1.0)); agg::trans_affine polygon_mtx; polygon_mtx *= agg::trans_affine_translation(-m_polygon_cx, -m_polygon_cy); polygon_mtx *= agg::trans_affine_rotation(m_polygon_angle.value() * agg::pi / 180.0); polygon_mtx *= agg::trans_affine_scaling(m_polygon_scale.value()); polygon_mtx *= agg::trans_affine_translation(m_polygon_cx, m_polygon_cy); double r = initial_width() / 3.0 - 8.0; create_star(m_polygon_cx, m_polygon_cy, r, r / 1.45, 14); agg::conv_transform<agg::path_storage> tr(m_ps, polygon_mtx); typedef agg::wrap_mode_reflect_auto_pow2 wrap_x_type; typedef agg::wrap_mode_reflect_auto_pow2 wrap_y_type; typedef agg::image_accessor_wrap<pixfmt, wrap_x_type, wrap_y_type> img_source_type; typedef agg::span_pattern_rgba<img_source_type> span_gen_type; unsigned offset_x = 0; unsigned offset_y = 0; if(m_tie_pattern.status()) { offset_x = unsigned(width-m_polygon_cx); offset_y = unsigned(height-m_polygon_cy); } agg::span_allocator<color_type> sa; pixfmt img_pixf(m_pattern_rbuf); img_source_type img_src(img_pixf); span_gen_type sg(img_src, offset_x, offset_y); // Alpha is meaningful for RGB only because RGBA has its own sg.alpha(span_gen_type::value_type(m_pattern_alpha.value() * 255.0)); m_ras.add_path(tr); agg::render_scanlines_aa(m_ras, m_sl, rb_pre, sa, sg); agg::render_ctrl(m_ras, m_sl, rb, m_polygon_angle); agg::render_ctrl(m_ras, m_sl, rb, m_polygon_scale); agg::render_ctrl(m_ras, m_sl, rb, m_pattern_angle); agg::render_ctrl(m_ras, m_sl, rb, m_pattern_size); agg::render_ctrl(m_ras, m_sl, rb, m_pattern_alpha); agg::render_ctrl(m_ras, m_sl, rb, m_rotate_polygon); agg::render_ctrl(m_ras, m_sl, rb, m_rotate_pattern); agg::render_ctrl(m_ras, m_sl, rb, m_tie_pattern); }
void Display::impl::draw() { SDL_PumpEvents(); pixfmt pixf(rbwindow); pixfmt pixf_pre(rbwindow); base_renderer rb(pixf); base_renderer rb_pre(pixf_pre); solid_renderer rs(rb); renderer_bin rbin(rb); agg::scanline_u8 sl; agg::rasterizer_scanline_aa<> pf; if (fondo) SDL_BlitSurface(fondo.get(), 0, window.get(), 0); else rb.clear(agg::rgba(0, 0, 0)); agg::glyph_rendering gren = agg::glyph_ren_agg_gray8; if(m_feng.load_font("timesi.ttf", 0, gren)) { m_feng.hinting(1); m_feng.flip_y(1); for (impl::it_tsprites it = textSprites.begin() ,end = textSprites.end() ;it!= end ;++it) { TextSprite::impl* tsimpl = *it; if (tsimpl->visible) { m_feng.height(tsimpl->size); m_feng.width(tsimpl->size); m_contour.width(-tsimpl->size * tsimpl->size * 0.05); double x = tsimpl->x; double y0 = tsimpl->y + tsimpl->size; double y = y0; for (std::string::iterator letra = tsimpl->caption.begin(), last = tsimpl->caption.end(); letra != last; ++letra) { const agg::glyph_cache* glyph = m_fman.glyph(*letra); if (glyph) { m_fman.init_embedded_adaptors(glyph, x, y); rs.color(agg::rgba8(0, 0, 0)); agg::render_scanlines(m_fman.gray8_adaptor(), m_fman.gray8_scanline(), rs); x += glyph->advance_x; y += glyph->advance_y; } } } } } for (impl::it_sprites it = sprites.begin() ,end = sprites.end() ;it!= end ;++it) { Sprite::impl* simpl = *it; if (simpl->visible) { agg::rendering_buffer buffer((unsigned char*)simpl->surface->pixels, simpl->surface->w, simpl->surface->h, simpl->surface->pitch); interpolator_type interpolator; span_alloc_type sa; span_gen_type sg(sa, buffer, agg::rgba_pre(0, 0, 0, 0), interpolator); renderer_type ri; agg::rounded_rect rec(0, 0, buffer.width(), buffer.height(), 0); agg::trans_affine src_mtx; src_mtx *= agg::trans_affine_translation(simpl->x, simpl->y); agg::trans_affine img_mtx = src_mtx; img_mtx.invert(); interpolator.transformer(img_mtx); ri.attach(rb_pre, sg); agg::rounded_rect rrect(0, 0, buffer.width(), buffer.height(), 0); agg::conv_transform<agg::rounded_rect> tr(rrect, src_mtx); pf.add_path(tr); agg::render_scanlines(pf, sl, ri); } } SDL_BlitSurface(window.get(), 0, screen, 0); SDL_Flip(screen); }
void transform_image(double angle) { double width = rbuf_img(0).width(); double height = rbuf_img(0).height(); pixfmt pixf(rbuf_img(0)); pixfmt_pre pixf_pre(rbuf_img(0)); renderer_base rb(pixf); renderer_base_pre rb_pre(pixf_pre); rb.clear(agg::rgba(1.0, 1.0, 1.0)); agg::rasterizer_scanline_aa<> ras; agg::scanline_u8 sl; agg::span_allocator<color_type> sa; agg::trans_affine src_mtx; src_mtx *= agg::trans_affine_translation(-width/2.0, -height/2.0); src_mtx *= agg::trans_affine_rotation(angle * agg::pi / 180.0); src_mtx *= agg::trans_affine_translation(width/2.0, height/2.0); agg::trans_affine img_mtx = src_mtx; img_mtx.invert(); double r = width; if(height < r) r = height; r *= 0.5; r -= 4.0; agg::ellipse ell(width / 2.0, height / 2.0, r, r, 200); agg::conv_transform<agg::ellipse> tr(ell, src_mtx); m_num_pix += r * r * agg::pi; typedef agg::span_interpolator_linear<> interpolator_type; interpolator_type interpolator(img_mtx); agg::image_filter_lut filter; bool norm = m_normalize.status(); switch(m_filters.cur_item()) { case 0: { typedef agg::span_image_filter_nn<color_type, #ifdef AGG_COMPONENT_ORDER component_order, #endif interpolator_type> span_gen_type; typedef agg::renderer_scanline_aa<renderer_base_pre, span_gen_type> renderer_type; span_gen_type sg(sa, rbuf_img(1), agg::rgba(0,0,0,0), interpolator); renderer_type ri(rb_pre, sg); ras.add_path(tr); agg::render_scanlines(ras, sl, ri); } break; case 1: { typedef agg::span_image_filter_bilinear<color_type, #ifdef AGG_COMPONENT_ORDER component_order, #endif interpolator_type> span_gen_type; typedef agg::renderer_scanline_aa<renderer_base_pre, span_gen_type> renderer_type; span_gen_type sg(sa, rbuf_img(1), agg::rgba(0,0,0,0), interpolator); renderer_type ri(rb_pre, sg); ras.add_path(tr); agg::render_scanlines(ras, sl, ri); } break; case 5: case 6: case 7: { switch(m_filters.cur_item()) { case 5: filter.calculate(agg::image_filter_hanning(), norm); break; case 6: filter.calculate(agg::image_filter_hamming(), norm); break; case 7: filter.calculate(agg::image_filter_hermite(), norm); break; } typedef agg::span_image_filter_2x2<color_type, #ifdef AGG_COMPONENT_ORDER component_order, #endif interpolator_type> span_gen_type; typedef agg::renderer_scanline_aa<renderer_base_pre, span_gen_type> renderer_type; span_gen_type sg(sa, rbuf_img(1), agg::rgba(0,0,0,0), interpolator, filter); renderer_type ri(rb_pre, sg); ras.add_path(tr); agg::render_scanlines(ras, sl, ri); } break; case 2: case 3: case 4: case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15: case 16: { switch(m_filters.cur_item()) { case 2: filter.calculate(agg::image_filter_bicubic(), norm); break; case 3: filter.calculate(agg::image_filter_spline16(), norm); break; case 4: filter.calculate(agg::image_filter_spline36(), norm); break; case 8: filter.calculate(agg::image_filter_kaiser(), norm); break; case 9: filter.calculate(agg::image_filter_quadric(), norm); break; case 10: filter.calculate(agg::image_filter_catrom(), norm); break; case 11: filter.calculate(agg::image_filter_gaussian(), norm); break; case 12: filter.calculate(agg::image_filter_bessel(), norm); break; case 13: filter.calculate(agg::image_filter_mitchell(), norm); break; case 14: filter.calculate(agg::image_filter_sinc(m_radius.value()), norm); break; case 15: filter.calculate(agg::image_filter_lanczos(m_radius.value()), norm); break; case 16: filter.calculate(agg::image_filter_blackman(m_radius.value()), norm); break; } typedef agg::span_image_filter<color_type, #ifdef AGG_COMPONENT_ORDER component_order, #endif interpolator_type> span_gen_type; typedef agg::renderer_scanline_aa<renderer_base_pre, span_gen_type> renderer_type; span_gen_type sg(sa, rbuf_img(1), agg::rgba(0,0,0,0), interpolator, filter); renderer_type ri(rb_pre, sg); ras.add_path(tr); agg::render_scanlines(ras, sl, ri); } break; } }
virtual void on_draw() { if(m_gamma.value() != m_old_gamma) { m_gamma_lut.gamma(m_gamma.value()); load_img(0, "spheres"); pixfmt pixf(rbuf_img(0)); pixf.apply_gamma_dir(m_gamma_lut); m_old_gamma = m_gamma.value(); } pixfmt pixf(rbuf_window()); pixfmt_pre pixf_pre(rbuf_window()); renderer_base rb(pixf); renderer_base_pre rb_pre(pixf_pre); renderer_solid r(rb); rb.clear(agg::rgba(1, 1, 1)); if(m_trans_type.cur_item() < 2) { // For the affine parallelogram transformations we // calculate the 4-th (implicit) point of the parallelogram m_quad.xn(3) = m_quad.xn(0) + (m_quad.xn(2) - m_quad.xn(1)); m_quad.yn(3) = m_quad.yn(0) + (m_quad.yn(2) - m_quad.yn(1)); } //-------------------------- // Render the "quad" tool and controls g_rasterizer.add_path(m_quad); r.color(agg::rgba(0, 0.3, 0.5, 0.1)); agg::render_scanlines(g_rasterizer, g_scanline, r); // Prepare the polygon to rasterize. Here we need to fill // the destination (transformed) polygon. g_rasterizer.clip_box(0, 0, width(), height()); g_rasterizer.reset(); int b = 0; g_rasterizer.move_to_d(m_quad.xn(0)-b, m_quad.yn(0)-b); g_rasterizer.line_to_d(m_quad.xn(1)+b, m_quad.yn(1)-b); g_rasterizer.line_to_d(m_quad.xn(2)+b, m_quad.yn(2)+b); g_rasterizer.line_to_d(m_quad.xn(3)-b, m_quad.yn(3)+b); typedef agg::span_allocator<color_type> span_alloc_type; span_alloc_type sa; agg::image_filter_bilinear filter_kernel; agg::image_filter_lut filter(filter_kernel, true); pixfmt pixf_img(rbuf_img(0)); typedef agg::image_accessor_clone<pixfmt> source_type; source_type source(pixf_img); start_timer(); switch(m_trans_type.cur_item()) { case 0: { agg::trans_affine tr(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2); typedef agg::span_interpolator_linear<agg::trans_affine> interpolator_type; interpolator_type interpolator(tr); typedef image_filter_2x2_type<source_type, interpolator_type> span_gen_type; span_gen_type sg(source, interpolator, filter); agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg); break; } case 1: { agg::trans_affine tr(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2); typedef agg::span_interpolator_linear<agg::trans_affine> interpolator_type; typedef image_resample_affine_type<source_type> span_gen_type; interpolator_type interpolator(tr); span_gen_type sg(source, interpolator, filter); sg.blur(m_blur.value()); agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg); break; } case 2: { agg::trans_perspective tr(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2); if(tr.is_valid()) { typedef agg::span_interpolator_linear_subdiv<agg::trans_perspective> interpolator_type; interpolator_type interpolator(tr); typedef image_filter_2x2_type<source_type, interpolator_type> span_gen_type; span_gen_type sg(source, interpolator, filter); agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg); } break; } case 3: { agg::trans_perspective tr(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2); if(tr.is_valid()) { typedef agg::span_interpolator_trans<agg::trans_perspective> interpolator_type; interpolator_type interpolator(tr); typedef image_filter_2x2_type<source_type, interpolator_type> span_gen_type; span_gen_type sg(source, interpolator, filter); agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg); } break; } case 4: { typedef agg::span_interpolator_persp_lerp<> interpolator_type; typedef agg::span_subdiv_adaptor<interpolator_type> subdiv_adaptor_type; interpolator_type interpolator(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2); subdiv_adaptor_type subdiv_adaptor(interpolator); if(interpolator.is_valid()) { typedef image_resample_type<source_type, subdiv_adaptor_type> span_gen_type; span_gen_type sg(source, subdiv_adaptor, filter); sg.blur(m_blur.value()); agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg); } break; } case 5: { typedef agg::span_interpolator_persp_exact<> interpolator_type; typedef agg::span_subdiv_adaptor<interpolator_type> subdiv_adaptor_type; interpolator_type interpolator(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2); subdiv_adaptor_type subdiv_adaptor(interpolator); if(interpolator.is_valid()) { typedef image_resample_type<source_type, subdiv_adaptor_type> span_gen_type; span_gen_type sg(source, subdiv_adaptor, filter); sg.blur(m_blur.value()); agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg); } break; } } double tm = elapsed_time(); pixf.apply_gamma_inv(m_gamma_lut); char buf[64]; agg::gsv_text t; t.size(10.0); agg::conv_stroke<agg::gsv_text> pt(t); pt.width(1.5); sprintf(buf, "%3.2f ms", tm); t.start_point(10.0, 70.0); t.text(buf); g_rasterizer.add_path(pt); r.color(agg::rgba(0,0,0)); agg::render_scanlines(g_rasterizer, g_scanline, r); //-------------------------- agg::render_ctrl(g_rasterizer, g_scanline, rb, m_trans_type); agg::render_ctrl(g_rasterizer, g_scanline, rb, m_gamma); agg::render_ctrl(g_rasterizer, g_scanline, rb, m_blur); }