sij/mapnik
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

variables support for cairo/grid/svg

Browse source
This commit is contained in:
Dane Springmeyer 2014-05-13 18:24:17 -07:00
parent 29d92fd162
commit 2f8451b99a
26 changed files with 281 additions and 230 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
bindings/python/mapnik_python.cpp
View file

@ -190,8 +190,10 @@ void render_with_vars(mapnik::Map const& map,
boost::python::dict const& d)
{
mapnik::attributes vars = mapnik::dict2attr(d);
mapnik::request req(map.width(),map.height(),map.get_current_extent());
req.set_buffer_size(map.buffer_size());
python_unblock_auto_block b;
mapnik::agg_renderer<mapnik::image_32> ren(map,image,vars,1,0,0);
mapnik::agg_renderer<mapnik::image_32> ren(map,req,vars,image,1,0,0);
ren.apply();
}

5
include/mapnik/agg_renderer.hpp
View file

@ -67,14 +67,13 @@ public:
typedef T0 buffer_type;
typedef agg_renderer<T0> processor_impl_type;
typedef T1 detector_type;
agg_renderer(Map const& m, buffer_type & pixmap, attributes const& vars, double scale_factor=1.0, unsigned offset_x=0, unsigned offset_y=0);
// create with default, empty placement detector
agg_renderer(Map const& m, buffer_type & pixmap, double scale_factor=1.0, unsigned offset_x=0, unsigned offset_y=0);
// create with external placement detector, possibly non-empty
agg_renderer(Map const &m, buffer_type & pixmap, std::shared_ptr<detector_type> detector,
double scale_factor=1.0, unsigned offset_x=0, unsigned offset_y=0);
// pass in mapnik::request object to provide the mutable things per render
agg_renderer(Map const& m, request const& req, buffer_type & pixmap, double scale_factor=1.0, unsigned offset_x=0, unsigned offset_y=0);
agg_renderer(Map const& m, request const& req, attributes const& vars, buffer_type & pixmap, double scale_factor=1.0, unsigned offset_x=0, unsigned offset_y=0);
~agg_renderer();
void start_map_processing(Map const& map);
void end_map_processing(Map const& map);
@ -143,7 +142,7 @@ public:
return common_.scale_factor_;
}
inline attributes variables()
inline attributes const& variables() const
{
return common_.vars_;
}

9
include/mapnik/cairo_renderer.hpp
View file

@ -58,17 +58,20 @@ class MAPNIK_DECL cairo_renderer_base : private mapnik::noncopyable
protected:
cairo_renderer_base(Map const& m,
cairo_ptr const& cairo,
attributes const& vars,
double scale_factor=1.0,
unsigned offset_x=0,
unsigned offset_y=0);
cairo_renderer_base(Map const& m,
request const& req,
cairo_ptr const& cairo,
attributes const& vars,
double scale_factor=1.0,
unsigned offset_x=0,
unsigned offset_y=0);
cairo_renderer_base(Map const& m,
cairo_ptr const& cairo,
attributes const& vars,
std::shared_ptr<label_collision_detector4> detector,
double scale_factor=1.0,
unsigned offset_x=0,
@ -138,6 +141,11 @@ public:
return common_.scale_factor_;
}
inline attributes const& variables() const
{
return common_.vars_;
}
void render_marker(pixel_position const& pos,
marker const& marker,
agg::trans_affine const& mtx,
@ -165,6 +173,7 @@ public:
unsigned offset_y=0);
cairo_renderer(Map const& m,
request const& req,
attributes const& vars,
T const& obj,
double scale_factor=1.0,
unsigned offset_x=0,

66
include/mapnik/grid/grid_marker_helpers.hpp
View file

@ -55,6 +55,7 @@ struct raster_markers_rasterizer_dispatch_grid
Detector & detector,
double scale_factor,
mapnik::feature_impl & feature,
attributes const& vars,
PixMapType & pixmap)
: buf_(render_buffer),
pixf_(buf_),
@ -66,29 +67,19 @@ struct raster_markers_rasterizer_dispatch_grid
detector_(detector),
scale_factor_(scale_factor),
feature_(feature),
vars_(vars),
pixmap_(pixmap),
placed_(false)
{
// TODO - support basic binary operators
//pixf_.comp_op(static_cast<agg::comp_op_e>(sym_.comp_op()));
}
raster_markers_rasterizer_dispatch_grid(raster_markers_rasterizer_dispatch_grid &&d)
: buf_(d.buf_), pixf_(d.pixf_), renb_(d.renb_), ras_(d.ras_), src_(d.src_),
marker_trans_(d.marker_trans_), sym_(d.sym_), detector_(d.detector_),
scale_factor_(d.scale_factor_), feature_(d.feature_), pixmap_(d.pixmap_),
placed_(d.placed_)
{
}
template <typename T>
void add_path(T & path)
{
marker_placement_enum placement_method = get<marker_placement_enum>(sym_, keys::markers_placement_type, MARKER_POINT_PLACEMENT);
bool ignore_placement = get<bool>(sym_, keys::ignore_placement, false);
bool allow_overlap = get<bool>(sym_, keys::allow_overlap, false);
double spacing = get<double>(sym_, keys::spacing, 100.0);
double max_error = get<double>(sym_, keys::max_error, 0.2);
agg::scanline_bin sl_;
marker_placement_enum placement_method = get<marker_placement_enum>(sym_, keys::markers_placement_type, feature_, vars_, MARKER_POINT_PLACEMENT);
bool ignore_placement = get<bool>(sym_, keys::ignore_placement, feature_, vars_, false);
bool allow_overlap = get<bool>(sym_, keys::allow_overlap, feature_, vars_, false);
box2d<double> bbox_(0,0, src_.width(),src_.height());
if (placement_method != MARKER_LINE_PLACEMENT ||
@ -99,17 +90,23 @@ struct raster_markers_rasterizer_dispatch_grid
if (path.type() == geometry_type::types::LineString)
{
if (!label::middle_point(path, x, y))
{
return;
}
}
else if (placement_method == MARKER_INTERIOR_PLACEMENT)
{
if (!label::interior_position(path, x, y))
{
return;
}
}
else
{
if (!label::centroid(path, x, y))
{
return;
}
}
agg::trans_affine matrix = marker_trans_;
matrix.translate(x,y);
@ -131,6 +128,8 @@ struct raster_markers_rasterizer_dispatch_grid
}
else
{
double spacing = get<double>(sym_, keys::spacing, feature_, vars_, 100.0);
double max_error = get<double>(sym_, keys::max_error, feature_, vars_, 0.2);
markers_placement<T, label_collision_detector4> placement(path, bbox_, marker_trans_, detector_,
spacing * scale_factor_,
max_error,
@ -153,6 +152,7 @@ struct raster_markers_rasterizer_dispatch_grid
void render_raster_marker(agg::trans_affine const& marker_tr)
{
agg::scanline_bin sl_;
double width = src_.width();
double height = src_.height();
double p[8];
@ -174,7 +174,6 @@ struct raster_markers_rasterizer_dispatch_grid
}
private:
agg::scanline_bin sl_;
BufferType & buf_;
PixFmt pixf_;
RendererBase renb_;
@ -185,6 +184,7 @@ private:
Detector & detector_;
double scale_factor_;
mapnik::feature_impl & feature_;
attributes const& vars_;
PixMapType & pixmap_;
bool placed_;
};
@ -208,6 +208,7 @@ struct vector_markers_rasterizer_dispatch_grid
Detector & detector,
double scale_factor,
mapnik::feature_impl & feature,
attributes const& vars,
PixMapType & pixmap)
: buf_(render_buffer),
pixf_(buf_),
@ -220,30 +221,20 @@ struct vector_markers_rasterizer_dispatch_grid
detector_(detector),
scale_factor_(scale_factor),
feature_(feature),
vars_(vars),
pixmap_(pixmap),
placed_(false)
{
// TODO
//pixf_.comp_op(static_cast<agg::comp_op_e>(sym_.comp_op()));
}
vector_markers_rasterizer_dispatch_grid(vector_markers_rasterizer_dispatch_grid &&d)
: buf_(d.buf_), pixf_(d.pixf_), svg_renderer_(std::move(d.svg_renderer_)), ras_(d.ras_),
bbox_(d.bbox_), marker_trans_(d.marker_trans_), sym_(d.sym_), detector_(d.detector_),
scale_factor_(d.scale_factor_), feature_(d.feature_), pixmap_(d.pixmap_),
placed_(d.placed_)
{
}
template <typename T>
void add_path(T & path)
{
marker_placement_enum placement_method = get<marker_placement_enum>(sym_, keys::markers_placement_type, MARKER_POINT_PLACEMENT);
bool ignore_placement = get<bool>(sym_, keys::ignore_placement, false);
double spacing = get<double>(sym_, keys::spacing, 100.0);
double max_error = get<double>(sym_, keys::max_error, 0.2);
double opacity = get<double>(sym_,keys::opacity, 1.0);
bool allow_overlap = get<bool>(sym_, keys::allow_overlap, false);
agg::scanline_bin sl_;
marker_placement_enum placement_method = get<marker_placement_enum>(sym_, keys::markers_placement_type, feature_, vars_, MARKER_POINT_PLACEMENT);
bool ignore_placement = get<bool>(sym_, keys::ignore_placement, feature_, vars_, false);
double opacity = get<double>(sym_,keys::opacity, feature_, vars_, 1.0);
bool allow_overlap = get<bool>(sym_, keys::allow_overlap, feature_, vars_, false);
if (placement_method != MARKER_LINE_PLACEMENT ||
path.type() == geometry_type::types::Point)
@ -253,17 +244,23 @@ struct vector_markers_rasterizer_dispatch_grid
if (path.type() == geometry_type::types::LineString)
{
if (!label::middle_point(path, x, y))
{
return;
}
}
else if (placement_method == MARKER_INTERIOR_PLACEMENT)
{
if (!label::interior_position(path, x, y))
{
return;
}
}
else
{
if (!label::centroid(path, x, y))
{
return;
}
}
agg::trans_affine matrix = marker_trans_;
matrix.translate(x,y);
@ -285,6 +282,8 @@ struct vector_markers_rasterizer_dispatch_grid
}
else
{
double spacing = get<double>(sym_, keys::spacing, feature_, vars_, 100.0);
double max_error = get<double>(sym_, keys::max_error, feature_, vars_, 0.2);
markers_placement<T, Detector> placement(path, bbox_, marker_trans_, detector_,
spacing * scale_factor_,
max_error,
@ -305,7 +304,6 @@ struct vector_markers_rasterizer_dispatch_grid
}
}
private:
agg::scanline_bin sl_;
BufferType & buf_;
pixfmt_type pixf_;
renderer_base renb_;
@ -317,10 +315,10 @@ private:
Detector & detector_;
double scale_factor_;
mapnik::feature_impl & feature_;
attributes const& vars_;
PixMapType & pixmap_;
bool placed_;
};
}
#endif

7
include/mapnik/grid/grid_renderer.hpp
View file

@ -68,7 +68,7 @@ public:
typedef T buffer_type;
typedef grid_renderer<T> processor_impl_type;
grid_renderer(Map const& m, T & pixmap, double scale_factor=1.0, unsigned offset_x=0, unsigned offset_y=0);
grid_renderer(Map const& m, request const& req, T & pixmap, double scale_factor=1.0, unsigned offset_x=0, unsigned offset_y=0);
grid_renderer(Map const& m, request const& req, attributes const& vars, T & pixmap, double scale_factor=1.0, unsigned offset_x=0, unsigned offset_y=0);
~grid_renderer();
void start_map_processing(Map const& map);
void end_map_processing(Map const& map);
@ -131,6 +131,11 @@ public:
return common_.scale_factor_;
}
inline attributes const& variables() const
{
return common_.vars_;
}
private:
buffer_type & pixmap_;
const std::unique_ptr<grid_rasterizer> ras_ptr;

97
include/mapnik/marker_helpers.hpp
View file

@ -75,6 +75,8 @@ struct vector_markers_rasterizer_dispatch
agg::trans_affine const& marker_trans,
markers_symbolizer const& sym,
Detector & detector,
feature_impl & feature,
attributes const& vars,
double scale_factor,
bool snap_to_pixels)
: buf_(render_buffer),
@ -86,26 +88,22 @@ struct vector_markers_rasterizer_dispatch
marker_trans_(marker_trans),
sym_(sym),
detector_(detector),
feature_(feature),
vars_(vars),
scale_factor_(scale_factor),
snap_to_pixels_(snap_to_pixels)
{
pixf_.comp_op(get<agg::comp_op_e>(sym_, keys::comp_op, agg::comp_op_src_over));
}
vector_markers_rasterizer_dispatch(vector_markers_rasterizer_dispatch &&d)
: buf_(d.buf_), pixf_(d.pixf_), svg_renderer_(std::move(d.svg_renderer_)), ras_(d.ras_),
bbox_(d.bbox_), marker_trans_(d.marker_trans_), sym_(d.sym_), detector_(d.detector_),
scale_factor_(d.scale_factor_), snap_to_pixels_(d.snap_to_pixels_)
{
pixf_.comp_op(get<agg::comp_op_e>(sym_, keys::comp_op, feature_, vars_, agg::comp_op_src_over));
}
template <typename T>
void add_path(T & path)
{
marker_placement_enum placement_method = get<marker_placement_enum>(sym_, keys::markers_placement_type, MARKER_POINT_PLACEMENT);
bool ignore_placement = get<bool>(sym_, keys::ignore_placement, false);
bool allow_overlap = get<bool>(sym_, keys::allow_overlap, false);
double opacity = get<double>(sym_,keys::opacity, 1.0);
agg::scanline_u8 sl_;
marker_placement_enum placement_method = get<marker_placement_enum>(sym_, keys::markers_placement_type, feature_, vars_, MARKER_POINT_PLACEMENT);
bool ignore_placement = get<bool>(sym_, keys::ignore_placement, feature_, vars_, false);
bool allow_overlap = get<bool>(sym_, keys::allow_overlap, feature_, vars_, false);
double opacity = get<double>(sym_,keys::opacity, feature_, vars_, 1.0);
if (placement_method != MARKER_LINE_PLACEMENT ||
path.type() == mapnik::geometry_type::types::Point)
@ -115,17 +113,23 @@ struct vector_markers_rasterizer_dispatch
if (path.type() == mapnik::geometry_type::types::LineString)
{
if (!label::middle_point(path, x, y))
{
return;
}
}
else if (placement_method == MARKER_INTERIOR_PLACEMENT)
{
if (!label::interior_position(path, x, y))
{
return;
}
}
else
{
if (!label::centroid(path, x, y))
{
return;
}
}
agg::trans_affine matrix = marker_trans_;
matrix.translate(x,y);
@ -150,8 +154,8 @@ struct vector_markers_rasterizer_dispatch
}
else
{
double spacing = get<double>(sym_, keys::spacing, 100.0);
double max_error = get<double>(sym_, keys::max_error, 0.2);
double spacing = get<double>(sym_, keys::spacing, feature_, vars_, 100.0);
double max_error = get<double>(sym_, keys::max_error, feature_, vars_, 0.2);
markers_placement<T, Detector> placement(path, bbox_, marker_trans_, detector_,
spacing * scale_factor_,
max_error,
@ -169,7 +173,6 @@ struct vector_markers_rasterizer_dispatch
}
}
private:
agg::scanline_u8 sl_;
BufferType & buf_;
pixfmt_type pixf_;
renderer_base renb_;
@ -179,6 +182,8 @@ private:
agg::trans_affine const& marker_trans_;
markers_symbolizer const& sym_;
Detector & detector_;
feature_impl & feature_;
attributes const& vars_;
double scale_factor_;
bool snap_to_pixels_;
};
@ -199,6 +204,8 @@ struct raster_markers_rasterizer_dispatch
agg::trans_affine const& marker_trans,
markers_symbolizer const& sym,
Detector & detector,
feature_impl & feature,
attributes const& vars,
double scale_factor,
bool snap_to_pixels)
: buf_(render_buffer),
@ -209,27 +216,22 @@ struct raster_markers_rasterizer_dispatch
marker_trans_(marker_trans),
sym_(sym),
detector_(detector),
feature_(feature),
vars_(vars),
scale_factor_(scale_factor),
snap_to_pixels_(snap_to_pixels)
{
pixf_.comp_op(get<agg::comp_op_e>(sym_, keys::comp_op, agg::comp_op_src_over));
}
raster_markers_rasterizer_dispatch(raster_markers_rasterizer_dispatch &&d)
: buf_(d.buf_), pixf_(d.pixf_), renb_(d.renb_), ras_(d.ras_), src_(d.src_),
marker_trans_(d.marker_trans_), sym_(d.sym_), detector_(d.detector_),
scale_factor_(d.scale_factor_), snap_to_pixels_(d.snap_to_pixels_)
{
pixf_.comp_op(get<agg::comp_op_e>(sym_, keys::comp_op, feature_, vars_, agg::comp_op_src_over));
}
template <typename T>
void add_path(T & path)
{
marker_placement_enum placement_method = get<marker_placement_enum>(sym_, keys::markers_placement_type, MARKER_POINT_PLACEMENT);
bool allow_overlap = get<bool>(sym_, keys::allow_overlap, false);
marker_placement_enum placement_method = get<marker_placement_enum>(sym_, keys::markers_placement_type, feature_, vars_, MARKER_POINT_PLACEMENT);
bool allow_overlap = get<bool>(sym_, keys::allow_overlap, feature_, vars_, false);
box2d<double> bbox_(0,0, src_.width(),src_.height());
double opacity = get<double>(sym_, keys::opacity, 1.0);
bool ignore_placement = get<bool>(sym_, keys::ignore_placement, false);
double opacity = get<double>(sym_, keys::opacity, feature_, vars_, 1.0);
bool ignore_placement = get<bool>(sym_, keys::ignore_placement, feature_, vars_, false);
if (placement_method != MARKER_LINE_PLACEMENT ||
path.type() == mapnik::geometry_type::types::Point)
@ -239,17 +241,23 @@ struct raster_markers_rasterizer_dispatch
if (path.type() == mapnik::geometry_type::types::LineString)
{
if (!label::middle_point(path, x, y))
{
return;
}
}
else if (placement_method == MARKER_INTERIOR_PLACEMENT)
{
if (!label::interior_position(path, x, y))
{
return;
}
}
else
{
if (!label::centroid(path, x, y))
{
return;
}
}
agg::trans_affine matrix = marker_trans_;
matrix.translate(x,y);
@ -267,8 +275,8 @@ struct raster_markers_rasterizer_dispatch
}
else
{
double spacing = get<double>(sym_, keys::spacing, 100.0);
double max_error = get<double>(sym_, keys::max_error, 0.2);
double spacing = get<double>(sym_, keys::spacing, feature_, vars_, 100.0);
double max_error = get<double>(sym_, keys::max_error, feature_, vars_, 0.2);
markers_placement<T, label_collision_detector4> placement(path, bbox_, marker_trans_, detector_,
spacing * scale_factor_,
max_error,
@ -288,6 +296,7 @@ struct raster_markers_rasterizer_dispatch
double opacity)
{
typedef agg::pixfmt_rgba32_pre pixfmt_pre;
agg::scanline_u8 sl_;
double width = src_.width();
double height = src_.height();
if (std::fabs(1.0 - scale_factor_) < 0.001
@ -350,7 +359,6 @@ struct raster_markers_rasterizer_dispatch
}
private:
agg::scanline_u8 sl_;
BufferType & buf_;
pixfmt_comp_type pixf_;
renderer_base renb_;
@ -359,13 +367,15 @@ private:
agg::trans_affine const& marker_trans_;
markers_symbolizer const& sym_;
Detector & detector_;
feature_impl & feature_;
attributes const& vars_;
double scale_factor_;
bool snap_to_pixels_;
};
template <typename T>
void build_ellipse(T const& sym, mapnik::feature_impl const& feature, attributes const& vars, svg_storage_type & marker_ellipse, svg::svg_path_adapter & svg_path)
void build_ellipse(T const& sym, mapnik::feature_impl & feature, attributes const& vars, svg_storage_type & marker_ellipse, svg::svg_path_adapter & svg_path)
{
auto width_expr = get<expression_ptr>(sym, keys::width);
auto height_expr = get<expression_ptr>(sym, keys::height);
@ -401,13 +411,16 @@ void build_ellipse(T const& sym, mapnik::feature_impl const& feature, attributes
}
template <typename Attr>
bool push_explicit_style(Attr const& src, Attr & dst, markers_symbolizer const& sym)
bool push_explicit_style(Attr const& src, Attr & dst,
markers_symbolizer const& sym,
feature_impl & feature,
attributes const& vars)
{
auto fill_color = get_optional<color>(sym, keys::fill);
auto fill_opacity = get_optional<double>(sym, keys::fill_opacity);
auto stroke_color = get_optional<color>(sym, keys::stroke);
auto stroke_width = get_optional<double>(sym, keys::stroke_width);
auto stroke_opacity = get_optional<double>(sym, keys::stroke_opacity);
auto fill_color = get_optional<color>(sym, keys::fill, feature, vars);
auto fill_opacity = get_optional<double>(sym, keys::fill_opacity, feature, vars);
auto stroke_color = get_optional<color>(sym, keys::stroke, feature, vars);
auto stroke_width = get_optional<double>(sym, keys::stroke_width, feature, vars);
auto stroke_opacity = get_optional<double>(sym, keys::stroke_opacity, feature, vars);
if (fill_color ||
fill_opacity ||
stroke_color ||
@ -464,7 +477,7 @@ template <typename T>
void setup_transform_scaling(agg::trans_affine & tr,
double svg_width,
double svg_height,
mapnik::feature_impl const& feature,
mapnik::feature_impl & feature,
attributes const& vars,
T const& sym)
{
@ -499,7 +512,7 @@ void setup_transform_scaling(agg::trans_affine & tr,
// Apply markers to a feature with multiple geometries
template <typename Converter>
void apply_markers_multi(feature_impl & feature, Converter& converter, markers_symbolizer const& sym)
void apply_markers_multi(feature_impl & feature, attributes const& vars, Converter& converter, markers_symbolizer const& sym)
{
std::size_t geom_count = feature.paths().size();
if (geom_count == 1)
@ -508,8 +521,8 @@ void apply_markers_multi(feature_impl & feature, Converter& converter, markers_s
}
else if (geom_count > 1)
{
marker_multi_policy_enum multi_policy = get<marker_multi_policy_enum>(sym, keys::markers_multipolicy, MARKER_EACH_MULTI);
marker_placement_enum placement = get<marker_placement_enum>(sym, keys::markers_placement_type, MARKER_POINT_PLACEMENT);
marker_multi_policy_enum multi_policy = get<marker_multi_policy_enum>(sym, keys::markers_multipolicy, feature, vars, MARKER_EACH_MULTI);
marker_placement_enum placement = get<marker_placement_enum>(sym, keys::markers_placement_type, feature, vars, MARKER_POINT_PLACEMENT);
if (placement == MARKER_POINT_PLACEMENT &&
multi_policy == MARKER_WHOLE_MULTI)
{
@ -553,7 +566,7 @@ void apply_markers_multi(feature_impl & feature, Converter& converter, markers_s
}
for (geometry_type & path : feature.paths())
{
converter.apply(path);
converter.apply(path);
}
}
}

10
include/mapnik/renderer_common/process_markers_symbolizer.hpp
View file

@ -78,7 +78,7 @@ void render_markers_symbolizer(markers_symbolizer const &sym,
svg_path_adapter svg_path(stl_storage);
build_ellipse(sym, feature, common.vars_, marker_ellipse, svg_path);
svg_attribute_type attributes;
bool result = push_explicit_style( (*stock_vector_marker)->attributes(), attributes, sym);
bool result = push_explicit_style( (*stock_vector_marker)->attributes(), attributes, sym, feature, common.vars_);
auto image_transform = get_optional<transform_type>(sym, keys::image_transform);
if (image_transform) evaluate_transform(tr, feature, common.vars_, *image_transform);
box2d<double> bbox = marker_ellipse.bounding_box();
@ -103,7 +103,7 @@ void render_markers_symbolizer(markers_symbolizer const &sym,
}
converter.template set<transform_tag>(); //always transform
if (smooth > 0.0) converter.template set<smooth_tag>(); // optional smooth converter
apply_markers_multi(feature, converter, sym);
apply_markers_multi(feature, common.vars_, converter, sym);
}
else
{
@ -114,7 +114,7 @@ void render_markers_symbolizer(markers_symbolizer const &sym,
vertex_stl_adapter<svg_path_storage> stl_storage((*stock_vector_marker)->source());
svg_path_adapter svg_path(stl_storage);
svg_attribute_type attributes;
bool result = push_explicit_style( (*stock_vector_marker)->attributes(), attributes, sym);
bool result = push_explicit_style( (*stock_vector_marker)->attributes(), attributes, sym, feature, common.vars_);
auto rasterizer_dispatch = make_vector_dispatch(
svg_path, result ? attributes : (*stock_vector_marker)->attributes(),
**stock_vector_marker, bbox, tr, snap_pixels);
@ -135,7 +135,7 @@ void render_markers_symbolizer(markers_symbolizer const &sym,
}
converter.template set<transform_tag>(); //always transform
if (smooth > 0.0) converter.template set<smooth_tag>(); // optional smooth converter
apply_markers_multi(feature, converter, sym);
apply_markers_multi(feature, common.vars_, converter, sym);
}
}
else // raster markers
@ -165,7 +165,7 @@ void render_markers_symbolizer(markers_symbolizer const &sym,
}
converter.template set<transform_tag>(); //always transform
if (smooth > 0.0) converter.template set<smooth_tag>(); // optional smooth converter
apply_markers_multi(feature, converter, sym);
apply_markers_multi(feature, common.vars_, converter, sym);
}
}
}

6
include/mapnik/svg/output/svg_renderer.hpp
View file

@ -73,6 +73,7 @@ class MAPNIK_DECL svg_renderer : public feature_style_processor<svg_renderer<Out
{
public:
typedef svg_renderer<OutputIterator> processor_impl_type;
svg_renderer(Map const& m, OutputIterator& output_iterator, attributes const& vars, double scale_factor=1.0, unsigned offset_x=0, unsigned offset_y=0);
svg_renderer(Map const& m, OutputIterator& output_iterator, double scale_factor=1.0, unsigned offset_x=0, unsigned offset_y=0);
svg_renderer(Map const& m, request const& req, OutputIterator& output_iterator, double scale_factor=1.0, unsigned offset_x=0, unsigned offset_y=0);
~svg_renderer();
@ -147,6 +148,11 @@ public:
return common_.scale_factor_;
}
inline attributes const& variables() const
{
return common_.vars_;
}
inline OutputIterator& get_output_iterator()
{
return output_iterator_;

3
include/mapnik/webp_io.hpp
View file

@ -28,7 +28,10 @@
#include <mapnik/util/conversions.hpp>
// webp
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-function"
#include <webp/encode.h>
#pragma clang diagnostic pop
// stl
#include <stdexcept>

19
src/agg/agg_renderer.cpp
View file

@ -62,21 +62,6 @@
namespace mapnik
{
template <typename T0, typename T1>
agg_renderer<T0,T1>::agg_renderer(Map const& m, T0 & pixmap, attributes const& vars, double scale_factor, unsigned offset_x, unsigned offset_y)
: feature_style_processor<agg_renderer>(m, scale_factor),
pixmap_(pixmap),
internal_buffer_(),
current_buffer_(&pixmap),
style_level_compositing_(false),
ras_ptr(new rasterizer),
gamma_method_(GAMMA_POWER),
gamma_(1.0),
common_(m, vars, offset_x, offset_y, m.width(), m.height(), scale_factor)
{
setup(m);
}
template <typename T0, typename T1>
agg_renderer<T0,T1>::agg_renderer(Map const& m, T0 & pixmap, double scale_factor, unsigned offset_x, unsigned offset_y)
: feature_style_processor<agg_renderer>(m, scale_factor),
@ -93,7 +78,7 @@ agg_renderer<T0,T1>::agg_renderer(Map const& m, T0 & pixmap, double scale_factor
}
template <typename T0, typename T1>
agg_renderer<T0,T1>::agg_renderer(Map const& m, request const& req, T0 & pixmap, double scale_factor, unsigned offset_x, unsigned offset_y)
agg_renderer<T0,T1>::agg_renderer(Map const& m, request const& req, attributes const& vars, T0 & pixmap, double scale_factor, unsigned offset_x, unsigned offset_y)
: feature_style_processor<agg_renderer>(m, scale_factor),
pixmap_(pixmap),
internal_buffer_(),
@ -102,7 +87,7 @@ agg_renderer<T0,T1>::agg_renderer(Map const& m, request const& req, T0 & pixmap,
ras_ptr(new rasterizer),
gamma_method_(GAMMA_POWER),
gamma_(1.0),
common_(req, attributes(), offset_x, offset_y, req.width(), req.height(), scale_factor)
common_(req, vars, offset_x, offset_y, req.width(), req.height(), scale_factor)
{
setup(m);
}

1
src/agg/process_line_pattern_symbolizer.cpp
View file

@ -114,7 +114,6 @@ void agg_renderer<T0,T1>::process(line_pattern_symbolizer const& sym,
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 opacity = get<value_double>(sym,keys::stroke_opacity,feature, 1.0); TODO
double offset = get<value_double>(sym, keys::offset, feature, common_.vars_, 0.0);

2
src/agg/process_markers_symbolizer.cpp
View file

@ -111,6 +111,7 @@ void agg_renderer<T0,T1>::process(markers_symbolizer const& sym,
marker_trans,
sym,
*common_.detector_,
feature, common_.vars_,
common_.scale_factor_,
snap_pixels);
},
@ -125,6 +126,7 @@ void agg_renderer<T0,T1>::process(markers_symbolizer const& sym,
marker_trans,
sym,
*common_.detector_,
feature, common_.vars_,
common_.scale_factor_,
true /*snap rasters no matter what*/);
});

20
src/agg/process_polygon_pattern_symbolizer.cpp
View file

@ -59,6 +59,15 @@ void agg_renderer<T0,T1>::process(polygon_pattern_symbolizer const& sym,
boost::optional<mapnik::marker_ptr> marker = marker_cache::instance().find(filename, true);
if (!marker) return;
if (!(*marker)->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 = (*marker)->get_bitmap_data();
if (!pat) return;
typedef agg::conv_clip_polygon<geometry_type> clipped_geometry_type;
typedef coord_transform<CoordTransform,clipped_geometry_type> path_type;
@ -73,17 +82,6 @@ void agg_renderer<T0,T1>::process(polygon_pattern_symbolizer const& sym,
gamma_ = gamma;
}
if (!(*marker)->is_bitmap())
{
MAPNIK_LOG_DEBUG(agg_renderer) << "agg_renderer: Only images (not '" << filename << "') are supported in the polygon_pattern_symbolizer";
return;
}
boost::optional<image_ptr> pat = (*marker)->get_bitmap_data();
if (!pat) return;
bool clip = get<value_bool>(sym, keys::clip, feature, common_.vars_, false);
double opacity = get<double>(sym,keys::stroke_opacity, feature, common_.vars_, 1.0);
double simplify_tolerance = get<value_double>(sym, keys::simplify_tolerance, feature, common_.vars_, 0.0);

145
src/cairo_renderer.cpp
View file

@ -58,6 +58,7 @@
#include <mapnik/attribute_collector.hpp>
#include <mapnik/group/group_layout_manager.hpp>
#include <mapnik/group/group_symbolizer_helper.hpp>
#include <mapnik/attribute.hpp>
// mapnik symbolizer generics
#include <mapnik/renderer_common/process_building_symbolizer.hpp>
@ -108,12 +109,13 @@ struct cairo_save_restore
cairo_renderer_base::cairo_renderer_base(Map const& m,
cairo_ptr const& cairo,
attributes const& vars,
double scale_factor,
unsigned offset_x,
unsigned offset_y)
: m_(m),
context_(cairo),
common_(m, offset_x, offset_y, m.width(), m.height(), scale_factor),
common_(m, vars, offset_x, offset_y, m.width(), m.height(), scale_factor),
face_manager_(common_.shared_font_engine_)
{
setup(m);
@ -122,12 +124,13 @@ cairo_renderer_base::cairo_renderer_base(Map const& m,
cairo_renderer_base::cairo_renderer_base(Map const& m,
request const& req,
cairo_ptr const& cairo,
attributes const& vars,
double scale_factor,
unsigned offset_x,
unsigned offset_y)
: m_(m),
context_(cairo),
common_(req, offset_x, offset_y, req.width(), req.height(), scale_factor),
common_(req, vars, offset_x, offset_y, req.width(), req.height(), scale_factor),
face_manager_(common_.shared_font_engine_)
{
setup(m);
@ -135,13 +138,14 @@ cairo_renderer_base::cairo_renderer_base(Map const& m,
cairo_renderer_base::cairo_renderer_base(Map const& m,
cairo_ptr const& cairo,
attributes const& vars,
std::shared_ptr<label_collision_detector4> detector,
double scale_factor,
unsigned offset_x,
unsigned offset_y)
: m_(m),
context_(cairo),
common_(m, offset_x, offset_y, m.width(), m.height(), scale_factor, detector),
common_(m, vars, offset_x, offset_y, m.width(), m.height(), scale_factor, detector),
face_manager_(common_.shared_font_engine_)
{
MAPNIK_LOG_DEBUG(cairo_renderer) << "cairo_renderer_base: Scale=" << m.scale();
@ -150,32 +154,32 @@ cairo_renderer_base::cairo_renderer_base(Map const& m,
template <>
cairo_renderer<cairo_ptr>::cairo_renderer(Map const& m, cairo_ptr const& cairo, double scale_factor, unsigned offset_x, unsigned offset_y)
: feature_style_processor<cairo_renderer>(m,scale_factor),
cairo_renderer_base(m,cairo,scale_factor,offset_x,offset_y) {}
cairo_renderer_base(m,cairo,attributes(),scale_factor,offset_x,offset_y) {}
template <>
cairo_renderer<cairo_surface_ptr>::cairo_renderer(Map const& m, cairo_surface_ptr const& surface, double scale_factor, unsigned offset_x, unsigned offset_y)
: feature_style_processor<cairo_renderer>(m,scale_factor),
cairo_renderer_base(m,create_context(surface),scale_factor,offset_x,offset_y) {}
cairo_renderer_base(m,create_context(surface),attributes(),scale_factor,offset_x,offset_y) {}
template <>
cairo_renderer<cairo_ptr>::cairo_renderer(Map const& m, request const& req, cairo_ptr const& cairo, double scale_factor, unsigned offset_x, unsigned offset_y)
cairo_renderer<cairo_ptr>::cairo_renderer(Map const& m, request const& req, attributes const& vars, cairo_ptr const& cairo, double scale_factor, unsigned offset_x, unsigned offset_y)
: feature_style_processor<cairo_renderer>(m,scale_factor),
cairo_renderer_base(m,req,cairo,scale_factor,offset_x,offset_y) {}
cairo_renderer_base(m,req,cairo,vars,scale_factor,offset_x,offset_y) {}
template <>
cairo_renderer<cairo_surface_ptr>::cairo_renderer(Map const& m, request const& req, cairo_surface_ptr const& surface, double scale_factor, unsigned offset_x, unsigned offset_y)
cairo_renderer<cairo_surface_ptr>::cairo_renderer(Map const& m, request const& req, attributes const& vars, cairo_surface_ptr const& surface, double scale_factor, unsigned offset_x, unsigned offset_y)
: feature_style_processor<cairo_renderer>(m,scale_factor),
cairo_renderer_base(m,req, create_context(surface),scale_factor,offset_x,offset_y) {}
cairo_renderer_base(m,req,create_context(surface),attributes(),scale_factor,offset_x,offset_y) {}
template <>
cairo_renderer<cairo_ptr>::cairo_renderer(Map const& m, cairo_ptr const& cairo, std::shared_ptr<label_collision_detector4> detector, double scale_factor, unsigned offset_x, unsigned offset_y)
: feature_style_processor<cairo_renderer>(m,scale_factor),
cairo_renderer_base(m,cairo,detector,scale_factor,offset_x,offset_y) {}
cairo_renderer_base(m,cairo,attributes(),detector,scale_factor,offset_x,offset_y) {}
template <>
cairo_renderer<cairo_surface_ptr>::cairo_renderer(Map const& m, cairo_surface_ptr const& surface, std::shared_ptr<label_collision_detector4> detector, double scale_factor, unsigned offset_x, unsigned offset_y)
: feature_style_processor<cairo_renderer>(m,scale_factor),
cairo_renderer_base(m,create_context(surface),detector,scale_factor,offset_x,offset_y) {}
cairo_renderer_base(m,create_context(surface),attributes(),detector,scale_factor,offset_x,offset_y) {}
cairo_renderer_base::~cairo_renderer_base() {}
@ -279,7 +283,7 @@ void cairo_renderer_base::process(polygon_symbolizer const& sym,
conv_types, feature_impl> vertex_converter_type;
cairo_save_restore guard(context_);
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, src_over);
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, common_.vars_, src_over);
context_.set_operator(comp_op);
render_polygon_symbolizer<vertex_converter_type>(
@ -298,10 +302,10 @@ void cairo_renderer_base::process(building_symbolizer const& sym,
{
typedef coord_transform<CoordTransform,geometry_type> path_type;
cairo_save_restore guard(context_);
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, src_over);
mapnik::color fill = get<mapnik::color>(sym, keys::fill, feature);
double opacity = get<double>(sym, keys::fill_opacity, feature, 1.0);
double height = get<double>(sym, keys::height, feature, 0.0);
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, common_.vars_, src_over);
mapnik::color fill = get<mapnik::color>(sym, keys::fill, feature, common_.vars_, mapnik::color(128,128,128));
double opacity = get<double>(sym, keys::fill_opacity, feature, common_.vars_, 1.0);
double height = get<double>(sym, keys::height, feature, common_.vars_, 0.0);
context_.set_operator(comp_op);
@ -340,21 +344,19 @@ void cairo_renderer_base::process(line_symbolizer const& sym,
offset_transform_tag,
dash_tag, stroke_tag> conv_types;
cairo_save_restore guard(context_);
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, src_over);
auto geom_transform = get_optional<transform_type>(sym, keys::geometry_transform);
bool clip = get<bool>(sym, keys::clip, feature, true);
double offset = get<double>(sym, keys::offset, feature, 0.0);
double simplify_tolerance = get<double>(sym, keys::simplify_tolerance, feature, 0.0);
double smooth = get<double>(sym, keys::smooth, feature, 0.0);
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, common_.vars_, src_over);
bool clip = get<bool>(sym, keys::clip, feature, common_.vars_, true);
double offset = get<double>(sym, keys::offset, feature, common_.vars_, 0.0);
double simplify_tolerance = get<double>(sym, keys::simplify_tolerance, feature, common_.vars_, 0.0);
double smooth = get<double>(sym, keys::smooth, feature, common_.vars_, 0.0);
mapnik::color stroke = get<mapnik::color>(sym, keys::stroke, feature, mapnik::color(0,0,0));
double stroke_opacity = get<double>(sym, keys::stroke_opacity, feature, 1.0);
line_join_enum stroke_join = get<line_join_enum>(sym, keys::stroke_linejoin, MITER_JOIN);
line_cap_enum stroke_cap = get<line_cap_enum>(sym, keys::stroke_linecap, BUTT_CAP);
mapnik::color stroke = get<mapnik::color>(sym, keys::stroke, feature, common_.vars_, mapnik::color(0,0,0));
double stroke_opacity = get<double>(sym, keys::stroke_opacity, feature, common_.vars_, 1.0);
line_join_enum stroke_join = get<line_join_enum>(sym, keys::stroke_linejoin, feature, common_.vars_, MITER_JOIN);
line_cap_enum stroke_cap = get<line_cap_enum>(sym, keys::stroke_linecap, feature, common_.vars_, BUTT_CAP);
auto dash = get_optional<dash_array>(sym, keys::stroke_dasharray);
double miterlimit = get<double>(sym, keys::stroke_miterlimit, feature, 4.0);
double width = get<double>(sym, keys::stroke_width, feature, 1.0);
double miterlimit = get<double>(sym, keys::stroke_miterlimit, feature, common_.vars_, 4.0);
double width = get<double>(sym, keys::stroke_width, feature, common_.vars_, 1.0);
context_.set_operator(comp_op);
context_.set_color(stroke, stroke_opacity);
@ -368,7 +370,8 @@ void cairo_renderer_base::process(line_symbolizer const& sym,
}
agg::trans_affine tr;
if (geom_transform) { evaluate_transform(tr, feature, *geom_transform, common_.scale_factor_); }
auto geom_transform = get_optional<transform_type>(sym, keys::geometry_transform);
if (geom_transform) { evaluate_transform(tr, feature, common_.vars_, *geom_transform, common_.scale_factor_); }
box2d<double> clipping_extent = common_.query_extent_;
if (clip)
@ -384,7 +387,7 @@ void cairo_renderer_base::process(line_symbolizer const& sym,
}
vertex_converter<box2d<double>, cairo_context, line_symbolizer,
CoordTransform, proj_transform, agg::trans_affine, conv_types, feature_impl>
converter(clipping_extent,context_,sym,common_.t_,prj_trans,tr,feature,common_.scale_factor_);
converter(clipping_extent,context_,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
@ -553,7 +556,7 @@ void cairo_renderer_base::process(point_symbolizer const& sym,
mapnik::feature_impl & feature,
proj_transform const& prj_trans)
{
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, src_over);
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, common_.vars_, src_over);
cairo_save_restore guard(context_);
context_.set_operator(comp_op);
@ -571,15 +574,15 @@ void cairo_renderer_base::process(shield_symbolizer const& sym,
proj_transform const& prj_trans)
{
text_symbolizer_helper helper(
sym, feature, prj_trans,
sym, feature, common_.vars_, prj_trans,
common_.width_, common_.height_,
common_.scale_factor_,
common_.t_, common_.font_manager_, *common_.detector_,
common_.query_extent_);
cairo_save_restore guard(context_);
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, src_over);
double opacity = get<double>(sym,keys::opacity,feature, 1.0);
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, common_.vars_, src_over);
double opacity = get<double>(sym,keys::opacity,feature, common_.vars_, 1.0);
context_.set_operator(comp_op);
@ -605,8 +608,8 @@ void cairo_renderer_base::process(line_pattern_symbolizer const& sym,
typedef agg::conv_clip_polyline<geometry_type> clipped_geometry_type;
typedef coord_transform<CoordTransform,clipped_geometry_type> path_type;
std::string filename = get<std::string>(sym, keys::file, feature);
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, src_over);
std::string filename = get<std::string>(sym, keys::file, feature, common_.vars_);
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, common_.vars_, src_over);
boost::optional<marker_ptr> marker;
if ( !filename.empty() )
@ -690,12 +693,11 @@ void cairo_renderer_base::process(polygon_pattern_symbolizer const& sym,
//typedef coord_transform<CoordTransform,clipped_geometry_type> path_type;
cairo_save_restore guard(context_);
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, src_over);
std::string filename = get<std::string>(sym, keys::file, feature);
auto geom_transform = get_optional<transform_type>(sym, keys::geometry_transform);
bool clip = get<bool>(sym, keys::clip, feature, false);
double simplify_tolerance = get<double>(sym, keys::simplify_tolerance, feature, 0.0);
double smooth = get<double>(sym, keys::smooth, feature, 0.0);
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, common_.vars_, src_over);
std::string filename = get<std::string>(sym, keys::file, feature, common_.vars_);
bool clip = get<bool>(sym, keys::clip, feature, common_.vars_, true);
double simplify_tolerance = get<double>(sym, keys::simplify_tolerance, feature, common_.vars_, 0.0);
double smooth = get<double>(sym, keys::smooth, feature, common_.vars_, 0.0);
context_.set_operator(comp_op);
@ -728,12 +730,13 @@ void cairo_renderer_base::process(polygon_pattern_symbolizer const& sym,
//}
agg::trans_affine tr;
if (geom_transform) { evaluate_transform(tr, feature, *geom_transform, common_.scale_factor_); }
auto geom_transform = get_optional<transform_type>(sym, keys::geometry_transform);
if (geom_transform) { evaluate_transform(tr, feature, common_.vars_, *geom_transform, common_.scale_factor_); }
typedef boost::mpl::vector<clip_poly_tag,transform_tag,affine_transform_tag,simplify_tag,smooth_tag> conv_types;
vertex_converter<box2d<double>, cairo_context, polygon_pattern_symbolizer,
CoordTransform, proj_transform, agg::trans_affine, conv_types, feature_impl>
converter(common_.query_extent_,context_,sym,common_.t_,prj_trans,tr,feature,common_.scale_factor_);
converter(common_.query_extent_,context_,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
@ -780,6 +783,8 @@ struct markers_dispatch
markers_symbolizer const& sym,
box2d<double> const& bbox,
agg::trans_affine const& marker_trans,
feature_impl const& feature,
mapnik::attributes const& vars,
double scale_factor)
:ctx_(ctx),
marker_(marker),
@ -788,19 +793,20 @@ struct markers_dispatch
sym_(sym),
bbox_(bbox),
marker_trans_(marker_trans),
feature_(feature),
vars_(vars),
scale_factor_(scale_factor) {}
template <typename T>
void add_path(T & path)
{
marker_placement_enum placement_method = get<marker_placement_enum>(sym_, keys::markers_placement_type, MARKER_POINT_PLACEMENT);
bool ignore_placement = get<bool>(sym_, keys::ignore_placement, false);
bool allow_overlap = get<bool>(sym_, keys::allow_overlap, false);
double opacity = get<double>(sym_, keys::opacity, 1.0);
double spacing = get<double>(sym_, keys::spacing, 100.0);
double max_error = get<double>(sym_, keys::max_error, 0.2);
marker_placement_enum placement_method = get<marker_placement_enum>(sym_, keys::markers_placement_type, feature_, vars_, MARKER_POINT_PLACEMENT);
bool ignore_placement = get<bool>(sym_, keys::ignore_placement, feature_, vars_, false);
bool allow_overlap = get<bool>(sym_, keys::allow_overlap, feature_, vars_, false);
double opacity = get<double>(sym_, keys::opacity, feature_, vars_, 1.0);
double spacing = get<double>(sym_, keys::spacing, feature_, vars_, 100.0);
double max_error = get<double>(sym_, keys::max_error, feature_, vars_, 0.2);
if (placement_method != MARKER_LINE_PLACEMENT ||
path.type() == geometry_type::types::Point)
@ -864,6 +870,8 @@ struct markers_dispatch
markers_symbolizer const& sym_;
box2d<double> const& bbox_;
agg::trans_affine const& marker_trans_;
feature_impl const& feature_;
attributes const& vars_;
double scale_factor_;
};
@ -876,6 +884,8 @@ struct markers_dispatch_2
markers_symbolizer const& sym,
box2d<double> const& bbox,
agg::trans_affine const& marker_trans,
feature_impl const& feature,
mapnik::attributes const& vars,
double scale_factor)
:ctx_(ctx),
marker_(marker),
@ -883,18 +893,20 @@ struct markers_dispatch_2
sym_(sym),
bbox_(bbox),
marker_trans_(marker_trans),
feature_(feature),
vars_(vars),
scale_factor_(scale_factor) {}
template <typename T>
void add_path(T & path)
{
marker_placement_enum placement_method = get<marker_placement_enum>(sym_, keys::markers_placement_type, MARKER_POINT_PLACEMENT);
double opacity = get<double>(sym_, keys::opacity, 1.0);
double spacing = get<double>(sym_, keys::spacing, 100.0);
double max_error = get<double>(sym_, keys::max_error, 0.2);
bool allow_overlap = get<bool>(sym_, keys::allow_overlap, false);
bool ignore_placement = get<bool>(sym_, keys::ignore_placement, false);
marker_placement_enum placement_method = get<marker_placement_enum>(sym_, keys::markers_placement_type, feature_, vars_, MARKER_POINT_PLACEMENT);
double opacity = get<double>(sym_, keys::opacity, feature_, vars_, 1.0);
double spacing = get<double>(sym_, keys::spacing, feature_, vars_, 100.0);
double max_error = get<double>(sym_, keys::max_error, feature_, vars_, 0.2);
bool allow_overlap = get<bool>(sym_, keys::allow_overlap, feature_, vars_, false);
bool ignore_placement = get<bool>(sym_, keys::ignore_placement, feature_, vars_, false);
if (placement_method != MARKER_LINE_PLACEMENT ||
path.type() == geometry_type::types::Point)
@ -958,6 +970,8 @@ struct markers_dispatch_2
markers_symbolizer const& sym_;
box2d<double> const& bbox_;
agg::trans_affine const& marker_trans_;
feature_impl const& feature_;
attributes const& vars_;
double scale_factor_;
};
@ -973,7 +987,7 @@ void cairo_renderer_base::process(markers_symbolizer const& sym,
label_collision_detector4> vector_dispatch_type;
cairo_save_restore guard(context_);
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, src_over);
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, common_.vars_, src_over);
context_.set_operator(comp_op);
box2d<double> clip_box = common_.query_extent_;
@ -983,12 +997,12 @@ void cairo_renderer_base::process(markers_symbolizer const& sym,
box2d<double> const &bbox, agg::trans_affine const &marker_trans,
bool) -> vector_dispatch_type {
return vector_dispatch_type(context_, marker, attr, *common_.detector_, sym, bbox,
marker_trans, common_.scale_factor_);
marker_trans, feature, common_.vars_, common_.scale_factor_);
},
[&](image_data_32 &marker, agg::trans_affine const &marker_trans,
box2d<double> const &bbox) -> raster_dispatch_type {
return raster_dispatch_type(context_, marker, *common_.detector_, sym, bbox,
marker_trans, common_.scale_factor_);
marker_trans, feature, common_.vars_, common_.scale_factor_);
});
}
@ -997,15 +1011,14 @@ void cairo_renderer_base::process(text_symbolizer const& sym,
proj_transform const& prj_trans)
{
text_symbolizer_helper helper(
sym, feature, prj_trans,
sym, feature, common_.vars_, prj_trans,
common_.width_, common_.height_,
common_.scale_factor_,
common_.t_, common_.font_manager_, *common_.detector_,
common_.query_extent_);
cairo_save_restore guard(context_);
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, src_over);
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, common_.vars_, src_over);
context_.set_operator(comp_op);
placements_list const &placements = helper.get();
@ -1085,7 +1098,7 @@ void cairo_renderer_base::process(group_symbolizer const& sym,
proj_transform const& prj_trans)
{
render_group_symbolizer(
sym, feature, prj_trans, common_.query_extent_, common_,
sym, feature, common_.vars_, prj_trans, common_.query_extent_, common_,
[&](render_thunk_list const& thunks, pixel_position const& render_offset)
{
thunk_renderer ren(*this, context_, face_manager_, common_, render_offset);
@ -1123,7 +1136,7 @@ void cairo_renderer_base::process(debug_symbolizer const& sym,
typedef label_collision_detector4 detector_type;
cairo_save_restore guard(context_);
debug_symbolizer_mode_enum mode = get<debug_symbolizer_mode_enum>(sym, keys::mode, DEBUG_SYM_MODE_COLLISION);
debug_symbolizer_mode_enum mode = get<debug_symbolizer_mode_enum>(sym, keys::mode, feature, common_.vars_, DEBUG_SYM_MODE_COLLISION);
context_.set_operator(src_over);
context_.set_color(mapnik::color(255, 0, 0), 1.0);

6
src/grid/grid_renderer.cpp
View file

@ -63,19 +63,19 @@ grid_renderer<T>::grid_renderer(Map const& m, T & pixmap, double scale_factor, u
ras_ptr(new grid_rasterizer),
// NOTE: can change this to m dims instead of pixmap_ if render-time
// resolution support is dropped from grid_renderer python interface
common_(m, offset_x, offset_y, pixmap_.width(), pixmap_.height(), scale_factor)
common_(m, attributes(), offset_x, offset_y, pixmap_.width(), pixmap_.height(), scale_factor)
{
setup(m);
}
template <typename T>
grid_renderer<T>::grid_renderer(Map const& m, request const& req, T & pixmap, double scale_factor, unsigned offset_x, unsigned offset_y)
grid_renderer<T>::grid_renderer(Map const& m, request const& req, attributes const& vars, T & pixmap, double scale_factor, unsigned offset_x, unsigned offset_y)
: feature_style_processor<grid_renderer>(m, scale_factor),
pixmap_(pixmap),
ras_ptr(new grid_rasterizer),
// NOTE: can change this to m dims instead of pixmap_ if render-time
// resolution support is dropped from grid_renderer python interface
common_(req, offset_x, offset_y, pixmap_.width(), pixmap_.height(), scale_factor)
common_(req, vars, offset_x, offset_y, pixmap_.width(), pixmap_.height(), scale_factor)
{
setup(m);
}

2
src/grid/process_building_symbolizer.cpp
View file

@ -68,7 +68,7 @@ void grid_renderer<T>::process(building_symbolizer const& sym,
ras_ptr->reset();
double height = get<value_double>(sym, keys::height,feature, 0.0);
double height = get<value_double>(sym, keys::height, feature, common_.vars_, 0.0);
render_building_symbolizer(
feature, height,

2
src/grid/process_group_symbolizer.cpp
View file

@ -117,7 +117,7 @@ void grid_renderer<T>::process(group_symbolizer const& sym,
proj_transform const& prj_trans)
{
render_group_symbolizer(
sym, feature, prj_trans, common_.query_extent_, common_,
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, pixmap_, common_, feature, render_offset);

21
src/grid/process_line_pattern_symbolizer.cpp
View file

@ -50,9 +50,9 @@ 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);
boost::optional<marker_ptr> mark = marker_cache::instance().find(filename,true);
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())
@ -64,10 +64,10 @@ void grid_renderer<T>::process(line_pattern_symbolizer const& sym,
boost::optional<image_ptr> pat = (*mark)->get_bitmap_data();
if (!pat) return;
bool clip = get<value_bool>(sym, keys::clip, feature);
double offset = get<value_double>(sym, keys::offset, feature, 0.0);
double simplify_tolerance = get<value_double>(sym, keys::simplify_tolerance, feature, 0.0);
double smooth = get<value_double>(sym, keys::smooth, feature, false);
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);
typedef typename grid_renderer_base_type::pixfmt_type pixfmt_type;
typedef typename grid_renderer_base_type::pixfmt_type::color_type color_type;
@ -89,7 +89,10 @@ void grid_renderer<T>::process(line_pattern_symbolizer const& sym,
agg::trans_affine tr;
auto transform = get_optional<transform_type>(sym, keys::geometry_transform);
if (transform) { evaluate_transform(tr, feature, *transform, common_.scale_factor_); }
if (transform)
{
evaluate_transform(tr, feature, common_.vars_, *transform, common_.scale_factor_);
}
box2d<double> clipping_extent = common_.query_extent_;
if (clip)
@ -117,7 +120,7 @@ void grid_renderer<T>::process(line_pattern_symbolizer const& sym,
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_.scale_factor_);
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

17
src/grid/process_line_symbolizer.cpp
View file

@ -65,15 +65,18 @@ void grid_renderer<T>::process(line_symbolizer const& sym,
agg::trans_affine tr;
auto transform = get_optional<transform_type>(sym, keys::geometry_transform);
if (transform) { evaluate_transform(tr, feature, *transform, common_.scale_factor_); }
if (transform)
{
evaluate_transform(tr, feature, common_.vars_, *transform, common_.scale_factor_);
}
box2d<double> clipping_extent = common_.query_extent_;
bool clip = get<value_bool>(sym, keys::clip, feature, true);
double width = get<value_double>(sym, keys::stroke_width, feature, 1.0);
double offset = get<value_double>(sym, keys::offset, feature, 0.0);
double simplify_tolerance = get<value_double>(sym, keys::simplify_tolerance, feature, 0.0);
double smooth = get<value_double>(sym, keys::smooth, feature, false);
bool clip = get<value_bool>(sym, keys::clip, feature, common_.vars_, true);
double width = get<value_double>(sym, keys::stroke_width, feature, common_.vars_,1.0);
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);
bool has_dash = has_key<dash_array>(sym, keys::stroke_dasharray);
if (clip)
@ -90,7 +93,7 @@ void grid_renderer<T>::process(line_symbolizer const& sym,
vertex_converter<box2d<double>, grid_rasterizer, line_symbolizer,
CoordTransform, proj_transform, agg::trans_affine, conv_types, feature_impl>
converter(clipping_extent,*ras_ptr,sym,common_.t_,prj_trans,tr,feature,common_.scale_factor_);
converter(clipping_extent,*ras_ptr,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 (std::fabs(offset) > 0.0) converter.set<offset_transform_tag>(); // parallel offset

2
src/grid/process_markers_symbolizer.cpp
View file

@ -129,6 +129,7 @@ void grid_renderer<T>::process(markers_symbolizer const& sym,
*common_.detector_,
common_.scale_factor_,
feature,
common_.vars_,
pixmap_);
},
[&](image_data_32 const &marker, agg::trans_affine const &tr,
@ -145,6 +146,7 @@ void grid_renderer<T>::process(markers_symbolizer const& sym,
*common_.detector_,
common_.scale_factor_,
feature,
common_.vars_,
pixmap_);
});
}

2
src/grid/process_point_symbolizer.cpp
View file

@ -52,7 +52,7 @@ void grid_renderer<T>::process(point_symbolizer const& sym,
mapnik::feature_impl & feature,
proj_transform const& prj_trans)
{
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, src_over);
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, common_.vars_, src_over);
render_point_symbolizer(
sym, feature, prj_trans, common_,

21
src/grid/process_polygon_pattern_symbolizer.cpp
View file

@ -52,9 +52,9 @@ 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);
boost::optional<marker_ptr> mark = marker_cache::instance().find(filename,true);
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())
@ -68,18 +68,21 @@ void grid_renderer<T>::process(polygon_pattern_symbolizer const& sym,
ras_ptr->reset();
bool clip = get<value_bool>(sym, keys::clip, feature, false);
double simplify_tolerance = get<value_double>(sym, keys::simplify_tolerance, feature, 0.0);
double smooth = get<value_double>(sym, keys::smooth, feature, false);
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 geom_transform = get_optional<transform_type>(sym, keys::geometry_transform);
if (geom_transform) evaluate_transform(tr, feature, *geom_transform, common_.scale_factor_);
auto transform = get_optional<transform_type>(sym, keys::geometry_transform);
if (transform)
{
evaluate_transform(tr, feature, common_.vars_, *transform, common_.scale_factor_);
}
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, feature_impl>
converter(common_.query_extent_,*ras_ptr,sym,common_.t_,prj_trans,tr,feature,common_.scale_factor_);
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

6
src/grid/process_shield_symbolizer.cpp
View file

@ -44,15 +44,15 @@ void grid_renderer<T>::process(shield_symbolizer const& sym,
proj_transform const& prj_trans)
{
text_symbolizer_helper helper(
sym, feature, prj_trans,
sym, feature, common_.vars_, prj_trans,
common_.width_, common_.height_,
common_.scale_factor_,
common_.t_, common_.font_manager_, *common_.detector_,
common_.query_extent_);
bool placement_found = false;
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, src_over);
double opacity = get<double>(sym,keys::opacity,feature, 1.0);
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, common_.vars_, src_over);
double opacity = get<double>(sym, keys::opacity, feature, common_.vars_, 1.0);
grid_text_renderer<T> ren(pixmap_,
comp_op,

4
src/grid/process_text_symbolizer.cpp
View file

@ -37,14 +37,14 @@ void grid_renderer<T>::process(text_symbolizer const& sym,
proj_transform const& prj_trans)
{
text_symbolizer_helper helper(
sym, feature, prj_trans,
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_);
bool placement_found = false;
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, src_over);
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,

13
src/svg/output/svg_renderer.cpp
View file

@ -36,13 +36,22 @@
namespace mapnik
{
template <typename T>
svg_renderer<T>::svg_renderer(Map const& m, T & output_iterator, attributes const& vars, double scale_factor, unsigned offset_x, unsigned offset_y) :
feature_style_processor<svg_renderer>(m, scale_factor),
output_iterator_(output_iterator),
generator_(output_iterator),
painted_(false),
common_(m, vars, offset_x, offset_y, m.width(), m.height(), scale_factor)
{}
template <typename T>
svg_renderer<T>::svg_renderer(Map const& m, T & output_iterator, double scale_factor, unsigned offset_x, unsigned offset_y) :
feature_style_processor<svg_renderer>(m, scale_factor),
output_iterator_(output_iterator),
generator_(output_iterator),
painted_(false),
common_(m, offset_x, offset_y, m.width(), m.height(), scale_factor)
common_(m, attributes(), offset_x, offset_y, m.width(), m.height(), scale_factor)
{}
template <typename T>
@ -51,7 +60,7 @@ svg_renderer<T>::svg_renderer(Map const& m, request const& req, T & output_itera
output_iterator_(output_iterator),
generator_(output_iterator),
painted_(false),
common_(req, offset_x, offset_y, req.width(), req.height(), scale_factor)
common_(req, attributes(), offset_x, offset_y, req.width(), req.height(), scale_factor)
{}
template <typename T>

21
tests/cpp_tests/svg_renderer_tests/path_element_test.cpp
View file

@ -44,7 +44,7 @@ void prepare_map(Map & m)
put(poly_sym, keys::fill, color(250, 190, 183));
r.append(std::move(poly_sym));
}
provpoly_style.add_rule(r);
provpoly_style.add_rule(std::move(r));
}
{
rule r;
@ -54,7 +54,7 @@ void prepare_map(Map & m)
put(poly_sym, keys::fill, color(217, 235, 203));
r.append(std::move(poly_sym));
}
provpoly_style.add_rule(r);
provpoly_style.add_rule(std::move(r));
}
m.insert_style("provinces",provpoly_style);
@ -73,7 +73,7 @@ void prepare_map(Map & m)
put(line_sym,keys::stroke_dasharray,dash);
r.append(std::move(line_sym));
}
provlines_style.add_rule(r);
provlines_style.add_rule(std::move(r));
}
m.insert_style("provlines",provlines_style);
@ -87,7 +87,7 @@ void prepare_map(Map & m)
put(poly_sym, keys::fill, color(153, 204, 255));
r.append(std::move(poly_sym));
}
qcdrain_style.add_rule(r);
qcdrain_style.add_rule(std::move(r));
}
m.insert_style("drainage",qcdrain_style);
@ -104,7 +104,7 @@ void prepare_map(Map & m)
put(line_sym,keys::stroke_linejoin,ROUND_JOIN);
r.append(std::move(line_sym));
}
roads34_style.add_rule(r);
roads34_style.add_rule(std::move(r));
}
m.insert_style("smallroads",roads34_style);
@ -121,7 +121,7 @@ void prepare_map(Map & m)
put(line_sym,keys::stroke_linejoin,ROUND_JOIN);
r.append(std::move(line_sym));
}
roads2_style_1.add_rule(r);
roads2_style_1.add_rule(std::move(r));
}
m.insert_style("road-border", roads2_style_1);
@ -137,7 +137,7 @@ void prepare_map(Map & m)
put(line_sym,keys::stroke_linejoin,ROUND_JOIN);
r.append(std::move(line_sym));
}
roads2_style_2.add_rule(r);
roads2_style_2.add_rule(std::move(r));
}
m.insert_style("road-fill", roads2_style_2);
@ -154,7 +154,7 @@ void prepare_map(Map & m)
put(line_sym,keys::stroke_linejoin,ROUND_JOIN);
r.append(std::move(line_sym));
}
roads1_style_1.add_rule(r);
roads1_style_1.add_rule(std::move(r));
}
m.insert_style("highway-border", roads1_style_1);
@ -170,7 +170,7 @@ void prepare_map(Map & m)
put(line_sym,keys::stroke_linejoin,ROUND_JOIN);
r.append(std::move(line_sym));
}
roads1_style_2.add_rule(r);
roads1_style_2.add_rule(std::move(r));
}
m.insert_style("highway-fill", roads1_style_2);
@ -190,7 +190,7 @@ void prepare_map(Map & m)
put<text_placements_ptr>(text_sym, keys::text_placements_, placement_finder);
r.append(std::move(text_sym));
}
popplaces_style.add_rule(r);
popplaces_style.add_rule(std::move(r));
}
m.insert_style("popplaces",popplaces_style );
@ -202,7 +202,6 @@ void prepare_map(Map & m)
p["type"]="shape";
p["file"]="demo/data/boundaries";
p["encoding"]="latin1";
layer lyr("Provinces");
lyr.set_datasource(datasource_cache::instance().create(p));
lyr.set_srs(srs_lcc);