virtual void on_draw() { typedef agg::pixfmt_bgra32 pixfmt; 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 ren(rb); rb.clear(agg::rgba(1,1,1)); agg::rasterizer_scanline_aa<> ras; agg::scanline_p8 sl; agg::trans_affine mtx; ras.gamma(agg::gamma_power(m_gamma.value())); mtx *= agg::trans_affine_translation((m_min_x + m_max_x) * -0.5, (m_min_y + m_max_y) * -0.5); mtx *= agg::trans_affine_scaling(m_scale.value()); mtx *= agg::trans_affine_rotation(agg::deg2rad(m_rotate.value())); mtx *= agg::trans_affine_translation((m_min_x + m_max_x) * 0.5 + m_x, (m_min_y + m_max_y) * 0.5 + m_y + 30); m_path.expand(m_expand.value()); start_timer(); m_path.render(ras, sl, ren, mtx, rb.clip_box(), 1.0); double tm = elapsed_time(); unsigned vertex_count = m_path.vertex_count(); ras.gamma(agg::gamma_none()); agg::render_ctrl(ras, sl, rb, m_expand); agg::render_ctrl(ras, sl, rb, m_gamma); agg::render_ctrl(ras, sl, rb, m_scale); agg::render_ctrl(ras, sl, rb, m_rotate); char buf[128]; agg::gsv_text t; t.size(10.0); t.flip(true); agg::conv_stroke<agg::gsv_text> pt(t); pt.width(1.5); sprintf(buf, "Vertices=%d Time=%.3f ms", vertex_count, tm); t.start_point(10.0, 40.0); t.text(buf); ras.add_path(pt); ren.color(agg::rgba(0,0,0)); agg::render_scanlines(ras, sl, ren); //agg::gamma_lut<> gl(m_gamma.value()); //unsigned x, y; //unsigned w = unsigned(width()); //unsigned h = unsigned(height()); //for(y = 0; y < h; y++) //{ // for(x = 0; x < w; x++) // { // agg::rgba8 c = rb.pixel(x, y); // c.r = gl.inv(c.r); // c.g = gl.inv(c.g); // c.b = gl.inv(c.b); // rb.copy_pixel(x, y, c); // } //} }
//------------------------------------------------------------------------ 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); }
virtual void on_draw() { pixfmt pixf(rbuf_window()); renderer_base rb(pixf); renderer_solid r(rb); rb.clear(agg::rgba(1, 1, 1)); scanline_type sl; agg::rasterizer_scanline_aa<> ras; m_poly.close(m_close.status()); agg::simple_polygon_vertex_source path(m_poly.polygon(), m_poly.num_points(), false, m_close.status()); typedef agg::conv_bspline<agg::simple_polygon_vertex_source> conv_bspline_type; conv_bspline_type bspline(path); bspline.interpolation_step(1.0 / m_num_points.value()); agg::trans_single_path tcurve; tcurve.add_path(bspline); tcurve.preserve_x_scale(m_preserve_x_scale.status()); if(m_fixed_len.status()) tcurve.base_length(1120); typedef agg::conv_curve<font_manager_type::path_adaptor_type> conv_font_curve_type; typedef agg::conv_segmentator<conv_font_curve_type> conv_font_segm_type; typedef agg::conv_transform<conv_font_segm_type, agg::trans_single_path> conv_font_trans_type; conv_font_curve_type fcurves(m_fman.path_adaptor()); conv_font_segm_type fsegm(fcurves); conv_font_trans_type ftrans(fsegm, tcurve); fsegm.approximation_scale(3.0); fcurves.approximation_scale(2.0); m_feng.height(40.0); //m_feng.italic(true); if(m_feng.create_font("Times New Roman", agg::glyph_ren_outline)) { double x = 0.0; double y = 3.0; const char* p = text; while(*p) { const agg::glyph_cache* glyph = m_fman.glyph(*p); if(glyph) { if(x > tcurve.total_length()) break; m_fman.add_kerning(&x, &y); m_fman.init_embedded_adaptors(glyph, x, y); if(glyph->data_type == agg::glyph_data_outline) { ras.reset(); ras.add_path(ftrans); r.color(agg::rgba8(0, 0, 0)); agg::render_scanlines(ras, sl, r); } // increment pen position x += glyph->advance_x; y += glyph->advance_y; } ++p; } } typedef agg::conv_stroke<conv_bspline_type> conv_stroke_type; conv_stroke_type stroke(bspline); stroke.width(2.0); r.color(agg::rgba8(170, 50, 20, 100)); ras.add_path(stroke); agg::render_scanlines(ras, sl, r); //-------------------------- // Render the "poly" tool and controls r.color(agg::rgba(0, 0.3, 0.5, 0.3)); ras.add_path(m_poly); agg::render_scanlines(ras, sl, r); agg::render_ctrl(ras, sl, rb, m_close); agg::render_ctrl(ras, sl, rb, m_preserve_x_scale); agg::render_ctrl(ras, sl, rb, m_fixed_len); agg::render_ctrl(ras, sl, rb, m_animate); agg::render_ctrl(ras, sl, rb, m_num_points); //-------------------------- }
void grid_renderer<T>::process(line_pattern_symbolizer const& sym, mapnik::feature_impl & feature, proj_transform const& prj_trans) { std::string filename = get<std::string>(sym, keys::file, feature, common_.vars_); if (filename.empty()) return; boost::optional<mapnik::marker_ptr> mark = marker_cache::instance().find(filename, true); if (!mark) return; if (!(*mark)->is_bitmap()) { MAPNIK_LOG_DEBUG(agg_renderer) << "agg_renderer: Only images (not '" << filename << "') are supported in the line_pattern_symbolizer"; return; } boost::optional<image_ptr> pat = (*mark)->get_bitmap_data(); if (!pat) return; bool clip = get<value_bool>(sym, keys::clip, feature, common_.vars_, true); double offset = get<value_double>(sym, keys::offset, feature, common_.vars_, 0.0); double simplify_tolerance = get<value_double>(sym, keys::simplify_tolerance, feature, common_.vars_, 0.0); double smooth = get<value_double>(sym, keys::smooth, feature, common_.vars_, false); using pixfmt_type = typename grid_renderer_base_type::pixfmt_type; using color_type = typename grid_renderer_base_type::pixfmt_type::color_type; using renderer_type = agg::renderer_scanline_bin_solid<grid_renderer_base_type>; using conv_types = boost::mpl::vector<clip_line_tag, transform_tag, offset_transform_tag, affine_transform_tag, simplify_tag, smooth_tag, stroke_tag>; agg::scanline_bin sl; grid_rendering_buffer buf(pixmap_.raw_data(), common_.width_, common_.height_, common_.width_); pixfmt_type pixf(buf); grid_renderer_base_type renb(pixf); renderer_type ren(renb); ras_ptr->reset(); int stroke_width = (*pat)->width(); agg::trans_affine tr; auto transform = get_optional<transform_type>(sym, keys::geometry_transform); if (transform) { evaluate_transform(tr, feature, common_.vars_, *transform, common_.scale_factor_); } box2d<double> clipping_extent = common_.query_extent_; if (clip) { double padding = (double)(common_.query_extent_.width()/pixmap_.width()); double half_stroke = stroke_width/2.0; if (half_stroke > 1) padding *= half_stroke; if (std::fabs(offset) > 0) padding *= std::fabs(offset) * 1.2; padding *= common_.scale_factor_; clipping_extent.pad(padding); } // to avoid the complexity of using an agg pattern filter instead // we create a line_symbolizer in order to fake the pattern line_symbolizer line; put<value_double>(line, keys::stroke_width, value_double(stroke_width)); // TODO: really should pass the offset to the fake line too, but // this wasn't present in the previous version and makes the test // fail - in this case, probably the test should be updated. //put<value_double>(line, keys::offset, value_double(offset)); put<value_double>(line, keys::simplify_tolerance, value_double(simplify_tolerance)); put<value_double>(line, keys::smooth, value_double(smooth)); vertex_converter<box2d<double>, grid_rasterizer, line_symbolizer, CoordTransform, proj_transform, agg::trans_affine, conv_types, feature_impl> converter(clipping_extent,*ras_ptr,line,common_.t_,prj_trans,tr,feature,common_.vars_,common_.scale_factor_); if (clip) converter.set<clip_line_tag>(); // optional clip (default: true) converter.set<transform_tag>(); // always transform if (std::fabs(offset) > 0.0) converter.set<offset_transform_tag>(); // parallel offset converter.set<affine_transform_tag>(); // optional affine transform if (simplify_tolerance > 0.0) converter.set<simplify_tag>(); // optional simplify converter if (smooth > 0.0) converter.set<smooth_tag>(); // optional smooth converter converter.set<stroke_tag>(); //always stroke for (geometry_type & geom : feature.paths()) { if (geom.size() > 1) { converter.apply(geom); } } // render id ren.color(color_type(feature.id())); agg::render_scanlines(*ras_ptr, sl, ren); // add feature properties to grid cache pixmap_.add_feature(feature); }
void grid_renderer<T>::process(polygon_pattern_symbolizer const& sym, mapnik::feature_impl & feature, proj_transform const& prj_trans) { std::string filename = get<std::string>(sym, keys::file, feature, common_.vars_); if (filename.empty()) return; boost::optional<mapnik::marker_ptr> mark = marker_cache::instance().find(filename, true); if (!mark) return; if (!(*mark)->is_bitmap()) { MAPNIK_LOG_DEBUG(agg_renderer) << "agg_renderer: Only images (not '" << filename << "') are supported in the line_pattern_symbolizer"; return; } boost::optional<image_ptr> pat = (*mark)->get_bitmap_data(); if (!pat) return; ras_ptr->reset(); bool clip = get<value_bool>(sym, keys::clip, feature, common_.vars_, true); double simplify_tolerance = get<value_double>(sym, keys::simplify_tolerance, feature, common_.vars_, 0.0); double smooth = get<value_double>(sym, keys::smooth, feature, common_.vars_, false); agg::trans_affine tr; auto transform = get_optional<transform_type>(sym, keys::geometry_transform); if (transform) { evaluate_transform(tr, feature, common_.vars_, *transform, common_.scale_factor_); } using conv_types = boost::mpl::vector<clip_poly_tag,transform_tag,affine_transform_tag,smooth_tag>; vertex_converter<box2d<double>, grid_rasterizer, polygon_pattern_symbolizer, CoordTransform, proj_transform, agg::trans_affine, conv_types, feature_impl> converter(common_.query_extent_,*ras_ptr,sym,common_.t_,prj_trans,tr,feature,common_.vars_,common_.scale_factor_); if (prj_trans.equal() && clip) converter.set<clip_poly_tag>(); //optional clip (default: true) converter.set<transform_tag>(); //always transform converter.set<affine_transform_tag>(); if (simplify_tolerance > 0.0) converter.set<simplify_tag>(); // optional simplify converter if (smooth > 0.0) converter.set<smooth_tag>(); // optional smooth converter for ( geometry_type & geom : feature.paths()) { if (geom.size() > 2) { converter.apply(geom); } } using pixfmt_type = typename grid_renderer_base_type::pixfmt_type; using color_type = typename grid_renderer_base_type::pixfmt_type::color_type; using renderer_type = agg::renderer_scanline_bin_solid<grid_renderer_base_type>; grid_rendering_buffer buf(pixmap_.raw_data(), common_.width_, common_.height_, common_.width_); pixfmt_type pixf(buf); grid_renderer_base_type renb(pixf); renderer_type ren(renb); // render id ren.color(color_type(feature.id())); agg::scanline_bin sl; ras_ptr->filling_rule(agg::fill_even_odd); agg::render_scanlines(*ras_ptr, sl, ren); // add feature properties to grid cache pixmap_.add_feature(feature); }
virtual void on_draw() { struct font_type { const agg::int8u* font; const char* name; } fonts[] = { { agg::gse4x6, "gse4x6" }, { agg::gse4x8, "gse4x8" }, { agg::gse5x7, "gse5x7" }, { agg::gse5x9, "gse5x9" }, { agg::gse6x9, "gse6x9" }, { agg::gse6x12, "gse6x12" }, { agg::gse7x11, "gse7x11" }, { agg::gse7x11_bold, "gse7x11_bold" }, { agg::gse7x15, "gse7x15" }, { agg::gse7x15_bold, "gse7x15_bold" }, { agg::gse8x16, "gse8x16" }, { agg::gse8x16_bold, "gse8x16_bold" }, { agg::mcs11_prop, "mcs11_prop" }, { agg::mcs11_prop_condensed, "mcs11_prop_condensed" }, { agg::mcs12_prop, "mcs12_prop" }, { agg::mcs13_prop, "mcs13_prop" }, { agg::mcs5x10_mono, "mcs5x10_mono" }, { agg::mcs5x11_mono, "mcs5x11_mono" }, { agg::mcs6x10_mono, "mcs6x10_mono" }, { agg::mcs6x11_mono, "mcs6x11_mono" }, { agg::mcs7x12_mono_high, "mcs7x12_mono_high" }, { agg::mcs7x12_mono_low, "mcs7x12_mono_low" }, { agg::verdana12, "verdana12" }, { agg::verdana12_bold, "verdana12_bold" }, { agg::verdana13, "verdana13" }, { agg::verdana13_bold, "verdana13_bold" }, { agg::verdana14, "verdana14" }, { agg::verdana14_bold, "verdana14_bold" }, { agg::verdana16, "verdana16" }, { agg::verdana16_bold, "verdana16_bold" }, { agg::verdana17, "verdana17" }, { agg::verdana17_bold, "verdana17_bold" }, { agg::verdana18, "verdana18" }, { agg::verdana18_bold, "verdana18_bold" }, 0, 0 }; glyph_gen glyph(0); pixfmt pixf(rbuf_window()); ren_base rb(pixf); rb.clear(agg::rgba(1,1,1)); agg::renderer_raster_htext_solid<ren_base, glyph_gen> rt(rb, glyph); int i; double y = 5; rt.color(agg::rgba(0,0,0)); for(i = 0; fonts[i].font; i++) { char buf[100]; strcpy(buf, "A quick brown fox jumps over the lazy dog 0123456789: "); strcat(buf, fonts[i].name); // Testing "wide-char" unsigned wbuf[100]; unsigned* wp = wbuf; const char* p = buf; while(*p) *wp++ = *(unsigned char*)p++; *wp++ = 0; glyph.font(fonts[i].font); rt.render_text(5, y, wbuf, !flip_y()); y += glyph.height() + 1; } // Rendering raster text with a custom span generator, gradient typedef agg::span_interpolator_linear<> interpolator_type; typedef agg::span_allocator<agg::rgba8> span_alloc_type; typedef agg::span_gradient<agg::rgba8, interpolator_type, gradient_sine_repeat_adaptor<agg::gradient_circle>, agg::gradient_linear_color<agg::rgba8> > span_gen_type; typedef agg::renderer_scanline_aa<ren_base, span_alloc_type, span_gen_type> ren_type; agg::trans_affine mtx; gradient_sine_repeat_adaptor<agg::gradient_circle> grad_func; grad_func.periods(5); agg::gradient_linear_color<agg::rgba8> color_func; color_func.colors(agg::rgba(1.0,0,0), agg::rgba(0,0.5,0)); interpolator_type inter(mtx); span_alloc_type sa; span_gen_type sg(inter, grad_func, color_func, 0, 150.0); ren_type ren(rb, sa, sg); agg::renderer_raster_htext<ren_type, glyph_gen> rt2(ren, glyph); rt2.render_text(5, 465, (unsigned char*)"RADIAL REPEATING GRADIENT: A quick brown fox jumps over the lazy dog", !flip_y()); }
void composite(T1 & im, T2 & im2, composite_mode_e mode) { typedef agg::rgba8 color; typedef agg::order_bgra order; typedef agg::pixel32_type pixel_type; typedef agg::comp_op_adaptor_rgba<color, order> blender_type; typedef agg::pixfmt_custom_blend_rgba<blender_type, agg::rendering_buffer> pixfmt_type; typedef agg::renderer_base<pixfmt_type> renderer_type; typedef agg::comp_op_adaptor_rgba<color, order> blender_type; typedef agg::renderer_base<pixfmt_type> renderer_type; agg::rendering_buffer source(im.getBytes(),im.width(),im.height(),im.width() * 4); agg::rendering_buffer mask(im2.getBytes(),im2.width(),im2.height(),im2.width() * 4); agg::pixfmt_custom_blend_rgba<blender_type, agg::rendering_buffer> pixf(source); agg::pixfmt_custom_blend_rgba<blender_type, agg::rendering_buffer> pixf_mask(mask); switch(mode) { case clear : pixf.comp_op(agg::comp_op_clear); break; case src: pixf.comp_op(agg::comp_op_src); break; case dst: pixf.comp_op(agg::comp_op_dst); break; case src_over: pixf.comp_op(agg::comp_op_src_over); break; case dst_over: pixf.comp_op(agg::comp_op_dst_over); break; case src_in: pixf.comp_op(agg::comp_op_src_in); break; case dst_in: pixf.comp_op(agg::comp_op_dst_in); break; case src_out: pixf.comp_op(agg::comp_op_src_out); break; case dst_out: pixf.comp_op(agg::comp_op_dst_out); break; case src_atop: pixf.comp_op(agg::comp_op_src_atop); break; case dst_atop: pixf.comp_op(agg::comp_op_dst_atop); break; case _xor: pixf.comp_op(agg::comp_op_xor); break; case plus: pixf.comp_op(agg::comp_op_plus); break; case minus: pixf.comp_op(agg::comp_op_minus); break; case multiply: pixf.comp_op(agg::comp_op_multiply); break; case screen: pixf.comp_op(agg::comp_op_screen); break; case overlay: pixf.comp_op(agg::comp_op_overlay); break; case darken: pixf.comp_op(agg::comp_op_darken); break; case lighten: pixf.comp_op(agg::comp_op_lighten); break; case color_dodge: pixf.comp_op(agg::comp_op_color_dodge); break; case color_burn: pixf.comp_op(agg::comp_op_color_burn); break; case hard_light: pixf.comp_op(agg::comp_op_hard_light); break; case soft_light: pixf.comp_op(agg::comp_op_soft_light); break; case difference: pixf.comp_op(agg::comp_op_difference); break; case exclusion: pixf.comp_op(agg::comp_op_exclusion); break; case contrast: pixf.comp_op(agg::comp_op_contrast); break; case invert: pixf.comp_op(agg::comp_op_invert); break; case invert_rgb: pixf.comp_op(agg::comp_op_invert_rgb); break; default: break; } renderer_type ren(pixf); agg::renderer_base<pixfmt_type> rb(pixf); rb.blend_from(pixf_mask,0,0,0,255); }
void agg_renderer<T>::process(polygon_pattern_symbolizer const& sym, Feature const& feature, proj_transform const& prj_trans) { typedef coord_transform2<CoordTransform,geometry_type> path_type; typedef agg::renderer_base<agg::pixfmt_rgba32_plain> ren_base; typedef agg::wrap_mode_repeat wrap_x_type; typedef agg::wrap_mode_repeat wrap_y_type; typedef agg::pixfmt_alpha_blend_rgba<agg::blender_rgba32, agg::row_accessor<agg::int8u>, agg::pixel32_type> rendering_buffer; typedef agg::image_accessor_wrap<rendering_buffer, wrap_x_type, wrap_y_type> img_source_type; typedef agg::span_pattern_rgba<img_source_type> span_gen_type; typedef agg::renderer_scanline_aa<ren_base, agg::span_allocator<agg::rgba8>, span_gen_type> renderer_type; agg::rendering_buffer buf(pixmap_.raw_data(),width_,height_, width_ * 4); agg::pixfmt_rgba32_plain pixf(buf); ren_base renb(pixf); agg::scanline_u8 sl; ras_ptr->reset(); ras_ptr->gamma(agg::gamma_linear(0.0, sym.get_gamma())); std::string filename = path_processor_type::evaluate( *sym.get_filename(), feature); boost::optional<mapnik::marker_ptr> marker; if ( !filename.empty() ) { marker = marker_cache::instance()->find(filename, true); } else { std::clog << "### Warning: file not found: " << filename << "\n"; } if (!marker || !(*marker)->is_bitmap()) return; boost::optional<image_ptr> pat = (*marker)->get_bitmap_data(); if (!pat) return; unsigned w=(*pat)->width(); unsigned h=(*pat)->height(); agg::row_accessor<agg::int8u> pattern_rbuf((agg::int8u*)(*pat)->getBytes(),w,h,w*4); agg::span_allocator<agg::rgba8> sa; agg::pixfmt_alpha_blend_rgba<agg::blender_rgba32, agg::row_accessor<agg::int8u>, agg::pixel32_type> pixf_pattern(pattern_rbuf); img_source_type img_src(pixf_pattern); unsigned num_geometries = feature.num_geometries(); pattern_alignment_e align = sym.get_alignment(); unsigned offset_x=0; unsigned offset_y=0; if (align == LOCAL_ALIGNMENT) { double x0=0,y0=0; if (num_geometries>0) { path_type path(t_,feature.get_geometry(0),prj_trans); path.vertex(&x0,&y0); } offset_x = unsigned(width_-x0); offset_y = unsigned(height_-y0); } span_gen_type sg(img_src, offset_x, offset_y); renderer_type rp(renb,sa, sg); metawriter_with_properties writer = sym.get_metawriter(); for (unsigned i=0;i<num_geometries;++i) { geometry_type const& geom = feature.get_geometry(i); if (geom.num_points() > 2) { path_type path(t_,geom,prj_trans); ras_ptr->add_path(path); if (writer.first) writer.first->add_polygon(path, feature, t_, writer.second); } } agg::render_scanlines(*ras_ptr, sl, rp); }
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); }
virtual void on_draw() { #if ENABLE_GAMMA_CTRL typedef agg::gamma_lut<agg::int8u, agg::int8u, 8, 8> gamma_type; typedef pixfmt_gamma<gamma_type> pixfmt_type; typedef agg::renderer_base<pixfmt_type> ren_base; double g = m_gamma.value(); gamma_type gamma(g); pixfmt_type pixf(rbuf_window(), gamma); #else typedef agg::renderer_base<pixfmt> ren_base; pixfmt pixf(rbuf_window()); #endif ren_base renb(pixf); renb.clear(agg::rgba(1, 1, 1)); double dark = 1.0 - m_contrast.value(); double light = m_contrast.value(); renb.copy_bar(0,0,int(width())/2, int(height()), agg::rgba(dark,dark,dark)); renb.copy_bar(int(width())/2+1,0, int(width()), int(height()), agg::rgba(light,light,light)); renb.copy_bar(0,int(height())/2+1, int(width()), int(height()), agg::rgba(1.0,dark,dark)); agg::rasterizer_scanline_aa<> ras; agg::scanline_u8 sl; agg::path_storage path; #if ENABLE_GAMMA_CTRL unsigned i; double x = (width() - 256.0) / 2.0; double y = 50.0; path.remove_all(); agg::gamma_power gp(g); for(i = 0; i < 256; i++) { double v = double(i) / 255.0; double gval = gp(v); double dy = gval * 255.0; if(i == 0) path.move_to(x + i, y + dy); else path.line_to(x + i, y + dy); } agg::conv_stroke<agg::path_storage> gpoly(path); gpoly.width(2.0); ras.reset(); ras.add_path(gpoly); agg::render_scanlines_aa_solid(ras, sl, renb, agg::srgba8(80,127,80)); #endif agg::ellipse ell(width() / 2, height() / 2, m_rx, m_ry, 150); agg::conv_stroke<agg::ellipse> poly(ell); poly.width(m_thickness.value()); ras.reset(); ras.add_path(poly); agg::render_scanlines_aa_solid(ras, sl, renb, agg::srgba8(255,0,0)); ell.init(width() / 2, height() / 2, m_rx-5.0, m_ry-5.0, 150); ras.reset(); ras.add_path(poly); agg::render_scanlines_aa_solid(ras, sl, renb, agg::srgba8(0,255,0)); ell.init(width() / 2, height() / 2, m_rx-10.0, m_ry-10.0, 150); ras.reset(); ras.add_path(poly); agg::render_scanlines_aa_solid(ras, sl, renb, agg::srgba8(0,0,255)); ell.init(width() / 2, height() / 2, m_rx-15.0, m_ry-15.0, 150); ras.reset(); ras.add_path(poly); agg::render_scanlines_aa_solid(ras, sl, renb, agg::srgba8(0,0,0)); ell.init(width() / 2, height() / 2, m_rx-20.0, m_ry-20.0, 150); ras.reset(); ras.add_path(poly); agg::render_scanlines_aa_solid(ras, sl, renb, agg::srgba8(255,255,255)); agg::render_ctrl(ras, sl, renb, m_thickness); agg::render_ctrl(ras, sl, renb, m_contrast); #if ENABLE_GAMMA_CTRL agg::render_ctrl(ras, sl, renb, m_gamma); #endif }
MAPNIK_DECL void warp_image (T & target, T const& source, proj_transform const& prj_trans, box2d<double> const& target_ext, box2d<double> const& source_ext, double offset_x, double offset_y, unsigned mesh_size, scaling_method_e scaling_method, double filter_factor) { using image_type = T; using pixel_type = typename image_type::pixel_type; using pixfmt_pre = typename detail::agg_scaling_traits<image_type>::pixfmt_pre; using color_type = typename detail::agg_scaling_traits<image_type>::color_type; using renderer_base = agg::renderer_base<pixfmt_pre>; using interpolator_type = typename detail::agg_scaling_traits<image_type>::interpolator_type; constexpr std::size_t pixel_size = sizeof(pixel_type); view_transform ts(source.width(), source.height(), source_ext); view_transform tt(target.width(), target.height(), target_ext, offset_x, offset_y); std::size_t mesh_nx = std::ceil(source.width()/double(mesh_size) + 1); std::size_t mesh_ny = std::ceil(source.height()/double(mesh_size) + 1); image_gray64f xs(mesh_nx, mesh_ny, false); image_gray64f ys(mesh_nx, mesh_ny, false); // Precalculate reprojected mesh for(std::size_t j = 0; j < mesh_ny; ++j) { for (std::size_t i=0; i<mesh_nx; ++i) { xs(i,j) = std::min(i*mesh_size,source.width()); ys(i,j) = std::min(j*mesh_size,source.height()); ts.backward(&xs(i,j), &ys(i,j)); } } prj_trans.backward(xs.getData(), ys.getData(), nullptr, mesh_nx*mesh_ny); agg::rasterizer_scanline_aa<> rasterizer; agg::scanline_bin scanline; agg::rendering_buffer buf(target.getBytes(), target.width(), target.height(), target.width() * pixel_size); pixfmt_pre pixf(buf); renderer_base rb(pixf); rasterizer.clip_box(0, 0, target.width(), target.height()); agg::rendering_buffer buf_tile( const_cast<unsigned char*>(source.getBytes()), source.width(), source.height(), source.width() * pixel_size); pixfmt_pre pixf_tile(buf_tile); using img_accessor_type = agg::image_accessor_clone<pixfmt_pre>; img_accessor_type ia(pixf_tile); agg::span_allocator<color_type> sa; // Project mesh cells into target interpolating raster inside each one for (std::size_t j = 0; j < mesh_ny - 1; ++j) { for (std::size_t 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(std::floor(polygon[0]), std::floor(polygon[1])); rasterizer.line_to_d(std::floor(polygon[2]), std::floor(polygon[3])); rasterizer.line_to_d(std::floor(polygon[4]), std::floor(polygon[5])); rasterizer.line_to_d(std::floor(polygon[6]), std::floor(polygon[7])); std::size_t x0 = i * mesh_size; std::size_t y0 = j * mesh_size; std::size_t x1 = (i+1) * mesh_size; std::size_t y1 = (j+1) * mesh_size; x1 = std::min(x1, source.width()); y1 = std::min(y1, source.height()); agg::trans_affine tr(polygon, x0, y0, x1, y1); if (tr.is_valid()) { interpolator_type interpolator(tr); if (scaling_method == SCALING_NEAR) { using span_gen_type = typename detail::agg_scaling_traits<image_type>::span_image_filter; span_gen_type sg(ia, interpolator); agg::render_scanlines_bin(rasterizer, scanline, rb, sa, sg); } else { using span_gen_type = typename detail::agg_scaling_traits<image_type>::span_image_resample_affine; agg::image_filter_lut filter; detail::set_scaling_method(filter, scaling_method, filter_factor); span_gen_type sg(ia, interpolator, filter); agg::render_scanlines_bin(rasterizer, scanline, rb, sa, sg); } } } } }
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); }
virtual void on_draw() { typedef agg::renderer_base<pixfmt> renderer_base; typedef agg::renderer_scanline_aa_solid<renderer_base> renderer_scanline; typedef agg::scanline_u8 scanline; pixfmt pixf(rbuf_window()); renderer_base ren_base(pixf); ren_base.clear(agg::rgba(1.0, 1.0, 0.95)); renderer_scanline ren(ren_base); unsigned i; unsigned w = unsigned(width()); m_gradient.resize(w); agg::rgba8 c1(255, 0, 0, 180); agg::rgba8 c2(0, 0, 255, 180); for(i = 0; i < w; i++) { m_gradient[i] = c1.gradient(c2, i / width()); m_gradient[i].premultiply(); } agg::rasterizer_scanline_aa<agg::rasterizer_sl_clip_dbl> ras; agg::rasterizer_compound_aa<agg::rasterizer_sl_clip_dbl> rasc; agg::scanline_u8 sl; agg::scanline_bin sl_bin; agg::conv_transform<agg::compound_shape> shape(m_shape, m_scale); agg::conv_stroke<agg::conv_transform<agg::compound_shape> > stroke(shape); agg::test_styles style_handler(m_colors, m_gradient.data()); agg::span_allocator<agg::rgba8> alloc; m_shape.approximation_scale(m_scale.scale()); // Fill shape //---------------------- rasc.clip_box(0, 0, width(), height()); rasc.reset(); //rasc.filling_rule(agg::fill_even_odd); start_timer(); for(i = 0; i < m_shape.paths(); i++) { if(m_shape.style(i).left_fill >= 0 || m_shape.style(i).right_fill >= 0) { rasc.styles(m_shape.style(i).left_fill, m_shape.style(i).right_fill); rasc.add_path(shape, m_shape.style(i).path_id); } } agg::render_scanlines_compound(rasc, sl, sl_bin, ren_base, alloc, style_handler); double tfill = elapsed_time(); // Hit-test test bool draw_strokes = true; if(m_hit_x >= 0 && m_hit_y >= 0) { if(rasc.hit_test(m_hit_x, m_hit_y)) { draw_strokes = false; } } // Draw strokes //---------------------- start_timer(); if(draw_strokes) { ras.clip_box(0, 0, width(), height()); stroke.width(sqrt(m_scale.scale())); stroke.line_join(agg::round_join); stroke.line_cap(agg::round_cap); for(i = 0; i < m_shape.paths(); i++) { ras.reset(); if(m_shape.style(i).line >= 0) { ras.add_path(stroke, m_shape.style(i).path_id); ren.color(agg::rgba8(0,0,0, 128)); agg::render_scanlines(ras, sl, ren); } } } double tstroke = elapsed_time(); char buf[256]; agg::gsv_text t; t.size(8.0); t.flip(true); agg::conv_stroke<agg::gsv_text> ts(t); ts.width(1.6); ts.line_cap(agg::round_cap); sprintf(buf, "Fill=%.2fms (%dFPS) Stroke=%.2fms (%dFPS) Total=%.2fms (%dFPS)\n\n" "Space: Next Shape\n\n" "+/- : ZoomIn/ZoomOut (with respect to the mouse pointer)", tfill, int(1000.0 / tfill), tstroke, int(1000.0 / tstroke), tfill+tstroke, int(1000.0 / (tfill+tstroke))); t.start_point(10.0, 20.0); t.text(buf); ras.add_path(ts); ren.color(agg::rgba(0,0,0)); agg::render_scanlines(ras, sl, ren); if(m_gamma.gamma() != 1.0) { pixf.apply_gamma_inv(m_gamma); } }
Py::Object Image::resize(const Py::Tuple& args) { _VERBOSE("Image::resize"); args.verify_length(2); if (bufferIn ==NULL) throw Py::RuntimeError("You must first load the image"); int numcols = Py::Int(args[0]); int numrows = Py::Int(args[1]); colsOut = numcols; rowsOut = numrows; size_t NUMBYTES(numrows * numcols * BPP); agg::int8u *buffer = new agg::int8u[NUMBYTES]; if (buffer ==NULL) //todo: also handle allocation throw throw Py::MemoryError("Image::resize could not allocate memory"); rbufOut = new agg::rendering_buffer; rbufOut->attach(buffer, numcols, numrows, numcols * BPP); // init the output rendering/rasterizing stuff pixfmt pixf(*rbufOut); renderer_base rb(pixf); rb.clear(bg); agg::rasterizer_scanline_aa<> ras; agg::scanline_u8 sl; //srcMatrix *= resizingMatrix; //imageMatrix *= resizingMatrix; imageMatrix.invert(); interpolator_type interpolator(imageMatrix); agg::image_filter_base* filter = 0; agg::span_allocator<agg::rgba8> sa; agg::rgba8 background(agg::rgba8(int(255*bg.r), int(255*bg.g), int(255*bg.b), int(255*bg.a))); // the image path agg::path_storage path; agg::int8u *bufferPad = NULL; agg::rendering_buffer rbufPad; double x0, y0, x1, y1; if (interpolation==NEAREST) { x0 = 0.0; x1 = colsIn; y0 = 0.0; y1 = rowsIn; } else { // if interpolation != nearest, create a new input buffer with the // edges mirrored on all size. Then new buffer size is colsIn+2 by // rowsIn+2 x0 = 1.0; x1 = colsIn+1; y0 = 1.0; y1 = rowsIn+1; bufferPad = new agg::int8u[(rowsIn+2) * (colsIn+2) * BPP]; if (bufferPad ==NULL) throw Py::MemoryError("Image::resize could not allocate memory"); //pad the input buffer for (size_t rowNum=0; rowNum<rowsIn+2; rowNum++) for (size_t colNum=0; colNum<colsIn+2; colNum++) { if ( (colNum==0) && (rowNum==1||(rowNum==rowsIn+1))) { //rewind to begining of column bufferIn -= colsIn * BPP; } *bufferPad++ = *bufferIn++; //red *bufferPad++ = *bufferIn++; //green *bufferPad++ = *bufferIn++; //blue *bufferPad++ = *bufferIn++; //alpha //rewind one byte on the first and next to last columns if ( colNum==0 || colNum==colsIn) bufferIn-=4; } //rewind the input buffers bufferIn -= rowsIn * colsIn * BPP; bufferPad -= (rowsIn+2) * (colsIn+2) * BPP; rbufPad.attach(bufferPad, colsIn+2, rowsIn+2, (colsIn+2) * BPP); } if (buffer ==NULL) //todo: also handle allocation throw throw Py::MemoryError("Image::resize could not allocate memory"); path.move_to(x0, y0); path.line_to(x1, y0); path.line_to(x1, y1); path.line_to(x0, y1); path.close_polygon(); agg::conv_transform<agg::path_storage> imageBox(path, srcMatrix); ras.add_path(imageBox); switch(interpolation) { case NEAREST: { typedef agg::span_image_filter_rgba32_nn<agg::order_rgba32, interpolator_type> span_gen_type; typedef agg::renderer_scanline_aa<renderer_base, span_gen_type> renderer_type; span_gen_type sg(sa, *rbufIn, background, interpolator); renderer_type ri(rb, sg); agg::render_scanlines(ras, sl, ri); } break; case BILINEAR: { typedef agg::span_image_filter_rgba32_bilinear<agg::order_rgba32, interpolator_type> span_gen_type; typedef agg::renderer_scanline_aa<renderer_base, span_gen_type> renderer_type; span_gen_type sg(sa, rbufPad, background, interpolator); renderer_type ri(rb, sg); agg::render_scanlines(ras, sl, ri); } break; case BICUBIC: filter = new agg::image_filter<agg::image_filter_bicubic>; case SPLINE16: filter = new agg::image_filter<agg::image_filter_spline16>; case SPLINE36: filter = new agg::image_filter<agg::image_filter_spline36>; case SINC64: filter = new agg::image_filter<agg::image_filter_sinc64>; case SINC144: filter = new agg::image_filter<agg::image_filter_sinc144>; case SINC256: filter = new agg::image_filter<agg::image_filter_sinc256>; case BLACKMAN64: filter = new agg::image_filter<agg::image_filter_blackman64>; case BLACKMAN100: filter = new agg::image_filter<agg::image_filter_blackman100>; case BLACKMAN256: filter = new agg::image_filter<agg::image_filter_blackman256>; typedef agg::span_image_filter_rgba32<agg::order_rgba32, interpolator_type> span_gen_type; typedef agg::renderer_scanline_aa<renderer_base, span_gen_type> renderer_type; span_gen_type sg(sa, rbufPad, background, interpolator, *filter); renderer_type ri(rb, sg); agg::render_scanlines(ras, sl, ri); } /* std::ofstream of2( "image_out.raw", std::ios::binary|std::ios::out); for (size_t i=0; i<NUMBYTES; ++i) of2.write((char*)&buffer[i], sizeof(char)); */ bufferOut = buffer; delete [] bufferPad; return Py::Object(); }
void agg_renderer<T>::process(line_symbolizer const& sym, mapnik::feature_impl & feature, proj_transform const& prj_trans) { stroke const& stroke_ = sym.get_stroke(); color const& col = stroke_.get_color(); unsigned r=col.red(); unsigned g=col.green(); unsigned b=col.blue(); unsigned a=col.alpha(); ras_ptr->reset(); if (stroke_.get_gamma() != gamma_ || stroke_.get_gamma_method() != gamma_method_) { set_gamma_method(stroke_, ras_ptr); gamma_method_ = stroke_.get_gamma_method(); gamma_ = stroke_.get_gamma(); } agg::rendering_buffer buf(current_buffer_->raw_data(),current_buffer_->width(),current_buffer_->height(), current_buffer_->width() * 4); typedef agg::rgba8 color_type; typedef agg::order_rgba order_type; typedef agg::comp_op_adaptor_rgba_pre<color_type, order_type> blender_type; // comp blender typedef agg::pixfmt_custom_blend_rgba<blender_type, agg::rendering_buffer> pixfmt_comp_type; typedef agg::renderer_base<pixfmt_comp_type> renderer_base; typedef boost::mpl::vector<clip_line_tag, transform_tag, offset_transform_tag, affine_transform_tag, simplify_tag, smooth_tag, dash_tag, stroke_tag> conv_types; pixfmt_comp_type pixf(buf); pixf.comp_op(static_cast<agg::comp_op_e>(sym.comp_op())); renderer_base renb(pixf); agg::trans_affine tr; evaluate_transform(tr, feature, sym.get_transform(), scale_factor_); box2d<double> clip_box = clipping_extent(); if (sym.clip()) { double padding = (double)(query_extent_.width()/pixmap_.width()); double half_stroke = stroke_.get_width()/2.0; if (half_stroke > 1) padding *= half_stroke; if (std::fabs(sym.offset()) > 0) padding *= std::fabs(sym.offset()) * 1.2; padding *= scale_factor_; clip_box.pad(padding); // debugging //box2d<double> inverse = query_extent_; //inverse.pad(-padding); //draw_geo_extent(inverse,mapnik::color("red")); } if (sym.get_rasterizer() == RASTERIZER_FAST) { typedef agg::renderer_outline_aa<renderer_base> renderer_type; typedef agg::rasterizer_outline_aa<renderer_type> rasterizer_type; agg::line_profile_aa profile(stroke_.get_width() * scale_factor_, agg::gamma_power(stroke_.get_gamma())); renderer_type ren(renb, profile); ren.color(agg::rgba8_pre(r, g, b, int(a*stroke_.get_opacity()))); rasterizer_type ras(ren); set_join_caps_aa(stroke_,ras); vertex_converter<box2d<double>, rasterizer_type, line_symbolizer, CoordTransform, proj_transform, agg::trans_affine, conv_types> converter(clip_box,ras,sym,t_,prj_trans,tr,scale_factor_); if (sym.clip()) converter.set<clip_line_tag>(); // optional clip (default: true) converter.set<transform_tag>(); // always transform if (std::fabs(sym.offset()) > 0.0) converter.set<offset_transform_tag>(); // parallel offset converter.set<affine_transform_tag>(); // optional affine transform if (sym.simplify_tolerance() > 0.0) converter.set<simplify_tag>(); // optional simplify converter if (sym.smooth() > 0.0) converter.set<smooth_tag>(); // optional smooth converter for (geometry_type & geom : feature.paths()) { if (geom.size() > 1) { converter.apply(geom); } } } else { vertex_converter<box2d<double>, rasterizer, line_symbolizer, CoordTransform, proj_transform, agg::trans_affine, conv_types> converter(clip_box,*ras_ptr,sym,t_,prj_trans,tr,scale_factor_); if (sym.clip()) converter.set<clip_line_tag>(); // optional clip (default: true) converter.set<transform_tag>(); // always transform if (std::fabs(sym.offset()) > 0.0) converter.set<offset_transform_tag>(); // parallel offset converter.set<affine_transform_tag>(); // optional affine transform if (sym.simplify_tolerance() > 0.0) converter.set<simplify_tag>(); // optional simplify converter if (sym.smooth() > 0.0) converter.set<smooth_tag>(); // optional smooth converter if (stroke_.has_dash()) converter.set<dash_tag>(); converter.set<stroke_tag>(); //always stroke for (geometry_type & geom : feature.paths()) { if (geom.size() > 1) { converter.apply(geom); } } typedef agg::renderer_scanline_aa_solid<renderer_base> renderer_type; renderer_type ren(renb); ren.color(agg::rgba8_pre(r, g, b, int(a * stroke_.get_opacity()))); agg::scanline_u8 sl; ras_ptr->filling_rule(agg::fill_non_zero); agg::render_scanlines(*ras_ptr, sl, ren); } }
Py::Object _image_module::from_images(const Py::Tuple& args) { _VERBOSE("_image_module::from_images"); args.verify_length(3); size_t numrows = Py::Int(args[0]); size_t numcols = Py::Int(args[1]); Py::SeqBase<Py::Object> tups = args[2]; size_t N = tups.length(); if (N==0) throw Py::RuntimeError("Empty list of images"); Py::Tuple tup; size_t ox(0), oy(0), thisx(0), thisy(0); //copy image 0 output buffer into return images output buffer Image* imo = new Image; imo->rowsOut = numrows; imo->colsOut = numcols; size_t NUMBYTES(numrows * numcols * imo->BPP); imo->bufferOut = new agg::int8u[NUMBYTES]; if (imo->bufferOut==NULL) //todo: also handle allocation throw throw Py::MemoryError("_image_module::from_images could not allocate memory"); imo->rbufOut = new agg::rendering_buffer; imo->rbufOut->attach(imo->bufferOut, imo->colsOut, imo->rowsOut, imo->colsOut * imo->BPP); pixfmt pixf(*imo->rbufOut); renderer_base rb(pixf); for (size_t imnum=0; imnum< N; imnum++) { tup = Py::Tuple(tups[imnum]); Image* thisim = static_cast<Image*>(tup[0].ptr()); if (imnum==0) rb.clear(thisim->bg); ox = Py::Int(tup[1]); oy = Py::Int(tup[2]); size_t ind=0; for (size_t j=0; j<thisim->rowsOut; j++) { for (size_t i=0; i<thisim->colsOut; i++) { thisx = i+ox; thisy = j+oy; if (thisx<0 || thisx>=numcols || thisy<0 || thisy>=numrows) { ind +=4; continue; } pixfmt::color_type p; p.r = *(thisim->bufferOut+ind++); p.g = *(thisim->bufferOut+ind++); p.b = *(thisim->bufferOut+ind++); p.a = *(thisim->bufferOut+ind++); pixf.blend_pixel(thisx, thisy, p, 255); } } } return Py::asObject(imo); }
void grid_renderer<T>::process(polygon_pattern_symbolizer const& sym, mapnik::feature_impl & feature, proj_transform const& prj_trans) { std::string filename = get<std::string, keys::file>(sym, feature, common_.vars_); if (filename.empty()) return; mapnik::marker const& mark = marker_cache::instance().find(filename, true); if (mark.is<mapnik::marker_null>()) return; if (!mark.is<mapnik::marker_rgba8>()) { MAPNIK_LOG_DEBUG(agg_renderer) << "agg_renderer: Only images (not '" << filename << "') are supported in the line_pattern_symbolizer"; return; } ras_ptr->reset(); value_bool clip = get<value_bool, keys::clip>(sym, feature, common_.vars_); value_double simplify_tolerance = get<value_double, keys::simplify_tolerance>(sym, feature, common_.vars_); value_double smooth = get<value_double, keys::smooth>(sym, feature, common_.vars_); agg::trans_affine tr; auto transform = get_optional<transform_type>(sym, keys::geometry_transform); if (transform) { evaluate_transform(tr, feature, common_.vars_, *transform, common_.scale_factor_); } using vertex_converter_type = vertex_converter<clip_poly_tag,transform_tag,affine_transform_tag,smooth_tag>; vertex_converter_type converter(common_.query_extent_,sym,common_.t_,prj_trans,tr,feature,common_.vars_,common_.scale_factor_); if (prj_trans.equal() && clip) converter.set<clip_poly_tag>(); //optional clip (default: true) converter.set<transform_tag>(); //always transform converter.set<affine_transform_tag>(); if (simplify_tolerance > 0.0) converter.set<simplify_tag>(); // optional simplify converter if (smooth > 0.0) converter.set<smooth_tag>(); // optional smooth converter using apply_vertex_converter_type = detail::apply_vertex_converter<vertex_converter_type, grid_rasterizer>; using vertex_processor_type = geometry::vertex_processor<apply_vertex_converter_type>; apply_vertex_converter_type apply(converter, *ras_ptr); mapnik::util::apply_visitor(vertex_processor_type(apply),feature.get_geometry()); using pixfmt_type = typename grid_renderer_base_type::pixfmt_type; using color_type = typename grid_renderer_base_type::pixfmt_type::color_type; using renderer_type = agg::renderer_scanline_bin_solid<grid_renderer_base_type>; grid_rendering_buffer buf(pixmap_.raw_data(), common_.width_, common_.height_, common_.width_); pixfmt_type pixf(buf); grid_renderer_base_type renb(pixf); renderer_type ren(renb); // render id ren.color(color_type(feature.id())); agg::scanline_bin sl; ras_ptr->filling_rule(agg::fill_even_odd); agg::render_scanlines(*ras_ptr, sl, ren); // add feature properties to grid cache pixmap_.add_feature(feature); }
void render(geometry_type& geom, Image32& image) const { typedef agg::renderer_base<agg::pixfmt_rgba32> ren_base; agg::row_ptr_cache<agg::int8u> buf(image.raw_data(),image.width(),image.height(), image.width()*4); agg::pixfmt_rgba32 pixf(buf); ren_base renb(pixf); Color const& col = stroke_.get_color(); double r=col.red()/255.0; double g=col.green()/255.0; double b=col.blue()/255.0; if (0) //stroke_.width() == 1.0) { typedef agg::renderer_outline_aa<ren_base> renderer_oaa; typedef agg::rasterizer_outline_aa<renderer_oaa> rasterizer_outline_aa; agg::line_profile_aa prof; prof.width(stroke_.get_width()); renderer_oaa ren_oaa(renb, prof); rasterizer_outline_aa ras_oaa(ren_oaa); ren_oaa.color(agg::rgba(r, g, b, stroke_.get_opacity())); ras_oaa.add_path(geom); //LineRasterizerAA<Image32> rasterizer(image); //rasterizer.render<SHIFT0>(geom,stroke_.get_color()); } else { //typedef agg::renderer_base<agg::pixfmt_rgba32> ren_base; typedef agg::renderer_scanline_aa_solid<ren_base> renderer; renderer ren(renb); agg::rasterizer_scanline_aa<> ras; agg::scanline_u8 sl; if (stroke_.has_dash()) { agg::conv_dash<geometry<vertex2d,vertex_vector> > dash(geom); dash_array const& d = stroke_.get_dash_array(); dash_array::const_iterator itr = d.begin(); dash_array::const_iterator end = d.end(); while (itr != end) { dash.add_dash(itr->first, itr->second); ++itr; } agg::conv_stroke<agg::conv_dash<geometry<vertex2d,vertex_vector> > > stroke(dash); line_join_e join=stroke_.get_line_join(); if ( join == MITER_JOIN) stroke.generator().line_join(agg::miter_join); else if( join == MITER_REVERT_JOIN) stroke.generator().line_join(agg::miter_join); else if( join == ROUND_JOIN) stroke.generator().line_join(agg::round_join); else stroke.generator().line_join(agg::bevel_join); line_cap_e cap=stroke_.get_line_cap(); if (cap == BUTT_CAP) stroke.generator().line_cap(agg::butt_cap); else if (cap == SQUARE_CAP) stroke.generator().line_cap(agg::square_cap); else stroke.generator().line_cap(agg::round_cap); stroke.generator().miter_limit(4.0); stroke.generator().width(stroke_.get_width()); ras.clip_box(0,0,image.width(),image.height()); ras.add_path(stroke); ren.color(agg::rgba(r, g, b, stroke_.get_opacity())); agg::render_scanlines(ras, sl, ren); } else { agg::conv_stroke<geometry<vertex2d,vertex_vector> > stroke(geom); line_join_e join=stroke_.get_line_join(); if ( join == MITER_JOIN) stroke.generator().line_join(agg::miter_join); else if( join == MITER_REVERT_JOIN) stroke.generator().line_join(agg::miter_join); else if( join == ROUND_JOIN) stroke.generator().line_join(agg::round_join); else stroke.generator().line_join(agg::bevel_join); line_cap_e cap=stroke_.get_line_cap(); if (cap == BUTT_CAP) stroke.generator().line_cap(agg::butt_cap); else if (cap == SQUARE_CAP) stroke.generator().line_cap(agg::square_cap); else stroke.generator().line_cap(agg::round_cap); stroke.generator().miter_limit(4.0); stroke.generator().width(stroke_.get_width()); ras.clip_box(0,0,image.width(),image.height()); ras.add_path(stroke); ren.color(agg::rgba(r, g, b, stroke_.get_opacity())); agg::render_scanlines(ras, sl, ren); } } }
virtual void on_draw() { typedef agg::pixfmt_bgr24 pixfmt; 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.0, 1.0, 1.0)); agg::rasterizer_scanline_aa<> ras; agg::scanline_p8 sl; double x_start = 125.0; double x_end = initial_width() - 15.0; double y_start = 10.0; double y_end = initial_height() - 10.0; double x_center = (x_start + x_end) / 2; unsigned i; agg::path_storage p; agg::conv_stroke<agg::path_storage> pl(p); agg::conv_transform<agg::conv_stroke<agg::path_storage> > tr(pl, trans_affine_resizing()); for(i = 0; i <= 16; i++) { double x = x_start + (x_end - x_start) * i / 16.0; p.remove_all(); p.move_to(x+0.5, y_start); p.line_to(x+0.5, y_end); ras.add_path(tr); rs.color(agg::rgba8(0, 0, 0, i == 8 ? 255 : 100)); agg::render_scanlines(ras, sl, rs); } double ys = y_start + (y_end - y_start) / 6.0; p.remove_all(); p.move_to(x_start, ys); p.line_to(x_end, ys); ras.add_path(tr); rs.color(agg::rgba8(0, 0, 0)); agg::render_scanlines(ras, sl, rs); pl.width(1.0); for(i = 0; i < m_num_filters; i++) { if(m_filters[i]->status()) { m_filter_func[i]->set_radius(m_radius.value()); unsigned j; double radius = m_filter_func[i]->radius(); unsigned n = unsigned(radius * 256 * 2); double dy = y_end - ys; double xs = (x_end + x_start)/2.0 - (radius * (x_end - x_start) / 16.0); double dx = (x_end - x_start) * radius / 8.0; p.remove_all(); p.move_to(xs+0.5, ys + dy * m_filter_func[i]->calc_weight(-radius)); for(j = 1; j < n; j++) { p.line_to(xs + dx * j / n + 0.5, ys + dy * m_filter_func[i]->calc_weight(j / 256.0 - radius)); } ras.add_path(tr); rs.color(agg::rgba8(100, 0, 0)); agg::render_scanlines(ras, sl, rs); p.remove_all(); unsigned xint; int ir = int(ceil(radius) + 0.1); for(xint = 0; xint < 256; xint++) { int xfract; double sum = 0; for(xfract = -ir; xfract < ir; xfract++) { double xf = xint/256.0 + xfract; if(xf >= -radius || xf <= radius) { sum += m_filter_func[i]->calc_weight(xf); } } double x = x_center + ((-128.0 + xint) / 128.0) * radius * (x_end - x_start) / 16.0; double y = ys + sum * 256 - 256; if(xint == 0) p.move_to(x, y); else p.line_to(x, y); } ras.add_path(tr); rs.color(agg::rgba8(0, 100, 0)); agg::render_scanlines(ras, sl, rs); agg::image_filter_lut normalized(*m_filter_func[i]); const agg::int16* weights = normalized.weight_array(); xs = (x_end + x_start)/2.0 - (normalized.diameter() * (x_end - x_start) / 32.0); unsigned nn = normalized.diameter() * 256; p.remove_all(); p.move_to(xs+0.5, ys + dy * weights[0] / agg::image_filter_size); for(j = 1; j < nn; j++) { p.line_to(xs + dx * j / n + 0.5, ys + dy * weights[j] / agg::image_filter_size); } ras.add_path(tr); rs.color(agg::rgba8(0, 0, 100, 255)); agg::render_scanlines(ras, sl, rs); } } for(i = 0; i < m_num_filters; i++) { agg::render_ctrl(ras, sl, rs, *m_filters[i]); } if(m_sinc.status() || m_lanczos.status() || m_blackman.status()) { agg::render_ctrl(ras, sl, rs, m_radius); } }
void agg_renderer<T0,T1>::process(building_symbolizer const& sym, mapnik::feature_impl & feature, proj_transform const& prj_trans) { using transform_path_type = transform_path_adapter<view_transform, vertex_adapter>; using ren_base = agg::renderer_base<agg::pixfmt_rgba32_pre>; using renderer = agg::renderer_scanline_aa_solid<ren_base>; agg::rendering_buffer buf(current_buffer_->bytes(),current_buffer_->width(),current_buffer_->height(), current_buffer_->row_size()); agg::pixfmt_rgba32_pre pixf(buf); ren_base renb(pixf); value_double opacity = get<value_double,keys::fill_opacity>(sym,feature, common_.vars_); color const& fill = get<color, keys::fill>(sym, feature, common_.vars_); unsigned r=fill.red(); unsigned g=fill.green(); unsigned b=fill.blue(); unsigned a=fill.alpha(); renderer ren(renb); agg::scanline_u8 sl; ras_ptr->reset(); double gamma = get<value_double, keys::gamma>(sym, feature, common_.vars_); gamma_method_enum gamma_method = get<gamma_method_enum, keys::gamma_method>(sym, feature, common_.vars_); if (gamma != gamma_ || gamma_method != gamma_method_) { set_gamma_method(ras_ptr, gamma, gamma_method); gamma_method_ = gamma_method; gamma_ = gamma; } double height = get<double, keys::height>(sym, feature, common_.vars_) * common_.scale_factor_; render_building_symbolizer( feature, height, [&,r,g,b,a,opacity](path_type const& faces) { vertex_adapter va(faces); transform_path_type faces_path (this->common_.t_,va,prj_trans); ras_ptr->add_path(faces_path); ren.color(agg::rgba8_pre(int(r*0.8), int(g*0.8), int(b*0.8), int(a * opacity))); agg::render_scanlines(*ras_ptr, sl, ren); this->ras_ptr->reset(); }, [&,r,g,b,a,opacity](path_type const& frame) { vertex_adapter va(frame); transform_path_type path(common_.t_,va, prj_trans); agg::conv_stroke<transform_path_type> stroke(path); stroke.width(common_.scale_factor_); ras_ptr->add_path(stroke); ren.color(agg::rgba8_pre(int(r*0.8), int(g*0.8), int(b*0.8), int(a * opacity))); agg::render_scanlines(*ras_ptr, sl, ren); ras_ptr->reset(); }, [&,r,g,b,a,opacity](path_type const& roof) { vertex_adapter va(roof); transform_path_type roof_path (common_.t_,va,prj_trans); ras_ptr->add_path(roof_path); ren.color(agg::rgba8_pre(r, g, b, int(a * opacity))); agg::render_scanlines(*ras_ptr, sl, ren); }); }
int main(int argc, char* argv[]) { if(argc < 4) { printf("usage: bezier_test <width> <height> <number_of_curves>\n"); return 1; } unsigned w = atoi(argv[1]); unsigned h = atoi(argv[2]); unsigned n = atoi(argv[3]); if(w < 20 || h < 20) { printf("Width and hight must be at least 20\n"); return 1; } if(w > 4096 || h > 4096) { printf("Width and hight mustn't exceed 4096\n"); return 1; } unsigned stride = (w * 3 + 3) / 4 * 4; unsigned char* frame_buffer = new unsigned char[stride * h]; agg::rendering_buffer rbuf; rbuf.attach((unsigned char*)frame_buffer, w, h, stride); agg::pixfmt_bgr24 pixf(rbuf); agg::renderer_base<agg::pixfmt_bgr24> renb(pixf); agg::renderer_scanline_aa_solid<agg::renderer_base<agg::pixfmt_bgr24> > ren(renb); renb.clear(agg::rgba(1.0, 1.0, 1.0)); clock_t t1 = clock(); agg::curve4 curve; agg::conv_stroke<agg::curve4> poly(curve); agg::rasterizer_scanline_aa<> ras; agg::scanline_p8 sl; unsigned i; for(i = 0; i < n; i++) { poly.width(double(rand() % 3500 + 500) / 500.0); curve.init(rand() % w, rand() % h, rand() % w, rand() % h, rand() % w, rand() % h, rand() % w, rand() % h); ren.color(agg::rgba8(rand() & 0xFF, rand() & 0xFF, rand() & 0xFF, rand() & 0xFF)); ras.add_path(poly, 0); agg::render_scanlines(ras, sl, ren); } clock_t t2 = clock(); double sec = double(t2 - t1) / CLOCKS_PER_SEC; printf("%10.3f sec, %10.3f curves per sec\n", sec, double(n) / sec); write_bmp_24("output.bmp", (unsigned char*)frame_buffer, w, h, stride); delete [] frame_buffer; return 0; }
virtual void on_draw() { typedef agg::renderer_base<pixfmt> ren_base; pixfmt pixf(rbuf_window()); ren_base rbase(pixf); trans_roundoff roundoff; if(m_redraw_flag) { g_rasterizer.gamma(agg::gamma_none()); rbase.clear(agg::rgba8(255,255,255)); g_rasterizer.filling_rule(agg::fill_non_zero); agg::render_ctrl(g_rasterizer, g_scanline, rbase, m_rotate); agg::render_ctrl(g_rasterizer, g_scanline, rbase, m_even_odd); agg::render_ctrl(g_rasterizer, g_scanline, rbase, m_draft); agg::render_ctrl(g_rasterizer, g_scanline, rbase, m_roundoff); agg::render_ctrl(g_rasterizer, g_scanline, rbase, m_angle_delta); m_redraw_flag = false; } else { rbase.copy_bar(0, int(32.0 * rbuf_window().height() / m_dy), rbuf_window().width(), rbuf_window().height(), agg::rgba8(255,255,255)); } if(m_draft.status()) { g_rasterizer.gamma(agg::gamma_threshold(0.4)); } agg::trans_affine mtx; mtx.reset(); mtx *= agg::trans_affine_rotation(g_angle * agg::pi / 180.0); mtx *= agg::trans_affine_translation(m_dx / 2, m_dy / 2 + 10); mtx *= agg::trans_affine_scaling(rbuf_window().width() / m_dx, rbuf_window().height() / m_dy); agg::conv_transform<agg::path_storage> fill(g_path, mtx); agg::conv_transform < agg::conv_transform<agg::path_storage>, trans_roundoff > fill_roundoff(fill, roundoff); agg::conv_stroke < agg::conv_transform<agg::path_storage> > stroke(fill); agg::conv_stroke < agg::conv_transform < agg::conv_transform<agg::path_storage>, trans_roundoff > > stroke_roundoff(fill_roundoff); g_pflag = m_even_odd.status() ? agg::fill_even_odd : agg::fill_non_zero; unsigned i; for(i = 0; i < g_npaths; i++) { g_rasterizer.filling_rule(g_pflag); if(m_roundoff.status()) g_rasterizer.add_path(fill_roundoff, g_attr[i].index); else g_rasterizer.add_path(fill, g_attr[i].index); if(m_draft.status()) { agg::render_scanlines_bin_solid(g_rasterizer, g_scanline, rbase, g_attr[i].fill_color); } else { agg::render_scanlines_aa_solid(g_rasterizer, g_scanline, rbase, g_attr[i].fill_color); } if(g_attr[i].stroke_width > 0.001) { stroke.width(g_attr[i].stroke_width * mtx.scale()); stroke_roundoff.width(g_attr[i].stroke_width * mtx.scale()); if(m_roundoff.status()) g_rasterizer.add_path(stroke_roundoff, g_attr[i].index); else g_rasterizer.add_path(stroke, g_attr[i].index); if(m_draft.status()) { agg::render_scanlines_bin_solid(g_rasterizer, g_scanline, rbase, g_attr[i].stroke_color); } else { agg::render_scanlines_aa_solid(g_rasterizer, g_scanline, rbase, g_attr[i].stroke_color); } } } }
Py::Object Image::resize(const Py::Tuple& args) { _VERBOSE("Image::resize"); args.verify_length(2); if (bufferIn ==NULL) throw Py::RuntimeError("You must first load the image"); int numcols = Py::Int(args[0]); int numrows = Py::Int(args[1]); colsOut = numcols; rowsOut = numrows; size_t NUMBYTES(numrows * numcols * BPP); agg::int8u *buffer = new agg::int8u[NUMBYTES]; if (buffer ==NULL) //todo: also handle allocation throw throw Py::MemoryError("Image::resize could not allocate memory"); rbufOut = new agg::rendering_buffer; rbufOut->attach(buffer, numcols, numrows, numcols * BPP); // init the output rendering/rasterizing stuff pixfmt pixf(*rbufOut); renderer_base rb(pixf); rb.clear(bg); agg::rasterizer_scanline_aa<> ras; agg::scanline_u8 sl; //srcMatrix *= resizingMatrix; //imageMatrix *= resizingMatrix; imageMatrix.invert(); interpolator_type interpolator(imageMatrix); // the image path agg::path_storage path; path.move_to(0, 0); path.line_to(colsIn, 0); path.line_to(colsIn, rowsIn); path.line_to(0, rowsIn); path.close_polygon(); agg::conv_transform<agg::path_storage> imageBox(path, srcMatrix); ras.add_path(imageBox); agg::image_filter_base* filter = 0; agg::span_allocator<agg::rgba8> sa; switch(interpolation) { case NEAREST: { typedef agg::span_image_filter_rgba32_nn<agg::order_rgba32, interpolator_type> span_gen_type; typedef agg::renderer_scanline_u<renderer_base, span_gen_type> renderer_type; span_gen_type sg(sa, *rbufIn, agg::rgba(1,1,1,0), interpolator); renderer_type ri(rb, sg); ras.add_path(imageBox); ras.render(sl, ri); } break; case BILINEAR: { typedef agg::span_image_filter_rgba32_bilinear<agg::order_rgba32, interpolator_type> span_gen_type; typedef agg::renderer_scanline_u<renderer_base, span_gen_type> renderer_type; span_gen_type sg(sa, *rbufIn, agg::rgba(1,1,1,0), interpolator); renderer_type ri(rb, sg); ras.add_path(imageBox); ras.render(sl, ri); } break; case BICUBIC: filter = new agg::image_filter<agg::image_filter_bicubic>; case SPLINE16: filter = new agg::image_filter<agg::image_filter_spline16>; case SPLINE36: filter = new agg::image_filter<agg::image_filter_spline36>; case SINC64: filter = new agg::image_filter<agg::image_filter_sinc64>; case SINC144: filter = new agg::image_filter<agg::image_filter_sinc144>; case SINC256: filter = new agg::image_filter<agg::image_filter_sinc256>; case BLACKMAN64: filter = new agg::image_filter<agg::image_filter_blackman64>; case BLACKMAN100: filter = new agg::image_filter<agg::image_filter_blackman100>; case BLACKMAN256: filter = new agg::image_filter<agg::image_filter_blackman256>; typedef agg::span_image_filter_rgba32<agg::order_rgba32, interpolator_type> span_gen_type; typedef agg::renderer_scanline_u<renderer_base, span_gen_type> renderer_type; span_gen_type sg(sa, *rbufIn, agg::rgba(1,1,1,0), interpolator, *filter); renderer_type ri(rb, sg); ras.render(sl, ri); } /* std::ofstream of2( "image_out.raw", std::ios::binary|std::ios::out); for (size_t i=0; i<NUMBYTES; ++i) of2.write((char*)&buffer[i], sizeof(char)); */ bufferOut = buffer; return Py::Object(); }
void operator() (marker_rgba8 const& marker) { using color = agg::rgba8; using order = agg::order_rgba; using blender_type = agg::comp_op_adaptor_rgba_pre<color, order>; using pattern_filter_type = agg::pattern_filter_bilinear_rgba8; using pattern_type = agg::line_image_pattern<pattern_filter_type>; using pixfmt_type = agg::pixfmt_custom_blend_rgba<blender_type, agg::rendering_buffer>; using renderer_base = agg::renderer_base<pixfmt_type>; using renderer_type = agg::renderer_outline_image<renderer_base, pattern_type>; using rasterizer_type = agg::rasterizer_outline_aa<renderer_type>; value_double opacity = get<value_double, keys::opacity>(sym_, feature_, common_.vars_); mapnik::image_rgba8 const& image = marker.get_data(); value_bool clip = get<value_bool, keys::clip>(sym_, feature_, common_.vars_); value_double offset = get<value_double, keys::offset>(sym_, feature_, common_.vars_); value_double simplify_tolerance = get<value_double, keys::simplify_tolerance>(sym_, feature_, common_.vars_); value_double smooth = get<value_double, keys::smooth>(sym_, feature_, common_.vars_); agg::rendering_buffer buf(current_buffer_->getBytes(),current_buffer_->width(),current_buffer_->height(), current_buffer_->getRowSize()); pixfmt_type pixf(buf); pixf.comp_op(static_cast<agg::comp_op_e>(get<composite_mode_e, keys::comp_op>(sym_, feature_, common_.vars_))); renderer_base ren_base(pixf); agg::pattern_filter_bilinear_rgba8 filter; pattern_source source(image, opacity); pattern_type pattern (filter,source); renderer_type ren(ren_base, pattern); ren.clip_box(0,0,common_.width_,common_.height_); rasterizer_type ras(ren); agg::trans_affine tr; auto transform = get_optional<transform_type>(sym_, keys::geometry_transform); if (transform) evaluate_transform(tr, feature_, common_.vars_, *transform, common_.scale_factor_); box2d<double> clip_box = clipping_extent(common_); if (clip) { double padding = (double)(common_.query_extent_.width()/pixmap_.width()); double half_stroke = marker.width()/2.0; if (half_stroke > 1) padding *= half_stroke; if (std::fabs(offset) > 0) padding *= std::fabs(offset) * 1.2; padding *= common_.scale_factor_; clip_box.pad(padding); } vertex_converter<rasterizer_type, clip_line_tag, transform_tag, affine_transform_tag, simplify_tag,smooth_tag, offset_transform_tag> converter(clip_box,ras,sym_,common_.t_,prj_trans_,tr,feature_,common_.vars_,common_.scale_factor_); if (clip) converter.set<clip_line_tag>(); //optional clip (default: true) converter.set<transform_tag>(); //always transform if (simplify_tolerance > 0.0) converter.set<simplify_tag>(); // optional simplify converter if (std::fabs(offset) > 0.0) converter.set<offset_transform_tag>(); // parallel offset converter.set<affine_transform_tag>(); // optional affine transform if (smooth > 0.0) converter.set<smooth_tag>(); // optional smooth converter for (geometry_type const& geom : feature_.paths()) { if (geom.size() > 1) { vertex_adapter va(geom); converter.apply(va); } } }
void agg_renderer<T>::process(line_symbolizer const& sym, Feature const& feature, proj_transform const& prj_trans) { typedef agg::renderer_base<agg::pixfmt_rgba32_plain> ren_base; typedef coord_transform2<CoordTransform,geometry_type> path_type; typedef agg::renderer_outline_aa<ren_base> renderer_oaa; typedef agg::rasterizer_outline_aa<renderer_oaa> rasterizer_outline_aa; typedef agg::renderer_scanline_aa_solid<ren_base> renderer; agg::rendering_buffer buf(pixmap_.raw_data(),width_,height_, width_ * 4); agg::pixfmt_rgba32_plain pixf(buf); ren_base renb(pixf); stroke const& stroke_ = sym.get_stroke(); color const& col = stroke_.get_color(); unsigned r=col.red(); unsigned g=col.green(); unsigned b=col.blue(); unsigned a=col.alpha(); renderer ren(renb); ras_ptr->reset(); ras_ptr->gamma(agg::gamma_linear()); agg::scanline_p8 sl; metawriter_with_properties writer = sym.get_metawriter(); for (unsigned i=0;i<feature.num_geometries();++i) { geometry_type const& geom = feature.get_geometry(i); if (geom.num_points() > 1) { path_type path(t_,geom,prj_trans); if (stroke_.has_dash()) { agg::conv_dash<path_type> dash(path); dash_array const& d = stroke_.get_dash_array(); dash_array::const_iterator itr = d.begin(); dash_array::const_iterator end = d.end(); for (;itr != end;++itr) { dash.add_dash(itr->first * scale_factor_, itr->second * scale_factor_); } agg::conv_stroke<agg::conv_dash<path_type > > stroke(dash); line_join_e join=stroke_.get_line_join(); if ( join == MITER_JOIN) stroke.generator().line_join(agg::miter_join); else if( join == MITER_REVERT_JOIN) stroke.generator().line_join(agg::miter_join); else if( join == ROUND_JOIN) stroke.generator().line_join(agg::round_join); else stroke.generator().line_join(agg::bevel_join); line_cap_e cap=stroke_.get_line_cap(); if (cap == BUTT_CAP) stroke.generator().line_cap(agg::butt_cap); else if (cap == SQUARE_CAP) stroke.generator().line_cap(agg::square_cap); else stroke.generator().line_cap(agg::round_cap); stroke.generator().miter_limit(4.0); stroke.generator().width(stroke_.get_width() * scale_factor_); ras_ptr->add_path(stroke); } else { agg::conv_stroke<path_type> stroke(path); line_join_e join=stroke_.get_line_join(); if ( join == MITER_JOIN) stroke.generator().line_join(agg::miter_join); else if( join == MITER_REVERT_JOIN) stroke.generator().line_join(agg::miter_join); else if( join == ROUND_JOIN) stroke.generator().line_join(agg::round_join); else stroke.generator().line_join(agg::bevel_join); line_cap_e cap=stroke_.get_line_cap(); if (cap == BUTT_CAP) stroke.generator().line_cap(agg::butt_cap); else if (cap == SQUARE_CAP) stroke.generator().line_cap(agg::square_cap); else stroke.generator().line_cap(agg::round_cap); stroke.generator().miter_limit(4.0); stroke.generator().width(stroke_.get_width() * scale_factor_); ras_ptr->add_path(stroke); if (writer.first) writer.first->add_line(path, feature, t_, writer.second); } } } ren.color(agg::rgba8(r, g, b, int(a*stroke_.get_opacity()))); agg::render_scanlines(*ras_ptr, sl, ren); }
void agg_renderer<T0,T1>::process(line_symbolizer const& sym, mapnik::feature_impl & feature, proj_transform const& prj_trans) { color const& col = get<color, keys::stroke>(sym, feature, common_.vars_); unsigned r=col.red(); unsigned g=col.green(); unsigned b=col.blue(); unsigned a=col.alpha(); double gamma = get<value_double, keys::stroke_gamma>(sym, feature, common_.vars_); gamma_method_enum gamma_method = get<gamma_method_enum, keys::stroke_gamma_method>(sym, feature, common_.vars_); ras_ptr->reset(); if (gamma != gamma_ || gamma_method != gamma_method_) { set_gamma_method(ras_ptr, gamma, gamma_method); gamma_method_ = gamma_method; gamma_ = gamma; } buffer_type & current_buffer = buffers_.top().get(); agg::rendering_buffer buf(current_buffer.bytes(), current_buffer.width(), current_buffer.height(), current_buffer.row_size()); using color_type = agg::rgba8; using order_type = agg::order_rgba; using blender_type = agg::comp_op_adaptor_rgba_pre<color_type, order_type>; // comp blender using pixfmt_comp_type = agg::pixfmt_custom_blend_rgba<blender_type, agg::rendering_buffer>; using renderer_base = agg::renderer_base<pixfmt_comp_type>; pixfmt_comp_type pixf(buf); pixf.comp_op(static_cast<agg::comp_op_e>(get<composite_mode_e, keys::comp_op>(sym, feature, common_.vars_))); renderer_base renb(pixf); agg::trans_affine tr; auto transform = get_optional<transform_type>(sym, keys::geometry_transform); if (transform) evaluate_transform(tr, feature, common_.vars_, *transform, common_.scale_factor_); box2d<double> clip_box = clipping_extent(common_); value_bool clip = get<value_bool, keys::clip>(sym, feature, common_.vars_); value_double width = get<value_double, keys::stroke_width>(sym, feature, common_.vars_); value_double opacity = get<value_double,keys::stroke_opacity>(sym,feature, common_.vars_); value_double offset = get<value_double, keys::offset>(sym, feature, common_.vars_); value_double simplify_tolerance = get<value_double, keys::simplify_tolerance>(sym, feature, common_.vars_); value_double smooth = get<value_double, keys::smooth>(sym, feature, common_.vars_); line_rasterizer_enum rasterizer_e = get<line_rasterizer_enum, keys::line_rasterizer>(sym, feature, common_.vars_); if (clip) { double padding = static_cast<double>(common_.query_extent_.width() / common_.width_); double half_stroke = 0.5 * width; if (half_stroke > 1) { padding *= half_stroke; } if (std::fabs(offset) > 0) { padding *= std::fabs(offset) * 1.2; } padding *= common_.scale_factor_; clip_box.pad(padding); // debugging //box2d<double> inverse = query_extent_; //inverse.pad(-padding); //draw_geo_extent(inverse,mapnik::color("red")); } if (rasterizer_e == RASTERIZER_FAST) { using renderer_type = agg::renderer_outline_aa<renderer_base>; using rasterizer_type = agg::rasterizer_outline_aa<renderer_type>; agg::line_profile_aa profile(width * common_.scale_factor_, agg::gamma_power(gamma)); renderer_type ren(renb, profile); ren.color(agg::rgba8_pre(r, g, b, int(a * opacity))); rasterizer_type ras(ren); set_join_caps_aa(sym, ras, feature, common_.vars_); using vertex_converter_type = vertex_converter<clip_line_tag, clip_poly_tag, transform_tag, affine_transform_tag, simplify_tag, smooth_tag, offset_transform_tag>; vertex_converter_type converter(clip_box,sym,common_.t_,prj_trans,tr,feature,common_.vars_,common_.scale_factor_); if (clip) { geometry::geometry_types type = geometry::geometry_type(feature.get_geometry()); if (type == geometry::geometry_types::Polygon || type == geometry::geometry_types::MultiPolygon) converter.template set<clip_poly_tag>(); else if (type == geometry::geometry_types::LineString || type == geometry::geometry_types::MultiLineString) converter.template set<clip_line_tag>(); } converter.set<transform_tag>(); // always transform if (std::fabs(offset) > 0.0) converter.set<offset_transform_tag>(); // parallel offset converter.set<affine_transform_tag>(); // optional affine transform if (simplify_tolerance > 0.0) converter.set<simplify_tag>(); // optional simplify converter if (smooth > 0.0) converter.set<smooth_tag>(); // optional smooth converter using apply_vertex_converter_type = detail::apply_vertex_converter<vertex_converter_type, rasterizer_type>; using vertex_processor_type = geometry::vertex_processor<apply_vertex_converter_type>; apply_vertex_converter_type apply(converter, ras); mapnik::util::apply_visitor(vertex_processor_type(apply),feature.get_geometry()); } else { using vertex_converter_type = vertex_converter<clip_line_tag, clip_poly_tag, transform_tag, affine_transform_tag, simplify_tag, smooth_tag, offset_transform_tag, dash_tag, stroke_tag>; vertex_converter_type converter(clip_box, sym,common_.t_,prj_trans,tr,feature,common_.vars_,common_.scale_factor_); if (clip) { geometry::geometry_types type = geometry::geometry_type(feature.get_geometry()); if (type == geometry::geometry_types::Polygon || type == geometry::geometry_types::MultiPolygon) converter.template set<clip_poly_tag>(); else if (type == geometry::geometry_types::LineString || type == geometry::geometry_types::MultiLineString) converter.template set<clip_line_tag>(); } converter.set<transform_tag>(); // always transform if (std::fabs(offset) > 0.0) converter.set<offset_transform_tag>(); // parallel offset converter.set<affine_transform_tag>(); // optional affine transform if (simplify_tolerance > 0.0) converter.set<simplify_tag>(); // optional simplify converter if (smooth > 0.0) converter.set<smooth_tag>(); // optional smooth converter if (has_key(sym, keys::stroke_dasharray)) converter.set<dash_tag>(); converter.set<stroke_tag>(); //always stroke using apply_vertex_converter_type = detail::apply_vertex_converter<vertex_converter_type, rasterizer>; using vertex_processor_type = geometry::vertex_processor<apply_vertex_converter_type>; apply_vertex_converter_type apply(converter, *ras_ptr); mapnik::util::apply_visitor(vertex_processor_type(apply),feature.get_geometry()); using renderer_type = agg::renderer_scanline_aa_solid<renderer_base>; renderer_type ren(renb); ren.color(agg::rgba8_pre(r, g, b, int(a * opacity))); agg::scanline_u8 sl; ras_ptr->filling_rule(agg::fill_non_zero); agg::render_scanlines(*ras_ptr, sl, ren); } }
virtual void on_draw() { double img_width = rbuf_img(0).width(); double img_height = rbuf_img(0).height(); typedef agg::pixfmt_bgr24 pixfmt; typedef agg::renderer_base<pixfmt> renderer_base; pixfmt pixf(rbuf_window()); pixfmt img_pixf(rbuf_img(0)); renderer_base rb(pixf); rb.clear(agg::rgba(1.0, 1.0, 1.0)); agg::trans_affine src_mtx; src_mtx *= agg::trans_affine_translation(-img_width/2, -img_height/2); src_mtx *= agg::trans_affine_rotation(m_angle.value() * agg::pi / 180.0); src_mtx *= agg::trans_affine_translation(img_width/2 + 10, img_height/2 + 10 + 40); src_mtx *= trans_affine_resizing(); agg::trans_affine img_mtx; img_mtx *= agg::trans_affine_translation(-img_width/2, -img_height/2); 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(img_width/2 + 10, img_height/2 + 10 + 40); img_mtx *= trans_affine_resizing(); img_mtx.invert(); typedef agg::span_allocator<agg::rgba8> span_alloc_type; span_alloc_type sa; typedef agg::span_interpolator_adaptor<agg::span_interpolator_linear<>, periodic_distortion> interpolator_type; periodic_distortion* dist = 0; distortion_wave dist_wave; distortion_swirl dist_swirl; distortion_wave_swirl dist_wave_swirl; distortion_swirl_wave dist_swirl_wave; switch(m_distortion.cur_item()) { case 0: dist = &dist_wave; break; case 1: dist = &dist_swirl; break; case 2: dist = &dist_wave_swirl; break; case 3: dist = &dist_swirl_wave; break; } dist->period(m_period.value()); dist->amplitude(m_amplitude.value()); dist->phase(m_phase); double cx = m_center_x; double cy = m_center_y; img_mtx.transform(&cx, &cy); dist->center(cx, cy); interpolator_type interpolator(img_mtx, *dist); typedef agg::image_accessor_clip<pixfmt> img_source_type; img_source_type img_src(img_pixf, agg::rgba(1,1,1)); /* // 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(1,1,1), 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; agg::scanline_u8 sl; double r = img_width; if(img_height < r) r = img_height; agg::ellipse ell(img_width / 2.0, img_height / 2.0, r / 2.0 - 20.0, r / 2.0 - 20.0, 200); agg::conv_transform<agg::ellipse> tr(ell, src_mtx); ras.add_path(tr); agg::render_scanlines_aa(ras, sl, rb, sa, sg); src_mtx *= ~trans_affine_resizing(); src_mtx *= agg::trans_affine_translation(img_width - img_width/10, 0.0); src_mtx *= trans_affine_resizing(); ras.add_path(tr); agg::render_scanlines_aa_solid(ras, sl, rb, agg::rgba8(0,0,0)); typedef agg::span_gradient<agg::rgba8, interpolator_type, agg::gradient_circle, color_array_type> gradient_span_gen; agg::gradient_circle gradient_function; color_array_type gradient_colors(m_gradient_colors); gradient_span_gen span_gradient(interpolator, gradient_function, gradient_colors, 0, 180); agg::trans_affine gr1_mtx; gr1_mtx *= agg::trans_affine_translation(-img_width/2, -img_height/2); gr1_mtx *= agg::trans_affine_scaling(0.8); gr1_mtx *= agg::trans_affine_rotation(m_angle.value() * agg::pi / 180.0); gr1_mtx *= agg::trans_affine_translation(img_width - img_width/10 + img_width/2 + 10, img_height/2 + 10 + 40); gr1_mtx *= trans_affine_resizing(); agg::trans_affine gr2_mtx; gr2_mtx *= agg::trans_affine_rotation(m_angle.value() * agg::pi / 180.0); gr2_mtx *= agg::trans_affine_scaling(m_scale.value()); gr2_mtx *= agg::trans_affine_translation(img_width - img_width/10 + img_width/2 + 10 + 50, img_height/2 + 10 + 40 + 50); gr2_mtx *= trans_affine_resizing(); gr2_mtx.invert(); cx = m_center_x + img_width - img_width/10; cy = m_center_y; gr2_mtx.transform(&cx, &cy); dist->center(cx, cy); interpolator.transformer(gr2_mtx); agg::conv_transform<agg::ellipse> tr2(ell, gr1_mtx); ras.add_path(tr2); agg::render_scanlines_aa(ras, sl, rb, sa, span_gradient); agg::render_ctrl(ras, sl, rb, m_angle); agg::render_ctrl(ras, sl, rb, m_scale); agg::render_ctrl(ras, sl, rb, m_amplitude); agg::render_ctrl(ras, sl, rb, m_period); agg::render_ctrl(ras, sl, rb, m_distortion); }
void operator() (marker_svg const& marker) const { using color = agg::rgba8; using order = agg::order_rgba; using blender_type = agg::comp_op_adaptor_rgba_pre<color, order>; using pattern_filter_type = agg::pattern_filter_bilinear_rgba8; using pattern_type = agg::line_image_pattern<pattern_filter_type>; using pixfmt_type = agg::pixfmt_custom_blend_rgba<blender_type, agg::rendering_buffer>; using renderer_base = agg::renderer_base<pixfmt_type>; using renderer_type = agg::renderer_outline_image<renderer_base, pattern_type>; using rasterizer_type = agg::rasterizer_outline_aa<renderer_type>; value_double opacity = get<value_double, keys::opacity>(sym_, feature_, common_.vars_); agg::trans_affine image_tr = agg::trans_affine_scaling(common_.scale_factor_); auto image_transform = get_optional<transform_type>(sym_, keys::image_transform); if (image_transform) evaluate_transform(image_tr, feature_, common_.vars_, *image_transform, common_.scale_factor_); mapnik::box2d<double> const& bbox_image = marker.get_data()->bounding_box() * image_tr; image_rgba8 image(bbox_image.width(), bbox_image.height()); render_pattern<buffer_type>(*ras_ptr_, marker, image_tr, 1.0, image); value_bool clip = get<value_bool, keys::clip>(sym_, feature_, common_.vars_); value_double offset = get<value_double, keys::offset>(sym_, feature_, common_.vars_); value_double simplify_tolerance = get<value_double, keys::simplify_tolerance>(sym_, feature_, common_.vars_); value_double smooth = get<value_double, keys::smooth>(sym_, feature_, common_.vars_); agg::rendering_buffer buf(current_buffer_->bytes(),current_buffer_->width(),current_buffer_->height(), current_buffer_->row_size()); pixfmt_type pixf(buf); pixf.comp_op(static_cast<agg::comp_op_e>(get<composite_mode_e, keys::comp_op>(sym_, feature_, common_.vars_))); renderer_base ren_base(pixf); agg::pattern_filter_bilinear_rgba8 filter; pattern_source source(image, opacity); pattern_type pattern (filter,source); renderer_type ren(ren_base, pattern); double half_stroke = std::max(marker.width()/2.0,marker.height()/2.0); int rast_clip_padding = static_cast<int>(std::round(half_stroke)); ren.clip_box(-rast_clip_padding,-rast_clip_padding,common_.width_+rast_clip_padding,common_.height_+rast_clip_padding); rasterizer_type ras(ren); agg::trans_affine tr; auto transform = get_optional<transform_type>(sym_, keys::geometry_transform); if (transform) evaluate_transform(tr, feature_, common_.vars_, *transform, common_.scale_factor_); box2d<double> clip_box = clipping_extent(common_); if (clip) { double padding = (double)(common_.query_extent_.width()/pixmap_.width()); if (half_stroke > 1) padding *= half_stroke; if (std::fabs(offset) > 0) padding *= std::fabs(offset) * 1.2; padding *= common_.scale_factor_; clip_box.pad(padding); } using vertex_converter_type = vertex_converter<clip_line_tag, transform_tag, affine_transform_tag, simplify_tag,smooth_tag, offset_transform_tag>; vertex_converter_type converter(clip_box,sym_,common_.t_,prj_trans_,tr,feature_,common_.vars_,common_.scale_factor_); if (clip) converter.set<clip_line_tag>(); converter.set<transform_tag>(); //always transform if (simplify_tolerance > 0.0) converter.set<simplify_tag>(); // optional simplify converter if (std::fabs(offset) > 0.0) converter.set<offset_transform_tag>(); // parallel offset converter.set<affine_transform_tag>(); // optional affine transform if (smooth > 0.0) converter.set<smooth_tag>(); // optional smooth converter using apply_vertex_converter_type = detail::apply_vertex_converter<vertex_converter_type, rasterizer_type>; using vertex_processor_type = geometry::vertex_processor<apply_vertex_converter_type>; apply_vertex_converter_type apply(converter, ras); mapnik::util::apply_visitor(vertex_processor_type(apply),feature_.get_geometry()); }
virtual void on_draw() { typedef agg::pixfmt_gray8 pixfmt_gray8; typedef agg::renderer_base<pixfmt_gray8> ren_base_gray8; m_ras.clip_box(0,0, width(), height()); pixfmt_gray8 pixf_gray8(m_gray8_rbuf); ren_base_gray8 renb_gray8(pixf_gray8); renb_gray8.clear(agg::gray8(0)); // Testing enhanced compositing operations. // Uncomment and replace renb.blend_from_* to renb_blend.blend_from_* //---------------- //typedef agg::comp_op_rgba_minus<color_type, component_order> blender_type; //typedef agg::comp_adaptor_rgba<blender_type> blend_adaptor_type; //typedef agg::pixfmt_custom_blend_rgba<blend_adaptor_type, agg::rendering_buffer> pixfmt_type; //typedef agg::renderer_base<pixfmt_type> ren_base; //pixfmt_type pixf_blend(rbuf_window()); //agg::renderer_base<pixfmt_type> renb_blend(pixf_blend); pixfmt pixf(rbuf_window()); agg::renderer_base<pixfmt> renb(pixf); renb.clear(agg::rgba(1, 0.95, 0.95)); agg::trans_perspective shadow_persp(m_shape_bounds.x1, m_shape_bounds.y1, m_shape_bounds.x2, m_shape_bounds.y2, m_shadow_ctrl.polygon()); agg::conv_transform<shape_type, agg::trans_perspective> shadow_trans(m_shape, shadow_persp); start_timer(); // Render shadow m_ras.add_path(shadow_trans); agg::render_scanlines_aa_solid(m_ras, m_sl, renb_gray8, agg::gray8(255)); // Calculate the bounding box and extend it by the blur radius agg::rect_d bbox; agg::bounding_rect_single(shadow_trans, 0, &bbox.x1, &bbox.y1, &bbox.x2, &bbox.y2); bbox.x1 -= m_radius.value(); bbox.y1 -= m_radius.value(); bbox.x2 += m_radius.value(); bbox.y2 += m_radius.value(); if(bbox.clip(agg::rect_d(0, 0, width(), height()))) { // Create a new pixel renderer and attach it to the main one as a child image. // It returns true if the attachment suceeded. It fails if the rectangle // (bbox) is fully clipped. //------------------ pixfmt_gray8 pixf2(m_gray8_rbuf2); if(pixf2.attach(pixf_gray8, int(bbox.x1), int(bbox.y1), int(bbox.x2), int(bbox.y2))) { // Blur it agg::stack_blur_gray8(pixf2, agg::uround(m_radius.value()), agg::uround(m_radius.value())); } if(m_method.cur_item() == 0) { renb.blend_from_color(pixf2, agg::rgba8(0, 100, 0), 0, int(bbox.x1), int(bbox.y1)); } else { renb.blend_from_lut(pixf2, m_color_lut.data(), 0, int(bbox.x1), int(bbox.y1)); } } double tm = elapsed_time(); char buf[64]; agg::gsv_text t; t.size(10.0); agg::conv_stroke<agg::gsv_text> st(t); st.width(1.5); sprintf(buf, "%3.2f ms", tm); t.start_point(140.0, 30.0); t.text(buf); m_ras.add_path(st); agg::render_scanlines_aa_solid(m_ras, m_sl, renb, agg::rgba(0,0,0)); agg::render_ctrl(m_ras, m_sl, renb, m_method); agg::render_ctrl(m_ras, m_sl, renb, m_radius); agg::render_ctrl(m_ras, m_sl, renb, m_shadow_ctrl); }