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

Complete XML changes in load_map.cpp

Browse source
This commit is contained in:
Hermann Kraus 2012-03-07 01:35:37 +01:00
parent 7a052f81f7
commit 7d3fd0755d
13 changed files with 186 additions and 374 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
include/mapnik/formatting/base.hpp
View file

@ -36,6 +36,7 @@ namespace mapnik {
typedef std::set<expression_ptr> expression_set;
class processed_text;
class xml_node;
struct char_properties;
namespace formatting {
@ -48,7 +49,7 @@ class node
public:
virtual ~node() {}
virtual void to_xml(boost::property_tree::ptree &xml) const;
static node_ptr from_xml(boost::property_tree::ptree const& xml);
static node_ptr from_xml(xml_node const& xml);
virtual void apply(char_properties const& p, Feature const& feature, processed_text &output) const = 0;
virtual void add_expressions(expression_set &output) const;
};

2
include/mapnik/formatting/expression.hpp
View file

@ -31,7 +31,7 @@ namespace formatting {
class expression_format: public node {
public:
void to_xml(boost::property_tree::ptree &xml) const;
static node_ptr from_xml(boost::property_tree::ptree const& xml);
static node_ptr from_xml(xml_node const& xml);
virtual void apply(char_properties const& p, Feature const& feature, processed_text &output) const;
virtual void add_expressions(expression_set &output) const;

2
include/mapnik/formatting/format.hpp
View file

@ -31,7 +31,7 @@ namespace formatting {
class format_node: public node {
public:
void to_xml(boost::property_tree::ptree &xml) const;
static node_ptr from_xml(boost::property_tree::ptree const& xml);
static node_ptr from_xml(xml_node const& xml);
virtual void apply(char_properties const& p, Feature const& feature, processed_text &output) const;
virtual void add_expressions(expression_set &output) const;

4
include/mapnik/formatting/registry.hpp
View file

@ -38,7 +38,7 @@ namespace mapnik
namespace formatting
{
typedef node_ptr (*from_xml_function_ptr)(boost::property_tree::ptree const& xml);
typedef node_ptr (*from_xml_function_ptr)(xml_node const& xml);
class registry : public singleton<registry, CreateStatic>,
private boost::noncopyable
@ -47,7 +47,7 @@ public:
registry();
~registry() {}
void register_name(std::string name, from_xml_function_ptr ptr, bool overwrite=false);
node_ptr from_xml(std::string name, boost::property_tree::ptree const& xml);
node_ptr from_xml(std::string name, xml_node const& xml);
private:
std::map<std::string, from_xml_function_ptr> map_;
};

2
include/mapnik/formatting/text.hpp
View file

@ -31,7 +31,7 @@ public:
text_node(expression_ptr text): node(), text_(text) {}
text_node(std::string text): node(), text_(parse_expression(text)) {}
void to_xml(boost::property_tree::ptree &xml) const;
static node_ptr from_xml(boost::property_tree::ptree const& xml);
static node_ptr from_xml(xml_node const& xml);
virtual void apply(char_properties const& p, Feature const& feature, processed_text &output) const;
virtual void add_expressions(expression_set &output) const;

2
include/mapnik/text_placements/list.hpp
View file

@ -38,7 +38,7 @@ public:
text_symbolizer_properties & add();
text_symbolizer_properties & get(unsigned i);
unsigned size() const;
static text_placements_ptr from_xml(boost::property_tree::ptree const &xml, fontset_map const & fontsets);
static text_placements_ptr from_xml(xml_node const &xml, fontset_map const & fontsets);
private:
std::vector<text_symbolizer_properties> list_;
friend class text_placement_info_list;

2
include/mapnik/text_placements/registry.hpp
View file

@ -49,7 +49,7 @@ public:
~registry() {}
void register_name(std::string name, from_xml_function_ptr ptr, bool overwrite=false);
text_placements_ptr from_xml(std::string name,
boost::property_tree::ptree const& xml,
xml_node const& xml,
fontset_map const & fontsets);
private:
std::map<std::string, from_xml_function_ptr> map_;

2
include/mapnik/text_placements/simple.hpp
View file

@ -52,7 +52,7 @@ public:
text_placement_info_ptr get_placement_info(double scale_factor) const;
void set_positions(std::string positions);
std::string get_positions();
static text_placements_ptr from_xml(boost::property_tree::ptree const &xml, fontset_map const & fontsets);
static text_placements_ptr from_xml(xml_node const &xml, fontset_map const & fontsets);
private:
std::string positions_;
std::vector<directions_t> direction_;

4
include/mapnik/text_properties.hpp
View file

@ -54,7 +54,7 @@ struct char_properties
{
char_properties();
/** Construct object from XML. */
void from_xml(boost::property_tree::ptree const &sym, fontset_map const & fontsets);
void from_xml(xml_node const &sym, fontset_map const & fontsets);
/** Write object to XML ptree. */
void to_xml(boost::property_tree::ptree &node, bool explicit_defaults, char_properties const &dfl=char_properties()) const;
std::string face_name;
@ -124,7 +124,7 @@ struct text_symbolizer_properties
{
text_symbolizer_properties();
/** Load all values from XML ptree. */
void from_xml(boost::property_tree::ptree const &sym, fontset_map const & fontsets);
void from_xml(xml_node const &sym, fontset_map const & fontsets);
/** Save all values to XML ptree (but does not create a new parent node!). */
void to_xml(boost::property_tree::ptree &node, bool explicit_defaults, text_symbolizer_properties const &dfl=text_symbolizer_properties()) const;

8
include/mapnik/xml_tree.hpp
View file

@ -75,8 +75,10 @@ public:
const_iterator begin() const;
const_iterator end() const;
xml_node & get_child(std::string name);
xml_node const& get_child(std::string name) const;
xml_node & get_child(std::string const& name);
xml_node const& get_child(std::string const& name) const;
xml_node *get_opt_child(std::string const& name) const;
bool has_child(std::string const& name) const;
template <typename T>
boost::optional<T> get_opt_attr(std::string const& name) const;
@ -89,7 +91,7 @@ public:
std::string get_text() const;
template <typename T>
T get_value(std::string const& name) const;
T get_value() const;
private:
xml_tree &tree_;
std::string name_;

525
src/load_map.cpp
View file

@ -73,7 +73,6 @@
using boost::lexical_cast;
using boost::bad_lexical_cast;
using boost::tokenizer;
using boost::property_tree::ptree;
using std::cerr;
using std::endl;
@ -101,32 +100,31 @@ private:
void parse_style(Map & map, xml_node const& sty);
void parse_layer(Map & map, xml_node const& lay);
void parse_metawriter(Map & map, xml_node const& lay);
void parse_metawriter_in_symbolizer(symbolizer_base &sym, ptree const &pt);
void parse_metawriter_in_symbolizer(symbolizer_base &sym, xml_node const& pt);
void parse_fontset(Map & map, xml_node const & fset);
void parse_font(font_set & fset, xml_node const& f);
void parse_rule(feature_type_style & style, ptree const & r);
void parse_rule(feature_type_style & style, xml_node const & r);
void parse_point_symbolizer(rule & rule, ptree const & sym);
void parse_line_pattern_symbolizer(rule & rule, ptree const & sym);
void parse_polygon_pattern_symbolizer(rule & rule, ptree const & sym);
void parse_text_symbolizer(rule & rule, ptree const & sym);
void parse_shield_symbolizer(rule & rule, ptree const & sym);
void parse_line_symbolizer(rule & rule, ptree const & sym);
void parse_polygon_symbolizer(rule & rule, ptree const & sym);
void parse_building_symbolizer(rule & rule, ptree const & sym );
void parse_raster_symbolizer(rule & rule, ptree const & sym );
void parse_markers_symbolizer(rule & rule, ptree const & sym );
void parse_point_symbolizer(rule & rule, xml_node const& sym);
void parse_line_pattern_symbolizer(rule & rule, xml_node const& sym);
void parse_polygon_pattern_symbolizer(rule & rule, xml_node const& sym);
void parse_text_symbolizer(rule & rule, xml_node const& sym);
void parse_shield_symbolizer(rule & rule, xml_node const& sym);
void parse_line_symbolizer(rule & rule, xml_node const& sym);
void parse_polygon_symbolizer(rule & rule, xml_node const& sym);
void parse_building_symbolizer(rule & rule, xml_node const& sym );
void parse_raster_symbolizer(rule & rule, xml_node const& sym );
void parse_markers_symbolizer(rule & rule, xml_node const& sym );
void parse_raster_colorizer(raster_colorizer_ptr const& rc, ptree const& node );
void parse_stroke(stroke & strk, ptree const & sym);
void parse_raster_colorizer(raster_colorizer_ptr const& rc, xml_node const& node );
void parse_stroke(stroke & strk, xml_node const & sym);
expression_ptr parse_expr(std::string const& expr);
void ensure_font_face( const std::string & face_name );
std::string ensure_relative_to_xml( boost::optional<std::string> opt_path );
void ensure_attrs( ptree const& sym, std::string name, std::string attrs);
boost::optional<color> get_opt_color_attr(boost::property_tree::ptree const& node,
std::string const& name);
@ -144,27 +142,7 @@ private:
};
void remove_empty_text_nodes(ptree &pt)
{
ptree::iterator itr = pt.begin();
ptree::iterator end = pt.end();
while (itr!=end)
{
if (itr->first == "<xmltext>") {
std::string trimmed = boost::algorithm::trim_copy(itr->second.data());
if (trimmed.empty()) {
itr = pt.erase(itr);
} else {
itr++;
}
} else {
remove_empty_text_nodes(itr->second);
itr++;
}
}
}
//#include <mapnik/internal/dump_xml.hpp>
void load_map(Map & map, std::string const& filename, bool strict)
{
xml_tree tree;
@ -183,7 +161,7 @@ void load_map(Map & map, std::string const& filename, bool strict)
}
#endif
map_parser parser(strict, filename);
// parser.parse_map(map, pt);
parser.parse_map(map, tree.root());
}
void load_map_string(Map & map, std::string const& str, bool strict, std::string const& base_path)
@ -209,7 +187,7 @@ void load_map_string(Map & map, std::string const& str, bool strict, std::string
#endif
map_parser parser(strict, base_path);
// parser.parse_map(map, tree.root(), base_path);
parser.parse_map(map, tree.root(), base_path);
}
expression_ptr map_parser::parse_expr(std::string const& str)
@ -408,15 +386,15 @@ void map_parser::parse_map_include(Map & map, xml_node const& include)
}
else if (itr->name() == "Layer")
{
// parse_layer(map, *itr);
parse_layer(map, *itr);
}
else if (itr->name() == "FontSet")
{
// parse_fontset(map, *itr);
parse_fontset(map, *itr);
}
else if (itr->name() == "MetaWriter")
{
// parse_metawriter(map, *itr);
parse_metawriter(map, *itr);
}
else if (itr->name() == "FileSource")
{
@ -459,13 +437,13 @@ void map_parser::parse_map_include(Map & map, xml_node const& include)
if (*type == "int")
{
is_string = false;
int value = paramIter->get_value<int>("parameter");
int value = paramIter->get_value<int>();
params[name] = value;
}
else if (*type == "float")
{
is_string = false;
double value = paramIter->get_value<double>("parameter");
double value = paramIter->get_value<double>();
params[name] = value;
}
}
@ -505,7 +483,7 @@ void map_parser::parse_style(Map & map, xml_node const& sty)
{
if (ruleIter->is("Rule"))
{
// parse_rule(style, rule_tag.second);
parse_rule(style, *ruleIter);
}
}
@ -523,7 +501,7 @@ void map_parser::parse_metawriter(Map & map, xml_node const& pt)
try
{
name = pt.get_attr<std::string>("name");
// writer = metawriter_create(pt);
//TODO: writer = metawriter_create(pt);
map.insert_metawriter(name, writer);
} catch (const config_error & ex) {
ex.append_context(std::string("in meta writer '") + name + "'");
@ -642,7 +620,7 @@ void map_parser::parse_layer(Map & map, xml_node const& lay)
if (child->is("StyleName"))
{
std::string style_name = child->get_value<std::string>("style name"); //TODO: get_text
std::string style_name = child->get_value<std::string>(); //TODO: get_text
if (style_name.empty())
{
std::ostringstream ss;
@ -722,149 +700,140 @@ void map_parser::parse_layer(Map & map, xml_node const& lay)
}
}
void map_parser::parse_rule( feature_type_style & style, ptree const & r )
void map_parser::parse_rule(feature_type_style & style, xml_node const& r)
{
ensure_attrs(r, "Rule", "name");
std::string name;
try
{
name = get_attr( r, "name", std::string());
name = r.get_attr("name", std::string());
rule rule(name);
optional<std::string> filter_expr =
get_opt_child<std::string>( r, "Filter");
if (filter_expr)
xml_node *child = r.get_opt_child("Filter");
if (child)
{
rule.set_filter(parse_expr(*filter_expr));
rule.set_filter(child->get_value<expression_ptr>());
}
if (has_child(r, "ElseFilter"))
if (r.has_child("ElseFilter"))
{
rule.set_else(true);
}
if (has_child(r, "AlsoFilter"))
if (r.has_child("AlsoFilter"))
{
rule.set_also(true);
}
optional<double> min_scale =
get_opt_child<double>(r, "MinScaleDenominator");
if (min_scale)
child = r.get_opt_child("MinScaleDenominator");
if (child)
{
rule.set_min_scale(*min_scale);
rule.set_min_scale(child->get_value<double>());
}
optional<double> max_scale =
get_opt_child<double>(r, "MaxScaleDenominator");
if (max_scale)
child = r.get_opt_child("MaxScaleDenominator");
if (child)
{
rule.set_max_scale(*max_scale);
rule.set_max_scale(child->get_value<double>());
}
ptree::const_iterator symIter = r.begin();
ptree::const_iterator endSym = r.end();
xml_node::const_iterator symIter = r.begin();
xml_node::const_iterator endSym = r.end();
for( ;symIter != endSym; ++symIter)
{
ptree::value_type const& sym = *symIter;
if ( sym.first == "PointSymbolizer")
if ( symIter->is("PointSymbolizer"))
{
parse_point_symbolizer( rule, sym.second );
parse_point_symbolizer(rule, *symIter);
}
else if ( sym.first == "LinePatternSymbolizer")
else if (symIter->is("LinePatternSymbolizer"))
{
parse_line_pattern_symbolizer( rule, sym.second );
parse_line_pattern_symbolizer(rule, *symIter);
}
else if ( sym.first == "PolygonPatternSymbolizer")
else if (symIter->is("PolygonPatternSymbolizer"))
{
parse_polygon_pattern_symbolizer( rule, sym.second );
parse_polygon_pattern_symbolizer(rule, *symIter);
}
else if ( sym.first == "TextSymbolizer")
else if (symIter->is("TextSymbolizer"))
{
parse_text_symbolizer( rule, sym.second );
parse_text_symbolizer(rule, *symIter);
}
else if ( sym.first == "ShieldSymbolizer")
else if (symIter->is("ShieldSymbolizer"))
{
parse_shield_symbolizer( rule, sym.second );
parse_shield_symbolizer(rule, *symIter);
}
else if ( sym.first == "LineSymbolizer")
else if (symIter->is("LineSymbolizer"))
{
parse_line_symbolizer( rule, sym.second );
parse_line_symbolizer(rule, *symIter);
}
else if ( sym.first == "PolygonSymbolizer")
else if (symIter->is("PolygonSymbolizer"))
{
parse_polygon_symbolizer( rule, sym.second );
parse_polygon_symbolizer(rule, *symIter);
}
else if ( sym.first == "BuildingSymbolizer")
else if (symIter->is("BuildingSymbolizer"))
{
parse_building_symbolizer( rule, sym.second );
parse_building_symbolizer(rule, *symIter);
}
else if ( sym.first == "RasterSymbolizer")
else if (symIter->is("RasterSymbolizer"))
{
parse_raster_symbolizer( rule, sym.second );
parse_raster_symbolizer( rule, *symIter);
}
else if ( sym.first == "MarkersSymbolizer")
else if (symIter->is("MarkersSymbolizer"))
{
parse_markers_symbolizer(rule, sym.second);
}
else if ( sym.first != "MinScaleDenominator" &&
sym.first != "MaxScaleDenominator" &&
sym.first != "Filter" &&
sym.first != "ElseFilter" &&
sym.first != "AlsoFilter" &&
sym.first != "<xmlcomment>" &&
sym.first != "<xmlattr>" )
{
throw config_error(std::string("Unknown symbolizer '") +
sym.first + "'");
parse_markers_symbolizer(rule, *symIter);
}
}
style.add_rule(rule);
}
catch (const config_error & ex)
{
if ( ! name.empty() )
if (!name.empty() )
{
ex.append_context(std::string("in rule '") + name + "' in map '" + filename_ + "')");
ex.append_context(std::string("in rule '") + name + "'");
}
throw;
}
}
void map_parser::parse_metawriter_in_symbolizer(symbolizer_base &sym, ptree const &pt)
void map_parser::parse_metawriter_in_symbolizer(symbolizer_base &sym, xml_node const &pt)
{
optional<std::string> writer = get_opt_attr<std::string>(pt, "meta-writer");
optional<std::string> writer = pt.get_opt_attr<std::string>("meta-writer");
if (!writer) return;
optional<std::string> output = get_opt_attr<std::string>(pt, "meta-output");
optional<std::string> output = pt.get_opt_attr<std::string>("meta-output");
sym.add_metawriter(*writer, output);
}
void map_parser::parse_point_symbolizer( rule & rule, ptree const & sym )
void map_parser::parse_point_symbolizer(rule & rule, xml_node const & sym)
{
try
{
std::stringstream s;
s << "file,base,allow-overlap,ignore-placement,opacity,placement,transform,meta-writer,meta-output";
optional<std::string> file = sym.get_opt_attr<std::string>("file");
optional<std::string> base = sym.get_opt_attr<std::string>("base");
optional<boolean> allow_overlap = sym.get_opt_attr<boolean>("allow-overlap");
optional<boolean> ignore_placement = sym.get_opt_attr<boolean>("ignore-placement");
optional<float> opacity = sym.get_opt_attr<float>("opacity");
optional<std::string> transform_wkt = sym.get_opt_attr<std::string>("transform");
optional<std::string> file = get_opt_attr<std::string>(sym, "file");
optional<std::string> base = get_opt_attr<std::string>(sym, "base");
optional<boolean> allow_overlap =
get_opt_attr<boolean>(sym, "allow-overlap");
optional<boolean> ignore_placement =
get_opt_attr<boolean>(sym, "ignore-placement");
optional<float> opacity =
get_opt_attr<float>(sym, "opacity");
optional<std::string> transform_wkt = get_opt_attr<std::string>(sym, "transform");
point_symbolizer symbol;
if (allow_overlap)
{
symbol.set_allow_overlap( * allow_overlap );
}
if (opacity)
{
symbol.set_opacity( * opacity );
}
if (ignore_placement)
{
symbol.set_ignore_placement( * ignore_placement );
}
point_placement_e placement =
sym.get_attr<point_placement_e>("placement", CENTROID_POINT_PLACEMENT);
symbol.set_point_placement( placement );
if (file)
{
ensure_attrs(sym, "PointSymbolizer", s.str());
try
{
if( base )
@ -878,23 +847,7 @@ void map_parser::parse_point_symbolizer( rule & rule, ptree const & sym )
*file = ensure_relative_to_xml(file);
point_symbolizer symbol(parse_path(*file));
if (allow_overlap)
{
symbol.set_allow_overlap( * allow_overlap );
}
if (opacity)
{
symbol.set_opacity( * opacity );
}
if (ignore_placement)
{
symbol.set_ignore_placement( * ignore_placement );
}
point_placement_e placement =
get_attr<point_placement_e>(sym, "placement", CENTROID_POINT_PLACEMENT);
symbol.set_point_placement( placement );
symbol.set_filename(parse_path(*file));
if (transform_wkt)
{
@ -930,32 +883,9 @@ void map_parser::parse_point_symbolizer( rule & rule, ptree const & sym )
std::clog << "### WARNING: " << msg << endl;
}
}
}
else
{
ensure_attrs(sym, "PointSymbolizer", s.str());
point_symbolizer symbol;
if (allow_overlap)
{
symbol.set_allow_overlap( * allow_overlap );
}
if (opacity)
{
symbol.set_opacity( * opacity );
}
if (ignore_placement)
{
symbol.set_ignore_placement( * ignore_placement );
}
point_placement_e placement =
get_attr<point_placement_e>(sym, "placement", CENTROID_POINT_PLACEMENT);
symbol.set_point_placement( placement );
parse_metawriter_in_symbolizer(symbol, sym);
rule.append(symbol);
}
parse_metawriter_in_symbolizer(symbol, sym);
rule.append(symbol);
}
catch (const config_error & ex)
{
@ -965,30 +895,17 @@ void map_parser::parse_point_symbolizer( rule & rule, ptree const & sym )
}
void map_parser::parse_markers_symbolizer( rule & rule, ptree const & sym )
void map_parser::parse_markers_symbolizer(rule & rule, xml_node const& sym)
{
try
{
std::string filename("");
optional<std::string> file = get_opt_attr<std::string>(sym, "file");
optional<std::string> base = get_opt_attr<std::string>(sym, "base");
optional<std::string> transform_wkt = get_opt_attr<std::string>(sym, "transform");
std::stringstream s;
//s << "file,opacity,spacing,max-error,allow-overlap,placement,";
s << "file,base,transform,fill,opacity,"
<< "spacing,max-error,allow-overlap,"
<< "width,height,placement,marker-type,"
<< "stroke,stroke-width,stroke-opacity,stroke-linejoin,"
<< "stroke-linecap,stroke-dashoffset,stroke-dasharray,"
// note: stroke-gamma intentionally left off here as markers do not support them
<< "meta-writer,meta-output";
ensure_attrs(sym, "MarkersSymbolizer", s.str());
optional<std::string> file = sym.get_opt_attr<std::string>("file");
optional<std::string> base = sym.get_opt_attr<std::string>("base");
optional<std::string> transform_wkt = sym.get_opt_attr<std::string>("transform");
if (file)
{
//s << "base,transform";
//ensure_attrs(sym, "MarkersSymbolizer", s.str());
try
{
if (base)
@ -1015,14 +932,9 @@ void map_parser::parse_markers_symbolizer( rule & rule, ptree const & sym )
}
}
}
/*else
{
//s << "fill,marker-type,width,height";
//ensure_attrs(sym, "MarkersSymbolizer", s.str());
}*/
markers_symbolizer symbol(parse_path(filename));
optional<float> opacity = get_opt_attr<float>(sym, "opacity");
optional<float> opacity = sym.get_opt_attr<float>("opacity");
if (opacity) symbol.set_opacity( *opacity );
if (transform_wkt)
@ -1043,17 +955,17 @@ void map_parser::parse_markers_symbolizer( rule & rule, ptree const & sym )
symbol.set_transform(matrix);
}
optional<color> c = get_opt_color_attr(sym, "fill");
optional<color> c = sym.get_opt_attr<color>("fill");
if (c) symbol.set_fill(*c);
optional<double> spacing = get_opt_attr<double>(sym, "spacing");
optional<double> spacing = sym.get_opt_attr<double>("spacing");
if (spacing) symbol.set_spacing(*spacing);
optional<double> max_error = get_opt_attr<double>(sym, "max-error");
optional<double> max_error = sym.get_opt_attr<double>("max-error");
if (max_error) symbol.set_max_error(*max_error);
optional<boolean> allow_overlap = get_opt_attr<boolean>(sym, "allow-overlap");
optional<boolean> allow_overlap = sym.get_opt_attr<boolean>("allow-overlap");
if (allow_overlap) symbol.set_allow_overlap(*allow_overlap);
optional<double> w = get_opt_attr<double>(sym, "width");
optional<double> h = get_opt_attr<double>(sym, "height");
optional<double> w = sym.get_opt_attr<double>("width");
optional<double> h = sym.get_opt_attr<double>("height");
if (w && h)
{
symbol.set_width(*w);
@ -1075,7 +987,7 @@ void map_parser::parse_markers_symbolizer( rule & rule, ptree const & sym )
parse_stroke(strk,sym);
symbol.set_stroke(strk);
marker_placement_e placement = get_attr<marker_placement_e>(sym, "placement", MARKER_LINE_PLACEMENT);
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 = ARROW;
@ -1083,7 +995,7 @@ void map_parser::parse_markers_symbolizer( rule & rule, ptree const & sym )
if (placement == MARKER_POINT_PLACEMENT)
dfl_marker_type = ELLIPSE;
marker_type_e marker_type = get_attr<marker_type_e>(sym, "marker-type", dfl_marker_type);
marker_type_e marker_type = sym.get_attr<marker_type_e>("marker-type", dfl_marker_type);
symbol.set_marker_type( marker_type );
parse_metawriter_in_symbolizer(symbol, sym);
@ -1096,13 +1008,12 @@ void map_parser::parse_markers_symbolizer( rule & rule, ptree const & sym )
}
}
void map_parser::parse_line_pattern_symbolizer( rule & rule, ptree const & sym )
void map_parser::parse_line_pattern_symbolizer( rule & rule, xml_node const & sym )
{
ensure_attrs(sym, "LinePatternSymbolizer", "file,base,meta-writer,meta-output");
try
{
std::string file = get_attr<std::string>(sym, "file");
optional<std::string> base = get_opt_attr<std::string>(sym, "base");
std::string file = sym.get_attr<std::string>("file");
optional<std::string> base = sym.get_opt_attr<std::string>("base");
try
{
@ -1144,13 +1055,12 @@ void map_parser::parse_line_pattern_symbolizer( rule & rule, ptree const & sym )
}
void map_parser::parse_polygon_pattern_symbolizer( rule & rule,
ptree const & sym )
xml_node const & sym )
{
ensure_attrs(sym, "PolygonPatternSymbolizer", "file,base,alignment,gamma,meta-writer,meta-output");
try
{
std::string file = get_attr<std::string>(sym, "file");
optional<std::string> base = get_opt_attr<std::string>(sym, "base");
std::string file = sym.get_attr<std::string>("file");
optional<std::string> base = sym.get_opt_attr<std::string>("base");
try
{
@ -1168,15 +1078,15 @@ void map_parser::parse_polygon_pattern_symbolizer( rule & rule,
polygon_pattern_symbolizer symbol(parse_path(file));
// pattern alignment
pattern_alignment_e p_alignment = get_attr<pattern_alignment_e>(sym, "alignment",LOCAL_ALIGNMENT);
pattern_alignment_e p_alignment = sym.get_attr<pattern_alignment_e>("alignment",LOCAL_ALIGNMENT);
symbol.set_alignment(p_alignment);
// gamma
optional<double> gamma = get_opt_attr<double>(sym, "gamma");
optional<double> gamma = sym.get_opt_attr<double>("gamma");
if (gamma) symbol.set_gamma(*gamma);
// gamma method
optional<gamma_method_e> gamma_method = get_opt_attr<gamma_method_e>(sym, "gamma-method");
optional<gamma_method_e> gamma_method = sym.get_opt_attr<gamma_method_e>("gamma-method");
if (gamma_method) symbol.set_gamma_method(*gamma_method);
parse_metawriter_in_symbolizer(symbol, sym);
@ -1203,27 +1113,12 @@ void map_parser::parse_polygon_pattern_symbolizer( rule & rule,
}
}
void map_parser::parse_text_symbolizer( rule & rule, ptree const & sym )
void map_parser::parse_text_symbolizer( rule & rule, xml_node const& sym )
{
std::stringstream s_common;
s_common << "name,face-name,fontset-name,size,fill,orientation,"
<< "dx,dy,placement,vertical-alignment,halo-fill,"
<< "halo-radius,text-ratio,wrap-width,wrap-before,"
<< "wrap-character,text-transform,line-spacing,"
<< "label-position-tolerance,character-spacing,"
<< "spacing,minimum-distance,minimum-padding,minimum-path-length,"
<< "avoid-edges,allow-overlap,opacity,max-char-angle-delta,"
<< "horizontal-alignment,justify-alignment";
std::stringstream s_symbolizer;
s_symbolizer << s_common.str() << ",placements,placement-type,"
<< "meta-writer,meta-output";
ensure_attrs(sym, "TextSymbolizer", s_symbolizer.str());
try
{
text_placements_ptr placement_finder;
optional<std::string> placement_type = get_opt_attr<std::string>(sym, "placement-type");
optional<std::string> placement_type = sym.get_opt_attr<std::string>("placement-type");
if (placement_type) {
placement_finder = placements::registry::instance()->from_xml(*placement_type, sym, fontsets_);
} else {
@ -1245,28 +1140,12 @@ void map_parser::parse_text_symbolizer( rule & rule, ptree const & sym )
}
}
void map_parser::parse_shield_symbolizer( rule & rule, ptree const & sym )
void map_parser::parse_shield_symbolizer(rule & rule, xml_node const& sym )
{
std::string s_common(
"name,face-name,fontset-name,size,fill,orientation,"
"dx,dy,placement,vertical-alignment,halo-fill,"
"halo-radius,text-ratio,wrap-width,wrap-before,"
"wrap-character,text-transform,line-spacing,"
"label-position-tolerance,character-spacing,"
"spacing,minimum-distance,minimum-padding,minimum-path-length,"
"avoid-edges,allow-overlap,opacity,max-char-angle-delta,"
"horizontal-alignment,justify-alignment");
std::string s_symbolizer(s_common + ",file,base,"
"transform,shield-dx,shield-dy,text-opacity,"
"unlock-image"
"placements,placement-type,meta-writer,meta-output");
ensure_attrs(sym, "ShieldSymbolizer", s_symbolizer);
try
{
text_placements_ptr placement_finder;
optional<std::string> placement_type = get_opt_attr<std::string>(sym, "placement-type");
optional<std::string> placement_type = sym.get_opt_attr<std::string>("placement-type");
if (placement_type) {
placement_finder = placements::registry::instance()->from_xml(*placement_type, sym, fontsets_);
} else {
@ -1279,7 +1158,7 @@ void map_parser::parse_shield_symbolizer( rule & rule, ptree const & sym )
shield_symbolizer shield_symbol = shield_symbolizer(placement_finder);
/* Symbolizer specific attributes. */
optional<std::string> transform_wkt = get_opt_attr<std::string>(sym, "transform");
optional<std::string> transform_wkt = sym.get_opt_attr<std::string>("transform");
if (transform_wkt)
{
agg::trans_affine tr;
@ -1297,12 +1176,12 @@ void map_parser::parse_shield_symbolizer( rule & rule, ptree const & sym )
shield_symbol.set_transform(matrix);
}
// shield displacement
double shield_dx = get_attr(sym, "shield-dx", 0.0);
double shield_dy = get_attr(sym, "shield-dy", 0.0);
double shield_dx = sym.get_attr("shield-dx", 0.0);
double shield_dy = sym.get_attr("shield-dy", 0.0);
shield_symbol.set_shield_displacement(shield_dx,shield_dy);
// opacity
optional<double> opacity = get_opt_attr<double>(sym, "opacity");
optional<double> opacity = sym.get_opt_attr<double>("opacity");
if (opacity)
{
shield_symbol.set_opacity(*opacity);
@ -1311,7 +1190,7 @@ void map_parser::parse_shield_symbolizer( rule & rule, ptree const & sym )
// text-opacity
// TODO: Could be problematic because it is named opacity in TextSymbolizer but opacity has a diffrent meaning here.
optional<double> text_opacity =
get_opt_attr<double>(sym, "text-opacity");
sym.get_opt_attr<double>("text-opacity");
if (text_opacity)
{
shield_symbol.set_text_opacity( * text_opacity );
@ -1319,7 +1198,7 @@ void map_parser::parse_shield_symbolizer( rule & rule, ptree const & sym )
// unlock_image
optional<boolean> unlock_image =
get_opt_attr<boolean>(sym, "unlock-image");
sym.get_opt_attr<boolean>("unlock-image");
if (unlock_image)
{
shield_symbol.set_unlock_image( * unlock_image );
@ -1327,8 +1206,8 @@ void map_parser::parse_shield_symbolizer( rule & rule, ptree const & sym )
parse_metawriter_in_symbolizer(shield_symbol, sym);
std::string image_file = get_attr<std::string>(sym, "file");
optional<std::string> base = get_opt_attr<std::string>(sym, "base");
std::string image_file = sym.get_attr<std::string>("file");
optional<std::string> base = sym.get_opt_attr<std::string>("base");
try
{
@ -1366,42 +1245,42 @@ void map_parser::parse_shield_symbolizer( rule & rule, ptree const & sym )
}
}
void map_parser::parse_stroke(stroke & strk, ptree const & sym)
void map_parser::parse_stroke(stroke & strk, xml_node const & sym)
{
// stroke color
optional<color> c = get_opt_color_attr(sym, "stroke");
optional<color> c = sym.get_opt_attr<color>("stroke");
if (c) strk.set_color(*c);
// stroke-width
optional<double> width = get_opt_attr<double>(sym, "stroke-width");
optional<double> width = sym.get_opt_attr<double>("stroke-width");
if (width) strk.set_width(*width);
// stroke-opacity
optional<double> opacity = get_opt_attr<double>(sym, "stroke-opacity");
optional<double> opacity = sym.get_opt_attr<double>("stroke-opacity");
if (opacity) strk.set_opacity(*opacity);
// stroke-linejoin
optional<line_join_e> line_join = get_opt_attr<line_join_e>(sym, "stroke-linejoin");
optional<line_join_e> line_join = sym.get_opt_attr<line_join_e>("stroke-linejoin");
if (line_join) strk.set_line_join(*line_join);
// stroke-linecap
optional<line_cap_e> line_cap = get_opt_attr<line_cap_e>(sym, "stroke-linecap");
optional<line_cap_e> line_cap = sym.get_opt_attr<line_cap_e>("stroke-linecap");
if (line_cap) strk.set_line_cap(*line_cap);
// stroke-gamma
optional<double> gamma = get_opt_attr<double>(sym, "stroke-gamma");
optional<double> gamma = sym.get_opt_attr<double>("stroke-gamma");
if (gamma) strk.set_gamma(*gamma);
// stroke-gamma-method
optional<gamma_method_e> gamma_method = get_opt_attr<gamma_method_e>(sym, "stroke-gamma-method");
optional<gamma_method_e> gamma_method = sym.get_opt_attr<gamma_method_e>("stroke-gamma-method");
if (gamma_method) strk.set_gamma_method(*gamma_method);
// stroke-dashoffset
optional<double> dash_offset = get_opt_attr<double>(sym, "stroke-dashoffset");
optional<double> dash_offset = sym.get_opt_attr<double>("stroke-dashoffset");
if (dash_offset) strk.set_dash_offset(*dash_offset);
// stroke-dasharray
optional<std::string> str = get_opt_attr<std::string>(sym,"stroke-dasharray");
optional<std::string> str = sym.get_opt_attr<std::string>("stroke-dasharray");
if (str)
{
tokenizer<> tok (*str);
@ -1441,15 +1320,8 @@ void map_parser::parse_stroke(stroke & strk, ptree const & sym)
}
}
void map_parser::parse_line_symbolizer( rule & rule, ptree const & sym )
void map_parser::parse_line_symbolizer( rule & rule, xml_node const & sym )
{
std::stringstream s;
s << "stroke,stroke-width,stroke-opacity,stroke-linejoin,"
<< "stroke-linecap,stroke-gamma,stroke-dash-offset,stroke-dasharray,"
<< "rasterizer,"
<< "meta-writer,meta-output";
ensure_attrs(sym, "LineSymbolizer", s.str());
try
{
stroke strk;
@ -1457,8 +1329,8 @@ void map_parser::parse_line_symbolizer( rule & rule, ptree const & sym )
line_symbolizer symbol = line_symbolizer(strk);
// rasterizer method
line_rasterizer_e rasterizer = get_attr<line_rasterizer_e>(sym, "rasterizer", RASTERIZER_FULL);
//optional<line_rasterizer_e> rasterizer_method = get_opt_attr<line_rasterizer_e>(sym, "full");
line_rasterizer_e rasterizer = sym.get_attr<line_rasterizer_e>("rasterizer", RASTERIZER_FULL);
//optional<line_rasterizer_e> rasterizer_method = sym.get_opt_attr<line_rasterizer_e>("full");
symbol.set_rasterizer(rasterizer);
parse_metawriter_in_symbolizer(symbol, sym);
@ -1472,23 +1344,22 @@ void map_parser::parse_line_symbolizer( rule & rule, ptree const & sym )
}
void map_parser::parse_polygon_symbolizer( rule & rule, ptree const & sym )
void map_parser::parse_polygon_symbolizer( rule & rule, xml_node const & sym )
{
ensure_attrs(sym, "PolygonSymbolizer", "fill,fill-opacity,gamma,gamma-method,meta-writer,meta-output");
try
{
polygon_symbolizer poly_sym;
// fill
optional<color> fill = get_opt_color_attr(sym, "fill");
optional<color> fill = sym.get_opt_attr<color>("fill");
if (fill) poly_sym.set_fill(*fill);
// fill-opacity
optional<double> opacity = get_opt_attr<double>(sym, "fill-opacity");
optional<double> opacity = sym.get_opt_attr<double>("fill-opacity");
if (opacity) poly_sym.set_opacity(*opacity);
// gamma
optional<double> gamma = get_opt_attr<double>(sym, "gamma");
optional<double> gamma = sym.get_opt_attr<double>("gamma");
if (gamma) poly_sym.set_gamma(*gamma);
// gamma method
optional<gamma_method_e> gamma_method = get_opt_attr<gamma_method_e>(sym, "gamma-method");
optional<gamma_method_e> gamma_method = sym.get_opt_attr<gamma_method_e>("gamma-method");
if (gamma_method) poly_sym.set_gamma_method(*gamma_method);
parse_metawriter_in_symbolizer(poly_sym, sym);
@ -1502,21 +1373,20 @@ void map_parser::parse_polygon_symbolizer( rule & rule, ptree const & sym )
}
void map_parser::parse_building_symbolizer( rule & rule, ptree const & sym )
void map_parser::parse_building_symbolizer( rule & rule, xml_node const & sym )
{
ensure_attrs(sym, "PolygonSymbolizer", "fill,fill-opacity,height,meta-writer,meta-output");
try
{
building_symbolizer building_sym;
// fill
optional<color> fill = get_opt_color_attr(sym, "fill");
optional<color> fill = sym.get_opt_attr<color>("fill");
if (fill) building_sym.set_fill(*fill);
// fill-opacity
optional<double> opacity = get_opt_attr<double>(sym, "fill-opacity");
optional<double> opacity = sym.get_opt_attr<double>("fill-opacity");
if (opacity) building_sym.set_opacity(*opacity);
// height
optional<std::string> height = get_opt_attr<std::string>(sym, "height");
optional<std::string> height = sym.get_opt_attr<std::string>("height");
if (height) building_sym.set_height(parse_expr(*height));
parse_metawriter_in_symbolizer(building_sym, sym);
@ -1529,53 +1399,43 @@ void map_parser::parse_building_symbolizer( rule & rule, ptree const & sym )
}
}
void map_parser::parse_raster_symbolizer( rule & rule, ptree const & sym )
void map_parser::parse_raster_symbolizer( rule & rule, xml_node const & sym )
{
// no support for meta-writer,meta-output
ensure_attrs(sym, "RasterSymbolizer", "mode,scaling,opacity,filter-factor,mesh-size");
try
{
raster_symbolizer raster_sym;
// mode
optional<std::string> mode = get_opt_attr<std::string>(sym, "mode");
optional<std::string> mode = sym.get_opt_attr<std::string>("mode");
if (mode) raster_sym.set_mode(*mode);
// scaling
optional<std::string> scaling = get_opt_attr<std::string>(sym, "scaling");
optional<std::string> scaling = sym.get_opt_attr<std::string>("scaling");
if (scaling) raster_sym.set_scaling(*scaling);
// opacity
optional<double> opacity = get_opt_attr<double>(sym, "opacity");
optional<double> opacity = sym.get_opt_attr<double>("opacity");
if (opacity) raster_sym.set_opacity(*opacity);
// filter factor
optional<double> filter_factor = get_opt_attr<double>(sym, "filter-factor");
optional<double> filter_factor = sym.get_opt_attr<double>("filter-factor");
if (filter_factor) raster_sym.set_filter_factor(*filter_factor);
// mesh-size
optional<unsigned> mesh_size = get_opt_attr<unsigned>(sym, "mesh-size");
optional<unsigned> mesh_size = sym.get_opt_attr<unsigned>("mesh-size");
if (mesh_size) raster_sym.set_mesh_size(*mesh_size);
ptree::const_iterator cssIter = sym.begin();
ptree::const_iterator endCss = sym.end();
xml_node::const_iterator cssIter = sym.begin();
xml_node::const_iterator endCss = sym.end();
for(; cssIter != endCss; ++cssIter)
{
ptree::value_type const& css_tag = *cssIter;
if (css_tag.first == "RasterColorizer")
if (cssIter->is("RasterColorizer"))
{
raster_colorizer_ptr colorizer(new raster_colorizer());
raster_sym.set_colorizer(colorizer);
parse_raster_colorizer(colorizer, css_tag.second);
}
else if (css_tag.first != "<xmlcomment>" &&
css_tag.first != "<xmlattr>" )
{
throw config_error(std::string("Unknown child node. ") +
"Expected 'RasterColorizer' but got '" + css_tag.first + "'");
parse_raster_colorizer(colorizer, *cssIter);
}
}
//Note: raster_symbolizer doesn't support metawriters
@ -1589,14 +1449,13 @@ void map_parser::parse_raster_symbolizer( rule & rule, ptree const & sym )
}
void map_parser::parse_raster_colorizer(raster_colorizer_ptr const& rc,
ptree const& node )
xml_node const& node )
{
try
{
ensure_attrs(node, "RasterColorizer", "default-mode,default-color,epsilon");
// mode
colorizer_mode default_mode =
get_attr<colorizer_mode>(node, "default-mode", COLORIZER_LINEAR);
node.get_attr<colorizer_mode>("default-mode", COLORIZER_LINEAR);
if(default_mode == COLORIZER_INHERIT) {
throw config_error("RasterColorizer mode must not be INHERIT. ");
@ -1604,7 +1463,7 @@ void map_parser::parse_raster_colorizer(raster_colorizer_ptr const& rc,
rc->set_default_mode( default_mode );
// default colour
optional<color> default_color = get_opt_color_attr(node, "default-color");
optional<color> default_color = node.get_opt_attr<color>("default-color");
if (default_color)
{
rc->set_default_color( *default_color );
@ -1612,7 +1471,7 @@ void map_parser::parse_raster_colorizer(raster_colorizer_ptr const& rc,
// epsilon
optional<float> eps = get_opt_attr<float>(node, "epsilon");
optional<float> eps = node.get_opt_attr<float>("epsilon");
if (eps)
{
if(*eps < 0) {
@ -1622,31 +1481,27 @@ void map_parser::parse_raster_colorizer(raster_colorizer_ptr const& rc,
}
ptree::const_iterator stopIter = node.begin();
ptree::const_iterator endStop = node.end();
xml_node::const_iterator stopIter = node.begin();
xml_node::const_iterator endStop = node.end();
float maximumValue = -std::numeric_limits<float>::max();
for(; stopIter != endStop; ++stopIter)
{
ptree::value_type const& stop_tag = *stopIter;
ptree const & stop = stopIter->second;
if (stop_tag.first == "stop")
if (stopIter->is("stop"))
{
ensure_attrs(stop_tag.second, "stop", "color,mode,value,label");
// colour is optional.
optional<color> stopcolor = get_opt_color_attr(stop, "color");
optional<color> stopcolor = stopIter->get_opt_attr<color>("color");
if (!stopcolor) {
*stopcolor = *default_color;
}
// mode default to INHERIT
colorizer_mode mode =
get_attr<colorizer_mode>(stop, "mode", COLORIZER_INHERIT);
stopIter->get_attr<colorizer_mode>("mode", COLORIZER_INHERIT);
// value is required, and it must be bigger than the previous
optional<float> value =
get_opt_attr<float>(stop, "value");
stopIter->get_opt_attr<float>("value");
if(!value) {
throw config_error("stop tag missing value");
@ -1658,7 +1513,7 @@ void map_parser::parse_raster_colorizer(raster_colorizer_ptr const& rc,
maximumValue = *value;
optional<std::string> label =
get_opt_attr<std::string>(stop, "label");
stopIter->get_opt_attr<std::string>("label");
//append the stop
colorizer_stop tmpStop;
@ -1670,12 +1525,6 @@ void map_parser::parse_raster_colorizer(raster_colorizer_ptr const& rc,
rc->add_stop(tmpStop);
}
else if (stop_tag.first != "<xmlcomment>" &&
stop_tag.first != "<xmlattr>" )
{
throw config_error(std::string("Unknown child node. ") +
"Expected 'stop' but got '" + stop_tag.first + "'");
}
}
}
catch (const config_error & ex)
@ -1720,44 +1569,4 @@ std::string map_parser::ensure_relative_to_xml( boost::optional<std::string> opt
return *opt_path;
}
void map_parser::ensure_attrs(ptree const& sym, std::string name, std::string attrs)
{
typedef ptree::key_type::value_type Ch;
optional<const ptree &> attribs = sym.get_child_optional( boost::property_tree::xml_parser::xmlattr<Ch>() );
if (attribs)
{
std::set<std::string> attr_set;
boost::split(attr_set, attrs, boost::is_any_of(","));
std::ostringstream s("");
s << "### " << name << " properties warning: ";
int missing = 0;
for (ptree::const_iterator it = attribs.get().begin(); it != attribs.get().end(); ++it)
{
std::string name = it->first;
bool found = (attr_set.find(name) != attr_set.end());
if (!found)
{
if (missing)
{
s << ",";
}
s << "'" << name << "'";
++missing;
}
}
if (missing) {
if (missing > 1)
{
s << " are";
}
else
{
s << " is";
}
s << " invalid, acceptable values are:\n'" << attrs << "'\n";
std::clog << s.str();
}
}
}
} // end of namespace mapnik

2
src/xml_tree.cpp
View file

@ -185,7 +185,7 @@ void xml_node::set_processed(bool processed)
processed_ = processed;
}
xml_node &xml_node::add_child(std::string name, unsigned line, bool text_node)
xml_node &xml_node::add_child(std::string const& name, unsigned line, bool text_node)
{
children_.push_back(xml_node(tree_, name, line, text_node));
return children_.back();

2
tests/visual_tests/test.py
View file

@ -51,7 +51,7 @@ def render(filename, width, height=100):
return m
if len(sys.argv) == 2:
files = [(sys.argv[1], 500)]
files = [(sys.argv[1], (500, 500))]
elif len(sys.argv) > 2:
files = [sys.argv[1:]]