def test_polygonsymbolizer_init():
p = mapnik2.PolygonSymbolizer()
eq_(p.fill, mapnik2.Color('gray'))
eq_(p.fill_opacity, 1)
p = mapnik2.PolygonSymbolizer(mapnik2.Color('blue'))
eq_(p.fill, mapnik2.Color('blue'))
eq_(p.fill_opacity, 1)
def test_polygonsymbolizer_init():
p = mapnik2.PolygonSymbolizer()
eq_(p.fill, mapnik2.Color('gray'))
eq_(p.fill_opacity, 1)
eq_(p.placement, mapnik2.point_placement.CENTROID)
p = mapnik2.PolygonSymbolizer(mapnik2.Color('blue'))
p.placement = mapnik2.point_placement.INTERIOR
eq_(p.fill, mapnik2.Color('blue'))
eq_(p.fill_opacity, 1)
eq_(p.placement, mapnik2.point_placement.INTERIOR)
def test_polygonsymbolizer_pickle():
p = mapnik2.PolygonSymbolizer(mapnik2.Color('black'))
p.fill_opacity = .5
# does not work for some reason...
#eq_(pickle.loads(pickle.dumps(p)), p)
p2 = pickle.loads(pickle.dumps(p,pickle.HIGHEST_PROTOCOL))
eq_(p.fill, p2.fill)
eq_(p.fill_opacity, p2.fill_opacity)
def generate_mapnik_style(self, user_id, global_id):
style = mapnik.Style()
for color in self.load_colors(user_id, global_id):
c = mapnik.Color(str(color))
line = mapnik.LineSymbolizer(c, 1.5)
line.stroke.opacity = 0.7
poly = mapnik.PolygonSymbolizer(c)
poly.fill_opacity = 0.5
rule = mapnik.Rule()
rule.filter = mapnik.Filter(str("[color] = '%s'" % (color,)))
rule.symbols.extend([poly,line])
style.rules.append(rule)
return style
def ogc_PolygonSymbolizer_to_mapnik(sym):
m_poly = mapnik.PolygonSymbolizer()
if hasattr(sym, 'Fill'):
fill = sym.Fill
for css in fill.CssParameter:
if css.get('name') == 'fill':
m_poly.fill = mapnik.Color(css.text)
elif css.get('name') == 'fill-opacity':
m_poly.opacity = float(css.text)
else:
raise Exception('unhanded: ' + css.get('name'))
if hasattr(sym, 'Stroke'):
stroke = sym.Stroke
m_stroke = stroke_to_mapnik(stroke)
yield mapnik.LineSymbolizer(m_stroke)
yield m_poly
def rpc_renderCoordOld(self, lat, lon, zoom):
"""
Renders a map for the given coordinates.
"""
Map = None
LandmassShapefile = 'cape/Interface/ne_110m_admin_0_countries.shp'
im = mapnik.Image(self.mapsize[0], self.mapsize[1])
m = mapnik.Map(self.mapsize[0], self.mapsize[1])
m.background = mapnik.Color(self.backgroundColor)
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer(
mapnik.Color(self.foregroundColor))
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer(
mapnik.Color('rgb(50%,50%,50%)'), 0.1)
r.symbols.append(line_symbolizer)
s.rules.append(r)
m.append_style('My Style', s)
ds = mapnik.Shapefile(file=LandmassShapefile)
layer = mapnik.Layer('world')
layer.datasource = ds
layer.styles.append('My Style')
m.layers.append(layer)
center = mapnik.Coord(lat, lon)
transform = mapnik.ProjTransform(self.longlat, self.merc)
merc_center = transform.forward(center)
dx = (20037508.34 * 2 * (self.mapsize[0] / 2)) / (256 * (2**(zoom)))
minx = merc_center.x - dx
maxx = merc_center.x + dx
m.aspect_fix_mode = mapnik.aspect_fix_mode.ADJUST_BBOX_HEIGHT
merc_bbox = mapnik.Box2d(minx, merc_center.y - 1, maxx,
merc_center.y + 1)
m.zoom_to_box(merc_bbox)
mapnik.render(m, im)
Map = im.tostring('png')
return (True, Map)
def get(self):
mapfile = os.path.join(DATA_PATH, 'hazard', 'flood.shp')
#mapfile = os.path.join(DATA_PATH, 'impact', 'impact.json')
filename = os.path.join(DATA_PATH, 'pdf', 'report_map.pdf')
filename2 = os.path.join(DATA_PATH, 'pdf', 'report_map.png')
map = mapnik2.Map(600, 400)
map.background = mapnik2.Color('steelblue')
s = mapnik2.Style()
r = mapnik2.Rule()
polygon_symbolizer = mapnik2.PolygonSymbolizer(
mapnik2.Color('#f2eff9'))
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik2.LineSymbolizer(
mapnik2.Color('rgb(50%,50%,50%)'), 0.1)
r.symbols.append(line_symbolizer)
s.rules.append(r)
map.append_style('My Style', s)
ds = mapnik2.Shapefile(file=mapfile)
layer = mapnik2.Layer('world')
layer.datasource = ds
layer.styles.append('My Style')
map.layers.append(layer)
map.zoom_all()
mapnik2.render_to_file(map, filename2, 'png')
#bbox = mapnik.Envelope(-180.0,-90.0,180.0,90.0)
#map.zoom_to_box(bbox)
surface = cairo.PDFSurface(filename, map.width, map.height)
mapnik2.render(map, surface)
surface.finish()
with open(filename) as data:
pdf = data.read()
data.close()
self.set_header("Content-Type", "application/pdf")
self.write(pdf)
def mapnik_rendering(f_pct,f_vct,f_render):
import mapnik2 as mapnik
ref_pct = GR.geo_raster.open(f_pct)
proj = ref_pct.projection
tr = ref_pct.geo_transform
width = ref_pct.width
height = ref_pct.height
size_p = tr[1]
minx = tr[0]
maxy = tr[3]
miny = tr[3] - height * size_p
maxx = tr[0] + width * size_p
bbox = (minx, miny, maxx, maxy)
#---- init
_map = mapnik.Map(width,height)
_map.background = mapnik.Color('black')
#----==== raster
style_gdal = mapnik.Style() # style object to hold rules
rule_gdal = mapnik.Rule() # rule object to hold symbolizers
symbol_gdal = mapnik.RasterSymbolizer()
#symbol_gdal.opacity = 0.5
#$symbol_gdal.colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_INHERIT, mapnik.Color(255,255,255))
c = mapnik.RasterColorizer( mapnik.COLORIZER_LINEAR , mapnik.Color(0,0,0) )
c.epsilon = 0.001
c.add_stop(0)
c.add_stop(900, mapnik.COLORIZER_LINEAR, mapnik.Color("#F3DDB4"))
c.add_stop(1300, mapnik.COLORIZER_LINEAR, mapnik.Color("cyan"))
c.add_stop(2000, mapnik.COLORIZER_LINEAR, mapnik.Color("white"))
#c.get_color(2000)
#c.stops[1].color
#'''
symbol_gdal.colorizer = c
rule_gdal.symbols.append(symbol_gdal)
style_gdal.rules.append(rule_gdal)
_map.append_style("Raster Style", style_gdal)
mlyr_gdal = mapnik.Layer('TM_images')
mlyr_gdal.datasource = mapnik.Gdal(file=f_pct,band=1,bbox=bbox)
#mlyr_gdal.srs = '+proj=utm +zone=46 +ellps=WGS84 +units=m +no_defs '
mlyr_gdal.styles.append('Raster Style')
_map.layers.append(mlyr_gdal)
#'''
#----==== shape
style_vct = mapnik.Style() # style object to hold rules
rule_vct = mapnik.Rule() # rule object to hold symbolizers
#==== ==== add labels
symbol_text = mapnik.TextSymbolizer(mapnik.Expression('[Code_uniq]'), 'DejaVu Sans Book', 20, mapnik.Color('black'))
symbol_text.halo_fill = mapnik.Color('white')
symbol_text.halo_radius = 1
symbol_text.avoid_edges = True
#symbol_text.allow_overlap = False
symbol_text.vertical_alignment = mapnik.vertical_alignment.TOP
symbol_text.label_placement = mapnik.label_placement.POINT_PLACEMENT #LINE_PLACEMENT # is default
rule_vct.symbols.append(symbol_text)
#==== ==== 1.add polygon
symbol_vct = mapnik.PolygonSymbolizer(mapnik.Color('#059BFF'))
symbol_vct.opacity = 1#0.6
rule_vct.symbols.append(symbol_vct) # add the symbolizer to the rule object
#==== ==== 2.add outlines
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('black'),0.3)
rule_vct.symbols.append(line_symbolizer) # add the symbolizer to the rule object
style_vct.rules.append(rule_vct) # now add the rule to the style and we're done
_map.append_style('vector',style_vct) # Styles are given names only as they are applied to the map
ds_shp = mapnik.Shapefile(file=f_vct)
mlyr_shp = mapnik.Layer('lakes')
mlyr_shp.datasource = ds_shp
mlyr_shp.styles.append('vector')
_map.layers.append(mlyr_shp)
#'''
_map.zoom_all()
# Write the data to a png image called world.png the current directory
mapnik.render_to_file(_map,f_render, 'png')
print f_render
#!/usr/bin/env python
import mapnik2 as mapnik
m = mapnik.Map(6000,3000,"+proj=latlong +datum=WGS84")
m.background = mapnik.Color('steelblue')
s = mapnik.Style()
r=mapnik.Rule()
r.symbols.append(mapnik.PolygonSymbolizer(mapnik.Color('#f2eff9')))
r.symbols.append(mapnik.LineSymbolizer(mapnik.Color('rgb(50%,50%,50%)'),0.1))
s.rules.append(r)
m.append_style('My Style',s)
lyr = mapnik.Layer('world',"+proj=latlong +datum=WGS84")
lyr.datasource = mapnik.Shapefile(file='/opt/gdata/world_borders.shp')
lyr.styles.append('My Style')
m.layers.append(lyr)
m.zoom_to_box(lyr.envelope())
mapnik.render_to_file(m,'world.png', 'png')
def to_mapnik(self):
sym = mapnik.PolygonSymbolizer(mapnik.Color(str(self.color)))
sym.fill_opacity = self.opacity
sym.gamma = self.gamma or sym.gamma
return sym
def main(root,**options):
m = mapnik.Map(1,1)
idx = 0
layers = []
if hasattr(root,'NamedLayer'):
layers.extend(root.NamedLayer)
if hasattr(root,'UserLayer'):
layers.extend(root.UserLayer)
for layer in layers:
lyr = mapnik.Layer(str(getattr(layer,'Name',None) or 'Layer'))
datasource = options.get('datasource')
if datasource and datasource.endswith('shp'):
shp_dir = os.path.abspath(datasource).split('.shp')[0]
name = datasource.split('.shp')[0]
lyr.datasource = mapnik.Shapefile(file=shp_dir)
if options.get('srid'):
lyr.srs = '+init=epsg:%s' % options.get('srid')
m.srs = lyr.srs
else:
srs = proj4_from_osr(shp_dir)
if srs:
lyr.srs = srs
for user_style in layer.UserStyle:
for feature_style in user_style.FeatureTypeStyle:
m_sty = mapnik.Style()
# TODO = Styles should have title,abstract, etc...
sty_name = getattr(feature_style,'Name',None)
if not sty_name:
sty_name = '%s %s' % (lyr.name,str(idx))
sty_name = str(sty_name)
for rule in feature_style.Rule:
#print rule.get_childen()
m_rule = mapnik.Rule(str(getattr(rule,'Name','')))
ogc_filter = rule.find("{%s}Filter" % rule.nsmap['ogc'])
if ogc_filter is not None:
# TODO - support ogc:And and oc:Or
m_rule.filter = ogc_filter_to_mapnik(ogc_filter)
else:
if hasattr(rule,'ElseFilter'):
m_rule.set_else(True)
if hasattr(rule,'MaxScaleDenominator'):
m_rule.max_scale = float(rule.MaxScaleDenominator)
if hasattr(rule,'MinScaleDenominator'):
m_rule.min_scale = float(rule.MinScaleDenominator)
if hasattr(rule,'LineSymbolizer'):
stroke = rule.LineSymbolizer.Stroke
m_stroke = stroke_to_mapnik(stroke)
m_rule.symbols.append(mapnik.LineSymbolizer(m_stroke))
if hasattr(rule,'PolygonSymbolizer'):
m_poly = mapnik.PolygonSymbolizer()
if hasattr(rule.PolygonSymbolizer,'Fill'):
fill = rule.PolygonSymbolizer.Fill
for css in fill.CssParameter:
if css.get('name') == 'fill':
m_poly.fill = mapnik.Color(css.text)
elif css.get('name') == 'fill-opacity':
m_poly.opacity = float(css.text)
else:
raise Exception('unhanded: ' + css.get('name'))
if hasattr(rule.PolygonSymbolizer,'Stroke'):
stroke = rule.PolygonSymbolizer.Stroke
m_stroke = stroke_to_mapnik(stroke)
m_rule.symbols.append(mapnik.LineSymbolizer(m_stroke))
m_rule.symbols.append(m_poly)
if hasattr(rule,'PointSymbolizer'):
#fill = rule.PolygonSymbolizer.Fill
#m_point = point_to_mapnik(point)
# TODO
m_rule.symbols.append(mapnik.PointSymbolizer())
if hasattr(rule,'TextSymbolizer'):
text = rule.TextSymbolizer
name = text.Label.find("{%s}PropertyName" % rule.nsmap['ogc'])
if not name and hasattr(text,'Label'):
name = shlex.split(str(text.Label))[0]
face_name = '[%s]' % text.Font
face_name = 'DejaVu Sans Book'
size = 10
for css in text.Font.CssParameter:
if css.get('name') == 'font-family':
face_name = css.text
elif css.get('name') == 'font-size':
size = int(float(css.text))
color = mapnik.Color('black')
for css in text.Fill.CssParameter:
if css.get('name') == 'fill':
color = mapnik.Color(css.text)
m_text = mapnik.TextSymbolizer(mapnik.Expression('['+str(name)+']'),str(face_name),int(size),color)
if hasattr(text,'LabelPlacement'):
if hasattr(text.LabelPlacement,'LinePlacement'):
m_text.label_placement = mapnik.label_placement.LINE_PLACEMENT
if hasattr(text,'Halo'):
h = text.Halo
if hasattr(h,'Radius'):
m_text.halo_radius = float(h.Radius)
if hasattr(h,'Fill'):
for css in h.Fill.CssParameter:
if css.get('name') == 'fill':
m_text.halo_fill = mapnik.Color(css.text)
m_rule.symbols.append(m_text)
m_sty.rules.append(m_rule)
lyr.styles.append(sty_name)
m.append_style(sty_name,m_sty)
idx+= 1
m.layers.append(lyr)
if FIX_HEX:
(handle, path) = tempfile.mkstemp(suffix='.xml', prefix='geotools2mapnik-')
os.close(handle)
open(path,'w').write(mapnik.save_map_to_string(m))
tree = objectify.parse(path)
fix_colors(tree)
print etree.tostring(tree)#,pretty_print=True)
else:
print mapnik.save_map_to_string(m)
# uses mapnik 2
import mapnik2
symbolizer = mapnik2.PolygonSymbolizer(mapnik2.Color("darkgrey"))
rule = mapnik2.Rule()
rule.symbols.append(symbolizer)
style = mapnik2.Style()
style.rules.append(rule)
layer = mapnik2.Layer("mapLayer")
layer.datasource = mapnik2.Shapefile(
file="/data/82945364-10m-admin-0-countries.shp")
layer.styles.append("mapStyle")
map = mapnik2.Map(2400, 1200)
map.background = mapnik2.Color("black")
map.append_style("mapStyle", style)
map.layers.append(layer)
map.zoom_all()
mapnik2.render_to_file(map, "map.png", "png")
provpoly_rule_on.filter = mapnik2.Expression("[NAME_EN] = 'Ontario'")
# Here a symbolizer is defined. Available are:
# - LineSymbolizer(Color(),<width>)
# - LineSymbolizer(Stroke())
# - PolygonSymbolizer(Color())
# - PointSymbolizer(<file>,<type>,<width>,<height>)
# Some of them can accept a Color() instance, which can be created with:
# - Color(<red>, <green>, <blue>)
# - Color(<red>, <green>, <blue>, <alpha>)
# - Color(<string>) where <string> will be something like '#00FF00'
# or '#0f0' or 'green'
provpoly_rule_on.symbols.append(
mapnik2.PolygonSymbolizer(mapnik2.Color(250, 190, 183)))
provpoly_style.rules.append(provpoly_rule_on)
provpoly_rule_qc = mapnik2.Rule()
provpoly_rule_qc.filter = mapnik2.Expression("[NOM_FR] = 'Québec'")
provpoly_rule_qc.symbols.append(
mapnik2.PolygonSymbolizer(mapnik2.Color(217, 235, 203)))
provpoly_style.rules.append(provpoly_rule_qc)
# Add the style to the map, giving it a name. This is the name that will be
# used to refer to it from here on. Having named styles allows them to be
# re-used throughout the map.
m.append_style('provinces', provpoly_style)
# Then associate the style to the layer itself.
###
### START Layer 1
###
# style object to hold rules
s = mapnik2.Style()
# rule object to hold symbolizers
r = mapnik2.Rule()
r2 = mapnik2.Rule()
# Lines (outlines of polygons and/or simple lines. Line-Color (RGB) line-thickness
polygon_symbolizer = mapnik2.PolygonSymbolizer(mapnik2.Color('red')) #rgb(5%,5%,5%)
# Point Style. Path to marker.png
point_symbolizer = mapnik2.PointSymbolizer(mapnik2.PathExpression(point_marker) )
# Allow Overlaps and set opacity of marker
point_symbolizer.allow_overlap = True
point_symbolizer.opacity = 0.7
# add the polygon_symbolizer to the rule object
r.symbols.append(polygon_symbolizer)
r2.symbols.append(point_symbolizer)
# style object to hold rules
s = mapnik2.Style()
s2 = mapnik2.Style()
s3 = mapnik2.Style()
s4 = mapnik2.Style()
# rule object to hold symbolizers
r = mapnik2.Rule()
r2 = mapnik2.Rule()
r3 = mapnik2.Rule()
r4 = mapnik2.Rule()
###
### Color of the lines
###
polygon_symbolizer = mapnik2.PolygonSymbolizer(
mapnik2.Color('#00d200')) # green
polygon_symbolizer2 = mapnik2.PolygonSymbolizer(
mapnik2.Color('#eaea00')) # yellow
polygon_symbolizer3 = mapnik2.PolygonSymbolizer(
mapnik2.Color('#ff7f24')) # orange
polygon_symbolizer4 = mapnik2.PolygonSymbolizer(
mapnik2.Color('#ec0000')) # red
# fill-opacity
polygon_symbolizer.fill_opacity = 0.7
polygon_symbolizer2.fill_opacity = 0.7
polygon_symbolizer3.fill_opacity = 0.7
polygon_symbolizer4.fill_opacity = 0.7
# add the polygon_symbolizer to the rule object
r.symbols.append(polygon_symbolizer)
m.zoom_to_box(e)
###
### START Layer 1
###
# style object to hold rules
s = mapnik2.Style()
s2 = mapnik2.Style()
# rule object to hold symbolizers
r = mapnik2.Rule()
r2 = mapnik2.Rule()
# Lines (outlines of polygons and/or simple lines. Line-Color (RGB) line-thickness
polygon_symbolizer = mapnik2.PolygonSymbolizer(mapnik2.Color('#ec0000'))
polygon_symbolizer.fill_opacity = 0.5
polygon_symbolizer2 = mapnik2.PolygonSymbolizer(mapnik2.Color('#00d200'))
polygon_symbolizer2.fill_opacity = 0.5
# add the polygon_symbolizer to the rule object
r.symbols.append(polygon_symbolizer)
r2.symbols.append(polygon_symbolizer2)
# now add the rule(s) to the style
s.rules.append(r)
s2.rules.append(r2)
# Styles are added to the map
m.append_style('My Style', s)
def mapnik_rendering(f_pct, f_vct, f_render):
import mapnik2 as mapnik
ref_pct = GR.geo_raster.open(f_pct)
proj = ref_pct.projection
tr = ref_pct.geo_transform
width = ref_pct.width
height = ref_pct.height
size_p = tr[1]
minx = tr[0]
maxy = tr[3]
miny = tr[3] - height * size_p
maxx = tr[0] + width * size_p
bbox = (minx, miny, maxx, maxy)
#---- init
_map = mapnik.Map(width, height)
_map.background = mapnik.Color('black')
#'''
#----==== shape
style_vct = mapnik.Style() # style object to hold rules
rule_vct = mapnik.Rule() # rule object to hold symbolizers
symbol_vct = mapnik.PolygonSymbolizer(mapnik.Color('#f2eff9'))
symbol_vct.opacity = 0.8
rule_vct.symbols.append(
symbol_vct) # add the symbolizer to the rule object
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('rgb(50%,50%,50%)'),
0.1)
rule_vct.symbols.append(
line_symbolizer) # add the symbolizer to the rule object
style_vct.rules.append(
rule_vct) # now add the rule to the style and we're done
_map.append_style(
'vector', style_vct
) # Styles are given names only as they are applied to the map
ds_shp = mapnik.Shapefile(file=f_vct)
mlyr_shp = mapnik.Layer('lakes')
mlyr_shp.srs = '+proj=utm +zone=46 +ellps=WGS84 +units=m +no_defs '
mlyr_shp.datasource = ds_shp
mlyr_shp.styles.append('vector')
_map.layers.append(mlyr_shp)
#'''
#----==== raster
style_gdal = mapnik.Style() # style object to hold rules
rule_gdal = mapnik.Rule() # rule object to hold symbolizers
symbol_gdal = mapnik.RasterSymbolizer()
#symbol_gdal.mode = 'multiply'
symbol_gdal.opacity = 0.5
#symbol_gdal.colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_INHERIT, mapnik.Color(0,255,255))
c = mapnik.RasterColorizer(mapnik.COLORIZER_LINEAR,
mapnik.Color(255, 0, 0))
c.epsilon = 0.001
c.add_stop(0)
c.add_stop(255, mapnik.COLORIZER_LINEAR, mapnik.Color("red"))
c.get_color(255)
c.stops[1].color
#'''
symbol_gdal.colorizer = c
rule_gdal.symbols.append(symbol_gdal)
style_gdal.rules.append(rule_gdal)
_map.append_style("Raster Style", style_gdal)
mlyr_gdal = mapnik.Layer('TM_images')
mlyr_gdal.datasource = mapnik.Gdal(file=f_pct, band=1, bbox=bbox)
mlyr_gdal.srs = '+proj=utm +zone=46 +ellps=WGS84 +units=m +no_defs '
mlyr_gdal.styles.append('Raster Style')
_map.layers.append(mlyr_gdal)
#====
style_gdal1 = mapnik.Style() # style object to hold rules
rule_gdal1 = mapnik.Rule() # rule object to hold symbolizers
symbol_gdal1 = mapnik.RasterSymbolizer()
#symbol_gdal.mode = 'multiply'
symbol_gdal1.opacity = 0.5
#symbol_gdal.colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_INHERIT, mapnik.Color(0,255,255))
c1 = mapnik.RasterColorizer(mapnik.COLORIZER_LINEAR,
mapnik.Color(0, 255, 0))
c1.epsilon = 0.001
c1.add_stop(0)
c1.add_stop(255, mapnik.COLORIZER_LINEAR, mapnik.Color("green"))
c1.get_color(255)
c1.stops[1].color
#'''
symbol_gdal1.colorizer = c1
rule_gdal1.symbols.append(symbol_gdal1)
style_gdal1.rules.append(rule_gdal1)
_map.append_style("Raster Style2", style_gdal1)
mlyr_gdal1 = mapnik.Layer('TM_images2')
mlyr_gdal1.datasource = mapnik.Gdal(file=f_pct, band=2, bbox=bbox)
mlyr_gdal1.srs = '+proj=utm +zone=46 +ellps=WGS84 +units=m +no_defs '
mlyr_gdal1.styles.append('Raster Style2')
_map.layers.append(mlyr_gdal1)
#====
#====
style_gdal_b = mapnik.Style() # style object to hold rules
rule_gdal_b = mapnik.Rule() # rule object to hold symbolizers
symbol_gdal_b = mapnik.RasterSymbolizer()
#symbol_gdal.mode = 'multiply'
symbol_gdal_b.opacity = 0.5
#symbol_gdal.colorizer = mapnik.RasterColorizer(mapnik.COLORIZER_INHERIT, mapnik.Color(0,255,255))
c_b = mapnik.RasterColorizer(mapnik.COLORIZER_LINEAR,
mapnik.Color(0, 0, 255))
c_b.epsilon = 0.001
c_b.add_stop(0)
c_b.add_stop(255, mapnik.COLORIZER_LINEAR, mapnik.Color("blue"))
c_b.get_color(255)
c_b.stops[1].color
#'''
symbol_gdal_b.colorizer = c_b
rule_gdal_b.symbols.append(symbol_gdal_b)
style_gdal_b.rules.append(rule_gdal_b)
_map.append_style("Raster Style3", style_gdal_b)
mlyr_gdal_b = mapnik.Layer('TM_images3')
mlyr_gdal_b.datasource = mapnik.Gdal(file=f_pct, band=3, bbox=bbox)
mlyr_gdal_b.srs = '+proj=utm +zone=46 +ellps=WGS84 +units=m +no_defs '
mlyr_gdal_b.styles.append('Raster Style3')
_map.layers.append(mlyr_gdal_b)
#====
_map.zoom_all()
# Write the data to a png image called world.png the current directory
mapnik.render_to_file(_map, f_render, 'png')