bool operator()() const { mapnik::Map m(256,256,"+init=epsg:3857"); mapnik::parameters params; params["type"]="memory"; auto ds = std::make_shared<mapnik::memory_datasource>(params); // add whitespace to trigger phony "reprojection" mapnik::layer lay("layer",m.srs() + " "); lay.set_datasource(ds); lay.add_style("style"); m.add_layer(lay); // dummy style to ensure that layer is processed m.insert_style("style",mapnik::feature_type_style()); // dummy bbox, but "valid" because minx and miny are less // with an invalid bbox then layer.visible() returns false // and the initial rendering setup is not run m.zoom_to_box(mapnik::box2d<double>(-1,-1,0,0)); for (unsigned i=0;i<iterations_;++i) { mapnik::image_rgba8 im(256,256); mapnik::agg_renderer<mapnik::image_rgba8> ren(m,im); ren.apply(); } return true; }
void render(mapnik::geometry_type & geom, mapnik::box2d<double> const& extent, std::string const& name) { using path_type = mapnik::coord_transform<mapnik::CoordTransform,mapnik::geometry_type>; using ren_base = agg::renderer_base<agg::pixfmt_rgba32_plain>; using renderer = agg::renderer_scanline_aa_solid<ren_base>; mapnik::image_32 im(256,256); im.set_background(mapnik::color("white")); mapnik::box2d<double> padded_extent = extent; padded_extent.pad(10); mapnik::CoordTransform tr(im.width(),im.height(),padded_extent,0,0); agg::rendering_buffer buf(im.raw_data(),im.width(),im.height(), im.width() * 4); agg::pixfmt_rgba32_plain pixf(buf); ren_base renb(pixf); renderer ren(renb); ren.color(agg::rgba8(127,127,127,255)); agg::rasterizer_scanline_aa<> ras; mapnik::proj_transform prj_trans(mapnik::projection("+init=epsg:4326"),mapnik::projection("+init=epsg:4326")); geom.rewind(0); path_type path(tr,geom,prj_trans); ras.add_path(path); agg::scanline_u8 sl; agg::render_scanlines(ras, sl, ren); mapnik::save_to_file(im,name); geom.rewind(0); }
void grid_renderer<T>::process(text_symbolizer const& sym, mapnik::feature_impl & feature, proj_transform const& prj_trans) { 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_); text_symbolizer_helper helper( sym, feature, common_.vars_, prj_trans, common_.width_, common_.height_, common_.scale_factor_ * (1.0/pixmap_.get_resolution()), common_.t_, common_.font_manager_, *common_.detector_, common_.query_extent_, tr); bool placement_found = false; composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, common_.vars_, src_over); grid_text_renderer<T> ren(pixmap_, comp_op, common_.scale_factor_); placements_list const& placements = helper.get(); value_integer feature_id = feature.id(); for (glyph_positions_ptr glyphs : placements) { ren.render(*glyphs, feature_id); placement_found = true; } if (placement_found) { pixmap_.add_feature(feature); } }
int main( int argc, char **argv ) { QApplication app( argc, argv ); #ifndef QSA_NO_IDE QObject::connect( &app, SIGNAL( lastWindowClosed() ), &app, SLOT( quit() ) ); QSProject proj( 0, "FilterModules" ); proj.load( "filter.qsa" ); Renderer ren( proj.interpreter() ); proj.addObject( &ren ); ModuleFactory factory; proj.interpreter()->addObjectFactory( &factory ); QSWorkbench workbench( &proj ); workbench.open(); app.exec(); proj.commitEditorContents(); proj.save( "filter.qsa" ); #else QMessageBox::information( 0, "Disabled feature", "QSA Workbench has been disabled. Reconfigure to enable", QMessageBox::Ok ); #endif return 0; }
void grid_renderer<T>::process(polygon_pattern_symbolizer const& sym, mapnik::feature_impl & feature, proj_transform const& prj_trans) { std::string filename = path_processor_type::evaluate( *sym.get_filename(), feature); boost::optional<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(); agg::trans_affine tr; evaluate_transform(tr, feature, sym.get_transform()); typedef boost::mpl::vector<clip_poly_tag,transform_tag,affine_transform_tag,smooth_tag> conv_types; vertex_converter<box2d<double>, grid_rasterizer, polygon_pattern_symbolizer, CoordTransform, proj_transform, agg::trans_affine, conv_types> converter(query_extent_,*ras_ptr,sym,t_,prj_trans,tr,scale_factor_); if (prj_trans.equal() && sym.clip()) converter.set<clip_poly_tag>(); //optional clip (default: true) converter.set<transform_tag>(); //always transform converter.set<affine_transform_tag>(); if (sym.smooth() > 0.0) converter.set<smooth_tag>(); // optional smooth converter for ( geometry_type & geom : feature.paths()) { if (geom.size() > 2) { converter.apply(geom); } } typedef typename grid_renderer_base_type::pixfmt_type pixfmt_type; typedef typename grid_renderer_base_type::pixfmt_type::color_type color_type; typedef agg::renderer_scanline_bin_solid<grid_renderer_base_type> renderer_type; grid_rendering_buffer buf(pixmap_.raw_data(), width_, height_, 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 fill(Rasterizer *ras, Bitmap<Pixel> *bitmap, BlendOp *blendOp, Filler *filler, float opacity) { agg::scanline_pf sl; ImageBaseRenderer<Filler> baseRen(*bitmap, blendOp, opacity, filler); Renderer<ImageBaseRenderer<Filler> > ren(baseRen); renderScanlines(*ras, sl, ren); }
image_type render(mapnik::Map const & map, double scale_factor) const { std::stringstream ss; std::ostream_iterator<char> output_stream_iterator(ss); mapnik::svg_renderer<std::ostream_iterator<char>> ren(map, output_stream_iterator, scale_factor); ren.apply(); return ss.str(); }
image_type render(mapnik::Map const & map, double scale_factor) const { mapnik::grid grid(map.width(), map.height(), "__id__"); mapnik::grid_renderer<mapnik::grid> ren(map, grid, scale_factor); ren.apply(); image_type image(map.width(), map.height()); convert(grid.data(), image); return image; }
void grid_renderer<T>::render_marker(Feature const& feature, unsigned int step, const int x, const int y, marker &marker, const agg::trans_affine & tr, double opacity) { if (marker.is_vector()) { typedef coord_transform2<CoordTransform,geometry_type> path_type; typedef agg::renderer_base<mapnik::pixfmt_gray16> ren_base; typedef agg::renderer_scanline_bin_solid<ren_base> renderer; agg::scanline_bin sl; grid_rendering_buffer buf(pixmap_.raw_data(), width_, height_, width_); mapnik::pixfmt_gray16 pixf(buf); ren_base renb(pixf); renderer ren(renb); ras_ptr->reset(); box2d<double> const& bbox = (*marker.get_vector_data())->bounding_box(); coord<double,2> c = bbox.center(); // center the svg marker on '0,0' agg::trans_affine mtx = agg::trans_affine_translation(-c.x,-c.y); // apply symbol transformation to get to map space mtx *= tr; mtx *= agg::trans_affine_scaling(scale_factor_*(1.0/step)); // render the marker at the center of the marker box mtx.translate(x+0.5 * marker.width(), y+0.5 * marker.height()); vertex_stl_adapter<svg_path_storage> stl_storage((*marker.get_vector_data())->source()); svg_path_adapter svg_path(stl_storage); svg_renderer<svg_path_adapter, agg::pod_bvector<path_attributes>, renderer, mapnik::pixfmt_gray16> svg_renderer(svg_path, (*marker.get_vector_data())->attributes()); svg_renderer.render_id(*ras_ptr, sl, renb, feature.id(), mtx, opacity, bbox); } else { image_data_32 const& data = **marker.get_bitmap_data(); if (step == 1 && scale_factor_ == 1.0) { pixmap_.set_rectangle(feature.id(), data, x, y); } else { double ratio = (1.0/step); image_data_32 target(ratio * data.width(), ratio * data.height()); mapnik::scale_image_agg<image_data_32>(target,data, SCALING_NEAR, scale_factor_, 0.0, 0.0, 1.0, ratio); pixmap_.set_rectangle(feature.id(), target, x, y); } } pixmap_.add_feature(feature); }
void agg_renderer<T0,T1>::process(group_symbolizer const& sym, mapnik::feature_impl & feature, proj_transform const& prj_trans) { thunk_renderer<buffer_type> ren(*this, ras_ptr, current_buffer_, common_); render_group_symbolizer( sym, feature, common_.vars_, prj_trans, clipping_extent(common_), common_, ren); }
void grid_renderer<T>::process(group_symbolizer const& sym, mapnik::feature_impl & feature, proj_transform const& prj_trans) { thunk_renderer<T> ren(*this, *ras_ptr, pixmap_, common_, feature); render_group_symbolizer( sym, feature, common_.vars_, prj_trans, common_.query_extent_, common_, ren); }
void cairo_renderer<T>::process(group_symbolizer const& sym, mapnik::feature_impl & feature, proj_transform const& prj_trans) { thunk_renderer<T> ren(*this, context_, face_manager_, common_); render_group_symbolizer( sym, feature, common_.vars_, prj_trans, common_.query_extent_, common_, ren); }
int do_ren(u8 * _old , u8 * _new){ s8 ret; if (!check_for_args(REN,2)) return 1; ret =ren(_old, _new); if(ret == -1){ vd_puts("CANNOT RENAME THIS FILE\n"); errormessage(geterror()); } fl_clean(); return 0; }
bool validate() const { mapnik::Map m(256,256); mapnik::load_map(m,xml_); m.zoom_to_box(extent_); mapnik::image_32 im(m.width(),m.height()); mapnik::agg_renderer<mapnik::image_32> ren(m,im); ren.apply(); //mapnik::save_to_file(im,"test.png"); return true; }
void agg_renderer<T0,T1>::process(dot_symbolizer const& sym, mapnik::feature_impl & feature, proj_transform const& prj_trans) { double width = 0.0; double height = 0.0; bool has_width = has_key(sym,keys::width); bool has_height = has_key(sym,keys::height); if (has_width && has_height) { width = get<double>(sym, keys::width, feature, common_.vars_, 0.0); height = get<double>(sym, keys::height, feature, common_.vars_, 0.0); } else if (has_width) { width = height = get<double>(sym, keys::width, feature, common_.vars_, 0.0); } else if (has_height) { width = height = get<double>(sym, keys::height, feature, common_.vars_, 0.0); } double rx = width/2.0; double ry = height/2.0; double opacity = get<double>(sym, keys::opacity, feature, common_.vars_, 1.0); color const& fill = get<mapnik::color>(sym, keys::fill, feature, common_.vars_, mapnik::color(128,128,128)); ras_ptr->reset(); agg::rendering_buffer buf(current_buffer_->raw_data(),current_buffer_->width(),current_buffer_->height(),current_buffer_->width() * 4); using blender_type = agg::comp_op_adaptor_rgba_pre<agg::rgba8, agg::order_rgba>; using pixfmt_comp_type = agg::pixfmt_custom_blend_rgba<blender_type, agg::rendering_buffer>; using renderer_base = agg::renderer_base<pixfmt_comp_type>; using renderer_type = agg::renderer_scanline_aa_solid<renderer_base>; pixfmt_comp_type pixf(buf); pixf.comp_op(static_cast<agg::comp_op_e>(get<composite_mode_e>(sym, keys::comp_op, feature, common_.vars_, src_over))); renderer_base renb(pixf); renderer_type ren(renb); agg::scanline_u8 sl; ren.color(agg::rgba8_pre(fill.red(), fill.green(), fill.blue(), int(fill.alpha() * opacity))); agg::ellipse el(0,0,rx,ry); unsigned num_steps = el.num_steps(); for (geometry_type const& geom : feature.paths()) { double x,y,z = 0; unsigned cmd = 1; geom.rewind(0); while ((cmd = geom.vertex(&x, &y)) != mapnik::SEG_END) { if (cmd == SEG_CLOSE) continue; prj_trans.backward(x,y,z); common_.t_.forward(&x,&y); el.init(x,y,rx,ry,num_steps); ras_ptr->add_path(el); agg::render_scanlines(*ras_ptr, sl, ren); } } }
image_type render(mapnik::Map const & map, double scale_factor) const { mapnik::cairo_surface_ptr image_surface( cairo_image_surface_create(CAIRO_FORMAT_ARGB32, map.width(), map.height()), mapnik::cairo_surface_closer()); mapnik::cairo_ptr image_context(mapnik::create_context(image_surface)); mapnik::cairo_renderer<mapnik::cairo_ptr> ren(map, image_context, scale_factor); ren.apply(); image_type image(map.width(), map.height()); mapnik::cairo_image_to_rgba8(image, image_surface); return image; }
image_type render(mapnik::Map const & map, double scale_factor) const { std::ostringstream ss(std::stringstream::binary); mapnik::cairo_surface_ptr image_surface( SurfaceCreateFunction(write, &ss, map.width(), map.height()), mapnik::cairo_surface_closer()); mapnik::cairo_ptr image_context(mapnik::create_context(image_surface)); mapnik::cairo_renderer<mapnik::cairo_ptr> ren(map, image_context, scale_factor); ren.apply(); cairo_surface_finish(&*image_surface); return ss.str(); }
void render_layer_for_grid(mapnik::Map const& map, mapnik::grid & grid, unsigned layer_idx, boost::python::list const& fields, double scale_factor, unsigned offset_x, unsigned offset_y) { std::vector<mapnik::layer> const& layers = map.layers(); std::size_t layer_num = layers.size(); if (layer_idx >= layer_num) { std::ostringstream s; s << "Zero-based layer index '" << layer_idx << "' not valid, only '" << layer_num << "' layers are in map\n"; throw std::runtime_error(s.str()); } // convert python list to std::set boost::python::ssize_t num_fields = boost::python::len(fields); for(boost::python::ssize_t i=0; i<num_fields; i++) { boost::python::extract<std::string> name(fields[i]); if (name.check()) { grid.add_field(name()); } else { std::stringstream s; s << "list of field names must be strings"; throw mapnik::value_error(s.str()); } } // copy field names std::set<std::string> attributes = grid.get_fields(); // todo - make this a static constant std::string known_id_key = "__id__"; if (attributes.find(known_id_key) != attributes.end()) { attributes.erase(known_id_key); } std::string join_field = grid.get_key(); if (known_id_key != join_field && attributes.find(join_field) == attributes.end()) { attributes.insert(join_field); } mapnik::grid_renderer<mapnik::grid> ren(map,grid,scale_factor,offset_x,offset_y); mapnik::layer const& layer = layers[layer_idx]; ren.apply(layer,attributes); }
void operator()() const { mapnik::Map m(256,256); mapnik::load_map(m,xml_); m.zoom_to_box(extent_); for (unsigned i=0;i<iterations_;++i) { mapnik::image_32 im(m.width(),m.height()); mapnik::agg_renderer<mapnik::image_32> ren(m,im); ren.apply(); } }
void agg_renderer<T>::process(line_pattern_symbolizer const& sym, mapnik::feature_ptr const& feature, proj_transform const& prj_trans) { typedef agg::conv_clip_polyline<geometry_type> clipped_geometry_type; typedef coord_transform2<CoordTransform,clipped_geometry_type> path_type; typedef agg::line_image_pattern<agg::pattern_filter_bilinear_rgba8> pattern_type; typedef agg::renderer_base<agg::pixfmt_rgba32_plain> renderer_base; typedef agg::renderer_outline_image<renderer_base, pattern_type> renderer_type; typedef agg::rasterizer_outline_aa<renderer_type> rasterizer_type; agg::rendering_buffer buf(pixmap_.raw_data(),width_,height_, width_ * 4); agg::pixfmt_rgba32_plain pixf(buf); std::string filename = path_processor_type::evaluate( *sym.get_filename(), *feature); boost::optional<marker_ptr> mark = marker_cache::instance()->find(filename,true); if (!mark) return; if (!(*mark)->is_bitmap()) { std::clog << "### Warning only images (not '" << filename << "') are supported in the line_pattern_symbolizer\n"; return; } boost::optional<image_ptr> pat = (*mark)->get_bitmap_data(); if (!pat) return; box2d<double> ext = query_extent_ * 1.1; renderer_base ren_base(pixf); agg::pattern_filter_bilinear_rgba8 filter; pattern_source source(*(*pat)); pattern_type pattern (filter,source); renderer_type ren(ren_base, pattern); // TODO - should be sensitive to buffer size ren.clip_box(0,0,width_,height_); rasterizer_type ras(ren); //metawriter_with_properties writer = sym.get_metawriter(); for (unsigned i=0;i<feature->num_geometries();++i) { geometry_type & geom = feature->get_geometry(i); if (geom.num_points() > 1) { clipped_geometry_type clipped(geom); clipped.clip_box(ext.minx(),ext.miny(),ext.maxx(),ext.maxy()); path_type path(t_,clipped,prj_trans); ras.add_path(path); //if (writer.first) writer.first->add_line(path, *feature, t_, writer.second); } } }
void grid_renderer<T>::process(building_symbolizer const& sym, mapnik::feature_impl & feature, proj_transform const& prj_trans) { 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 transform_path_type = transform_path_adapter<view_transform, vertex_adapter>; 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(); double height = get<value_double>(sym, keys::height, feature, common_.vars_, 0.0); render_building_symbolizer( feature, height, [&](path_type const& faces) { vertex_adapter va(faces); transform_path_type faces_path (common_.t_,va,prj_trans); ras_ptr->add_path(faces_path); ren.color(color_type(feature.id())); agg::render_scanlines(*ras_ptr, sl, ren); ras_ptr->reset(); }, [&](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); ras_ptr->add_path(stroke); ren.color(color_type(feature.id())); agg::render_scanlines(*ras_ptr, sl, ren); ras_ptr->reset(); }, [&](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(color_type(feature.id())); agg::render_scanlines(*ras_ptr, sl, ren); }); pixmap_.add_feature(feature); }
void grid_renderer<T>::process(shield_symbolizer const& sym, mapnik::feature_impl & feature, proj_transform const& prj_trans) { shield_symbolizer_helper<face_manager<freetype_engine>, label_collision_detector4> helper( sym, feature, prj_trans, width_, height_, scale_factor_, t_, font_manager_, *detector_, query_extent_); bool placement_found = false; text_renderer<T> ren(pixmap_, font_manager_, sym.get_halo_rasterizer(), sym.comp_op(), scale_factor_); text_placement_info_ptr placement; while (helper.next()) { placement_found = true; placements_type const& placements = helper.placements(); for (unsigned int ii = 0; ii < placements.size(); ++ii) { // get_marker_position returns (minx,miny) corner position, // while (currently only) agg_renderer::render_marker newly // expects center position; // until all renderers and shield_symbolizer_helper are // modified accordingly, we must adjust the position here pixel_position pos = helper.get_marker_position(placements[ii]); pos.x += 0.5 * helper.get_marker_width(); pos.y += 0.5 * helper.get_marker_height(); render_marker(feature, pixmap_.get_resolution(), pos, helper.get_marker(), helper.get_image_transform(), sym.get_opacity(), sym.comp_op()); ren.prepare_glyphs(placements[ii]); ren.render_id(feature.id(), placements[ii].center); } } if (placement_found) pixmap_.add_feature(feature); }
virtual void on_draw() { typedef agg::gamma_lut<agg::int8u, agg::int8u, 8, 8> gamma_lut_type; typedef agg::pixfmt_bgr24_gamma<gamma_lut_type> pixfmt; typedef agg::renderer_base<pixfmt> renderer_base; typedef agg::renderer_scanline_aa_solid<renderer_base> renderer_solid; gamma_lut_type gamma(m_gamma.value()); pixfmt pixf(rbuf_window(), gamma); renderer_base rb(pixf); renderer_solid ren(rb); rb.clear(m_white_on_black.status() ? agg::rgba(0,0,0) : agg::rgba(1,1,1)); agg::rasterizer_scanline_aa<> ras; agg::scanline_p8 sl; agg::ellipse e; // Render two "control" circles ren.color(agg::rgba8(127,127,127)); e.init(m_x[0], m_y[0], 3, 3, 16); ras.add_path(e); agg::render_scanlines(ras, sl, ren); e.init(m_x[1], m_y[1], 3, 3, 16); ras.add_path(e); agg::render_scanlines(ras, sl, ren); double d = m_offset.value(); // Creating a rounded rectangle agg::rounded_rect r(m_x[0]+d, m_y[0]+d, m_x[1]+d, m_y[1]+d, m_radius.value()); r.normalize_radius(); // Drawing as an outline agg::conv_stroke<agg::rounded_rect> p(r); p.width(1.0); ras.add_path(p); ren.color(m_white_on_black.status() ? agg::rgba(1,1,1) : agg::rgba(0,0,0)); agg::render_scanlines(ras, sl, ren); ras.gamma(agg::gamma_none()); // Render the controls agg::render_ctrl(ras, sl, rb, m_radius); agg::render_ctrl(ras, sl, rb, m_gamma); agg::render_ctrl(ras, sl, rb, m_offset); agg::render_ctrl(ras, sl, rb, m_white_on_black); }
void agg_renderer<T0,T1>::process(shield_symbolizer const& sym, mapnik::feature_impl & feature, proj_transform const& prj_trans) { box2d<double> clip_box = clipping_extent(common_); 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_); text_symbolizer_helper helper( sym, feature, common_.vars_, prj_trans, common_.width_, common_.height_, common_.scale_factor_, common_.t_, common_.font_manager_, *common_.detector_, clip_box, tr); pixel_position originalLocation = helper.getScreenPostion(); halo_rasterizer_enum halo_rasterizer = get<halo_rasterizer_enum>(sym, keys::halo_rasterizer, feature, common_.vars_, HALO_RASTERIZER_FULL); composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, common_.vars_, src_over); composite_mode_e halo_comp_op = get<composite_mode_e>(sym, keys::halo_comp_op, feature, common_.vars_, src_over); agg_text_renderer<T0> ren(*current_buffer_, halo_rasterizer, comp_op, halo_comp_op, common_.scale_factor_, common_.font_manager_.get_stroker()); double opacity = get<double>(sym,keys::opacity, feature, common_.vars_, 1.0); placements_list const& placements = helper.get(); for (glyph_positions_ptr glyphs : placements) { ren.render(*glyphs, originalLocation); if (glyphs->marker()) { agg::trans_affine tr; tr *= glyphs->marker()->transform; //apply any transform specified in the style xml tr *= glyphs->marker_placement_tr(); //apply any special placement transform render_marker(sym, feature, glyphs->marker_pos(), *(glyphs->marker()->marker), tr, opacity, comp_op); } } }
void agg_renderer<T0,T1>::process(group_symbolizer const& sym, mapnik::feature_impl & feature, proj_transform const& prj_trans) { render_group_symbolizer( sym, feature, common_.vars_, prj_trans, clipping_extent(common_), common_, [&](render_thunk_list const& thunks, pixel_position const& render_offset) { thunk_renderer<buffer_type> ren(*this, ras_ptr, current_buffer_, common_, render_offset); for (render_thunk_ptr const& thunk : thunks) { util::apply_visitor(ren, *thunk); } }); }
void cairo_renderer<T>::process(group_symbolizer const& sym, mapnik::feature_impl & feature, proj_transform const& prj_trans) { render_group_symbolizer( sym, feature, common_.vars_, prj_trans, common_.query_extent_, common_, [&](render_thunk_list const& thunks, pixel_position const& render_offset) { thunk_renderer<T> ren(*this, context_, face_manager_, common_, render_offset); for (render_thunk_ptr const& thunk : thunks) { util::apply_visitor(ren, *thunk); } }); }
virtual void operator()(raster_marker_render_thunk const& thunk) { using buf_type = grid_rendering_buffer; using pixfmt_type = typename grid_renderer_base_type::pixfmt_type; using renderer_type = agg::renderer_scanline_bin_solid<grid_renderer_base_type>; buf_type render_buf(pixmap_.raw_data(), common_.width_, common_.height_, common_.width_); ras_.reset(); pixfmt_type pixf(render_buf); grid_renderer_base_type renb(pixf); renderer_type ren(renb); agg::trans_affine offset_tr = thunk.tr_; offset_tr.translate(offset_.x, offset_.y); render_raster_marker(ren, ras_, thunk.src_, feature_, offset_tr, thunk.opacity_); pixmap_.add_feature(feature_); }
void grid_renderer<T>::process(polygon_symbolizer const& sym, mapnik::feature_impl & feature, proj_transform const& prj_trans) { typedef agg::renderer_scanline_bin_solid<grid_renderer_base_type> renderer_type; typedef typename grid_renderer_base_type::pixfmt_type pixfmt_type; typedef typename grid_renderer_base_type::pixfmt_type::color_type color_type; ras_ptr->reset(); agg::trans_affine tr; evaluate_transform(tr, feature, sym.get_transform(), scale_factor_); typedef boost::mpl::vector<clip_poly_tag,transform_tag,affine_transform_tag,simplify_tag,smooth_tag> conv_types; vertex_converter<box2d<double>, grid_rasterizer, polygon_symbolizer, CoordTransform, proj_transform, agg::trans_affine, conv_types> converter(query_extent_,*ras_ptr,sym,t_,prj_trans,tr,scale_factor_); if (prj_trans.equal() && sym.clip()) converter.set<clip_poly_tag>(); //optional clip (default: true) converter.set<transform_tag>(); //always transform converter.set<affine_transform_tag>(); 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() > 2) { converter.apply(geom); } } grid_rendering_buffer buf(pixmap_.raw_data(), width_, height_, 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() { 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()); m_path.render(ras, sl, ren, mtx, rb.clip_box(), 1.0); ras.gamma(agg::gamma_none()); agg::render_ctrl(ras, sl, ren, m_expand); agg::render_ctrl(ras, sl, ren, m_gamma); agg::render_ctrl(ras, sl, ren, m_scale); agg::render_ctrl(ras, sl, ren, m_rotate); //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() { int width = rbuf_window().width(); int height = rbuf_window().height(); 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 r(rb); rb.clear(agg::rgba(1,1,1)); agg::trans_affine mtx; mtx *= agg::trans_affine_translation(-g_base_dx, -g_base_dy); mtx *= agg::trans_affine_scaling(g_scale, g_scale); mtx *= agg::trans_affine_rotation(g_angle + agg::pi); mtx *= agg::trans_affine_skewing(g_skew_x/1000.0, g_skew_y/1000.0); mtx *= agg::trans_affine_translation(width/2, height/2); if(m_scanline.status()) { agg::conv_stroke<agg::path_storage> stroke(g_path); stroke.width(m_width_slider.value()); stroke.line_join(agg::round_join); agg::conv_transform<agg::conv_stroke<agg::path_storage> > trans(stroke, mtx); agg::render_all_paths(g_rasterizer, g_scanline, r, trans, g_colors, g_path_idx, g_npaths); } else { typedef agg::renderer_outline_aa<renderer_base> renderer_type; typedef agg::rasterizer_outline_aa<renderer_type> rasterizer_type; double w = m_width_slider.value() * mtx.scale(); agg::line_profile_aa profile(w, agg::gamma_none()); renderer_type ren(rb, profile); rasterizer_type ras(ren); agg::conv_transform<agg::path_storage> trans(g_path, mtx); ras.render_all_paths(trans, g_colors, g_path_idx, g_npaths); } agg::render_ctrl(g_rasterizer, g_scanline, rb, m_width_slider); agg::render_ctrl(g_rasterizer, g_scanline, rb, m_scanline); }