+ parse 'orientation' parameter

This commit is contained in:
Artem Pavlenko 2010-05-27 10:20:10 +00:00
parent 2085b3bc08
commit cbf1356e4d

View File

@ -66,230 +66,230 @@ using boost::optional;
class map_parser : boost::noncopyable {
public:
map_parser( bool strict, std::string const& filename = "" ) :
strict_( strict ),
filename_( filename ),
relative_to_xml_(true),
font_manager_(font_engine_) {}
map_parser( bool strict, std::string const& filename = "" ) :
strict_( strict ),
filename_( filename ),
relative_to_xml_(true),
font_manager_(font_engine_) {}
void parse_map( Map & map, ptree const & sty);
private:
void parse_style( Map & map, ptree const & sty);
void parse_layer( Map & map, ptree const & lay);
void parse_style( Map & map, ptree const & sty);
void parse_layer( Map & map, ptree const & lay);
void parse_fontset(Map & map, ptree const & fset);
void parse_font(font_set & fset, ptree const & f);
void parse_fontset(Map & map, ptree const & fset);
void parse_font(font_set & fset, ptree const & f);
void parse_rule( feature_type_style & style, ptree const & r);
void parse_rule( feature_type_style & style, ptree const & r);
void parse_point_symbolizer( rule_type & rule, ptree const & sym);
void parse_line_pattern_symbolizer( rule_type & rule, ptree const & sym);
void parse_polygon_pattern_symbolizer( rule_type & rule, ptree const & sym);
void parse_text_symbolizer( rule_type & rule, ptree const & sym);
void parse_shield_symbolizer( rule_type & rule, ptree const & sym);
void parse_line_symbolizer( rule_type & rule, ptree const & sym);
void parse_polygon_symbolizer( rule_type & rule, ptree const & sym);
void parse_building_symbolizer( rule_type & rule, ptree const & sym );
void parse_raster_symbolizer( rule_type & rule, ptree const & sym );
void parse_markers_symbolizer( rule_type & rule, ptree const & sym );
void parse_glyph_symbolizer( rule_type & rule, ptree const & sym );
void parse_point_symbolizer( rule_type & rule, ptree const & sym);
void parse_line_pattern_symbolizer( rule_type & rule, ptree const & sym);
void parse_polygon_pattern_symbolizer( rule_type & rule, ptree const & sym);
void parse_text_symbolizer( rule_type & rule, ptree const & sym);
void parse_shield_symbolizer( rule_type & rule, ptree const & sym);
void parse_line_symbolizer( rule_type & rule, ptree const & sym);
void parse_polygon_symbolizer( rule_type & rule, ptree const & sym);
void parse_building_symbolizer( rule_type & rule, ptree const & sym );
void parse_raster_symbolizer( rule_type & rule, ptree const & sym );
void parse_markers_symbolizer( rule_type & rule, ptree const & sym );
void parse_glyph_symbolizer( rule_type & rule, ptree const & sym );
void parse_raster_colorizer(raster_colorizer_ptr const& rc, ptree const& node );
void parse_raster_colorizer(raster_colorizer_ptr const& rc, ptree const& node );
void ensure_font_face( const std::string & face_name );
void ensure_font_face( const std::string & face_name );
std::string ensure_relative_to_xml( boost::optional<std::string> opt_path );
std::string ensure_relative_to_xml( boost::optional<std::string> opt_path );
bool strict_;
std::string filename_;
bool relative_to_xml_;
std::map<std::string,parameters> datasource_templates_;
freetype_engine font_engine_;
face_manager<freetype_engine> font_manager_;
std::map<std::string,std::string> file_sources_;
std::map<std::string,font_set> fontsets_;
bool strict_;
std::string filename_;
bool relative_to_xml_;
std::map<std::string,parameters> datasource_templates_;
freetype_engine font_engine_;
face_manager<freetype_engine> font_manager_;
std::map<std::string,std::string> file_sources_;
std::map<std::string,font_set> fontsets_;
};
void load_map(Map & map, std::string const& filename, bool strict)
{
ptree pt;
ptree pt;
#ifdef HAVE_LIBXML2
read_xml2(filename, pt);
read_xml2(filename, pt);
#else
try
{
read_xml(filename, pt);
}
catch (const boost::property_tree::xml_parser_error & ex)
{
throw config_error( ex.what() );
}
try
{
read_xml(filename, pt);
}
catch (const boost::property_tree::xml_parser_error & ex)
{
throw config_error( ex.what() );
}
#endif
map_parser parser( strict, filename);
parser.parse_map(map, pt);
map_parser parser( strict, filename);
parser.parse_map(map, pt);
}
void load_map_string(Map & map, std::string const& str, bool strict, std::string const& base_url)
{
ptree pt;
ptree pt;
#ifdef HAVE_LIBXML2
read_xml2_string(str, pt, base_url);
read_xml2_string(str, pt, base_url);
#else
try
{
std::istringstream s(str);
read_xml(s,pt);
}
catch (const boost::property_tree::xml_parser_error & ex)
{
throw config_error( ex.what() ) ;
}
try
{
std::istringstream s(str);
read_xml(s,pt);
}
catch (const boost::property_tree::xml_parser_error & ex)
{
throw config_error( ex.what() ) ;
}
#endif
map_parser parser( strict, base_url);
parser.parse_map(map, pt);
map_parser parser( strict, base_url);
parser.parse_map(map, pt);
}
void map_parser::parse_map( Map & map, ptree const & pt )
{
try
{
ptree const & map_node = pt.get_child("Map");
try
{
ptree const & map_node = pt.get_child("Map");
try
{
optional<color> bgcolor = get_opt_attr<color>(map_node, "bgcolor");
if (bgcolor) {
map.set_background( * bgcolor );
}
try
{
optional<color> bgcolor = get_opt_attr<color>(map_node, "bgcolor");
if (bgcolor) {
map.set_background( * bgcolor );
}
map.set_srs( get_attr(map_node, "srs", map.srs() ));
map.set_srs( get_attr(map_node, "srs", map.srs() ));
optional<unsigned> buffer_size = get_opt_attr<unsigned>(map_node,"buffer_size");
if (buffer_size)
{
map.set_buffer_size(*buffer_size);
}
optional<unsigned> buffer_size = get_opt_attr<unsigned>(map_node,"buffer_size");
if (buffer_size)
{
map.set_buffer_size(*buffer_size);
}
// Check if relative paths should be interpreted as relative to/from XML location
// Default is true, and map_parser::ensure_relative_to_xml will be called to modify path
optional<boolean> paths_from_xml = get_opt_attr<boolean>(map_node, "paths_from_xml");
if (paths_from_xml)
{
relative_to_xml_ = *paths_from_xml;
}
optional<boolean> paths_from_xml = get_opt_attr<boolean>(map_node, "paths_from_xml");
if (paths_from_xml)
{
relative_to_xml_ = *paths_from_xml;
}
optional<std::string> min_version_string = get_opt_attr<std::string>(map_node, "minimum_version");
optional<std::string> min_version_string = get_opt_attr<std::string>(map_node, "minimum_version");
if (min_version_string)
{
boost::char_separator<char> sep(".");
boost::tokenizer<boost::char_separator<char> > tokens(*min_version_string,sep);
unsigned i = 0;
bool success = false;
int n[3];
for (boost::tokenizer<boost::char_separator<char> >::iterator beg=tokens.begin();
beg!=tokens.end();++beg)
{
try
{
n[i] = boost::lexical_cast<int>(boost::trim_copy(*beg));
}
catch (boost::bad_lexical_cast & ex)
{
std::clog << *beg << " : " << ex.what() << "\n";
break;
}
if (i==2)
{
success = true;
break;
}
++i;
}
if (success)
{
int min_version = (n[0] * 100000) + (n[1] * 100) + (n[2]);
if (min_version > MAPNIK_VERSION)
{
throw config_error(std::string("This map uses features only present in Mapnik version ") + *min_version_string + " and newer");
}
if (min_version_string)
{
boost::char_separator<char> sep(".");
boost::tokenizer<boost::char_separator<char> > tokens(*min_version_string,sep);
unsigned i = 0;
bool success = false;
int n[3];
for (boost::tokenizer<boost::char_separator<char> >::iterator beg=tokens.begin();
beg!=tokens.end();++beg)
{
try
{
n[i] = boost::lexical_cast<int>(boost::trim_copy(*beg));
}
catch (boost::bad_lexical_cast & ex)
{
std::clog << *beg << " : " << ex.what() << "\n";
break;
}
if (i==2)
{
success = true;
break;
}
++i;
}
if (success)
{
int min_version = (n[0] * 100000) + (n[1] * 100) + (n[2]);
if (min_version > MAPNIK_VERSION)
{
throw config_error(std::string("This map uses features only present in Mapnik version ") + *min_version_string + " and newer");
}
}
}
}
}
catch (const config_error & ex)
{
ex.append_context("(in node Map)");
throw;
}
ptree::const_iterator itr = map_node.begin();
ptree::const_iterator end = map_node.end();
for (; itr != end; ++itr)
{
ptree::value_type const& v = *itr;
if (v.first == "Style")
{
parse_style( map, v.second );
}
else if (v.first == "Layer")
{
parse_layer(map, v.second );
}
else if (v.first == "FontSet")
{
parse_fontset(map, v.second);
}
else if (v.first == "FileSource")
{
std::string name = get_attr<string>( v.second, "name");
std::string value = get_value<string>( v.second, "");
file_sources_[name] = value;
}
else if (v.first == "Datasource")
{
std::string name = get_attr(v.second, "name", string("Unnamed"));
parameters params;
ptree::const_iterator paramIter = v.second.begin();
ptree::const_iterator endParam = v.second.end();
for (; paramIter != endParam; ++paramIter)
{
ptree const& param = paramIter->second;
if (paramIter->first == "Parameter")
{
std::string name = get_attr<string>(param, "name");
std::string value = get_value<string>( param,
"datasource parameter");
params[name] = value;
}
else if( paramIter->first != "<xmlattr>" &&
paramIter->first != "<xmlcomment>" )
{
throw config_error(std::string("Unknown child node in ") +
"'Datasource'. Expected 'Parameter' but got '" +
paramIter->first + "'");
}
}
datasource_templates_[name] = params;
catch (const config_error & ex)
{
ex.append_context("(in node Map)");
throw;
}
ptree::const_iterator itr = map_node.begin();
ptree::const_iterator end = map_node.end();
for (; itr != end; ++itr)
{
ptree::value_type const& v = *itr;
if (v.first == "Style")
{
parse_style( map, v.second );
}
else if (v.first == "Layer")
{
parse_layer(map, v.second );
}
else if (v.first == "FontSet")
{
parse_fontset(map, v.second);
}
else if (v.first == "FileSource")
{
std::string name = get_attr<string>( v.second, "name");
std::string value = get_value<string>( v.second, "");
file_sources_[name] = value;
}
else if (v.first == "Datasource")
{
std::string name = get_attr(v.second, "name", string("Unnamed"));
parameters params;
ptree::const_iterator paramIter = v.second.begin();
ptree::const_iterator endParam = v.second.end();
for (; paramIter != endParam; ++paramIter)
{
ptree const& param = paramIter->second;
if (paramIter->first == "Parameter")
{
std::string name = get_attr<string>(param, "name");
std::string value = get_value<string>( param,
"datasource parameter");
params[name] = value;
}
else if( paramIter->first != "<xmlattr>" &&
paramIter->first != "<xmlcomment>" )
{
throw config_error(std::string("Unknown child node in ") +
"'Datasource'. Expected 'Parameter' but got '" +
paramIter->first + "'");
}
}
datasource_templates_[name] = params;
}
else if (v.first != "<xmlcomment>" &&
v.first != "<xmlattr>")
{
throw config_error(std::string("Unknown child node in 'Map'. ") +
"Expected 'Style' or 'Layer' but got '" + v.first + "'");
}
}
}
else if (v.first != "<xmlcomment>" &&
v.first != "<xmlattr>")
catch (const boost::property_tree::ptree_bad_path &)
{
throw config_error(std::string("Unknown child node in 'Map'. ") +
"Expected 'Style' or 'Layer' but got '" + v.first + "'");
throw config_error("Not a map file. Node 'Map' not found.");
}
}
}
catch (const boost::property_tree::ptree_bad_path &)
{
throw config_error("Not a map file. Node 'Map' not found.");
}
}
void map_parser::parse_style( Map & map, ptree const & sty )
{
@ -355,7 +355,7 @@ void map_parser::parse_fontset( Map & map, ptree const & fset )
}
map.insert_fontset(name, fontset);
// XXX Hack because map object isn't accessible by text_symbolizer
// when it's parsed
fontsets_.insert(pair<std::string, font_set>(name, fontset));
@ -725,11 +725,11 @@ void map_parser::parse_point_symbolizer( rule_type & rule, ptree const & sym )
if (allow_overlap)
{
symbol.set_allow_overlap( * allow_overlap );
symbol.set_allow_overlap( * allow_overlap );
}
if (opacity)
{
symbol.set_opacity( * opacity );
symbol.set_opacity( * opacity );
}
rule.append(symbol);
}
@ -850,7 +850,7 @@ void map_parser::parse_text_symbolizer( rule_type & rule, ptree const & sym )
try
{
std::string name = get_attr<string>(sym, "name");
optional<std::string> face_name =
get_opt_attr<std::string>(sym, "face_name");
@ -862,7 +862,13 @@ void map_parser::parse_text_symbolizer( rule_type & rule, ptree const & sym )
color c = get_attr(sym, "fill", color(0,0,0));
text_symbolizer text_symbol = text_symbolizer(parse_expression(name, "utf8"), size, c);
optional<std::string> orientation = get_opt_attr<std::string>(sym, "orientation");
if (orientation)
{
text_symbol.set_orientation(parse_expression(*orientation, "utf8"));
}
if (fontset_name && face_name)
{
throw config_error(std::string("Can't have both face_name and fontset_name"));