def test_linesymbolizer_init():
l = mapnik2.LineSymbolizer()
eq_(l.stroke.width, 1)
eq_(l.stroke.opacity, 1)
eq_(l.stroke.color, mapnik2.Color('black'))
eq_(l.stroke.line_cap, mapnik2.line_cap.BUTT_CAP)
eq_(l.stroke.line_join, mapnik2.line_join.MITER_JOIN)
l = mapnik2.LineSymbolizer(mapnik2.Color('blue'), 5.0)
eq_(l.stroke.width, 5)
eq_(l.stroke.opacity, 1)
eq_(l.stroke.color, mapnik2.Color('blue'))
eq_(l.stroke.line_cap, mapnik2.line_cap.BUTT_CAP)
eq_(l.stroke.line_join, mapnik2.line_join.MITER_JOIN)
s = mapnik2.Stroke(mapnik2.Color('blue'), 5.0)
l = mapnik2.LineSymbolizer(s)
eq_(l.stroke.width, 5)
eq_(l.stroke.opacity, 1)
eq_(l.stroke.color, mapnik2.Color('blue'))
eq_(l.stroke.line_cap, mapnik2.line_cap.BUTT_CAP)
eq_(l.stroke.line_join, mapnik2.line_join.MITER_JOIN)
def add_gpx_style(self, gpx_style):
"""Adds mapnik style for styling GPX track
This is blue 40% transparent 4 width line.
Parameters
---------
gpx_style : str
Name of the style layer
Note
----
This doesn't work for some reason. Style is added and if mapnik XML is
saved and read it is used.
"""
self._lazy_init_map()
style = mapnik.Style()
style.filter_mode = mapnik.filter_mode.FIRST
rule = mapnik.Rule()
line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer.stroke = mapnik.Color('rgb(0%,0%,100%)')
line_symbolizer.stroke_width = 4
line_symbolizer.stroke_opacity = 0.4
#line_symbolizer.simplify = 0.1
rule.symbols.append(line_symbolizer)
style.rules.append(rule)
self.m.append_style(gpx_style, style)
print("Making style")
def to_mapnik(self):
stroke = mapnik.Stroke(mapnik.Color(str(self.color)), self.width)
stroke.opacity = self.opacity or stroke.opacity
stroke.line_cap = self.cap or stroke.line_cap
stroke.line_join = self.join or stroke.line_join
if self.dashes:
stroke.add_dash(*self.dashes.values)
sym = mapnik.LineSymbolizer(stroke)
return sym
def test_linesymbolizer_pickle():
p = mapnik2.LineSymbolizer()
p2 = pickle.loads(pickle.dumps(p,pickle.HIGHEST_PROTOCOL))
# line and stroke eq fails, so we compare attributes for now..
s,s2 = p.stroke, p2.stroke
eq_(s.color, s2.color)
eq_(s.opacity, s2.opacity)
eq_(s.width, s2.width)
eq_(s.get_dashes(), s2.get_dashes())
eq_(s.line_cap, s2.line_cap)
eq_(s.line_join, s2.line_join)
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)
# Zoom map to bounding box
m.zoom_to_box(e)
###
### START Layer 1
###
# style object to hold rules
s = mapnik2.Style()
# rule object to hold symbolizers
r = mapnik2.Rule()
# Lines (outlines of polygons and/or simple lines. Line-Color (RGB) line-thickness
line_symbolizer = mapnik2.LineSymbolizer(mapnik2.Color('#f5001d'), 4)
# add the line_symbolizer to the rule object
r.symbols.append(line_symbolizer)
# now add the rule(s) to the style
s.rules.append(r)
# Styles are added to the map
m.append_style('My Style', s)
# Projection from PostGIS-Layer-Data
lyr = mapnik2.Layer(
'Geometry from PostGIS',
'+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs +over'
)
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 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)
provlines_lyr = mapnik2.Layer('Provincial borders')
provlines_lyr.srs = "+proj=lcc +ellps=GRS80 +lat_0=49 +lon_0=-95 +lat+1=49 +lat_2=77 +datum=NAD83 +units=m +no_defs"
provlines_lyr.datasource = mapnik2.Shapefile(file='../data/boundaries_l')
# Here we define a "dash dot dot dash" pattern for the provincial boundaries.
provlines_stk = mapnik2.Stroke()
provlines_stk.add_dash(8, 4)
provlines_stk.add_dash(2, 2)
provlines_stk.add_dash(2, 2)
provlines_stk.color = mapnik2.Color('black')
provlines_stk.width = 1.0
provlines_style = mapnik2.Style()
provlines_rule = mapnik2.Rule()
provlines_rule.symbols.append(mapnik2.LineSymbolizer(provlines_stk))
provlines_style.rules.append(provlines_rule)
m.append_style('provlines', provlines_style)
provlines_lyr.styles.append('provlines')
m.layers.append(provlines_lyr)
# Roads 3 and 4 (The "grey" roads)
roads34_lyr = mapnik2.Layer('Roads')
roads34_lyr.srs = "+proj=lcc +ellps=GRS80 +lat_0=49 +lon_0=-95 +lat+1=49 +lat_2=77 +datum=NAD83 +units=m +no_defs"
# create roads datasource (we're going to re-use it later)
roads34_lyr.datasource = mapnik2.Shapefile(file='../data/roads')
roads34_style = mapnik2.Style()
# 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
###
line_symbolizer = mapnik2.LineSymbolizer(mapnik2.Color('#00d200'), 3) # green
line_symbolizer2 = mapnik2.LineSymbolizer(mapnik2.Color('#eaea00'),
3) # yellow
line_symbolizer3 = mapnik2.LineSymbolizer(mapnik2.Color('#ff7f24'),
3) # orange
line_symbolizer4 = mapnik2.LineSymbolizer(mapnik2.Color('#ec0000'), 3) # red
# add the line_symbolizer to the rule object
r.symbols.append(line_symbolizer)
r2.symbols.append(line_symbolizer2)
r3.symbols.append(line_symbolizer3)
r4.symbols.append(line_symbolizer4)
# now add the rule(s) to the style and we're done
s.rules.append(r)
s2.rules.append(r2)
def ogc_LineSymbolyzer_to_mapnik(sym):
stroke = sym.Stroke
m_stroke = stroke_to_mapnik(stroke)
yield mapnik.LineSymbolizer(m_stroke)
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')