def _test_rgb_8bui_rendering(lbl, tnam, overview, rescale, clip):
if rescale:
lbl += ' Sc'
if clip:
lbl += ' Cl'
ds = mapnik.PgRaster(dbname=MAPNIK_TEST_DBNAME,
table=tnam,
use_overviews=1 if overview else 0,
prescale_rasters=rescale,
clip_rasters=clip)
fs = ds.featureset()
feature = fs.next()
eq_(feature['rid'], 1)
lyr = mapnik.Layer('rgba_8bui')
lyr.datasource = ds
expenv = mapnik.Box2d(-12329035.7652168,4508650.39854396, \
-12328653.0279471,4508957.34625536)
env = lyr.envelope()
# As the input size is a prime number both horizontally
# and vertically, we expect the extent of the overview
# tables to be a pixel wider than the original, whereas
# the pixel size in geographical units depends on the
# overview factor. So we start with the original pixel size
# as base scale and multiply by the overview factor.
# NOTE: the overview table extent only grows north and east
pixsize = 2 # see gdalinfo nodata-edge.tif
tol = pixsize * max(overview.split(',')) if overview else 0
assert_almost_equal(env.minx, expenv.minx, places=0)
assert_almost_equal(env.miny, expenv.miny, delta=tol)
assert_almost_equal(env.maxx, expenv.maxx, delta=tol)
assert_almost_equal(env.maxy, expenv.maxy, places=0)
mm = mapnik.Map(256, 256)
style = mapnik.Style()
sym = mapnik.RasterSymbolizer()
rule = mapnik.Rule()
rule.symbols.append(sym)
style.rules.append(rule)
mm.append_style('foo', style)
lyr.styles.append('foo')
mm.layers.append(lyr)
mm.zoom_to_box(expenv)
im = mapnik.Image(mm.width, mm.height)
t0 = time.time() # we want wall time to include IO waits
mapnik.render(mm, im)
lap = time.time() - t0
log('T ' + str(lap) + ' -- ' + lbl + ' E:full')
expected = 'images/support/pgraster/%s-%s-%s-%s-%s-box1.png' % (
lyr.name, tnam, lbl, overview, clip)
compare_images(expected, im)
# no data
eq_(hexlify(im.view(3, 16, 1, 1).tostring()), '00000000')
eq_(hexlify(im.view(128, 16, 1, 1).tostring()), '00000000')
eq_(hexlify(im.view(250, 16, 1, 1).tostring()), '00000000')
eq_(hexlify(im.view(3, 240, 1, 1).tostring()), '00000000')
eq_(hexlify(im.view(128, 240, 1, 1).tostring()), '00000000')
eq_(hexlify(im.view(250, 240, 1, 1).tostring()), '00000000')
# dark brown
eq_(hexlify(im.view(174, 39, 1, 1).tostring()), 'c3a698ff')
# dark gray
eq_(hexlify(im.view(195, 132, 1, 1).tostring()), '575f62ff')
# Now zoom over a portion of the env (1/10)
newenv = mapnik.Box2d(-12329035.7652168, 4508926.651484220, \
-12328997.49148983,4508957.34625536)
mm.zoom_to_box(newenv)
t0 = time.time() # we want wall time to include IO waits
im = mapnik.Image(mm.width, mm.height)
mapnik.render(mm, im)
lap = time.time() - t0
log('T ' + str(lap) + ' -- ' + lbl + ' E:1/10')
expected = 'images/support/pgraster/%s-%s-%s-%s-%s-box2.png' % (
lyr.name, tnam, lbl, overview, clip)
compare_images(expected, im)
# no data
eq_(hexlify(im.view(3, 16, 1, 1).tostring()), '00000000')
eq_(hexlify(im.view(128, 16, 1, 1).tostring()), '00000000')
eq_(hexlify(im.view(250, 16, 1, 1).tostring()), '00000000')
# black
eq_(hexlify(im.view(3, 42, 1, 1).tostring()), '000000ff')
eq_(hexlify(im.view(3, 134, 1, 1).tostring()), '000000ff')
eq_(hexlify(im.view(3, 244, 1, 1).tostring()), '000000ff')
# gray
eq_(hexlify(im.view(135, 157, 1, 1).tostring()), '4e555bff')
# brown
eq_(hexlify(im.view(195, 223, 1, 1).tostring()), 'f2cdbaff')
def school_sheds_results(request=None,
school_id=None,
bbox=None,
width=816,
height=1056,
srid=3857,
format='png'):
'''
Default height and width are 'Letter' ratio
'''
format = format.encode('ascii')
school = School.objects.get(pk=school_id)
point = school.geometry
circle = point.buffer(3400.0)
m = mapnik.Map(int(width), int(height), "+init=epsg:" + str(srid))
mapnik.load_map(m, os.path.dirname(__file__) + "/basemap/basemap.xml")
if bbox is None:
circle.transform(srid)
bbox = mapnik.Box2d(*circle.extent)
m.zoom_to_box(bbox)
#m.background = mapnik.Color('steelblue')
# styles for sheds
s = mapnik.Style()
for name, color in (('0.5', VIOLET), ('1.0', PURPLE), ('1.5', LAVENDER),
('2.0', LIGHTCYAN)):
r = mapnik.Rule()
r.filter = mapnik.Expression("[name] = " + name)
c = mapnik.Color(color)
c.a = 80
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color("gray"), 1)
poly_symbolizer = mapnik.PolygonSymbolizer(c)
r.symbols.append(line_symbolizer)
r.symbols.append(poly_symbolizer)
s.rules.append(r)
# styles for schools
school_colors = SCHOOL_COLORS
for name, color in school_colors:
r = mapnik.Rule()
r.filter = mapnik.Expression("[name] = '" + name + "'")
line_symbolizer = mapnik.LineSymbolizer()
poly_symbolizer = mapnik.PolygonSymbolizer(mapnik.Color(color))
r.symbols.append(line_symbolizer)
r.symbols.append(poly_symbolizer)
s.rules.append(r)
r = mapnik.Rule()
r.filter = mapnik.Expression(
"[name] != 'map_title' and [name] != 'map_subtitle' and [name] != 'legend_title' and [name] != 'school'"
)
text_symbolizer = mapnik.TextSymbolizer(mapnik.Expression('[label]'),
'DejaVu Sans Book', 9,
mapnik.Color('black'))
text_symbolizer.halo_fill = mapnik.Color('white')
text_symbolizer.halo_radius = 1
text_symbolizer.horizontal_alignment = mapnik.horizontal_alignment.RIGHT
#text_symbolizer.label_placement = mapnik.label_placement.VERTEX_PLACEMENT
text_symbolizer.allow_overlap = True
text_symbolizer.displacement = (12, 0)
r.symbols.append(text_symbolizer)
s.rules.append(r)
r = mapnik.Rule()
r.filter = mapnik.Expression("[name] = 'map_title'")
text_symbolizer = mapnik.TextSymbolizer(mapnik.Expression('[label]'),
'DejaVu Sans Book', 15,
mapnik.Color('black'))
text_symbolizer.horizontal_alignment = mapnik.horizontal_alignment.RIGHT
text_symbolizer.halo_fill = mapnik.Color('white')
text_symbolizer.allow_overlap = True
r.symbols.append(text_symbolizer)
s.rules.append(r)
r = mapnik.Rule()
r.filter = mapnik.Expression("[name] = 'map_subtitle'")
text_symbolizer = mapnik.TextSymbolizer(mapnik.Expression('[label]'),
'DejaVu Sans Book', 12,
mapnik.Color('black'))
text_symbolizer.horizontal_alignment = mapnik.horizontal_alignment.RIGHT
text_symbolizer.halo_fill = mapnik.Color('white')
text_symbolizer.allow_overlap = True
r.symbols.append(text_symbolizer)
s.rules.append(r)
r = mapnik.Rule()
r.filter = mapnik.Expression("[name] = 'legend_title'")
text_symbolizer = mapnik.TextSymbolizer(mapnik.Expression('[label]'),
'DejaVu Sans Condensed Bold', 11,
mapnik.Color('black'))
text_symbolizer.horizontal_alignment = mapnik.horizontal_alignment.RIGHT
text_symbolizer.halo_fill = mapnik.Color('white')
text_symbolizer.halo_radius = 1
text_symbolizer.allow_overlap = True
r.symbols.append(text_symbolizer)
s.rules.append(r)
r = mapnik.Rule()
r.filter = mapnik.Expression("[name] = 'legend_box'")
poly_symbolizer = mapnik.PolygonSymbolizer(mapnik.Color("white"))
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color("black"), 0.5)
poly_symbolizer.fill_opacity = 0.8
r.symbols.append(line_symbolizer)
r.symbols.append(poly_symbolizer)
s.rules.append(r)
r = mapnik.Rule()
r.filter = mapnik.Expression("[name] = 'school'")
ps = mapnik.PointSymbolizer(
mapnik.PathExpression(
os.path.dirname(__file__) + '/static/img/School.svg'))
ps.transform = 'scale(0.06)'
ps.allow_overlap = True
#shield.label_placement = mapnik.label_placement.POINT_PLACEMENT
r.symbols.append(ps)
s.rules.append(r)
m.append_style("surveys", s)
def p2l(pct_x, pct_y):
loc_x = bbox.minx + (bbox.maxx - bbox.minx) * pct_x / 100.0
loc_y = bbox.miny + (bbox.maxy - bbox.miny) * pct_y / 100.0
return (loc_x, loc_y)
sheds = {
0.5: school.shed_05,
1.0: school.shed_10,
1.5: school.shed_15,
2.0: school.shed_20
}
csv_string = 'wkt,name,label\n'
for key, g in reversed(sorted(sheds.items(), key=lambda a: a[0])):
if g is None:
continue
g.srid = 26986
g.transform(srid)
csv_string += '"%s","%s",""\n' % (g.wkt, str(key))
surveys = Survey.objects.filter(school=school)
for survey in surveys:
survey.location.transform(srid)
children = list(survey.child_set.all())
if len(children) > 0:
for c in children:
name = str(c.to_school)
point = survey.location
point.x += random.randint(-50, 50)
point.y += random.randint(-50, 50)
school_circle = point.buffer(50)
csv_string += '"%s","%s",""\n' % (school_circle.wkt, name)
else:
name = "o"
point = survey.location
point.x += random.randint(-50, 50)
point.y += random.randint(-50, 50)
school_circle = point.buffer(50)
csv_string += '"%s","%s",""\n' % (school_circle.wkt, name)
#Add School geometry
school.geometry.transform(srid)
csv_string += '"%s","school","%s"\n' % (school.geometry.wkt, school.name)
def box(minx, miny, maxx, maxy):
lmin = Point(p2l(minx, miny))
lmax = Point(p2l(maxx, maxy))
lr = LinearRing((lmin.x, lmin.y), (lmax.x, lmin.y), (lmax.x, lmax.y),
(lmin.x, lmax.y), (lmin.x, lmin.y))
poly = Polygon(lr)
return poly
legend = box(2, 108, 50, 113.5)
csv_string += '"%s","%s","%s"\n' % (legend.wkt, "legend_box", "")
xy = p2l(3.5, 112)
point = Point(*xy)
csv_string += '"%s","%s","School Commute Survey Results"\n' % (point.wkt,
"map_title")
xy = p2l(3.5, 109.5)
point = Point(*xy)
csv_string += '"%s","%s","%s, %s"\n' % (point.wkt, "map_subtitle", school,
school.districtid)
legend_x = 53
legend = box(legend_x, 97, 97.5, 113.5)
csv_string += '"%s","%s","%s"\n' % (legend.wkt, "legend_box", "")
xy = p2l(legend_x + 1.5, 112)
point = Point(*xy)
csv_string += '"%s","legend_title","Approx. home locations and travel to school mode"\n' % (
point.wkt, )
walksheds_x = 88
xy = p2l(walksheds_x, 112)
point = Point(*xy)
csv_string += '"%s","legend_title","Walksheds"\n' % (point.wkt, )
y = 111.5
for name, label in school_colors:
y -= 1.8
xy = p2l(legend_x + 2, y)
point = Point(*xy)
circle = point.buffer(50)
csv_string += '"%s","%s","%s"\n' % (circle.wkt, name, MODE_DICT[name])
y = 110
for name in (
'0.5',
'1.0',
'1.5',
'2.0',
):
y -= 2.4
ws = box(walksheds_x, y, walksheds_x + 2, y + 1.5)
csv_string += '"%s","%s","%s Mile"\n' % (ws.wkt, name, name)
layer = mapnik.Layer('surveys', "+init=epsg:" + str(srid))
ds = mapnik.Datasource(type="csv", inline=csv_string.encode('ascii'))
layer.datasource = ds
layer.styles.append('surveys')
m.layers.append(layer)
# Render to image
if format == 'pdf':
tmp_file = tempfile.NamedTemporaryFile()
surface = cairo.PDFSurface(tmp_file.name, m.width, m.height)
mapnik.render(m, surface)
surface.finish()
tmp_file.seek(0)
im = tmp_file.read()
else:
im = mapnik.Image(m.width, m.height)
mapnik.render(m, im)
im = im.tostring(format)
response = HttpResponse()
response['Content-length'] = str(len(im))
response['Content-Type'] = mimetypes.types_map['.' + format]
response.write(im)
return response
# -*- coding: utf-8 -*-
import os
import mapnik
from helper.textool import get_tmp_file
stylesheet = os.path.splitext(os.path.realpath(__file__))[0] + '.xml'
# image = 'xx_world_style_from_xml.png'
m = mapnik.Map(600, 300)
mapnik.load_map(m, stylesheet)
m.zoom_all()
# m.background = mapnik.Color('steelblue')
# bbox = mapnik.Box2d(118, 36.6, 124.6, 40.7)
bbox = mapnik.Box2d(-1, -1, 25, 1)
m.zoom_to_box(bbox)
mapnik.render_to_file(m, get_tmp_file(__file__, 1))
mapnik.render_to_file(m, get_tmp_file(__file__, 1, file_ext='pdf'))
# stylesheet = os.path.splitext(os.path.realpath(__file__))[0] + '1.xml'
#
# # image = 'xx_world_style_from_xml.png'
# m = mapnik.Map(600, 300)
# mapnik.load_map(m, stylesheet)
# m.zoom_all()
# # m.background = mapnik.Color('steelblue')
#
# # bbox = mapnik.Box2d(118, 36.6, 124.6, 40.7)
#
# m.zoom_to_box(bbox)
import mapnik
m = mapnik.Map(1280, 720)
m.background = mapnik.Color('steelblue')
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('White')
r.symbols.append(polygon_symbolizer)
s.rules.append(r)
m.append_style('Yoesril', s)
ds = mapnik.Shapefile(file="INDONESIA_PROP.shp")
layer = mapnik.Layer('world')
layer.datasource = ds
layer.styles.append('Yoesril')
m.layers.append(layer)
m.zoom_all()
s.rules.append(r)
point_sym = mapnik.MarkersSymbolizer()
point_sym.filename
s = mapnik.Style()
r = mapnik.Rule()
basinsLabels = mapnik.TextSymbolizer(mapnik.Expression('[point]'),
'DejaVu Sans Bold', 2,
mapnik.Color('black'))
basinsLabels.halo_fill = mapnik.Color('Yellow')
basinsLabels.halo_radius = 0.3
# -*- coding: utf-8 -*-
print('=' * 40)
print(__file__)
from helper.textool import get_tmp_file
################################################################################
import mapnik
nmap = mapnik.Map(600, 400)
################################################################################
nmap.srs
################################################################################
style1, style2, style3 = [mapnik.Style()] * 3
nmap.append_style("s1", style1)
nmap.append_style("s2", style2)
nmap.append_style("s3", style1)
nmap.append_style("s1", style3)
################################################################################
layer = mapnik.Layer('lyrname')
layer.srs
################################################################################
ds = mapnik.Shapefile(file='/gdata/GSHHS_c.shp')
layer.datasource = ds
layer.styles.append("s1")
layer.styles.append("s2")
################################################################################
nmap.layers.append(layer)
def testMapnik():
#Help from Dane Springmeyer: https://gist.github.com/3438657
#print mapnik.mapnik_version_string()
#mapfile = '/home/klammer/Software/Quickly/TileGen/tilegen/data/media/testdaten/mercator_polygon/vogtland_style_PC-version.xml'
mapfile = '/home/klammer/Software/Quickly/TileGen/tilegen/data/media/testdaten/mercator_polygon/slippy_vogtland.xml'
imgx = 256
imgy = 256
#print dir(imgx)
m = mapnik.Map(imgx, imgy)
mapnik.load_map(m, mapfile)
print mapnik.scale_denominator(m, mapnik.Projection(m.srs).geographic)
m.zoom_all()
m.buffer_size = 128
print '*Number of Layers: ', m.layers.__len__()
for layer in m.layers.__iter__():
print layer.name
#print layer.datasource.params().get('type')
#print layer.name
#print layer.datasource
#print dir(layer.datasource)
#print dir(layer.datasource.envelope())
#print layer.datasource.envelope()
#print layer.datasource.params().as_dict()['type']
#print layer.datasource.envelope().minx
#print layer.datasource.envelope().width()
#desc = layer.datasource.params().as_dict()
#print desc
#print layer.srs
#print layer.datasource.envelope()[0]
#print dir(layer.datasource.features)
length = len(layer.datasource.all_features())
# if length < 10:
# print dir(layer.datasource.all_features())
# for feature in layer.datasource.all_features().__iter__():
# print dir(feature)
# for item in feature.iteritems():
# print item
# print dir(layer.datasource)
#print layer.datasource.fields()
#print '**Number of Styles: ',len(layer.styles)
for i in xrange(len(layer.styles)):
#print layer.styles[i]
style = m.find_style(layer.styles[i])
#print '***Number of Rules: ',len(style.rules)
# for rule in style.rules.__iter__():
# print rule.filter, rule.min_scale, rule.max_scale
# for j in xrange(len(rule.symbols)):
# symbol = rule.symbols[j]
# print symbol
# symbol_type = str(symbol).split('.')[2].split(' ')[0]
# #print symbol_type
# if symbol_type == 'PolygonSymbolizer':
# help = 0
# #print symbol.fill, symbol.fill_opacity, symbol.gamma
# elif symbol_type == 'LineSymbolizer':
# stroke = symbol.stroke
# #print stroke.color, stroke.dash_offset, stroke.gamma, stroke.line_cap, stroke.line_join, stroke.opacity, stroke.width
## else:
# print 'Please implement the missing types!!!!!'
##print mapnik.save_map_to_string(m)
for plugs in mapnik.DatasourceCache.plugin_names():
plug_in = ''
for i in xrange(plugs.__len__()):
plug_in = plug_in + plugs.__getitem__(i)
#print plug_in
ds = mapnik.Shapefile(
file=
'/home/klammer/Software/Quickly/TileGen/tilegen/data/media/testdaten/mercator_polygon/lines.shp'
)
def test_render_with_scale_factor_zero_throws():
m = mapnik.Map(256, 256)
im = mapnik.Image(256, 256)
mapnik.render(m, im, 0.0)
def test_adding_datasource_to_layer():
map_string = '''<?xml version="1.0" encoding="utf-8"?>
<Map>
<Layer name="world_borders">
<StyleName>world_borders_style</StyleName>
<StyleName>point_style</StyleName>
<!-- leave datasource empty -->
<!--
<Datasource>
<Parameter name="file">../data/shp/world_merc.shp</Parameter>
<Parameter name="type">shape</Parameter>
</Datasource>
-->
</Layer>
</Map>
'''
m = mapnik.Map(256, 256)
try:
mapnik.load_map_from_string(m, map_string)
# validate it loaded fine
eq_(m.layers[0].styles[0], 'world_borders_style')
eq_(m.layers[0].styles[1], 'point_style')
eq_(len(m.layers), 1)
# also assign a variable reference to that layer
# below we will test that this variable references
# the same object that is attached to the map
lyr = m.layers[0]
# ensure that there was no datasource for the layer...
eq_(m.layers[0].datasource, None)
eq_(lyr.datasource, None)
# also note that since the srs was black it defaulted to wgs84
eq_(m.layers[0].srs,
'+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
eq_(lyr.srs, '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
# now add a datasource one...
ds = mapnik.Shapefile(file='../data/shp/world_merc.shp')
m.layers[0].datasource = ds
# now ensure it is attached
eq_(m.layers[0].datasource.describe()['name'], "shape")
eq_(lyr.datasource.describe()['name'], "shape")
# and since we have now added a shapefile in spherical mercator, adjust the projection
lyr.srs = '+proj=merc +lon_0=0 +lat_ts=0 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m +no_defs'
# test that assignment
eq_(
m.layers[0].srs,
'+proj=merc +lon_0=0 +lat_ts=0 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m +no_defs'
)
eq_(
lyr.srs,
'+proj=merc +lon_0=0 +lat_ts=0 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m +no_defs'
)
except RuntimeError, e:
# only test datasources that we have installed
if not 'Could not create datasource' in str(e):
raise RuntimeError(e)
WHERE nspname NOT LIKE E'pg\\_%' AND
nspname <> 'information_schema' AND
relkind IN ('r','S','v') ORDER BY relkind = 'S') s;
""")
con.commit()
cur.close()
con.close()
# Call function to create the views
create_views(dsn, dbprefix, viewprefix, hstore, columns, date)
# Create map with width height
m = mapnik.Map(pic_output_width, pic_output_height)
# Load osm-xml-stylesheet for rendering the views
mapnik.load_map(m, path_to_osm_xml)
# Define projection
prj = mapnik.Projection(
"+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"
)
# Map bounds. Bound values come from SQL-query
if hasattr(mapnik, 'Box2d'):
bbox = mapnik.Box2d(xmin, ymin, xmax, ymax)
else:
bbox = mapnik.Envelope(xmin, ymin, xmax, ymax)
mapfile = "osm.xml"
map_uri = "image.png"
#---------------------------------------------------
# Change this to the bounding box you want
#
#bounds = (-96, 33, -89, 36)
bounds = (-92.493874, 34.626320, -92.15654, 34.818401) #Little Rock
#---------------------------------------------------
z = 11
imgx = 500 * z
imgy = 1000 * z
m = mapnik.Map(imgx, imgy)
mapnik.load_map(m, mapfile)
# ensure the target map projection is mercator
m.srs = merc.params()
s = mapnik.Style() # style object to hold rules
r = mapnik.Rule() # rule object to hold symbolizers
point_sym = mapnik.PointSymbolizer()
point_sym.filename = './symbols/airport.p.16.png'
r.symbols.append(point_sym) # add the symbolizer to the rule object
s.rules.append(r) # now add the rule to the style and we're done
m.append_style('airport point', s)
ds = mapnik.MemoryDatasource()
f = mapnik.Feature(mapnik.Context(), 1)
f.add_geometries_from_wkt("POINT(-92.289595 34.746481)")
def getMapImage(osmFile, map_output):
'''Uses the data from the osmFile to out a .png image
of the area depicted by the input file'''
if not HAS_MAPNIK:
print('Error: Mapnik module is missing. ' +
'Please install for getting the image functionality.')
return -2
print('Has Mapnik.')
if osmFile == '':
print 'Error: getMapImage::No File Recieved'
return -1
else:
print('OSM File: ' + osmFile)
highwayList = dict({
"motorway": {
'width': 4,
'color': 'green',
'fontSize': 12
},
"trunk": {
'width': 3,
'color': 'green',
'fontSize': 11
},
"primary": {
'width': 1.5,
'color': '#0090ff',
'fontSize': 10
},
"secondary": {
'width': 0.8,
'color': '#ff00ff',
'fontSize': 8
},
"tertiary": {
'width': 0.42,
'color': '#000000',
'fontSize': 8
},
"residential": {
'width': 0.21,
'color': 'black',
'fontSize': 8
},
"living_street": {
'width': 0.21,
'color': 'black',
'fontSize': 8
},
"pedestrian": {
'width': 0.21,
'color': 'brown',
'fontSize': 8
},
"footway": {
'width': 0.21,
'color': 'brown',
'fontSize': 8
}
})
m = mapnik.Map(1024, 1024)
m.background = mapnik.Color('white')
for highwayType in highwayList.keys():
styleType = mapnik.Style()
print(styleType)
rule = mapnik.Rule()
rule.filter = mapnik.Expression('[highway]=' + "'" + highwayType + "'")
stk = mapnik.Stroke()
stk.color = mapnik.Color(highwayList[highwayType]['color'])
stk.line_cap = mapnik.line_cap.ROUND_CAP
stk.width = highwayList[highwayType]['width']
line_symbolizer = mapnik.LineSymbolizer(stk)
rule.symbols.append(line_symbolizer)
rule2 = mapnik.Rule()
rule2.filter = mapnik.Expression('[highway]=' + "'" + highwayType +
"'")
text_symbolizer = mapnik.TextSymbolizer(
mapnik.Expression("[name]"), "DejaVu Sans Book",
highwayList[highwayType]['fontSize'], mapnik.Color('black'))
text_symbolizer.halo_fill = mapnik.Color('white')
rule2.symbols.append(text_symbolizer)
styleType.rules.append(rule)
styleType.rules.append(rule2)
m.append_style(highwayType, styleType)
ds = mapnik.Osm(file=osmFile)
layer = mapnik.Layer('world')
layer.datasource = ds
for highwayType in highwayList.keys():
layer.styles.append(highwayType)
m.layers.append(layer)
m.zoom_all()
mapnik.render_to_file(m, map_output, 'png')
return os.system('xdg-open ' + map_output)
def renderTile(self, tile):
import mapnik
if self.mapnik:
m = self.mapnik
else:
if self.fonts:
engine = mapnik.FontEngine.instance()
for font in self.fonts:
engine.register_font(font)
# Init it as 0,0
m = mapnik.Map(0, 0)
mapnik.load_map(m, self.mapfile)
if self.projection:
m.srs = self.projection
# Restrict layer list, if requested
if self.layers and self.layers != self.name:
layers = self.layers.split(",")
for layer_num in range(len(m.layers) - 1, -1, -1):
l = m.layers[layer_num]
if l.name not in layers:
del m.layers[layer_num]
if self.debug:
print >> sys.stderr, "Removed layer %s loaded from %s, not in list: %s" % (
l.name, self.mapfile, layers)
# this will insure that it gets cached in mod_python
self.mapnik = m
# Set the mapnik size to match the size of the current tile
m.width = tile.size()[0]
m.height = tile.size()[1]
bbox = tile.bounds()
bbox = mapnik.Envelope(bbox[0], bbox[1], bbox[2], bbox[3])
m.zoom_to_box(bbox)
im = mapnik.Image(*tile.size())
mapnik.render(m, im)
if hasattr(im, 'tostring'):
if self.paletted:
data = im.tostring('png256')
else:
data = im.tostring(self.extension)
tile.data = data
return tile.data
elif hasattr(mapnik, 'rawdata'):
data = mapnik.rawdata(im)
import PIL.Image, StringIO
im = PIL.Image.fromstring('RGBA', tile.size(), data)
buffer = StringIO.StringIO()
if self.paletted:
print >> sys.stderr, "Mapnik's 8-bit (png256) format not supported with PIL"
im.save(buffer, self.extension)
buffer.seek(0)
tile.data = buffer.read()
return tile.data
else:
raise Exception(
"Something is wrong: your version of Mapnik can't create a string from an image."
)
def _test_rgba_subquery(lbl, pixtype, r, g, b, a, g1, b1):
#
# 3 8 13
# +---+---+---+
# 3 | v | v | h | NOTE: writes different alpha
# +---+---+---+ in 13,8 and 8,13
# 8 | v | v | a |
# +---+---+---+
# 13 | v | b | v |
# +---+---+---+
#
sql = "(select 3 as i, " \
" ST_SetValues(" \
" ST_SetValues(" \
" ST_AddBand(" \
" ST_AddBand(" \
" ST_AddBand(" \
" ST_AsRaster(" \
" ST_MakeEnvelope(0,0,14,14), " \
" 1.0, -1.0, '%s', %s" \
" )," \
" '%s', %d::float" \
" ), " \
" '%s', %d::float" \
" ), " \
" '%s', %d::float" \
" ), " \
" 2, 11, 6, 4, 5, %s::float8" \
" )," \
" 3, 6, 11, 5, 4, %s::float8" \
" ) as r" \
") as foo" % (pixtype, r, pixtype, g, pixtype, b, pixtype, a, g1, b1)
overview = ''
rescale = 0
clip = 0
if rescale:
lbl += ' Sc'
if clip:
lbl += ' Cl'
ds = mapnik.PgRaster(dbname=MAPNIK_TEST_DBNAME,
table=sql,
raster_field='r',
use_overviews=0 if overview else 0,
prescale_rasters=rescale,
clip_rasters=clip)
fs = ds.featureset()
feature = fs.next()
eq_(feature['i'], 3)
lyr = mapnik.Layer('rgba_subquery')
lyr.datasource = ds
expenv = mapnik.Box2d(0, 0, 14, 14)
env = lyr.envelope()
assert_almost_equal(env.minx, expenv.minx, places=0)
assert_almost_equal(env.miny, expenv.miny, places=0)
assert_almost_equal(env.maxx, expenv.maxx, places=0)
assert_almost_equal(env.maxy, expenv.maxy, places=0)
mm = mapnik.Map(15, 15)
style = mapnik.Style()
sym = mapnik.RasterSymbolizer()
rule = mapnik.Rule()
rule.symbols.append(sym)
style.rules.append(rule)
mm.append_style('foo', style)
lyr.styles.append('foo')
mm.layers.append(lyr)
mm.zoom_to_box(expenv)
im = mapnik.Image(mm.width, mm.height)
t0 = time.time() # we want wall time to include IO waits
mapnik.render(mm, im)
lap = time.time() - t0
log('T ' + str(lap) + ' -- ' + lbl + ' E:full')
expected = 'images/support/pgraster/%s-%s-%s-%s-%s-%s-%s-%s-%s.png' % (
lyr.name, lbl, pixtype, r, g, b, a, g1, b1)
compare_images(expected, im)
hex_v = format(r << 24 | g << 16 | b << 8 | a, '08x')
hex_a = format(r << 24 | g1 << 16 | b << 8 | a, '08x')
hex_b = format(r << 24 | g << 16 | b1 << 8 | a, '08x')
eq_(hexlify(im.view(3, 3, 1, 1).tostring()), hex_v)
eq_(hexlify(im.view(8, 3, 1, 1).tostring()), hex_v)
eq_(hexlify(im.view(13, 3, 1, 1).tostring()), hex_v)
eq_(hexlify(im.view(3, 8, 1, 1).tostring()), hex_v)
eq_(hexlify(im.view(8, 8, 1, 1).tostring()), hex_v)
eq_(hexlify(im.view(13, 8, 1, 1).tostring()), hex_a)
eq_(hexlify(im.view(3, 13, 1, 1).tostring()), hex_v)
eq_(hexlify(im.view(8, 13, 1, 1).tostring()), hex_b)
eq_(hexlify(im.view(13, 13, 1, 1).tostring()), hex_v)
def _test_data_subquery(lbl, pixtype, value):
#
# 3 8 13
# +---+---+---+
# 3 | v | v | v | NOTE: writes different values
# +---+---+---+ in 13,8 and 8,13
# 8 | v | v | a |
# +---+---+---+
# 13 | v | b | v |
# +---+---+---+
#
val_a = value / 3
val_b = val_a * 2
sql = "(select 3 as i, " \
" ST_SetValues(" \
" ST_SetValues(" \
" ST_AsRaster(" \
" ST_MakeEnvelope(0,0,14,14), " \
" 1.0, -1.0, '%s', %s" \
" ), " \
" 11, 6, 5, 5, %s::float8" \
" )," \
" 6, 11, 5, 5, %s::float8" \
" ) as \"R\"" \
") as foo" % (pixtype,value, val_a, val_b)
overview = ''
rescale = 0
clip = 0
if rescale:
lbl += ' Sc'
if clip:
lbl += ' Cl'
ds = mapnik.PgRaster(dbname=MAPNIK_TEST_DBNAME,
table=sql,
raster_field='R',
use_overviews=0 if overview else 0,
band=1,
prescale_rasters=rescale,
clip_rasters=clip)
fs = ds.featureset()
feature = fs.next()
eq_(feature['i'], 3)
lyr = mapnik.Layer('data_subquery')
lyr.datasource = ds
expenv = mapnik.Box2d(0, 0, 14, 14)
env = lyr.envelope()
assert_almost_equal(env.minx, expenv.minx, places=0)
assert_almost_equal(env.miny, expenv.miny, places=0)
assert_almost_equal(env.maxx, expenv.maxx, places=0)
assert_almost_equal(env.maxy, expenv.maxy, places=0)
mm = mapnik.Map(15, 15)
style = mapnik.Style()
col = mapnik.RasterColorizer()
col.default_mode = mapnik.COLORIZER_DISCRETE
col.add_stop(val_a, mapnik.Color(0xff, 0x00, 0x00, 255))
col.add_stop(val_b, mapnik.Color(0x00, 0xff, 0x00, 255))
col.add_stop(value, mapnik.Color(0x00, 0x00, 0xff, 255))
sym = mapnik.RasterSymbolizer()
sym.colorizer = col
rule = mapnik.Rule()
rule.symbols.append(sym)
style.rules.append(rule)
mm.append_style('foo', style)
lyr.styles.append('foo')
mm.layers.append(lyr)
mm.zoom_to_box(expenv)
im = mapnik.Image(mm.width, mm.height)
t0 = time.time() # we want wall time to include IO waits
mapnik.render(mm, im)
lap = time.time() - t0
log('T ' + str(lap) + ' -- ' + lbl + ' E:full')
expected = 'images/support/pgraster/%s-%s-%s-%s.png' % (lyr.name, lbl,
pixtype, value)
compare_images(expected, im)
def render_element(style_file, db_name, element_type, zoom, tags, width,
png_path):
""" render a single legend element
Arguments:
* style_file - a mapnik xml style file
* db_name - osm2pgsql db name for style_file
* element_type - point, line, etc...
* zoom - zoom factor to render for
* tags - OSM element tags
* width - width of image to generate, height will be auto-calculated
* png_path - where to store the result image
"""
tmpdir = tempfile.mkdtemp()
osm_xml = os.path.join(tmpdir, 'data.osm')
rendered_img = os.path.join(tmpdir, 'result.png')
tree = create_osm_tree()
osm = tree.getroot()
bound = add_osm_element(osm, element_type, zoom, tags)
tree.write(osm_xml, pretty_print=True)
cmd = "osm2pgsql --create --database=%s --merc --slim --hstore-all --style=import.style --tag-transform-script=import.lua %s 2>/dev/null" % (
db_name, osm_xml)
os.system(cmd)
lonlat_proj = mapnik.Projection('+proj=longlat +datum=WGS84')
ratio = abs((bound[2] - bound[0]) / (bound[3] - bound[1]))
height = int(width / ratio * 1)
map = mapnik.Map(width, height)
mapnik.load_map(map, style_file)
mapnik.background = Color('white')
map.srs = lonlat_proj.params()
bbox = lonlat_proj.forward(
mapnik.Box2d(mapnik.Coord(bound[0], bound[1]),
mapnik.Coord(bound[2], bound[3])))
map.zoom_to_box(bbox)
im = mapnik.Image(width, height)
mapnik.render(map, im)
view = im.view(0, 0, width, height)
view.save(rendered_img, 'png')
img = Image.open(rendered_img)
if len(img.getcolors()) == 1:
return False
img256 = img.convert('L')
imgbg = ImageChops.constant(img256, img256.getpixel((0, 0)))
box = ImageChops.difference(img256, imgbg).getbbox()
out = img.crop(box)
out.save(png_path, 'png')
shutil.rmtree(tmpdir)
return True
def test_pre_multiply_status_of_map1():
m = mapnik.Map(256, 256)
im = mapnik.Image(m.width, m.height)
eq_(validate_pixels_are_not_premultiplied(im), True)
mapnik.render(m, im)
eq_(validate_pixels_are_not_premultiplied(im), True)
import mapnik m = mapnik.Map(1024, 600) mapnik.load_map(m, "mapnik_composite.xml") m.zoom_all() mapnik.render_to_file(m, "images/simple_map_5.png")
import os
import mapnik
import sqlite3
from hashlib import md5
### ======================================
NUM_IMG = 0
### ======================================
### Setup Mapnik
# create the map
_map = mapnik.Map(256, 256)
# set a background color
_map.background = mapnik.Color('transparent')
# create a polygon symbolizer
poly_color = mapnik.Color('black')
poly_sym = mapnik.PolygonSymbolizer(poly_color)
# create a rule and add symbolizer to it
rule = mapnik.Rule()
rule.symbols.append(poly_sym)
# create a style and add rule to it
style = mapnik.Style()
style.rules.append(rule)
# add style to map as "MyStyle"
_map.append_style('MyStyle', style)
# Compute the bounds.
top_left_lon = -74.06
top_left_lat = 41.12
bottom_right_lon = -73.90
bottom_right_lat = 40.85
box_coords = [
merc_x(bottom_right_lon),
merc_y(bottom_right_lat),
merc_x(top_left_lon),
merc_y(top_left_lat),
]
bounds = mapnik.Box2d(*box_coords)
# Create the map.
factor = 4 # higher for higher res
m = mapnik.Map(1024*factor, 2048*factor)
m.background = mapnik.Color("#FFFFFF")
m.aspect_fix_mode = mapnik.aspect_fix_mode.ADJUST_BBOX_HEIGHT
m.zoom_to_box(bounds)
# Create the style.
s = mapnik.Style()
r = mapnik.Rule()
line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer.stroke_width = 1.95
r.symbols.append(line_symbolizer)
s.rules.append(r)
m.append_style("basic_style", s)
# Create the layer.
layer = mapnik.Layer("osm_lines")
#!/usr/bin/env python2 # -*- coding: utf-8 -*- """ Created on Wed Apr 17 17:17:08 2019 @author: phunh """ import mapnik map = mapnik.Map(800, 600) mapnik.load_map(map, 'map_style.xml') map.zoom_all() mapnik.render_to_file(map, '../output/world_xml.png')
def map_image(zoom, left, bottom, right, top, line, orientation='n', highres=True):
mapfile = settings.MAPNIK_STYLES + "mapnik2normal.xml"
if orientation != 'n':
mapfile = settings.MAPNIK_STYLES + "mapnik2orlice_%s.xml" % str(orientation)
imgx, imgy = get_image_size(zoom, top, left, bottom, right)
if orientation in ('w', 'e'):
imgx, imgy = imgy, imgx
if highres:
mapfile = settings.MAPNIK_STYLES + "mapnik2print.xml"
if orientation != 'n':
mapfile = settings.MAPNIK_STYLES + "mapnik2print_orlice_%s.xml" % str(orientation)
imgx = 2*imgx
imgy = 2*imgy
m = mapnik.Map(imgx, imgy)
mapnik.load_map(m, mapfile)
prj = mapnik.Projection('+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')
# North on top
n0 = prj.forward(mapnik.Coord(left, bottom))
n1 = prj.forward(mapnik.Coord(right, top))
# East on top
e0 = mapnik.Coord(-n0.y, n0.x)
e1 = mapnik.Coord(-n1.y, n1.x)
# South on top
s0 = mapnik.Coord(-n1.x, -n1.y)
s1 = mapnik.Coord(-n0.x, -n0.y)
# West on top
w0 = mapnik.Coord(-e1.x, -e1.y)
w1 = mapnik.Coord(-e0.x, -e0.y)
# bottom_left = prj.forward(mapnik.Coord(left, bottom))
# top_right = prj.forward(mapnik.Coord(right, top))
boxes = {'n': mapnik.Box2d(n0.x, n0.y, n1.x, n1.y),
'e': mapnik.Box2d(e0.x, e0.y, e1.x, e1.y),
's': mapnik.Box2d(s0.x, s0.y, s1.x, s1.y),
'w': mapnik.Box2d(w0.x, w0.y, w1.x, w1.y)
}
if line:
gpxstyle = mapnik.Style()
gpxrule = mapnik.Rule()
lns = mapnik.LineSymbolizer()
stroke = mapnik.Stroke()
stroke.color = mapnik.Color('#FF6600')
if highres:
stroke.width = 10
else:
stroke.width = 5
stroke.opacity = 0.9
stroke.line_join = mapnik.line_join.names['round']
stroke.line_cap = mapnik.line_cap.names['round']
lns.stroke = stroke
gpxrule.symbols.append(lns)
gpxstyle.rules.append(gpxrule)
m.append_style('gpxstyle', gpxstyle)
gpxlayer = mapnik.Layer('gpx')
gpxlayer.datasource = mapnik.Ogr(file=line, layer='OGRGeoJSON')
gpxlayer.styles.append('gpxstyle')
m.layers.append(gpxlayer)
bbox = boxes[orientation]
m.zoom_to_box(bbox)
im = mapnik.Image(imgx, imgy)
mapnik.render(m, im)
return Image.open(StringIO(im.tostring('png')))
try:
HEIGHT = int(HEIGHT)
except Exception, E:
output_error("Height must be an integer", E)
start = timeit.time.time()
STARTED = True
try:
import mapnik
output_message('Loaded mapnik python bindings')
except Exception, E:
output_error('Could not load mapnik python bindings', E)
try:
mapnik_map = mapnik.Map(WIDTH, HEIGHT)
output_message('Map object created successfully')
except Exception, E:
output_error("Problem initiating map", E)
if var.has_key('resolutions') and var.has_key('levels'):
output_error(
'Only accepts one of either --resolutions or --levels options')
elif var.has_key('resolutions'):
ZOOM_LEVELS = [float(r) for r in var['resolutions'].split(',')]
output_message('Using custom zoom levels: %s' % ZOOM_LEVELS)
elif var.has_key('levels'):
levels = var['levels']
try:
levels = int(levels) + 1
ZOOM_LEVELS = generate_levels(levels)
def createisomap(iso, mapscale, name, name_en):
map_width = int(mapscale[0])
map_height = int(mapscale[1])
map_minx = float(mapscale[2])
map_maxx = float(mapscale[3])
map_miny = float(mapscale[4])
map_maxy = float(mapscale[5])
print "mapdata:", map_width, map_height, map_maxx, map_maxy, map_minx, map_miny
geojsonfile = '/osm/service/' + CONTINENT + '/' + iso + '/poly/osm.geojson'
m = mapnik.Map(
map_width,
map_height) # create a map with a given width and height in pixels
# note: m.srs will default to '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs'
# the 'map.srs' is the target projection of the map and can be whatever you wish
m.background = mapnik.Color(
'#000000') # set background colour to 'steelblue'.
s = mapnik.Style() # style object to hold rules
r = mapnik.Rule() # rule object to hold symbolizers
# to fill a polygon we create a PolygonSymbolizer
psymbolizer = mapnik.PolygonSymbolizer()
#psymbolizer.fill = mapnik.Color('#f2eff9')
psymbolizer.fill = mapnik.Color('#000000')
r.symbols.append(psymbolizer)
lsymbolizer = mapnik.LineSymbolizer()
#lsymbolizer.stroke = mapnik.Color('rgb(50%,50%,50%)')
lsymbolizer.stroke = mapnik.Color('#FFA500')
lsymbolizer.stroke_width = 0.8
r.symbols.append(lsymbolizer)
s.rules.append(r) # now add the rule to the style and we're done
m.append_style(
'My Style',
s) # Styles are given names only as they are applied to the map
ds = mapnik.Ogr(file=geojsonfile, layer_by_index=0)
print(ds)
ds.envelope()
layer = mapnik.Layer(
'world') # new layer called 'world' (we could name it anything)
# note: layer.srs will default to '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs'
layer.datasource = ds
layer.styles.append('My Style')
m.layers.append(layer)
bbox = mapnik.Box2d(map_maxx, map_maxy, map_minx, map_miny)
m.zoom_to_box(bbox)
# Write the data to a png image called world.png the current directory
img_directory = '/osm/service/' + CONTINENT + '/' + iso + '/img/'
if not os.path.exists(img_directory):
os.makedirs(img_directory)
mapnik.render_to_file(m, img_directory + 'dbackground0.png', 'png')
gdalw1 = 'gdalwarp -te {} {} {} {} -ts {} {} '.format(
map_minx, map_miny, map_maxx, map_maxy, map_width, map_height)
# NE1_HR_LC_SR_W_DR.tif
gdalw2 = ' -of GTiff /osm/ne/ne.tif {} '.format(img_directory +
'nebackground.geotif')
print "gdalw:", gdalw1, gdalw2
os.system(gdalw1 + gdalw2)
os.system('gdal_translate -of PNG {} {} '.format(
img_directory + 'nebackground.geotif',
img_directory + 'nebackground.png'))
os.system('convert {} -transparent Black {} '.format(
img_directory + 'dbackground0.png',
img_directory + 'tdbackground.png'))
os.system('composite {} -compose over {} {} '.format(
img_directory + 'tdbackground.png', img_directory + 'nebackground.png',
img_directory + 'dbackground.png'))
###################### flag ##################################
im_cmd1 = r'convert /osm/setup/osmlogo.png -font DejaVu-Serif -fill darkblue -pointsize 34 -gravity center -draw "text 16,-18'
im_cmd2 = r" '." + iso[:2] + "' "
im_cmd3 = r'" ' + img_directory + 'dflag.png'
os.system(im_cmd1 + im_cmd2 + im_cmd3)
#################### Logo #####################################
surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 448, 98)
ctx = cairo.Context(surface)
ctx.select_font_face("Courier", cairo.FONT_SLANT_NORMAL,
cairo.FONT_WEIGHT_BOLD)
ctx.set_font_size(42)
ctx.move_to(2, 50)
ctx.set_source_rgb(0.0, 0.0, 0.15)
ctx.show_text('Taginfo-' + CONTINENT + '-' + iso)
ctx.select_font_face('Sans')
if len(name_en) > 26:
ctx.set_font_size(20)
elif len(name_en) > 18:
ctx.set_font_size(26)
else:
ctx.set_font_size(30)
ctx.move_to(1, 90)
ctx.set_source_rgb(0.0, 0.0, 0.35)
ctx.show_text(name_en)
# finish up
ctx.stroke()
surface.write_to_png(img_directory + 'dlogo.png')
from math import tan, radians, hypot, cos, sin, atan2, sqrt
centrex=10.5
centrey=51.3
zoom=7
scale=2
attribution="population per square kilometre in Germany - Andreas Binder ©OpenStreetMap contributors ODbL (State 14.05.2019)"
merc = mapnik.Projection('+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')
longlat = mapnik.Projection('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
width=450 * scale
height=600 * scale
m = mapnik.Map(width, height)
mapnik.load_map(m, 'population-density.xml')
m.srs = merc.params()
centre = mapnik.Coord(centrex, centrey)
transform = mapnik.ProjTransform(longlat, merc)
merc_centre = transform.forward(centre)
dx = ((20037508.34*2*(width/2)))/(256*(2 ** (zoom)))
minx = merc_centre.x - dx
maxx = merc_centre.x + dx
m.aspect_fix_mode = mapnik.aspect_fix_mode.ADJUST_BBOX_HEIGHT
bounds = mapnik.Box2d(minx, merc_centre.y-10, maxx, merc_centre.y+10)
import mapnik
m = mapnik.Map(3840, 2160)
m.background = mapnik.Color('steelblue')
# MAP 1 DUNIA
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('#7FFF00')
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('white'), 1)
line_symbolizer.stroke_width = 10.0
r.symbols.append(line_symbolizer)
s.rules.append(r)
m.append_style('Bangkit', s)
ds = mapnik.Shapefile(file="countries/ne_110m_admin_0_countries.shp")
layer = mapnik.Layer('world')
layer.datasource = ds
layer.styles.append('Bangkit')
m.layers.append(layer)
# BATAS AKHIR MAP 1 DUNIA
# MAP 2 Negara Afrika
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('#D2691E')
r.symbols.append(polygon_symbolizer)
def compose_relief(self, xml_file, slopeshade, hillshade, color_relief,
relief, flood, water):
xml = "<Map srs='+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'>\n"
xml += "<Style name='color relief style'>\n"
xml += "<Rule>\n"
xml += "<RasterSymbolizer comp-op='src-over' />\n"
xml += "</Rule>\n"
xml += "</Style>\n"
xml += "<Style name='slopeshade style'>\n"
xml += "<Rule>\n"
xml += "<RasterSymbolizer opacity='0.4' comp-op='multiply' />\n"
xml += "</Rule>\n"
xml += "</Style>\n"
xml += "<Style name='hillshade style'>\n"
xml += "<Rule>\n"
xml += "<RasterSymbolizer opacity='0.6' comp-op='multiply' />\n"
xml += "</Rule>\n"
xml += "</Style>\n"
xml += "<Style name='flood water'>\n"
xml += "<Rule>\n"
xml += "<RasterSymbolizer opacity='1' />\n"
xml += "</Rule>\n"
xml += "</Style>\n"
xml += "<Style name='water'>\n"
xml += "<Rule>\n"
xml += "<RasterSymbolizer opacity='1' comp-op='src-over'/>\n"
xml += "</Rule>\n"
xml += "</Style>\n"
xml += "<Layer name='color relief'>\n"
xml += "<StyleName>color relief style</StyleName>\n"
xml += "<Datasource>\n"
xml += "<Parameter name='type'>gdal</Parameter>\n"
xml += "<Parameter name='file'>" + color_relief + "</Parameter>\n"
xml += "<Parameter name='format'>tiff</Parameter>\n"
xml += "</Datasource>\n"
xml += "</Layer>\n"
xml += "<Layer name='slopeshade'>\n"
xml += "<StyleName>slopeshade style</StyleName>\n"
xml += "<Datasource>\n"
xml += "<Parameter name='type'>gdal</Parameter>\n"
xml += "<Parameter name='file'>" + slopeshade + "</Parameter>\n"
xml += "<Parameter name='format'>tiff</Parameter>\n"
xml += "</Datasource>\n"
xml += "</Layer>\n"
xml += "<Layer name='hillshade'>\n"
xml += "<StyleName>hillshade style</StyleName>\n"
xml += "<Datasource>\n"
xml += "<Parameter name='type'>gdal</Parameter>\n"
xml += "<Parameter name='file'>" + hillshade + "</Parameter>\n"
xml += "<Parameter name='format'>tiff</Parameter>\n"
xml += "</Datasource>\n"
xml += "</Layer>\n"
if flood:
xml += "<Layer name='flood water'>\n"
xml += "<StyleName>flood water</StyleName>\n"
xml += "<Datasource>\n"
xml += "<Parameter name='type'>gdal</Parameter>\n"
xml += "<Parameter name='file'>" + flood + "</Parameter>\n"
xml += "<Parameter name='format'>tiff</Parameter>\n"
xml += "</Datasource>\n"
xml += "</Layer>\n"
xml += "<Layer name='water'>\n"
xml += "<StyleName>water</StyleName>\n"
xml += "<Datasource>\n"
xml += "<Parameter name='type'>gdal</Parameter>\n"
xml += "<Parameter name='file'>" + water + "</Parameter>\n"
xml += "<Parameter name='format'>tiff</Parameter>\n"
xml += "</Datasource>\n"
xml += "</Layer>\n"
xml += "</Map>\n"
f = open(xml_file, 'w')
f.write(xml)
f.close()
print "Generating relief file:", color_relief, xml_file
print self.RasterXSize, self.RasterYSize
map = mapnik.Map(self.RasterXSize, self.RasterYSize)
mapnik.load_map(map, xml_file)
map.zoom_all()
mapnik.render_to_file(map, relief)
mapnik.load_map(m, xml, False, absolute_base)
except RuntimeError, e:
# only test datasources that we have installed
if not 'Could not create datasource' in str(e):
raise RuntimeError(str(e))
return
(handle, test_map) = tempfile.mkstemp(suffix='.xml',
prefix='mapnik-temp-map1-')
os.close(handle)
(handle, test_map2) = tempfile.mkstemp(suffix='.xml',
prefix='mapnik-temp-map2-')
os.close(handle)
if os.path.exists(test_map):
os.remove(test_map)
mapnik.save_map(m, test_map)
new_map = mapnik.Map(256, 256)
mapnik.load_map(new_map, test_map, False, absolute_base)
open(test_map2, 'w').write(mapnik.save_map_to_string(new_map))
diff = ' diff -u %s %s' % (os.path.abspath(test_map),
os.path.abspath(test_map2))
try:
eq_(open(test_map).read(), open(test_map2).read())
except AssertionError, e:
raise AssertionError(
'serialized map "%s" not the same after being reloaded, \ncompare with command:\n\n$%s'
% (xml, diff))
if os.path.exists(test_map):
os.remove(test_map)
else:
# Fail, the map wasn't written
def __init__ (self, app, layer):
self.app = app
self.mapid = layer ['id']
self.map = mapnik.Map (METATILE_SIZE, METATILE_SIZE)
mapnik.load_map (self.map, os.path.join (app.root_path, layer['map_style']))
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
###############################################################################
import mapnik
m = mapnik.Map(600, 500, "+proj=latlong +datum=WGS84")
symbol = mapnik.RasterSymbolizer()
###############################################################################
s = mapnik.Style()
r = mapnik.Rule()
r.symbols.append(symbol)
s.rules.append(r)
m.append_style('My Style', s)
datasource = mapnik.Gdal(file='/gdata/geotiff_file.tif')
layer = mapnik.Layer("myLayer")
layer.datasource = datasource
layer.styles.append('My Style')
m.layers.append(layer)
###############################################################################
layer.envelope()
###############################################################################
m.zoom_to_box(layer.envelope())
mapnik.render_to_file(m, 'xx_mapnik_result.png', 'png')
def _test_rgba_8bui_rendering(lbl, overview, rescale, clip):
if rescale:
lbl += ' Sc'
if clip:
lbl += ' Cl'
ds = mapnik.PgRaster(dbname=MAPNIK_TEST_DBNAME,
table='(select * from "River") foo',
use_overviews=1 if overview else 0,
prescale_rasters=rescale,
clip_rasters=clip)
fs = ds.featureset()
feature = fs.next()
eq_(feature['rid'], 1)
lyr = mapnik.Layer('rgba_8bui')
lyr.datasource = ds
expenv = mapnik.Box2d(0, -210, 256, 0)
env = lyr.envelope()
# As the input size is a prime number both horizontally
# and vertically, we expect the extent of the overview
# tables to be a pixel wider than the original, whereas
# the pixel size in geographical units depends on the
# overview factor. So we start with the original pixel size
# as base scale and multiply by the overview factor.
# NOTE: the overview table extent only grows north and east
pixsize = 1 # see gdalinfo river.tif
tol = pixsize * max(overview.split(',')) if overview else 0
assert_almost_equal(env.minx, expenv.minx)
assert_almost_equal(env.miny, expenv.miny, delta=tol)
assert_almost_equal(env.maxx, expenv.maxx, delta=tol)
assert_almost_equal(env.maxy, expenv.maxy)
mm = mapnik.Map(256, 256)
style = mapnik.Style()
sym = mapnik.RasterSymbolizer()
rule = mapnik.Rule()
rule.symbols.append(sym)
style.rules.append(rule)
mm.append_style('foo', style)
lyr.styles.append('foo')
mm.layers.append(lyr)
mm.zoom_to_box(expenv)
im = mapnik.Image(mm.width, mm.height)
t0 = time.time() # we want wall time to include IO waits
mapnik.render(mm, im)
lap = time.time() - t0
log('T ' + str(lap) + ' -- ' + lbl + ' E:full')
expected = 'images/support/pgraster/%s-%s-%s-%s-box1.png' % (
lyr.name, lbl, overview, clip)
compare_images(expected, im)
# no data
eq_(hexlify(im.view(3, 3, 1, 1).tostring()), '00000000')
eq_(hexlify(im.view(250, 250, 1, 1).tostring()), '00000000')
# full opaque river color
eq_(hexlify(im.view(175, 118, 1, 1).tostring()), 'b9d8f8ff')
# half-transparent pixel
pxstr = hexlify(im.view(122, 138, 1, 1).tostring())
apat = ".*(..)$"
match = re.match(apat, pxstr)
assert match, 'pixel ' + pxstr + ' does not match pattern ' + apat
alpha = match.group(1)
assert alpha != 'ff' and alpha != '00', \
'unexpected full transparent/opaque pixel: ' + alpha
# Now zoom over a portion of the env (1/10)
newenv = mapnik.Box2d(166, -105, 191, -77)
mm.zoom_to_box(newenv)
t0 = time.time() # we want wall time to include IO waits
im = mapnik.Image(mm.width, mm.height)
mapnik.render(mm, im)
lap = time.time() - t0
log('T ' + str(lap) + ' -- ' + lbl + ' E:1/10')
expected = 'images/support/pgraster/%s-%s-%s-%s-box2.png' % (
lyr.name, lbl, overview, clip)
compare_images(expected, im)
# no data
eq_(hexlify(im.view(255, 255, 1, 1).tostring()), '00000000')
eq_(hexlify(im.view(200, 40, 1, 1).tostring()), '00000000')
# full opaque river color
eq_(hexlify(im.view(100, 168, 1, 1).tostring()), 'b9d8f8ff')
# half-transparent pixel
pxstr = hexlify(im.view(122, 138, 1, 1).tostring())
apat = ".*(..)$"
match = re.match(apat, pxstr)
assert match, 'pixel ' + pxstr + ' does not match pattern ' + apat
alpha = match.group(1)
assert alpha != 'ff' and alpha != '00', \
'unexpected full transparent/opaque pixel: ' + alpha
