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

remove arrow/ellipse ad-hoc markers - see #1285

Browse source
This commit is contained in:
artemp 2012-07-04 14:50:11 +01:00
parent 6bc3f06afd
commit 9b14a7206a
9 changed files with 655 additions and 1009 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
bindings/python/mapnik_markers_symbolizer.cpp
View file

@ -96,11 +96,6 @@ void export_markers_symbolizer()
.value("LINE_PLACEMENT",mapnik::MARKER_LINE_PLACEMENT)
;
mapnik::enumeration_<mapnik::marker_type_e>("marker_type")
.value("ARROW",mapnik::MARKER_ARROW)
.value("ELLIPSE",mapnik::MARKER_ELLIPSE)
;
class_<markers_symbolizer>("MarkersSymbolizer",
init<>("Default Markers Symbolizer - blue arrow"))
.def (init<mapnik::path_expression_ptr>("<path expression ptr>"))
@ -145,10 +140,6 @@ void export_markers_symbolizer()
return_value_policy<copy_const_reference>()),
&markers_symbolizer::set_stroke,
"Set/get the marker stroke (outline)")
.add_property("marker_type",
&markers_symbolizer::get_marker_type,
&markers_symbolizer::set_marker_type,
"Set/get the marker-type")
.add_property("placement",
&markers_symbolizer::get_marker_placement,
&markers_symbolizer::set_marker_placement,

11
include/mapnik/markers_symbolizer.hpp
View file

@ -42,14 +42,6 @@ enum marker_placement_enum {
DEFINE_ENUM( marker_placement_e, marker_placement_enum );
enum marker_type_enum {
MARKER_ARROW,
MARKER_ELLIPSE,
marker_type_enum_MAX
};
DEFINE_ENUM( marker_type_e, marker_type_enum );
struct MAPNIK_DECL markers_symbolizer :
public symbolizer_with_image, public symbolizer_base
{
@ -75,8 +67,6 @@ public:
void set_stroke(stroke const& stroke);
void set_marker_placement(marker_placement_e marker_p);
marker_placement_e get_marker_placement() const;
void set_marker_type(marker_type_e marker_p);
marker_type_e get_marker_type() const;
private:
bool ignore_placement_;
@ -88,7 +78,6 @@ private:
expression_ptr height_;
stroke stroke_;
marker_placement_e marker_p_;
marker_type_e marker_type_;
};

2
src/agg/process_markers_symbolizer.cpp
View file

@ -78,7 +78,7 @@ void agg_renderer<T>::process(markers_symbolizer const& sym,
tr = agg::trans_affine_scaling(scale_factor_) * tr;
agg::trans_affine geom_tr;
evaluate_transform(geom_tr, feature, sym.get_transform());x
evaluate_transform(geom_tr, feature, sym.get_transform());
std::string filename = path_processor_type::evaluate(*sym.get_filename(), feature);
marker_placement_e placement_method = sym.get_marker_placement();

1459
src/cairo_renderer.cpp
View file

File diff suppressed because it is too large Load diff

138
src/grid/process_markers_symbolizer.cpp
View file

@ -74,7 +74,6 @@ void grid_renderer<T>::process(markers_symbolizer const& sym,
tr = agg::trans_affine_scaling(scale_factor_*(1.0/res)) * tr;
std::string filename = path_processor_type::evaluate(*sym.get_filename(), feature);
marker_placement_e placement_method = sym.get_marker_placement();
marker_type_e marker_type = sym.get_marker_type();
if (!filename.empty())
{
@ -149,143 +148,6 @@ void grid_renderer<T>::process(markers_symbolizer const& sym,
pixmap_.add_feature(feature);
}
}
else
{
double w = (boost::apply_visitor(evaluate<Feature,value_type>(feature), *(sym.get_width()))).to_double() * scale_factor_;
double h = (boost::apply_visitor(evaluate<Feature,value_type>(feature), *(sym.get_height()))).to_double() * scale_factor_;
// clamp to at least 4 px otherwise interactive pixels can be too small
if (res == 1) {
w = std::max(w,4.0);
h = std::max(h,4.0);
} else {
double min = static_cast<double>(4.0/res);
w = std::max(w/res,min);
h = std::max(h/res,min);
}
double rx = w/2.0;
double ry = h/2.0;
arrow arrow_;
box2d<double> extent;
stroke const& stroke_ = sym.get_stroke();
double strk_width = stroke_.get_width();
double dx = w + (2*strk_width);
double dy = h + (2*strk_width);
if (marker_type == MARKER_ARROW)
{
extent = arrow_.extent();
double x1 = extent.minx();
double y1 = extent.miny();
double x2 = extent.maxx();
double y2 = extent.maxy();
tr.transform(&x1,&y1);
tr.transform(&x2,&y2);
extent.init(x1,y1,x2,y2);
}
else
{
double x1 = -1 *(dx);
double y1 = -1 *(dy);
double x2 = dx;
double y2 = dy;
tr.transform(&x1,&y1);
tr.transform(&x2,&y2);
extent.init(x1,y1,x2,y2);
}
double x;
double y;
double z=0;
for (unsigned i=0; i<feature.num_geometries(); ++i)
{
geometry_type & geom = feature.get_geometry(i);
if (placement_method == MARKER_POINT_PLACEMENT || geom.num_points() <= 1)
{
geom.label_position(&x,&y);
prj_trans.backward(x,y,z);
t_.forward(&x,&y);
int px = int(floor(x - 0.5 * dx));
int py = int(floor(y - 0.5 * dy));
box2d<double> label_ext (px, py, px + dx +1, py + dy +1);
if (sym.get_allow_overlap() ||
detector_.has_placement(label_ext))
{
agg::ellipse c(x, y, rx, ry);
agg::path_storage marker;
marker.concat_path(c);
ras_ptr->add_path(marker);
// outline
if (strk_width)
{
agg::conv_stroke<agg::path_storage> outline(marker);
outline.generator().width(strk_width * scale_factor_);
ras_ptr->add_path(outline);
}
detector_.insert(label_ext);
}
}
else
{
agg::path_storage marker;
if (marker_type == MARKER_ARROW)
marker.concat_path(arrow_);
path_type path(t_,geom,prj_trans);
markers_placement<path_type, label_collision_detector4> placement(path, extent, agg::trans_affine() ,detector_,
sym.get_spacing() * scale_factor_,
sym.get_max_error(),
sym.get_allow_overlap());
double x_t, y_t, angle;
while (placement.get_point(x_t, y_t, angle))
{
agg::trans_affine matrix;
if (marker_type == MARKER_ELLIPSE)
{
// todo proper bbox - this is buggy
agg::ellipse c(x_t, y_t, rx, ry);
marker.concat_path(c);
agg::trans_affine matrix;
matrix *= agg::trans_affine_translation(-x_t,-y_t);
matrix *= agg::trans_affine_rotation(angle);
matrix *= agg::trans_affine_translation(x_t,y_t);
marker.transform(matrix);
}
else
{
matrix = tr * agg::trans_affine_rotation(angle) * agg::trans_affine_translation(x_t, y_t);
}
agg::conv_transform<agg::path_storage, agg::trans_affine> trans(marker, matrix);
// fill
ras_ptr->add_path(trans);
// outline
if (strk_width)
{
agg::conv_stroke<agg::conv_transform<agg::path_storage, agg::trans_affine> > outline(trans);
outline.generator().width(strk_width * scale_factor_);
ras_ptr->add_path(outline);
}
}
}
}
ren.color(mapnik::gray32(feature.id()));
agg::render_scanlines(*ras_ptr, sl, ren);
pixmap_.add_feature(feature);
}
}
template void grid_renderer<grid>::process(markers_symbolizer const&,

11
src/load_map.cpp
View file

@ -1057,17 +1057,6 @@ void map_parser::parse_markers_symbolizer(rule & rule, xml_node const& sym)
marker_placement_e placement = sym.get_attr<marker_placement_e>("placement", MARKER_LINE_PLACEMENT);
symbol.set_marker_placement(placement);
marker_type_e dfl_marker_type = MARKER_ARROW;
if (placement == MARKER_POINT_PLACEMENT)
{
dfl_marker_type = MARKER_ELLIPSE;
}
marker_type_e marker_type = sym.get_attr<marker_type_e>("marker-type", dfl_marker_type);
symbol.set_marker_type(marker_type);
parse_symbolizer_base(symbol, sym);
rule.append(symbol);
}

29
src/markers_symbolizer.cpp
View file

@ -36,15 +36,6 @@ static const char * marker_placement_strings[] = {
IMPLEMENT_ENUM( marker_placement_e, marker_placement_strings )
static const char * marker_type_strings[] = {
"arrow",
"ellipse",
""
};
IMPLEMENT_ENUM( marker_type_e, marker_type_strings )
markers_symbolizer::markers_symbolizer()
: symbolizer_with_image(path_expression_ptr(new path_expression)),
symbolizer_base(),
@ -56,8 +47,7 @@ markers_symbolizer::markers_symbolizer()
width_(boost::make_shared<expr_node>(10.0)),
height_(boost::make_shared<expr_node>(10.0)),
stroke_(),
marker_p_(MARKER_LINE_PLACEMENT),
marker_type_(MARKER_ARROW) {}
marker_p_(MARKER_LINE_PLACEMENT) {}
markers_symbolizer::markers_symbolizer(path_expression_ptr filename)
: symbolizer_with_image(filename),
@ -70,8 +60,7 @@ markers_symbolizer::markers_symbolizer(path_expression_ptr filename)
width_(boost::make_shared<expr_node>(10.0)),
height_(boost::make_shared<expr_node>(10.0)),
stroke_(),
marker_p_(MARKER_LINE_PLACEMENT),
marker_type_(MARKER_ARROW) {}
marker_p_(MARKER_LINE_PLACEMENT) {}
markers_symbolizer::markers_symbolizer(markers_symbolizer const& rhs)
: symbolizer_with_image(rhs),
@ -84,8 +73,7 @@ markers_symbolizer::markers_symbolizer(markers_symbolizer const& rhs)
width_(rhs.width_),
height_(rhs.height_),
stroke_(rhs.stroke_),
marker_p_(rhs.marker_p_),
marker_type_(rhs.marker_type_) {}
marker_p_(rhs.marker_p_) {}
void markers_symbolizer::set_ignore_placement(bool ignore_placement)
{
@ -177,15 +165,4 @@ marker_placement_e markers_symbolizer::get_marker_placement() const
return marker_p_;
}
void markers_symbolizer::set_marker_type(marker_type_e marker_type)
{
marker_type_ = marker_type;
}
marker_type_e markers_symbolizer::get_marker_type() const
{
return marker_type_;
}
}

4
src/save_map.cpp
View file

@ -294,10 +294,6 @@ public:
{
set_attr( sym_node, "height", to_expression_string(*sym.get_height()) );
}
if (sym.get_marker_type() != dfl.get_marker_type() || explicit_defaults_)
{
set_attr( sym_node, "marker-type", sym.get_marker_type() );
}
if (sym.get_marker_placement() != dfl.get_marker_placement() || explicit_defaults_)
{
set_attr( sym_node, "placement", sym.get_marker_placement() );

1
src/xml_tree.cpp
View file

@ -474,7 +474,6 @@ compile_get_attr(std::string);
compile_get_attr(filter_mode_e);
compile_get_attr(point_placement_e);
compile_get_attr(marker_placement_e);
compile_get_attr(marker_type_e);
compile_get_attr(pattern_alignment_e);
compile_get_attr(line_rasterizer_e);
compile_get_attr(colorizer_mode);