def __call__(self, feature_layers):
# take the feature_layers dict and generate a gif response
# this just puts all the features across all layers into a
# single one, and then just renders them all with a very
# simple style as a proof of concept
# we probably want to do this per layer with a separate style
# for each
features = feature_layers_to_features_list(feature_layers)
layer = mapnik.Layer('tile')
memds = mapnik.MemoryDatasource()
ctx = mapnik.Context()
for feature in features:
wkb, properties, fid = feature
for key in properties.keys():
ctx.push(key.encode('utf-8'))
i = 1
for feature in features:
wkb, properties, fid = feature
mf = mapnik.Feature(ctx, i)
i += 1
mf.add_geometries_from_wkb(wkb)
for k, v in properties.items():
mf[k.encode('utf-8')] = str(v)
memds.add_feature(mf)
layer.datasource = memds
m = mapnik.Map(256, 256)
m.background = mapnik.Color('blue')
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer(mapnik.Color('#f2eff9'))
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)
layer.styles.append('my style')
m.layers.append(layer)
m.zoom_all()
# from mapnik import Image
# im = Image(m.width, m.height)
# mapnik.render(m, im)
# png_contents = im.tostring()
# this was just the easiest way for me to get this to work
import tempfile
tmpfile = tempfile.NamedTemporaryFile()
with tmpfile.file as fp:
mapnik.render_to_file(m, tmpfile.name, 'png')
fp.seek(0)
png_contents = fp.read()
return png_contents
def qickTest():
m = mapnik.Map(600,300)
m.background = mapnik.Color('steelblue')
s = mapnik.Style()
r = mapnik.Rule()
#polygon_symbolizer = mapnik.PolygonSymbolizer(mapnik.Color('#ff00ff'))
#r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('rgb(100%,100%,100%)'),0.1)
r.symbols.append(line_symbolizer)
s.rules.append(r)
m.append_style('My Style',s)
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('rgb(100%,0%,100%)'),0.5)
r.symbols.append(line_symbolizer)
s.rules.append(r)
m.append_style('My New Style',s)
ds = mapnik.Shapefile(file = '/home/klammer/Software/Quickly/tilegen/data/media/testdaten/mercator_polygon/lines-vgtl-27-01-12.shp')
layer = mapnik.Layer('world')
layer.datasource = ds
layer.styles.append('My Style')
m.layers.append(layer)
lyr = mapnik.Layer('Generalized geometry from PostGIS')
lyr.datasource = mapnik.PostGIS(host='localhost',user='******',password='******',dbname='meingis',table='generalized_line_cache')
lyr.srs = layer.srs
lyr.styles.append('My New Style')
m.layers.append(lyr)
m.zoom_all()
mapnik.render_to_file(m,'world.png', 'png')
print "rendered image to 'world.png'"
def render(qs,options):
kwargs = {}
if options:
if ';' in options:
for item in options.split(';'):
if ':' in item:
k,v = item.split(':')
kwargs[k] = v
width = int(kwargs.get('width',600))
height = int(kwargs.get('height',600))
#field = kwargs.get('field',None)
if hasattr(qs,'_meta'):
# it looks like a model
qs = qs.objects.all()
m = mapnik.Map(width,height)
m.aspect_fix_mode = mapnik.aspect_fix_mode.GROW_CANVAS
adapter = PostgisLayer(qs)
lyr = adapter.to_mapnik()
sty = adapter.get_default_style()
lyr.styles.append('style')
m.append_style('style',sty)
#m.background = mapnik.Color('green')
m.srs = lyr.srs
m.layers.append(lyr)
m.zoom_all()
#print mapnik.save_map_to_string(m)
mod = qs.query.get_meta().module_name
# TODO - need way to properly cache vs. always overwriting...
name = '%s_%s_%s_%s.png' % (mod,width,height,random())
map_graphic = os.path.join(graphics,name)
mapnik.render_to_file(m,str(map_graphic))
url = os.path.join(settings.MEDIA_URL,'mapgraphics',name)
return mark_safe(force_unicode('<img src="%s" />' % smart_str(url)))
def drawSHPFile(self):
#Loop thru related files list.
for fileName in self.relatedFiles:
self.downloadFile(self.confSHPDownloadsLoc, fileName)
#Create a map with a given width and height in pixels.
# Map
m = mapnik.Map(600,300,'+proj=latlong +datum=WGS84')
m.background = mapnik.Color('steelblue')
# Styles
poly = mapnik.PolygonSymbolizer(mapnik.Color('lavender'))
line = mapnik.LineSymbolizer(mapnik.Color('slategray'),.3)
s,r = mapnik.Style(),mapnik.Rule()
r.symbols.extend([poly,line])
s.rules.append(r)
m.append_style('My Style',s)
# Layer
lyr = mapnik.Layer('world')
lyr.datasource = mapnik.Shapefile(file=self.confSHPDownloadsLoc+'ne_110m_admin_0_countries')
lyr.srs = '+proj=latlong +datum=WGS84'
lyr.styles.append('My Style')
m.layers.append(lyr)
# Render
m.zoom_to_box(lyr.envelope())
mapnik.render_to_file(m, 'hello_world_in_pure_python.png')
def test_mapnik(self):
m = mapnik.Map(600, 300)
mapnik.load_map(m, 'style_sheet.xml')
m.zoom_all()
mapnik.render_to_file(m, actual_image)
with open(actual_image) as actual, open(expected_image) as expected:
self.assertEquals(actual.read(), expected.read())
def render(self, fmt, width, height, bbox, srs, styles, layers, **kwargs):
"""Render a WMS request or a tile. TODO - create an SQLite cache for this as well, based on hashed filename."""
_log.debug('render called for {0}'.format(layers))
if srs.lower().startswith('epsg'):
if srs.endswith("900913") or srs.endswith("3857"):
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"
else:
srs = "+init=" + srs.lower()
name = self.prepare_wms(layers, srs, styles, **kwargs)
filename = "{name}.{bbox}.{width}x{height}.{fmt}".format(
name=name,
bbox='_'.join(str(b) for b in bbox),
width=width,
height=height,
fmt=fmt
)
_log.debug('waiting on lock')
while os.path.exists(name + ".lock"):
time.sleep(0.05)
_log.debug('rendering {0}x{1} tile'.format(width, height))
m = mapnik.Map(width, height)
mapnik.load_map(m, (name + '.xml').encode('ascii'))
m.zoom_to_box(mapnik.Box2d(*bbox))
mapnik.render_to_file(m, filename, fmt)
with open(filename) as tiledata:
tile = buffer(tiledata.read())
os.unlink(filename)
return filename, tile
def make_map(shpfile, img_name):
lyr = mapnik.Layer('world', "+proj=latlong +datum=NAD83")
lyr.datasource = mapnik.Shapefile(file=shpfile)
lyr.styles.append('My Style')
m.layers.append(lyr)
m.zoom_to_box(lyr.envelope())
mapnik.render_to_file(m, img_name, 'png')
def render_to_file(self,*args):
"""
Routine to render the requested AGG format.
"""
format = args[2]
if format in ('tif','tiff'):
self.timer()
(handle, png_tmp) = tempfile.mkstemp('.png', 'nik2img-tmp')
os.close(handle)
self.world_file_ext = 'wld'
self.write_wld(png_tmp)
im = mapnik.Image(args[0].width,self.m.height)
if self.scale_factor:
mapnik.render(args[0],im,self.scale_factor)
else:
mapnik.render(args[0],im)
im.save(png_tmp,'png')
# todo - figure out more reasonable defaults
opts = ' -ot Byte -co COMPRESS=JPEG -co JPEG_QUALITY=100'
base_cmd = 'gdal_translate %s %s -a_srs "%s" %s'
cmd = base_cmd % (png_tmp,args[1],args[0].srs,opts)
#print call(cmd,fail=True)
os.system(cmd)
self.stop()
else:
self.timer()
if self.scale_factor:
args = args + (self.scale_factor,)
mapnik.render_to_file(*args)
if self.world_file_ext:
self.write_wld(args[1])
self.stop()
if self.zip_compress:
self.zip_up(args[1])
def render_agg(self, *args):
"""
Routine to render the requested AGG format.
"""
mapnik.render_to_file(*args)
if self.world_file_ext:
self.write_wld(args[1])
def generate_img(self):
print "\n- Render image"
m = mapnik.Map(600, 300)
mapnik.load_map(m, self.stylesheet)
m.zoom_all()
mapnik.render_to_file(m, self.image)
print "rendered image to '{0}'".format(self.image)
def render_png(self, show=True):
import mapnik
#TODO scale dimensions to aspect ratio of data
m = mapnik.Map(800, 400)
m.background = mapnik.Color('white')
s = mapnik.Style()
r = mapnik.Rule()
if "point" in self.collection().schema['geometry'].lower():
point_symbolizer = mapnik.PointSymbolizer()
r.symbols.append(point_symbolizer)
else:
polygon_symbolizer = mapnik.PolygonSymbolizer(
mapnik.Color('#f2eff9'))
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer(
mapnik.Color('rgb(50%,50%,50%)'), 0.8)
r.symbols.append(line_symbolizer)
s.rules.append(r)
m.append_style('My Style', s)
ds = mapnik.Shapefile(file=self.path)
layer = mapnik.Layer('world')
layer.datasource = ds
layer.styles.append('My Style')
m.layers.append(layer)
m.zoom_all()
outfile = '/tmp/world.png'
mapnik.render_to_file(m, outfile, 'png')
if show:
im = Image.open(outfile)
im.show()
return outfile
def render(input_file, output_file, width=800, height=800, bbox=None):
m = mapnik.Map(width, height)
mapnik.load_map(m, input_file, False)
if bbox is not None:
m.zoom_to_box(bbox)
else:
m.zoom_all()
mapnik.render_to_file(m, output_file)
def export(self, mapnik_xml, output_file):
self.log.info("Exporting %s to %s. Mapnik version %s", mapnik_xml, output_file,
mapnik.mapnik_version_string())
mapnik_map = mapnik.Map(2000, 2000)
mapnik.load_map(mapnik_map, mapnik_xml.encode('utf-8'))
mapnik_map.zoom_all()
mapnik.render_to_file(mapnik_map, output_file, b"pdf")
def render(filename, width):
print 'Rendering style "%s" with width %d' % (filename, width)
m = mapnik.Map(width, 100)
mapnik.load_map(m, os.path.join(dirname, "%s.xml" % filename), False)
bbox = mapnik.Box2d(-0.05, -0.01, 0.95, 0.01)
m.zoom_to_box(bbox)
mapnik.render_to_file(m, "%s-%d-agg.png" % (filename, width))
return m
def saveImage(self, mapFilename, imgFilename):
if self.m is None:
self.m = mapnik.Map(self.width, self.height)
mapnik.load_map(self.m, mapFilename)
# extent = mapnik.Box2d(-300, -180.0, 90.0, 90.0)
# self.m.zoom_to_box(self.extents)
self.m.zoom_all()
mapnik.render_to_file(self.m, imgFilename)
def render_to_file(self,*args):
"""
Routine to render the requested AGG format.
"""
self.timer()
mapnik.render_to_file(*args)
self.stop()
if self.world_file_ext:
self.write_wld(args[1])
def test_gen_map():
mapxmlfile = '../data/good_maps/raster_colorizer.xml'
mapxmloutputfile = 'raster_colorizer_test_save.xml'
outputfile = 'raster_colorizer_test.png'
m = mapnik.Map(800, 600)
mapnik.load_map(m, mapxmlfile)
mapnik.save_map(m, mapxmloutputfile)
m.zoom_all()
mapnik.render_to_file(m, outputfile)
def renderImage(self, map_output, mapfile, imgx, imgy, bbox): print "renderImage" m = mapnik.Map(imgx, imgy) mapnik.load_map(m, mapfile) #ll = (1321613.269848, 6475998.706584, 1674460.199655, 6743324.6719772) ll = (1321613.269848, 6475998.706584, 1674460.199655, 6743324.671977) ll = bbox bbox = mapnik.Box2d(mapnik.Coord(ll[0], ll[3]), mapnik.Coord(ll[2], ll[1])) m.zoom_to_box(bbox) mapnik.render_to_file(m, map_output)
def test_psql_error_should_give_back_connections_opened_for_lower_layers_to_the_pool():
map1 = mapnik.Map(600,300)
s = mapnik.Style()
r = mapnik.Rule()
r.symbols.append(mapnik.PolygonSymbolizer(mapnik.Color('#f2eff9')))
s.rules.append(r)
map1.append_style('style',s)
# This layer will fail after a while
buggy_s = mapnik.Style()
buggy_r = mapnik.Rule()
buggy_r.symbols.append(mapnik.PolygonSymbolizer(mapnik.Color('#ff0000')))
buggy_r.filter = mapnik.Filter("[fips] = 'FR'")
buggy_s.rules.append(buggy_r)
map1.append_style('style for buggy layer',buggy_s)
buggy_layer = mapnik.Layer('this layer is buggy at runtime')
# We ensure the query wille be long enough
buggy_layer.datasource = mapnik.PostGIS(dbname=MAPNIK_TEST_DBNAME,table='(SELECT geom as geom, pg_sleep(0.1), fips::int from world_merc) as failure_tabl',
max_async_connection=2, max_size=2,asynchronous_request = True, geometry_field='geom')
buggy_layer.styles.append('style for buggy layer')
# The query for this layer will be sent, then the previous layer will raise an exception before results are read
forced_canceled_layer = mapnik.Layer('this layer will be canceled when an exception stops map rendering')
forced_canceled_layer.datasource = mapnik.PostGIS(dbname=MAPNIK_TEST_DBNAME,table='world_merc',
max_async_connection=2, max_size=2, asynchronous_request = True, geometry_field='geom')
forced_canceled_layer.styles.append('style')
map1.layers.append(buggy_layer)
map1.layers.append(forced_canceled_layer)
map1.zoom_all()
map2 = mapnik.Map(600,300)
map2.background = mapnik.Color('steelblue')
s = mapnik.Style()
r = mapnik.Rule()
r.symbols.append(mapnik.LineSymbolizer(mapnik.Color('rgb(50%,50%,50%)'),0.1))
r.symbols.append(mapnik.LineSymbolizer(mapnik.Color('rgb(50%,50%,50%)'),0.1))
s.rules.append(r)
map2.append_style('style',s)
layer1 = mapnik.Layer('layer1')
layer1.datasource = mapnik.PostGIS(dbname=MAPNIK_TEST_DBNAME,table='world_merc',
max_async_connection=2, max_size=2, asynchronous_request = True, geometry_field='geom')
layer1.styles.append('style')
map2.layers.append(layer1)
map2.zoom_all()
# We expect this to trigger a PSQL error
try:
mapnik.render_to_file(map1,'world.png', 'png')
# Test must fail if error was not raised just above
eq_(False,True)
except RuntimeError:
pass
# This used to raise an exception before correction of issue 2042
mapnik.render_to_file(map2,'world2.png', 'png')
def test_render_points():
if not mapnik.has_cairo(): return
# create and populate point datasource (WGS84 lat-lon coordinates)
ds = mapnik.MemoryDatasource()
context = mapnik.Context()
context.push('Name')
f = mapnik.Feature(context,1)
f['Name'] = 'Westernmost Point'
f.add_geometries_from_wkt('POINT (142.48 -38.38)')
ds.add_feature(f)
f = mapnik.Feature(context,2)
f['Name'] = 'Southernmost Point'
f.add_geometries_from_wkt('POINT (143.10 -38.60)')
ds.add_feature(f)
# create layer/rule/style
s = mapnik.Style()
r = mapnik.Rule()
symb = mapnik.PointSymbolizer()
symb.allow_overlap = True
r.symbols.append(symb)
s.rules.append(r)
lyr = mapnik.Layer('Places','+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
lyr.datasource = ds
lyr.styles.append('places_labels')
# latlon bounding box corners
ul_lonlat = mapnik.Coord(142.30,-38.20)
lr_lonlat = mapnik.Coord(143.40,-38.80)
# render for different projections
projs = {
'google': '+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',
'latlon': '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs',
'merc': '+proj=merc +datum=WGS84 +k=1.0 +units=m +over +no_defs',
'utm': '+proj=utm +zone=54 +datum=WGS84'
}
for projdescr in projs.iterkeys():
m = mapnik.Map(1000, 500, projs[projdescr])
m.append_style('places_labels',s)
m.layers.append(lyr)
dest_proj = mapnik.Projection(projs[projdescr])
src_proj = mapnik.Projection('+init=epsg:4326')
tr = mapnik.ProjTransform(src_proj,dest_proj)
m.zoom_to_box(tr.forward(mapnik.Box2d(ul_lonlat,lr_lonlat)))
# Render to SVG so that it can be checked how many points are there with string comparison
svg_file = os.path.join(tempfile.gettempdir(), 'mapnik-render-points-%s.svg' % projdescr)
mapnik.render_to_file(m, svg_file)
num_points_present = len(ds.all_features())
svg = open(svg_file,'r').read()
num_points_rendered = svg.count('<image ')
eq_(num_points_present, num_points_rendered, "Not all points were rendered (%d instead of %d) at projection %s" % (num_points_rendered, num_points_present, projdescr))
def show(lyr,sty,width=400,height=300,filename=None,app=None):
m = mapnik.Map(width,height,lyr.srs)
m.background = mapnik.Color('transparent')
lyr.styles.append('style')
m.append_style('style',sty)
m.layers.append(lyr)
m.zoom_all()
if not filename:
(handle, filename) = tempfile.mkstemp('.png', 'django-map-')
os.close(handle)
mapnik.render_to_file(m,str(filename))
open_image(str(filename))
return m
def toMapnik(shapefile, destfile):
symbolizer = mapnik.PolygonSymbolizer(mapnik.Color("darkgreen"))
rule = mapnik.Rule()
rule.symbols.append(symbolizer)
style = mapnik.Style()
style.rules.append(rule)
layer = mapnik.Layer("mapLayer")
layer.datasource = mapnik.Shapefile(file=shapefile)
layer.styles.append("mapStyle")
mapk = mapnik.Map(800, 400)
mapk.background = mapnik.Color("steelblue")
mapk.append_style("mapStyle", style)
mapk.layers.append(layer)
mapk.zoom_all()
mapnik.render_to_file(mapk, destfile, "png")
def test_gen_map():
mapxmlfile = '../data/good_maps/raster_colorizer.xml'
mapxmloutputfile = 'raster_colorizer_test_save.xml'
outputfile = 'raster_colorizer_test.png'
m = mapnik.Map(800, 600)
try:
mapnik.load_map(m, mapxmlfile)
mapnik.save_map(m, mapxmloutputfile)
m.zoom_all()
mapnik.render_to_file(m, outputfile)
except RuntimeError,e:
# only test datasources that we have installed
if not 'Could not create datasource' in str(e):
raise RuntimeError(str(e))
def render(filename, width, height, bbox):
print "-"*80
print "Rendering style \"%s\" with size %dx%d ... " % (filename, width, height)
print "-"*80
m = mapnik.Map(width, height)
mapnik.load_map(m, os.path.join(dirname, "styles", "%s.xml" % filename), False)
if bbox is not None:
m.zoom_to_box(bbox)
else:
m.zoom_all()
basefn = os.path.join(dirname, "images", '%s-%d' % (filename, width))
mapnik.render_to_file(m, basefn+'-agg.png')
diff = compare(basefn + '-agg.png', basefn + '-reference.png')
if diff > 0:
print "-"*80
print 'Error: %u different pixels' % diff
print "-"*80
return m
def basemap(dateval):
import sys
import datetime
import mapnik
d0 = datetime.date(2008,2,1)
f = open('dateinc.inc', 'w')
ddif = dateval - d0
f.write(str(ddif.days))
f.close()
f = open('texte_date.inc', 'w')
td = datetime.date.today()
if ((dateval - td).days > 0):
f.write(td.strftime('\'%Y-%m-%d\''))
else:
f.write(dateval.strftime('\'%Y-%m-%d\''))
f.close()
# bbox = mapnik.Envelope(mapnik.Coord(80000,6000000), mapnik.Coord(1250000,7150000))
# proportions 4x3
xmin = -49000
xmax = 1391000
ymin = 6040000
ymax = 7120000
# proportions 16x9
xmin = -289000
xmax = 1631000
ymin = 6040000
ymax = 7120000
e = open('extent.inc', 'w')
e.write(str(xmin) + ',' + str(ymin) +',' + str(xmax) + ',' + str(ymax))
e.close()
bbox = mapnik.Envelope(mapnik.Coord(xmin,ymin), mapnik.Coord(xmax,ymax))
mapfile = "animfla.xml"
# m = mapnik.Map(640, 480)
# m = mapnik.Map(800, 600)
m = mapnik.Map(1280, 720)
# m = mapnik.Map(960, 540)
mapnik.load_map(m, mapfile)
m.zoom_to_box(bbox)
mapnik.render_to_file(m, 'png\\'+dateval.strftime('%Y%m%d')+'.png', 'png')
def test_render_points():
if not mapnik.has_cairo(): return
# create and populate point datasource (WGS84 lat-lon coordinates)
places_ds = mapnik.PointDatasource()
places_ds.add_point(142.48,-38.38,'Name','Westernmost Point') # westernmost
places_ds.add_point(143.10,-38.60,'Name','Southernmost Point') # southernmost
# create layer/rule/style
s = mapnik.Style()
r = mapnik.Rule()
symb = mapnik.PointSymbolizer()
symb.allow_overlap = True
r.symbols.append(symb)
s.rules.append(r)
lyr = mapnik.Layer('Places','+proj=latlon +datum=WGS84')
lyr.datasource = places_ds
lyr.styles.append('places_labels')
# latlon bounding box corners
ul_lonlat = mapnik.Coord(142.30,-38.20)
lr_lonlat = mapnik.Coord(143.40,-38.80)
# render for different projections
projs = {
'latlon': '+proj=latlon +datum=WGS84',
'merc': '+proj=merc +datum=WGS84 +k=1.0 +units=m +over +no_defs',
'google': '+proj=merc +ellps=sphere +R=6378137 +a=6378137 +units=m',
'utm': '+proj=utm +zone=54 +datum=WGS84'
}
for projdescr in projs.iterkeys():
m = mapnik.Map(1000, 500, projs[projdescr])
m.append_style('places_labels',s)
m.layers.append(lyr)
p = mapnik.Projection(projs[projdescr])
m.zoom_to_box(p.forward(mapnik.Box2d(ul_lonlat,lr_lonlat)))
# Render to SVG so that it can be checked how many points are there with string comparison
svg_file = '/tmp/%s.svg'
mapnik.render_to_file(m, svg_file)
num_points_present = len(places_ds.all_features())
svg = open(svg_file,'r').read()
num_points_rendered = svg.count('<image ')
eq_(num_points_present, num_points_rendered, "Not all points were rendered (%d instead of %d) at projection %s" % (num_points_rendered, num_points_present, projdescr))
def render(input_file, output_file, width=800, height=800, bounds=None):
m = mk.Map(width, height)
mk.load_map(m, input_file, False)
if bounds is not None:
bbox = m.Envelope(*bounds)
m.zoom_to_box(bbox)
else:
m.zoom_all()
if output_file[-4:] in ['.png','.tif','.jpg']:
mk.render_to_file(m, output_file)
elif output_file[-4:] == '.pdf':
s = cairo.PDFSurface(output_file, width, height)
mk.render(m, s)
s.finish()
elif output_file[-4:] == '.svg':
s = cairo.SVGSurface(output_file, width, height)
mk.render(m, s)
s.finish()
else:
print "Error: output file extension '{}' not understood".format(output_file)
def render(self, **kwargs):
m = mapnik.Map(kwargs['width'], kwargs['height'], '+init=epsg:' + str(kwargs['epsg']))
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer(mapnik.Color(str(kwargs['color'])))
polygon_symbolizer.fill_opacity = kwargs['opacity']
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('rgb(50%,50%,50%)'), 1.0)
r.symbols.append(line_symbolizer)
point_symbolizer = mapnik.PointSymbolizer()
r.symbols.append(point_symbolizer)
s.rules.append(r)
m.append_style('My Style', s)
ds = mapnik.Ogr(string=json.dumps(kwargs['geojson']), layer='OGRGeoJSON')
layer = mapnik.Layer('wkt', '+init=epsg:' + str(kwargs['epsg']))
layer.datasource = ds
layer.styles.append('My Style')
m.layers.append(layer)
extent = mapnik.Box2d(kwargs['bbox'][0], kwargs['bbox'][1], kwargs['bbox'][2], kwargs['bbox'][3])
m.zoom_to_box(extent)
mapnik.render_to_file(m, str(kwargs['filename']), str(kwargs['filetype']))
def render(filename, width, height, bbox, quiet=False):
if not quiet:
print "Rendering style \"%s\" with size %dx%d ... \x1b[1;32m✓ \x1b[0m" % (filename, width, height)
print "-"*80
m = mapnik.Map(width, height)
mapnik.load_map(m, os.path.join(dirname, "styles", "%s.xml" % filename), False)
if bbox is not None:
m.zoom_to_box(bbox)
else:
m.zoom_all()
expected = os.path.join(dirname, "images", '%s-%d-reference.png' % (filename, width))
if not os.path.exists('/tmp/mapnik-visual-images'):
os.makedirs('/tmp/mapnik-visual-images')
actual = os.path.join("/tmp/mapnik-visual-images", '%s-%d-agg.png' % (filename, width))
mapnik.render_to_file(m, actual)
diff = compare(actual, expected)
if diff > 0:
print "-"*80
print '\x1b[33mError:\x1b[0m %u different pixels' % diff
print "-"*80
return m
def main():
# creates the map
m = mapnik.Map(1200,600)
# Blue background
m.background = mapnik.Color('steelblue')
s = mapnik.Style()
r = mapnik.Rule()
# Styles - If style is not defined, then it's not drawed
# Polygon style (countries)
polygon_symbolizer = mapnik.PolygonSymbolizer(mapnik.Color('#f2eff9'))
r.symbols.append(polygon_symbolizer)
# Line style
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('rgb(50%,50%,50%)'),0.1)
r.symbols.append(line_symbolizer)
# Point style (default)
point_symbolizer = mapnik.PointSymbolizer()
r.symbols.append(point_symbolizer)
s.rules.append(r)
m.append_style('My Style',s)
# World Map Layer
layer = create_layer('world','resources/ne_110m_admin_0_countries.shp','My Style')
m.layers.append(layer)
# Ivory Coast Layer
layer2 = create_layer('points','resources/antennas.shp','My Style')
m.layers.append(layer2)
# Zoom to layer 2 boundaries
m.zoom_to_box(layer2.envelope())
mapnik.render_to_file(m,'ivory.png', 'png')
labelStyle.rules.append(rule)
# Setup our datasource:
datasource = mapnik.Shapefile(file="TM_WORLD_BORDERS-0.3/" +
"TM_WORLD_BORDERS-0.3.shp")
# Define our map layers:
polygonLayer = mapnik.Layer("Polygons")
polygonLayer.datasource = datasource
polygonLayer.styles.append("PolygonStyle")
labelLayer = mapnik.Layer("Labels")
labelLayer.datasource = datasource
labelLayer.styles.append("LabelStyle")
# Setup our Map object:
map = mapnik.Map(MAP_WIDTH, MAP_HEIGHT, "+proj=longlat +datum=WGS84")
map.background = mapnik.Color("#8080a0")
map.append_style("PolygonStyle", polygonStyle)
map.append_style("LabelStyle", labelStyle)
map.layers.append(polygonLayer)
map.layers.append(labelLayer)
map.zoom_to_box(mapnik.Box2d(MIN_LONG, MIN_LAT, MAX_LONG, MAX_LAT))
mapnik.render_to_file(map, "map.png")
#! /usr/bin/env /usr/bin/python3 import mapnik map = mapnik.Map(600,300) mapnik.load_map(map, 'gamma.xml') map.zoom_all() map.zoom(-1.1) mapnik.render_to_file(map, 'gamma.png', 'png')
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)
os.system("rm -f " + 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')
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, 150)
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, 8, 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)
# mapnik.render_to_file(m, get_tmp_file(__file__, 2), 'png')
#!/usr/bin/env python3
import mapnik
mapfile = 'ready_style.xml'
map_output = 'mymap.png'
ll = (55.8851814, 37.6125984)
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')
m = mapnik.Map(800, 600)
mapnik.load_map(m, mapfile)
#bbox=mapnik.Box2d(37.1,55.45,38,56.05)
#bbox=mapnik.Box2d(37.6020,55.7107,37.6087,55.7137365)
bbox = mapnik.Box2d(ll[1] - 0.0033, ll[0] - 0.00151825, ll[1] + 0.0033,
ll[0] + 0.00151825)
transform = mapnik.ProjTransform(longlat, merc)
merc_bbox = transform.forward(bbox)
m.aspect_fix_mode = mapnik.aspect_fix_mode.GROW_BBOX
m.zoom_to_box(merc_bbox)
print("Scale = ", m.scale())
print(mapnik.mapnik_version())
mapnik.render_to_file(m, map_output)
point_sym = mapnik.MarkersSymbolizer()
point_sym.filename = 'D:/Tugas 2/gambar.png'
point_sym.width = mapnik.Expression("10")
point_sym.height = mapnik.Expression("10")
point_sym.allow_overlap = True
r.symbols.append(point_sym)
text_sym = mapnik.TextSymbolizer(mapnik.Expression('[Propinsi]'),'DejaVu Sans Bold',5,mapnik.Color('black'))
text_sym.halo_radius = 1
text_sym.allow_overlap = True
text_sym.avoid_edges = False
r.symbols.append(text_sym)
s.rules.append(r)
m.append_style('bonbin',s)
ds = mapnik.MemoryDatasource()
f = mapnik.Feature(mapnik.Context(),1)
f['Propinsi'] = 'Kebun Binatang Surabaya'
f.add_geometries_from_wkt("POINT(112.736111 -7.295833)")
ds.add_feature(f)
player = mapnik.Layer('bonbin_layer')
player.datasource = ds
player.styles.append('bonbin')
m.layers.append(player)
m.zoom_all()
mapnik.render_to_file(m,'world.pdf','pdf')
print "rendered image to 'world.pdf"
m = mapnik.Map(width, height)
mapnik.load_map(m, mapfile)
# ensure the target map projection is mercator
m.srs = merc.params()
# transform the centre point into the target coord sys
centre = mapnik.Coord(centrex, centrey)
transform = mapnik.ProjTransform(longlat, merc)
merc_centre = transform.forward(centre)
# 360/(2**zoom) degrees = 256 px
# so in merc 1px = (20037508.34*2) / (256 * 2**zoom)
# hence to find the bounds of our rectangle in projected coordinates + and - half the image width worth of projected coord units
dx = ((20037508.34 * 2 * (width / 2))) / (256 * (2**(zoom)))
minx = merc_centre.x - dx
maxx = merc_centre.x + dx
# grow the height bbox, as we only accurately set the width bbox
m.aspect_fix_mode = mapnik.aspect_fix_mode.ADJUST_BBOX_HEIGHT
bounds = mapnik.Box2d(
minx, merc_centre.y - 10, maxx, merc_centre.y +
10) # the y bounds will be fixed by mapnik due to ADJUST_BBOX_HEIGHT
m.zoom_to_box(bounds)
# render the map image to a file
mapnik.render_to_file(m, output, formt, scale_factor)
sys.stdout.write('output image to %s!\n' % output)
import mapnik
m = mapnik.Map(700,400)
m.background = mapnik.Color('steelblue')
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('#000000')
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('Yello'),1)
line_symbolizer.stroke_width = 10.0
r.symbols.append(line_symbolizer)
s.rules.append(r)
m.append_style('Yoesril',s)
ds = mapnik.Shapefile(file="ne_110m_admin_0_countries.shp")
layer = mapnik.Layer('world')
layer.datasource = ds
layer.styles.append('Yoesril')
m.layers.append(layer)
m.zoom_all()
mapnik.render_to_file(m,'world3.JPEG', 'JPEG')
print "rendered image to 'world3.JEPG' "
ds = mapnik.Shapefile(file="mapecuador/map.shp")
layer = mapnik.Layer('provinsiecuador')
layer.datasource = ds
layer.styles.append('Sancaka4')
m.layers.append(layer)
# BATAS MAP 4 EKUADOR
# MAP 5 Australia
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('#FF00FF')
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('Sancaka5', s)
ds = mapnik.Shapefile(file="mapaustralia/map.shp")
layer = mapnik.Layer('provinsiaustralia')
layer.datasource = ds
layer.styles.append('Sancaka5')
m.layers.append(layer)
# BATAS MAP 5 Australia
m.zoom_all()
mapnik.render_to_file(m, 'world.jpeg', 'jpeg')
print "rendered image to 'world.jpeg'"
def render_agg(m, output, scale_factor):
mapnik.render_to_file(m, output, 'png8:m=h', scale_factor),
qs = urllib.parse.parse_qs(parsed.query)
box, = qs['box']
return box
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('partyexport', help='directory where extracted '\
'terarain.party map lives')
parser.add_argument('waterways', help='path to "waterways" .shp file')
parser.add_argument('water', help='path to "water" .shp file')
args = parser.parse_args()
exportdir = os.listdir(args.partyexport)
backgrounds = filter(lambda s: s.endswith('png'), exportdir)
# make sure if the script is run twice we ignore files we've
# generated
backgrounds = filter(lambda s: not s.startswith(PREFIX), backgrounds)
readme, = filter(lambda s: s.endswith('README.txt'), exportdir)
with open(os.path.join(args.partyexport, readme), 'r') as fp:
boxstr = coordinates_from_readme(fp)
box = map(float, boxstr.split(','))
m = getmap(args.waterways, args.water, box)
for background in backgrounds:
m.background_image = os.path.join(args.partyexport, background)
newfile = ''.join([PREFIX, background])
mapnik.render_to_file(m, os.path.join(args.partyexport, newfile), 'png')
import mapnik
m = mapnik.Map(1080, 720)
m.background = mapnik.Color('steelblue')
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer()
polygon_symbolizer.fill = mapnik.Color('#f2eff9')
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer()
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('green'), 1)
line_symbolizer.stroke_width = 20.0
r.symbols.append(line_symbolizer)
s.rules.append(r)
m.append_style('My Style', s)
ds = mapnik.Shapefile(file="D:\cp1\airterjun.shp")
layer = mapnik.Layer('world')
layer.datasource = ds
layer.styles.append('My Style')
m.layers.append(layer)
m.zoom_all()
mapnik.render_to_file(m, 'wp1.pdf', 'pdf')
print "rendered image to 'cp1.pdf'"
def render_cairo(m, output, scale_factor):
mapnik.render_to_file(m, output, 'ARGB32', scale_factor)
# open and re-save as png8 to save space
new_im = mapnik.Image.open(output)
new_im.save(output, 'png8:m=h')