mapnik._mapnik

class mapnik._mapnik.BuildingSymbolizer

Bases: mapnik._SymbolizerBase

symbol()

class mapnik._mapnik.ColorizerMode

Bases: Boost.Python.enum

COLORIZER_DISCRETE = mapnik._mapnik.ColorizerMode.COLORIZER_DISCRETE

COLORIZER_EXACT = mapnik._mapnik.ColorizerMode.COLORIZER_EXACT

COLORIZER_INHERIT = mapnik._mapnik.ColorizerMode.COLORIZER_INHERIT

COLORIZER_LINEAR = mapnik._mapnik.ColorizerMode.COLORIZER_LINEAR

names = {'COLORIZER_DISCRETE': mapnik._mapnik.ColorizerMode.COLORIZER_DISCRETE, 'COLORIZER_EXACT': mapnik._mapnik.ColorizerMode.COLORIZER_EXACT, 'COLORIZER_INHERIT': mapnik._mapnik.ColorizerMode.COLORIZER_INHERIT, 'COLORIZER_LINEAR': mapnik._mapnik.ColorizerMode.COLORIZER_LINEAR}

values = {0: mapnik._mapnik.ColorizerMode.COLORIZER_INHERIT, 1: mapnik._mapnik.ColorizerMode.COLORIZER_LINEAR, 2: mapnik._mapnik.ColorizerMode.COLORIZER_DISCRETE, 3: mapnik._mapnik.ColorizerMode.COLORIZER_EXACT}

class mapnik._mapnik.ColorizerStop

Bases: Boost.Python.instance

property color

The stop color (mapnik.Color).

property label

The stop label.

property mode

The stop mode (mapnik.ColorizerMode).

If this is COLORIZER_INHERIT then it will inherit the default mode

from the RasterColorizer it is added to.

property value

The stop value.

class mapnik._mapnik.ColorizerStops

Bases: Boost.Python.instance

A RasterColorizer’s collection of ordered color stops. This class is not meant to be instantiated from python. However, it can be accessed at a RasterColorizer’s “stops” attribute for introspection purposes

append((ColorizerStops)arg1, (object)arg2) → None :

C++ signature :

void append(std::vector<mapnik::colorizer_stop, std::allocator<mapnik::colorizer_stop> > {lvalue},boost::python::api::object)

extend((ColorizerStops)arg1, (object)arg2) → None :

C++ signature :

void extend(std::vector<mapnik::colorizer_stop, std::allocator<mapnik::colorizer_stop> > {lvalue},boost::python::api::object)

class mapnik._mapnik.CompositeOp

Bases: Boost.Python.enum

clear = mapnik._mapnik.CompositeOp.clear

color = mapnik._mapnik.CompositeOp.color

color_burn = mapnik._mapnik.CompositeOp.color_burn

color_dodge = mapnik._mapnik.CompositeOp.color_dodge

contrast = mapnik._mapnik.CompositeOp.contrast

darken = mapnik._mapnik.CompositeOp.darken

difference = mapnik._mapnik.CompositeOp.difference

divide = mapnik._mapnik.CompositeOp.divide

dst = mapnik._mapnik.CompositeOp.dst

dst_atop = mapnik._mapnik.CompositeOp.dst_atop

dst_in = mapnik._mapnik.CompositeOp.dst_in

dst_out = mapnik._mapnik.CompositeOp.dst_out

dst_over = mapnik._mapnik.CompositeOp.dst_over

exclusion = mapnik._mapnik.CompositeOp.exclusion

grain_extract = mapnik._mapnik.CompositeOp.grain_extract

grain_merge = mapnik._mapnik.CompositeOp.grain_merge

hard_light = mapnik._mapnik.CompositeOp.hard_light

hue = mapnik._mapnik.CompositeOp.hue

invert = mapnik._mapnik.CompositeOp.invert

lighten = mapnik._mapnik.CompositeOp.lighten

linear_burn = mapnik._mapnik.CompositeOp.linear_burn

linear_dodge = mapnik._mapnik.CompositeOp.linear_dodge

minus = mapnik._mapnik.CompositeOp.minus

multiply = mapnik._mapnik.CompositeOp.multiply

names = {'clear': mapnik._mapnik.CompositeOp.clear, 'color': mapnik._mapnik.CompositeOp.color, 'color_burn': mapnik._mapnik.CompositeOp.color_burn, 'color_dodge': mapnik._mapnik.CompositeOp.color_dodge, 'contrast': mapnik._mapnik.CompositeOp.contrast, 'darken': mapnik._mapnik.CompositeOp.darken, 'difference': mapnik._mapnik.CompositeOp.difference, 'divide': mapnik._mapnik.CompositeOp.divide, 'dst': mapnik._mapnik.CompositeOp.dst, 'dst_atop': mapnik._mapnik.CompositeOp.dst_atop, 'dst_in': mapnik._mapnik.CompositeOp.dst_in, 'dst_out': mapnik._mapnik.CompositeOp.dst_out, 'dst_over': mapnik._mapnik.CompositeOp.dst_over, 'exclusion': mapnik._mapnik.CompositeOp.exclusion, 'grain_extract': mapnik._mapnik.CompositeOp.grain_extract, 'grain_merge': mapnik._mapnik.CompositeOp.grain_merge, 'hard_light': mapnik._mapnik.CompositeOp.hard_light, 'hue': mapnik._mapnik.CompositeOp.hue, 'invert': mapnik._mapnik.CompositeOp.invert, 'lighten': mapnik._mapnik.CompositeOp.lighten, 'linear_burn': mapnik._mapnik.CompositeOp.linear_burn, 'linear_dodge': mapnik._mapnik.CompositeOp.linear_dodge, 'minus': mapnik._mapnik.CompositeOp.minus, 'multiply': mapnik._mapnik.CompositeOp.multiply, 'overlay': mapnik._mapnik.CompositeOp.overlay, 'plus': mapnik._mapnik.CompositeOp.plus, 'saturation': mapnik._mapnik.CompositeOp.saturation, 'screen': mapnik._mapnik.CompositeOp.screen, 'soft_light': mapnik._mapnik.CompositeOp.soft_light, 'src': mapnik._mapnik.CompositeOp.src, 'src_atop': mapnik._mapnik.CompositeOp.src_atop, 'src_in': mapnik._mapnik.CompositeOp.src_in, 'src_out': mapnik._mapnik.CompositeOp.src_out, 'src_over': mapnik._mapnik.CompositeOp.src_over, 'value': mapnik._mapnik.CompositeOp.value, 'xor': mapnik._mapnik.CompositeOp.xor}

overlay = mapnik._mapnik.CompositeOp.overlay

plus = mapnik._mapnik.CompositeOp.plus

saturation = mapnik._mapnik.CompositeOp.saturation

screen = mapnik._mapnik.CompositeOp.screen

soft_light = mapnik._mapnik.CompositeOp.soft_light

src = mapnik._mapnik.CompositeOp.src

src_atop = mapnik._mapnik.CompositeOp.src_atop

src_in = mapnik._mapnik.CompositeOp.src_in

src_out = mapnik._mapnik.CompositeOp.src_out

src_over = mapnik._mapnik.CompositeOp.src_over

value = mapnik._mapnik.CompositeOp.value

values = {0: mapnik._mapnik.CompositeOp.clear, 1: mapnik._mapnik.CompositeOp.src, 2: mapnik._mapnik.CompositeOp.dst, 3: mapnik._mapnik.CompositeOp.src_over, 4: mapnik._mapnik.CompositeOp.dst_over, 5: mapnik._mapnik.CompositeOp.src_in, 6: mapnik._mapnik.CompositeOp.dst_in, 7: mapnik._mapnik.CompositeOp.src_out, 8: mapnik._mapnik.CompositeOp.dst_out, 9: mapnik._mapnik.CompositeOp.src_atop, 10: mapnik._mapnik.CompositeOp.dst_atop, 11: mapnik._mapnik.CompositeOp.xor, 12: mapnik._mapnik.CompositeOp.plus, 13: mapnik._mapnik.CompositeOp.minus, 14: mapnik._mapnik.CompositeOp.multiply, 15: mapnik._mapnik.CompositeOp.screen, 16: mapnik._mapnik.CompositeOp.overlay, 17: mapnik._mapnik.CompositeOp.darken, 18: mapnik._mapnik.CompositeOp.lighten, 19: mapnik._mapnik.CompositeOp.color_dodge, 20: mapnik._mapnik.CompositeOp.color_burn, 21: mapnik._mapnik.CompositeOp.hard_light, 22: mapnik._mapnik.CompositeOp.soft_light, 23: mapnik._mapnik.CompositeOp.difference, 24: mapnik._mapnik.CompositeOp.exclusion, 25: mapnik._mapnik.CompositeOp.contrast, 26: mapnik._mapnik.CompositeOp.invert, 28: mapnik._mapnik.CompositeOp.grain_merge, 29: mapnik._mapnik.CompositeOp.grain_extract, 30: mapnik._mapnik.CompositeOp.hue, 31: mapnik._mapnik.CompositeOp.saturation, 32: mapnik._mapnik.CompositeOp.color, 33: mapnik._mapnik.CompositeOp.value, 34: mapnik._mapnik.CompositeOp.linear_dodge, 35: mapnik._mapnik.CompositeOp.linear_burn, 36: mapnik._mapnik.CompositeOp.divide}

xor = mapnik._mapnik.CompositeOp.xor

class mapnik._mapnik.Context

Bases: Boost.Python.instance

push((Context)arg1, (str)arg2) → int :

C++ signature :

unsigned long push(mapnik::context<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned long, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, unsigned long> > > > {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

mapnik._mapnik.CreateDatasource((dict)arg1) → Datasource :

C++ signature :

std::shared_ptr<mapnik::datasource> CreateDatasource(boost::python::dict)

class mapnik._mapnik.DataGeometryType

Bases: Boost.Python.enum

Collection = mapnik._mapnik.DataGeometryType.Collection

LineString = mapnik._mapnik.DataGeometryType.LineString

Point = mapnik._mapnik.DataGeometryType.Point

Polygon = mapnik._mapnik.DataGeometryType.Polygon

names = {'Collection': mapnik._mapnik.DataGeometryType.Collection, 'LineString': mapnik._mapnik.DataGeometryType.LineString, 'Point': mapnik._mapnik.DataGeometryType.Point, 'Polygon': mapnik._mapnik.DataGeometryType.Polygon}

values = {1: mapnik._mapnik.DataGeometryType.Point, 2: mapnik._mapnik.DataGeometryType.LineString, 3: mapnik._mapnik.DataGeometryType.Polygon, 4: mapnik._mapnik.DataGeometryType.Collection}

class mapnik._mapnik.DataType

Bases: Boost.Python.enum

Raster = mapnik._mapnik.DataType.Raster

Vector = mapnik._mapnik.DataType.Vector

names = {'Raster': mapnik._mapnik.DataType.Raster, 'Vector': mapnik._mapnik.DataType.Vector}

values = {0: mapnik._mapnik.DataType.Vector, 1: mapnik._mapnik.DataType.Raster}

class mapnik._mapnik.DatasourceCache

Bases: Boost.Python.instance

static create((dict)arg1) → Datasource :

C++ signature :

std::shared_ptr<mapnik::datasource> create(boost::python::dict)

static plugin_directories() → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > plugin_directories()

static plugin_names() → Names :

C++ signature :

std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > plugin_names()

static register_datasources((str)arg1) → None :

C++ signature :

void register_datasources(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

class mapnik._mapnik.DebugSymbolizer

Bases: mapnik._SymbolizerBase

symbol()

mapnik._mapnik.Expression((str)expr) → Expression :

Expression string

C++ signature :

std::shared_ptr<mapbox::util::variant<mapnik::value_null, bool, long, double, icu_66::UnicodeString, mapnik::attribute, mapnik::global_attribute, mapnik::geometry_type_attribute, mapbox::util::recursive_wrapper<mapnik::unary_node<mapnik::tags::negate> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::plus> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::minus> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::mult> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::div> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::mod> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::less> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::less_equal> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::greater> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::greater_equal> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::equal_to> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::not_equal_to> >, mapbox::util::recursive_wrapper<mapnik::unary_node<mapnik::tags::logical_not> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::logical_and> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::logical_or> >, mapbox::util::recursive_wrapper<mapnik::regex_match_node>, mapbox::util::recursive_wrapper<mapnik::regex_replace_node>, mapbox::util::recursive_wrapper<mapnik::unary_function_call>, mapbox::util::recursive_wrapper<mapnik::binary_function_call> > > Expression(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

class mapnik._mapnik.Featureset

Bases: Boost.Python.instance

next((Featureset)arg1) → Feature :

C++ signature :

std::shared_ptr<mapnik::feature_impl> next(std::shared_ptr<mapnik::Featureset>)

class mapnik._mapnik.FontEngine

Bases: Boost.Python.instance

static face_names() → Names :

C++ signature :

std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > face_names()

static register_font((str)arg1) → bool :

C++ signature :

bool register_font(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

static register_fonts((str)arg1, (bool)arg2) → bool :

C++ signature :

bool register_fonts(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,bool)

class mapnik._mapnik.FontSet

Bases: Boost.Python.instance

add_face_name((FontSet)arg1, (str)name) → None :

Add a face-name to the fontset.

Example: >>> fs = Fontset(‘book-fonts’) >>> fs.add_face_name(‘DejaVu Sans Book’)

C++ signature :

void add_face_name(mapnik::font_set {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

property name

Get/Set the name of the FontSet.

property names

List of face names belonging to a FontSet.

class mapnik._mapnik.GeometryType

Bases: Boost.Python.enum

GeometryCollection = mapnik._mapnik.GeometryType.GeometryCollection

LineString = mapnik._mapnik.GeometryType.LineString

MultiLineString = mapnik._mapnik.GeometryType.MultiLineString

MultiPoint = mapnik._mapnik.GeometryType.MultiPoint

MultiPolygon = mapnik._mapnik.GeometryType.MultiPolygon

Point = mapnik._mapnik.GeometryType.Point

Polygon = mapnik._mapnik.GeometryType.Polygon

Unknown = mapnik._mapnik.GeometryType.Unknown

names = {'GeometryCollection': mapnik._mapnik.GeometryType.GeometryCollection, 'LineString': mapnik._mapnik.GeometryType.LineString, 'MultiLineString': mapnik._mapnik.GeometryType.MultiLineString, 'MultiPoint': mapnik._mapnik.GeometryType.MultiPoint, 'MultiPolygon': mapnik._mapnik.GeometryType.MultiPolygon, 'Point': mapnik._mapnik.GeometryType.Point, 'Polygon': mapnik._mapnik.GeometryType.Polygon, 'Unknown': mapnik._mapnik.GeometryType.Unknown}

values = {0: mapnik._mapnik.GeometryType.Unknown, 1: mapnik._mapnik.GeometryType.Point, 2: mapnik._mapnik.GeometryType.LineString, 3: mapnik._mapnik.GeometryType.Polygon, 4: mapnik._mapnik.GeometryType.MultiPoint, 5: mapnik._mapnik.GeometryType.MultiLineString, 6: mapnik._mapnik.GeometryType.MultiPolygon, 7: mapnik._mapnik.GeometryType.GeometryCollection}

class mapnik._mapnik.Grid

Bases: Boost.Python.instance

This class represents a feature hitgrid.

clear((Grid)arg1) → None :

C++ signature :

void clear(mapnik::hit_grid<mapnik::gray64s_t> {lvalue})

encode((Grid)arg1[, (str)encoding='utf'[, (bool)features=True[, (int)resolution=4]]]) → dict :

Encode the grid as as optimized json

C++ signature :

boost::python::dict encode(mapnik::hit_grid<mapnik::gray64s_t> [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >=’utf’ [,bool=True [,unsigned int=4]]])

get_pixel((Grid)arg1, (int)arg2, (int)arg3) → int :

C++ signature :

long get_pixel(mapnik::hit_grid<mapnik::gray64s_t>,int,int)

height((Grid)arg1) → int :

C++ signature :

unsigned long height(mapnik::hit_grid<mapnik::gray64s_t> {lvalue})

property key

Get/Set key to be used as unique indentifier for features The value should either be __id__ to refer to the feature.id() or some globally unique integer or string attribute field

painted((Grid)arg1) → bool :

C++ signature :

bool painted(mapnik::hit_grid<mapnik::gray64s_t>)

view((Grid)arg1, (int)arg2, (int)arg3, (int)arg4, (int)arg5) → GridView :

C++ signature :

mapnik::hit_grid_view<mapnik::image<mapnik::gray64s_t> > view(mapnik::hit_grid<mapnik::gray64s_t> {lvalue},unsigned long,unsigned long,unsigned long,unsigned long)

width((Grid)arg1) → int :

C++ signature :

unsigned long width(mapnik::hit_grid<mapnik::gray64s_t> {lvalue})

class mapnik._mapnik.GridView

Bases: Boost.Python.instance

This class represents a feature hitgrid subset.

encode((GridView)arg1[, (str)encoding='utf'[, (bool)add_features=True[, (int)resolution=4]]]) → dict :

Encode the grid as as optimized json

C++ signature :

boost::python::dict encode(mapnik::hit_grid_view<mapnik::image<mapnik::gray64s_t> > [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >=’utf’ [,bool=True [,unsigned int=4]]])

height((GridView)arg1) → int :

C++ signature :

unsigned int height(mapnik::hit_grid_view<mapnik::image<mapnik::gray64s_t> > {lvalue})

width((GridView)arg1) → int :

C++ signature :

unsigned int width(mapnik::hit_grid_view<mapnik::image<mapnik::gray64s_t> > {lvalue})

class mapnik._mapnik.GroupRule

Bases: Boost.Python.instance

append((GroupRule)arg1, (Symbolizer)arg2) → None :

C++ signature :

void append(mapnik::group_rule {lvalue},mapbox::util::variant<mapnik::point_symbolizer, mapnik::line_symbolizer, mapnik::line_pattern_symbolizer, mapnik::polygon_symbolizer, mapnik::polygon_pattern_symbolizer, mapnik::raster_symbolizer, mapnik::shield_symbolizer, mapnik::text_symbolizer, mapnik::building_symbolizer, mapnik::markers_symbolizer, mapnik::group_symbolizer, mapnik::debug_symbolizer, mapnik::dot_symbolizer>)

set_filter((GroupRule)arg1, (Expression)arg2) → None :

C++ signature :

void set_filter(mapnik::group_rule {lvalue},std::shared_ptr<mapbox::util::variant<mapnik::value_null, bool, long, double, icu_66::UnicodeString, mapnik::attribute, mapnik::global_attribute, mapnik::geometry_type_attribute, mapbox::util::recursive_wrapper<mapnik::unary_node<mapnik::tags::negate> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::plus> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::minus> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::mult> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::div> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::mod> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::less> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::less_equal> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::greater> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::greater_equal> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::equal_to> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::not_equal_to> >, mapbox::util::recursive_wrapper<mapnik::unary_node<mapnik::tags::logical_not> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::logical_and> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::logical_or> >, mapbox::util::recursive_wrapper<mapnik::regex_match_node>, mapbox::util::recursive_wrapper<mapnik::regex_replace_node>, mapbox::util::recursive_wrapper<mapnik::unary_function_call>, mapbox::util::recursive_wrapper<mapnik::binary_function_call> > >)

set_repeat_key((GroupRule)arg1, (Expression)arg2) → None :

C++ signature :

void set_repeat_key(mapnik::group_rule {lvalue},std::shared_ptr<mapbox::util::variant<mapnik::value_null, bool, long, double, icu_66::UnicodeString, mapnik::attribute, mapnik::global_attribute, mapnik::geometry_type_attribute, mapbox::util::recursive_wrapper<mapnik::unary_node<mapnik::tags::negate> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::plus> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::minus> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::mult> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::div> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::mod> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::less> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::less_equal> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::greater> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::greater_equal> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::equal_to> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::not_equal_to> >, mapbox::util::recursive_wrapper<mapnik::unary_node<mapnik::tags::logical_not> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::logical_and> >, mapbox::util::recursive_wrapper<mapnik::binary_node<mapnik::tags::logical_or> >, mapbox::util::recursive_wrapper<mapnik::regex_match_node>, mapbox::util::recursive_wrapper<mapnik::regex_replace_node>, mapbox::util::recursive_wrapper<mapnik::unary_function_call>, mapbox::util::recursive_wrapper<mapnik::binary_function_call> > >)

class mapnik._mapnik.GroupSymbolizer

Bases: mapnik._SymbolizerBase

symbol()

class mapnik._mapnik.GroupSymbolizerProperties

Bases: Boost.Python.instance

add_rule((GroupSymbolizerProperties)arg1, (GroupRule)arg2) → None :

C++ signature :

void add_rule(mapnik::group_symbolizer_properties {lvalue},std::shared_ptr<mapnik::group_rule>)

set_layout((GroupSymbolizerProperties)arg1, (SimpleRowLayout)arg2) → None :

C++ signature :

void set_layout(mapnik::group_symbolizer_properties {lvalue},mapnik::simple_row_layout {lvalue})

set_layout( (GroupSymbolizerProperties)arg1, (PairLayout)arg2) -> None :

C++ signature :

void set_layout(mapnik::group_symbolizer_properties {lvalue},mapnik::pair_layout {lvalue})

class mapnik._mapnik.Image

Bases: Boost.Python.instance

This class represents a image.

apply_opacity((Image)arg1, (float)arg2) → None :

Set the opacity of the Image relative to the current alpha of each pixel.

C++ signature :

void apply_opacity(mapnik::image_any {lvalue},float)

clear((Image)arg1) → None :

C++ signature :

void clear(mapnik::image_any {lvalue})

compare((Image)self, (Image)image[, (float)threshold=0.0[, (bool)alpha=True]]) → int :

C++ signature :

unsigned long compare(mapnik::image_any,mapnik::image_any [,double=0.0 [,bool=True]])

composite((Image)self, (Image)image[, (CompositeOp)mode=mapnik._mapnik.CompositeOp.src_over[, (float)opacity=1.0[, (int)dx=0[, (int)dy=0]]]]) → None :

C++ signature :

void composite(mapnik::image_any {lvalue},mapnik::image_any {lvalue} [,mapnik::composite_mode_e=mapnik._mapnik.CompositeOp.src_over [,float=1.0 [,int=0 [,int=0]]]])

copy((Image)self, (ImageType)type[, (float)offset=0.0[, (float)scaling=1.0]]) → Image :

C++ signature :

std::shared_ptr<mapnik::image_any> copy(mapnik::image_any,mapnik::image_dtype [,double=0.0 [,double=1.0]])

demultiply((Image)arg1) → bool :

C++ signature :

bool demultiply(mapnik::image_any {lvalue})

fill((Image)arg1, (Color)arg2) → None :

C++ signature :

void fill(mapnik::image_any {lvalue},mapnik::color)

fill( (Image)arg1, (int)arg2) -> None :

C++ signature :

void fill(mapnik::image_any {lvalue},int)

fill( (Image)arg1, (float)arg2) -> None :

C++ signature :

void fill(mapnik::image_any {lvalue},double)

static frombuffer((object)arg1) → Image :

C++ signature :

std::shared_ptr<mapnik::image_any> frombuffer(_object*)

static fromstring((str)arg1) → Image :

C++ signature :

std::shared_ptr<mapnik::image_any> fromstring(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

get_pixel((Image)self, (int)x, (int)y[, (bool)get_color=False]) → object :

C++ signature :

boost::python::api::object get_pixel(mapnik::image_any,unsigned int,unsigned int [,bool=False])

get_type((Image)arg1) → int :

C++ signature :

unsigned int get_type(mapnik::image_any {lvalue})

height((Image)arg1) → int :

C++ signature :

unsigned long height(mapnik::image_any {lvalue})

is_solid((Image)arg1) → bool :

C++ signature :

bool is_solid(mapnik::image_any)

property offset

Gets or sets the offset component.

static open((str)arg1) → Image :

C++ signature :

std::shared_ptr<mapnik::image_any> open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

painted((Image)arg1) → bool :

C++ signature :

bool painted(mapnik::image_any {lvalue})

premultiplied((Image)arg1) → bool :

C++ signature :

bool premultiplied(mapnik::image_any {lvalue})

premultiply((Image)arg1) → bool :

C++ signature :

bool premultiply(mapnik::image_any {lvalue})

save((Image)arg1, (str)arg2) → None :

C++ signature :

void save(mapnik::image_any,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

save( (Image)arg1, (str)arg2, (str)arg3) -> None :

C++ signature :

void save(mapnik::image_any,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

save( (Image)arg1, (str)arg2, (str)arg3, (Palette)arg4) -> None :

C++ signature :

void save(mapnik::image_any,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,mapnik::rgba_palette)

property scaling

Gets or sets the offset component.

set_color_to_alpha((Image)arg1, (Color)arg2) → None :

Set a given color to the alpha channel of the Image

C++ signature :

void set_color_to_alpha(mapnik::image_any {lvalue},mapnik::color)

set_grayscale_to_alpha((Image)arg1) → None :

Set the grayscale values to the alpha channel of the Image

C++ signature :

void set_grayscale_to_alpha(mapnik::image_any {lvalue})

set_grayscale_to_alpha( (Image)arg1, (Color)arg2) -> None :

Set the grayscale values to the alpha channel of the Image

C++ signature :

void set_grayscale_to_alpha(mapnik::image_any {lvalue},mapnik::color)

set_pixel((Image)arg1, (int)arg2, (int)arg3, (Color)arg4) → None :

C++ signature :

void set_pixel(mapnik::image_any {lvalue},unsigned int,unsigned int,mapnik::color)

set_pixel( (Image)arg1, (int)arg2, (int)arg3, (float)arg4) -> None :

C++ signature :

void set_pixel(mapnik::image_any {lvalue},unsigned int,unsigned int,double)

set_pixel( (Image)arg1, (int)arg2, (int)arg3, (int)arg4) -> None :

C++ signature :

void set_pixel(mapnik::image_any {lvalue},unsigned int,unsigned int,int)

tostring((Image)arg1) → object :

C++ signature :

_object* tostring(mapnik::image_any)

tostring( (Image)arg1, (str)arg2) -> object :

C++ signature :

_object* tostring(mapnik::image_any,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

tostring( (Image)arg1, (str)arg2, (Palette)arg3) -> object :

C++ signature :

_object* tostring(mapnik::image_any,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,mapnik::rgba_palette)

view((Image)arg1, (int)arg2, (int)arg3, (int)arg4, (int)arg5) → ImageView :

C++ signature :

mapnik::image_view_any view(mapnik::image_any,unsigned int,unsigned int,unsigned int,unsigned int)

width((Image)arg1) → int :

C++ signature :

unsigned long width(mapnik::image_any {lvalue})

class mapnik._mapnik.ImageType

Bases: Boost.Python.enum

gray16 = mapnik._mapnik.ImageType.gray16

gray16s = mapnik._mapnik.ImageType.gray16s

gray32 = mapnik._mapnik.ImageType.gray32

gray32f = mapnik._mapnik.ImageType.gray32f

gray32s = mapnik._mapnik.ImageType.gray32s

gray64 = mapnik._mapnik.ImageType.gray64

gray64f = mapnik._mapnik.ImageType.gray64f

gray64s = mapnik._mapnik.ImageType.gray64s

gray8 = mapnik._mapnik.ImageType.gray8

gray8s = mapnik._mapnik.ImageType.gray8s

names = {'gray16': mapnik._mapnik.ImageType.gray16, 'gray16s': mapnik._mapnik.ImageType.gray16s, 'gray32': mapnik._mapnik.ImageType.gray32, 'gray32f': mapnik._mapnik.ImageType.gray32f, 'gray32s': mapnik._mapnik.ImageType.gray32s, 'gray64': mapnik._mapnik.ImageType.gray64, 'gray64f': mapnik._mapnik.ImageType.gray64f, 'gray64s': mapnik._mapnik.ImageType.gray64s, 'gray8': mapnik._mapnik.ImageType.gray8, 'gray8s': mapnik._mapnik.ImageType.gray8s, 'rgba8': mapnik._mapnik.ImageType.rgba8}

rgba8 = mapnik._mapnik.ImageType.rgba8

values = {0: mapnik._mapnik.ImageType.rgba8, 1: mapnik._mapnik.ImageType.gray8, 2: mapnik._mapnik.ImageType.gray8s, 3: mapnik._mapnik.ImageType.gray16, 4: mapnik._mapnik.ImageType.gray16s, 5: mapnik._mapnik.ImageType.gray32, 6: mapnik._mapnik.ImageType.gray32s, 7: mapnik._mapnik.ImageType.gray32f, 8: mapnik._mapnik.ImageType.gray64, 9: mapnik._mapnik.ImageType.gray64s, 10: mapnik._mapnik.ImageType.gray64f}

class mapnik._mapnik.ImageView

Bases: Boost.Python.instance

A view into an image.

height((ImageView)arg1) → int :

C++ signature :

unsigned long height(mapnik::image_view_any {lvalue})

is_solid((ImageView)arg1) → bool :

C++ signature :

bool is_solid(mapnik::image_view_any)

save((ImageView)arg1, (str)arg2) → None :

C++ signature :

void save(mapnik::image_view_any,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

save( (ImageView)arg1, (str)arg2, (str)arg3) -> None :

C++ signature :

void save(mapnik::image_view_any,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

save( (ImageView)arg1, (str)arg2, (str)arg3, (Palette)arg4) -> None :

C++ signature :

void save(mapnik::image_view_any,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,mapnik::rgba_palette)

tostring((ImageView)arg1) → object :

C++ signature :

_object* tostring(mapnik::image_view_any)

tostring( (ImageView)arg1, (str)arg2) -> object :

C++ signature :

_object* tostring(mapnik::image_view_any,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

tostring( (ImageView)arg1, (str)arg2, (Palette)arg3) -> object :

C++ signature :

_object* tostring(mapnik::image_view_any,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,mapnik::rgba_palette)

width((ImageView)arg1) → int :

C++ signature :

unsigned long width(mapnik::image_view_any {lvalue})

class mapnik._mapnik.LabelCollisionDetector

Bases: Boost.Python.instance

Object to detect collisions between labels, used in the rendering process.

boxes((LabelCollisionDetector)arg1) → list :

Returns a list of all the label boxes inside the detector.

C++ signature :

boost::python::list boxes(std::shared_ptr<mapnik::label_collision_detector4>)

extent((LabelCollisionDetector)arg1) → Box2d :

Returns the total extent (bounding box) of all labels inside the detector.

Example: >>> detector.extent() Box2d(573.252589209,494.789179821,584.261023823,496.83610261)

C++ signature :

mapnik::box2d<double> extent(mapnik::label_collision_detector4 {lvalue})

insert((LabelCollisionDetector)arg1, (Box2d)arg2) → None :

Insert a 2d box into the collision detector. This can be used to ensure that some space is left clear on the map for later overdrawing, for example by non-Mapnik processes.

Example: >>> m = Map(size_x, size_y) >>> detector = mapnik.LabelCollisionDetector(m)>>> detector.insert(mapnik.Box2d(196, 254, 291, 389))

C++ signature :

void insert(mapnik::label_collision_detector4 {lvalue},mapnik::box2d<double>)

class mapnik._mapnik.Layer

Bases: Boost.Python.instance

A Mapnik map layer.

property active

Get/Set whether this layer is active and will be rendered (same as status property).

Usage: >>> from mapnik import Layer >>> lyr = Layer(‘My Layer’,’+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs’) >>> lyr.active True # Active by default >>> lyr.active = False # set False to disable layer rendering >>> lyr.active False

property buffer_size

Get/Set the size of buffer around layer in pixels.

Usage: >>> print(l.buffer_size) None # None by default >>> l.buffer_size = 2 >>> l.buffer_size 2

property cache_features

Get/Set whether features should be cached during rendering if used between multiple styles

Usage: >>> lyr.cache_features False # False by default >>> lyr.cache_features = True # set to True to enable feature caching

property clear_label_cache

Get/Set whether to clear the label collision detector cache for this layer during rendering

Usage: >>> lyr.clear_label_cache False # False by default, meaning label positions from other layers will impact placement >>> lyr.clear_label_cache = True # set to True to clear the label collision detector cache

property datasource

The datasource attached to this layer.

Usage: >>> from mapnik import Layer, Datasource >>> lyr = Layer(‘My Layer’,’+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs’) >>> lyr.datasource = Datasource(type=’shape’,file=’world_borders’) >>> lyr.datasource <mapnik.Datasource object at 0x65470>

envelope((Layer)arg1) → Box2d :

Return the geographic envelope/bounding box. Determined based on the layer datasource.

Usage: >>> from mapnik import Layer >>> lyr = Layer(‘My Layer’,’+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs’) >>> lyr.envelope() box2d(-1.0,-1.0,0.0,0.0) # default until a datasource is loaded

C++ signature :

mapnik::box2d<double> envelope(mapnik::layer {lvalue})

property group_by

Get/Set the optional layer group name.

More details at https://github.com/mapnik/mapnik/wiki/Grouped-rendering:

property maximum_extent

The maximum extent of the map.

Usage: >>> m.maximum_extent = Box2d(-180,-90,180,90)

property maximum_scale_denominator

Get/Set the maximum scale denominator of the layer.

Usage: >>> from mapnik import Layer >>> lyr = Layer(‘My Layer’,’+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs’) >>> lyr.maximum_scale_denominator 1.7976931348623157e+308 # default is the numerical maximum >>> lyr.maximum_scale_denominator = 1.0/1000000 >>> lyr.maximum_scale_denominator 9.9999999999999995e-07

property minimum_scale_denominator

Get/Set the minimum scale denominator of the layer.

Usage: >>> from mapnik import Layer >>> lyr = Layer(‘My Layer’,’+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs’) >>> lyr.minimum_scale_denominator # default is 0 0.0 >>> lyr.minimum_scale_denominator = 1.0/1000000 >>> lyr.minimum_scale_denominator 9.9999999999999995e-07

property name

Get/Set the name of the layer.

Usage: >>> from mapnik import Layer >>> lyr = Layer(‘My Layer’,’+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs’) >>> lyr.name ‘My Layer’ >>> lyr.name = ‘New Name’ >>> lyr.name ‘New Name’

property queryable

Get/Set whether this layer is queryable.

Usage: >>> from mapnik import layer >>> lyr = layer(‘My layer’,’+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs’) >>> lyr.queryable False # Not queryable by default >>> lyr.queryable = True >>> lyr.queryable True

property srs

Get/Set the SRS of the layer.

Usage: >>> from mapnik import layer >>> lyr = layer(‘My layer’,’+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs’) >>> lyr.srs ‘+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs’ # The default srs if not initialized with custom srs >>> # set to google mercator with Proj.4 literal … >>> lyr.srs = ‘+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0.0 +k=1.0 +units=m +nadgrids=@null +wktext +no_defs +over’

property status

Get/Set whether this layer is active and will be rendered.

Usage: >>> from mapnik import Layer >>> lyr = Layer(‘My Layer’,’+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs’) >>> lyr.status True # Active by default >>> lyr.status = False # set False to disable layer rendering >>> lyr.status False

property styles

The styles list attached to this layer.

Usage: >>> from mapnik import layer >>> lyr = layer(‘My layer’,’+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs’) >>> lyr.styles <mapnik._mapnik.Names object at 0x6d3e8> >>> len(lyr.styles) 0

# no styles until you append them

lyr.styles.append(‘My Style’) # mapnik uses named styles for flexibility >>> len(lyr.styles) 1 >>> lyr.styles[0] ‘My Style’

visible((Layer)arg1, (float)arg2) → bool :

Return True if this layer’s data is active and visible at a given scale_denom.

Otherwise returns False. Accepts a scale value as an integer or float input. Will return False if:

scale_denom >= minimum_scale_denominator - 1e-6 or: scale_denom < maximum_scale_denominator + 1e-6

Usage: >>> from mapnik import Layer >>> lyr = Layer(‘My Layer’,’+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs’) >>> lyr.visible(1.0/1000000) True >>> lyr.active = False >>> lyr.visible(1.0/1000000) False

C++ signature :

bool visible(mapnik::layer {lvalue},double)

class mapnik._mapnik.Layers

Bases: Boost.Python.instance

append((Layers)arg1, (object)arg2) → None :

C++ signature :

void append(std::vector<mapnik::layer, std::allocator<mapnik::layer> > {lvalue},boost::python::api::object)

extend((Layers)arg1, (object)arg2) → None :

C++ signature :

void extend(std::vector<mapnik::layer, std::allocator<mapnik::layer> > {lvalue},boost::python::api::object)

class mapnik._mapnik.LinePatternSymbolizer

Bases: mapnik._SymbolizerBase

symbol()

class mapnik._mapnik.LineString

Bases: Boost.Python.instance

add_coord((LineString)arg1, (float)arg2, (float)arg3) → None :

Adds coord

C++ signature :

void add_coord(mapnik::geometry::line_string<double> {lvalue},double,double)

is_simple((Geometry)arg1) → bool :

C++ signature :

bool is_simple(mapnik::geometry::geometry<double>)

is_valid((Geometry)arg1) → bool :

C++ signature :

bool is_valid(mapnik::geometry::geometry<double>)

to_geojson((Geometry)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > to_geojson(mapnik::geometry::geometry<double>)

to_wkb((Geometry)arg1, (wkbByteOrder)arg2) → object :

C++ signature :

_object* to_wkb(mapnik::geometry::geometry<double>,mapnik::wkbByteOrder)

to_wkt((Geometry)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > to_wkt(mapnik::geometry::geometry<double>)

class mapnik._mapnik.LineSymbolizer

Bases: mapnik._SymbolizerBase

symbol()

class mapnik._mapnik.LinearRing

Bases: Boost.Python.instance

add_coord((LinearRing)arg1, (float)arg2, (float)arg3) → None :

Adds coord

C++ signature :

void add_coord(mapnik::geometry::linear_ring<double> {lvalue},double,double)

class mapnik._mapnik.Map

Bases: Boost.Python.instance

The map object.

append_fontset((Map)arg1, (str)arg2, (FontSet)fontset) → None :

Add a FontSet to the map.

C++ signature :

void append_fontset(mapnik::Map {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,mapnik::font_set)

append_style((Map)arg1, (str)style_name, (Style)style_object) → None :

Insert a Mapnik Style onto the map by appending it.

Usage: >>> sty <mapnik._mapnik.Style object at 0x6a330> >>> m.append_style(‘Style Name’, sty) True # style object added to map by name >>> m.append_style(‘Style Name’, sty) False # you can only append styles with unique names

C++ signature :

void append_style(mapnik::Map {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,mapnik::feature_type_style)

property aspect_fix_mode

Get/Set aspect fix mode. Usage:

>>> m.aspect_fix_mode = aspect_fix_mode.GROW_BBOX

property background

The background color of the map (same as background_color property).

Usage: >>> m.background = Color(‘steelblue’)

property background_color

The background color of the map.

Usage: >>> m.background_color = Color(‘steelblue’)

property background_image

The optional background image of the map.

Usage: >>> m.background_image = ‘/path/to/image.png’

property background_image_comp_op

The background image compositing operation.

Usage: >>> m.background_image_comp_op = mapnik.CompositeOp.src_over

property background_image_opacity

The background image opacity.

Usage: >>> m.background_image_opacity = 1.0

property base

The base path of the map where any files using relative paths will be interpreted as relative to.

Usage: >>> m.base_path = ‘.’

property buffer_size

Get/Set the size of buffer around map in pixels.

Usage: >>> m.buffer_size 0 # zero by default >>> m.buffer_size = 2 >>> m.buffer_size 2

buffered_envelope((Map)arg1) → Box2d :

Get the Box2d() of the Map given the Map.buffer_size.

Usage: >>> m = Map(600,400) >>> m.envelope() Box2d(-1.0,-1.0,0.0,0.0) >>> m.buffered_envelope() Box2d(-1.0,-1.0,0.0,0.0) >>> m.buffer_size = 1 >>> m.buffered_envelope() Box2d(-1.02222222222,-1.02222222222,0.0222222222222,0.0222222222222)

C++ signature :

mapnik::box2d<double> buffered_envelope(mapnik::Map {lvalue})

envelope((Map)arg1) → Box2d :

Return the Map Box2d object and print the string representation of the current extent of the map.

Usage: >>> m.envelope() Box2d(-0.185833333333,-0.96,0.189166666667,-0.71) >>> dir(m.envelope()) …’center’, ‘contains’, ‘expand_to_include’, ‘forward’, …’height’, ‘intersect’, ‘intersects’, ‘inverse’, ‘maxx’, …’maxy’, ‘minx’, ‘miny’, ‘width’

C++ signature :

mapnik::box2d<double> envelope(mapnik::Map {lvalue})

find_fontset((Map)arg1, (str)name) → FontSet :

Find a fontset by name.

C++ signature :

mapnik::font_set find_fontset(mapnik::Map,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

find_style((Map)arg1, (str)name) → Style :

Query the Map for a style by name and return a style object if found or raise KeyError style if not found.

Usage: >>> m.find_style(‘Style Name’) <mapnik._mapnik.Style object at 0x654f0>

C++ signature :

mapnik::feature_type_style find_style(mapnik::Map,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

property height

Get/Set the height of the map in pixels. Minimum settable size is 16 pixels.

Usage: >>> m.height 400 >>> m.height = 600 >>> m.height 600

property layers

The list of map layers.

Usage: >>> m.layers <mapnik._mapnik.layers object at 0x6d458>>>> m.layers[0] <mapnik._mapnik.layer object at 0x5fe130>

property maximum_extent

The maximum extent of the map.

Usage: >>> m.maximum_extent = Box2d(-180,-90,180,90)

pan((Map)arg1, (int)x, (int)y) → None :

Set the Map center at a given x,y location as integers in the coordinates of the pixmap or map surface.

Usage: >>> m = Map(600,400) >>> m.envelope().center() Coord(-0.5,-0.5) # default Map center >>> m.pan(-1,-1) >>> m.envelope().center() Coord(0.00166666666667,-0.835)

C++ signature :

void pan(mapnik::Map {lvalue},int,int)

pan_and_zoom((Map)arg1, (int)x, (int)y, (float)factor) → None :

Set the Map center at a given x,y location and zoom factor as a float.

Usage: >>> m = Map(600,400) >>> m.envelope().center() Coord(-0.5,-0.5) # default Map center >>> m.scale() -0.0016666666666666668 >>> m.pan_and_zoom(-1,-1,0.25) >>> m.scale() 0.00062500000000000001

C++ signature :

void pan_and_zoom(mapnik::Map {lvalue},int,int,double)

property parameters

TODO

query_map_point((Map)arg1, (int)layer_idx, (float)pixel_x, (float)pixel_y) → Featureset :

Query a Map Layer (by layer index) for features intersecting the given x,y location in the pixel coordinates of the rendered map image. Layer index starts at 0 (first layer in map). Will return a Mapnik Featureset if successful otherwise will return None.

Usage: >>> featureset = m.query_map_point(0,200,200) >>> featureset <mapnik._mapnik.Featureset object at 0x23b0b0> >>> featureset.features >>> [<mapnik.Feature object at 0x3995630>]

C++ signature :

std::shared_ptr<mapnik::Featureset> query_map_point(mapnik::Map,int,double,double)

query_point((Map)arg1, (int)layer idx, (float)x, (float)y) → Featureset :

Query a Map Layer (by layer index) for features intersecting the given x,y location in the coordinates of map projection. Layer index starts at 0 (first layer in map). Will return a Mapnik Featureset if successful otherwise will return None.

Usage: >>> featureset = m.query_point(0,-122,48) >>> featureset <mapnik._mapnik.Featureset object at 0x23b0b0> >>> featureset.features >>> [<mapnik.Feature object at 0x3995630>]

C++ signature :

std::shared_ptr<mapnik::Featureset> query_point(mapnik::Map,int,double,double)

remove_all((Map)arg1) → None :

Remove all Mapnik Styles and layers from the Map.

Usage: >>> m.remove_all()

C++ signature :

void remove_all(mapnik::Map {lvalue})

remove_style((Map)arg1, (str)style_name) → None :

Remove a Mapnik Style from the map.

Usage: >>> m.remove_style(‘Style Name’)

C++ signature :

void remove_style(mapnik::Map {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

resize((Map)arg1, (int)width, (int)height) → None :

Resize a Mapnik Map.

Usage: >>> m.resize(64,64)

C++ signature :

void resize(mapnik::Map {lvalue},unsigned int,unsigned int)

scale((Map)arg1) → float :

Return the Map Scale. Usage:

>>> m.scale()

C++ signature :

double scale(mapnik::Map {lvalue})

scale_denominator((Map)arg1) → float :

Return the Map Scale Denominator. Usage:

>>> m.scale_denominator()

C++ signature :

double scale_denominator(mapnik::Map {lvalue})

property srs

Spatial reference in Proj.4 format. Either an epsg code or proj literal. For example, a proj literal:

‘+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs’

and a proj epsg code:

‘+init=epsg:4326’

Note: using epsg codes requires the installation of the Proj.4 ‘epsg’ data file normally found in ‘/usr/local/share/proj’

Usage: >>> m.srs ‘+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs’ # The default srs if not initialized with custom srs >>> # set to google mercator with Proj.4 literal … >>> m.srs = ‘+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0.0 +k=1.0 +units=m +nadgrids=@null +wktext +no_defs +over’

property styles

view_transform((Map)arg1) → ViewTransform :

Return the map ViewTransform object which is used internally to convert between geographic coordinates and screen coordinates.

Usage: >>> m.view_transform()

C++ signature :

mapnik::view_transform view_transform(mapnik::Map {lvalue})

property width

Get/Set the width of the map in pixels. Minimum settable size is 16 pixels.

Usage: >>> m.width 600 >>> m.width = 800 >>> m.width 800

zoom((Map)arg1, (float)factor) → None :

Zoom in or out by a given factor. positive number larger than 1, zooms out positive number smaller than 1, zooms in

Usage:

>>> m.zoom(0.25)

C++ signature :

void zoom(mapnik::Map {lvalue},double)

zoom_all((Map)arg1) → None :

Set the geographical extent of the map to the combined extents of all active layers.

Usage: >>> m.zoom_all()

C++ signature :

void zoom_all(mapnik::Map {lvalue})

zoom_to_box((Map)arg1, (Box2d)Boxd2) → None :

Set the geographical extent of the map by specifying a Mapnik Box2d.

Usage: >>> extent = Box2d(-180.0, -90.0, 180.0, 90.0) >>> m.zoom_to_box(extent)

C++ signature :

void zoom_to_box(mapnik::Map {lvalue},mapnik::box2d<double>)

class mapnik._mapnik.MarkersSymbolizer

Bases: mapnik._SymbolizerBase

symbol()

class mapnik._mapnik.MemoryDatasourceBase

Bases: mapnik._Datasource

add_feature((MemoryDatasourceBase)arg1, (Feature)arg2) → None :

Adds a Feature: >>> ms = MemoryDatasource() >>> feature = Feature(1) >>> ms.add_feature(Feature(1))

C++ signature :

void add_feature(mapnik::memory_datasource {lvalue},std::shared_ptr<mapnik::feature_impl>)

num_features((MemoryDatasourceBase)arg1) → int :

C++ signature :

unsigned long num_features(mapnik::memory_datasource {lvalue})

class mapnik._mapnik.Names

Bases: Boost.Python.instance

append((Names)arg1, (object)arg2) → None :

C++ signature :

void append(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > {lvalue},boost::python::api::object)

extend((Names)arg1, (object)arg2) → None :

C++ signature :

void extend(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > {lvalue},boost::python::api::object)

class mapnik._mapnik.NumericWrapper

Bases: Boost.Python.instance

class mapnik._mapnik.PairLayout

Bases: Boost.Python.instance

item_margin((SimpleRowLayout)arg1) → float :

C++ signature :

double item_margin(mapnik::simple_row_layout {lvalue})

max_difference((PairLayout)arg1) → float :

C++ signature :

double max_difference(mapnik::pair_layout {lvalue})

set_item_margin((SimpleRowLayout)arg1, (float)arg2) → None :

C++ signature :

void set_item_margin(mapnik::simple_row_layout {lvalue},double)

set_max_difference((PairLayout)arg1, (float)arg2) → None :

C++ signature :

void set_max_difference(mapnik::pair_layout {lvalue},double)

class mapnik._mapnik.Palette

Bases: Boost.Python.instance

to_string((Palette)arg1) → str :

Returns the palette as a string.

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > to_string(mapnik::rgba_palette {lvalue})

class mapnik._mapnik.Parameter

Bases: Boost.Python.instance

class mapnik._mapnik.Parameters

Bases: Boost.Python.instance

append((Parameters)arg1, (Parameter)arg2) → None :

C++ signature :

void append(mapnik::parameters {lvalue},std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, mapnik::value_holder>)

get((Parameters)arg1, (str)arg2) → object :

C++ signature :

mapnik::value_holder get(mapnik::parameters,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

iteritems((object)arg1) → object :

C++ signature :

boost::python::objects::iterator_range<boost::python::return_value_policy<boost::python::return_by_value, boost::python::default_call_policies>, std::_Rb_tree_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, mapnik::value_holder> > > iteritems(boost::python::back_reference<mapnik::parameters&>)

mapnik._mapnik.PathExpression((str)expr) → PathExpression :

PathExpression string

C++ signature :

std::shared_ptr<std::vector<mapbox::util::variant<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, mapnik::attribute>, std::allocator<mapbox::util::variant<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, mapnik::attribute> > > > PathExpression(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

class mapnik._mapnik.Point

Bases: Boost.Python.instance

is_simple((Geometry)arg1) → bool :

C++ signature :

bool is_simple(mapnik::geometry::geometry<double>)

is_valid((Geometry)arg1) → bool :

C++ signature :

bool is_valid(mapnik::geometry::geometry<double>)

to_geojson((Geometry)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > to_geojson(mapnik::geometry::geometry<double>)

to_wkb((Geometry)arg1, (wkbByteOrder)arg2) → object :

C++ signature :

_object* to_wkb(mapnik::geometry::geometry<double>,mapnik::wkbByteOrder)

to_wkt((Geometry)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > to_wkt(mapnik::geometry::geometry<double>)

property x

X coordinate

property y

Y coordinate

class mapnik._mapnik.PointSymbolizer

Bases: mapnik._SymbolizerBase

symbol()

class mapnik._mapnik.Polygon

Bases: Boost.Python.instance

add_hole((Polygon)arg1, (LinearRing)arg2) → None :

Add interior ring

C++ signature :

void add_hole(mapnik::geometry::polygon<double, mapnik::geometry::rings_container> {lvalue},mapnik::geometry::linear_ring<double>)

property exterior_ring

Exterior ring

is_simple((Geometry)arg1) → bool :

C++ signature :

bool is_simple(mapnik::geometry::geometry<double>)

is_valid((Geometry)arg1) → bool :

C++ signature :

bool is_valid(mapnik::geometry::geometry<double>)

num_rings((Polygon)arg1, (LinearRing)arg2) → None :

Number of rings (at least 1)

C++ signature :

void num_rings(mapnik::geometry::polygon<double, mapnik::geometry::rings_container> {lvalue},mapnik::geometry::linear_ring<double>)

to_geojson((Geometry)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > to_geojson(mapnik::geometry::geometry<double>)

to_wkb((Geometry)arg1, (wkbByteOrder)arg2) → object :

C++ signature :

_object* to_wkb(mapnik::geometry::geometry<double>,mapnik::wkbByteOrder)

to_wkt((Geometry)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > to_wkt(mapnik::geometry::geometry<double>)

class mapnik._mapnik.PolygonPatternSymbolizer

Bases: Boost.Python.instance

symbol()

class mapnik._mapnik.PolygonSymbolizer

Bases: mapnik._SymbolizerBase

symbol()

class mapnik._mapnik.ProjTransform

Bases: Boost.Python.instance

backward((ProjTransform)arg1, (Coord)arg2) → Coord :

C++ signature :

mapnik::coord<double, 2> backward(mapnik::proj_transform {lvalue},mapnik::coord<double, 2>)

backward( (ProjTransform)arg1, (Box2d)arg2) -> Box2d :

C++ signature :

mapnik::box2d<double> backward(mapnik::proj_transform {lvalue},mapnik::box2d<double>)

backward( (ProjTransform)arg1, (Box2d)arg2, (int)arg3) -> Box2d :

C++ signature :

mapnik::box2d<double> backward(mapnik::proj_transform {lvalue},mapnik::box2d<double>,unsigned int)

forward((ProjTransform)arg1, (Coord)arg2) → Coord :

C++ signature :

mapnik::coord<double, 2> forward(mapnik::proj_transform {lvalue},mapnik::coord<double, 2>)

forward( (ProjTransform)arg1, (Box2d)arg2) -> Box2d :

C++ signature :

mapnik::box2d<double> forward(mapnik::proj_transform {lvalue},mapnik::box2d<double>)

forward( (ProjTransform)arg1, (Box2d)arg2, (int)arg3) -> Box2d :

C++ signature :

mapnik::box2d<double> forward(mapnik::proj_transform {lvalue},mapnik::box2d<double>,unsigned int)

class mapnik._mapnik.Query

Bases: Boost.Python.instance

a spatial query data object

add_property_name((Query)arg1, (str)arg2) → None :

C++ signature :

void add_property_name(mapnik::query {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

property bbox

property property_names

property resolution

set_variables((Query)arg1, (dict)arg2) → None :

C++ signature :

void set_variables(mapnik::query {lvalue},boost::python::dict)

class mapnik._mapnik.RasterColorizer

Bases: Boost.Python.instance

A Raster Colorizer object.

add_stop((RasterColorizer)arg1, (ColorizerStop)ColorizerStop) → None :

Add a colorizer stop to the raster colorizer.

Usage: >>> colorizer = mapnik.RasterColorizer() >>> color = mapnik.Color(“#0044cc”) >>> stop = mapnik.ColorizerStop(3, mapnik.COLORIZER_INHERIT, color) >>> colorizer.add_stop(stop)

C++ signature :

void add_stop(std::shared_ptr<mapnik::raster_colorizer> {lvalue},mapnik::colorizer_stop {lvalue})

add_stop( (RasterColorizer)arg1, (float)value) -> None :

Add a colorizer stop to the raster colorizer, using the default mode and color.

Usage: >>> default_color = mapnik.Color(“#0044cc”) >>> colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_LINEAR, default_color) >>> colorizer.add_stop(100)

C++ signature :

void add_stop(std::shared_ptr<mapnik::raster_colorizer> {lvalue},float)

add_stop( (RasterColorizer)arg1, (float)arg2, (Color)value) -> None :

Add a colorizer stop to the raster colorizer, using the default mode.

Usage: >>> default_color = mapnik.Color(“#0044cc”) >>> colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_LINEAR, default_color) >>> colorizer.add_stop(100, mapnik.Color(“#123456”))

C++ signature :

void add_stop(std::shared_ptr<mapnik::raster_colorizer> {lvalue},float,mapnik::color)

add_stop( (RasterColorizer)arg1, (float)arg2, (ColorizerMode)value) -> None :

Add a colorizer stop to the raster colorizer, using the default color.

Usage: >>> default_color = mapnik.Color(“#0044cc”) >>> colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_LINEAR, default_color) >>> colorizer.add_stop(100, mapnik.COLORIZER_EXACT)

C++ signature :

void add_stop(std::shared_ptr<mapnik::raster_colorizer> {lvalue},float,mapnik::colorizer_mode_enum)

add_stop( (RasterColorizer)arg1, (float)arg2, (ColorizerMode)arg3, (Color)value) -> None :

Add a colorizer stop to the raster colorizer.

Usage: >>> default_color = mapnik.Color(“#0044cc”) >>> colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_LINEAR, default_color) >>> colorizer.add_stop(100, mapnik.COLORIZER_DISCRETE, mapnik.Color(“#112233”))

C++ signature :

void add_stop(std::shared_ptr<mapnik::raster_colorizer> {lvalue},float,mapnik::colorizer_mode_enum,mapnik::color)

property default_color

The default color for stops added without a color (mapnik.Color).

property default_mode

The default mode (mapnik.ColorizerMode).

If a stop is added without a mode, then it will inherit this default mode

property epsilon

Comparison epsilon value for exact mode

When comparing values in exact mode, values need only be within epsilon to match.

get_color((RasterColorizer)arg1, (float)arg2) → Color :

Get the color assigned to a certain value in raster data.

Usage: >>> colorizer = mapnik.RasterColorizer() >>> color = mapnik.Color(“#0044cc”) >>> colorizer.add_stop(0, mapnik.COLORIZER_DISCRETE, mapnik.Color(“#000000”)) >>> colorizer.add_stop(100, mapnik.COLORIZER_DISCRETE, mapnik.Color(“#0E0A06”)) >>> colorizer.get_color(50) Color(‘#070503’)

C++ signature :

mapnik::color get_color(std::shared_ptr<mapnik::raster_colorizer> {lvalue},float)

property stops

The list of stops this RasterColorizer contains

class mapnik._mapnik.RasterSymbolizer

Bases: mapnik._SymbolizerBase

symbol()

class mapnik._mapnik.Rule

Bases: Boost.Python.instance

active((Rule)arg1, (float)arg2) → bool :

C++ signature :

bool active(mapnik::rule {lvalue},double)

property copy_symbols

property filter

has_also((Rule)arg1) → bool :

C++ signature :

bool has_also(mapnik::rule {lvalue})

has_else((Rule)arg1) → bool :

C++ signature :

bool has_else(mapnik::rule {lvalue})

property max_scale

property min_scale

property name

set_also((Rule)arg1, (bool)arg2) → None :

C++ signature :

void set_also(mapnik::rule {lvalue},bool)

set_else((Rule)arg1, (bool)arg2) → None :

C++ signature :

void set_else(mapnik::rule {lvalue},bool)

property symbols

class mapnik._mapnik.Rules

Bases: Boost.Python.instance

append((Rules)arg1, (object)arg2) → None :

C++ signature :

void append(std::vector<mapnik::rule, std::allocator<mapnik::rule> > {lvalue},boost::python::api::object)

extend((Rules)arg1, (object)arg2) → None :

C++ signature :

void extend(std::vector<mapnik::rule, std::allocator<mapnik::rule> > {lvalue},boost::python::api::object)

class mapnik._mapnik.ShieldSymbolizer

Bases: mapnik._TextSymbolizer

symbol()

class mapnik._mapnik.SimpleRowLayout

Bases: Boost.Python.instance

item_margin((SimpleRowLayout)arg1) → float :

C++ signature :

double item_margin(mapnik::simple_row_layout {lvalue})

set_item_margin((SimpleRowLayout)arg1, (float)arg2) → None :

C++ signature :

void set_item_margin(mapnik::simple_row_layout {lvalue},double)

class mapnik._mapnik.Singleton

Bases: Boost.Python.instance

static instance() → logger :

C++ signature :

mapnik::logger {lvalue} instance()

class mapnik._mapnik.Style

Bases: Boost.Python.instance

property comp_op

Set/get the comp-op (composite operation) of the style

property filter_mode

Set/get the filter mode of the style

property image_filters

Set/get the comp-op (composite operation) of the style

property image_filters_inflate

Set/get the image_filters_inflate property of the style

property opacity

Set/get the opacity of the style

property rules

List of rules belonging to a style as rule objects.

Usage: >>> for r in m.find_style(‘style 1’).rules: >>> print r <mapnik._mapnik.Rule object at 0x100549910> <mapnik._mapnik.Rule object at 0x100549980>

class mapnik._mapnik.StyleRange

Bases: Boost.Python.instance

class mapnik._mapnik.Symbolizer

Bases: Boost.Python.instance

extract((Symbolizer)arg1) → object :

C++ signature :

boost::python::api::object extract(mapbox::util::variant<mapnik::point_symbolizer, mapnik::line_symbolizer, mapnik::line_pattern_symbolizer, mapnik::polygon_symbolizer, mapnik::polygon_pattern_symbolizer, mapnik::raster_symbolizer, mapnik::shield_symbolizer, mapnik::text_symbolizer, mapnik::building_symbolizer, mapnik::markers_symbolizer, mapnik::group_symbolizer, mapnik::debug_symbolizer, mapnik::dot_symbolizer>)

symbol()

type((Symbolizer)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > type(mapbox::util::variant<mapnik::point_symbolizer, mapnik::line_symbolizer, mapnik::line_pattern_symbolizer, mapnik::polygon_symbolizer, mapnik::polygon_pattern_symbolizer, mapnik::raster_symbolizer, mapnik::shield_symbolizer, mapnik::text_symbolizer, mapnik::building_symbolizer, mapnik::markers_symbolizer, mapnik::group_symbolizer, mapnik::debug_symbolizer, mapnik::dot_symbolizer>)

class mapnik._mapnik.Symbolizers

Bases: Boost.Python.instance

append((Symbolizers)arg1, (object)arg2) → None :

C++ signature :

void append(std::vector<mapbox::util::variant<mapnik::point_symbolizer, mapnik::line_symbolizer, mapnik::line_pattern_symbolizer, mapnik::polygon_symbolizer, mapnik::polygon_pattern_symbolizer, mapnik::raster_symbolizer, mapnik::shield_symbolizer, mapnik::text_symbolizer, mapnik::building_symbolizer, mapnik::markers_symbolizer, mapnik::group_symbolizer, mapnik::debug_symbolizer, mapnik::dot_symbolizer>, std::allocator<mapbox::util::variant<mapnik::point_symbolizer, mapnik::line_symbolizer, mapnik::line_pattern_symbolizer, mapnik::polygon_symbolizer, mapnik::polygon_pattern_symbolizer, mapnik::raster_symbolizer, mapnik::shield_symbolizer, mapnik::text_symbolizer, mapnik::building_symbolizer, mapnik::markers_symbolizer, mapnik::group_symbolizer, mapnik::debug_symbolizer, mapnik::dot_symbolizer> > > {lvalue},boost::python::api::object)

extend((Symbolizers)arg1, (object)arg2) → None :

C++ signature :

void extend(std::vector<mapbox::util::variant<mapnik::point_symbolizer, mapnik::line_symbolizer, mapnik::line_pattern_symbolizer, mapnik::polygon_symbolizer, mapnik::polygon_pattern_symbolizer, mapnik::raster_symbolizer, mapnik::shield_symbolizer, mapnik::text_symbolizer, mapnik::building_symbolizer, mapnik::markers_symbolizer, mapnik::group_symbolizer, mapnik::debug_symbolizer, mapnik::dot_symbolizer>, std::allocator<mapbox::util::variant<mapnik::point_symbolizer, mapnik::line_symbolizer, mapnik::line_pattern_symbolizer, mapnik::polygon_symbolizer, mapnik::polygon_pattern_symbolizer, mapnik::raster_symbolizer, mapnik::shield_symbolizer, mapnik::text_symbolizer, mapnik::building_symbolizer, mapnik::markers_symbolizer, mapnik::group_symbolizer, mapnik::debug_symbolizer, mapnik::dot_symbolizer> > > {lvalue},boost::python::api::object)

class mapnik._mapnik.ViewTransform

Bases: Boost.Python.instance

backward((ViewTransform)arg1, (Coord)arg2) → Coord :

C++ signature :

mapnik::coord<double, 2> backward(mapnik::view_transform,mapnik::coord<double, 2>)

backward( (ViewTransform)arg1, (Box2d)arg2) -> Box2d :

C++ signature :

mapnik::box2d<double> backward(mapnik::view_transform,mapnik::box2d<double>)

forward((ViewTransform)arg1, (Coord)arg2) → Coord :

C++ signature :

mapnik::coord<double, 2> forward(mapnik::view_transform,mapnik::coord<double, 2>)

forward( (ViewTransform)arg1, (Box2d)arg2) -> Box2d :

C++ signature :

mapnik::box2d<double> forward(mapnik::view_transform,mapnik::box2d<double>)

scale_x((ViewTransform)arg1) → float :

C++ signature :

double scale_x(mapnik::view_transform {lvalue})

scale_y((ViewTransform)arg1) → float :

C++ signature :

double scale_y(mapnik::view_transform {lvalue})

class mapnik._mapnik.aspect_fix_mode

Bases: Boost.Python.enum

ADJUST_BBOX_HEIGHT = mapnik._mapnik.aspect_fix_mode.ADJUST_BBOX_HEIGHT

ADJUST_BBOX_WIDTH = mapnik._mapnik.aspect_fix_mode.ADJUST_BBOX_WIDTH

ADJUST_CANVAS_HEIGHT = mapnik._mapnik.aspect_fix_mode.ADJUST_CANVAS_HEIGHT

ADJUST_CANVAS_WIDTH = mapnik._mapnik.aspect_fix_mode.ADJUST_CANVAS_WIDTH

GROW_BBOX = mapnik._mapnik.aspect_fix_mode.GROW_BBOX

GROW_CANVAS = mapnik._mapnik.aspect_fix_mode.GROW_CANVAS

RESPECT = mapnik._mapnik.aspect_fix_mode.RESPECT

SHRINK_BBOX = mapnik._mapnik.aspect_fix_mode.SHRINK_BBOX

SHRINK_CANVAS = mapnik._mapnik.aspect_fix_mode.SHRINK_CANVAS

names = {'ADJUST_BBOX_HEIGHT': mapnik._mapnik.aspect_fix_mode.ADJUST_BBOX_HEIGHT, 'ADJUST_BBOX_WIDTH': mapnik._mapnik.aspect_fix_mode.ADJUST_BBOX_WIDTH, 'ADJUST_CANVAS_HEIGHT': mapnik._mapnik.aspect_fix_mode.ADJUST_CANVAS_HEIGHT, 'ADJUST_CANVAS_WIDTH': mapnik._mapnik.aspect_fix_mode.ADJUST_CANVAS_WIDTH, 'GROW_BBOX': mapnik._mapnik.aspect_fix_mode.GROW_BBOX, 'GROW_CANVAS': mapnik._mapnik.aspect_fix_mode.GROW_CANVAS, 'RESPECT': mapnik._mapnik.aspect_fix_mode.RESPECT, 'SHRINK_BBOX': mapnik._mapnik.aspect_fix_mode.SHRINK_BBOX, 'SHRINK_CANVAS': mapnik._mapnik.aspect_fix_mode.SHRINK_CANVAS}

values = {0: mapnik._mapnik.aspect_fix_mode.GROW_BBOX, 1: mapnik._mapnik.aspect_fix_mode.GROW_CANVAS, 2: mapnik._mapnik.aspect_fix_mode.SHRINK_BBOX, 3: mapnik._mapnik.aspect_fix_mode.SHRINK_CANVAS, 4: mapnik._mapnik.aspect_fix_mode.ADJUST_BBOX_WIDTH, 5: mapnik._mapnik.aspect_fix_mode.ADJUST_BBOX_HEIGHT, 6: mapnik._mapnik.aspect_fix_mode.ADJUST_CANVAS_WIDTH, 7: mapnik._mapnik.aspect_fix_mode.ADJUST_CANVAS_HEIGHT, 8: mapnik._mapnik.aspect_fix_mode.RESPECT}

mapnik._mapnik.clear_cache() → None :

Clear all global caches of markers and mapped memory regions.

Usage: >>> from mapnik import clear_cache >>> clear_cache()

C++ signature :

void clear_cache()

class mapnik._mapnik.debug_symbolizer_mode

Bases: Boost.Python.enum

COLLISION = mapnik._mapnik.debug_symbolizer_mode.COLLISION

VERTEX = mapnik._mapnik.debug_symbolizer_mode.VERTEX

collision = mapnik._mapnik.debug_symbolizer_mode.collision

names = {'COLLISION': mapnik._mapnik.debug_symbolizer_mode.COLLISION, 'VERTEX': mapnik._mapnik.debug_symbolizer_mode.VERTEX, 'collision': mapnik._mapnik.debug_symbolizer_mode.collision, 'rings': mapnik._mapnik.debug_symbolizer_mode.rings, 'vertex': mapnik._mapnik.debug_symbolizer_mode.vertex}

rings = mapnik._mapnik.debug_symbolizer_mode.rings

values = {0: mapnik._mapnik.debug_symbolizer_mode.COLLISION, 1: mapnik._mapnik.debug_symbolizer_mode.VERTEX, 2: mapnik._mapnik.debug_symbolizer_mode.rings}

vertex = mapnik._mapnik.debug_symbolizer_mode.vertex

class mapnik._mapnik.filter_mode

Bases: Boost.Python.enum

ALL = mapnik._mapnik.filter_mode.ALL

FIRST = mapnik._mapnik.filter_mode.FIRST

all = mapnik._mapnik.filter_mode.all

first = mapnik._mapnik.filter_mode.first

names = {'ALL': mapnik._mapnik.filter_mode.ALL, 'FIRST': mapnik._mapnik.filter_mode.FIRST, 'all': mapnik._mapnik.filter_mode.all, 'first': mapnik._mapnik.filter_mode.first}

values = {0: mapnik._mapnik.filter_mode.ALL, 1: mapnik._mapnik.filter_mode.FIRST}

mapnik._mapnik.forward_((Coord)arg1, (Projection)arg2) → Coord :

C++ signature :

mapnik::coord<double, 2> forward_(mapnik::coord<double, 2>,mapnik::projection)

forward_( (Box2d)arg1, (Projection)arg2) -> Box2d :

C++ signature :

mapnik::box2d<double> forward_(mapnik::box2d<double>,mapnik::projection)

class mapnik._mapnik.gamma_method

Bases: Boost.Python.enum

LINEAR = mapnik._mapnik.gamma_method.LINEAR

MULTIPLY = mapnik._mapnik.gamma_method.MULTIPLY

NONE = mapnik._mapnik.gamma_method.NONE

POWER = mapnik._mapnik.gamma_method.POWER

THRESHOLD = mapnik._mapnik.gamma_method.THRESHOLD

linear = mapnik._mapnik.gamma_method.linear

multiply = mapnik._mapnik.gamma_method.multiply

names = {'LINEAR': mapnik._mapnik.gamma_method.LINEAR, 'MULTIPLY': mapnik._mapnik.gamma_method.MULTIPLY, 'NONE': mapnik._mapnik.gamma_method.NONE, 'POWER': mapnik._mapnik.gamma_method.POWER, 'THRESHOLD': mapnik._mapnik.gamma_method.THRESHOLD, 'linear': mapnik._mapnik.gamma_method.linear, 'multiply': mapnik._mapnik.gamma_method.multiply, 'none': mapnik._mapnik.gamma_method.none, 'power': mapnik._mapnik.gamma_method.power, 'threshold': mapnik._mapnik.gamma_method.threshold}

none = mapnik._mapnik.gamma_method.none

power = mapnik._mapnik.gamma_method.power

threshold = mapnik._mapnik.gamma_method.threshold

values = {0: mapnik._mapnik.gamma_method.POWER, 1: mapnik._mapnik.gamma_method.LINEAR, 2: mapnik._mapnik.gamma_method.NONE, 3: mapnik._mapnik.gamma_method.THRESHOLD, 4: mapnik._mapnik.gamma_method.MULTIPLY}

class mapnik._mapnik.halo_rasterizer

Bases: Boost.Python.enum

FAST = mapnik._mapnik.halo_rasterizer.FAST

FULL = mapnik._mapnik.halo_rasterizer.FULL

fast = mapnik._mapnik.halo_rasterizer.fast

full = mapnik._mapnik.halo_rasterizer.full

names = {'FAST': mapnik._mapnik.halo_rasterizer.FAST, 'FULL': mapnik._mapnik.halo_rasterizer.FULL, 'fast': mapnik._mapnik.halo_rasterizer.fast, 'full': mapnik._mapnik.halo_rasterizer.full}

values = {0: mapnik._mapnik.halo_rasterizer.FULL, 1: mapnik._mapnik.halo_rasterizer.FAST}

mapnik._mapnik.has_cairo() → bool :

Get cairo library status

C++ signature :

bool has_cairo()

mapnik._mapnik.has_grid_renderer() → bool :

Get grid_renderer status

C++ signature :

bool has_grid_renderer()

mapnik._mapnik.has_jpeg() → bool :

Get jpeg read/write support status

C++ signature :

bool has_jpeg()

mapnik._mapnik.has_png() → bool :

Get png read/write support status

C++ signature :

bool has_png()

mapnik._mapnik.has_proj4() → bool :

Get proj4 status

C++ signature :

bool has_proj4()

mapnik._mapnik.has_pycairo() → bool :

Get pycairo module status

C++ signature :

bool has_pycairo()

mapnik._mapnik.has_svg_renderer() → bool :

Get svg_renderer status

C++ signature :

bool has_svg_renderer()

mapnik._mapnik.has_tiff() → bool :

Get tiff read/write support status

C++ signature :

bool has_tiff()

mapnik._mapnik.has_webp() → bool :

Get webp read/write support status

C++ signature :

bool has_webp()

class mapnik._mapnik.horizontal_alignment

Bases: Boost.Python.enum

AUTO = mapnik._mapnik.horizontal_alignment.AUTO

LEFT = mapnik._mapnik.horizontal_alignment.LEFT

MIDDLE = mapnik._mapnik.horizontal_alignment.MIDDLE

RIGHT = mapnik._mapnik.horizontal_alignment.RIGHT

adjust = mapnik._mapnik.horizontal_alignment.adjust

auto = mapnik._mapnik.horizontal_alignment.auto

left = mapnik._mapnik.horizontal_alignment.left

middle = mapnik._mapnik.horizontal_alignment.middle

names = {'AUTO': mapnik._mapnik.horizontal_alignment.AUTO, 'LEFT': mapnik._mapnik.horizontal_alignment.LEFT, 'MIDDLE': mapnik._mapnik.horizontal_alignment.MIDDLE, 'RIGHT': mapnik._mapnik.horizontal_alignment.RIGHT, 'adjust': mapnik._mapnik.horizontal_alignment.adjust, 'auto': mapnik._mapnik.horizontal_alignment.auto, 'left': mapnik._mapnik.horizontal_alignment.left, 'middle': mapnik._mapnik.horizontal_alignment.middle, 'right': mapnik._mapnik.horizontal_alignment.right}

right = mapnik._mapnik.horizontal_alignment.right

values = {0: mapnik._mapnik.horizontal_alignment.LEFT, 1: mapnik._mapnik.horizontal_alignment.MIDDLE, 2: mapnik._mapnik.horizontal_alignment.RIGHT, 3: mapnik._mapnik.horizontal_alignment.AUTO, 4: mapnik._mapnik.horizontal_alignment.adjust}

mapnik._mapnik.inverse_((Coord)arg1, (Projection)arg2) → Coord :

C++ signature :

mapnik::coord<double, 2> inverse_(mapnik::coord<double, 2>,mapnik::projection)

inverse_( (Box2d)arg1, (Projection)arg2) -> Box2d :

C++ signature :

mapnik::box2d<double> inverse_(mapnik::box2d<double>,mapnik::projection)

class mapnik._mapnik.justify_alignment

Bases: Boost.Python.enum

AUTO = mapnik._mapnik.justify_alignment.AUTO

LEFT = mapnik._mapnik.justify_alignment.LEFT

MIDDLE = mapnik._mapnik.justify_alignment.MIDDLE

RIGHT = mapnik._mapnik.justify_alignment.RIGHT

auto = mapnik._mapnik.justify_alignment.auto

center = mapnik._mapnik.justify_alignment.center

left = mapnik._mapnik.justify_alignment.left

names = {'AUTO': mapnik._mapnik.justify_alignment.AUTO, 'LEFT': mapnik._mapnik.justify_alignment.LEFT, 'MIDDLE': mapnik._mapnik.justify_alignment.MIDDLE, 'RIGHT': mapnik._mapnik.justify_alignment.RIGHT, 'auto': mapnik._mapnik.justify_alignment.auto, 'center': mapnik._mapnik.justify_alignment.center, 'left': mapnik._mapnik.justify_alignment.left, 'right': mapnik._mapnik.justify_alignment.right}

right = mapnik._mapnik.justify_alignment.right

values = {0: mapnik._mapnik.justify_alignment.LEFT, 1: mapnik._mapnik.justify_alignment.MIDDLE, 2: mapnik._mapnik.justify_alignment.RIGHT, 3: mapnik._mapnik.justify_alignment.AUTO}

class mapnik._mapnik.keys

Bases: Boost.Python.enum

gamma = mapnik._mapnik.keys.gamma

gamma_method = mapnik._mapnik.keys.gamma_method

names = {'gamma': mapnik._mapnik.keys.gamma, 'gamma_method': mapnik._mapnik.keys.gamma_method}

values = {0: mapnik._mapnik.keys.gamma, 1: mapnik._mapnik.keys.gamma_method}

class mapnik._mapnik.label_placement

Bases: Boost.Python.enum

INTERIOR_PLACEMENT = mapnik._mapnik.label_placement.INTERIOR_PLACEMENT

LINE_PLACEMENT = mapnik._mapnik.label_placement.LINE_PLACEMENT

POINT_PLACEMENT = mapnik._mapnik.label_placement.POINT_PLACEMENT

VERTEX_PLACEMENT = mapnik._mapnik.label_placement.VERTEX_PLACEMENT

grid = mapnik._mapnik.label_placement.grid

interior = mapnik._mapnik.label_placement.interior

line = mapnik._mapnik.label_placement.line

names = {'INTERIOR_PLACEMENT': mapnik._mapnik.label_placement.INTERIOR_PLACEMENT, 'LINE_PLACEMENT': mapnik._mapnik.label_placement.LINE_PLACEMENT, 'POINT_PLACEMENT': mapnik._mapnik.label_placement.POINT_PLACEMENT, 'VERTEX_PLACEMENT': mapnik._mapnik.label_placement.VERTEX_PLACEMENT, 'alternating-grid': mapnik._mapnik.label_placement.alternating-grid, 'grid': mapnik._mapnik.label_placement.grid, 'interior': mapnik._mapnik.label_placement.interior, 'line': mapnik._mapnik.label_placement.line, 'point': mapnik._mapnik.label_placement.point, 'vertex': mapnik._mapnik.label_placement.vertex}

point = mapnik._mapnik.label_placement.point

values = {0: mapnik._mapnik.label_placement.POINT_PLACEMENT, 1: mapnik._mapnik.label_placement.LINE_PLACEMENT, 2: mapnik._mapnik.label_placement.VERTEX_PLACEMENT, 3: mapnik._mapnik.label_placement.INTERIOR_PLACEMENT, 4: mapnik._mapnik.label_placement.grid, 5: mapnik._mapnik.label_placement.alternating-grid}

vertex = mapnik._mapnik.label_placement.vertex

class mapnik._mapnik.line_rasterizer

Bases: Boost.Python.enum

FAST = mapnik._mapnik.line_rasterizer.FAST

FULL = mapnik._mapnik.line_rasterizer.FULL

fast = mapnik._mapnik.line_rasterizer.fast

full = mapnik._mapnik.line_rasterizer.full

names = {'FAST': mapnik._mapnik.line_rasterizer.FAST, 'FULL': mapnik._mapnik.line_rasterizer.FULL, 'fast': mapnik._mapnik.line_rasterizer.fast, 'full': mapnik._mapnik.line_rasterizer.full}

values = {0: mapnik._mapnik.line_rasterizer.FULL, 1: mapnik._mapnik.line_rasterizer.FAST}

mapnik._mapnik.load_map((Map)arg1, (str)arg2[, (bool)arg3[, (str)arg4]]) → None :

C++ signature :

void load_map(mapnik::Map {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > [,bool [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >]])

mapnik._mapnik.load_map_from_string((Map)arg1, (str)arg2[, (bool)arg3[, (str)arg4]]) → None :

C++ signature :

void load_map_from_string(mapnik::Map {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > [,bool [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >]])

class mapnik._mapnik.logger

Bases: mapnik._mapnik.Singleton

static clear_object_severity() → None :

C++ signature :

void clear_object_severity()

static get_format() → object :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > get_format()

static get_object_severity((str)arg1) → severity_type :

C++ signature :

mapnik::logger::severity_type get_object_severity(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

static get_severity() → severity_type :

C++ signature :

mapnik::logger::severity_type get_severity()

static set_format((str)arg1) → None :

C++ signature :

void set_format(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

static set_object_severity((str)arg1, (severity_type)arg2) → None :

C++ signature :

void set_object_severity(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,mapnik::logger::severity_type)

static set_severity((severity_type)arg1) → None :

C++ signature :

void set_severity(mapnik::logger::severity_type)

static str() → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > str()

static use_console() → None :

C++ signature :

void use_console()

static use_file((str)arg1) → None :

C++ signature :

void use_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

mapnik._mapnik.mapnik_version() → int :

Get the Mapnik version number

C++ signature :

unsigned int mapnik_version()

mapnik._mapnik.mapnik_version_string() → str :

Get the Mapnik version string

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > mapnik_version_string()

class mapnik._mapnik.marker_multi_policy

Bases: Boost.Python.enum

EACH = mapnik._mapnik.marker_multi_policy.EACH

LARGEST = mapnik._mapnik.marker_multi_policy.LARGEST

WHOLE = mapnik._mapnik.marker_multi_policy.WHOLE

each = mapnik._mapnik.marker_multi_policy.each

largest = mapnik._mapnik.marker_multi_policy.largest

names = {'EACH': mapnik._mapnik.marker_multi_policy.EACH, 'LARGEST': mapnik._mapnik.marker_multi_policy.LARGEST, 'WHOLE': mapnik._mapnik.marker_multi_policy.WHOLE, 'each': mapnik._mapnik.marker_multi_policy.each, 'largest': mapnik._mapnik.marker_multi_policy.largest, 'whole': mapnik._mapnik.marker_multi_policy.whole}

values = {0: mapnik._mapnik.marker_multi_policy.EACH, 1: mapnik._mapnik.marker_multi_policy.WHOLE, 2: mapnik._mapnik.marker_multi_policy.LARGEST}

whole = mapnik._mapnik.marker_multi_policy.whole

class mapnik._mapnik.marker_placement

Bases: Boost.Python.enum

INTERIOR_PLACEMENT = mapnik._mapnik.marker_placement.INTERIOR_PLACEMENT

LINE_PLACEMENT = mapnik._mapnik.marker_placement.LINE_PLACEMENT

POINT_PLACEMENT = mapnik._mapnik.marker_placement.POINT_PLACEMENT

interior = mapnik._mapnik.marker_placement.interior

line = mapnik._mapnik.marker_placement.line

names = {'INTERIOR_PLACEMENT': mapnik._mapnik.marker_placement.INTERIOR_PLACEMENT, 'LINE_PLACEMENT': mapnik._mapnik.marker_placement.LINE_PLACEMENT, 'POINT_PLACEMENT': mapnik._mapnik.marker_placement.POINT_PLACEMENT, 'interior': mapnik._mapnik.marker_placement.interior, 'line': mapnik._mapnik.marker_placement.line, 'point': mapnik._mapnik.marker_placement.point, 'vertex-first': mapnik._mapnik.marker_placement.vertex-first, 'vertex-last': mapnik._mapnik.marker_placement.vertex-last}

point = mapnik._mapnik.marker_placement.point

values = {0: mapnik._mapnik.marker_placement.POINT_PLACEMENT, 1: mapnik._mapnik.marker_placement.INTERIOR_PLACEMENT, 2: mapnik._mapnik.marker_placement.LINE_PLACEMENT, 3: mapnik._mapnik.marker_placement.vertex-first, 4: mapnik._mapnik.marker_placement.vertex-last}

class mapnik._mapnik.pattern_alignment

Bases: Boost.Python.enum

GLOBAL = mapnik._mapnik.pattern_alignment.GLOBAL

LOCAL = mapnik._mapnik.pattern_alignment.LOCAL

global = mapnik._mapnik.pattern_alignment.global

local = mapnik._mapnik.pattern_alignment.local

names = {'GLOBAL': mapnik._mapnik.pattern_alignment.GLOBAL, 'LOCAL': mapnik._mapnik.pattern_alignment.LOCAL, 'global': mapnik._mapnik.pattern_alignment.global, 'local': mapnik._mapnik.pattern_alignment.local}

values = {0: mapnik._mapnik.pattern_alignment.LOCAL, 1: mapnik._mapnik.pattern_alignment.GLOBAL}

class mapnik._mapnik.point_placement

Bases: Boost.Python.enum

CENTROID = mapnik._mapnik.point_placement.CENTROID

INTERIOR = mapnik._mapnik.point_placement.INTERIOR

centroid = mapnik._mapnik.point_placement.centroid

interior = mapnik._mapnik.point_placement.interior

names = {'CENTROID': mapnik._mapnik.point_placement.CENTROID, 'INTERIOR': mapnik._mapnik.point_placement.INTERIOR, 'centroid': mapnik._mapnik.point_placement.centroid, 'interior': mapnik._mapnik.point_placement.interior}

values = {0: mapnik._mapnik.point_placement.CENTROID, 1: mapnik._mapnik.point_placement.INTERIOR}

mapnik._mapnik.render((Map)arg1, (Image)arg2[, (float)arg3[, (int)arg4[, (int)arg5]]]) → None :

Render Map to an AGG image_any using offsets

Usage: >>> from mapnik import Map, Image, render, load_map >>> m = Map(256,256) >>> load_map(m,’mapfile.xml’) >>> im = Image(m.width,m.height) >>> scale_factor=2.0 >>> offset = [100,50] >>> render(m,im) >>> render(m,im,scale_factor) >>> render(m,im,scale_factor,offset[0],offset[1])

C++ signature :

void render(mapnik::Map,mapnik::image_any {lvalue} [,double [,unsigned int [,unsigned int]]])

mapnik._mapnik.render_layer((Map)map, (Image)image, (int)layer[, (float)scale_factor=1.0[, (int)offset_x=0[, (int)offset_y=0]]]) → None :

C++ signature :

void render_layer(mapnik::Map,mapnik::image_any {lvalue},unsigned int [,double=1.0 [,unsigned int=0 [,unsigned int=0]]])

render_layer( (Map)map, (Grid)grid, (int)layer [, (list)fields=[] [, (float)scale_factor=1.0 [, (int)offset_x=0 [, (int)offset_y=0]]]]) -> None :

C++ signature :

void render_layer(mapnik::Map,mapnik::hit_grid<mapnik::gray64s_t> {lvalue},unsigned int [,boost::python::list=[] [,double=1.0 [,unsigned int=0 [,unsigned int=0]]]])

mapnik._mapnik.render_tile_to_file((Map)arg1, (int)arg2, (int)arg3, (int)arg4, (int)arg5, (str)arg6, (str)arg7) → None :

TODO

C++ signature :

void render_tile_to_file(mapnik::Map,unsigned int,unsigned int,unsigned int,unsigned int,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

mapnik._mapnik.render_to_file((Map)arg1, (str)arg2, (str)arg3) → None :

Render Map to file using explicit image type.

Usage: >>> from mapnik import Map, render_to_file, load_map >>> m = Map(256,256) >>> load_map(m,’mapfile.xml’) >>> render_to_file(m,’image32bit.png’,’png’)

8 bit (paletted) PNG can be requested with ‘png256’: >>> render_to_file(m,’8bit_image.png’,’png256’)

JPEG quality can be controlled by adding a suffix to ‘jpeg’ between 0 and 100 (default is 85): >>> render_to_file(m,’top_quality.jpeg’,’jpeg100’) >>> render_to_file(m,’medium_quality.jpeg’,’jpeg50’)

C++ signature :

void render_to_file(mapnik::Map,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

render_to_file( (Map)arg1, (str)arg2) -> None :

Render Map to file (type taken from file extension)

Usage: >>> from mapnik import Map, render_to_file, load_map >>> m = Map(256,256) >>> render_to_file(m,’image.jpeg’)

C++ signature :

void render_to_file(mapnik::Map,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

render_to_file( (Map)arg1, (str)arg2, (str)arg3, (float)arg4) -> None :

Render Map to file using explicit image type and scale factor.

Usage: >>> from mapnik import Map, render_to_file, load_map >>> m = Map(256,256) >>> scale_factor = 4 >>> render_to_file(m,’image.jpeg’,scale_factor)

C++ signature :

void render_to_file(mapnik::Map,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,double)

mapnik._mapnik.render_with_detector((Map)arg1, (Image)arg2, (LabelCollisionDetector)arg3[, (float)arg4[, (int)arg5[, (int)arg6]]]) → None :

Render Map to an AGG image_any using a pre-constructed detector.

Usage: >>> from mapnik import Map, Image, LabelCollisionDetector, render_with_detector, load_map >>> m = Map(256,256) >>> load_map(m,’mapfile.xml’) >>> im = Image(m.width,m.height) >>> detector = LabelCollisionDetector(m) >>> render_with_detector(m, im, detector)

C++ signature :

void render_with_detector(mapnik::Map,mapnik::image_any {lvalue},std::shared_ptr<mapnik::label_collision_detector4> [,double [,unsigned int [,unsigned int]]])

mapnik._mapnik.render_with_vars((Map)map, (Image)image, (dict)vars[, (float)scale_factor=1.0[, (int)offset_x=0[, (int)offset_y=0]]]) → None :

C++ signature :

void render_with_vars(mapnik::Map,mapnik::image_any {lvalue},boost::python::dict [,double=1.0 [,unsigned int=0 [,unsigned int=0]]])

mapnik._mapnik.save_map((Map)arg1, (str)arg2[, (bool)arg3]) → None :

C++ signature :

void save_map(mapnik::Map,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > [,bool])

mapnik._mapnik.save_map_to_string((Map)arg1[, (bool)arg2]) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > save_map_to_string(mapnik::Map [,bool])

mapnik._mapnik.scale_denominator((Map)map, (bool)is_geographic) → float :

Return the Map Scale Denominator. Also available as Map.scale_denominator()

Usage:

>>> from mapnik import Map, Projection, scale_denominator, load_map
>>> m = Map(256,256)
>>> load_map(m,'mapfile.xml')
>>> scale_denominator(m,Projection(m.srs).geographic)

C++ signature :

double scale_denominator(mapnik::Map,bool)

class mapnik._mapnik.scaling_method

Bases: Boost.Python.enum

BESSEL = mapnik._mapnik.scaling_method.BESSEL

BICUBIC = mapnik._mapnik.scaling_method.BICUBIC

BILINEAR = mapnik._mapnik.scaling_method.BILINEAR

BLACKMAN = mapnik._mapnik.scaling_method.BLACKMAN

CATROM = mapnik._mapnik.scaling_method.CATROM

GAUSSIAN = mapnik._mapnik.scaling_method.GAUSSIAN

HAMMING = mapnik._mapnik.scaling_method.HAMMING

HANNING = mapnik._mapnik.scaling_method.HANNING

HERMITE = mapnik._mapnik.scaling_method.HERMITE

KAISER = mapnik._mapnik.scaling_method.KAISER

LANCZOS = mapnik._mapnik.scaling_method.LANCZOS

MITCHELL = mapnik._mapnik.scaling_method.MITCHELL

NEAR = mapnik._mapnik.scaling_method.NEAR

QUADRIC = mapnik._mapnik.scaling_method.QUADRIC

SINC = mapnik._mapnik.scaling_method.SINC

SPLINE16 = mapnik._mapnik.scaling_method.SPLINE16

SPLINE36 = mapnik._mapnik.scaling_method.SPLINE36

names = {'BESSEL': mapnik._mapnik.scaling_method.BESSEL, 'BICUBIC': mapnik._mapnik.scaling_method.BICUBIC, 'BILINEAR': mapnik._mapnik.scaling_method.BILINEAR, 'BLACKMAN': mapnik._mapnik.scaling_method.BLACKMAN, 'CATROM': mapnik._mapnik.scaling_method.CATROM, 'GAUSSIAN': mapnik._mapnik.scaling_method.GAUSSIAN, 'HAMMING': mapnik._mapnik.scaling_method.HAMMING, 'HANNING': mapnik._mapnik.scaling_method.HANNING, 'HERMITE': mapnik._mapnik.scaling_method.HERMITE, 'KAISER': mapnik._mapnik.scaling_method.KAISER, 'LANCZOS': mapnik._mapnik.scaling_method.LANCZOS, 'MITCHELL': mapnik._mapnik.scaling_method.MITCHELL, 'NEAR': mapnik._mapnik.scaling_method.NEAR, 'QUADRIC': mapnik._mapnik.scaling_method.QUADRIC, 'SINC': mapnik._mapnik.scaling_method.SINC, 'SPLINE16': mapnik._mapnik.scaling_method.SPLINE16, 'SPLINE36': mapnik._mapnik.scaling_method.SPLINE36}

values = {0: mapnik._mapnik.scaling_method.NEAR, 1: mapnik._mapnik.scaling_method.BILINEAR, 2: mapnik._mapnik.scaling_method.BICUBIC, 3: mapnik._mapnik.scaling_method.SPLINE16, 4: mapnik._mapnik.scaling_method.SPLINE36, 5: mapnik._mapnik.scaling_method.HANNING, 6: mapnik._mapnik.scaling_method.HAMMING, 7: mapnik._mapnik.scaling_method.HERMITE, 8: mapnik._mapnik.scaling_method.KAISER, 9: mapnik._mapnik.scaling_method.QUADRIC, 10: mapnik._mapnik.scaling_method.CATROM, 11: mapnik._mapnik.scaling_method.GAUSSIAN, 12: mapnik._mapnik.scaling_method.BESSEL, 13: mapnik._mapnik.scaling_method.MITCHELL, 14: mapnik._mapnik.scaling_method.SINC, 15: mapnik._mapnik.scaling_method.LANCZOS, 16: mapnik._mapnik.scaling_method.BLACKMAN}

class mapnik._mapnik.severity_type

Bases: Boost.Python.enum

Debug = mapnik._mapnik.severity_type.Debug

Error = mapnik._mapnik.severity_type.Error

None = mapnik._mapnik.severity_type.None

Warn = mapnik._mapnik.severity_type.Warn

names = {'Debug': mapnik._mapnik.severity_type.Debug, 'Error': mapnik._mapnik.severity_type.Error, 'None': mapnik._mapnik.severity_type.None, 'Warn': mapnik._mapnik.severity_type.Warn}

values = {0: mapnik._mapnik.severity_type.Debug, 1: mapnik._mapnik.severity_type.Warn, 2: mapnik._mapnik.severity_type.Error, 3: mapnik._mapnik.severity_type.None}

class mapnik._mapnik.stroke_linecap

Bases: Boost.Python.enum

The possible values for a line cap used when drawing with a stroke.

BUTT_CAP = mapnik._mapnik.stroke_linecap.BUTT_CAP

ROUND_CAP = mapnik._mapnik.stroke_linecap.ROUND_CAP

SQUARE_CAP = mapnik._mapnik.stroke_linecap.SQUARE_CAP

butt = mapnik._mapnik.stroke_linecap.butt

names = {'BUTT_CAP': mapnik._mapnik.stroke_linecap.BUTT_CAP, 'ROUND_CAP': mapnik._mapnik.stroke_linecap.ROUND_CAP, 'SQUARE_CAP': mapnik._mapnik.stroke_linecap.SQUARE_CAP, 'butt': mapnik._mapnik.stroke_linecap.butt, 'round': mapnik._mapnik.stroke_linecap.round, 'square': mapnik._mapnik.stroke_linecap.square}

round = mapnik._mapnik.stroke_linecap.round

square = mapnik._mapnik.stroke_linecap.square

values = {0: mapnik._mapnik.stroke_linecap.BUTT_CAP, 1: mapnik._mapnik.stroke_linecap.SQUARE_CAP, 2: mapnik._mapnik.stroke_linecap.ROUND_CAP}

class mapnik._mapnik.stroke_linejoin

Bases: Boost.Python.enum

The possible values for the line joining mode when drawing with a stroke.

BEVEL_JOIN = mapnik._mapnik.stroke_linejoin.BEVEL_JOIN

MITER_JOIN = mapnik._mapnik.stroke_linejoin.MITER_JOIN

MITER_REVERT_JOIN = mapnik._mapnik.stroke_linejoin.MITER_REVERT_JOIN

ROUND_JOIN = mapnik._mapnik.stroke_linejoin.ROUND_JOIN

bevel = mapnik._mapnik.stroke_linejoin.bevel

miter = mapnik._mapnik.stroke_linejoin.miter

names = {'BEVEL_JOIN': mapnik._mapnik.stroke_linejoin.BEVEL_JOIN, 'MITER_JOIN': mapnik._mapnik.stroke_linejoin.MITER_JOIN, 'MITER_REVERT_JOIN': mapnik._mapnik.stroke_linejoin.MITER_REVERT_JOIN, 'ROUND_JOIN': mapnik._mapnik.stroke_linejoin.ROUND_JOIN, 'bevel': mapnik._mapnik.stroke_linejoin.bevel, 'miter': mapnik._mapnik.stroke_linejoin.miter, 'miter-revert': mapnik._mapnik.stroke_linejoin.miter-revert, 'round': mapnik._mapnik.stroke_linejoin.round}

round = mapnik._mapnik.stroke_linejoin.round

values = {0: mapnik._mapnik.stroke_linejoin.MITER_JOIN, 1: mapnik._mapnik.stroke_linejoin.MITER_REVERT_JOIN, 2: mapnik._mapnik.stroke_linejoin.ROUND_JOIN, 3: mapnik._mapnik.stroke_linejoin.BEVEL_JOIN}

class mapnik._mapnik.text_transform

Bases: Boost.Python.enum

CAPITALIZE = mapnik._mapnik.text_transform.CAPITALIZE

LOWERCASE = mapnik._mapnik.text_transform.LOWERCASE

NONE = mapnik._mapnik.text_transform.NONE

UPPERCASE = mapnik._mapnik.text_transform.UPPERCASE

capitalize = mapnik._mapnik.text_transform.capitalize

lowercase = mapnik._mapnik.text_transform.lowercase

names = {'CAPITALIZE': mapnik._mapnik.text_transform.CAPITALIZE, 'LOWERCASE': mapnik._mapnik.text_transform.LOWERCASE, 'NONE': mapnik._mapnik.text_transform.NONE, 'UPPERCASE': mapnik._mapnik.text_transform.UPPERCASE, 'capitalize': mapnik._mapnik.text_transform.capitalize, 'lowercase': mapnik._mapnik.text_transform.lowercase, 'none': mapnik._mapnik.text_transform.none, 'reverse': mapnik._mapnik.text_transform.reverse, 'uppercase': mapnik._mapnik.text_transform.uppercase}

none = mapnik._mapnik.text_transform.none

reverse = mapnik._mapnik.text_transform.reverse

uppercase = mapnik._mapnik.text_transform.uppercase

values = {0: mapnik._mapnik.text_transform.NONE, 1: mapnik._mapnik.text_transform.UPPERCASE, 2: mapnik._mapnik.text_transform.LOWERCASE, 3: mapnik._mapnik.text_transform.CAPITALIZE, 4: mapnik._mapnik.text_transform.reverse}

class mapnik._mapnik.vertical_alignment

Bases: Boost.Python.enum

AUTO = mapnik._mapnik.vertical_alignment.AUTO

BOTTOM = mapnik._mapnik.vertical_alignment.BOTTOM

MIDDLE = mapnik._mapnik.vertical_alignment.MIDDLE

TOP = mapnik._mapnik.vertical_alignment.TOP

auto = mapnik._mapnik.vertical_alignment.auto

bottom = mapnik._mapnik.vertical_alignment.bottom

middle = mapnik._mapnik.vertical_alignment.middle

names = {'AUTO': mapnik._mapnik.vertical_alignment.AUTO, 'BOTTOM': mapnik._mapnik.vertical_alignment.BOTTOM, 'MIDDLE': mapnik._mapnik.vertical_alignment.MIDDLE, 'TOP': mapnik._mapnik.vertical_alignment.TOP, 'auto': mapnik._mapnik.vertical_alignment.auto, 'bottom': mapnik._mapnik.vertical_alignment.bottom, 'middle': mapnik._mapnik.vertical_alignment.middle, 'top': mapnik._mapnik.vertical_alignment.top}

top = mapnik._mapnik.vertical_alignment.top

values = {0: mapnik._mapnik.vertical_alignment.TOP, 1: mapnik._mapnik.vertical_alignment.MIDDLE, 2: mapnik._mapnik.vertical_alignment.BOTTOM, 3: mapnik._mapnik.vertical_alignment.AUTO}

class mapnik._mapnik.wkbByteOrder

Bases: Boost.Python.enum

NDR = mapnik._mapnik.wkbByteOrder.NDR

XDR = mapnik._mapnik.wkbByteOrder.XDR

names = {'NDR': mapnik._mapnik.wkbByteOrder.NDR, 'XDR': mapnik._mapnik.wkbByteOrder.XDR}

values = {0: mapnik._mapnik.wkbByteOrder.XDR, 1: mapnik._mapnik.wkbByteOrder.NDR}