void operator() (marker_rgba8 const& mark) { using namespace mapnik::svg; bool clip = get<value_bool, keys::clip>(sym_, feature_, common_.vars_); double offset = get<value_double, keys::offset>(sym_, feature_, common_.vars_); double simplify_tolerance = get<value_double, keys::simplify_tolerance>(sym_, feature_, common_.vars_); double smooth = get<value_double, keys::smooth>(sym_, feature_, common_.vars_); agg::trans_affine geom_tr; auto transform = get_optional<transform_type>(sym_, keys::geometry_transform); if (transform) evaluate_transform(geom_tr, feature_, common_.vars_, *transform, common_.scale_factor_); agg::trans_affine image_tr = agg::trans_affine_scaling(common_.scale_factor_); setup_transform_scaling(image_tr, mark.width(), mark.height(), feature_, common_.vars_, sym_); auto image_transform = get_optional<transform_type>(sym_, keys::image_transform); if (image_transform) evaluate_transform(image_tr, feature_, common_.vars_, *image_transform); box2d<double> const& bbox = mark.bounding_box(); mapnik::image_rgba8 const& marker = mark.get_data(); // - clamp sizes to > 4 pixels of interactivity coord2d center = bbox.center(); agg::trans_affine_translation recenter(-center.x, -center.y); agg::trans_affine marker_trans = recenter * image_tr; raster_dispatch_type rasterizer_dispatch(marker, marker_trans, sym_, *common_.detector_, common_.scale_factor_, feature_, common_.vars_, renderer_context_); vertex_converter_type converter(clip_box_, sym_, common_.t_, prj_trans_, geom_tr, feature_, common_.vars_, common_.scale_factor_); if (clip) // optional clip (default: true) { 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.template set<transform_tag>(); //always transform if (std::fabs(offset) > 0.0) converter.template set<offset_transform_tag>(); // parallel offset converter.template set<affine_transform_tag>(); // optional affine transform if (simplify_tolerance > 0.0) converter.template set<simplify_tag>(); // optional simplify converter if (smooth > 0.0) converter.template set<smooth_tag>(); // optional smooth converter apply_markers_multi(feature_, common_.vars_, converter, rasterizer_dispatch, sym_); }
void operator() (marker_rgba8 const& marker) { double width = marker.get_data().width(); double height = marker.get_data().height(); double cx = 0.5 * width; double cy = 0.5 * height; agg::trans_affine marker_tr; marker_tr *= agg::trans_affine_translation(-cx,-cy); marker_tr *= tr_; marker_tr *= agg::trans_affine_scaling(common_.scale_factor_); marker_tr *= agg::trans_affine_translation(pos_.x,pos_.y); context_.add_image(marker_tr, marker.get_data(), opacity_); }
void operator() (marker_rgba8 const& marker) { image_rgba8 const& data = marker.get_data(); double width = data.width(); double height = data.height(); double cx = 0.5 * width; double cy = 0.5 * height; if ((std::fabs(1.0 - common_.scale_factor_) < 0.001 && tr_.is_identity())) { // TODO - support opacity pixmap_.set_rectangle(feature_.id(), data, boost::math::iround(pos_.x - cx), boost::math::iround(pos_.y - cy)); } else { image_rgba8 target(data.width(), data.height()); mapnik::scale_image_agg(target, data, SCALING_NEAR, 1, 1, 0.0, 0.0, 1.0); // TODO: is 1.0 a valid default here, and do we even care in grid_renderer what the image looks like? pixmap_.set_rectangle(feature_.id(), target, boost::math::iround(pos_.x - cx), boost::math::iround(pos_.y - cy)); } }
void operator() (marker_rgba8 const& marker) { cairo_pattern pattern(marker.get_data(), opacity_); pattern.set_extend(CAIRO_EXTEND_REPEAT); pattern.set_origin(offset_x_, offset_y_); context_.set_pattern(pattern); }
cairo_surface_ptr operator()(marker_rgba8 const& marker) const { box2d<double> bbox(marker.bounding_box()); agg::trans_affine tr(transform(bbox)); cairo_rectangle_t extent { 0, 0, bbox.width(), bbox.height() }; cairo_surface_ptr surface( cairo_recording_surface_create( CAIRO_CONTENT_COLOR_ALPHA, &extent), cairo_surface_closer()); cairo_ptr cairo = create_context(surface); cairo_context context(cairo); context.add_image(tr, marker.get_data(), opacity_); return surface; }
void operator() (marker_rgba8 const& mark) const { agg::trans_affine image_tr = agg::trans_affine_scaling(common_.scale_factor_); setup_transform_scaling(image_tr, mark.width(), mark.height(), feature_, common_.vars_, sym_); 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_); box2d<double> const& bbox = mark.bounding_box(); mapnik::image_rgba8 const& marker = mark.get_data(); // - clamp sizes to > 4 pixels of interactivity coord2d center = bbox.center(); agg::trans_affine_translation recenter(-center.x, -center.y); agg::trans_affine marker_trans = recenter * image_tr; raster_dispatch_type rasterizer_dispatch(marker, marker_trans, sym_, *common_.detector_, common_.scale_factor_, feature_, common_.vars_, renderer_context_); render_marker(mark, rasterizer_dispatch); }
void operator() (marker_rgba8 const& marker) const { mapnik::image_rgba8 const& bg_image = marker.get_data(); std::size_t w = bg_image.width(); std::size_t h = bg_image.height(); if ( w > 0 && h > 0) { // repeat background-image both vertically and horizontally std::size_t x_steps = std::size_t(std::ceil(common_.width_/double(w))); std::size_t y_steps = std::size_t(std::ceil(common_.height_/double(h))); for (std::size_t x=0;x<x_steps;++x) { for (std::size_t y=0;y<y_steps;++y) { agg::trans_affine matrix = agg::trans_affine_translation( x*w, y*h); context_.add_image(matrix, bg_image, 1.0f); } } } }
void operator() (marker_rgba8 const& marker) const { render(marker.get_data()); }
void operator() (marker_rgba8 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_); 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_->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()); }
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 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 pixfmt_type = agg::pixfmt_custom_blend_rgba<blender_type, agg::rendering_buffer>; using wrap_x_type = agg::wrap_mode_repeat; using wrap_y_type = agg::wrap_mode_repeat; using img_source_type = agg::image_accessor_wrap<agg::pixfmt_rgba32_pre, wrap_x_type, wrap_y_type>; using span_gen_type = agg::span_pattern_rgba<img_source_type>; using ren_base = agg::renderer_base<pixfmt_type>; using renderer_type = agg::renderer_scanline_aa_alpha<ren_base, agg::span_allocator<agg::rgba8>, span_gen_type>; mapnik::image_rgba8 const& image = marker.get_data(); agg::rendering_buffer buf(current_buffer_->bytes(), current_buffer_->width(), current_buffer_->height(), current_buffer_->row_size()); ras_ptr_->reset(); value_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; } value_bool clip = get<value_bool, keys::clip>(sym_, feature_, common_.vars_); value_double opacity = get<double, keys::opacity>(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_); box2d<double> clip_box = clipping_extent(common_); pixfmt_type pixf(buf); pixf.comp_op(static_cast<agg::comp_op_e>(get<composite_mode_e, keys::comp_op>(sym_, feature_, common_.vars_))); ren_base renb(pixf); unsigned w = image.width(); unsigned h = image.height(); agg::rendering_buffer pattern_rbuf((agg::int8u*)image.bytes(),w,h,w*4); agg::pixfmt_rgba32_pre pixf_pattern(pattern_rbuf); img_source_type img_src(pixf_pattern); pattern_alignment_enum alignment = get<pattern_alignment_enum, keys::alignment>(sym_, feature_, common_.vars_); unsigned offset_x=0; unsigned offset_y=0; if (alignment == LOCAL_ALIGNMENT) { double x0 = 0; double y0 = 0; using apply_local_alignment = detail::apply_local_alignment; apply_local_alignment apply(common_.t_,prj_trans_, clip_box, x0, y0); util::apply_visitor(geometry::vertex_processor<apply_local_alignment>(apply), feature_.get_geometry()); offset_x = unsigned(current_buffer_->width() - x0); offset_y = unsigned(current_buffer_->height() - y0); } span_gen_type sg(img_src, offset_x, offset_y); agg::span_allocator<agg::rgba8> sa; renderer_type rp(renb,sa, sg, unsigned(opacity * 255)); 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, simplify_tag, smooth_tag>; vertex_converter_type converter(clip_box, sym_,common_.t_,prj_trans_,tr,feature_,common_.vars_,common_.scale_factor_); if (prj_trans_.equal() && clip) converter.set<clip_poly_tag>(); converter.set<transform_tag>(); //always transform 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>; 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()); agg::scanline_u8 sl; ras_ptr_->filling_rule(agg::fill_even_odd); agg::render_scanlines(*ras_ptr_, sl, rp); }