mapnik Namespace Reference


Classes

class  pattern_source
struct  rasterizer
class  cairo_pattern
class  cairo_face
class  cairo_context
class  libxml2_loader
class  map_parser
struct  accumulate_extent
class  PngReader
class  serialize_symbolizer
class  TiffReader
struct  wkb_reader
class  agg_renderer
class  arrow
struct  attribute_traits
struct  attribute_traits< std::string >
class  attribute
struct  bad_attribute_cast
struct  symbolizer_attributes
class  attribute_collector
struct  attribute_desc
struct  boolean_filter
class  cairo_face_manager
class  cairo_renderer
class  Color
class  color_factory
struct  greater_than
struct  greater_than_or_equal
struct  less_than
struct  less_than_or_equal
struct  equals
struct  not_equals
struct  compare_filter
class  config_error
struct  coord
struct  coord< T, 2 >
struct  coord< T, 3 >
class  coord_array
struct  named_colors
struct  css_color_grammar
struct  named_color_action
struct  hex6_action
struct  hex3_action
struct  red_action
struct  green_action
struct  blue_action
struct  red_action_p
struct  green_action_p
struct  blue_action_p
struct  actions
struct  coord_transform
struct  coord_transform2
struct  coord_transform3
class  CoordTransform
struct  Featureset
class  datasource_exception
class  datasource
class  datasource_deleter
class  datasource_cache
class  great_circle_distance
struct  ellipsoid
class  illegal_enum_value
class  enumeration
class  Envelope
class  expression
class  literal
class  property
class  default_factory_error
class  factory
struct  feature
struct  feature_factory
class  attribute_descriptor
class  layer_descriptor
class  feature_style_processor
class  feature_type_style
class  fill
class  filter
class  all_filter
class  none_filter
class  filter_to_string
class  filter_factory
class  filter_featureset
struct  push_boolean
struct  push_integer
struct  push_real
struct  push_string
struct  push_property
struct  compose_expression
struct  compose_regex
struct  compose_filter
struct  compose_boolean_filter
struct  compose_and_filter
struct  compose_or_filter
struct  compose_not_filter
struct  filter_grammar
struct  filter_grammar_ast
class  node_data
class  filter_visitor
class  font_glyph
class  font_face
class  font_face_set
class  freetype_engine
class  face_manager
struct  text_renderer
class  FontSet
struct  gamma
struct  filter_in_box
struct  filter_at_point
class  geometry
class  point
class  polygon
class  line_string
class  Image32
class  hit_test_filter
class  ImageData
class  ImageReaderException
struct  ImageReader
class  ImageWriterException
struct  image_op
struct  image_op< Image, 2 >
class  image_view
struct  dest_mgr
struct  label_collision_detector
class  label_collision_detector2
class  label_collision_detector3
class  label_collision_detector4
struct  point_
class  label_placement
class  Layer
struct  line_pattern_symbolizer
struct  line_symbolizer
struct  logical_and
struct  logical_or
struct  logical_not
class  Map
class  markers_converter
struct  markers_symbolizer
struct  add
struct  sub
struct  mult
struct  div
struct  math_expr_b
class  MemoryUtils
class  MemoryManager
class  Object
class  geometry_pool
class  memory_datasource
class  memory_featureset
struct  rgb
struct  RGBPolicy
class  octree
struct  value_extractor_visitor
class  parameters
struct  placement
class  placement_finder
class  PluginInfo
struct  point_symbolizer
struct  polygon_pattern_symbolizer
struct  polygon_symbolizer
struct  building_symbolizer
class  PoolGuard
class  Pool
class  proj_transform
class  proj_init_error
class  projection
class  boolean
struct  name_trait
struct  name_trait< mapnik::enumeration< ENUM, MAX > >
class  quad_tree
class  query
struct  raster
struct  raster_symbolizer
struct  regex_filter
class  rule
struct  shield_symbolizer
struct  equals_
struct  disjoint
struct  touches
struct  within
struct  overlaps
struct  crosses
struct  bbox
class  stroke
class  style_factory
class  symbolizer_with_image
struct  character_info
class  string_info
struct  text_path
struct  text_symbolizer
class  transcoder
class  CreateUsingNew
class  CreateStatic
class  singleton
struct  value_null
class  value
struct  vertex
struct  vertex< T, 2 >
struct  Shift
struct  Shift< T0, T1, 0 >
struct  Shift< T, T, 0 >
struct  view_transform< vertex2d, vertex2d, Trans >
struct  view_transform< vertex2d, vertex2i, Trans >
struct  view_transform< Envelope< double >, Envelope< double >, Trans >
class  vertex_vector
struct  vertex_vector2
class  geometry_utils

Namespaces

namespace  impl

Typedefs

typedef boost::tuple< double,
double, double, double > 
segment_t
typedef factory< ImageReader,
std::string, ImageReader
*(*)(const std::string &) 
ImageReaderFactory )
typedef coord_transform2
< CoordTransform, geometry2d
PathType
typedef label_collision_detector4 DetectorType
typedef boost::shared_ptr
< cairo_face
cairo_face_ptr
typedef coord< double, 2 > coord2d
typedef coord< int, 2 > coord2i
typedef coord_array< coord2dCoordinateArray
typedef MAPNIK_DECL
boost::shared_ptr< Feature
feature_ptr
typedef MAPNIK_DECL
boost::shared_ptr< Featureset
featureset_ptr
typedef std::string datasource_name ()
typedef datasourcecreate_ds (const parameters &params)
typedef void destroy_ds (datasource *ds)
typedef boost::shared_ptr
< datasource
datasource_ptr
typedef boost::shared_ptr< rasterraster_ptr
typedef
boost::associative_property_map
< std::map< std::string, value > > 
properties
typedef feature< geometry2d,
raster_ptr
Feature
typedef std::vector< rule_typerules
typedef boost::shared_ptr
< filter< Feature > > 
filter_ptr
typedef char const * iterator_t
typedef node_val_data_factory
< node_data
factory_t
typedef tree_match< iterator_t,
factory_t >::tree_iterator 
iter_t
typedef boost::shared_ptr
< font_face
face_ptr
typedef boost::shared_ptr
< font_glyph
glyph_ptr
typedef boost::shared_ptr
< font_face_set
face_set_ptr
typedef point< vertex2dpoint_impl
typedef line_string< vertex2d,
vertex_vector2
line_string_impl
typedef polygon< vertex2d,
vertex_vector2
polygon_impl
typedef geometry< vertex2dgeometry2d
typedef boost::shared_ptr
< geometry2d
geometry_ptr
typedef boost::ptr_vector
< geometry2d
geometry_containter
typedef uint8_t byte
typedef ImageData< unsigned > ImageData32
typedef ImageData< uint8_t > ImageData8
typedef boost::variant< int,
double, std::string > 
value_holder
typedef std::pair< const
std::string, value_holder
parameter
typedef std::map< const
std::string, value_holder
param_map
typedef text_path placement_element
typedef boost::variant
< point_symbolizer,
line_symbolizer,
line_pattern_symbolizer,
polygon_symbolizer,
polygon_pattern_symbolizer,
raster_symbolizer,
shield_symbolizer,
text_symbolizer,
building_symbolizer,
markers_symbolizer
symbolizer
typedef std::vector< symbolizersymbolizers
typedef rule< Feature, filterrule_type
typedef vector< pair< float,
float > > 
dash_array
typedef boost::tuple< double,
double > 
position
typedef boost::variant
< value_null, bool, int,
double, UnicodeString > 
value_base
typedef vertex< double, 2 > vertex2d
typedef vertex< int, 2 > vertex2i
typedef Shift< double, double, 0 > NO_SHIFT
typedef Shift< double, int, 0 > SHIFT0
typedef Shift< double, int, 8 > SHIFT8

Enumerations

enum  eAttributeType {
  Integer = 1, Float = 2, Double = 3, String = 4,
  Geometry = 5, Object = 6
}
enum  GeomType { Point = 1, LineString = 2, Polygon = 3 }
enum  line_cap_enum { BUTT_CAP, SQUARE_CAP, ROUND_CAP, line_cap_enum_MAX }
enum  line_join_enum {
  MITER_JOIN, MITER_REVERT_JOIN, ROUND_JOIN, BEVEL_JOIN,
  line_join_enum_MAX
}
enum  label_placement_enum { POINT_PLACEMENT, LINE_PLACEMENT, label_placement_enum_MAX }
enum  CommandType { SEG_END = 0, SEG_MOVETO = 1, SEG_LINETO = 2, SEG_CLOSE = 3 }

Functions

bool y_order (segment_t const &first, segment_t const &second)
bool cairo_y_order (segment_t const &first, segment_t const &second)
bool is_input_plugin (std::string const &filename)
filter_ptr create_filter (std::string const &wkt, std::string const &encoding)
filter_ptr create_filter (std::string const &wkt)
bool register_image_reader (const std::string &type, ImageReader *(*fun)(const std::string &))
ImageReaderget_image_reader (const std::string &filename, const std::string &type)
ImageReaderget_image_reader (const std::string &filename)
template<typename T>
void save_to_file (T const &image, std::string const &filename, std::string const &type)
template<typename T>
void save_to_file (T const &image, std::string const &filename)
template void save_to_file< ImageData32 > (ImageData32 const &, std::string const &, std::string const &)
template void save_to_file< ImageData32 > (ImageData32 const &, std::string const &)
template void save_to_file< image_view< ImageData32 > > (image_view< ImageData32 > const &, std::string const &, std::string const &)
template void save_to_file< image_view< ImageData32 > > (image_view< ImageData32 > const &, std::string const &)
void read_xml2 (std::string const &filename, boost::property_tree::ptree &pt)
void load_map (Map &map, std::string const &filename, bool strict)
template<typename T>
std::pair< double, double > get_position_at_distance (double target_distance, T &shape_path)
template<typename T>
double get_total_distance (T &shape_path)
std::string guess_type (const std::string &filename)
void serialize_rule (ptree &style_node, const rule_type &rule)
void serialize_style (ptree &map_node, Map::const_style_iterator style_it)
void serialize_datasource (ptree &layer_node, datasource_ptr datasource)
void serialize_layer (ptree &map_node, const Layer &layer)
void save_map (Map const &map, std::string const &filename)
double scale_denominator (Map const &map, bool geographic)
template<typename T>
bool is_type (const attribute &attr)
template<typename T>
T * attribute_cast (attribute *attr)
template<typename T>
const T * attribute_cast (const attribute *attr)
template<typename T>
attribute_cast (const attribute &attr)
template<typename T>
attribute_cast (attribute &attr)
template<typename T>
attribute attribute_from_string (const std::string &val)
template<typename charT, typename traits>
std::basic_ostream< charT,
traits > & 
operator<< (std::basic_ostream< charT, traits > &out, const attribute &attr)
template<typename charT, typename traits, typename T, int dim>
std::basic_ostream< charT,
traits > & 
operator<< (std::basic_ostream< charT, traits > &out, const coord< T, dim > &c)
template<typename charT, typename traits, typename T>
std::basic_ostream< charT,
traits > & 
operator<< (std::basic_ostream< charT, traits > &out, const coord< T, 2 > &c)
template<typename charT, typename traits, typename T>
std::basic_ostream< charT,
traits > & 
operator<< (std::basic_ostream< charT, traits > &out, const coord< T, 3 > &c)
template<class charT, class traits, class T>
std::basic_ostream< charT,
traits > & 
operator<< (std::basic_ostream< charT, traits > &out, const Envelope< T > &e)
std::ostream & operator<< (std::ostream &out, Feature const &f)
template<typename charT, typename traits>
std::basic_ostream< charT,
traits > & 
operator<< (std::basic_ostream< charT, traits > &out, attribute_descriptor const &ad)
template<typename charT, typename traits>
std::basic_ostream< charT,
traits > & 
operator<< (std::basic_ostream< charT, traits > &out, layer_descriptor const &ld)
void process_node (iter_t const &, string &)
void walk_ast_tree (tree_parse_info< iterator_t, factory_t > info, string &text)
template<typename T>
bool clip_test (T p, T q, double &tmin, double &tmax)
template<typename T, typename Image>
bool clip_line (T &x0, T &y0, T &x1, T &y1, Envelope< T > const &box)
template<typename Iter>
bool point_inside_path (double x, double y, Iter start, Iter end)
bool point_in_circle (double x, double y, double cx, double cy, double r)
template<typename T>
sqr (T x)
double distance2 (double x0, double y0, double x1, double y1)
double distance (double x0, double y0, double x1, double y1)
double point_to_segment_distance (double x, double y, double ax, double ay, double bx, double by)
template<typename Iter>
bool point_on_path (double x, double y, Iter start, Iter end, double tol)
bool register_image_reader (const std::string &type, ImageReader *(*)(const std::string &))
template<typename T>
void save_as_png (T const &image, std::string const &filename)
template<typename T>
void save_as_jpeg (std::string const &filename, int quality, T const &image)
bool is_png (std::string const &filename)
bool is_jpeg (std::string const &filename)
bool is_tiff (std::string const &filename)
std::string type_from_filename (std::string const &filename)
template<typename T>
double distance (T x0, T y0, T x1, T y1)
template<typename Image>
void scale_down2 (Image &target, const Image &source)
template<typename Image>
void scale_image (Image &target, const Image &source, unsigned scale)
template<typename Image>
void scale_image (Image &target, const Image &source)
MAPNIK_DECL void save_to_file (Image32 const &image, std::string const &file, std::string const &type)
MAPNIK_DECL void save_to_file (Image32 const &image, std::string const &file)
void init_destination (j_compress_ptr cinfo)
boolean empty_output_buffer (j_compress_ptr cinfo)
void term_destination (j_compress_ptr cinfo)
template<typename T1, typename T2>
void save_as_jpeg (T1 &file, int quality, T2 const &image)
template<typename T>
void write_data (png_structp png_ptr, png_bytep data, png_size_t length)
template<typename T>
void flush_data (png_structp png_ptr)
template<typename T1, typename T2>
void save_as_png (T1 &file, T2 const &image)
template<typename T>
void reduce_8 (T const &in, ImageData8 &out, octree< rgb > &tree)
template<typename T>
void reduce_4 (T const &in, ImageData8 &out, octree< rgb > &tree)
template<typename T>
void reduce_1 (T const &, ImageData8 &out, octree< rgb > &)
template<typename T>
void save_as_png (T &file, std::vector< mapnik::rgb > &palette, mapnik::ImageData8 const &image, unsigned width, unsigned height, unsigned color_depth)
template<typename T1, typename T2>
void save_as_png256 (T1 &file, T2 const &image)
template<typename T>
get (const boost::property_tree::ptree &node, const std::string &name, bool is_attribute, const T &default_value)
template<typename T>
get (const boost::property_tree::ptree &node, const std::string &name, bool is_attribute)
template<typename T>
get_own (const boost::property_tree::ptree &node, const std::string &name)
template<typename T>
boost::optional< T > get_optional (const boost::property_tree::ptree &node, const std::string &name, bool is_attribute)
template<typename T>
boost::optional< T > get_opt_attr (const boost::property_tree::ptree &node, const std::string &name)
template<typename T>
boost::optional< T > get_opt_child (const boost::property_tree::ptree &node, const std::string &name)
template<typename T>
get_attr (const boost::property_tree::ptree &node, const std::string &name, const T &default_value)
template<typename T>
get_attr (const boost::property_tree::ptree &node, const std::string &name)
template<typename T>
get_css (const boost::property_tree::ptree &node, const std::string &name)
template<typename charT, typename traits>
std::basic_istream< charT,
traits > & 
operator>> (std::basic_istream< charT, traits > &s, mapnik::Color &c)
template<typename charT, typename traits>
std::basic_ostream< charT,
traits > & 
operator<< (std::basic_ostream< charT, traits > &s, const mapnik::Color &c)
template<typename charT, typename traits>
std::basic_istream< charT,
traits > & 
operator>> (std::basic_istream< charT, traits > &s, boolean &b)
template<typename charT, typename traits>
std::basic_ostream< charT,
traits > & 
operator<< (std::basic_ostream< charT, traits > &s, const boolean &b)
template<typename T>
void set_attr (boost::property_tree::ptree &pt, const std::string &name, const T &v)
template<typename T>
void set_css (boost::property_tree::ptree &pt, const std::string &name, const T &v)
 DEFINE_NAME_TRAIT (double)
 DEFINE_NAME_TRAIT (float)
 DEFINE_NAME_TRAIT (unsigned)
 DEFINE_NAME_TRAIT (boolean)
 DEFINE_NAME_TRAIT_WITH_NAME (int,"integer")
 DEFINE_NAME_TRAIT_WITH_NAME (std::string,"string")
 DEFINE_NAME_TRAIT_WITH_NAME (Color,"color")
bool operator== (point_symbolizer const &lhs, point_symbolizer const &rhs)
bool operator== (line_symbolizer const &lhs, line_symbolizer const &rhs)
bool operator== (line_pattern_symbolizer const &lhs, line_pattern_symbolizer const &rhs)
bool operator== (polygon_symbolizer const &lhs, polygon_symbolizer const &rhs)
bool operator== (polygon_pattern_symbolizer const &lhs, polygon_pattern_symbolizer const &rhs)
bool operator== (raster_symbolizer const &lhs, raster_symbolizer const &rhs)
bool operator== (text_symbolizer const &lhs, text_symbolizer const &rhs)
bool operator== (shield_symbolizer const &lhs, shield_symbolizer const &rhs)
bool operator== (building_symbolizer const &lhs, building_symbolizer const &rhs)
bool operator== (markers_symbolizer const &lhs, markers_symbolizer const &rhs)
 DEFINE_ENUM (line_cap_e, line_cap_enum)
 DEFINE_ENUM (line_join_e, line_join_enum)
 DEFINE_ENUM (label_placement_e, label_placement_enum)
const value operator+ (value const &p1, value const &p2)
const value operator- (value const &p1, value const &p2)
const value operator* (value const &p1, value const &p2)
const value operator/ (value const &p1, value const &p2)
template<typename charT, typename traits>
std::basic_ostream< charT,
traits > & 
operator<< (std::basic_ostream< charT, traits > &out, value const &v)
template<class charT, class traits, class T, int dim>
std::basic_ostream< charT,
traits > & 
operator<< (std::basic_ostream< charT, traits > &out, const vertex< T, dim > &c)
template<class charT, class traits, class T>
std::basic_ostream< charT,
traits > & 
operator<< (std::basic_ostream< charT, traits > &out, const vertex< T, 2 > &v)
template<class charT, class traits, class T>
std::basic_ostream< charT,
traits > & 
operator<< (std::basic_ostream< charT, traits > &out, const vertex< T, 3 > &v)


Typedef Documentation

typedef uint8_t mapnik::byte

typedef boost::shared_ptr<cairo_face> mapnik::cairo_face_ptr

typedef coord<double,2> mapnik::coord2d

typedef coord<int,2> mapnik::coord2i

typedef datasource* mapnik::create_ds(const parameters &params)

typedef vector<pair<float,float> > mapnik::dash_array

typedef std::string mapnik::datasource_name()

typedef boost::shared_ptr<datasource> mapnik::datasource_ptr

typedef void mapnik::destroy_ds(datasource *ds)

typedef boost::shared_ptr<font_face> mapnik::face_ptr

typedef boost::shared_ptr<font_face_set> mapnik::face_set_ptr

typedef node_val_data_factory<node_data> mapnik::factory_t

typedef MAPNIK_DECL boost::shared_ptr<Feature> mapnik::feature_ptr

typedef MAPNIK_DECL boost::shared_ptr<Featureset> mapnik::featureset_ptr

typedef boost::shared_ptr<filter<Feature> > mapnik::filter_ptr

typedef boost::ptr_vector<geometry2d> mapnik::geometry_containter

typedef boost::shared_ptr<geometry2d> mapnik::geometry_ptr

typedef boost::shared_ptr<font_glyph> mapnik::glyph_ptr

typedef ImageData<unsigned> mapnik::ImageData32

typedef ImageData<uint8_t> mapnik::ImageData8

typedef factory<ImageReader,std::string, ImageReader* (*)(const std::string&) mapnik::ImageReaderFactory)

typedef tree_match<iterator_t,factory_t>::tree_iterator mapnik::iter_t

typedef char const* mapnik::iterator_t

typedef Shift<double,double,0> mapnik::NO_SHIFT

typedef std::map<const std::string, value_holder> mapnik::param_map

typedef std::pair<const std::string, value_holder> mapnik::parameter

typedef boost::tuple<double,double> mapnik::position

typedef boost::associative_property_map< std::map<std::string,value > > mapnik::properties

typedef boost::shared_ptr<raster> mapnik::raster_ptr

typedef std::vector<rule_type> mapnik::rules

typedef boost::tuple< double, double, double, double > mapnik::segment_t

typedef Shift<double,int,0> mapnik::SHIFT0

typedef Shift<double,int,8> mapnik::SHIFT8

typedef std::vector<symbolizer> mapnik::symbolizers

typedef boost::variant<value_null,bool,int,double,UnicodeString> mapnik::value_base

typedef boost::variant<int,double,std::string> mapnik::value_holder

typedef vertex<double,2> mapnik::vertex2d

typedef vertex<int,2> mapnik::vertex2i


Enumeration Type Documentation

Enumerator:
SEG_END 
SEG_MOVETO 
SEG_LINETO 
SEG_CLOSE 

Enumerator:
Integer 
Float 
Double 
String 
Geometry 
Object 

Enumerator:
Point 
LineString 
Polygon 

Enumerator:
POINT_PLACEMENT 
LINE_PLACEMENT 
label_placement_enum_MAX 

Enumerator:
BUTT_CAP 
SQUARE_CAP 
ROUND_CAP 
line_cap_enum_MAX 

Enumerator:
MITER_JOIN 
MITER_REVERT_JOIN 
ROUND_JOIN 
BEVEL_JOIN 
line_join_enum_MAX 


Function Documentation

template<typename T>
T mapnik::attribute_cast ( attribute &  attr  )  [inline]

References attribute_cast().

template<typename T>
T mapnik::attribute_cast ( const attribute &  attr  )  [inline]

References attribute_cast().

template<typename T>
const T* mapnik::attribute_cast ( const attribute *  attr  )  [inline]

References attribute_cast().

template<typename T>
T* mapnik::attribute_cast ( attribute *  attr  )  [inline]

template<typename T>
attribute mapnik::attribute_from_string ( const std::string &  val  )  [inline]

bool mapnik::cairo_y_order ( segment_t const &  first,
segment_t const &  second 
)

template<typename T, typename Image>
bool mapnik::clip_line ( T &  x0,
T &  y0,
T &  x1,
T &  y1,
Envelope< T > const &  box 
) [inline]

template<typename T>
bool mapnik::clip_test ( p,
q,
double &  tmin,
double &  tmax 
) [inline]

MAPNIK_DECL filter_ptr mapnik::create_filter ( std::string const &  wkt  ) 

References create_filter().

MAPNIK_DECL filter_ptr mapnik::create_filter ( std::string const &  wkt,
std::string const &  encoding 
)

mapnik::DEFINE_ENUM ( label_placement_e  ,
label_placement_enum   
)

mapnik::DEFINE_ENUM ( line_join_e  ,
line_join_enum   
)

mapnik::DEFINE_ENUM ( line_cap_e  ,
line_cap_enum   
)

mapnik::DEFINE_NAME_TRAIT ( boolean   ) 

mapnik::DEFINE_NAME_TRAIT ( unsigned   ) 

mapnik::DEFINE_NAME_TRAIT ( float   ) 

mapnik::DEFINE_NAME_TRAIT ( double   ) 

mapnik::DEFINE_NAME_TRAIT_WITH_NAME ( Color  ,
"color"   
)

mapnik::DEFINE_NAME_TRAIT_WITH_NAME ( std::string  ,
"string"   
)

mapnik::DEFINE_NAME_TRAIT_WITH_NAME ( int  ,
"integer"   
)

template<typename T>
double mapnik::distance ( x0,
y0,
x1,
y1 
) [inline]

double mapnik::distance ( double  x0,
double  y0,
double  x1,
double  y1 
) [inline]

double mapnik::distance2 ( double  x0,
double  y0,
double  x1,
double  y1 
) [inline]

References sqr().

Referenced by distance(), and point_to_segment_distance().

boolean mapnik::empty_output_buffer ( j_compress_ptr  cinfo  )  [inline]

template<typename T>
void mapnik::flush_data ( png_structp  png_ptr  )  [inline]

template<typename T>
T mapnik::get ( const boost::property_tree::ptree &  node,
const std::string &  name,
bool  is_attribute 
) [inline]

template<typename T>
T mapnik::get ( const boost::property_tree::ptree &  node,
const std::string &  name,
bool  is_attribute,
const T &  default_value 
) [inline]

template<typename T>
T mapnik::get_attr ( const boost::property_tree::ptree &  node,
const std::string &  name 
) [inline]

template<typename T>
T mapnik::get_attr ( const boost::property_tree::ptree &  node,
const std::string &  name,
const T &  default_value 
) [inline]

template<typename T>
T mapnik::get_css ( const boost::property_tree::ptree &  node,
const std::string &  name 
) [inline]

MAPNIK_DECL ImageReader * mapnik::get_image_reader ( const std::string &  filename  ) 

References type_from_filename().

MAPNIK_DECL ImageReader * mapnik::get_image_reader ( const std::string &  filename,
const std::string &  type 
)

template<typename T>
boost::optional<T> mapnik::get_opt_attr ( const boost::property_tree::ptree &  node,
const std::string &  name 
) [inline]

template<typename T>
boost::optional<T> mapnik::get_opt_child ( const boost::property_tree::ptree &  node,
const std::string &  name 
) [inline]

template<typename T>
boost::optional< T > mapnik::get_optional ( const boost::property_tree::ptree &  node,
const std::string &  name,
bool  is_attribute 
) [inline]

template<typename T>
T mapnik::get_own ( const boost::property_tree::ptree &  node,
const std::string &  name 
) [inline]

template<typename T>
std::pair<double, double> mapnik::get_position_at_distance ( double  target_distance,
T &  shape_path 
) [inline]

References distance().

template<typename T>
double mapnik::get_total_distance ( T &  shape_path  )  [inline]

std::string mapnik::guess_type ( const std::string &  filename  ) 

void mapnik::init_destination ( j_compress_ptr  cinfo  )  [inline]

bool mapnik::is_input_plugin ( std::string const &  filename  ) 

bool mapnik::is_jpeg ( std::string const &  filename  )  [inline]

Referenced by type_from_filename().

bool mapnik::is_png ( std::string const &  filename  )  [inline]

Referenced by type_from_filename().

bool mapnik::is_tiff ( std::string const &  filename  )  [inline]

Referenced by type_from_filename().

template<typename T>
bool mapnik::is_type ( const attribute &  attr  )  [inline]

MAPNIK_DECL void mapnik::load_map ( Map &  map,
std::string const &  filename,
bool  strict 
)

const value mapnik::operator* ( value const &  p1,
value const &  p2 
) [inline]

References mapnik::value::base_.

const value mapnik::operator+ ( value const &  p1,
value const &  p2 
) [inline]

References mapnik::value::base_.

const value mapnik::operator- ( value const &  p1,
value const &  p2 
) [inline]

References mapnik::value::base_.

const value mapnik::operator/ ( value const &  p1,
value const &  p2 
) [inline]

References mapnik::value::base_.

template<class charT, class traits, class T>
std::basic_ostream<charT,traits>& mapnik::operator<< ( std::basic_ostream< charT, traits > &  out,
const vertex< T, 3 > &  v 
) [inline]

template<class charT, class traits, class T>
std::basic_ostream<charT,traits>& mapnik::operator<< ( std::basic_ostream< charT, traits > &  out,
const vertex< T, 2 > &  v 
) [inline]

template<class charT, class traits, class T, int dim>
std::basic_ostream<charT,traits>& mapnik::operator<< ( std::basic_ostream< charT, traits > &  out,
const vertex< T, dim > &  c 
) [inline]

template<typename charT, typename traits>
std::basic_ostream<charT,traits>& mapnik::operator<< ( std::basic_ostream< charT, traits > &  out,
value const &  v 
) [inline]

template<typename charT, typename traits>
std::basic_ostream<charT, traits>& mapnik::operator<< ( std::basic_ostream< charT, traits > &  s,
const boolean &  b 
) [inline]

template<typename charT, typename traits>
std::basic_ostream<charT, traits>& mapnik::operator<< ( std::basic_ostream< charT, traits > &  s,
const mapnik::Color c 
) [inline]

template<typename charT, typename traits>
std::basic_ostream<charT,traits>& mapnik::operator<< ( std::basic_ostream< charT, traits > &  out,
layer_descriptor const &  ld 
) [inline]

template<typename charT, typename traits>
std::basic_ostream<charT,traits>& mapnik::operator<< ( std::basic_ostream< charT, traits > &  out,
attribute_descriptor const &  ad 
) [inline]

std::ostream& mapnik::operator<< ( std::ostream &  out,
Feature const &  f 
) [inline]

template<class charT, class traits, class T>
std::basic_ostream<charT,traits>& mapnik::operator<< ( std::basic_ostream< charT, traits > &  out,
const Envelope< T > &  e 
) [inline]

template<typename charT, typename traits, typename T>
std::basic_ostream<charT,traits>& mapnik::operator<< ( std::basic_ostream< charT, traits > &  out,
const coord< T, 3 > &  c 
) [inline]

template<typename charT, typename traits, typename T>
std::basic_ostream<charT,traits>& mapnik::operator<< ( std::basic_ostream< charT, traits > &  out,
const coord< T, 2 > &  c 
) [inline]

template<typename charT, typename traits, typename T, int dim>
std::basic_ostream<charT,traits>& mapnik::operator<< ( std::basic_ostream< charT, traits > &  out,
const coord< T, dim > &  c 
) [inline]

template<typename charT, typename traits>
std::basic_ostream<charT,traits>& mapnik::operator<< ( std::basic_ostream< charT, traits > &  out,
const attribute &  attr 
) [inline]

bool mapnik::operator== ( markers_symbolizer const &  lhs,
markers_symbolizer const &  rhs 
) [inline]

bool mapnik::operator== ( building_symbolizer const &  lhs,
building_symbolizer const &  rhs 
) [inline]

bool mapnik::operator== ( shield_symbolizer const &  lhs,
shield_symbolizer const &  rhs 
) [inline]

bool mapnik::operator== ( text_symbolizer const &  lhs,
text_symbolizer const &  rhs 
) [inline]

bool mapnik::operator== ( raster_symbolizer const &  lhs,
raster_symbolizer const &  rhs 
) [inline]

bool mapnik::operator== ( polygon_pattern_symbolizer const &  lhs,
polygon_pattern_symbolizer const &  rhs 
) [inline]

bool mapnik::operator== ( polygon_symbolizer const &  lhs,
polygon_symbolizer const &  rhs 
) [inline]

bool mapnik::operator== ( line_pattern_symbolizer const &  lhs,
line_pattern_symbolizer const &  rhs 
) [inline]

bool mapnik::operator== ( line_symbolizer const &  lhs,
line_symbolizer const &  rhs 
) [inline]

bool mapnik::operator== ( point_symbolizer const &  lhs,
point_symbolizer const &  rhs 
) [inline]

template<typename charT, typename traits>
std::basic_istream<charT, traits>& mapnik::operator>> ( std::basic_istream< charT, traits > &  s,
boolean &  b 
) [inline]

Special stream input operator for boolean values

template<typename charT, typename traits>
std::basic_istream<charT, traits>& mapnik::operator>> ( std::basic_istream< charT, traits > &  s,
mapnik::Color c 
) [inline]

Stream input operator for Color values

References mapnik::color_factory::from_string().

bool mapnik::point_in_circle ( double  x,
double  y,
double  cx,
double  cy,
double  r 
) [inline]

template<typename Iter>
bool mapnik::point_inside_path ( double  x,
double  y,
Iter  start,
Iter  end 
) [inline]

template<typename Iter>
bool mapnik::point_on_path ( double  x,
double  y,
Iter  start,
Iter  end,
double  tol 
) [inline]

double mapnik::point_to_segment_distance ( double  x,
double  y,
double  ax,
double  ay,
double  bx,
double  by 
) [inline]

References distance(), and distance2().

Referenced by point_on_path().

void mapnik::process_node ( iter_t const &  i,
string &  text 
)

void mapnik::read_xml2 ( std::string const &  filename,
boost::property_tree::ptree &  pt 
)

References mapnik::libxml2_loader::load().

Referenced by load_map().

template<typename T>
void mapnik::reduce_1 ( T const &  ,
ImageData8 &  out,
octree< rgb > &   
) [inline]

References mapnik::ImageData< T >::set().

Referenced by save_as_png256().

template<typename T>
void mapnik::reduce_4 ( T const &  in,
ImageData8 &  out,
octree< rgb > &  tree 
) [inline]

template<typename T>
void mapnik::reduce_8 ( T const &  in,
ImageData8 &  out,
octree< rgb > &  tree 
) [inline]

bool mapnik::register_image_reader ( const std::string &  type,
ImageReader *  *)(const std::string & 
)

bool mapnik::register_image_reader ( const std::string &  type,
ImageReader *(*)(const std::string &)  fun 
)

template<typename T1, typename T2>
void mapnik::save_as_jpeg ( T1 &  file,
int  quality,
T2 const &  image 
) [inline]

template<typename T>
void mapnik::save_as_jpeg ( std::string const &  filename,
int  quality,
T const &  image 
) [inline]

Referenced by save_to_file().

template<typename T>
void mapnik::save_as_png ( T &  file,
std::vector< mapnik::rgb > &  palette,
mapnik::ImageData8 const &  image,
unsigned  width,
unsigned  height,
unsigned  color_depth 
) [inline]

template<typename T1, typename T2>
void mapnik::save_as_png ( T1 &  file,
T2 const &  image 
) [inline]

template<typename T>
void mapnik::save_as_png ( T const &  image,
std::string const &  filename 
) [inline]

Referenced by save_as_png256(), and save_to_file().

template<typename T1, typename T2>
void mapnik::save_as_png256 ( T1 &  file,
T2 const &  image 
) [inline]

MAPNIK_DECL void mapnik::save_map ( Map const &  map,
std::string const &  filename 
)

MAPNIK_DECL void mapnik::save_to_file ( Image32 const &  image,
std::string const &  file 
) [inline]

MAPNIK_DECL void mapnik::save_to_file ( Image32 const &  image,
std::string const &  file,
std::string const &  type 
) [inline]

template<typename T>
MAPNIK_DECL void mapnik::save_to_file ( T const &  image,
std::string const &  filename 
) [inline]

References type_from_filename().

template<typename T>
MAPNIK_DECL void mapnik::save_to_file ( T const &  image,
std::string const &  filename,
std::string const &  type 
) [inline]

template void mapnik::save_to_file< image_view< ImageData32 > > ( image_view< ImageData32 > const &  ,
std::string const &   
)

template void mapnik::save_to_file< image_view< ImageData32 > > ( image_view< ImageData32 > const &  ,
std::string const &  ,
std::string const &   
)

template void mapnik::save_to_file< ImageData32 > ( ImageData32 const &  ,
std::string const &   
)

template void mapnik::save_to_file< ImageData32 > ( ImageData32 const &  ,
std::string const &  ,
std::string const &   
)

Referenced by save_to_file().

MAPNIK_DECL double mapnik::scale_denominator ( Map const &  map,
bool  geographic 
)

template<typename Image>
void mapnik::scale_down2 ( Image &  target,
const Image &  source 
) [inline]

template<typename Image>
void mapnik::scale_image ( Image &  target,
const Image &  source 
) [inline]

template<typename Image>
void mapnik::scale_image ( Image &  target,
const Image &  source,
unsigned  scale 
) [inline]

void mapnik::serialize_datasource ( ptree &  layer_node,
datasource_ptr  datasource 
)

Referenced by serialize_layer().

void mapnik::serialize_layer ( ptree &  map_node,
const Layer &  layer 
)

void mapnik::serialize_rule ( ptree &  style_node,
const rule_type &  rule 
)

void mapnik::serialize_style ( ptree &  map_node,
Map::const_style_iterator  style_it 
)

template<typename T>
void mapnik::set_attr ( boost::property_tree::ptree &  pt,
const std::string &  name,
const T &  v 
) [inline]

template<typename T>
void mapnik::set_css ( boost::property_tree::ptree &  pt,
const std::string &  name,
const T &  v 
) [inline]

template<typename T>
T mapnik::sqr ( x  )  [inline]

Referenced by distance2().

void mapnik::term_destination ( j_compress_ptr  cinfo  )  [inline]

std::string mapnik::type_from_filename ( std::string const &  filename  )  [inline]

References is_jpeg(), is_png(), and is_tiff().

Referenced by get_image_reader(), and save_to_file().

void mapnik::walk_ast_tree ( tree_parse_info< iterator_t, factory_t >  info,
string &  text 
)

References process_node().

template<typename T>
void mapnik::write_data ( png_structp  png_ptr,
png_bytep  data,
png_size_t  length 
) [inline]

bool mapnik::y_order ( segment_t const &  first,
segment_t const &  second 
)


Generated for Mapnik by doxygen 1.5.6