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

1.added default ctor in polygon_symbolizer (grey fill - RGB (128,128,128)

Browse source 
2.replaced tabs
This commit is contained in:
Artem Pavlenko 2006-05-19 16:11:59 +00:00
parent f59a949464
commit 453b714580
5 changed files with 238 additions and 236 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
include/fill.hpp
View file

@ -20,7 +20,6 @@
*
*****************************************************************************/
//$Id$
#ifndef FILL_HPP
@ -30,7 +29,7 @@ namespace mapnik
{
class fill
{
};
}

96
include/map.hpp
View file

@ -34,57 +34,57 @@ namespace mapnik
class MAPNIK_DECL Map
{
friend class boost::serialization::access;
template <typename Archive>
void serialize(Archive & ar, const unsigned int /*version*/)
{
ar & boost::serialization::make_nvp("width",width_)
& boost::serialization::make_nvp("height",height_)
& boost::serialization::make_nvp("srid",srid_)
& boost::serialization::make_nvp("layers",layers_);
}
friend class boost::serialization::access;
template <typename Archive>
void serialize(Archive & ar, const unsigned int /*version*/)
{
ar & boost::serialization::make_nvp("width",width_)
& boost::serialization::make_nvp("height",height_)
& boost::serialization::make_nvp("srid",srid_)
& boost::serialization::make_nvp("layers",layers_);
}
static const unsigned MIN_MAPSIZE=16;
static const unsigned MAX_MAPSIZE=1024;
unsigned width_;
unsigned height_;
int srid_;
Color background_;
std::map<std::string,feature_type_style> styles_;
std::vector<Layer> layers_;
Envelope<double> currentExtent_;
static const unsigned MIN_MAPSIZE=16;
static const unsigned MAX_MAPSIZE=2048;
unsigned width_;
unsigned height_;
int srid_;
Color background_;
std::map<std::string,feature_type_style> styles_;
std::vector<Layer> layers_;
Envelope<double> currentExtent_;
public:
Map();
Map(int width,int height,int srid=-1);
Map(const Map& rhs);
Map& operator=(const Map& rhs);
bool insert_style(std::string const& name,feature_type_style const& style);
void remove_style(const std::string& name);
feature_type_style const& find_style(std::string const& name) const;
size_t layerCount() const;
void addLayer(const Layer& l);
const Layer& getLayer(size_t index) const;
Layer& getLayer(size_t index);
void removeLayer(size_t index);
std::vector<Layer> const& layers() const;
unsigned getWidth() const;
unsigned getHeight() const;
void setWidth(unsigned width);
void setHeight(unsigned height);
void resize(unsigned width,unsigned height);
int srid() const;
void setBackground(const Color& c);
const Color& getBackground() const;
void zoom(double zoom);
void zoomToBox(const Envelope<double>& box);
void pan(int x,int y);
void pan_and_zoom(int x,int y,double zoom);
const Envelope<double>& getCurrentExtent() const;
double scale() const;
virtual ~Map();
Map();
Map(int width,int height,int srid=-1);
Map(const Map& rhs);
Map& operator=(const Map& rhs);
bool insert_style(std::string const& name,feature_type_style const& style);
void remove_style(const std::string& name);
feature_type_style const& find_style(std::string const& name) const;
size_t layerCount() const;
void addLayer(const Layer& l);
const Layer& getLayer(size_t index) const;
Layer& getLayer(size_t index);
void removeLayer(size_t index);
std::vector<Layer> const& layers() const;
unsigned getWidth() const;
unsigned getHeight() const;
void setWidth(unsigned width);
void setHeight(unsigned height);
void resize(unsigned width,unsigned height);
int srid() const;
void setBackground(const Color& c);
const Color& getBackground() const;
void zoom(double zoom);
void zoomToBox(const Envelope<double>& box);
void pan(int x,int y);
void pan_and_zoom(int x,int y,double zoom);
const Envelope<double>& getCurrentExtent() const;
double scale() const;
virtual ~Map();
private:
void fixAspectRatio();
void fixAspectRatio();
};
}

25
include/polygon_symbolizer.hpp
View file

@ -31,18 +31,21 @@ namespace mapnik
{
struct MAPNIK_DECL polygon_symbolizer
{
polygon_symbolizer(Color const& fill)
: fill_(fill) {}
Color const& get_fill() const
{
return fill_;
}
void set_fill(Color const& fill)
{
fill_ = fill;
}
explicit polygon_symbolizer()
: fill_(Color(128,128,128) {}
polygon_symbolizer(Color const& fill)
: fill_(fill) {}
Color const& get_fill() const
{
return fill_;
}
void set_fill(Color const& fill)
{
fill_ = fill;
}
private:
Color fill_;
Color fill_;
};
}

330
include/rule.hpp
View file

@ -40,52 +40,52 @@
namespace mapnik
{
inline bool operator==(point_symbolizer const& lhs,
point_symbolizer const& rhs)
point_symbolizer const& rhs)
{
return (&lhs == &rhs);
return (&lhs == &rhs);
}
inline bool operator==(line_symbolizer const& lhs,
line_symbolizer const& rhs)
line_symbolizer const& rhs)
{
return (&lhs == &rhs);
return (&lhs == &rhs);
}
inline bool operator==(line_pattern_symbolizer const& lhs,
line_pattern_symbolizer const& rhs)
line_pattern_symbolizer const& rhs)
{
return (&lhs == &rhs);
return (&lhs == &rhs);
}
inline bool operator==(polygon_symbolizer const& lhs,
polygon_symbolizer const& rhs)
polygon_symbolizer const& rhs)
{
return (&lhs == &rhs);
return (&lhs == &rhs);
}
inline bool operator==(polygon_pattern_symbolizer const& lhs,
polygon_pattern_symbolizer const& rhs)
polygon_pattern_symbolizer const& rhs)
{
return (&lhs == &rhs);
return (&lhs == &rhs);
}
inline bool operator==(raster_symbolizer const& lhs,
raster_symbolizer const& rhs)
raster_symbolizer const& rhs)
{
return (&lhs == &rhs);
return (&lhs == &rhs);
}
inline bool operator==(text_symbolizer const& lhs,
text_symbolizer const& rhs)
text_symbolizer const& rhs)
{
return (&lhs == &rhs);
return (&lhs == &rhs);
}
typedef boost::variant<point_symbolizer,
line_symbolizer,
line_pattern_symbolizer,
polygon_symbolizer,
polygon_pattern_symbolizer,
raster_symbolizer,
text_symbolizer> symbolizer;
line_symbolizer,
line_pattern_symbolizer,
polygon_symbolizer,
polygon_pattern_symbolizer,
raster_symbolizer,
text_symbolizer> symbolizer;
typedef std::vector<symbolizer> symbolizers;
@ -94,183 +94,183 @@ namespace mapnik
template <typename FeatureT,template <typename> class Filter>
class rule
{
typedef Filter<FeatureT> filter_type;
typedef boost::shared_ptr<filter_type> filter_ptr;
typedef Filter<FeatureT> filter_type;
typedef boost::shared_ptr<filter_type> filter_ptr;
private:
std::string name_;
std::string title_;
std::string abstract_;
double min_scale_;
double max_scale_;
std::string name_;
std::string title_;
std::string abstract_;
double min_scale_;
double max_scale_;
symbolizers syms_;
filter_ptr filter_;
bool else_filter_;
filter_ptr filter_;
bool else_filter_;
public:
rule()
: name_(),
title_(),
abstract_(),
min_scale_(0),
max_scale_(std::numeric_limits<double>::infinity()),
syms_(),
filter_(new all_filter<FeatureT>),
else_filter_(false) {}
rule()
: name_(),
title_(),
abstract_(),
min_scale_(0),
max_scale_(std::numeric_limits<double>::infinity()),
syms_(),
filter_(new all_filter<FeatureT>),
else_filter_(false) {}
rule(const std::string& name,
const std::string& title="",
double min_scale_denominator=0,
double max_scale_denominator=std::numeric_limits<double>::infinity())
: name_(name),
title_(title),
min_scale_(min_scale_denominator),
max_scale_(max_scale_denominator),
syms_(),
filter_(new all_filter<FeatureT>),
else_filter_(false) {}
rule(const std::string& name,
const std::string& title="",
double min_scale_denominator=0,
double max_scale_denominator=std::numeric_limits<double>::infinity())
: name_(name),
title_(title),
min_scale_(min_scale_denominator),
max_scale_(max_scale_denominator),
syms_(),
filter_(new all_filter<FeatureT>),
else_filter_(false) {}
rule(const rule& rhs)
: name_(rhs.name_),
title_(rhs.title_),
abstract_(rhs.abstract_),
min_scale_(rhs.min_scale_),
max_scale_(rhs.max_scale_),
syms_(rhs.syms_),
filter_(rhs.filter_),
else_filter_(rhs.else_filter_) {}
rule(const rule& rhs)
: name_(rhs.name_),
title_(rhs.title_),
abstract_(rhs.abstract_),
min_scale_(rhs.min_scale_),
max_scale_(rhs.max_scale_),
syms_(rhs.syms_),
filter_(rhs.filter_),
else_filter_(rhs.else_filter_) {}
rule& operator=(rule const& rhs)
{
rule tmp(rhs);
swap(tmp);
return *this;
}
bool operator==(rule const& other)
{
return (this == &other);
}
{
rule tmp(rhs);
swap(tmp);
return *this;
}
bool operator==(rule const& other)
{
return (this == &other);
}
void set_max_scale(double scale)
{
max_scale_=scale;
}
void set_max_scale(double scale)
{
max_scale_=scale;
}
double get_min_scale() const
{
return min_scale_;
}
double get_min_scale() const
{
return min_scale_;
}
double get_max_scale() const
{
return max_scale_;
}
double get_max_scale() const
{
return max_scale_;
}
void set_min_scale(double scale)
{
min_scale_=scale;
}
void set_min_scale(double scale)
{
min_scale_=scale;
}
void set_name(std::string const& name)
{
name_=name;
}
void set_name(std::string const& name)
{
name_=name;
}
std::string const& get_name() const
{
return name_;
}
std::string const& get_name() const
{
return name_;
}
std::string const& get_title() const
{
return title_;
}
std::string const& get_title() const
{
return title_;
}
void set_title(std::string const& title)
{
title_=title;
}
void set_title(std::string const& title)
{
title_=title;
}
void set_abstract(std::string const& abstract)
{
abstract_=abstract;
}
void set_abstract(std::string const& abstract)
{
abstract_=abstract;
}
std::string const& get_abstract() const
{
return abstract_;
}
std::string const& get_abstract() const
{
return abstract_;
}
void append(const symbolizer& sym)
{
syms_.push_back(sym);
}
void append(const symbolizer& sym)
{
syms_.push_back(sym);
}
void remove_at(size_t index)
{
if (index < syms_.size())
{
syms_.erase(syms_.begin()+index);
}
}
void remove_at(size_t index)
{
if (index < syms_.size())
{
syms_.erase(syms_.begin()+index);
}
}
const symbolizers& get_symbolizers() const
{
return syms_;
}
const symbolizers& get_symbolizers() const
{
return syms_;
}
symbolizers::const_iterator begin()
{
return syms_.begin();
}
symbolizers::const_iterator begin()
{
return syms_.begin();
}
symbolizers::const_iterator end()
{
return syms_.end();
}
symbolizers::const_iterator end()
{
return syms_.end();
}
void set_filter(const filter_ptr& filter)
{
filter_=filter;
}
void set_filter(const filter_ptr& filter)
{
filter_=filter;
}
filter_ptr const& get_filter() const
{
return filter_;
}
filter_ptr const& get_filter() const
{
return filter_;
}
void set_else(bool else_filter)
{
else_filter_=else_filter;
}
void set_else(bool else_filter)
{
else_filter_=else_filter;
}
bool has_else_filter() const
{
return else_filter_;
}
bool has_else_filter() const
{
return else_filter_;
}
bool active(double scale) const
{
return ( scale > min_scale_ && scale < max_scale_ );
}
bool active(double scale) const
{
return ( scale > min_scale_ && scale < max_scale_ );
}
void accept(filter_visitor<FeatureT>& v) const
{
v.visit(*this);
}
void accept(filter_visitor<FeatureT>& v) const
{
v.visit(*this);
}
private:
void swap(rule& rhs) throw()
{
name_=rhs.name_;
title_=rhs.title_;
abstract_=rhs.abstract_;
min_scale_=rhs.min_scale_;
max_scale_=rhs.max_scale_;
syms_=rhs.syms_;
filter_=rhs.filter_;
else_filter_=rhs.else_filter_;
}
void swap(rule& rhs) throw()
{
name_=rhs.name_;
title_=rhs.title_;
abstract_=rhs.abstract_;
min_scale_=rhs.min_scale_;
max_scale_=rhs.max_scale_;
syms_=rhs.syms_;
filter_=rhs.filter_;
else_filter_=rhs.else_filter_;
}
};
typedef rule<Feature,filter> rule_type;

20
include/utils.hpp
View file

@ -201,21 +201,21 @@ namespace mapnik
template <typename T>
inline std::string toString(const T& x)
{
std::ostringstream o;
if (!(o << x))
throw BadConversion(std::string("toString(")
+ typeid(x).name() + ")");
return o.str();
std::ostringstream o;
if (!(o << x))
throw BadConversion(std::string("toString(")
+ typeid(x).name() + ")");
return o.str();
}
template<typename T>
inline void fromString(const std::string& s, T& x,
bool failIfLeftoverChars = true)
bool failIfLeftoverChars = true)
{
std::istringstream i(s);
char c;
if (!(i >> x) || (failIfLeftoverChars && i.get(c)))
throw BadConversion("fromString("+s+")");
std::istringstream i(s);
char c;
if (!(i >> x) || (failIfLeftoverChars && i.get(c)))
throw BadConversion("fromString("+s+")");
}
//inline bool space (char c)